Metacat

import java.io.UnsupportedEncodingException;

import java.net.URISyntaxException;

import java.util.Map;

import org.dataone.ore.ResourceMapFactory;

import org.dspace.foresite.OREException;

import org.dspace.foresite.OREParserException;

import org.dspace.foresite.ORESerialiserException;

import org.dspace.foresite.ResourceMap;

	public static final String UUID_SCHEME = "UUID";

	public static final String DOI_SCHEME = "DOI";

	/**

	 * Given an existing Science Metadata PID, this method mints a DOI

	 * and updates the original object "publishing" the update with the DOI.

	 * This includes updating the ORE map that describes the Science Metadata+data.

	 * TODO: ensure all referenced objects allow public read

	 * 

	 * @see https://projects.ecoinformatics.org/ecoinfo/issues/6014

	 * 

	 * @param originalIdentifier

	 * @param request

	 * @throws InvalidRequest

	 * @throws EZIDException

	 * @throws InvalidToken

	 * @throws NotAuthorized

	 * @throws NotImplemented

	 * @throws ServiceFailure

	 * @throws NotFound

	 * @throws InsufficientResources

	 * @throws IdentifierNotUnique

	 * @throws InvalidSystemMetadata

	 * @throws UnsupportedType

	 * @throws McdbDocNotFoundException 

	 * @throws OREParserException 

	 * @throws URISyntaxException 

	 * @throws OREException 

	 * @throws UnsupportedEncodingException 

	 * @throws ORESerialiserException 

	 * @throws NoSuchAlgorithmException 

	 */

	public Identifier publish(Session session, Identifier originalIdentifier) throws InvalidRequest, EZIDException, InvalidToken, NotAuthorized, NotImplemented, ServiceFailure, NotFound, InsufficientResources, IdentifierNotUnique, InvalidSystemMetadata, UnsupportedType, McdbDocNotFoundException, UnsupportedEncodingException, OREException, URISyntaxException, OREParserException, ORESerialiserException, NoSuchAlgorithmException {

		// mint a DOI for the new revision

		Identifier newIdentifier = this.generateIdentifier(session, MNodeService.DOI_SCHEME, null);

		// get the original SM and update the values

		SystemMetadata sysmeta = this.getSystemMetadata(session, originalIdentifier);

		sysmeta.setIdentifier(newIdentifier);

		sysmeta.setObsoletes(originalIdentifier);

		sysmeta.setObsoletedBy(null);

		// get the bytes

		InputStream inputStream = this.get(session, originalIdentifier);

		// update the object

		this.update(session, originalIdentifier, inputStream , newIdentifier, sysmeta);

		// TODO: update ORE that references the scimeta

		String localId = IdentifierManager.getInstance().getLocalId(originalIdentifier.getValue());

		Identifier potentialOreIdentifier = new Identifier();

		potentialOreIdentifier.setValue(SystemMetadataFactory.RESOURCE_MAP_PREFIX + localId);

		InputStream oreInputStream = null;

		try {

			oreInputStream = this.get(session, potentialOreIdentifier);

		} catch (NotFound nf) {

			// this is probably okay for many sci meta data docs

			logMetacat.warn("No potential ORE map found for: " + potentialOreIdentifier.getValue());

		}

		if (oreInputStream != null) {

			Identifier newOreIdentifier = MNodeService.getInstance(request).generateIdentifier(session, MNodeService.UUID_SCHEME, null);

			Map<Identifier, Map<Identifier, List<Identifier>>> resourceMapStructure = ResourceMapFactory.getInstance().parseResourceMap(oreInputStream);

			Map<Identifier, List<Identifier>> sciMetaMap = resourceMapStructure.get(potentialOreIdentifier);

			List<Identifier> dataIdentifiers = sciMetaMap.get(originalIdentifier);

			// TODO: ensure all data package objects allow public read

			// reconstruct the ORE with the new identifiers

			sciMetaMap.remove(originalIdentifier);

			sciMetaMap.put(newIdentifier, dataIdentifiers);

			ResourceMap resourceMap = ResourceMapFactory.getInstance().createResourceMap(newOreIdentifier, sciMetaMap);

			String resourceMapString = ResourceMapFactory.getInstance().serializeResourceMap(resourceMap);

			// get the original ORE SM and update the values

			SystemMetadata oreSysMeta = this.getSystemMetadata(session, potentialOreIdentifier);

			oreSysMeta.setIdentifier(newOreIdentifier);

			oreSysMeta.setObsoletes(potentialOreIdentifier);

			oreSysMeta.setObsoletedBy(null);

			oreSysMeta.setSize(BigInteger.valueOf(resourceMapString.getBytes("UTF-8").length));

			oreSysMeta.setChecksum(ChecksumUtil.checksum(resourceMapString.getBytes("UTF-8"), oreSysMeta.getChecksum().getAlgorithm()));

			// save the updated ORE

			this.update(

					session, 

					potentialOreIdentifier, 

					new ByteArrayInputStream(resourceMapString.getBytes("UTF-8")), 

					newOreIdentifier, 

					oreSysMeta);

		}

		return newIdentifier;

	}