Metacat

		// publish

		suite.addTest(new RegisterDOITest("testPublishDOI"));

	/**

	 * Test object publishing

	 */

	public void testPublishDOI() {

		printTestHeader("testPublishDOI");

		try {

			// get ezid config properties

			String ezidUsername = PropertyService.getProperty("guid.ezid.username");

			String ezidPassword = PropertyService.getProperty("guid.ezid.password");

			String ezidServiceBaseUrl = PropertyService.getProperty("guid.ezid.baseurl");

			Session session = getTestSession();

			Identifier guid = new Identifier();

			guid.setValue("testPublishDOI." + System.currentTimeMillis());

			// use EML to test

			// TODO: include an ORE to really exercise it

			String emlFile = "test/tao.14563.1.xml";

			InputStream content = null;

			try {

				content = new FileInputStream(emlFile);

			} catch (FileNotFoundException e) {

				e.printStackTrace();

				fail(e.getMessage());

			}

			// create the initial version without DOI

			SystemMetadata sysmeta = createSystemMetadata(guid, session.getSubject(), null);

	        sysmeta.setFormatId(ObjectFormatCache.getInstance().getFormat("eml://ecoinformatics.org/eml-2.1.0").getFormatId());

			Identifier pid = MNodeService.getInstance(request).create(session, guid, content, sysmeta);

			assertEquals(guid.getValue(), pid.getValue());

			// now publish it

			Identifier publishedIdentifier = MNodeService.getInstance(request).publish(session, pid);

			// check for the metadata explicitly, using ezid service

			EZIDService ezid = new EZIDService(ezidServiceBaseUrl);

			ezid.login(ezidUsername, ezidPassword);

			HashMap<String, String> metadata = ezid.getMetadata(publishedIdentifier.getValue());

			assertNotNull(metadata);

			assertTrue(metadata.containsKey(DataCiteProfile.TITLE.toString()));

		} catch (Exception e) {

			e.printStackTrace();

			fail("Unexpected error: " + e.getMessage());

		}

	}

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;

	}

	public static final String RESOURCE_MAP_PREFIX = "resourceMap_";

				            resourceMapId.setValue(RESOURCE_MAP_PREFIX + localId);

								resourceMapObsoletes.setValue(RESOURCE_MAP_PREFIX + obsoletesLocalId );

								resourceMapObsoletedBy.setValue(RESOURCE_MAP_PREFIX + obsoletedByLocalId);