BrowserHelper.java

/**
 * 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.wui.api.controllers;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Map.Entry;
import java.util.MissingResourceException;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;

import javax.ws.rs.core.MultivaluedMap;

import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
import org.custommonkey.xmlunit.Diff;
import org.custommonkey.xmlunit.XMLUnit;
import org.roda.core.RodaCoreFactory;
import org.roda.core.common.ClassificationPlanUtils;
import org.roda.core.common.ConsumesOutputStream;
import org.roda.core.common.DownloadUtils;
import org.roda.core.common.EntityResponse;
import org.roda.core.common.HandlebarsUtility;
import org.roda.core.common.Messages;
import org.roda.core.common.PremisV3Utils;
import org.roda.core.common.RodaUtils;
import org.roda.core.common.StreamResponse;
import org.roda.core.common.UserUtility;
import org.roda.core.common.iterables.CloseableIterable;
import org.roda.core.common.iterables.CloseableIterables;
import org.roda.core.common.monitor.TransferredResourcesScanner;
import org.roda.core.common.tools.ZipEntryInfo;
import org.roda.core.common.validation.ValidationUtils;
import org.roda.core.data.common.RodaConstants;
import org.roda.core.data.common.RodaConstants.PreservationEventType;
import org.roda.core.data.common.RodaConstants.RODA_TYPE;
import org.roda.core.data.exceptions.AlreadyExistsException;
import org.roda.core.data.exceptions.AuthorizationDeniedException;
import org.roda.core.data.exceptions.GenericException;
import org.roda.core.data.exceptions.InvalidParameterException;
import org.roda.core.data.exceptions.IsStillUpdatingException;
import org.roda.core.data.exceptions.JobAlreadyStartedException;
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.v2.LinkingObjectUtils;
import org.roda.core.data.v2.common.ObjectPermission;
import org.roda.core.data.v2.common.ObjectPermissionResult;
import org.roda.core.data.v2.common.OptionalWithCause;
import org.roda.core.data.v2.common.Pair;
import org.roda.core.data.v2.formats.Format;
import org.roda.core.data.v2.index.IndexResult;
import org.roda.core.data.v2.index.IsIndexed;
import org.roda.core.data.v2.index.facet.FacetFieldResult;
import org.roda.core.data.v2.index.facet.FacetValue;
import org.roda.core.data.v2.index.facet.Facets;
import org.roda.core.data.v2.index.facet.SimpleFacetParameter;
import org.roda.core.data.v2.index.filter.EmptyKeyFilterParameter;
import org.roda.core.data.v2.index.filter.Filter;
import org.roda.core.data.v2.index.filter.OneOfManyFilterParameter;
import org.roda.core.data.v2.index.filter.SimpleFilterParameter;
import org.roda.core.data.v2.index.select.SelectedItems;
import org.roda.core.data.v2.index.select.SelectedItemsFilter;
import org.roda.core.data.v2.index.select.SelectedItemsList;
import org.roda.core.data.v2.index.sort.SortParameter;
import org.roda.core.data.v2.index.sort.Sorter;
import org.roda.core.data.v2.index.sublist.Sublist;
import org.roda.core.data.v2.ip.AIP;
import org.roda.core.data.v2.ip.AIPState;
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.IndexedAIP;
import org.roda.core.data.v2.ip.IndexedDIP;
import org.roda.core.data.v2.ip.IndexedFile;
import org.roda.core.data.v2.ip.IndexedRepresentation;
import org.roda.core.data.v2.ip.Permissions;
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.DescriptiveMetadataList;
import org.roda.core.data.v2.ip.metadata.IndexedPreservationAgent;
import org.roda.core.data.v2.ip.metadata.IndexedPreservationEvent;
import org.roda.core.data.v2.ip.metadata.LinkingIdentifier;
import org.roda.core.data.v2.ip.metadata.OtherMetadata;
import org.roda.core.data.v2.ip.metadata.OtherMetadataList;
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.ip.metadata.PreservationMetadataList;
import org.roda.core.data.v2.jobs.IndexedReport;
import org.roda.core.data.v2.jobs.Job;
import org.roda.core.data.v2.jobs.PluginType;
import org.roda.core.data.v2.jobs.Report;
import org.roda.core.data.v2.jobs.Report.PluginState;
import org.roda.core.data.v2.jobs.Reports;
import org.roda.core.data.v2.risks.IndexedRisk;
import org.roda.core.data.v2.risks.Risk;
import org.roda.core.data.v2.risks.Risk.SEVERITY_LEVEL;
import org.roda.core.data.v2.risks.RiskIncidence;
import org.roda.core.data.v2.risks.RiskIncidence.INCIDENCE_STATUS;
import org.roda.core.data.v2.user.User;
import org.roda.core.data.v2.validation.ValidationException;
import org.roda.core.data.v2.validation.ValidationReport;
import org.roda.core.index.IndexService;
import org.roda.core.index.utils.IterableIndexResult;
import org.roda.core.model.ModelService;
import org.roda.core.model.utils.ModelUtils;
import org.roda.core.plugins.plugins.PluginHelper;
import org.roda.core.plugins.plugins.characterization.SiegfriedPlugin;
import org.roda.core.plugins.plugins.ingest.AutoAcceptSIPPlugin;
import org.roda.core.plugins.plugins.internal.DeleteRODAObjectPlugin;
import org.roda.core.plugins.plugins.internal.MovePlugin;
import org.roda.core.plugins.plugins.internal.UpdateAIPPermissionsPlugin;
import org.roda.core.storage.Binary;
import org.roda.core.storage.BinaryVersion;
import org.roda.core.storage.ContentPayload;
import org.roda.core.storage.DefaultStoragePath;
import org.roda.core.storage.Directory;
import org.roda.core.storage.StorageService;
import org.roda.core.storage.fs.FSPathContentPayload;
import org.roda.core.storage.fs.FSUtils;
import org.roda.core.util.IdUtils;
import org.roda.wui.api.v1.utils.ApiUtils;
import org.roda.wui.api.v1.utils.ObjectResponse;
import org.roda.wui.client.browse.MetadataValue;
import org.roda.wui.client.browse.bundle.BinaryVersionBundle;
import org.roda.wui.client.browse.bundle.BrowseAIPBundle;
import org.roda.wui.client.browse.bundle.BrowseFileBundle;
import org.roda.wui.client.browse.bundle.BrowseRepresentationBundle;
import org.roda.wui.client.browse.bundle.DescriptiveMetadataEditBundle;
import org.roda.wui.client.browse.bundle.DescriptiveMetadataVersionsBundle;
import org.roda.wui.client.browse.bundle.DescriptiveMetadataViewBundle;
import org.roda.wui.client.browse.bundle.DipBundle;
import org.roda.wui.client.browse.bundle.PreservationEventViewBundle;
import org.roda.wui.client.browse.bundle.SupportedMetadataTypeBundle;
import org.roda.wui.client.planning.MitigationPropertiesBundle;
import org.roda.wui.client.planning.RiskMitigationBundle;
import org.roda.wui.client.planning.RiskVersionsBundle;
import org.roda.wui.common.HTMLUtils;
import org.roda.wui.common.server.ServerTools;
import org.roda.wui.server.common.XMLSimilarityIgnoreElements;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.xml.sax.SAXException;

/**
 * @author Luis Faria <lfaria@keep.pt>
 */
public class BrowserHelper {
  private static final String HTML_EXT = ".html";
  private static final Logger LOGGER = LoggerFactory.getLogger(BrowserHelper.class);
  private static final List<String> aipAncestorsFieldsToReturn = Arrays.asList(RodaConstants.INDEX_UUID,
    RodaConstants.AIP_GHOST, RodaConstants.AIP_LEVEL, RodaConstants.AIP_TITLE, RodaConstants.AIP_PARENT_ID);

  private BrowserHelper() {
    // do nothing
  }

  protected static BrowseAIPBundle retrieveBrowseAipBundle(User user, IndexedAIP aip, Locale locale)
    throws GenericException, NotFoundException, RequestNotValidException, AuthorizationDeniedException {
    BrowseAIPBundle bundle = new BrowseAIPBundle();

    // set aip
    bundle.setAIP(aip);
    String aipId = aip.getId();
    boolean justActive = aip.getState().equals(AIPState.ACTIVE);

    // set aip ancestors
    try {
      List<IndexedAIP> ancestors = retrieveAncestors(aip, aipAncestorsFieldsToReturn);
      bundle.setAIPAncestors(ancestors);
    } catch (NotFoundException e) {
      LOGGER.warn("Found an item with invalid ancestors: {}", aip.getId(), e);
    }

    // set descriptive metadata
    try {
      List<DescriptiveMetadataViewBundle> descriptiveMetadataList = retrieveDescriptiveMetadataBundles(aipId, locale);
      bundle.setDescriptiveMetadata(descriptiveMetadataList);
    } catch (NotFoundException e) {
      // do nothing
    }

    // Count child AIPs
    Filter childAIPfilter = new Filter(new SimpleFilterParameter(RodaConstants.AIP_PARENT_ID, aip.getId()));
    Long childAIPCount = RodaCoreFactory.getIndexService().count(IndexedAIP.class, childAIPfilter, user, justActive);
    bundle.setChildAIPCount(childAIPCount);

    // Count representations
    Filter repFilter = new Filter(new SimpleFilterParameter(RodaConstants.REPRESENTATION_AIP_ID, aipId));
    Long repCount = RodaCoreFactory.getIndexService().count(IndexedRepresentation.class, repFilter, user, justActive);
    bundle.setRepresentationCount(repCount);

    // Count DIPs
    Filter dipsFilter = new Filter(new SimpleFilterParameter(RodaConstants.DIP_AIP_UUIDS, aip.getId()));
    Long dipCount = RodaCoreFactory.getIndexService().count(IndexedDIP.class, dipsFilter, user, justActive);
    bundle.setDipCount(dipCount);

    return bundle;
  }

  public static BrowseRepresentationBundle retrieveBrowseRepresentationBundle(IndexedAIP aip,
    IndexedRepresentation representation, Locale locale)
    throws GenericException, RequestNotValidException, AuthorizationDeniedException {
    BrowseRepresentationBundle bundle = new BrowseRepresentationBundle();

    bundle.setAip(aip);
    bundle.setRepresentation(representation);

    // set aip ancestors
    try {
      List<IndexedAIP> ancestors = retrieveAncestors(aip, aipAncestorsFieldsToReturn);
      bundle.setAipAncestors(ancestors);
    } catch (NotFoundException e) {
      LOGGER.warn("Found an item with invalid ancestors: {}", aip.getId(), e);
    }

    // set representation desc. metadata
    try {
      bundle.setRepresentationDescriptiveMetadata(
        retrieveDescriptiveMetadataBundles(aip.getId(), representation.getId(), locale));
    } catch (NotFoundException e) {
      // do nothing
    }

    // Count DIPs
    Filter dipsFilter = new Filter(
      new SimpleFilterParameter(RodaConstants.DIP_REPRESENTATION_UUIDS, representation.getUUID()));
    Long dipCount = RodaCoreFactory.getIndexService().count(IndexedDIP.class, dipsFilter);
    bundle.setDipCount(dipCount);

    return bundle;
  }

  public static BrowseFileBundle retrieveBrowseFileBundle(IndexedAIP aip, IndexedRepresentation representation,
    IndexedFile file, User user) throws NotFoundException, GenericException, RequestNotValidException {
    BrowseFileBundle bundle = new BrowseFileBundle();

    bundle.setAip(aip);
    bundle.setRepresentation(representation);
    bundle.setFile(file);

    // set aip ancestors
    try {
      List<IndexedAIP> ancestors = retrieveAncestors(aip, aipAncestorsFieldsToReturn);
      bundle.setAipAncestors(ancestors);
    } catch (NotFoundException e) {
      LOGGER.warn("Found an item with invalid ancestors: {}", aip.getId(), e);
    }

    // set sibling count
    String parentUUID = bundle.getFile().getParentUUID();

    Filter siblingFilter = new Filter(
      new SimpleFilterParameter(RodaConstants.FILE_REPRESENTATION_UUID, bundle.getFile().getRepresentationUUID()));

    if (parentUUID != null) {
      siblingFilter.add(new SimpleFilterParameter(RodaConstants.FILE_PARENT_UUID, parentUUID));
    } else {
      siblingFilter.add(new EmptyKeyFilterParameter(RodaConstants.FILE_PARENT_UUID));
    }

    boolean justActive = AIPState.ACTIVE.equals(aip.getState());
    bundle.setTotalSiblingCount(count(IndexedFile.class, siblingFilter, justActive, user));

    // Count DIPs
    Filter dipsFilter = new Filter(new SimpleFilterParameter(RodaConstants.DIP_FILE_UUIDS, file.getUUID()));
    Long dipCount = RodaCoreFactory.getIndexService().count(IndexedDIP.class, dipsFilter);
    bundle.setDipCount(dipCount);
    return bundle;
  }

  private static List<DescriptiveMetadataViewBundle> retrieveDescriptiveMetadataBundles(String aipId, Locale locale)
    throws GenericException, RequestNotValidException, AuthorizationDeniedException, NotFoundException {
    return retrieveDescriptiveMetadataBundles(aipId, null, locale);
  }

  private static List<DescriptiveMetadataViewBundle> retrieveDescriptiveMetadataBundles(String aipId,
    String representationId, final Locale locale)
    throws GenericException, RequestNotValidException, AuthorizationDeniedException, NotFoundException {
    ModelService model = RodaCoreFactory.getModelService();
    List<DescriptiveMetadata> listDescriptiveMetadataBinaries;
    if (representationId != null) {
      listDescriptiveMetadataBinaries = model.retrieveRepresentation(aipId, representationId).getDescriptiveMetadata();
    } else {
      listDescriptiveMetadataBinaries = model.retrieveAIP(aipId).getDescriptiveMetadata();
    }
    List<DescriptiveMetadataViewBundle> descriptiveMetadataList = new ArrayList<>();

    // Can be null when the AIP is a ghost
    if (listDescriptiveMetadataBinaries != null) {
      for (DescriptiveMetadata descriptiveMetadata : listDescriptiveMetadataBinaries) {
        DescriptiveMetadataViewBundle bundle = retrieveDescriptiveMetadataBundle(aipId, representationId,
          descriptiveMetadata, locale);
        descriptiveMetadataList.add(bundle);
      }
    }

    return descriptiveMetadataList;
  }

  private static DescriptiveMetadataViewBundle retrieveDescriptiveMetadataBundle(String aipId, String representationId,
    DescriptiveMetadata descriptiveMetadata, final Locale locale)
    throws GenericException, RequestNotValidException, NotFoundException, AuthorizationDeniedException {
    ModelService model = RodaCoreFactory.getModelService();
    Messages messages = RodaCoreFactory.getI18NMessages(locale);
    DescriptiveMetadataViewBundle bundle = new DescriptiveMetadataViewBundle();
    bundle.setId(descriptiveMetadata.getId());

    if (descriptiveMetadata.getType() != null) {
      try {
        String labelWithoutVersion = messages.getTranslation(
          RodaConstants.I18N_UI_BROWSE_METADATA_DESCRIPTIVE_TYPE_PREFIX + descriptiveMetadata.getType().toLowerCase());
        if (descriptiveMetadata.getVersion() != null) {
          String labelWithVersion = messages.getTranslation(
            RodaConstants.I18N_UI_BROWSE_METADATA_DESCRIPTIVE_TYPE_PREFIX + descriptiveMetadata.getType().toLowerCase()
              + RodaConstants.METADATA_VERSION_SEPARATOR + descriptiveMetadata.getVersion().toLowerCase(),
            labelWithoutVersion);
          bundle.setLabel(labelWithVersion);
        } else {
          bundle.setLabel(labelWithoutVersion);
        }

      } catch (MissingResourceException e) {
        bundle.setLabel(descriptiveMetadata.getId());
      }
    }

    try {
      StoragePath storagePath;
      if (representationId != null) {
        storagePath = ModelUtils.getDescriptiveMetadataStoragePath(aipId, representationId,
          descriptiveMetadata.getId());
      } else {
        storagePath = ModelUtils.getDescriptiveMetadataStoragePath(aipId, descriptiveMetadata.getId());
      }

      bundle.setHasHistory(!CloseableIterables.isEmpty(model.getStorage().listBinaryVersions(storagePath)));

    } catch (RODAException | RuntimeException t) {
      bundle.setHasHistory(false);
    }
    return bundle;
  }

  private static DescriptiveMetadataViewBundle retrieveDescriptiveMetadataBundle(String aipId, String representationId,
    String descriptiveMetadataId, final Locale locale)
    throws GenericException, RequestNotValidException, NotFoundException, AuthorizationDeniedException {
    ModelService model = RodaCoreFactory.getModelService();
    DescriptiveMetadata descriptiveMetadata = model.retrieveDescriptiveMetadata(aipId, representationId,
      descriptiveMetadataId);
    return retrieveDescriptiveMetadataBundle(aipId, representationId, descriptiveMetadata, locale);
  }

  public static DescriptiveMetadataEditBundle retrieveDescriptiveMetadataEditBundle(User user, IndexedAIP aip,
    IndexedRepresentation representation, String descriptiveMetadataId, final Locale locale)
    throws GenericException, RequestNotValidException, NotFoundException, AuthorizationDeniedException {
    String representationId = representation != null ? representation.getId() : null;

    DescriptiveMetadata metadata = RodaCoreFactory.getModelService().retrieveDescriptiveMetadata(aip.getId(),
      representationId, descriptiveMetadataId);
    return retrieveDescriptiveMetadataEditBundle(user, aip, representation, descriptiveMetadataId, metadata.getType(),
      metadata.getVersion(), locale);
  }

