CollectionCollectionGenerator.java

/**
 * 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.sword;

import org.purl.sword.base.Collection;
import org.dspace.content.DSpaceObject;
import org.dspace.core.ConfigurationManager;
import org.apache.log4j.Logger;

import java.util.Map;
import java.util.List;

/**
 * Class to generate ATOM Collection Elements which represent
 * DSpace Collections
 *
 */
public class CollectionCollectionGenerator extends ATOMCollectionGenerator
{
	/** logger */
	private static Logger log = Logger.getLogger(CollectionCollectionGenerator.class);

	/**
	 * Construct an object taking the sword service instance an argument
	 * @param service
	 */
	public CollectionCollectionGenerator(SWORDService service)
	{
		super(service);
		log.debug("Create new instance of CollectionCollectionGenerator");
	}

	/**
	 * Build the collection for the given DSpaceObject.  In this implementation,
	 * if the object is not a DSpace COllection, it will throw an exception
	 * @param dso
	 * @return
	 * @throws DSpaceSWORDException
	 */
	public Collection buildCollection(DSpaceObject dso) throws DSpaceSWORDException
	{
		if (!(dso instanceof org.dspace.content.Collection))
		{
			log.error("buildCollection passed argument which is not of type Collection");
			throw new DSpaceSWORDException("Incorrect ATOMCollectionGenerator instantiated");
		}

		// get the things we need out of the service
		SWORDConfiguration swordConfig = swordService.getSwordConfig();
		SWORDUrlManager urlManager = swordService.getUrlManager();

		org.dspace.content.Collection col = (org.dspace.content.Collection) dso;

		Collection scol = new Collection();

		// prepare the parameters to be put in the sword collection
		String location = urlManager.getDepositLocation(col);

		// collection title is just its name
		String title = col.getMetadata("name");

		// the collection policy is the licence to which the collection adheres
		String collectionPolicy = col.getLicense();

		// FIXME: what is the treatment?  Doesn't seem appropriate for DSpace
		// String treatment = " ";

		// abstract is the short description of the collection
		String dcAbstract = col.getMetadata("short_description");

		// we just do support mediation
		boolean mediation = swordConfig.isMediated();

		// load up the sword collection
		scol.setLocation(location);

		// add the title if it exists
		if (title != null && !"".equals(title))
		{
			scol.setTitle(title);
		}

		// add the collection policy if it exists
		if (collectionPolicy != null && !"".equals(collectionPolicy))
		{
			scol.setCollectionPolicy(collectionPolicy);
		}

		// FIXME: leave the treatment out for the time being,
		// as there is no analogue
		// scol.setTreatment(treatment);

		// add the abstract if it exists
		if (dcAbstract != null && !"".equals(dcAbstract))
		{
			scol.setAbstract(dcAbstract);
		}

		scol.setMediation(mediation);

        List<String> accepts = swordService.getSwordConfig().getCollectionAccepts();
        for (String accept : accepts)
        {
            scol.addAccepts(accept);
        }

		// add the accept packaging values
		Map<String, Float> aps = swordConfig.getAcceptPackaging(col);
		for (Map.Entry<String, Float> ap : aps.entrySet())
		{
			scol.addAcceptPackaging(ap.getKey(), ap.getValue());
		}

		// should we offer the items in the collection up as deposit
		// targets?
		boolean itemService = ConfigurationManager.getBooleanProperty("sword-server", "expose-items");
		if (itemService)
		{
			String subService = urlManager.constructSubServiceUrl(col);
			scol.setService(subService);
		}

		log.debug("Created ATOM Collection for DSpace Collection");

		return scol;
	}
}