Java tutorial
/** * The contents of this file are subject to the license and copyright * detailed in the LICENSE file at the root of the source * tree and available online at * * https://github.com/keeps/roda */ package org.roda.core.model.utils; import java.io.IOException; import java.io.InputStream; import java.io.Serializable; import java.io.UnsupportedEncodingException; import java.net.URLEncoder; import java.nio.charset.Charset; import java.util.ArrayList; import java.util.Iterator; import java.util.List; import java.util.Objects; import java.util.Optional; import java.util.function.Function; import org.apache.commons.io.IOUtils; import org.apache.commons.lang3.StringUtils; import org.roda.core.RodaCoreFactory; import org.roda.core.common.iterables.CloseableIterable; import org.roda.core.common.iterables.CloseableIterables; import org.roda.core.data.common.RodaConstants; import org.roda.core.data.exceptions.AuthorizationDeniedException; import org.roda.core.data.exceptions.GenericException; import org.roda.core.data.exceptions.NotFoundException; import org.roda.core.data.exceptions.RODAException; import org.roda.core.data.exceptions.RequestNotValidException; import org.roda.core.data.utils.JsonUtils; import org.roda.core.data.utils.URNUtils; import org.roda.core.data.v2.IsRODAObject; import org.roda.core.data.v2.LiteRODAObject; import org.roda.core.data.v2.common.OptionalWithCause; import org.roda.core.data.v2.formats.Format; import org.roda.core.data.v2.ip.AIP; import org.roda.core.data.v2.ip.DIP; import org.roda.core.data.v2.ip.DIPFile; import org.roda.core.data.v2.ip.File; import org.roda.core.data.v2.ip.Representation; import org.roda.core.data.v2.ip.StoragePath; import org.roda.core.data.v2.ip.TransferredResource; import org.roda.core.data.v2.ip.metadata.DescriptiveMetadata; import org.roda.core.data.v2.ip.metadata.OtherMetadata; import org.roda.core.data.v2.ip.metadata.PreservationMetadata; import org.roda.core.data.v2.ip.metadata.PreservationMetadata.PreservationMetadataType; import org.roda.core.data.v2.jobs.Job; import org.roda.core.data.v2.jobs.Report; import org.roda.core.data.v2.notifications.Notification; import org.roda.core.data.v2.risks.Risk; import org.roda.core.data.v2.risks.RiskIncidence; import org.roda.core.model.LiteRODAObjectFactory; import org.roda.core.storage.Binary; import org.roda.core.storage.DefaultBinary; import org.roda.core.storage.DefaultDirectory; import org.roda.core.storage.DefaultStoragePath; import org.roda.core.storage.Resource; import org.roda.core.storage.StorageService; import org.roda.core.util.IdUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; public class ResourceParseUtils { private static final Logger LOGGER = LoggerFactory.getLogger(ResourceParseUtils.class); private static final String RESOURCE_CANNOT_BE_NULL = "Resource cannot be null"; private ResourceParseUtils() { // do nothing } public static File convertResourceToFile(Resource resource) throws GenericException, NotFoundException, AuthorizationDeniedException, RequestNotValidException { File ret; if (resource == null) { throw new RequestNotValidException(RESOURCE_CANNOT_BE_NULL); } StoragePath resourcePath = resource.getStoragePath(); String id = resourcePath.getName(); String aipId = ModelUtils.extractAipId(resourcePath); String representationId = ModelUtils.extractRepresentationId(resourcePath); List<String> filePath = ModelUtils.extractFilePathFromRepresentationData(resourcePath); if (resource instanceof DefaultBinary) { boolean isDirectory = false; ret = new File(id, aipId, representationId, filePath, isDirectory); } else if (resource instanceof DefaultDirectory) { boolean isDirectory = true; ret = new File(id, aipId, representationId, filePath, isDirectory); } else { throw new GenericException( "Error while trying to convert something that it isn't a Binary into a representation file"); } return ret; } public static DIPFile convertResourceToDIPFile(Resource resource) throws GenericException, NotFoundException, AuthorizationDeniedException, RequestNotValidException { DIPFile ret; if (resource == null) { throw new RequestNotValidException(RESOURCE_CANNOT_BE_NULL); } StoragePath resourcePath = resource.getStoragePath(); String id = resourcePath.getName(); String dipId = ModelUtils.extractDipId(resourcePath); List<String> filePath = ModelUtils.extractFilePathFromDIPData(resourcePath); if (resource instanceof DefaultBinary) { boolean isDirectory = false; ret = new DIPFile(id, dipId, filePath, isDirectory); } else if (resource instanceof DefaultDirectory) { boolean isDirectory = true; ret = new DIPFile(id, dipId, filePath, isDirectory); } else { throw new GenericException( "Error while trying to convert something that is not a Binary or Directory into a DIP file"); } return ret; } private static PreservationMetadata convertResourceToPreservationMetadata(Resource resource) throws RequestNotValidException { if (resource == null) { throw new RequestNotValidException(RESOURCE_CANNOT_BE_NULL); } StoragePath resourcePath = resource.getStoragePath(); String filename = resourcePath.getName(); PreservationMetadata pm = new PreservationMetadata(); String id; String aipId = ModelUtils.extractAipId(resourcePath); String representationId = ModelUtils.extractRepresentationId(resourcePath); List<String> fileDirectoryPath = null; String fileId = null; PreservationMetadataType type; if (filename.startsWith(URNUtils.getPremisPrefix(PreservationMetadataType.AGENT))) { id = filename.substring(0, filename.length() - RodaConstants.PREMIS_SUFFIX.length()); type = PreservationMetadataType.AGENT; aipId = null; representationId = null; } else if (filename.startsWith(URNUtils.getPremisPrefix(PreservationMetadataType.EVENT))) { id = filename.substring(0, filename.length() - RodaConstants.PREMIS_SUFFIX.length()); type = PreservationMetadataType.EVENT; try { String separator = URLEncoder.encode(RodaConstants.URN_SEPARATOR, RodaConstants.DEFAULT_ENCODING); if (StringUtils.countMatches(id, separator) > 0) { fileDirectoryPath = ModelUtils .extractFilePathFromRepresentationPreservationMetadata(resourcePath); fileId = id.substring(id.lastIndexOf(separator) + 1); } } catch (UnsupportedEncodingException e) { LOGGER.error("Error encoding urn separator when converting file event preservation metadata"); } } else if (filename.startsWith(URNUtils.getPremisPrefix(PreservationMetadataType.FILE))) { type = PreservationMetadataType.FILE; fileDirectoryPath = ModelUtils.extractFilePathFromRepresentationPreservationMetadata(resourcePath); fileId = filename.substring(0, filename.length() - RodaConstants.PREMIS_SUFFIX.length()); id = fileId; } else if (filename.startsWith(URNUtils.getPremisPrefix(PreservationMetadataType.OTHER))) { type = PreservationMetadataType.OTHER; fileDirectoryPath = ModelUtils.extractFilePathFromRepresentationPreservationMetadata(resourcePath); fileId = filename.substring(0, filename.length() - RodaConstants.PREMIS_SUFFIX.length()); id = fileId; } else if (filename.startsWith(URNUtils.getPremisPrefix(PreservationMetadataType.REPRESENTATION))) { id = filename.substring(0, filename.length() - RodaConstants.PREMIS_SUFFIX.length()); type = PreservationMetadataType.REPRESENTATION; } else { throw new RequestNotValidException("Unsupported PREMIS extension type in file: " + filename); } pm.setId(id); pm.setAipId(aipId); pm.setRepresentationId(representationId); pm.setFileDirectoryPath(fileDirectoryPath); pm.setFileId(fileId); pm.setType(type); return pm; } private static OtherMetadata convertResourceToOtherMetadata(Resource resource) throws RequestNotValidException { if (resource == null) { throw new RequestNotValidException(RESOURCE_CANNOT_BE_NULL); } StoragePath resourcePath = resource.getStoragePath(); String filename = resourcePath.getName(); String aipId = ModelUtils.extractAipId(resourcePath); String representationId = ModelUtils.extractRepresentationId(resourcePath); String type = representationId != null ? ModelUtils.extractTypeFromRepresentationOtherMetadata(resourcePath) : ModelUtils.extractTypeFromAipOtherMetadata(resourcePath); List<String> fileDirectoryPath = representationId != null ? ModelUtils.extractFilePathFromRepresentationOtherMetadata(resourcePath) : ModelUtils.extractFilePathFromAipOtherMetadata(resourcePath); String fileId = filename.substring(0, filename.lastIndexOf('.')); String suffix = filename.substring(filename.lastIndexOf('.'), filename.length()); OtherMetadata om = new OtherMetadata(); om.setId(IdUtils.getOtherMetadataId(aipId, representationId, fileDirectoryPath, fileId)); om.setAipId(aipId); om.setRepresentationId(representationId); om.setFileDirectoryPath(fileDirectoryPath); om.setFileId(fileId); om.setType(type); om.setFileSuffix(suffix); return om; } public static Representation convertResourceToRepresentation(Resource resource) throws GenericException, NotFoundException, AuthorizationDeniedException, RequestNotValidException { if (resource == null) { throw new RequestNotValidException(RESOURCE_CANNOT_BE_NULL); } StoragePath resourcePath = resource.getStoragePath(); String id = resourcePath.getName(); String aipId = ModelUtils.extractAipId(resourcePath); AIP aip = RodaCoreFactory.getModelService().retrieveAIP(aipId); Optional<Representation> rep = aip.getRepresentations().stream().filter(r -> r.getId().equals(id)) .findFirst(); if (rep.isPresent()) { return rep.get(); } else { throw new NotFoundException("Unable to find representation with storage path " + resourcePath); } } public static <T extends Serializable> T convertResourceToObject(Resource resource, Class<T> objectClass) throws GenericException, NotFoundException, AuthorizationDeniedException, RequestNotValidException, IOException { if (resource == null) { throw new RequestNotValidException(RESOURCE_CANNOT_BE_NULL); } Binary binary = (Binary) resource; InputStream inputStream = binary.getContent().createInputStream(); String jsonString = IOUtils.toString(inputStream, RodaConstants.DEFAULT_ENCODING); T ret = JsonUtils.getObjectFromJson(jsonString, objectClass); IOUtils.closeQuietly(inputStream); return ret; } public static <T extends IsRODAObject> OptionalWithCause<T> convertResourceTo(StorageService storage, Resource resource, Class<T> classToReturn) { OptionalWithCause<T> ret; try { if (classToReturn.equals(AIP.class)) { ret = OptionalWithCause.of(classToReturn.cast(getAIPMetadata(storage, resource.getStoragePath()))); } else if (classToReturn.equals(Representation.class)) { ret = OptionalWithCause.of(classToReturn.cast(convertResourceToRepresentation(resource))); } else if (classToReturn.equals(File.class)) { ret = OptionalWithCause.of(classToReturn.cast(convertResourceToFile(resource))); } else if (classToReturn.equals(PreservationMetadata.class)) { ret = OptionalWithCause.of(classToReturn.cast(convertResourceToPreservationMetadata(resource))); } else if (classToReturn.equals(OtherMetadata.class)) { ret = OptionalWithCause.of(classToReturn.cast(convertResourceToOtherMetadata(resource))); } else if (classToReturn.equals(DIP.class)) { ret = OptionalWithCause.of(classToReturn.cast(getDIPMetadata(storage, resource.getStoragePath()))); } else if (classToReturn.equals(DIPFile.class)) { ret = OptionalWithCause.of(classToReturn.cast(convertResourceToDIPFile(resource))); } else { ret = OptionalWithCause.of(convertResourceToObject(resource, classToReturn)); } } catch (RODAException e) { ret = OptionalWithCause.empty(e); } catch (IOException e) { ret = OptionalWithCause.empty(new RequestNotValidException(e)); } return ret; } public static <T extends IsRODAObject> OptionalWithCause<LiteRODAObject> convertResourceToLite( Resource resource, Class<T> classToReturn) { OptionalWithCause<LiteRODAObject> ret; StoragePath storagePath = resource.getStoragePath(); String fileName = resource.getStoragePath().getName(); if (classToReturn.equals(AIP.class) || classToReturn.equals(DIP.class)) { ret = OptionalWithCause.of(LiteRODAObjectFactory.get(classToReturn, fileName)); } else if (classToReturn.equals(Representation.class)) { String aipId = ModelUtils.extractAipId(storagePath); String repId = ModelUtils.extractRepresentationId(storagePath); ret = OptionalWithCause.of(LiteRODAObjectFactory.get(classToReturn, aipId, repId)); } else if (classToReturn.equals(File.class)) { List<String> ids = new ArrayList<>(); ids.add(ModelUtils.extractAipId(storagePath)); ids.add(ModelUtils.extractRepresentationId(storagePath)); ids.addAll(ModelUtils.extractFilePathFromRepresentationData(storagePath)); ids.add(fileName); ret = OptionalWithCause.of(LiteRODAObjectFactory.get(classToReturn, ids)); } else if (classToReturn.equals(DIPFile.class)) { List<String> ids = new ArrayList<>(); ids.add(ModelUtils.extractDipId(storagePath)); ids.addAll(ModelUtils.extractFilePathFromDIPData(storagePath)); ids.add(fileName); ret = OptionalWithCause.of(LiteRODAObjectFactory.get(classToReturn, ids)); } else if (classToReturn.equals(Risk.class)) { ret = OptionalWithCause.of(LiteRODAObjectFactory.get(classToReturn, ModelUtils.getRiskId(storagePath))); } else if (classToReturn.equals(RiskIncidence.class)) { ret = OptionalWithCause .of(LiteRODAObjectFactory.get(classToReturn, ModelUtils.getRiskIncidenceId(storagePath))); } else if (classToReturn.equals(Format.class)) { ret = OptionalWithCause .of(LiteRODAObjectFactory.get(classToReturn, ModelUtils.getFormatId(storagePath))); } else if (classToReturn.equals(Notification.class)) { ret = OptionalWithCause .of(LiteRODAObjectFactory.get(classToReturn, ModelUtils.getNotificationId(storagePath))); } else if (classToReturn.equals(Job.class)) { ret = OptionalWithCause.of(LiteRODAObjectFactory.get(classToReturn, ModelUtils.getJobId(storagePath))); } else if (classToReturn.equals(Report.class)) { ret = OptionalWithCause .of(LiteRODAObjectFactory.get(classToReturn, ModelUtils.getJobAndReportIds(storagePath))); } else if (classToReturn.equals(DescriptiveMetadata.class)) { List<String> ids = new ArrayList<>(); ids.add(ModelUtils.extractAipId(storagePath)); String representationId = ModelUtils.extractRepresentationId(storagePath); if (representationId != null) { ids.add(representationId); } ids.add(fileName); ret = OptionalWithCause.of(LiteRODAObjectFactory.get(classToReturn, ids)); } else if (classToReturn.equals(PreservationMetadata.class)) { List<String> ids = new ArrayList<>(); String aipId = ModelUtils.extractAipId(storagePath); if (aipId != null) { ids.add(aipId); } String representationId = ModelUtils.extractRepresentationId(storagePath); if (representationId != null) { ids.add(representationId); } ids.add(fileName.replace(RodaConstants.PREMIS_SUFFIX, "")); ret = OptionalWithCause.of(LiteRODAObjectFactory.get(classToReturn, ids)); } else { ret = OptionalWithCause.of(LiteRODAObjectFactory.get(classToReturn, fileName)); } return ret; } public static AIP getAIPMetadata(StorageService storage, String aipId) throws RequestNotValidException, GenericException, NotFoundException, AuthorizationDeniedException { return getAIPMetadata(storage, aipId, ModelUtils.getAIPStoragePath(aipId)); } public static AIP getAIPMetadata(StorageService storage, StoragePath storagePath) throws RequestNotValidException, GenericException, NotFoundException, AuthorizationDeniedException { return getAIPMetadata(storage, storagePath.getName(), storagePath); } public static AIP getAIPMetadata(StorageService storage, String aipId, StoragePath storagePath) throws RequestNotValidException, GenericException, NotFoundException, AuthorizationDeniedException { DefaultStoragePath metadataStoragePath = DefaultStoragePath.parse(storagePath, RodaConstants.STORAGE_AIP_METADATA_FILENAME); Binary binary = storage.getBinary(metadataStoragePath); String json; AIP aip; InputStream inputStream = null; try { inputStream = binary.getContent().createInputStream(); json = IOUtils.toString(inputStream, Charset.forName(RodaConstants.DEFAULT_ENCODING)); aip = JsonUtils.getObjectFromJson(json, AIP.class); } catch (IOException | GenericException e) { throw new GenericException("Could not parse AIP metadata of " + aipId + " at " + metadataStoragePath, e); } finally { IOUtils.closeQuietly(inputStream); } // Setting information that does not come in JSON aip.setId(aipId); return aip; } public static DIP getDIPMetadata(StorageService storage, StoragePath storagePath) throws RequestNotValidException, GenericException, NotFoundException, AuthorizationDeniedException { return getDIPMetadata(storage, storagePath.getName(), storagePath); } public static DIP getDIPMetadata(StorageService storage, String dipId, StoragePath storagePath) throws RequestNotValidException, GenericException, NotFoundException, AuthorizationDeniedException { DefaultStoragePath metadataStoragePath = DefaultStoragePath.parse(storagePath, RodaConstants.STORAGE_DIP_METADATA_FILENAME); Binary binary = storage.getBinary(metadataStoragePath); String json; DIP dip; InputStream inputStream = null; try { inputStream = binary.getContent().createInputStream(); json = IOUtils.toString(inputStream, Charset.forName(RodaConstants.DEFAULT_ENCODING)); dip = JsonUtils.getObjectFromJson(json, DIP.class); } catch (IOException | GenericException e) { throw new GenericException("Could not parse DIP metadata of " + dipId + " at " + metadataStoragePath, e); } finally { IOUtils.closeQuietly(inputStream); } // Setting information that does not come in JSON dip.setId(dipId); return dip; } private static <T extends Serializable> boolean isDirectoryAcceptable(Class<T> classToReturn) { return classToReturn.equals(File.class) || classToReturn.equals(AIP.class) || classToReturn.equals(Representation.class) || classToReturn.equals(TransferredResource.class) || classToReturn.equals(DIPFile.class) || classToReturn.equals(DIP.class); } @FunctionalInterface interface ResourceParser<T extends IsRODAObject, R extends Serializable> { OptionalWithCause<R> parse(StorageService storage, Resource resource, Class<T> classToReturn); default <V extends IsRODAObject> ResourceParser<T, V> andThen( Function<OptionalWithCause<R>, OptionalWithCause<V>> after) { Objects.requireNonNull(after); return (StorageService storage, Resource resource, Class<T> classToReturn) -> after .apply(parse(storage, resource, classToReturn)); } } public static <T extends IsRODAObject> CloseableIterable<OptionalWithCause<T>> convert( final StorageService storage, final CloseableIterable<Resource> iterable, final Class<T> classToReturn) { return convert(storage, iterable, classToReturn, (s, r, c) -> ResourceParseUtils.convertResourceTo(s, r, c)); } public static <T extends IsRODAObject> CloseableIterable<OptionalWithCause<LiteRODAObject>> convertLite( StorageService storage, CloseableIterable<Resource> iterable, Class<T> classToReturn) { return convert(storage, iterable, classToReturn, (s, r, c) -> ResourceParseUtils.convertResourceToLite(r, c)); } private static <T extends IsRODAObject, R extends Serializable> CloseableIterable<OptionalWithCause<R>> convert( final StorageService storage, final CloseableIterable<Resource> iterable, final Class<T> classToReturn, ResourceParser<T, R> parser) { final CloseableIterable<Resource> filtered; if (isDirectoryAcceptable(classToReturn)) { filtered = iterable; } else { filtered = CloseableIterables.filter(iterable, p -> !p.isDirectory()); } CloseableIterable<OptionalWithCause<R>> it; final Iterator<Resource> iterator = filtered.iterator(); it = new CloseableIterable<OptionalWithCause<R>>() { @Override public Iterator<OptionalWithCause<R>> iterator() { return new Iterator<OptionalWithCause<R>>() { @Override public boolean hasNext() { if (iterator == null) { return true; } return iterator.hasNext(); } @Override public OptionalWithCause<R> next() { return parser.parse(storage, iterator.next(), classToReturn); } @Override public void remove() { throw new UnsupportedOperationException(); } }; } @Override public void close() throws IOException { filtered.close(); } }; return it; } }