  public static DescriptiveMetadataEditBundle retrieveDescriptiveMetadataEditBundle(User user, IndexedAIP aip,
    IndexedRepresentation representation, String descriptiveMetadataId, String type, String version,
    final Locale locale)
    throws GenericException, RequestNotValidException, NotFoundException, AuthorizationDeniedException {
    DescriptiveMetadataEditBundle ret;
    InputStream inputStream = null;
    try {
      String representationId = representation != null ? representation.getId() : null;
      Binary binary = RodaCoreFactory.getModelService().retrieveDescriptiveMetadataBinary(aip.getId(), representationId,
        descriptiveMetadataId);
      inputStream = binary.getContent().createInputStream();
      String xml = IOUtils.toString(inputStream, "UTF-8");

      // Get the supported metadata type with the same type and version
      // We need this to try to get get the values for the form
      SupportedMetadataTypeBundle metadataTypeBundle = null;
      List<SupportedMetadataTypeBundle> supportedMetadataTypeBundles = BrowserHelper.retrieveSupportedMetadata(user,
        aip, representation, locale);
      for (SupportedMetadataTypeBundle typeBundle : supportedMetadataTypeBundles) {
        if (typeBundle.getType() != null && typeBundle.getType().equalsIgnoreCase(type)) {
          if (typeBundle.getVersion() != null && typeBundle.getVersion().equalsIgnoreCase(version)) {
            metadataTypeBundle = typeBundle;
            break;
          }
        }
      }

      boolean similar = false;
      // Get the values using XPath
      Set<MetadataValue> values = null;
      String template = null;

      if (metadataTypeBundle != null) {
        values = metadataTypeBundle.getValues();
        template = metadataTypeBundle.getTemplate();
        if (values != null) {
          for (MetadataValue mv : values) {
            // clear the auto-generated values
            // mv.set("value", null);
            String xpathRaw = mv.get("xpath");
            if (xpathRaw != null && xpathRaw.length() > 0) {
              String[] xpaths = xpathRaw.split("##%##");
              String value;
              List<String> allValues = new ArrayList<>();
              for (String xpath : xpaths) {
                allValues.addAll(ServerTools.applyXpath(xml, xpath));
              }
              // if any of the values is different, concatenate all values in a
              // string, otherwise return the value
              boolean allEqual = allValues.stream().allMatch(s -> s.trim().equals(allValues.get(0).trim()));
              if (allEqual && !allValues.isEmpty()) {
                value = allValues.get(0);
              } else {
                value = String.join(" / ", allValues);
              }
              mv.set("value", value.trim());
            }
          }

          // Identity check. Test if the original XML is equal to the result of
          // applying the extracted values to the template
          metadataTypeBundle.setValues(values);
          String templateWithValues = retrieveDescriptiveMetadataPreview(metadataTypeBundle);
          try {
            XMLUnit.setIgnoreComments(true);
            XMLUnit.setIgnoreWhitespace(true);
            XMLUnit.setIgnoreAttributeOrder(true);
            XMLUnit.setCompareUnmatched(false);

            Diff xmlDiff = new Diff(xml, templateWithValues);
            xmlDiff.overrideDifferenceListener(new XMLSimilarityIgnoreElements("schemaLocation"));
            similar = xmlDiff.identical() || xmlDiff.similar();
          } catch (SAXException e) {
            LOGGER.warn("Could not check if template can loose info", e);
          }
        }
      }

      ret = new DescriptiveMetadataEditBundle(descriptiveMetadataId, type, version, xml, template, values, similar);
    } catch (IOException e) {
      throw new GenericException("Error getting descriptive metadata edit bundle: " + e.getMessage());
    } finally {
      IOUtils.closeQuietly(inputStream);
    }

    return ret;
  }

  public static DipBundle retrieveDipBundle(String dipUUID, String dipFileUUID, User user)
    throws GenericException, NotFoundException, RequestNotValidException {
    DipBundle bundle = new DipBundle();

    bundle
      .setDip(retrieve(IndexedDIP.class, dipUUID,
        Arrays.asList(RodaConstants.INDEX_UUID, RodaConstants.DIP_ID, RodaConstants.DIP_TITLE,
          RodaConstants.DIP_AIP_IDS, RodaConstants.DIP_AIP_UUIDS, RodaConstants.DIP_FILE_IDS,
          RodaConstants.DIP_REPRESENTATION_IDS)));

    List<String> dipFileFields = new ArrayList<>();

    if (dipFileUUID != null) {
      DIPFile dipFile = retrieve(DIPFile.class, dipFileUUID, dipFileFields);
      bundle.setDipFile(dipFile);

      List<DIPFile> dipFileAncestors = new ArrayList<>();
      for (String dipFileAncestor : dipFile.getAncestorsUUIDs()) {
        try {
          dipFileAncestors.add(retrieve(DIPFile.class, dipFileAncestor,
            Arrays.asList(RodaConstants.INDEX_UUID, RodaConstants.DIPFILE_DIP_ID, RodaConstants.DIPFILE_ID)));
        } catch (NotFoundException e) {
          // ignore
        }
      }
      bundle.setDipFileAncestors(dipFileAncestors);
    } else {
      // if there is only one DIPFile in the DIP and it is NOT a directory
      // then select it
      Filter filter = new Filter(new SimpleFilterParameter(RodaConstants.DIPFILE_DIP_ID, dipUUID));
      Sublist sublist = new Sublist(0, 1);
      IndexResult<DIPFile> dipFiles = find(DIPFile.class, filter, Sorter.NONE, sublist, Facets.NONE, user, false,
        dipFileFields);
      if (dipFiles.getTotalCount() == 1 && !dipFiles.getResults().get(0).isDirectory()) {
        bundle.setDipFile(dipFiles.getResults().get(0));
      }
    }

    List<String> aipFields = Arrays.asList(RodaConstants.INDEX_UUID, RodaConstants.AIP_TITLE, RodaConstants.AIP_LEVEL,
      RodaConstants.AIP_DATE_FINAL, RodaConstants.AIP_DATE_INITIAL, RodaConstants.AIP_GHOST);
    List<String> representationFields = Arrays.asList(RodaConstants.INDEX_UUID, RodaConstants.REPRESENTATION_TYPE,
      RodaConstants.REPRESENTATION_NUMBER_OF_DATA_FILES, RodaConstants.REPRESENTATION_ORIGINAL,
      RodaConstants.REPRESENTATION_AIP_ID, RodaConstants.REPRESENTATION_ID);
    List<String> fileFields = new ArrayList<>();

    // infer from DIP
    IndexedDIP dip = bundle.getDip();
    if (!dip.getFileIds().isEmpty()) {
      IndexedFile file = BrowserHelper.retrieve(IndexedFile.class, IdUtils.getFileId(dip.getFileIds().get(0)),
        fileFields);
      bundle.setFile(file);
      bundle.setRepresentation(
        BrowserHelper.retrieve(IndexedRepresentation.class, file.getRepresentationUUID(), representationFields));
      bundle.setAip(BrowserHelper.retrieve(IndexedAIP.class, file.getAipId(), aipFields));
    } else if (!dip.getRepresentationIds().isEmpty()) {
      IndexedRepresentation representation = BrowserHelper.retrieve(IndexedRepresentation.class,
        IdUtils.getRepresentationId(dip.getRepresentationIds().get(0)), representationFields);
      bundle.setRepresentation(representation);
      bundle.setAip(BrowserHelper.retrieve(IndexedAIP.class, representation.getAipId(), aipFields));
    } else if (!dip.getAipIds().isEmpty()) {
      IndexedAIP aip = BrowserHelper.retrieve(IndexedAIP.class, dip.getAipIds().get(0).getAipId(), aipFields);
      bundle.setAip(aip);
    }

    return bundle;
  }

  protected static List<IndexedAIP> retrieveAncestors(IndexedAIP aip, List<String> fieldsToReturn)
    throws GenericException, NotFoundException {
    return RodaCoreFactory.getIndexService().retrieveAncestors(aip, fieldsToReturn);
  }

  protected static <T extends IsIndexed> IndexResult<T> find(Class<T> returnClass, Filter filter, Sorter sorter,
    Sublist sublist, Facets facets, User user, boolean justActive, List<String> fieldsToReturn)
    throws GenericException, RequestNotValidException {
    return RodaCoreFactory.getIndexService().find(returnClass, filter, sorter, sublist, facets, user, justActive,
      fieldsToReturn);
  }

  protected static <T extends IsIndexed> IterableIndexResult<T> findAll(final Class<T> returnClass, final Filter filter,
    final Sorter sorter, final Sublist sublist, final Facets facets, final User user, final boolean justActive,
    List<String> fieldsToReturn) {
    return RodaCoreFactory.getIndexService().findAll(returnClass, filter, sorter, sublist, facets, user, justActive,
      fieldsToReturn);
  }

  protected static <T extends IsIndexed> Long count(Class<T> returnClass, Filter filter, boolean justActive, User user)
    throws GenericException, RequestNotValidException {
    return RodaCoreFactory.getIndexService().count(returnClass, filter, user, justActive);
  }

  protected static <T extends IsIndexed> T retrieve(Class<T> returnClass, String id, List<String> fieldsToReturn)
    throws GenericException, NotFoundException {
    return RodaCoreFactory.getIndexService().retrieve(returnClass, id, fieldsToReturn);
  }

  protected static <T extends IsIndexed> void commit(Class<T> returnClass) throws GenericException, NotFoundException {
    RodaCoreFactory.getIndexService().commit(returnClass);
  }

  protected static <T extends IsIndexed> List<T> retrieve(Class<T> returnClass, SelectedItems<T> selectedItems,
    List<String> fieldsToReturn) throws GenericException, NotFoundException, RequestNotValidException {
    List<T> ret;

    if (selectedItems instanceof SelectedItemsList) {
      SelectedItemsList<T> selectedList = (SelectedItemsList<T>) selectedItems;
      ret = RodaCoreFactory.getIndexService().retrieve(returnClass, selectedList.getIds(), fieldsToReturn);
    } else if (selectedItems instanceof SelectedItemsFilter) {
      SelectedItemsFilter<T> selectedFilter = (SelectedItemsFilter<T>) selectedItems;
      int counter = RodaCoreFactory.getIndexService().count(returnClass, selectedFilter.getFilter()).intValue();
      ret = RodaCoreFactory.getIndexService()
        .find(returnClass, selectedFilter.getFilter(), Sorter.NONE, new Sublist(0, counter), fieldsToReturn)
        .getResults();
    } else {
      throw new RequestNotValidException(
        "Unsupported SelectedItems implementation: " + selectedItems.getClass().getName());
    }

    return ret;
  }

  protected static <T extends IsIndexed> List<String> suggest(Class<T> returnClass, String field, String query,
    User user, boolean allowPartial) throws GenericException, NotFoundException {
    boolean justActive = true;
    return RodaCoreFactory.getIndexService().suggest(returnClass, field, query, user, allowPartial, justActive);
  }

  public static void validateGetFileParams(String acceptFormat) throws RequestNotValidException {
    if (!RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_BIN.equals(acceptFormat)
      && !RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_JSON.equals(acceptFormat)
      && !RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_XML.equals(acceptFormat)) {
      throw new RequestNotValidException("Invalid '" + RodaConstants.API_QUERY_KEY_ACCEPT_FORMAT
        + "' value. Expected values: " + Arrays.asList(RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_XML,
          RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_JSON, RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_BIN));
    }
  }

  protected static void validateGetAIPRepresentationParams(String acceptFormat) throws RequestNotValidException {
    if (!RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_ZIP.equals(acceptFormat)
      && !RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_JSON.equals(acceptFormat)
      && !RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_XML.equals(acceptFormat)) {
      throw new RequestNotValidException("Invalid '" + RodaConstants.API_QUERY_KEY_ACCEPT_FORMAT
        + "' value. Expected values: " + Arrays.asList(RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_JSON,
          RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_XML, RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_ZIP));
    }
  }

  protected static void validateGetDIPParams(String acceptFormat) throws RequestNotValidException {
    if (!RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_ZIP.equals(acceptFormat)
      && !RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_JSON.equals(acceptFormat)
      && !RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_XML.equals(acceptFormat)) {
      throw new RequestNotValidException("Invalid '" + RodaConstants.API_QUERY_KEY_ACCEPT_FORMAT
        + "' value. Expected values: " + Arrays.asList(RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_JSON,
          RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_XML, RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_ZIP));
    }
  }

  protected static EntityResponse retrieveAIPRepresentation(IndexedRepresentation representation, String acceptFormat)
    throws GenericException, RequestNotValidException, NotFoundException, AuthorizationDeniedException {

    String aipId = representation.getAipId();
    String representationId = representation.getId();

    if (RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_ZIP.equals(acceptFormat)) {
      StoragePath storagePath = ModelUtils.getRepresentationStoragePath(representation.getAipId(),
        representation.getId());
      Directory directory = RodaCoreFactory.getStorageService().getDirectory(storagePath);
      return ApiUtils.download(directory, representationId);
    } else if (RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_JSON.equals(acceptFormat)
      || RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_XML.equals(acceptFormat)) {
      ModelService model = RodaCoreFactory.getModelService();
      Representation rep = model.retrieveRepresentation(aipId, representationId);
      return new ObjectResponse<Representation>(acceptFormat, rep);
    } else {
      throw new GenericException("Unsupported accept format: " + acceptFormat);
    }
  }

  public static StreamResponse retrieveAIPRepresentationPart(IndexedRepresentation representation, String part)
    throws RequestNotValidException, NotFoundException, GenericException, AuthorizationDeniedException {
    String aipId = representation.getAipId();
    String representationId = representation.getId();

    if (RodaConstants.STORAGE_DIRECTORY_DATA.equals(part)) {
      StoragePath storagePath = ModelUtils.getRepresentationDataStoragePath(aipId, representationId);
      Directory directory = RodaCoreFactory.getStorageService().getDirectory(storagePath);
      return ApiUtils.download(directory, part);
    } else if (RodaConstants.STORAGE_DIRECTORY_METADATA.equals(part)) {
      StoragePath storagePath = ModelUtils.getRepresentationMetadataStoragePath(aipId, representationId);
      Directory directory = RodaCoreFactory.getStorageService().getDirectory(storagePath);
      return ApiUtils.download(directory, part);
    } else if (RodaConstants.STORAGE_DIRECTORY_DOCUMENTATION.equals(part)) {
      Directory directory = RodaCoreFactory.getModelService().getDocumentationDirectory(aipId, representationId);
      return ApiUtils.download(directory, part);
    } else if (RodaConstants.STORAGE_DIRECTORY_SCHEMAS.equals(part)) {
      Directory directory = RodaCoreFactory.getModelService().getSchemasDirectory(aipId, representationId);
      return ApiUtils.download(directory, part);
    } else {
      throw new GenericException("Unsupported part: " + part);
    }
  }

  protected static void validateListAIPDescriptiveMetadataParams(String acceptFormat) throws RequestNotValidException {
    if (!RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_ZIP.equals(acceptFormat)
      && !RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_JSON.equals(acceptFormat)
      && !RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_XML.equals(acceptFormat)) {
      throw new RequestNotValidException("Invalid '" + RodaConstants.API_QUERY_KEY_ACCEPT_FORMAT
        + "' value. Expected values: " + Arrays.asList(RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_ZIP,
          RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_JSON, RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_XML));
    }
  }

  public static void validateGetOtherMetadataParams(String acceptFormat) throws RequestNotValidException {
    if (!RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_BIN.equals(acceptFormat)
      && !RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_JSON.equals(acceptFormat)
      && !RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_XML.equals(acceptFormat)) {
      throw new RequestNotValidException("Invalid '" + RodaConstants.API_QUERY_KEY_ACCEPT_FORMAT
        + "' value. Expected values: " + Arrays.asList(RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_XML,
          RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_JSON, RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_BIN));
    }
  }

  protected static EntityResponse listAIPDescriptiveMetadata(String aipId, String start, String limit,
    String acceptFormat)
    throws RequestNotValidException, NotFoundException, GenericException, AuthorizationDeniedException {
    ModelService model = RodaCoreFactory.getModelService();
    AIP aip = model.retrieveAIP(aipId);
    List<DescriptiveMetadata> metadata = aip.getDescriptiveMetadata();
    return listDescriptiveMetadata(metadata, aipId, start, limit, acceptFormat);
  }

  protected static EntityResponse listRepresentationDescriptiveMetadata(String aipId, String representationId,
    String start, String limit, String acceptFormat)
    throws RequestNotValidException, NotFoundException, GenericException, AuthorizationDeniedException {
    ModelService model = RodaCoreFactory.getModelService();
    Representation representation = model.retrieveRepresentation(aipId, representationId);
    List<DescriptiveMetadata> metadata = representation.getDescriptiveMetadata();
    return listDescriptiveMetadata(metadata, aipId, start, limit, acceptFormat);
  }

  private static EntityResponse listDescriptiveMetadata(List<DescriptiveMetadata> metadata, String aipId, String start,
    String limit, String acceptFormat)
    throws RequestNotValidException, GenericException, NotFoundException, AuthorizationDeniedException {
    StorageService storage = RodaCoreFactory.getStorageService();
    Pair<Integer, Integer> pagingParams = ApiUtils.processPagingParams(start, limit);
    int startInt = pagingParams.getFirst();
    int limitInt = pagingParams.getSecond();
    int counter = 0;

    if (RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_ZIP.equals(acceptFormat)) {
      List<ZipEntryInfo> zipEntries = new ArrayList<>();
      for (DescriptiveMetadata dm : metadata) {
        if (counter >= startInt && (counter <= limitInt || limitInt == -1)) {
          StoragePath storagePath = ModelUtils.getDescriptiveMetadataStoragePath(aipId, dm.getId());
          Binary binary = storage.getBinary(storagePath);
          ZipEntryInfo info = new ZipEntryInfo(storagePath.getName(), binary.getContent());
          zipEntries.add(info);
        } else {
          break;
        }
        counter++;
      }

      return DownloadUtils.createZipStreamResponse(zipEntries, aipId);
    } else if (RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_JSON.equals(acceptFormat)
      || RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_XML.equals(acceptFormat)) {
      int endInt = limitInt == -1 ? metadata.size() : (limitInt > metadata.size() ? metadata.size() : limitInt);
      DescriptiveMetadataList list = new DescriptiveMetadataList(metadata.subList(startInt, endInt));
      return new ObjectResponse<DescriptiveMetadataList>(acceptFormat, list);
    }

    return null;
  }

  protected static void validateGetPreservationMetadataParams(String acceptFormat) throws RequestNotValidException {
    if (!RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_XML.equals(acceptFormat)
      && !RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_HTML.equals(acceptFormat)
      && !RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_JSON.equals(acceptFormat)
      && !RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_BIN.equals(acceptFormat)) {
      throw new RequestNotValidException(
        "Invalid '" + RodaConstants.API_QUERY_KEY_ACCEPT_FORMAT + "' value. Expected values: "
          + Arrays.asList(RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_XML,
            RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_HTML, RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_JSON,
            RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_BIN));
    }
  }

  protected static void validateGetAIPDescriptiveMetadataParams(String acceptFormat) throws RequestNotValidException {
    if (!RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_XML.equals(acceptFormat)
      && !RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_HTML.equals(acceptFormat)
      && !RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_JSON.equals(acceptFormat)
      && !RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_BIN.equals(acceptFormat)) {
      throw new RequestNotValidException(
        "Invalid '" + RodaConstants.API_QUERY_KEY_ACCEPT_FORMAT + "' value. Expected values: "
          + Arrays.asList(RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_XML,
            RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_HTML, RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_JSON,
            RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_BIN));
    }
  }

