DSpace refactored service api

dspace-api/src/main/java/org/dspace/content/MetadataSchemaServiceImpl.java

@@ -0,0 +1,172 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.content;
+
+import org.apache.log4j.Logger;
+import org.dspace.authorize.AuthorizeException;
+import org.dspace.authorize.service.AuthorizeService;
+import org.dspace.content.dao.MetadataSchemaDAO;
+import org.dspace.content.service.MetadataSchemaService;
+import org.dspace.core.Context;
+import org.dspace.core.LogManager;
+import org.springframework.beans.factory.annotation.Autowired;
+
+import java.sql.SQLException;
+import java.util.List;
+
+/**
+ * Service implementation for the MetadataSchema object.
+ * This class is responsible for all business logic calls for the MetadataSchema object and is autowired by spring.
+ * This class should never be accessed directly.
+ *
+ * @author kevinvandevelde at atmire.com
+ */
+public class MetadataSchemaServiceImpl implements MetadataSchemaService {
+
+    /** log4j logger */
+    private static Logger log = Logger.getLogger(MetadataSchemaServiceImpl.class);
+
+    @Autowired(required = true)
+    protected AuthorizeService authorizeService;
+
+    @Autowired(required = true)
+    protected MetadataSchemaDAO metadataSchemaDAO;
+
+    @Override
+    public MetadataSchema create(Context context, String name, String namespace) throws SQLException, AuthorizeException, NonUniqueMetadataException {
+                // Check authorisation: Only admins may create metadata schemas
+        if (!authorizeService.isAdmin(context))
+        {
+            throw new AuthorizeException(
+                    "Only administrators may modify the metadata registry");
+        }
+
+        // Ensure the schema name is unique
+        if (!uniqueShortName(context,-1, name))
+        {
+            throw new NonUniqueMetadataException("Please make the name " + name
+                    + " unique");
+        }
+
+        // Ensure the schema namespace is unique
+        if (!uniqueNamespace(context,-1, namespace))
+        {
+            throw new NonUniqueMetadataException("Please make the namespace " + namespace
+                    + " unique");
+        }
+
+
+        // Create a table row and update it with the values
+        MetadataSchema metadataSchema = metadataSchemaDAO.create(context, new MetadataSchema());
+        metadataSchema.setNamespace(namespace);
+        metadataSchema.setName(name);
+        metadataSchemaDAO.save(context, metadataSchema);
+        log.info(LogManager.getHeader(context, "create_metadata_schema",
+                "metadata_schema_id="
+                        + metadataSchema.getSchemaID()));
+        return metadataSchema;
+    }
+
+    @Override
+    public MetadataSchema findByNamespace(Context context, String namespace) throws SQLException {
+        return metadataSchemaDAO.findByNamespace(context, namespace);
+    }
+
+    @Override
+    public void update(Context context, MetadataSchema metadataSchema) throws SQLException, AuthorizeException, NonUniqueMetadataException {
+        // Check authorisation: Only admins may update the metadata registry
+        if (!authorizeService.isAdmin(context))
+        {
+            throw new AuthorizeException(
+                    "Only administrators may modify the metadata registry");
+        }
+
+        // Ensure the schema name is unique
+        if (!uniqueShortName(context, metadataSchema.getSchemaID(), metadataSchema.getName()))
+        {
+            throw new NonUniqueMetadataException("Please make the name " + metadataSchema.getName()
+                    + " unique");
+        }
+
+        // Ensure the schema namespace is unique
+        if (!uniqueNamespace(context, metadataSchema.getSchemaID(), metadataSchema.getNamespace()))
+        {
+            throw new NonUniqueMetadataException("Please make the namespace " + metadataSchema.getNamespace()
+                    + " unique");
+        }
+        metadataSchemaDAO.save(context, metadataSchema);
+        log.info(LogManager.getHeader(context, "update_metadata_schema",
+                "metadata_schema_id=" + metadataSchema.getSchemaID() + "namespace="
+                        + metadataSchema.getNamespace() + "name=" + metadataSchema.getName()));
+    }
+
+    @Override
+    public void delete(Context context, MetadataSchema metadataSchema) throws SQLException, AuthorizeException {
+                // Check authorisation: Only admins may create DC types
+        if (!authorizeService.isAdmin(context))
+        {
+            throw new AuthorizeException(
+                    "Only administrators may modify the metadata registry");
+        }
+
+        log.info(LogManager.getHeader(context, "delete_metadata_schema",
+                "metadata_schema_id=" + metadataSchema.getSchemaID()));
+
+        metadataSchemaDAO.delete(context, metadataSchema);
+    }
+
+    @Override
+    public List<MetadataSchema> findAll(Context context) throws SQLException {
+        return metadataSchemaDAO.findAll(context, MetadataSchema.class);
+    }
+
+    @Override
+    public MetadataSchema find(Context context, int id) throws SQLException {
+        return metadataSchemaDAO.findByID(context,  MetadataSchema.class, id);
+    }
+
+    @Override
+    public MetadataSchema find(Context context, String shortName) throws SQLException {
+        // If we are not passed a valid schema name then return
+        if (shortName == null)
+        {
+            return null;
+        }
+        return metadataSchemaDAO.find(context, shortName);
+    }
+
+
+    /**
+     * Return true if and only if the passed name appears within the allowed
+     * number of times in the current schema.
+     *
+     * @param context DSpace context
+     * @param namespace namespace URI to match
+     * @return true of false
+     * @throws SQLException
+     */
+    protected boolean uniqueNamespace(Context context, int metadataSchemaId, String namespace)
+            throws SQLException
+    {
+        return metadataSchemaDAO.uniqueNamespace(context, metadataSchemaId, namespace);
+    }
+
+    /**
+     * Return true if and only if the passed name is unique.
+     *
+     * @param context DSpace context
+     * @param name  short name of schema
+     * @return true of false
+     * @throws SQLException
+     */
+    protected boolean uniqueShortName(Context context, int metadataSchemaId, String name)
+            throws SQLException
+    {
+        return metadataSchemaDAO.uniqueShortName(context, metadataSchemaId, name);
+    }
+}