source: ComponentRegistry/trunk/ComponentRegistry/src/main/java/clarin/cmdi/componentregistry/impl/database/ComponentRegistryDbImpl.java @ 3451

package clarin.cmdi.componentregistry.impl.database;

import clarin.cmdi.componentregistry.CMDComponentSpecExpander;
import clarin.cmdi.componentregistry.ComponentRegistry;
import clarin.cmdi.componentregistry.ComponentRegistryException;
import clarin.cmdi.componentregistry.ComponentStatus;
import clarin.cmdi.componentregistry.Configuration;
import clarin.cmdi.componentregistry.DeleteFailedException;
import clarin.cmdi.componentregistry.MDMarshaller;
import clarin.cmdi.componentregistry.Owner;
import clarin.cmdi.componentregistry.OwnerGroup;
import clarin.cmdi.componentregistry.OwnerUser;
import clarin.cmdi.componentregistry.UserUnauthorizedException;
import clarin.cmdi.componentregistry.components.CMDComponentSpec;
import clarin.cmdi.componentregistry.impl.ComponentRegistryImplBase;
import clarin.cmdi.componentregistry.model.AbstractDescription;
import clarin.cmdi.componentregistry.model.Comment;
import clarin.cmdi.componentregistry.model.ComponentDescription;
import clarin.cmdi.componentregistry.model.ProfileDescription;
import clarin.cmdi.componentregistry.model.RegistryUser;
import clarin.cmdi.componentregistry.persistence.AbstractDescriptionDao;
import clarin.cmdi.componentregistry.persistence.CommentsDao;
import clarin.cmdi.componentregistry.persistence.ComponentDescriptionDao;
import clarin.cmdi.componentregistry.persistence.ProfileDescriptionDao;
import clarin.cmdi.componentregistry.persistence.UserDao;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.security.Principal;
import java.text.ParseException;
import java.util.Calendar;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.List;

import javax.xml.bind.JAXBException;
import javax.xml.transform.TransformerException;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.dao.DataAccessException;

/**
 * Implementation of ComponentRegistry that uses Database Acces Objects for
 * accessing the registry (ergo: a database implementation)
 * 
 * @author Twan Goosen <twan.goosen@mpi.nl>
 * @author George.Georgovassilis@mpi.nl
 */