  public static EntityResponse retrieveAIPDescritiveMetadata(String aipId, String metadataId, String acceptFormat,
    String language)
    throws GenericException, RequestNotValidException, NotFoundException, AuthorizationDeniedException {

    final String filename;
    final String mediaType;
    final ConsumesOutputStream stream;
    StreamResponse ret;
    ModelService model = RodaCoreFactory.getModelService();

    if (RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_BIN.equals(acceptFormat)) {
      Binary descriptiveMetadataBinary = model.retrieveDescriptiveMetadataBinary(aipId, metadataId);
      filename = descriptiveMetadataBinary.getStoragePath().getName();
      mediaType = RodaConstants.MEDIA_TYPE_TEXT_XML;
      stream = new ConsumesOutputStream() {

        @Override
        public String getMediaType() {
          return mediaType;
        }

        @Override
        public String getFileName() {
          return filename;
        }

        @Override
        public void consumeOutputStream(OutputStream out) throws IOException {
          IOUtils.copy(descriptiveMetadataBinary.getContent().createInputStream(), out);
        }
      };
      ret = new StreamResponse(filename, mediaType, stream);

    } else if (RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_HTML.equals(acceptFormat)) {
      Binary descriptiveMetadataBinary = model.retrieveDescriptiveMetadataBinary(aipId, metadataId);
      filename = descriptiveMetadataBinary.getStoragePath().getName() + HTML_EXT;
      DescriptiveMetadata descriptiveMetadata = model.retrieveDescriptiveMetadata(aipId, metadataId);
      mediaType = RodaConstants.MEDIA_TYPE_TEXT_HTML;
      String htmlDescriptive = HTMLUtils.descriptiveMetadataToHtml(descriptiveMetadataBinary,
        descriptiveMetadata.getType(), descriptiveMetadata.getVersion(), ServerTools.parseLocale(language));
      stream = new ConsumesOutputStream() {

        @Override
        public String getMediaType() {
          return mediaType;
        }

        @Override
        public String getFileName() {
          return filename;
        }

        @Override
        public void consumeOutputStream(OutputStream out) throws IOException {
          PrintStream printStream = new PrintStream(out);
          printStream.print(htmlDescriptive);
          printStream.close();
        }
      };
      ret = new StreamResponse(filename, mediaType, stream);

    } else if (RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_JSON.equals(acceptFormat)
      || RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_XML.equals(acceptFormat)) {

      AIP aip = model.retrieveAIP(aipId);
      List<DescriptiveMetadata> resultList = aip.getDescriptiveMetadata().stream()
        .filter(dm -> dm.getId().equals(metadataId)).collect(Collectors.toList());

      return new ObjectResponse<DescriptiveMetadata>(acceptFormat, resultList.get(0));

    } else {
      throw new GenericException("Unsupported accept format: " + acceptFormat);
    }

    return ret;
  }

  public static EntityResponse retrieveRepresentationDescriptiveMetadata(String aipId, String representationId,
    String metadataId, String acceptFormat, String language)
    throws GenericException, RequestNotValidException, NotFoundException, AuthorizationDeniedException {

    final String filename;
    final String mediaType;
    final ConsumesOutputStream stream;
    StreamResponse ret;
    ModelService model = RodaCoreFactory.getModelService();

    if (RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_BIN.equals(acceptFormat)) {
      Binary descriptiveMetadataBinary = model.retrieveDescriptiveMetadataBinary(aipId, representationId, metadataId);
      filename = descriptiveMetadataBinary.getStoragePath().getName();
      mediaType = RodaConstants.MEDIA_TYPE_TEXT_XML;

      stream = new ConsumesOutputStream() {

        @Override
        public String getMediaType() {
          return mediaType;
        }

        @Override
        public String getFileName() {
          return filename;
        }

        @Override
        public void consumeOutputStream(OutputStream out) throws IOException {
          IOUtils.copy(descriptiveMetadataBinary.getContent().createInputStream(), out);
        }
      };

      ret = new StreamResponse(filename, mediaType, stream);

    } else if (RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_HTML.equals(acceptFormat)) {
      Binary descriptiveMetadataBinary = model.retrieveDescriptiveMetadataBinary(aipId, representationId, metadataId);
      filename = descriptiveMetadataBinary.getStoragePath().getName() + HTML_EXT;
      DescriptiveMetadata descriptiveMetadata = model.retrieveDescriptiveMetadata(aipId, representationId, metadataId);
      mediaType = RodaConstants.MEDIA_TYPE_TEXT_HTML;
      String htmlDescriptive = HTMLUtils.descriptiveMetadataToHtml(descriptiveMetadataBinary,
        descriptiveMetadata.getType(), descriptiveMetadata.getVersion(), ServerTools.parseLocale(language));

      stream = new ConsumesOutputStream() {

        @Override
        public String getMediaType() {
          return mediaType;
        }

        @Override
        public String getFileName() {
          return filename;
        }

        @Override
        public void consumeOutputStream(OutputStream out) throws IOException {
          PrintStream printStream = new PrintStream(out);
          printStream.print(htmlDescriptive);
          printStream.close();
        }
      };

      ret = new StreamResponse(filename, mediaType, stream);

    } else if (RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_JSON.equals(acceptFormat)
      || RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_XML.equals(acceptFormat)) {

      Representation representation = model.retrieveRepresentation(aipId, representationId);
      List<DescriptiveMetadata> resultList = representation.getDescriptiveMetadata().stream()
        .filter(dm -> dm.getId().equals(metadataId)).collect(Collectors.toList());

      return new ObjectResponse<DescriptiveMetadata>(acceptFormat, resultList.get(0));

    } else {
      throw new GenericException("Unsupported accept format: " + acceptFormat);
    }

    return ret;
  }

  public static EntityResponse retrieveAIPDescritiveMetadataVersion(String aipId, String metadataId, String versionId,
    String acceptFormat, String language)
    throws GenericException, RequestNotValidException, NotFoundException, AuthorizationDeniedException {

    final String filename;
    final String mediaType;
    final ConsumesOutputStream stream;

    ModelService model = RodaCoreFactory.getModelService();

    StoragePath storagePath = ModelUtils.getDescriptiveMetadataStoragePath(aipId, metadataId);
    BinaryVersion binaryVersion = model.getStorage().getBinaryVersion(storagePath, versionId);
    Binary binary = binaryVersion.getBinary();

    String fileName = binary.getStoragePath().getName();
    if (RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_BIN.equals(acceptFormat)) {
      mediaType = RodaConstants.MEDIA_TYPE_TEXT_XML;

      stream = new ConsumesOutputStream() {

        @Override
        public String getMediaType() {
          return mediaType;
        }

        @Override
        public String getFileName() {
          return fileName;
        }

        @Override
        public void consumeOutputStream(OutputStream out) throws IOException {
          IOUtils.copy(binary.getContent().createInputStream(), out);
        }
      };
      return new StreamResponse(fileName, mediaType, stream);

    } else if (RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_HTML.equals(acceptFormat)) {
      filename = fileName + HTML_EXT;
      DescriptiveMetadata descriptiveMetadata = model.retrieveDescriptiveMetadata(aipId, metadataId);
      mediaType = RodaConstants.MEDIA_TYPE_TEXT_HTML;
      String htmlDescriptive = HTMLUtils.descriptiveMetadataToHtml(binary, descriptiveMetadata.getType(),
        descriptiveMetadata.getVersion(), ServerTools.parseLocale(language));

      stream = new ConsumesOutputStream() {

        @Override
        public String getMediaType() {
          return mediaType;
        }

        @Override
        public String getFileName() {
          return filename;
        }

        @Override
        public void consumeOutputStream(OutputStream out) throws IOException {
          PrintStream printStream = new PrintStream(out);
          printStream.print(htmlDescriptive);
          printStream.close();
        }
      };

      return new StreamResponse(filename, mediaType, stream);
    } else if (RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_JSON.equals(acceptFormat)
      || RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_XML.equals(acceptFormat)) {

      AIP aip = model.retrieveAIP(aipId);
      List<DescriptiveMetadata> resultList = aip.getDescriptiveMetadata().stream()
        .filter(dm -> dm.getId().equals(metadataId)).collect(Collectors.toList());

      return new ObjectResponse<DescriptiveMetadata>(acceptFormat, resultList.get(0));

    } else {
      throw new GenericException("Unsupported accept format: " + acceptFormat);
    }
  }

  public static EntityResponse retrieveRepresentationDescriptiveMetadataVersion(String aipId, String representationId,
    String metadataId, String versionId, String acceptFormat, String language)
    throws GenericException, RequestNotValidException, NotFoundException, AuthorizationDeniedException {

    final String filename;
    final String mediaType;
    final ConsumesOutputStream stream;

    ModelService model = RodaCoreFactory.getModelService();

    StoragePath storagePath = ModelUtils.getDescriptiveMetadataStoragePath(aipId, representationId, metadataId);
    BinaryVersion binaryVersion = model.getStorage().getBinaryVersion(storagePath, versionId);
    Binary binary = binaryVersion.getBinary();

    String fileName = binary.getStoragePath().getName();
    if (RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_BIN.equals(acceptFormat)) {
      mediaType = RodaConstants.MEDIA_TYPE_TEXT_XML;

      stream = new ConsumesOutputStream() {

        @Override
        public String getMediaType() {
          return mediaType;
        }

        @Override
        public String getFileName() {
          return binary.getStoragePath().getName();
        }

        @Override
        public void consumeOutputStream(OutputStream out) throws IOException {
          IOUtils.copy(binary.getContent().createInputStream(), out);
        }
      };

      return new StreamResponse(fileName, mediaType, stream);

    } else if (RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_HTML.equals(acceptFormat)) {
      filename = fileName + HTML_EXT;
      DescriptiveMetadata descriptiveMetadata = model.retrieveDescriptiveMetadata(aipId, representationId, metadataId);
      mediaType = RodaConstants.MEDIA_TYPE_TEXT_HTML;
      String htmlDescriptive = HTMLUtils.descriptiveMetadataToHtml(binary, descriptiveMetadata.getType(),
        descriptiveMetadata.getVersion(), ServerTools.parseLocale(language));

      stream = new ConsumesOutputStream() {

        @Override
        public String getMediaType() {
          return mediaType;
        }

        @Override
        public String getFileName() {
          return fileName + HTML_EXT;
        }

        @Override
        public void consumeOutputStream(OutputStream out) throws IOException {
          PrintStream printStream = new PrintStream(out);
          printStream.print(htmlDescriptive);
          printStream.close();
        }
      };

      return new StreamResponse(filename, mediaType, stream);
    } else if (RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_JSON.equals(acceptFormat)
      || RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_XML.equals(acceptFormat)) {

      AIP aip = model.retrieveAIP(aipId);
      List<DescriptiveMetadata> resultList = new ArrayList<>();

      for (Representation representation : aip.getRepresentations()) {
        if (representation.getId().equals(representationId)) {
          resultList = representation.getDescriptiveMetadata().stream().filter(dm -> dm.getId().equals(metadataId))
            .collect(Collectors.toList());
        }
      }

      return new ObjectResponse<DescriptiveMetadata>(acceptFormat, resultList.get(0));

    } else {
      throw new GenericException("Unsupported accept format: " + acceptFormat);
    }
  }

  protected static void validateListAIPMetadataParams(String acceptFormat) throws RequestNotValidException {
    if (!RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_ZIP.equals(acceptFormat)
      && !RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_JSON.equals(acceptFormat)
      && !RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_XML.equals(acceptFormat)) {
      throw new RequestNotValidException("Invalid '" + RodaConstants.API_QUERY_KEY_ACCEPT_FORMAT
        + "' value. Expected values: " + Arrays.asList(RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_ZIP,
          RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_JSON, RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_XML));
    }
  }

  public static EntityResponse listAIPPreservationMetadata(String aipId, String acceptFormat)
    throws GenericException, NotFoundException, RequestNotValidException, AuthorizationDeniedException {

    if (RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_ZIP.equals(acceptFormat)) {
      CloseableIterable<OptionalWithCause<PreservationMetadata>> preservationFiles = RodaCoreFactory.getModelService()
        .listPreservationMetadata(aipId, true);
      StorageService storage = RodaCoreFactory.getStorageService();
      List<ZipEntryInfo> zipEntries = new ArrayList<>();
      Map<String, ZipEntryInfo> agents = new HashMap<>();

      for (OptionalWithCause<PreservationMetadata> oPreservationFile : preservationFiles) {
        if (oPreservationFile.isPresent()) {
          PreservationMetadata preservationFile = oPreservationFile.get();
          StoragePath storagePath = ModelUtils.getPreservationMetadataStoragePath(preservationFile);
          Binary binary = storage.getBinary(storagePath);

          ZipEntryInfo info = new ZipEntryInfo(FSUtils.getStoragePathAsString(storagePath, true), binary.getContent());
          zipEntries.add(info);

          if (preservationFile.getType() == PreservationMetadataType.EVENT) {
            try {
              List<LinkingIdentifier> agentIDS = PremisV3Utils.extractAgentsFromEvent(binary);
              if (!agentIDS.isEmpty()) {
                for (LinkingIdentifier li : agentIDS) {
                  String agentID = li.getValue();
                  if (!agents.containsKey(agentID)) {
                    StoragePath agentPath = ModelUtils.getPreservationMetadataStoragePath(agentID,
                      PreservationMetadataType.AGENT);
                    Binary agentBinary = storage.getBinary(agentPath);
                    info = new ZipEntryInfo(
                      FSUtils.getStoragePathAsString(DefaultStoragePath.parse(preservationFile.getAipId()), false,
                        agentPath, true),
                      agentBinary.getContent());
                    agents.put(agentID, info);
                  }
                }
              }
            } catch (ValidationException | GenericException e) {
              // do nothing
            }
          }

        } else {
          LOGGER.error("Cannot get AIP preservation metadata", oPreservationFile.getCause());
        }
      }

      if (agents.size() > 0) {
        for (Map.Entry<String, ZipEntryInfo> entry : agents.entrySet()) {
          zipEntries.add(entry.getValue());
        }
      }

      IOUtils.closeQuietly(preservationFiles);
      return DownloadUtils.createZipStreamResponse(zipEntries, aipId);
    } else if (RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_JSON.equals(acceptFormat)
      || RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_XML.equals(acceptFormat)) {
      CloseableIterable<OptionalWithCause<PreservationMetadata>> preservationFiles = RodaCoreFactory.getModelService()
        .listPreservationMetadata(aipId, true);
      PreservationMetadataList metadataList = new PreservationMetadataList();

      for (OptionalWithCause<PreservationMetadata> oPreservationFile : preservationFiles) {
        if (oPreservationFile.isPresent()) {
          metadataList.addObject(oPreservationFile.get());
        }
      }

      IOUtils.closeQuietly(preservationFiles);
      return new ObjectResponse<PreservationMetadataList>(acceptFormat, metadataList);
    } else {
      throw new GenericException("Unsupported accept format: " + acceptFormat);
    }
  }

  protected static void validateGetAIPRepresentationPreservationMetadataParams(String acceptFormat)
    throws RequestNotValidException {
    if (!RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_ZIP.equals(acceptFormat)
      && !RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_JSON.equals(acceptFormat)
      && !RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_XML.equals(acceptFormat)) {
      throw new RequestNotValidException("Invalid '" + RodaConstants.API_QUERY_KEY_ACCEPT_FORMAT
        + "' value. Expected values: " + Arrays.asList(RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_ZIP,
          RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_JSON, RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_XML));
    }
  }

  private static EntityResponse getAIPRepresentationPreservationMetadataEntityResponse(String aipId,
    String representationId, String startAgent, String limitAgent, String startEvent, String limitEvent,
    String startFile, String limitFile, String acceptFormat,
    CloseableIterable<OptionalWithCause<PreservationMetadata>> preservationFiles)
    throws GenericException, RequestNotValidException, NotFoundException, AuthorizationDeniedException, IOException {
    Pair<Integer, Integer> pagingParamsAgent = ApiUtils.processPagingParams(startAgent, limitAgent);
    int counterAgent = 0;
    Pair<Integer, Integer> pagingParamsEvent = ApiUtils.processPagingParams(startEvent, limitEvent);
    int counterEvent = 0;
    Pair<Integer, Integer> pagingParamsFile = ApiUtils.processPagingParams(startFile, limitFile);
    int counterFile = 0;

    List<ZipEntryInfo> zipEntries = new ArrayList<>();
    PreservationMetadataList pms = new PreservationMetadataList();

    for (OptionalWithCause<PreservationMetadata> oPreservationFile : preservationFiles) {
      if (oPreservationFile.isPresent()) {
        PreservationMetadata preservationFile = oPreservationFile.get();
        boolean add = false;

        if (preservationFile.getType().equals(PreservationMetadataType.AGENT)) {
          if (counterAgent >= pagingParamsAgent.getFirst()
            && (counterAgent <= pagingParamsAgent.getSecond() || pagingParamsAgent.getSecond() == -1)) {
            add = true;
          }
          counterAgent++;
        } else if (preservationFile.getType().equals(PreservationMetadataType.EVENT)) {
          if (counterEvent >= pagingParamsEvent.getFirst()
            && (counterEvent <= pagingParamsEvent.getSecond() || pagingParamsEvent.getSecond() == -1)) {
            add = true;
          }
          counterEvent++;
        } else if (preservationFile.getType().equals(PreservationMetadataType.FILE)) {
          if (counterFile >= pagingParamsFile.getFirst()
            && (counterFile <= pagingParamsFile.getSecond() || pagingParamsFile.getSecond() == -1)) {
            add = true;
          }
          counterFile++;
        }

        if (add) {
          if (RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_ZIP.equals(acceptFormat)) {
            StoragePath storagePath = ModelUtils.getPreservationMetadataStoragePath(preservationFile);
            Binary binary = RodaCoreFactory.getStorageService().getBinary(storagePath);
            ZipEntryInfo info = new ZipEntryInfo(storagePath.getName(), binary.getContent());
            zipEntries.add(info);
          } else {
            pms.addObject(preservationFile);
          }
        }
      } else {
        LOGGER.error("Cannot get AIP preservation metadata", oPreservationFile.getCause());
      }
    }

    IOUtils.closeQuietly(preservationFiles);
    if (RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_ZIP.equals(acceptFormat)) {
      return DownloadUtils.createZipStreamResponse(zipEntries, aipId + "_" + representationId);
    } else {
      return new ObjectResponse<PreservationMetadataList>(acceptFormat, pms);
    }
  }

  public static EntityResponse retrieveAIPRepresentationPreservationMetadata(String aipId, String representationId,
    String startAgent, String limitAgent, String startEvent, String limitEvent, String startFile, String limitFile,
    String acceptFormat)
    throws GenericException, NotFoundException, RequestNotValidException, AuthorizationDeniedException, IOException {

    if (RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_ZIP.equals(acceptFormat)
      || RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_JSON.equals(acceptFormat)
      || RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_XML.equals(acceptFormat)) {
      CloseableIterable<OptionalWithCause<PreservationMetadata>> preservationFiles = RodaCoreFactory.getModelService()
        .listPreservationMetadata(aipId, representationId);
      return getAIPRepresentationPreservationMetadataEntityResponse(aipId, representationId, startAgent, limitAgent,
        startEvent, limitEvent, startFile, limitFile, acceptFormat, preservationFiles);
    } else {
      throw new GenericException("Unsupported accept format: " + acceptFormat);
    }
  }

  public static EntityResponse retrieveAIPRepresentationPreservationMetadataFile(String aipId, String representationId,
    List<String> filePath, String fileId, String acceptFormat)
    throws NotFoundException, GenericException, RequestNotValidException, AuthorizationDeniedException {
    ModelService model = RodaCoreFactory.getModelService();

    if (RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_ZIP.equals(acceptFormat)) {
      Binary binary = model.retrievePreservationRepresentation(aipId, representationId, filePath, fileId);
      String filename = binary.getStoragePath().getName();

      ConsumesOutputStream stream = new ConsumesOutputStream() {

        @Override
        public String getMediaType() {
          return acceptFormat;
        }

        @Override
        public String getFileName() {
          return filename;
        }

        @Override
        public void consumeOutputStream(OutputStream out) throws IOException {
          IOUtils.copy(binary.getContent().createInputStream(), out);
        }
      };
      return new StreamResponse(filename, RodaConstants.MEDIA_TYPE_APPLICATION_OCTET_STREAM, stream);
    } else if (RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_JSON.equals(acceptFormat)
      || RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_XML.equals(acceptFormat)) {
      PreservationMetadataType type = PreservationMetadataType.REPRESENTATION;
      if (fileId != null) {
        type = PreservationMetadataType.FILE;
      }
      PreservationMetadata pm = model.retrievePreservationMetadata(aipId, representationId, filePath, fileId, type);
      return new ObjectResponse<PreservationMetadata>(acceptFormat, pm);
    } else {
      throw new GenericException("Unsupported accept format: " + acceptFormat);
    }
  }

  public static void createOrUpdateAIPRepresentationPreservationMetadataFile(String aipId, String representationId,
    List<String> fileDirectoryPath, String fileId, InputStream is, boolean create)
    throws GenericException, RequestNotValidException, NotFoundException, AuthorizationDeniedException,
    ValidationException, AlreadyExistsException {
    Path file = null;
    try {
      ModelService model = RodaCoreFactory.getModelService();
      file = Files.createTempFile("preservation", ".tmp");
      Files.copy(is, file, StandardCopyOption.REPLACE_EXISTING);
      ContentPayload payload = new FSPathContentPayload(file);
      boolean notify = true;
      if (create) {
        model.createPreservationMetadata(PreservationMetadataType.FILE, aipId, representationId, fileDirectoryPath,
          fileId, payload, notify);
      } else {
        PreservationMetadataType type = PreservationMetadataType.FILE;
        String id = IdUtils.getPreservationFileId(fileId);
        model.updatePreservationMetadata(id, type, aipId, representationId, fileDirectoryPath, fileId, payload, notify);
      }
    } catch (IOException e) {
      throw new GenericException("Error creating or updating AIP representation preservation metadata file", e);
    } finally {
      if (FSUtils.exists(file)) {
        try {
          Files.delete(file);
        } catch (IOException e) {
          LOGGER.warn("Error while deleting temporary file", e);
        }
      }
    }
  }

  public static void deletePreservationMetadataFile(PreservationMetadataType type, String aipId,
    String representationId, String id, boolean notify)
    throws RequestNotValidException, NotFoundException, GenericException, AuthorizationDeniedException {
    RodaCoreFactory.getModelService().deletePreservationMetadata(type, aipId, representationId, id, notify);
  }

  public static EntityResponse retrievePreservationMetadataEvent(String id, String aipId, String representationUUID,
    String fileUUID, boolean onlyDetails, String acceptFormat, String language)
    throws NotFoundException, GenericException, RequestNotValidException, AuthorizationDeniedException {
    ModelService model = RodaCoreFactory.getModelService();
    IndexService index = RodaCoreFactory.getIndexService();
    String representationId = null;
    List<String> filePath = null;
    String fileId = null;

    if (fileUUID != null) {
      IndexedFile file = index.retrieve(IndexedFile.class, fileUUID, RodaConstants.FILE_FIELDS_TO_RETURN);
      representationId = file.getRepresentationId();
      filePath = file.getPath();
      fileId = file.getId();
    } else if (representationUUID != null) {
      IndexedRepresentation rep = index.retrieve(IndexedRepresentation.class, representationUUID,
        Arrays.asList(RodaConstants.REPRESENTATION_ID));
      representationId = rep.getId();
    }

    if (RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_BIN.equals(acceptFormat)) {
      final Binary binary = model.retrievePreservationEvent(aipId, representationId, filePath, fileId, id);
      final String mediaType = RodaConstants.MEDIA_TYPE_TEXT_XML;

      final ConsumesOutputStream stream = new ConsumesOutputStream() {

        @Override
        public String getMediaType() {
          return mediaType;
        }

        @Override
        public String getFileName() {
          return binary.getStoragePath().getName();
        }

        @Override
        public void consumeOutputStream(OutputStream out) throws IOException {
          IOUtils.copy(binary.getContent().createInputStream(), out);
        }
      };

      return new StreamResponse(stream.getFileName(), mediaType, stream);
    } else if (RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_JSON.equals(acceptFormat)
      || RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_XML.equals(acceptFormat)) {
      PreservationMetadata pm = model.retrievePreservationMetadata(aipId, representationId, filePath, fileId,
        PreservationMetadataType.EVENT);
      return new ObjectResponse<PreservationMetadata>(acceptFormat, pm);
    } else if (RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_HTML.equals(acceptFormat)) {
      final Binary binary = model.retrievePreservationEvent(aipId, representationId, filePath, fileId, id);
      final String filename = binary.getStoragePath().getName() + HTML_EXT;
      final String mediaType = RodaConstants.MEDIA_TYPE_TEXT_HTML;
      final String htmlEvent = HTMLUtils.preservationMetadataEventToHtml(binary, onlyDetails,
        ServerTools.parseLocale(language));
      final ConsumesOutputStream stream = new ConsumesOutputStream() {

        @Override
        public String getMediaType() {
          return mediaType;
        }

        @Override
        public String getFileName() {
          return filename;
        }

        @Override
        public void consumeOutputStream(OutputStream out) throws IOException {
          PrintStream printStream = new PrintStream(out);
          printStream.print(htmlEvent);
          printStream.close();
        }
      };
      return new StreamResponse(filename, mediaType, stream);
    } else {
      throw new GenericException("Unsupported accept format: " + acceptFormat);
    }
  }

  public static EntityResponse listOtherMetadata(String aipId, String representationId, List<String> filePath,
    String fileId, String type, String acceptFormat)
    throws GenericException, NotFoundException, RequestNotValidException, AuthorizationDeniedException {

    CloseableIterable<OptionalWithCause<OtherMetadata>> otherFiles = RodaCoreFactory.getModelService()
      .listOtherMetadata(aipId, representationId, filePath, fileId, type);

    if (RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_ZIP.equals(acceptFormat)) {
      StorageService storage = RodaCoreFactory.getStorageService();
      List<ZipEntryInfo> zipEntries = new ArrayList<>();

      for (OptionalWithCause<OtherMetadata> oFile : otherFiles) {
        if (oFile.isPresent()) {
          OtherMetadata file = oFile.get();
          StoragePath storagePath = ModelUtils.getOtherMetadataStoragePath(aipId, representationId, filePath, fileId,
            file.getFileSuffix(), file.getType());
          Binary binary = storage.getBinary(storagePath);

          ZipEntryInfo info = new ZipEntryInfo(FSUtils.getStoragePathAsString(storagePath, true), binary.getContent());
          zipEntries.add(info);
        } else {
          LOGGER.error("Cannot get list other metadata", oFile.getCause());
        }
      }

      IOUtils.closeQuietly(otherFiles);
      return DownloadUtils.createZipStreamResponse(zipEntries, aipId);
    } else if (RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_JSON.equals(acceptFormat)
      || RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_XML.equals(acceptFormat)) {
      OtherMetadataList metadataList = new OtherMetadataList();

      for (OptionalWithCause<OtherMetadata> oFile : otherFiles) {
        if (oFile.isPresent()) {
          metadataList.addObject(oFile.get());
        }
      }

      IOUtils.closeQuietly(otherFiles);
      return new ObjectResponse<OtherMetadataList>(acceptFormat, metadataList);
    } else {
      throw new GenericException("Unsupported accept format: " + acceptFormat);
    }
  }

  public static EntityResponse retrieveOtherMetadata(String aipId, String representationId, List<String> filePath,
    String fileId, String type, String suffix, String acceptFormat)
    throws GenericException, NotFoundException, RequestNotValidException, AuthorizationDeniedException {

    if (RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_BIN.equals(acceptFormat)) {
      final ConsumesOutputStream stream;
      Binary otherMetadataBinary = RodaCoreFactory.getModelService().retrieveOtherMetadataBinary(aipId,
        representationId, filePath, fileId, suffix, type);
      String filename = otherMetadataBinary.getStoragePath().getName();
      String mediaType = RodaConstants.MEDIA_TYPE_WILDCARD;

      stream = new ConsumesOutputStream() {

        @Override
        public String getMediaType() {
          return acceptFormat;
        }

        @Override
        public String getFileName() {
          return filename;
        }

        @Override
        public void consumeOutputStream(OutputStream out) throws IOException {
          InputStream fileInputStream = null;
          try {
            fileInputStream = otherMetadataBinary.getContent().createInputStream();
            IOUtils.copy(fileInputStream, out);
          } finally {
            IOUtils.closeQuietly(fileInputStream);
          }
        }
      };
      return new StreamResponse(filename, mediaType, stream);
    } else if (RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_JSON.equals(acceptFormat)
      || RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_XML.equals(acceptFormat)) {
      OtherMetadata other = RodaCoreFactory.getModelService().retrieveOtherMetadata(aipId, representationId, filePath,
        fileId, suffix, type);
      return new ObjectResponse<OtherMetadata>(acceptFormat, other);
    } else {
      throw new GenericException("Unsupported accept format: " + acceptFormat);
    }
  }

  public static OtherMetadata createOrUpdateOtherMetadataFile(String aipId, String representationId,
    List<String> fileDirectoryPath, String fileId, String type, String fileSuffix, InputStream is)
    throws RequestNotValidException, GenericException, NotFoundException, AuthorizationDeniedException {
    try {
      Path tempFile = Files.createTempFile("descriptive", ".tmp");
      Files.copy(is, tempFile, StandardCopyOption.REPLACE_EXISTING);
      ContentPayload payload = new FSPathContentPayload(tempFile);

      return RodaCoreFactory.getModelService().createOrUpdateOtherMetadata(aipId, representationId, fileDirectoryPath,
        fileId, fileSuffix, type, payload, false);
    } catch (IOException e) {
      throw new GenericException("Error creating or updating other metadata");
    }
  }

  public static void deleteOtherMetadataFile(String aipId, String representationId, List<String> fileDirectoryPath,
    String fileId, String fileSuffix, String type)
    throws RequestNotValidException, GenericException, NotFoundException, AuthorizationDeniedException {
    RodaCoreFactory.getModelService().deleteOtherMetadata(aipId, representationId, fileDirectoryPath, fileId,
      fileSuffix, type);
  }

  public static IndexedAIP moveAIPInHierarchy(User user, SelectedItems<IndexedAIP> selected, String parentId,
    String details) throws GenericException, NotFoundException, RequestNotValidException, AuthorizationDeniedException,
    AlreadyExistsException, ValidationException {

    Job job = new Job();
    job.setId(IdUtils.createUUID());
    job.setName("Move AIP in hierarchy");
    job.setSourceObjects(selected);
    job.setPlugin(MovePlugin.class.getCanonicalName());
    job.setPluginType(PluginType.INTERNAL);
    job.setUsername(user.getName());

    Map<String, String> pluginParameters = new HashMap<>();
    pluginParameters.put(RodaConstants.PLUGIN_PARAMS_ID, parentId);
    pluginParameters.put(RodaConstants.PLUGIN_PARAMS_DETAILS, details);
    job.setPluginParameters(pluginParameters);

    RodaCoreFactory.getModelService().createJob(job);
    try {
      RodaCoreFactory.getPluginOrchestrator().executeJob(job, true);
    } catch (JobAlreadyStartedException e) {
      LOGGER.error("Could not execute move job", e);
    }

    IndexService index = RodaCoreFactory.getIndexService();
    index.commit(IndexedAIP.class);
    index.commit(IndexedRepresentation.class);
    index.commit(IndexedFile.class);

    return (parentId != null) ? index.retrieve(IndexedAIP.class, parentId, Arrays.asList(RodaConstants.INDEX_UUID))
      : null;
  }

  public static AIP createAIP(User user, String parentAipId, String type, Permissions permissions)
    throws GenericException, AuthorizationDeniedException, RequestNotValidException, NotFoundException,
    AlreadyExistsException {
    ModelService model = RodaCoreFactory.getModelService();
    return model.createAIP(parentAipId, type, permissions, user.getName());
  }

  public static AIP updateAIP(User user, AIP aip) throws GenericException, AuthorizationDeniedException,
    RequestNotValidException, NotFoundException, AlreadyExistsException {
    ModelService model = RodaCoreFactory.getModelService();
    return model.updateAIP(aip, user.getName());
  }

  public static void deleteAIP(User user, SelectedItems<IndexedAIP> selected, String details)
    throws AuthorizationDeniedException, GenericException, RequestNotValidException, NotFoundException {
    Job job = new Job();
    job.setId(IdUtils.createUUID());
    job.setName("Delete AIP");
    job.setSourceObjects(selected);
    job.setPlugin(DeleteRODAObjectPlugin.class.getCanonicalName());
    job.setPluginType(PluginType.INTERNAL);
    job.setUsername(user.getName());

    Map<String, String> pluginParameters = new HashMap<>();
    pluginParameters.put(RodaConstants.PLUGIN_PARAMS_DETAILS, details);
    job.setPluginParameters(pluginParameters);

    try {
      RodaCoreFactory.getModelService().createJob(job);
      RodaCoreFactory.getPluginOrchestrator().executeJob(job, true);
    } catch (JobAlreadyStartedException e) {
      LOGGER.error("Could not execute AIP delete action", e);
    }
  }

  public static void deleteRepresentation(User user, SelectedItems<IndexedRepresentation> selected, String details)
    throws AuthorizationDeniedException, GenericException, RequestNotValidException, NotFoundException {
    Job job = new Job();
    job.setId(IdUtils.createUUID());
    job.setName("Delete representations");
    job.setSourceObjects(selected);
    job.setPlugin(DeleteRODAObjectPlugin.class.getCanonicalName());
    job.setPluginType(PluginType.INTERNAL);
    job.setUsername(user.getName());

    Map<String, String> pluginParameters = new HashMap<>();
    pluginParameters.put(RodaConstants.PLUGIN_PARAMS_DETAILS, details);
    job.setPluginParameters(pluginParameters);

    try {
      RodaCoreFactory.getModelService().createJob(job);
      RodaCoreFactory.getPluginOrchestrator().executeJob(job, true);
    } catch (JobAlreadyStartedException e) {
      LOGGER.error("Could not execute representations delete action", e);
    }
  }

  public static void deleteFile(User user, SelectedItems<IndexedFile> selected, String details)
    throws AuthorizationDeniedException, GenericException, RequestNotValidException, NotFoundException {
    Job job = new Job();
    job.setId(IdUtils.createUUID());
    job.setName("Delete files");
    job.setSourceObjects(selected);
    job.setPlugin(DeleteRODAObjectPlugin.class.getCanonicalName());
    job.setPluginType(PluginType.INTERNAL);
    job.setUsername(user.getName());

    Map<String, String> pluginParameters = new HashMap<>();
    pluginParameters.put(RodaConstants.PLUGIN_PARAMS_DETAILS, details);
    job.setPluginParameters(pluginParameters);

    try {
      RodaCoreFactory.getModelService().createJob(job);
      RodaCoreFactory.getPluginOrchestrator().executeJob(job, true);
    } catch (JobAlreadyStartedException e) {
      LOGGER.error("Could not execute file delete action", e);
    }
  }

  public static DescriptiveMetadata createDescriptiveMetadataFile(String aipId, String descriptiveMetadataId,
    String descriptiveMetadataType, String descriptiveMetadataVersion, ContentPayload descriptiveMetadataPayload)
    throws GenericException, ValidationException, AuthorizationDeniedException, RequestNotValidException,
    AlreadyExistsException, NotFoundException {
    return createDescriptiveMetadataFile(aipId, null, descriptiveMetadataId, descriptiveMetadataType,
      descriptiveMetadataVersion, descriptiveMetadataPayload);
  }

  public static DescriptiveMetadata createDescriptiveMetadataFile(String aipId, String representationId,
    String descriptiveMetadataId, String descriptiveMetadataType, String descriptiveMetadataVersion,
    ContentPayload descriptiveMetadataPayload) throws GenericException, ValidationException,
    AuthorizationDeniedException, RequestNotValidException, AlreadyExistsException, NotFoundException {

    ValidationReport report = ValidationUtils.validateDescriptiveBinary(descriptiveMetadataPayload,
      descriptiveMetadataType, descriptiveMetadataVersion, false);

    if (!report.isValid()) {
      throw new ValidationException(report);
    }

    return RodaCoreFactory.getModelService().createDescriptiveMetadata(aipId, representationId, descriptiveMetadataId,
      descriptiveMetadataPayload, descriptiveMetadataType, descriptiveMetadataVersion);
  }