public class ComponentRegistryDbImpl extends ComponentRegistryImplBase
        implements ComponentRegistry {

    private final static Logger LOG = LoggerFactory
            .getLogger(ComponentRegistryDbImpl.class);
    private Owner registryOwner;
    private ComponentStatus registryStatus;
    @Autowired
    private Configuration configuration;
    @Autowired
    @Qualifier("componentsCache")
    private CMDComponentSpecCache componentsCache;
    @Autowired
    @Qualifier("profilesCache")
    private CMDComponentSpecCache profilesCache;
    // DAO's
    @Autowired
    private ProfileDescriptionDao profileDescriptionDao;
    @Autowired
    private ComponentDescriptionDao componentDescriptionDao;
    @Autowired
    private UserDao userDao;
    @Autowired
    private CommentsDao commentsDao;
    @Autowired
    private MDMarshaller marshaller;

    /**
     * Default constructor, to use this as a (spring) bean. The public registry
     * by default. Use setStatus() and setOwner() to make it another kind of
     * registry.
     * 
     * @see setUser
     */
    public ComponentRegistryDbImpl() throws TransformerException {
        this.registryStatus = ComponentStatus.PUBLISHED;
    }

    /**
     * Creates a new ComponentRegistry (either public or not) for the provided
     * user. Only use for test and/or make sure to inject all dao's and other
     * services
     * 
     * @param userId
     *            User id of the user to create registry for. Pass null for
     *            public
     */
    public ComponentRegistryDbImpl(ComponentStatus status, Owner owner) {
        this.registryStatus = status;
        this.registryOwner = owner;
    }

    @Override
    public List<ProfileDescription> getProfileDescriptions()
            throws ComponentRegistryException {
        try {
            switch (registryStatus) {
            // TODO: support other status types
            case PRIVATE:
                if (registryOwner == null) {
                    throw new ComponentRegistryException(
                            "Private workspace without owner!");
                }
                // TODO: Support group space
                return profileDescriptionDao
                        .getUserspaceDescriptions(registryOwner.getId());
            case PUBLISHED:
                return profileDescriptionDao.getPublicProfileDescriptions();
            default:
                throw new ComponentRegistryException("Unsupported status type"
                        + registryStatus);
            }
        } catch (DataAccessException ex) {
            throw new ComponentRegistryException(
                    "Database access error while trying to get profile descriptions",
                    ex);
        }
    }

    @Override
    public ProfileDescription getProfileDescription(String id)
            throws ComponentRegistryException {
        try {
            return profileDescriptionDao.getByCmdId(id, getUserId());
        } catch (DataAccessException ex) {
            throw new ComponentRegistryException(
                    "Database access error while trying to get profile description",
                    ex);
        }
    }

    @Override
    public List<ComponentDescription> getComponentDescriptions()
            throws ComponentRegistryException {
        try {
            if (isPublic()) {
                return componentDescriptionDao.getPublicComponentDescriptions();
            } else {
                return componentDescriptionDao
                        .getUserspaceDescriptions(getUserId());
            }
        } catch (DataAccessException ex) {
            throw new ComponentRegistryException(
                    "Database access error while trying to get component descriptions",
                    ex);
        }
    }

    @Override
    public ComponentDescription getComponentDescription(String id)
            throws ComponentRegistryException {
        try {
            return componentDescriptionDao.getByCmdId(id, getUserId());
        } catch (DataAccessException ex) {
            throw new ComponentRegistryException(
                    "Database access error while trying to get component description",
                    ex);
        }
    }

    @Override
    public List<Comment> getCommentsInProfile(String profileId,
            Principal principal) throws ComponentRegistryException {
        try {
            if (profileDescriptionDao.isInRegistry(profileId, getUserId())) {
                final List<Comment> commentsFromProfile = commentsDao
                        .getCommentsFromProfile(profileId);
                setCanDeleteInComments(commentsFromProfile, principal);
                return commentsFromProfile;
            } else {
                // Profile does not exist (at least not in this registry)
                throw new ComponentRegistryException("Profile " + profileId
                        + " does not exist in specified registry");
            }
        } catch (DataAccessException ex) {
            throw new ComponentRegistryException(
                    "Database access error while trying to get list of comments from profile",
                    ex);
        }
    }

    @Override
    public Comment getSpecifiedCommentInProfile(String profileId,
            String commentId, Principal principal)
            throws ComponentRegistryException {
        try {
            Comment comment = commentsDao
                    .getSpecifiedCommentFromProfile(commentId);
            if (comment != null
                    && profileId.equals(comment.getProfileDescriptionId())
                    && profileDescriptionDao.isInRegistry(
                            comment.getProfileDescriptionId(), getUserId())) {
                setCanDeleteInComments(Collections.singleton(comment),
                        principal);
                return comment;
            } else {
                // Comment exists in DB, but profile is not in this registry
                throw new ComponentRegistryException("Comment " + commentId
                        + " cannot be found in specified registry");
            }
        } catch (DataAccessException ex) {
            throw new ComponentRegistryException(
                    "Database access error while trying to get comment from profile",
                    ex);
        }
    }

    @Override
    public List<Comment> getCommentsInComponent(String componentId,
            Principal principal) throws ComponentRegistryException {
        try {
            if (componentDescriptionDao.isInRegistry(componentId, getUserId())) {
                final List<Comment> commentsFromComponent = commentsDao
                        .getCommentsFromComponent(componentId);
                setCanDeleteInComments(commentsFromComponent, principal);
                return commentsFromComponent;
            } else {
                // Component does not exist (at least not in this registry)
                throw new ComponentRegistryException("Component " + componentId
                        + " does not exist in specified registry");
            }
        } catch (DataAccessException ex) {
            throw new ComponentRegistryException(
                    "Database access error while trying to get list of comments from component",
                    ex);
        }
    }

    @Override
    public Comment getSpecifiedCommentInComponent(String componentId,
            String commentId, Principal principal)
            throws ComponentRegistryException {
        try {
            Comment comment = commentsDao
                    .getSpecifiedCommentFromComponent(commentId);
            if (comment != null
                    && componentId.equals(comment.getComponentDescriptionId())
                    && componentDescriptionDao.isInRegistry(
                            comment.getComponentDescriptionId(), getUserId())) {
                setCanDeleteInComments(Collections.singleton(comment),
                        principal);
                return comment;
            } else {
                // Comment does not exists in DB or component is not in this
                // registry
                throw new ComponentRegistryException(
                        "Comment "
                                + commentId
                                + " cannot be found in specified registry for specified component");
            }
        } catch (DataAccessException ex) {
            throw new ComponentRegistryException(
                    "Database access error while trying to get comment from component",
                    ex);
        }
    }

    /**
     * Sets the {@link Comment#setCanDelete(boolean) canDelete} property on all
     * comments in the provided collection for the perspective of the specified
     * principal. Comment owners (determined by {@link Comment#getUserId() }) and
     * admins can delete, others cannot.
     * 
     * @param comments
     *            comments to configure
     * @param principal
     *            user to configure for
     * @see Comment#isCanDelete()
     */
    private void setCanDeleteInComments(Collection<Comment> comments,
            Principal principal) {
        if (principal != null && principal.getName() != null) {
            final RegistryUser registryUser = userDao
                    .getByPrincipalName(principal.getName());
            final String registryUserId = registryUser == null ? null
                    : registryUser.getId().toString();
            final boolean isAdmin = registryUser != null
                    && configuration.isAdminUser(principal);
            for (Comment comment : comments) {
                comment.setCanDelete(isAdmin
                        || comment.getUserId().equals(registryUserId));
            }
        }
    }

    @Override
    public CMDComponentSpec getMDProfile(String id)
            throws ComponentRegistryException {
        if (inWorkspace(profileDescriptionDao, id)) {
            CMDComponentSpec result = profilesCache.get(id);
            if (result == null && !profilesCache.containsKey(id)) {
                result = getUncachedMDProfile(id);
                profilesCache.put(id, result);
            }
            return result;
        } else {
            // May exist, but not in this workspace
            LOG.debug("Could not find profile '{}' in registry '{}'",
                    new Object[] { id, this.toString() });
            return null;
        }
    }

    public CMDComponentSpec getUncachedMDProfile(String id)
            throws ComponentRegistryException {
        try {
            return getUncachedMDComponent(id, profileDescriptionDao);
        } catch (DataAccessException ex) {
            throw new ComponentRegistryException(
                    "Database access error while trying to get profile", ex);
        }
    }

    @Override
    public CMDComponentSpec getMDComponent(String id)
            throws ComponentRegistryException {
        if (inWorkspace(componentDescriptionDao, id)) {
            CMDComponentSpec result = componentsCache.get(id);
            if (result == null && !componentsCache.containsKey(id)) {
                result = getUncachedMDComponent(id);
                componentsCache.put(id, result);
            }
            return result;
        } else {
            // May exist, but not in this workspace
            LOG.info("Could not find component '{}' was in registry '{}'",
                    new Object[] { id, this.toString() });
            return null;
        }
    }

    public CMDComponentSpec getUncachedMDComponent(String id)
            throws ComponentRegistryException {
        try {
            return getUncachedMDComponent(id, componentDescriptionDao);
        } catch (DataAccessException ex) {
            throw new ComponentRegistryException(
                    "Database access error while trying to get component", ex);
        }
    }

    @Override
    public int register(AbstractDescription description, CMDComponentSpec spec) {
        enrichSpecHeader(spec, description);
        try {
            String xml = componentSpecToString(spec);
            // Convert principal name to user record id
            Number uid = convertUserInDescription(description);
            getDaoForDescription(description).insertDescription(description,
                    xml, isPublic(), uid);
            invalidateCache(description);
            return 0;
        } catch (DataAccessException ex) {
            LOG.error("Database error while registering component", ex);
            return -1;
        } catch (JAXBException ex) {
            LOG.error("Error while registering component", ex);
            return -2;
        } catch (UnsupportedEncodingException ex) {
            LOG.error("Error while registering component", ex);
            return -3;
        }
    }

    @Override
    public int registerComment(Comment comment, String principalName)
            throws ComponentRegistryException {
        try {
            if (comment.getComponentDescriptionId() != null
                    && componentDescriptionDao.isInRegistry(
                            comment.getComponentDescriptionId(), getUserId())
                    || comment.getProfileDescriptionId() != null
                    && profileDescriptionDao.isInRegistry(
                            comment.getProfileDescriptionId(), getUserId())) {
                // Convert principal name to user record id
                Number uid = convertUserIdInComment(comment, principalName);
                // Set date to current date
                comment.setCommentDate(Comment.createNewDate());
                Number commentId = commentsDao.insertComment(comment, uid);
                comment.setId(commentId.toString());
            } else {
                throw new ComponentRegistryException(
                        "Cannot insert comment into this registry. Unknown profileId or componentId");
            }
            return 0;
        } catch (DataAccessException ex) {
            LOG.error("Database error while registering component", ex);
            return -1;
        }
    }

    /**
     * Calling service sets user id to principle. Our task is to convert this to
     * an id for later reference. If none is set and this is a user's workspace,
     * set from that user's id.
     * 
     * It also sets the name in the description according to the display name in
     * the database.
     * 
     * @param description
     *            Description containing principle name as userId
     * @return Id (from database)
     * @throws DataAccessException
     */
    private Number convertUserInDescription(AbstractDescription description)
            throws DataAccessException {
        Number uid = null;
        String name = null;
        if (description.getUserId() != null) {
            RegistryUser user = userDao.getByPrincipalName(description
                    .getUserId());
            if (user != null) {
                uid = user.getId();
                name = user.getName();
            }
        } else {
            uid = getUserId(); // this can be null as well
        }
        if (uid != null) {
            description.setUserId(uid.toString());
        }
        if (name != null) {
            description.setCreatorName(name);
        }
        return uid;
    }

    /**
     * Calling service sets user id to principle. Our task is to convert this to
     * an id for later reference. If none is set and this is a user's workspace,
     * set from that user's id.
     * 
     * @param comment
     *            Comment containing principle name as userId
     * @return Id (from database)
     * @throws DataAccessException
     */
    private Number convertUserIdInComment(Comment comment, String principalName)
            throws DataAccessException, ComponentRegistryException {
        if (principalName != null) {
            RegistryUser user = userDao.getByPrincipalName(principalName);
            if (user != null) {
                Number id = user.getId();
                if (id != null) {
                    // Set user id in comment for convenience of calling method
                    comment.setUserId(id.toString());
                    // Set name to user's preferred display name
                    comment.setUserName(user.getName());
                    return id;
                } else {
                    throw new ComponentRegistryException(
                            "Cannot find user with principal name: "
                                    + principalName);
                }
            }
        }
        return null;
    }

    @Override
    public int update(AbstractDescription description, CMDComponentSpec spec,
            Principal principal, boolean forceUpdate) {
        try {
            checkAuthorisation(description, principal);
            checkAge(description, principal);
            // For public components, check if used in other components or
            // profiles (unless forced)
            if (!forceUpdate && this.isPublic() && !description.isProfile()) {
                checkStillUsed(description.getId());
            }
            AbstractDescriptionDao<?> dao = getDaoForDescription(description);
            dao.updateDescription(getIdForDescription(description),
                    description, componentSpecToString(spec));
            invalidateCache(description);
            return 0;
        } catch (JAXBException ex) {
            LOG.error("Error while updating component", ex);
            return -1;
        } catch (UnsupportedEncodingException ex) {
            LOG.error("Error while updating component", ex);
            return -1;
        } catch (IllegalArgumentException ex) {
            LOG.error("Error while updating component", ex);
            return -1;
        } catch (UserUnauthorizedException e) {
            LOG.error("Error while updating component", e);
            return -1;
        } catch (DeleteFailedException e) {
            LOG.error("Error while updating component", e);
            return -1;
        } catch (ComponentRegistryException e) {
            LOG.error("Error while updating component", e);
            return -1;
        }
    }

    @Override
    public int publish(AbstractDescription desc, CMDComponentSpec spec,
            Principal principal) {
        int result = 0;
        AbstractDescriptionDao<?> dao = getDaoForDescription(desc);
        if (!isPublic()) { // if already in public workspace there is nothing
                           // todo
            desc.setHref(AbstractDescription.createPublicHref(desc.getHref()));
            Number id = getIdForDescription(desc);
            try {
                // Update description & content
                dao.updateDescription(id, desc, componentSpecToString(spec));
                // Set to public
                dao.setPublished(id, true);
            } catch (DataAccessException ex) {
                LOG.error("Database error while updating component", ex);
                return -1;
            } catch (JAXBException ex) {
                LOG.error("Error while updating component", ex);
                return -2;
            } catch (UnsupportedEncodingException ex) {
                LOG.error("Error while updating component", ex);
                return -3;
            }
        }
        return result;
    }

    @Override
    public void getMDProfileAsXml(String profileId, OutputStream output)
            throws ComponentRegistryException {
        CMDComponentSpec expandedSpec = CMDComponentSpecExpanderDbImpl
                .expandProfile(profileId, this);
        writeXml(expandedSpec, output);
    }

    @Override
    public void getMDProfileAsXsd(String profileId, OutputStream outputStream)
            throws ComponentRegistryException {
        CMDComponentSpec expandedSpec = CMDComponentSpecExpanderDbImpl
                .expandProfile(profileId, this);
        writeXsd(expandedSpec, outputStream);
    }

    @Override
    public void getMDComponentAsXml(String componentId, OutputStream output)
            throws ComponentRegistryException {
        CMDComponentSpec expandedSpec = CMDComponentSpecExpanderDbImpl
                .expandComponent(componentId, this);
        writeXml(expandedSpec, output);
    }

    @Override
    public void getMDComponentAsXsd(String componentId,
            OutputStream outputStream) throws ComponentRegistryException {
        CMDComponentSpec expandedSpec = CMDComponentSpecExpanderDbImpl
                .expandComponent(componentId, this);
        writeXsd(expandedSpec, outputStream);
    }

    @Override
    public void deleteMDProfile(String profileId, Principal principal)
            throws UserUnauthorizedException, DeleteFailedException,
            ComponentRegistryException {
        ProfileDescription desc = getProfileDescription(profileId);
        if (desc != null) {
            try {
                checkAuthorisation(desc, principal);
                checkAge(desc, principal);
                profileDescriptionDao.setDeleted(desc, true);
                invalidateCache(desc);
            } catch (DataAccessException ex) {
                throw new DeleteFailedException(
                        "Database access error while trying to delete profile",
                        ex);
            }
        }
    }

    @Override
    public void deleteMDComponent(String componentId, Principal principal,
            boolean forceDelete) throws UserUnauthorizedException,
            DeleteFailedException, ComponentRegistryException {
        ComponentDescription desc = componentDescriptionDao
                .getByCmdId(componentId);
        if (desc != null) {
            try {
                checkAuthorisation(desc, principal);
                checkAge(desc, principal);

                if (!forceDelete) {
                    checkStillUsed(componentId);
                }
                componentDescriptionDao.setDeleted(desc, true);
                invalidateCache(desc);
            } catch (DataAccessException ex) {
                throw new DeleteFailedException(
                        "Database access error while trying to delete component",
                        ex);
            }
        }
    }

    /**
     * 
     * @return whether this is the public registry
     * @deprecated use {@link #getStatus() } to check if this is the
     *             {@link ComponentStatus#PUBLISHED public registry}
     */
    @Override
    @Deprecated
    public boolean isPublic() {
        return registryStatus == ComponentStatus.PUBLISHED;
    }

    /**
     * @return The user id, or null if there is no owner or it is not a user.
     */
    private Number getUserId() {
        if (registryOwner instanceof OwnerUser) {
            return registryOwner.getId();
        } else {
            return null;
        }
    }

    /**
     * @return The group id, or null if there is no owner or it is not a group.
     */
    private Number getGroupId() {
        if (registryOwner instanceof OwnerGroup) {
            return registryOwner.getId();
        } else {
            return null;
        }
    }

    @Override
    public Owner getOwner() {
        return registryOwner;
    }

    /**
     * Sets status and owner of this registry
     * 
     * @param status
     *            new status for registry
     * @param owner
     *            new owner for registry
     */
    public void setStatus(ComponentStatus status, Owner owner) {
        setStatus(status);
        this.registryOwner = owner;
    }

    public void setStatus(ComponentStatus status) {
        this.registryStatus = status;
    }

    @Override
    public ComponentStatus getStatus() {
        return registryStatus;
    }

    private void invalidateCache(AbstractDescription description) {
        if (description.isProfile()) {
            profilesCache.remove(description.getId());
        } else {
            componentsCache.remove(description.getId());
        }
    }

    private AbstractDescriptionDao<?> getDaoForDescription(
            AbstractDescription description) {
        return description.isProfile() ? profileDescriptionDao
                : componentDescriptionDao;
    }

    /**
     * Looks up description on basis of CMD Id. This will also check if such a
     * record even exists.
     * 
     * @param description
     *            Description to look up
     * @return Database id for description
     * @throws IllegalArgumentException
     *             If description with non-existing id is passed
     */
    private Number getIdForDescription(AbstractDescription description)
            throws IllegalArgumentException {
        Number dbId = null;
        AbstractDescriptionDao<?> dao = getDaoForDescription(description);
        try {
            dbId = dao.getDbId(description.getId());
        } catch (DataAccessException ex) {
            LOG.error(
                    "Error getting dbId for component with id "
                            + description.getId(), ex);
        }
        if (dbId == null) {
            throw new IllegalArgumentException(
                    "Could not get database Id for description");
        } else {
            return dbId;
        }
    }

    private String componentSpecToString(CMDComponentSpec spec)
            throws UnsupportedEncodingException, JAXBException {
        ByteArrayOutputStream os = new ByteArrayOutputStream();
        getMarshaller().marshal(spec, os);
        String xml = os.toString("UTF-8");
        return xml;
    }

    private CMDComponentSpec getUncachedMDComponent(String id,
            AbstractDescriptionDao dao) {
        String xml = dao.getContent(false, id);
        if (xml != null) {
            try {
                InputStream is = new ByteArrayInputStream(xml.getBytes("UTF-8"));
                return getMarshaller().unmarshal(CMDComponentSpec.class, is,
                        null);

            } catch (JAXBException ex) {
                LOG.error("Error while unmarshalling", ex);
            } catch (UnsupportedEncodingException ex) {
                LOG.error("Exception while reading XML from database", ex);
            }
        }
        return null;
    }

    private void checkAuthorisation(AbstractDescription desc,
            Principal principal) throws UserUnauthorizedException {
        if (!isOwnerOfDescription(desc, principal.getName())
                && !configuration.isAdminUser(principal)) {
            throw new UserUnauthorizedException("Unauthorized operation user '"
                    + principal.getName()
                    + "' is not the creator (nor an administrator) of the "
                    + (desc.isProfile() ? "profile" : "component") + "(" + desc
                    + ").");
        }
    }

    private void checkAuthorisationComment(Comment desc, Principal principal)
            throws UserUnauthorizedException {
        if (!isOwnerOfComment(desc, principal.getName())
                && !configuration.isAdminUser(principal)) {
            throw new UserUnauthorizedException("Unauthorized operation user '"
                    + principal.getName()
                    + "' is not the creator (nor an administrator) of the "
                    + (desc.getId()) + "(" + desc + ").");
        }
    }

    private boolean isOwnerOfDescription(AbstractDescription desc,
            String principalName) {
        String owner = getDaoForDescription(desc).getOwnerPrincipalName(
                getIdForDescription(desc));
        return owner != null // If owner is null, no one can be owner
                && principalName.equals(owner);
    }

    private boolean isOwnerOfComment(Comment com, String principalName) {
        String owner = commentsDao.getOwnerPrincipalName(Integer.parseInt(com
                .getId()));
        return owner != null // If owner is null, no one can be owner
                && principalName.equals(owner);
    }

    private void checkAge(AbstractDescription desc, Principal principal)
            throws DeleteFailedException {
        if (isPublic() && !configuration.isAdminUser(principal)) {
            try {
                Date regDate = AbstractDescription.getDate(desc
                        .getRegistrationDate());
                Calendar calendar = Calendar.getInstance();
                calendar.set(Calendar.MONTH, calendar.get(Calendar.MONTH) - 1);
                if (regDate.before(calendar.getTime())) { // More then month old
                    throw new DeleteFailedException(
                            "The "
                                    + (desc.isProfile() ? "Profile"
                                            : "Component")
                                    + " is more then a month old and cannot be deleted anymore. It might have been used to create metadata, deleting it would invalidate that metadata.");
                }
            } catch (ParseException e) {
                LOG.error("Cannot parse date of " + desc + " Error:" + e);
            }
        }
    }

    private boolean inWorkspace(AbstractDescriptionDao<?> dao, String cmdId) {
        if (isPublic()) {
            return dao.isPublic(cmdId);
        } else {
            return dao.isInUserSpace(cmdId, getUserId());
        }
    }

    @Override
    public String getName() {
        if (isPublic()) {
            return ComponentRegistry.PUBLIC_NAME;
        } else {
            return "Registry of " + userDao.getById(getUserId()).getName();
        }
    }

    @Override
    public List<ProfileDescription> getDeletedProfileDescriptions() {
        return profileDescriptionDao.getDeletedDescriptions(getUserId());
    }

    @Override
    public List<ComponentDescription> getDeletedComponentDescriptions() {
        return componentDescriptionDao.getDeletedDescriptions(getUserId());
    }

    @Override
    public void deleteComment(String commentId, Principal principal)
            throws IOException, ComponentRegistryException,
            UserUnauthorizedException, DeleteFailedException {
        try {
            Comment comment = commentsDao.getById(Integer.parseInt(commentId));
            if (comment != null
                    // Comment must have an existing (in this registry)
                    // componentId or profileId
                    && (comment.getComponentDescriptionId() != null
                            && componentDescriptionDao.isInRegistry(
                                    comment.getComponentDescriptionId(),
                                    getUserId()) || comment
                            .getProfileDescriptionId() != null
                            && profileDescriptionDao.isInRegistry(
                                    comment.getProfileDescriptionId(),
                                    getUserId()))) {
                checkAuthorisationComment(comment, principal);
                commentsDao.deleteComment(comment);
            } else {
                // Comment exists in DB, but component is not in this registry
                throw new ComponentRegistryException("Comment " + commentId
                        + " cannot be found in specified registry");
            }
        } catch (DataAccessException ex) {
            throw new DeleteFailedException(
                    "Database access error while trying to delete component",
                    ex);
        } catch (NumberFormatException ex) {
            throw new DeleteFailedException(
                    "Illegal comment ID, cannot parse integer", ex);
        }
    }

    @Override
    public CMDComponentSpecExpander getExpander() {
        return new CMDComponentSpecExpanderDbImpl(this);
    }

    @Override
    protected MDMarshaller getMarshaller() {
        return marshaller;
    }

    @Override
    public String toString() {
        return getName();
    }
}