  public static DescriptiveMetadata updateDescriptiveMetadataFile(String aipId, String representationId,
    String descriptiveMetadataId, String descriptiveMetadataType, String descriptiveMetadataVersion,
    ContentPayload descriptiveMetadataPayload, Map<String, String> properties) throws GenericException,
    AuthorizationDeniedException, ValidationException, RequestNotValidException, NotFoundException {

    ValidationReport report = ValidationUtils.validateDescriptiveBinary(descriptiveMetadataPayload,
      descriptiveMetadataType, descriptiveMetadataVersion, false);

    if (!report.isValid()) {
      throw new ValidationException(report);
    }

    return RodaCoreFactory.getModelService().updateDescriptiveMetadata(aipId, representationId, descriptiveMetadataId,
      descriptiveMetadataPayload, descriptiveMetadataType, descriptiveMetadataVersion, properties);

  }

  public static void deleteDescriptiveMetadataFile(String aipId, String representationId, String descriptiveMetadataId)
    throws GenericException, RequestNotValidException, NotFoundException, AuthorizationDeniedException {
    RodaCoreFactory.getModelService().deleteDescriptiveMetadata(aipId, representationId, descriptiveMetadataId);
  }

  public static DescriptiveMetadata retrieveMetadataFile(String aipId, String descriptiveMetadataId)
    throws GenericException, RequestNotValidException, NotFoundException, AuthorizationDeniedException {
    return RodaCoreFactory.getModelService().retrieveDescriptiveMetadata(aipId, descriptiveMetadataId);
  }

  public static Representation createRepresentation(User user, String aipId, String representationId, String type,
    String details) throws GenericException, AuthorizationDeniedException, RequestNotValidException, NotFoundException,
    AlreadyExistsException {
    String eventDescription = "The process of creating an object of the repository.";

    ModelService model = RodaCoreFactory.getModelService();

    try {
      Representation representation = model.createRepresentation(aipId, representationId, true, type, true);

      List<LinkingIdentifier> targets = new ArrayList<>();
      targets.add(PluginHelper.getLinkingIdentifier(aipId, representation.getId(),
        RodaConstants.PRESERVATION_LINKING_OBJECT_OUTCOME));

      String outcomeText = "The representation '" + representationId + "' has been manually created";
      model.createEvent(aipId, null, null, null, PreservationEventType.CREATION, eventDescription, null, targets,
        PluginState.SUCCESS, outcomeText, details, user.getName(), true);

      RodaCoreFactory.getIndexService().commit(IndexedRepresentation.class);
      return representation;
    } catch (RequestNotValidException | NotFoundException | GenericException | AuthorizationDeniedException
      | AlreadyExistsException e) {
      String outcomeText = "The representation '" + representationId + "' has not been manually created";
      model.createUpdateAIPEvent(aipId, null, null, null, PreservationEventType.CREATION, eventDescription,
        PluginState.FAILURE, outcomeText, details, user.getName(), true);

      throw e;
    }
  }

  public static Representation updateRepresentation(Representation representation) throws GenericException,
    AuthorizationDeniedException, RequestNotValidException, NotFoundException, AlreadyExistsException {
    return RodaCoreFactory.getModelService().updateRepresentationInfo(representation);
  }

  public static void deleteRepresentation(String aipId, String representationId)
    throws GenericException, RequestNotValidException, NotFoundException, AuthorizationDeniedException {
    RodaCoreFactory.getModelService().deleteRepresentation(aipId, representationId);
  }

  public static File createFile(User user, String aipId, String representationId, List<String> directoryPath,
    String fileId, ContentPayload content, String details) throws GenericException, AuthorizationDeniedException,
    RequestNotValidException, NotFoundException, AlreadyExistsException {
    String eventDescription = "The process of creating an object of the repository.";

    ModelService model = RodaCoreFactory.getModelService();

    try {
      File file = model.createFile(aipId, representationId, directoryPath, fileId, content);

      List<LinkingIdentifier> targets = new ArrayList<>();
      targets.add(PluginHelper.getLinkingIdentifier(aipId, file.getRepresentationId(), file.getPath(), file.getId(),
        RodaConstants.PRESERVATION_LINKING_OBJECT_OUTCOME));

      String outcomeText = "The file '" + file.getId() + "' has been manually created.";
      model.createEvent(aipId, representationId, null, null, PreservationEventType.CREATION, eventDescription, null,
        targets, PluginState.SUCCESS, outcomeText, details, user.getName(), true);

      return file;
    } catch (RequestNotValidException | NotFoundException | GenericException | AuthorizationDeniedException
      | AlreadyExistsException e) {
      String outcomeText = "The file '" + fileId + "' has not been manually created.";
      model.createUpdateAIPEvent(aipId, representationId, null, null, PreservationEventType.CREATION, eventDescription,
        PluginState.FAILURE, outcomeText, details, user.getName(), true);

      throw e;
    }
  }

  public static File updateFile(File file, ContentPayload contentPayload, boolean createIfNotExists, boolean notify)
    throws GenericException, AuthorizationDeniedException, RequestNotValidException, NotFoundException,
    AlreadyExistsException {
    return RodaCoreFactory.getModelService().updateFile(file, contentPayload, createIfNotExists, notify);
  }

  public static EntityResponse retrieveAIPRepresentationFile(IndexedFile iFile, String acceptFormat)
    throws GenericException, RequestNotValidException, NotFoundException, AuthorizationDeniedException {

    StoragePath filePath = ModelUtils.getFileStoragePath(iFile.getAipId(), iFile.getRepresentationId(), iFile.getPath(),
      iFile.getId());

    if (!iFile.isDirectory() && RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_BIN.equals(acceptFormat)) {
      final String filename;
      final String mediaType;
      final ConsumesOutputStream stream;

      StorageService storage = RodaCoreFactory.getStorageService();
      Binary representationFileBinary = storage.getBinary(filePath);
      filename = representationFileBinary.getStoragePath().getName();
      mediaType = RodaConstants.MEDIA_TYPE_WILDCARD;

      stream = new ConsumesOutputStream() {

        @Override
        public String getMediaType() {
          return acceptFormat;
        }

        @Override
        public String getFileName() {
          return filename;
        }

        @Override
        public void consumeOutputStream(OutputStream out) throws IOException {
          InputStream fileInputStream = null;
          try {
            fileInputStream = representationFileBinary.getContent().createInputStream();
            IOUtils.copy(fileInputStream, out);
          } finally {
            IOUtils.closeQuietly(fileInputStream);
          }
        }
      };
      return new StreamResponse(filename, mediaType, stream);
    } else if (iFile.isDirectory() && (RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_ZIP.equals(acceptFormat)
      || RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_BIN.equals(acceptFormat))) {
      Directory directory = RodaCoreFactory.getStorageService().getDirectory(filePath);
      return ApiUtils.download(directory);
    } else if (RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_JSON.equals(acceptFormat)
      || RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_XML.equals(acceptFormat)) {
      File file = RodaCoreFactory.getModelService().retrieveFile(iFile.getAipId(), iFile.getRepresentationId(),
        iFile.getPath(), iFile.getId());
      return new ObjectResponse<File>(acceptFormat, file);
    } else {
      throw new GenericException("Unsupported accept format: " + acceptFormat);
    }
  }

  public static DescriptiveMetadata createOrUpdateAIPDescriptiveMetadataFile(String aipId, String representationId,
    String metadataId, String metadataType, String metadataVersion, Map<String, String> properties, InputStream is,
    boolean create) throws GenericException, RequestNotValidException, NotFoundException, AuthorizationDeniedException,
    AlreadyExistsException, ValidationException {
    Path file = null;
    DescriptiveMetadata dm = null;
    try {
      ModelService model = RodaCoreFactory.getModelService();
      file = Files.createTempFile("descriptive", ".tmp");
      Files.copy(is, file, StandardCopyOption.REPLACE_EXISTING);
      ContentPayload payload = new FSPathContentPayload(file);

      if (create) {
        dm = model.createDescriptiveMetadata(aipId, representationId, metadataId, payload, metadataType,
          metadataVersion);
      } else {
        dm = model.updateDescriptiveMetadata(aipId, representationId, metadataId, payload, metadataType,
          metadataVersion, properties);
      }

    } catch (IOException e) {
      throw new GenericException("Error creating or updating AIP descriptive metadata file", e);
    } finally {
      FSUtils.deletePathQuietly(file);
    }

    return dm;
  }

  public static TransferredResource createTransferredResourcesFolder(String parentUUID, String folderName,
    boolean forceCommit) throws GenericException, RequestNotValidException, NotFoundException {
    TransferredResource transferredResource = RodaCoreFactory.getTransferredResourcesScanner().createFolder(parentUUID,
      folderName);
    if (forceCommit) {
      RodaCoreFactory.getTransferredResourcesScanner().commit();
    }
    return transferredResource;
  }

  private static <T extends IsIndexed> List<String> consolidate(User user, Class<T> classToReturn,
    SelectedItems<T> selected) throws GenericException, AuthorizationDeniedException, RequestNotValidException {
    List<String> ret;

    if (selected instanceof SelectedItemsList) {
      ret = ((SelectedItemsList<T>) selected).getIds();
    } else if (selected instanceof SelectedItemsFilter) {
      SelectedItemsFilter<T> selectedItemsFilter = (SelectedItemsFilter<T>) selected;
      Filter filter = selectedItemsFilter.getFilter();
      boolean justActive = selectedItemsFilter.justActive();
      Long count = count(classToReturn, filter, justActive, user);
      IndexResult<T> find = find(classToReturn, filter, Sorter.NONE, new Sublist(0, count.intValue()), Facets.NONE,
        user, justActive, Arrays.asList(RodaConstants.INDEX_UUID));
      ret = find.getResults().stream().map(i -> i.getUUID()).collect(Collectors.toList());
    } else {
      throw new RequestNotValidException("Class not supported: " + selected.getClass().getName());
    }

    return ret;
  }

  public static void deleteTransferredResources(SelectedItems<TransferredResource> selected, User user)
    throws GenericException, NotFoundException, AuthorizationDeniedException, RequestNotValidException {
    List<String> ids = consolidate(user, TransferredResource.class, selected);

    // check permissions
    UserUtility.checkTransferredResourceAccess(user, ids);

    RodaCoreFactory.getTransferredResourcesScanner().deleteTransferredResource(ids);
  }

  public static TransferredResource createTransferredResourceFile(String parentUUID, String fileName,
    InputStream inputStream, boolean forceCommit)
    throws GenericException, AlreadyExistsException, RequestNotValidException, NotFoundException {
    LOGGER.debug("createTransferredResourceFile(path={}, name={})", parentUUID, fileName);
    TransferredResource transferredResource = RodaCoreFactory.getTransferredResourcesScanner().createFile(parentUUID,
      fileName, inputStream);
    if (forceCommit) {
      RodaCoreFactory.getTransferredResourcesScanner().commit();
    }

    return transferredResource;
  }

  protected static <T extends IsIndexed> void delete(User user, Class<T> returnClass, SelectedItems<T> ids)
    throws GenericException, NotFoundException, RequestNotValidException, AuthorizationDeniedException {
    List<String> idList = consolidate(user, returnClass, ids);
    RodaCoreFactory.getIndexService().delete(returnClass, idList);
    RodaCoreFactory.getIndexService().commit(returnClass);
  }

  public static boolean retrieveScanUpdateStatus(Optional<String> folderRelativePath) {
    return RodaCoreFactory.getTransferredResourcesScannerUpdateStatus(folderRelativePath);
  }

  public static void updateTransferredResources(Optional<String> folderRelativePath, boolean waitToFinish)
    throws IsStillUpdatingException, GenericException {
    RodaCoreFactory.getTransferredResourcesScanner().updateTransferredResources(folderRelativePath, waitToFinish);
  }

  public static void updateTransferredResource(Optional<String> folderRelativePath, ContentPayload payload, String name,
    boolean waitToFinish) throws IsStillUpdatingException, GenericException, NotFoundException, IOException {
    RodaCoreFactory.getTransferredResourcesScanner().updateTransferredResource(folderRelativePath, payload, name,
      waitToFinish);
  }

  public static ConsumesOutputStream retrieveClassificationPlan(User user, String filename)
    throws GenericException, RequestNotValidException, NotFoundException, AuthorizationDeniedException {
    return ClassificationPlanUtils.retrieveClassificationPlan(user, filename);

  }

  public static List<SupportedMetadataTypeBundle> retrieveSupportedMetadata(User user, IndexedAIP aip,
    IndexedRepresentation representation, Locale locale) throws GenericException {
    Messages messages = RodaCoreFactory.getI18NMessages(locale);
    List<String> types = RodaUtils
      .copyList(RodaCoreFactory.getRodaConfiguration().getList(RodaConstants.UI_BROWSER_METADATA_DESCRIPTIVE_TYPES));

    List<SupportedMetadataTypeBundle> supportedMetadata = new ArrayList<>();

    if (types != null) {
      for (String id : types) {
        String type = id;
        String version = null;
        if (id.contains(RodaConstants.METADATA_VERSION_SEPARATOR)) {
          version = id.substring(id.lastIndexOf(RodaConstants.METADATA_VERSION_SEPARATOR) + 1, id.length());
          type = id.substring(0, id.lastIndexOf(RodaConstants.METADATA_VERSION_SEPARATOR));
        }
        String key = RodaConstants.I18N_UI_BROWSE_METADATA_DESCRIPTIVE_TYPE_PREFIX + type;
        if (version != null) {
          key += RodaConstants.METADATA_VERSION_SEPARATOR + version.toLowerCase();
        }
        String label = messages.getTranslation(key, type);

        String template = null;
        Set<MetadataValue> values = new HashSet<>();
        try (InputStream templateStream = RodaCoreFactory
          .getConfigurationFileAsStream(RodaConstants.METADATA_TEMPLATE_FOLDER + "/"
            + ((version != null) ? type + RodaConstants.METADATA_VERSION_SEPARATOR + version : type)
            + RodaConstants.METADATA_TEMPLATE_EXTENSION)) {

          if (templateStream != null) {
            template = IOUtils.toString(templateStream, RodaConstants.DEFAULT_ENCODING);
            values = ServerTools.transform(template);
            for (MetadataValue mv : values) {
              String generator = mv.get("auto-generate");
              if (generator != null && generator.length() > 0) {
                String value;
                if (representation != null) {
                  value = ServerTools.autoGenerateRepresentationValue(representation, generator);
                } else {
                  value = ServerTools.autoGenerateAIPValue(aip, user, generator);
                }

                if (value != null) {
                  mv.set("value", value);
                }
              }
              String labels = mv.get("label");
              String labelI18N = mv.get("labeli18n");
              if (labels != null && labelI18N != null) {
                Map<String, String> labelsMaps = JsonUtils.getMapFromJson(labels);
                try {
                  labelsMaps.put(locale.toString(), RodaCoreFactory.getI18NMessages(locale).getTranslation(labelI18N));
                } catch (MissingResourceException e) {
                  LOGGER.debug("Missing resource: {}", labelI18N);
                }
                labels = JsonUtils.getJsonFromObject(labelsMaps);
                mv.set("label", labels);
              }

              String i18nPrefix = mv.get("optionsLabelI18nKeyPrefix");
              if (i18nPrefix != null) {
                Map<String, String> terms = messages.getTranslations(i18nPrefix, String.class, false);
                if (terms.size() > 0) {
                  try {
                    String options = mv.get("options");
                    List<String> optionsList = JsonUtils.getListFromJson(options, String.class);

                    if (optionsList != null) {
                      Map<String, Map<String, String>> i18nMap = new HashMap<>();
                      for (int i = 0; i < optionsList.size(); i++) {
                        String value = optionsList.get(i);
                        String translation = terms.get(i18nPrefix + "." + value);
                        if (translation == null) {
                          translation = value;
                        }
                        Map<String, String> term = new HashMap<>();
                        term.put(locale.toString(), translation);
                        i18nMap.put(value, term);
                      }
                      mv.set("optionsLabels", JsonUtils.getJsonFromObject(i18nMap));
                    }
                  } catch (MissingResourceException e) {
                    LOGGER.error(e.getMessage(), e);
                  }
                }
              }

            }
          }
        } catch (IOException e) {
          LOGGER.error("Error getting the template from the stream", e);
        }

        supportedMetadata.add(new SupportedMetadataTypeBundle(id, type, version, label, template, values));
      }
    }
    return supportedMetadata;
  }

  public static EntityResponse retrieveTransferredResource(final TransferredResource transferredResource,
    String acceptFormat) throws NotFoundException, RequestNotValidException, GenericException {

    if (RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_BIN.equals(acceptFormat)) {

      ConsumesOutputStream stream = new ConsumesOutputStream() {

        @Override
        public String getMediaType() {
          return acceptFormat;
        }

        @Override
        public String getFileName() {
          return transferredResource.getName();
        }

        @Override
        public void consumeOutputStream(OutputStream out) throws IOException {
          InputStream retrieveFile = null;
          try {
            retrieveFile = RodaCoreFactory.getTransferredResourcesScanner()
              .retrieveFile(transferredResource.getFullPath());
            IOUtils.copy(retrieveFile, out);
          } catch (NotFoundException | RequestNotValidException | GenericException e) {
            // do nothing
          } finally {
            IOUtils.closeQuietly(retrieveFile);
          }
        }
      };

      return new StreamResponse(transferredResource.getName(), RodaConstants.MEDIA_TYPE_APPLICATION_OCTET_STREAM,
        stream);
    } else if (RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_JSON.equals(acceptFormat)
      || RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_XML.equals(acceptFormat)) {
      return new ObjectResponse<TransferredResource>(acceptFormat, transferredResource);
    } else {
      throw new GenericException("Unsupported accept format: " + acceptFormat);
    }
  }

  public static PreservationEventViewBundle retrievePreservationEventViewBundle(String eventId)
    throws NotFoundException, GenericException {
    PreservationEventViewBundle eventBundle = new PreservationEventViewBundle();
    Map<String, IndexedAIP> aips = new HashMap<>();
    Map<String, IndexedRepresentation> representations = new HashMap<>();
    Map<String, IndexedFile> files = new HashMap<>();
    Map<String, TransferredResource> transferredResources = new HashMap<>();

    List<String> eventFields = new ArrayList<>();
    IndexedPreservationEvent ipe = retrieve(IndexedPreservationEvent.class, eventId, eventFields);
    eventBundle.setEvent(ipe);
    if (ipe.getLinkingAgentIds() != null && !ipe.getLinkingAgentIds().isEmpty()) {
      Map<String, IndexedPreservationAgent> agents = new HashMap<>();
      for (LinkingIdentifier agentID : ipe.getLinkingAgentIds()) {
        try {
          List<String> agentFields = Arrays.asList(RodaConstants.PRESERVATION_AGENT_ID,
            RodaConstants.PRESERVATION_AGENT_NAME, RodaConstants.PRESERVATION_AGENT_TYPE,
            RodaConstants.PRESERVATION_AGENT_ROLES, RodaConstants.PRESERVATION_AGENT_VERSION,
            RodaConstants.PRESERVATION_AGENT_NOTE, RodaConstants.PRESERVATION_AGENT_EXTENSION);
          IndexedPreservationAgent agent = retrieve(IndexedPreservationAgent.class, agentID.getValue(), agentFields);
          agents.put(agentID.getValue(), agent);
        } catch (NotFoundException | GenericException e) {
          LOGGER.error("Error getting agent {}: {}", agentID, e.getMessage());
        }
      }
      eventBundle.setAgents(agents);
    }

    List<LinkingIdentifier> allLinkingIdentifiers = new ArrayList<>();

    if (ipe.getSourcesObjectIds() != null) {
      allLinkingIdentifiers.addAll(ipe.getSourcesObjectIds());
    }

    if (ipe.getOutcomeObjectIds() != null) {
      allLinkingIdentifiers.addAll(ipe.getOutcomeObjectIds());
    }

    for (LinkingIdentifier identifier : allLinkingIdentifiers) {
      String idValue = identifier.getValue();
      RODA_TYPE linkingType = LinkingObjectUtils.getLinkingIdentifierType(idValue);

      try {
        if (RODA_TYPE.AIP.equals(linkingType)) {
          String uuid = LinkingObjectUtils.getAipIdFromLinkingId(idValue);
          List<String> aipFields = Arrays.asList(RodaConstants.AIP_TITLE, RodaConstants.INDEX_UUID);
          IndexedAIP aip = retrieve(IndexedAIP.class, uuid, aipFields);
          aips.put(idValue, aip);
        } else if (RODA_TYPE.REPRESENTATION.equals(linkingType)) {
          String uuid = LinkingObjectUtils.getRepresentationIdFromLinkingId(idValue);
          List<String> representationFields = Arrays.asList(RodaConstants.REPRESENTATION_ID,
            RodaConstants.REPRESENTATION_AIP_ID, RodaConstants.REPRESENTATION_ORIGINAL);
          IndexedRepresentation rep = retrieve(IndexedRepresentation.class, uuid, representationFields);
          representations.put(idValue, rep);
        } else if (RODA_TYPE.FILE.equals(linkingType)) {
          List<String> fileFields = new ArrayList<>(RodaConstants.FILE_FIELDS_TO_RETURN);
          fileFields.addAll(RodaConstants.FILE_FORMAT_FIELDS_TO_RETURN);
          fileFields.addAll(Arrays.asList(RodaConstants.FILE_ORIGINALNAME, RodaConstants.FILE_SIZE,
            RodaConstants.FILE_FILEFORMAT, RodaConstants.FILE_FORMAT_VERSION));
          IndexedFile file = retrieve(IndexedFile.class, LinkingObjectUtils.getFileIdFromLinkingId(idValue),
            fileFields);
          files.put(idValue, file);
        } else if (RODA_TYPE.TRANSFERRED_RESOURCE.equals(linkingType)) {
          String id = LinkingObjectUtils.getTransferredResourceIdFromLinkingId(idValue);
          if (id != null) {
            List<String> resourceFields = Arrays.asList(RodaConstants.INDEX_UUID,
              RodaConstants.TRANSFERRED_RESOURCE_NAME, RodaConstants.TRANSFERRED_RESOURCE_FULLPATH);
            TransferredResource tr = retrieve(TransferredResource.class, IdUtils.createUUID(id), resourceFields);
            transferredResources.put(idValue, tr);
          }
        } else {
          LOGGER.warn("No support for linking object type: {}", linkingType);
        }
      } catch (NotFoundException e) {
        // nothing to do
      }
    }

    eventBundle.setAips(aips);
    eventBundle.setRepresentations(representations);
    eventBundle.setFiles(files);
    eventBundle.setTransferredResources(transferredResources);

    return eventBundle;
  }

  public static CloseableIterable<BinaryVersion> listDescriptiveMetadataVersions(String aipId, String representationId,
    String descriptiveMetadataId)
    throws RequestNotValidException, GenericException, NotFoundException, AuthorizationDeniedException {
    StoragePath storagePath = ModelUtils.getDescriptiveMetadataStoragePath(aipId, representationId,
      descriptiveMetadataId);
    return RodaCoreFactory.getStorageService().listBinaryVersions(storagePath);

  }

  public static DescriptiveMetadataVersionsBundle retrieveDescriptiveMetadataVersionsBundle(String aipId,
    String representationId, String metadataId, Locale locale)
    throws GenericException, RequestNotValidException, NotFoundException, AuthorizationDeniedException {
    DescriptiveMetadataVersionsBundle bundle = new DescriptiveMetadataVersionsBundle();

    DescriptiveMetadataViewBundle descriptiveMetadataBundle = retrieveDescriptiveMetadataBundle(aipId, representationId,
      metadataId, locale);
    bundle.setDescriptiveMetadata(descriptiveMetadataBundle);

    List<BinaryVersionBundle> versionBundles = new ArrayList<>();

    CloseableIterable<BinaryVersion> it = listDescriptiveMetadataVersions(aipId, representationId, metadataId);
    for (BinaryVersion v : it) {
      versionBundles.add(new BinaryVersionBundle(v.getId(), v.getCreatedDate(), v.getProperties()));
    }
    IOUtils.closeQuietly(it);

    bundle.setVersions(versionBundles);
    return bundle;
  }

  public static void revertDescriptiveMetadataVersion(String aipId, String representationId,
    String descriptiveMetadataId, String versionId, Map<String, String> properties)
    throws RequestNotValidException, NotFoundException, GenericException, AuthorizationDeniedException {
    RodaCoreFactory.getModelService().revertDescriptiveMetadataVersion(aipId, representationId, descriptiveMetadataId,
      versionId, properties);
  }

  public static void deleteDescriptiveMetadataVersion(String aipId, String representationId,
    String descriptiveMetadataId, String versionId)
    throws NotFoundException, GenericException, RequestNotValidException {
    StoragePath storagePath = ModelUtils.getDescriptiveMetadataStoragePath(aipId, representationId,
      descriptiveMetadataId);
    RodaCoreFactory.getStorageService().deleteBinaryVersion(storagePath, versionId);
  }

  public static void updateAIPPermissions(User user, IndexedAIP indexedAIP, Permissions permissions, String details,
    boolean recursive) throws GenericException, NotFoundException, RequestNotValidException,
    AuthorizationDeniedException, JobAlreadyStartedException {
    final String eventDescription = "The process of updating an object of the repository.";

    final ModelService model = RodaCoreFactory.getModelService();
    AIP aip = model.retrieveAIP(indexedAIP.getId());
    aip.setPermissions(permissions);
    List<LinkingIdentifier> sources = Arrays
      .asList(PluginHelper.getLinkingIdentifier(aip.getId(), RodaConstants.PRESERVATION_LINKING_OBJECT_OUTCOME));

    try {
      model.updateAIPPermissions(aip, user.getName());
      String outcomeText = PluginHelper.createOutcomeTextForAIP(indexedAIP, " permissions has been manually updated");
      model.createEvent(aip.getId(), null, null, null, PreservationEventType.UPDATE, eventDescription, sources, null,
        PluginState.SUCCESS, outcomeText, details, user.getName(), true);
    } catch (RequestNotValidException | NotFoundException | GenericException | AuthorizationDeniedException e) {
      String outcomeText = PluginHelper.createOutcomeTextForAIP(indexedAIP,
        " permissions has not been manually updated");
      model.createEvent(aip.getId(), null, null, null, PreservationEventType.UPDATE, eventDescription, sources, null,
        PluginState.FAILURE, outcomeText, details, user.getName(), true);

      throw e;
    }

    if (recursive) {
      Filter filter = new Filter(new SimpleFilterParameter(RodaConstants.AIP_ANCESTORS, indexedAIP.getId()));
      SelectedItemsFilter<IndexedAIP> selectedItems = new SelectedItemsFilter<>(filter, IndexedAIP.class.getName(),
        Boolean.FALSE);

      Job job = new Job();
      job.setId(IdUtils.createUUID());
      job.setName("Update AIP permissions recursively");
      job.setSourceObjects(selectedItems);
      job.setPlugin(UpdateAIPPermissionsPlugin.class.getCanonicalName());
      job.setPluginType(PluginType.INTERNAL);
      job.setUsername(user.getName());

      Map<String, String> pluginParameters = new HashMap<>();
      pluginParameters.put(RodaConstants.PLUGIN_PARAMS_AIP_ID, aip.getId());
      pluginParameters.put(RodaConstants.PLUGIN_PARAMS_DETAILS, details);
      pluginParameters.put(RodaConstants.PLUGIN_PARAMS_EVENT_DESCRIPTION, eventDescription);
      pluginParameters.put(RodaConstants.PLUGIN_PARAMS_OUTCOME_TEXT,
        "AIP " + indexedAIP.getId() + " permissions were updated and all sublevels will be too");
      job.setPluginParameters(pluginParameters);

      RodaCoreFactory.getModelService().createJob(job);
      RodaCoreFactory.getPluginOrchestrator().executeJob(job, true);
    }
  }

  public static void updateDIPPermissions(IndexedDIP indexedDIP, Permissions permissions, String details)
    throws GenericException, NotFoundException, RequestNotValidException, AuthorizationDeniedException {
    // TODO 20170222 nvieira it should create an event associated with DIP
    ModelService model = RodaCoreFactory.getModelService();
    DIP dip = model.retrieveDIP(indexedDIP.getId());
    dip.setPermissions(permissions);
    model.updateDIPPermissions(dip);
  }

  public static Risk createRisk(Risk risk, User user, boolean commit)
    throws GenericException, RequestNotValidException {
    risk.setCreatedBy(user.getName());
    risk.setUpdatedBy(user.getName());
    return RodaCoreFactory.getModelService().createRisk(risk, commit);
  }

  public static void updateRisk(Risk risk, User user, Map<String, String> properties, boolean commit, int incidences)
    throws GenericException, RequestNotValidException {
    risk.setUpdatedBy(user.getName());
    RodaCoreFactory.getModelService().updateRisk(risk, properties, commit, incidences);
  }

  public static Format createFormat(Format format, boolean commit) throws GenericException, RequestNotValidException {
    return RodaCoreFactory.getModelService().createFormat(format, commit);
  }

  public static void updateFormat(Format format, boolean commit) throws GenericException, RequestNotValidException {
    RodaCoreFactory.getModelService().updateFormat(format, commit);
  }

  public static RiskVersionsBundle retrieveRiskVersions(String riskId)
    throws RequestNotValidException, GenericException, NotFoundException, AuthorizationDeniedException, IOException {
    StoragePath storagePath = ModelUtils.getRiskStoragePath(riskId);
    CloseableIterable<BinaryVersion> iterable = RodaCoreFactory.getStorageService().listBinaryVersions(storagePath);
    List<BinaryVersionBundle> versionList = new ArrayList<>();
    boolean versionFlag = false;
    Date newestDate = new Date();
    Binary lastRiskBinary = null;

    for (BinaryVersion bv : iterable) {
      versionList.add(new BinaryVersionBundle(bv.getId(), bv.getCreatedDate(), bv.getProperties()));

      if (!versionFlag) {
        lastRiskBinary = bv.getBinary();
        newestDate = bv.getCreatedDate();
        versionFlag = true;
      } else if (newestDate.before(bv.getCreatedDate())) {
        lastRiskBinary = bv.getBinary();
        newestDate = bv.getCreatedDate();
      }
    }

    iterable.close();

    if (lastRiskBinary != null) {
      Risk lastRisk = JsonUtils.getObjectFromJson(lastRiskBinary.getContent().createInputStream(), Risk.class);
      return new RiskVersionsBundle(lastRisk, versionList);
    } else {
      return new RiskVersionsBundle();
    }
  }

  public static boolean hasRiskVersions(String id)
    throws RequestNotValidException, GenericException, NotFoundException, AuthorizationDeniedException {
    StoragePath storagePath = ModelUtils.getRiskStoragePath(id);
    CloseableIterable<BinaryVersion> iterable = RodaCoreFactory.getStorageService().listBinaryVersions(storagePath);
    boolean hasRiskVersion = iterable.iterator().hasNext();
    IOUtils.closeQuietly(iterable);
    return hasRiskVersion;
  }

  public static void revertRiskVersion(String riskId, String versionId, Map<String, String> properties, int incidences)
    throws RequestNotValidException, NotFoundException, GenericException, AuthorizationDeniedException {
    RodaCoreFactory.getModelService().revertRiskVersion(riskId, versionId, properties, false, incidences);
  }

  public static void deleteRiskVersion(String riskId, String versionId)
    throws NotFoundException, GenericException, RequestNotValidException {
    StoragePath storagePath = ModelUtils.getRiskStoragePath(riskId);
    RodaCoreFactory.getStorageService().deleteBinaryVersion(storagePath, versionId);
  }

  public static Risk retrieveRiskVersion(String riskId, String selectedVersion)
    throws RequestNotValidException, GenericException, NotFoundException, AuthorizationDeniedException, IOException {
    BinaryVersion bv = RodaCoreFactory.getModelService().retrieveVersion(riskId, selectedVersion);
    return JsonUtils.getObjectFromJson(bv.getBinary().getContent().createInputStream(), Risk.class);
  }

  public static void validateExportAIPParams(String acceptFormat) throws RequestNotValidException {
    if (!RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_BIN.equals(acceptFormat)) {
      throw new RequestNotValidException("Invalid '" + RodaConstants.API_QUERY_KEY_ACCEPT_FORMAT
        + "' value. Expected values: " + Arrays.asList(RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_BIN));
    }
  }

  public static void validateListingParams(String acceptFormat) throws RequestNotValidException {
    if (!RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_JSON.equals(acceptFormat)
      && !RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_XML.equals(acceptFormat)) {
      throw new RequestNotValidException(
        "Invalid '" + RodaConstants.API_QUERY_KEY_ACCEPT_FORMAT + "' value. Expected values: " + Arrays
          .asList(RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_JSON, RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_XML));
    }

  }

  public static void validateCreateAndUpdateParams(String acceptFormat) throws RequestNotValidException {
    if (!RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_JSON.equals(acceptFormat)
      && !RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_XML.equals(acceptFormat)) {
      throw new RequestNotValidException(
        "Invalid '" + RodaConstants.API_QUERY_KEY_ACCEPT_FORMAT + "' value. Expected values: " + Arrays
          .asList(RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_JSON, RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_XML));
    }

  }

  public static void validateGetAIPParams(String acceptFormat) throws RequestNotValidException {
    if (!RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_JSON.equals(acceptFormat)
      && !RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_XML.equals(acceptFormat)
      && !RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_ZIP.equals(acceptFormat)) {
      throw new RequestNotValidException("Invalid '" + RodaConstants.API_QUERY_KEY_ACCEPT_FORMAT
        + "' value. Expected values: " + Arrays.asList(RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_JSON,
          RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_XML, RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_ZIP));
    }

  }

  public static StreamResponse retrieveAIPPart(IndexedAIP aip, String part)
    throws RequestNotValidException, NotFoundException, GenericException, AuthorizationDeniedException {
    String aipId = aip.getId();

    if (RodaConstants.STORAGE_DIRECTORY_SUBMISSION.equals(part)) {
      Directory directory = RodaCoreFactory.getModelService().getSubmissionDirectory(aipId);
      return ApiUtils.download(directory, part);
    } else if (RodaConstants.STORAGE_DIRECTORY_DOCUMENTATION.equals(part)) {
      Directory directory = RodaCoreFactory.getModelService().getDocumentationDirectory(aipId);
      return ApiUtils.download(directory, part);
    } else if (RodaConstants.STORAGE_DIRECTORY_SCHEMAS.equals(part)) {
      Directory directory = RodaCoreFactory.getModelService().getSchemasDirectory(aipId);
      return ApiUtils.download(directory, part);
    } else {
      throw new GenericException("Unsupported part: " + part);
    }
  }

  public static StreamResponse retrieveAIPs(SelectedItems<IndexedAIP> selected, String acceptFormat)
    throws GenericException, RequestNotValidException, NotFoundException, AuthorizationDeniedException, IOException {
    IndexService index = RodaCoreFactory.getIndexService();
    if (RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_BIN.equals(acceptFormat)) {
      List<ZipEntryInfo> zipEntries = new ArrayList<>();
      if (selected instanceof SelectedItemsFilter) {
        SelectedItemsFilter<IndexedAIP> selectedItems = (SelectedItemsFilter<IndexedAIP>) selected;
        long count = index.count(IndexedAIP.class, selectedItems.getFilter());
        for (int i = 0; i < count; i += RodaConstants.DEFAULT_PAGINATION_VALUE) {
          List<IndexedAIP> aips = index.find(IndexedAIP.class, selectedItems.getFilter(), null,
            new Sublist(i, RodaConstants.DEFAULT_PAGINATION_VALUE), null).getResults();
          zipEntries.addAll(ModelUtils.zipIndexedAIP(aips));
        }
      } else {
        SelectedItemsList<IndexedAIP> selectedItems = (SelectedItemsList<IndexedAIP>) selected;
        zipEntries.addAll(ModelUtils.zipIndexedAIP(ModelUtils.getIndexedAIPsFromObjectIds(selectedItems)));
      }
      return DownloadUtils.createZipStreamResponse(zipEntries, "export");
    } else if (RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_JSON.equals(acceptFormat)) {
      throw new GenericException("Not yet supported: " + acceptFormat);
    } else {
      throw new GenericException("Unsupported accept format: " + acceptFormat);
    }
  }

  public static RiskMitigationBundle retrieveShowMitigationTerms(int preMitigationProbability, int preMitigationImpact,
    int posMitigationProbability, int posMitigationImpact) {

    int lowLimit = RodaCoreFactory.getRodaConfigurationAsInt("ui", "risk", "mitigationSeverity", "lowLimit");
    int highLimit = RodaCoreFactory.getRodaConfigurationAsInt("ui", "risk", "mitigationSeverity", "highLimit");

    String preProbability = RodaCoreFactory.getRodaConfigurationAsString("ui", "risk", "mitigationProbability",
      Integer.toString(preMitigationProbability));
    String preImpact = RodaCoreFactory.getRodaConfigurationAsString("ui", "risk", "mitigationImpact",
      Integer.toString(preMitigationImpact));
    String posProbability = RodaCoreFactory.getRodaConfigurationAsString("ui", "risk", "mitigationProbability",
      Integer.toString(posMitigationProbability));
    String posImpact = RodaCoreFactory.getRodaConfigurationAsString("ui", "risk", "mitigationImpact",
      Integer.toString(posMitigationImpact));

    return new RiskMitigationBundle(lowLimit, highLimit, preProbability, preImpact, posProbability, posImpact);
  }

  public static List<String> retrieveShowMitigationTerms() {
    List<String> terms = new ArrayList<>();
    terms.add(RodaCoreFactory.getRodaConfigurationAsString("ui", "risk", "mitigationSeverity", "lowLimit"));
    terms.add(RodaCoreFactory.getRodaConfigurationAsString("ui", "risk", "mitigationSeverity", "highLimit"));
    return terms;
  }

  public static MitigationPropertiesBundle retrieveAllMitigationProperties() {
    int lowLimit = RodaCoreFactory.getRodaConfigurationAsInt("ui", "risk", "mitigationSeverity", "lowLimit");
    int highLimit = RodaCoreFactory.getRodaConfigurationAsInt("ui", "risk", "mitigationSeverity", "highLimit");

    int probabilityLimit = RodaCoreFactory.getRodaConfigurationAsInt("ui", "risk", "mitigationProbability", "limit");
    int impactLimit = RodaCoreFactory.getRodaConfigurationAsInt("ui", "risk", "mitigationImpact", "limit");

    // second list contains probability content
    List<String> probabilities = new ArrayList<>();
    for (int i = 0; i <= probabilityLimit; i++) {
      String value = Integer.toString(i);
      probabilities.add(RodaCoreFactory.getRodaConfigurationAsString("ui", "risk", "mitigationProbability", value));
    }

    // third list contains impact content
    List<String> impacts = new ArrayList<>();
    for (int i = 0; i <= impactLimit; i++) {
      String value = Integer.toString(i);
      impacts.add(RodaCoreFactory.getRodaConfigurationAsString("ui", "risk", "mitigationImpact", value));
    }

    return new MitigationPropertiesBundle(lowLimit, highLimit, probabilities, impacts);
  }

  public static void deleteRisk(User user, SelectedItems<IndexedRisk> selected)
    throws GenericException, AuthorizationDeniedException, RequestNotValidException, NotFoundException,
    InvalidParameterException, JobAlreadyStartedException {
    Job job = new Job();
    job.setId(IdUtils.createUUID());
    job.setName("Delete risks");
    job.setSourceObjects(selected);
    job.setPlugin(DeleteRODAObjectPlugin.class.getCanonicalName());
    job.setPluginType(PluginType.INTERNAL);
    job.setUsername(user.getName());

    try {
      RodaCoreFactory.getModelService().createJob(job);
      RodaCoreFactory.getPluginOrchestrator().executeJob(job, true);
    } catch (JobAlreadyStartedException e) {
      LOGGER.error("Could not execute risk delete action", e);
    }
  }

  public static void deleteFormat(User user, SelectedItems<Format> selected)
    throws GenericException, AuthorizationDeniedException, RequestNotValidException, NotFoundException {
    Job job = new Job();
    job.setId(IdUtils.createUUID());
    job.setName("Delete formats");
    job.setSourceObjects(selected);
    job.setPlugin(DeleteRODAObjectPlugin.class.getCanonicalName());
    job.setPluginType(PluginType.INTERNAL);
    job.setUsername(user.getName());

    try {
      RodaCoreFactory.getModelService().createJob(job);
      RodaCoreFactory.getPluginOrchestrator().executeJob(job, true);
    } catch (JobAlreadyStartedException e) {
      LOGGER.error("Could not execute format delete action", e);
    }
  }

  public static void updateRiskCounters() throws GenericException, RequestNotValidException, NotFoundException {
    IndexService index = RodaCoreFactory.getIndexService();

    IndexResult<RiskIncidence> findAllRiskIncidences = index.find(RiskIncidence.class, Filter.ALL, Sorter.NONE,
      new Sublist(0, 0), new Facets(new SimpleFacetParameter(RodaConstants.RISK_INCIDENCE_RISK_ID)),
      Arrays.asList(RodaConstants.INDEX_UUID));

    Filter filter = new Filter(
      new SimpleFilterParameter(RodaConstants.RISK_INCIDENCE_STATUS, INCIDENCE_STATUS.UNMITIGATED.toString()));
    IndexResult<RiskIncidence> findNotMitigatedRiskIncidences = index.find(RiskIncidence.class, filter, Sorter.NONE,
      new Sublist(0, 0), new Facets(new SimpleFacetParameter(RodaConstants.RISK_INCIDENCE_RISK_ID)),
      Arrays.asList(RodaConstants.INDEX_UUID));

    Map<String, IndexedRisk> allRisks = new HashMap<>();

    // retrieve risks and set default object count to zero
    IterableIndexResult<IndexedRisk> risks = index.findAll(IndexedRisk.class, Filter.ALL, new ArrayList<>());
    for (IndexedRisk indexedRisk : risks) {
      indexedRisk.setIncidencesCount(0);
      indexedRisk.setUnmitigatedIncidencesCount(0);
      allRisks.put(indexedRisk.getId(), indexedRisk);
    }

    // update risks from facets (all incidences)
    for (FacetFieldResult fieldResult : findAllRiskIncidences.getFacetResults()) {
      for (FacetValue facetValue : fieldResult.getValues()) {
        String riskId = facetValue.getValue();
        long counter = facetValue.getCount();

        IndexedRisk risk = allRisks.get(riskId);
        if (risk != null) {
          risk.setIncidencesCount((int) counter);
        } else {
          LOGGER.warn("Updating risk counters found incidences pointing to non-existing risk: {}", riskId);
        }
      }
    }

    // update risks from facets (not mitigated incidences)
    for (FacetFieldResult fieldResult : findNotMitigatedRiskIncidences.getFacetResults()) {
      for (FacetValue facetValue : fieldResult.getValues()) {
        String riskId = facetValue.getValue();
        long counter = facetValue.getCount();

        IndexedRisk risk = allRisks.get(riskId);
        if (risk != null) {
          risk.setUnmitigatedIncidencesCount((int) counter);
        } else {
          LOGGER.warn("Updating risk counters found incidences pointing to non-existing risk: {}", riskId);
        }
      }
    }

    // update all in index
    for (IndexedRisk risk : allRisks.values()) {
      index.reindexRisk(risk);
    }

    index.commit(IndexedRisk.class);
  }

  public static void appraisal(User user, SelectedItems<IndexedAIP> selected, boolean accept, String rejectReason,
    Locale locale) throws GenericException, AuthorizationDeniedException, RequestNotValidException, NotFoundException {
    List<String> listOfIds = consolidate(user, IndexedAIP.class, selected);

    ModelService model = RodaCoreFactory.getModelService();
    IndexService index = RodaCoreFactory.getIndexService();
    Date now = new Date();

    // map of job id -> (total, accepted)
    Map<String, Pair<Integer, Integer>> jobState = new HashMap<>();
    List<String> aipsToDelete = new ArrayList<>();

    String userAgentId;
    try {
      boolean notifyAgent = true;
      PreservationMetadata pm = PremisV3Utils.createPremisUserAgentBinary(user.getName(), model, index, notifyAgent);
      userAgentId = pm.getId();
    } catch (AlreadyExistsException e) {
      userAgentId = IdUtils.getUserAgentId(user.getName());
    } catch (ValidationException e) {
      throw new GenericException(e);
    }

    for (String aipId : listOfIds) {
      AIP aip = model.retrieveAIP(aipId);
      String jobId = aip.getIngestJobId();
      if (accept) {
        // Accept AIP
        aip.setState(AIPState.ACTIVE);
        model.updateAIPState(aip, user.getName());

        // create preservation event
        String id = IdUtils.createPreservationMetadataId(PreservationMetadataType.EVENT);
        PreservationEventType type = PreservationEventType.ACCESSION;
        String preservationEventDescription = AutoAcceptSIPPlugin.DESCRIPTION;
        List<LinkingIdentifier> sources = new ArrayList<>();
        List<LinkingIdentifier> outcomes = Arrays
          .asList(PluginHelper.getLinkingIdentifier(aipId, RodaConstants.PRESERVATION_LINKING_OBJECT_OUTCOME));
        PluginState outcome = PluginState.SUCCESS;
        String outcomeDetailNote = AutoAcceptSIPPlugin.SUCCESS_MESSAGE;
        String outcomeDetailExtension = null;
        boolean notifyEvent = true;
        try {
          ContentPayload premisEvent = PremisV3Utils.createPremisEventBinary(id, now, type.toString(),
            preservationEventDescription, sources, outcomes, outcome.name(), outcomeDetailNote, outcomeDetailExtension,
            Arrays.asList(userAgentId));

          model.createPreservationMetadata(PreservationMetadataType.EVENT, id, aipId, null, null, null, premisEvent,
            notifyEvent);
        } catch (AlreadyExistsException | ValidationException e) {
          throw new GenericException(e);
        }

      } else {
        // Reject AIP
        model.deleteAIP(aipId);
        aipsToDelete.add(aipId);
      }

      // create job report
      Job job = model.retrieveJob(jobId);
      Report report = model.retrieveJobReport(jobId, aipId, true);

      Report reportItem = new Report();
      Messages messages = RodaCoreFactory.getI18NMessages(locale);
      reportItem.setTitle(messages.getTranslation(RodaConstants.I18N_UI_APPRAISAL));
      reportItem.setPlugin(messages.getTranslation(RodaConstants.I18N_UI_APPRAISAL));
      reportItem.setPluginDetails(rejectReason);
      reportItem.setPluginState(accept ? PluginState.SUCCESS : PluginState.FAILURE);
      reportItem.setOutcomeObjectState(accept ? AIPState.ACTIVE : AIPState.DELETED);
      reportItem.setDateCreated(now);
      report.addReport(reportItem);

      model.createOrUpdateJobReport(report, job);

      // save job state
      Pair<Integer, Integer> pair = jobState.get(jobId);
      if (pair == null) {
        jobState.put(jobId, Pair.of(1, accept ? 1 : 0));
      } else {
        jobState.put(jobId, Pair.of(pair.getFirst() + 1, pair.getSecond() + (accept ? 1 : 0)));
      }
    }

    // update job counters
    for (Entry<String, Pair<Integer, Integer>> entry : jobState.entrySet()) {
      String jobId = entry.getKey();
      int total = entry.getValue().getFirst();
      int accepted = entry.getValue().getSecond();
      int rejected = total - accepted;
      Job job = model.retrieveJob(jobId);
      if (rejected > 0) {
        // change counter to failure
        job.getJobStats()
          .setSourceObjectsProcessedWithSuccess(job.getJobStats().getSourceObjectsProcessedWithSuccess() - rejected);
        job.getJobStats()
          .setSourceObjectsProcessedWithFailure(job.getJobStats().getSourceObjectsProcessedWithFailure() + rejected);
      }

      // decrement manual interaction counter
      job.getJobStats()
        .setOutcomeObjectsWithManualIntervention(job.getJobStats().getOutcomeObjectsWithManualIntervention() - total);

      model.createOrUpdateJob(job);

    }

    RodaCoreFactory.getIndexService().commit(IndexedAIP.class, Job.class, IndexedReport.class,
      IndexedPreservationEvent.class);
  }

  public static String retrieveDescriptiveMetadataPreview(SupportedMetadataTypeBundle bundle) throws GenericException {
    String rawTemplate = bundle.getTemplate();
    String result;
    if (StringUtils.isNotBlank(rawTemplate)) {

      Map<String, String> data = new HashMap<>();
      Set<MetadataValue> values = bundle.getValues();
      if (values != null) {
        values.forEach(metadataValue -> {
          String val = metadataValue.get("value");
          if (val != null) {
            val = val.replaceAll("\\s", "");
            if (!"".equals(val)) {
              data.put(metadataValue.get("name"), metadataValue.get("value"));
            }
          }
        });
      }

      result = HandlebarsUtility.executeHandlebars(rawTemplate, data);
      // result = RodaUtils.indentXML(result);

    } else {
      result = rawTemplate;
    }
    return result;
  }

  public static String renameTransferredResource(String transferredResourceId, String newName) throws GenericException,
    RequestNotValidException, AlreadyExistsException, IsStillUpdatingException, NotFoundException {
    List<String> resourceFields = Arrays.asList(RodaConstants.INDEX_UUID, RodaConstants.TRANSFERRED_RESOURCE_FULLPATH,
      RodaConstants.TRANSFERRED_RESOURCE_PARENT_UUID);

    Filter filter = new Filter(new SimpleFilterParameter(RodaConstants.INDEX_UUID, transferredResourceId));
    IndexResult<TransferredResource> resources = RodaCoreFactory.getIndexService().find(TransferredResource.class,
      filter, Sorter.NONE, new Sublist(0, 1), resourceFields);

    if (!resources.getResults().isEmpty()) {
      TransferredResource resource = resources.getResults().get(0);
      return RodaCoreFactory.getTransferredResourcesScanner().renameTransferredResource(resource, newName, true, true);
    } else {
      return transferredResourceId;
    }
  }

  public static IndexedFile renameFolder(User user, String folderUUID, String newName, String details)
    throws GenericException, RequestNotValidException, AlreadyExistsException, NotFoundException,
    AuthorizationDeniedException {
    String eventDescription = "The process of updating an object of the repository.";

    ModelService model = RodaCoreFactory.getModelService();
    IndexService index = RodaCoreFactory.getIndexService();
    IndexedFile ifolder = index.retrieve(IndexedFile.class, folderUUID, RodaConstants.FILE_FIELDS_TO_RETURN);
    String oldName = ifolder.getId();

    try {
      File folder = model.retrieveFile(ifolder.getAipId(), ifolder.getRepresentationId(), ifolder.getPath(),
        ifolder.getId());
      File newFolder = model.renameFolder(folder, newName, true, true);
      String outcomeText = "The folder '" + oldName + "' has been manually renamed to '" + newName + "'.";
      model.createUpdateAIPEvent(ifolder.getAipId(), ifolder.getRepresentationId(), null, null,
        PreservationEventType.UPDATE, eventDescription, PluginState.SUCCESS, outcomeText, details, user.getName(),
        true);

      index.commitAIPs();
      return index.retrieve(IndexedFile.class, IdUtils.getFileId(newFolder), RodaConstants.FILE_FIELDS_TO_RETURN);
    } catch (RequestNotValidException | NotFoundException | GenericException | AuthorizationDeniedException e) {
      String outcomeText = "The folder '" + oldName + "' has not been manually renamed to '" + newName + "'.";

      model.createUpdateAIPEvent(ifolder.getAipId(), ifolder.getRepresentationId(), null, null,
        PreservationEventType.UPDATE, eventDescription, PluginState.FAILURE, outcomeText, details, user.getName(),
        true);

      throw e;
    }
  }

  public static void moveFiles(User user, String aipId, String representationId,
    SelectedItems<IndexedFile> selectedFiles, IndexedFile toFolder, String details) throws GenericException,
    RequestNotValidException, AlreadyExistsException, NotFoundException, AuthorizationDeniedException {

    if (toFolder != null
      && (!toFolder.getAipId().equals(aipId) || !toFolder.getRepresentationId().equals(representationId))) {
      throw new RequestNotValidException("Cannot move to a file outside defined representation");
    }

    Job job = new Job();
    job.setId(IdUtils.createUUID());
    job.setName("Move files");
    job.setSourceObjects(selectedFiles);
    job.setPlugin(MovePlugin.class.getCanonicalName());
    job.setPluginType(PluginType.INTERNAL);
    job.setUsername(user.getName());

    Map<String, String> pluginParameters = new HashMap<>();
    if (toFolder != null) {
      pluginParameters.put(RodaConstants.PLUGIN_PARAMS_ID, toFolder.getUUID());
    }
    pluginParameters.put(RodaConstants.PLUGIN_PARAMS_DETAILS, details);
    job.setPluginParameters(pluginParameters);

    try {
      RodaCoreFactory.getModelService().createJob(job);
      RodaCoreFactory.getPluginOrchestrator().executeJob(job, true);
    } catch (JobAlreadyStartedException e) {
      LOGGER.error("Could not execute move job", e);
    }
  }

  public static String moveTransferredResource(User user, SelectedItems<TransferredResource> selected,
    TransferredResource transferredResource) throws GenericException, RequestNotValidException, AlreadyExistsException,
    IsStillUpdatingException, NotFoundException {

    String resourceRelativePath = "";
    String uuid = null;
    if (transferredResource != null) {
      resourceRelativePath = transferredResource.getRelativePath();
      uuid = transferredResource.getUUID();
    }

    Job job = new Job();
    job.setId(IdUtils.createUUID());
    job.setName("Move transferred resources");
    job.setSourceObjects(selected);
    job.setPlugin(MovePlugin.class.getCanonicalName());
    job.setPluginType(PluginType.INTERNAL);
    job.setUsername(user.getName());

    Map<String, String> pluginParameters = new HashMap<>();
    pluginParameters.put(RodaConstants.PLUGIN_PARAMS_ID, resourceRelativePath);
    job.setPluginParameters(pluginParameters);

    try {
      RodaCoreFactory.getModelService().createJob(job);
      RodaCoreFactory.getPluginOrchestrator().executeJob(job, true);
    } catch (JobAlreadyStartedException | AuthorizationDeniedException e) {
      LOGGER.error("Could not execute move job", e);
    }

    return uuid;
  }

  public static IndexedFile createFolder(User user, String aipId, String representationId, String folderUUID,
    String newName, String details) throws GenericException, RequestNotValidException, AlreadyExistsException,
    NotFoundException, AuthorizationDeniedException {
    String eventDescription = "The process of creating an object of the repository.";

    ModelService model = RodaCoreFactory.getModelService();
    IndexService index = RodaCoreFactory.getIndexService();
    File newFolder;
    IndexedRepresentation irep = index.retrieve(IndexedRepresentation.class,
      IdUtils.getRepresentationId(aipId, representationId), RodaConstants.REPRESENTATION_FIELDS_TO_RETURN);

    try {
      if (folderUUID != null) {
        IndexedFile ifolder = index.retrieve(IndexedFile.class, folderUUID, RodaConstants.FILE_FIELDS_TO_RETURN);
        newFolder = model.createFile(ifolder.getAipId(), ifolder.getRepresentationId(), ifolder.getPath(),
          ifolder.getId(), newName, true);
      } else {
        newFolder = model.createFile(irep.getAipId(), irep.getId(), null, null, newName, true);
      }

      String outcomeText = "The folder '" + newName + "' has been manually created.";
      model.createUpdateAIPEvent(aipId, irep.getId(), null, null, PreservationEventType.CREATION, eventDescription,
        PluginState.SUCCESS, outcomeText, details, user.getName(), true);

      index.commit(IndexedFile.class);
      return index.retrieve(IndexedFile.class, IdUtils.getFileId(newFolder), new ArrayList<>());
    } catch (RequestNotValidException | NotFoundException | GenericException | AuthorizationDeniedException e) {
      String outcomeText = "The folder '" + newName + "' has not been manually created.";
      model.createUpdateAIPEvent(aipId, irep.getId(), null, null, PreservationEventType.CREATION, eventDescription,
        PluginState.FAILURE, outcomeText, details, user.getName(), true);

      throw e;
    }
  }

  public static List<TransferredResource> retrieveSelectedTransferredResource(
    SelectedItems<TransferredResource> selected) throws GenericException, RequestNotValidException {
    if (selected instanceof SelectedItemsList) {
      SelectedItemsList<TransferredResource> selectedList = (SelectedItemsList<TransferredResource>) selected;
      Filter filter = new Filter(new OneOfManyFilterParameter(RodaConstants.INDEX_UUID, selectedList.getIds()));
      IndexResult<TransferredResource> iresults = RodaCoreFactory.getIndexService().find(TransferredResource.class,
        filter, Sorter.NONE, new Sublist(0, selectedList.getIds().size()), new ArrayList<>());
      return iresults.getResults();
    } else if (selected instanceof SelectedItemsFilter) {
      SelectedItemsFilter<TransferredResource> selectedFilter = (SelectedItemsFilter<TransferredResource>) selected;
      Long counter = RodaCoreFactory.getIndexService().count(TransferredResource.class, selectedFilter.getFilter());
      IndexResult<TransferredResource> iresults = RodaCoreFactory.getIndexService().find(TransferredResource.class,
        selectedFilter.getFilter(), Sorter.NONE, new Sublist(0, counter.intValue()), new ArrayList<>());
      return iresults.getResults();
    } else {
      return new ArrayList<>();
    }
  }

  public static void updateRiskIncidence(RiskIncidence incidence) throws GenericException {
    RodaCoreFactory.getModelService().updateRiskIncidence(incidence, true);
  }

  protected static Reports listReports(int start, int limit)
    throws RequestNotValidException, NotFoundException, GenericException, AuthorizationDeniedException {
    Sorter sorter = new Sorter(new SortParameter(RodaConstants.JOB_REPORT_DATE_UPDATED, true));
    IndexResult<IndexedReport> indexReports = RodaCoreFactory.getIndexService().find(IndexedReport.class, Filter.ALL,
      sorter, new Sublist(start, limit), new ArrayList<>());
    List<Report> results = indexReports.getResults().stream().map(ireport -> (Report) ireport)
      .collect(Collectors.toList());
    return new Reports(results);
  }

  protected static Reports listTransferredResourcesReports(String resourceId, int start, int limit)
    throws RequestNotValidException, NotFoundException, GenericException, AuthorizationDeniedException {
    Filter filter = new Filter();
    filter.add(
      new SimpleFilterParameter(RodaConstants.JOB_REPORT_SOURCE_OBJECT_CLASS, TransferredResource.class.getName()));
    filter.add(new SimpleFilterParameter(RodaConstants.JOB_REPORT_SOURCE_OBJECT_ID, resourceId));
    filter.add(new OneOfManyFilterParameter(RodaConstants.JOB_REPORT_OUTCOME_OBJECT_CLASS,
      Arrays.asList(AIP.class.getName(), IndexedAIP.class.getName())));

    Sorter sorter = new Sorter(new SortParameter(RodaConstants.JOB_REPORT_DATE_UPDATED, true));
    IndexResult<IndexedReport> reports = RodaCoreFactory.getIndexService().find(IndexedReport.class, filter, sorter,
      new Sublist(start, limit), new ArrayList<>());
    List<Report> results = reports.getResults().stream().map(ireport -> (Report) ireport).collect(Collectors.toList());
    return new Reports(results);
  }

  protected static Reports listTransferredResourcesReportsWithSIP(String sipId, int start, int limit)
    throws RequestNotValidException, NotFoundException, GenericException, AuthorizationDeniedException {
    Filter filter = new Filter();
    filter.add(new OneOfManyFilterParameter(RodaConstants.JOB_REPORT_OUTCOME_OBJECT_CLASS,
      Arrays.asList(AIP.class.getName(), IndexedAIP.class.getName())));
    filter.add(new SimpleFilterParameter(RodaConstants.JOB_REPORT_SOURCE_OBJECT_ORIGINAL_IDS, sipId));

    Sorter sorter = new Sorter(new SortParameter(RodaConstants.JOB_REPORT_DATE_UPDATED, true));
    IndexResult<IndexedReport> indexReports = RodaCoreFactory.getIndexService().find(IndexedReport.class, filter,
      sorter, new Sublist(start, limit), new ArrayList<>());
    List<Report> results = indexReports.getResults().stream().map(ireport -> (Report) ireport)
      .collect(Collectors.toList());
    return new Reports(results);
  }

  public static void deleteRiskIncidences(User user, SelectedItems<RiskIncidence> selected)
    throws GenericException, AuthorizationDeniedException, RequestNotValidException, NotFoundException,
    InvalidParameterException, JobAlreadyStartedException {
    List<String> idList = consolidate(user, RiskIncidence.class, selected);
    for (String incidenceId : idList) {
      RodaCoreFactory.getModelService().deleteRiskIncidence(incidenceId, true);
    }
  }

  public static void updateMultipleIncidences(SelectedItems<RiskIncidence> selected, String status, String severity,
    Date mitigatedOn, String mitigatedBy, String mitigatedDescription)
    throws RequestNotValidException, GenericException, NotFoundException, AuthorizationDeniedException {
    IndexService index = RodaCoreFactory.getIndexService();
    ModelService model = RodaCoreFactory.getModelService();

    if (selected instanceof SelectedItemsList) {
      SelectedItemsList<RiskIncidence> list = (SelectedItemsList<RiskIncidence>) selected;
      List<String> ids = list.getIds();

      for (String id : ids) {
        RiskIncidence incidence = RodaCoreFactory.getModelService().retrieveRiskIncidence(id);
        incidence.setStatus(INCIDENCE_STATUS.valueOf(status));
        incidence.setSeverity(SEVERITY_LEVEL.valueOf(severity));
        incidence.setMitigatedOn(mitigatedOn);
        incidence.setMitigatedBy(mitigatedBy);
        incidence.setMitigatedDescription(mitigatedDescription);
        model.updateRiskIncidence(incidence, false);
      }

      index.commit(RiskIncidence.class);
    } else if (selected instanceof SelectedItemsFilter) {
      SelectedItemsFilter<RiskIncidence> filter = (SelectedItemsFilter<RiskIncidence>) selected;

      int counter = index.count(RiskIncidence.class, filter.getFilter()).intValue();
      IndexResult<RiskIncidence> incidences = index.find(RiskIncidence.class, filter.getFilter(), Sorter.NONE,
        new Sublist(0, counter), new ArrayList<>());

      for (RiskIncidence incidence : incidences.getResults()) {
        incidence.setStatus(INCIDENCE_STATUS.valueOf(status));
        incidence.setSeverity(SEVERITY_LEVEL.valueOf(severity));
        incidence.setMitigatedOn(mitigatedOn);
        incidence.setMitigatedBy(mitigatedBy);
        incidence.setMitigatedDescription(mitigatedDescription);
        model.updateRiskIncidence(incidence, false);
      }

      index.commit(RiskIncidence.class);
    }
  }

  public static TransferredResource reindexTransferredResource(String path)
    throws IsStillUpdatingException, NotFoundException, GenericException {
    TransferredResourcesScanner scanner = RodaCoreFactory.getTransferredResourcesScanner();
    scanner.updateTransferredResources(Optional.of(path), true);
    return RodaCoreFactory.getIndexService().retrieve(TransferredResource.class,
      IdUtils.getTransferredResourceUUID(path), new ArrayList<>());
  }

  public static DIP createDIP(DIP dip) throws GenericException, AuthorizationDeniedException {
    return RodaCoreFactory.getModelService().createDIP(dip, true);
  }

  public static DIP updateDIP(DIP dip) throws GenericException, AuthorizationDeniedException, NotFoundException {
    return RodaCoreFactory.getModelService().updateDIP(dip);
  }

  public static void deleteDIPs(SelectedItems<IndexedDIP> selected, User user)
    throws GenericException, AuthorizationDeniedException, NotFoundException, RequestNotValidException {
    for (String dipId : consolidate(user, IndexedDIP.class, selected)) {
      RodaCoreFactory.getModelService().deleteDIP(dipId);
    }
    RodaCoreFactory.getIndexService().commit(IndexedDIP.class);
  }

  protected static EntityResponse retrieveDIP(String dipId, String acceptFormat)
    throws GenericException, RequestNotValidException, NotFoundException, AuthorizationDeniedException {

    if (RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_ZIP.equals(acceptFormat)) {
      StorageService storage = RodaCoreFactory.getStorageService();
      StoragePath storagePath = ModelUtils.getDIPDataStoragePath(dipId);

      if (!storage.hasDirectory(storagePath)) {
        storagePath = ModelUtils.getDIPStoragePath(dipId);
      }

      return ApiUtils.download(storage.getDirectory(storagePath), dipId);
    } else if (RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_JSON.equals(acceptFormat)
      || RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_XML.equals(acceptFormat)) {
      DIP dip = RodaCoreFactory.getModelService().retrieveDIP(dipId);
      return new ObjectResponse<DIP>(acceptFormat, dip);
    } else {
      throw new GenericException("Unsupported accept format: " + acceptFormat);
    }
  }

  public static EntityResponse retrieveDIPFile(String fileUuid, String acceptFormat)
    throws GenericException, RequestNotValidException, NotFoundException, AuthorizationDeniedException {

    DIPFile iFile = RodaCoreFactory.getIndexService().retrieve(DIPFile.class, fileUuid,
      RodaConstants.DIPFILE_FIELDS_TO_RETURN);

    if (!iFile.isDirectory() && RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_BIN.equals(acceptFormat)) {
      final String filename;
      final String mediaType;
      final ConsumesOutputStream stream;

      StorageService storage = RodaCoreFactory.getStorageService();
      Binary representationFileBinary = storage.getBinary(ModelUtils.getDIPFileStoragePath(iFile));
      filename = representationFileBinary.getStoragePath().getName();
      mediaType = RodaConstants.MEDIA_TYPE_WILDCARD;

      stream = new ConsumesOutputStream() {

        @Override
        public String getMediaType() {
          return acceptFormat;
        }

        @Override
        public String getFileName() {
          return filename;
        }

        @Override
        public void consumeOutputStream(OutputStream out) throws IOException {
          InputStream fileInputStream = null;
          try {
            fileInputStream = representationFileBinary.getContent().createInputStream();
            IOUtils.copy(fileInputStream, out);
          } finally {
            IOUtils.closeQuietly(fileInputStream);
          }
        }
      };
      return new StreamResponse(filename, mediaType, stream);
    } else if (iFile.isDirectory() && (RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_ZIP.equals(acceptFormat)
      || RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_BIN.equals(acceptFormat))) {
      StoragePath filePath = ModelUtils.getDIPFileStoragePath(iFile);
      Directory directory = RodaCoreFactory.getStorageService().getDirectory(filePath);
      return ApiUtils.download(directory);
    } else if (RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_JSON.equals(acceptFormat)
      || RodaConstants.API_QUERY_VALUE_ACCEPT_FORMAT_XML.equals(acceptFormat)) {
      DIPFile file = RodaCoreFactory.getModelService().retrieveDIPFile(iFile.getDipId(), iFile.getPath(),
        iFile.getId());
      return new ObjectResponse<DIPFile>(acceptFormat, file);
    } else {
      throw new GenericException("Unsupported accept format: " + acceptFormat);
    }
  }

  public static DIPFile createDIPFile(String dipId, List<String> directoryPath, String fileId, long size,
    ContentPayload content, boolean notify) throws GenericException, AuthorizationDeniedException,
    RequestNotValidException, NotFoundException, AlreadyExistsException {
    return RodaCoreFactory.getModelService().createDIPFile(dipId, directoryPath, fileId, size, content, notify);
  }

  public static String createDIPFolder(String dipId, String folderUUID, String newName) throws GenericException,
    RequestNotValidException, AlreadyExistsException, NotFoundException, AuthorizationDeniedException {
    ModelService model = RodaCoreFactory.getModelService();
    IndexService index = RodaCoreFactory.getIndexService();

    if (folderUUID != null) {
      DIPFile ifolder = index.retrieve(DIPFile.class, folderUUID, RodaConstants.DIPFILE_FIELDS_TO_RETURN);
      DIPFile newFolder = model.createDIPFile(ifolder.getDipId(), ifolder.getPath(), ifolder.getId(), newName, true);
      index.commit(DIPFile.class);
      return IdUtils.getDIPFileId(newFolder);
    } else {
      DIPFile newFolder = model.createDIPFile(dipId, null, null, newName, true);
      index.commit(DIPFile.class);
      return IdUtils.getDIPFileId(newFolder);
    }
  }

  public static DIPFile updateDIPFile(String dipId, List<String> directoryPath, String oldFileId, String fileId,
    long size, ContentPayload content, boolean notify) throws GenericException, AuthorizationDeniedException,
    NotFoundException, RequestNotValidException, AlreadyExistsException {
    return RodaCoreFactory.getModelService().updateDIPFile(dipId, directoryPath, oldFileId, fileId, size, content, true,
      notify);
  }

  public static void deleteDIPFiles(SelectedItems<DIPFile> selected, User user)
    throws AuthorizationDeniedException, GenericException, RequestNotValidException, NotFoundException {
    List<String> fileIds = consolidate(user, DIPFile.class, selected);

    Filter filter = new Filter();
    filter.add(new OneOfManyFilterParameter(RodaConstants.INDEX_UUID, fileIds));
    IndexResult<DIPFile> files = RodaCoreFactory.getIndexService().find(DIPFile.class, filter, Sorter.NONE,
      new Sublist(0, fileIds.size()), RodaConstants.DIPFILE_FIELDS_TO_RETURN);

    for (DIPFile file : files.getResults()) {
      RodaCoreFactory.getModelService().deleteDIPFile(file.getDipId(), file.getPath(), file.getId(), true);
    }

    RodaCoreFactory.getIndexService().commit(DIPFile.class);
  }

  public static void createFormatIdentificationJob(User user, SelectedItems<?> selected) throws GenericException,
    JobAlreadyStartedException, RequestNotValidException, NotFoundException, AuthorizationDeniedException {
    Job job = new Job();
    job.setId(IdUtils.createUUID());
    job.setName("Format identification using Siegfried");
    job.setSourceObjects(selected);
    job.setPlugin(SiegfriedPlugin.class.getCanonicalName());
    job.setPluginType(PluginType.MISC);
    job.setUsername(user.getName());
    RodaCoreFactory.getModelService().createJob(job);
    RodaCoreFactory.getPluginOrchestrator().executeJob(job, true);
  }

  public static void changeRepresentationType(User user, SelectedItems<IndexedRepresentation> selected, String newType,
    String details) throws GenericException, AuthorizationDeniedException, RequestNotValidException, NotFoundException {
    String eventDescription = "The process of updating an object of the repository.";

    List<String> representationIds = consolidate(user, IndexedRepresentation.class, selected);
    ModelService model = RodaCoreFactory.getModelService();
    IndexService index = RodaCoreFactory.getIndexService();

    Filter filter = new Filter();
    filter.add(new OneOfManyFilterParameter(RodaConstants.INDEX_UUID, representationIds));
    IndexResult<IndexedRepresentation> reps = index.find(IndexedRepresentation.class, filter, Sorter.NONE,
      new Sublist(0, representationIds.size()), Arrays.asList(RodaConstants.REPRESENTATION_ID,
        RodaConstants.REPRESENTATION_TYPE, RodaConstants.REPRESENTATION_AIP_ID));

    for (IndexedRepresentation irep : reps.getResults()) {
      String oldType = irep.getType();
      List<LinkingIdentifier> sources = new ArrayList<>();
      sources.add(PluginHelper.getLinkingIdentifier(irep.getAipId(), irep.getId(),
        RodaConstants.PRESERVATION_LINKING_OBJECT_SOURCE));

      try {
        model.updateRepresentationType(irep.getAipId(), irep.getId(), newType);
        index.commit(IndexedRepresentation.class);
        StringBuilder outcomeText = new StringBuilder().append("The representation '").append(irep.getId())
          .append("' changed its type from '").append(oldType).append("' to '").append(newType).append("'.");

        model.createEvent(irep.getAipId(), irep.getId(), null, null, PreservationEventType.UPDATE, eventDescription,
          sources, null, PluginState.SUCCESS, outcomeText.toString(), details, user.getName(), true);
      } catch (RequestNotValidException | NotFoundException | GenericException | AuthorizationDeniedException e) {
        StringBuilder outcomeText = new StringBuilder().append("The representation '").append(irep.getId())
          .append("' did not change its type from '").append(oldType).append("' to '").append(newType).append("'.");

        model.createEvent(irep.getAipId(), irep.getId(), null, null, PreservationEventType.UPDATE, eventDescription,
          sources, null, PluginState.FAILURE, outcomeText.toString(), details, user.getName(), true);
        throw e;
      }
    }
  }

  public static ObjectPermissionResult verifyPermissions(String username, String permissionType,
    MultivaluedMap<String, String> queryParams)
    throws GenericException, NotFoundException, AuthorizationDeniedException, RequestNotValidException {
    ObjectPermissionResult result = new ObjectPermissionResult();
    for (Entry<String, List<String>> entry : queryParams.entrySet()) {
      String queryKey = entry.getKey();
      try {
        Class.forName(queryKey);
        for (String queryValues : entry.getValue()) {
          boolean hasPermission = RodaCoreFactory.getModelService().checkObjectPermission(username, permissionType,
            queryKey, queryValues);
          result.addObject(new ObjectPermission(queryKey, queryValues, hasPermission));
        }
      } catch (ClassNotFoundException e) {
        // do nothing
      }
    }
    return result;
  }

  public static boolean hasDocumentation(String aipId)
    throws RequestNotValidException, AuthorizationDeniedException, GenericException {
    StoragePath aipPath = ModelUtils.getAIPStoragePath(aipId);
    StoragePath documentationPath = DefaultStoragePath.parse(aipPath, RodaConstants.STORAGE_DIRECTORY_DOCUMENTATION);
    try {
      Long counter = RodaCoreFactory.getStorageService().countResourcesUnderContainer(documentationPath, false);
      return counter > 0;
    } catch (NotFoundException e) {
      return false;
    }
  }

}