+ "</pre></p>",
      restParameters = {
          @RestParameter(description = "The kind of media track. This has to be specified prior to each media track", isRequired = true, name = "flavor", type = RestParameter.Type.STRING),
          @RestParameter(description = "Episode metadata value", isRequired = false, name = "abstract", type = RestParameter.Type.STRING),
          @RestParameter(description = "Episode metadata value", isRequired = false, name = "accessRights", type = RestParameter.Type.STRING),
          @RestParameter(description = "Episode metadata value", isRequired = false, name = "available", type = RestParameter.Type.STRING),
          @RestParameter(description = "Episode metadata value", isRequired = false, name = "contributor", type = RestParameter.Type.STRING),
          @RestParameter(description = "Episode metadata value", isRequired = false, name = "coverage", type = RestParameter.Type.STRING),
          @RestParameter(description = "Episode metadata value", isRequired = false, name = "created", type = RestParameter.Type.STRING),
          @RestParameter(description = "Episode metadata value", isRequired = false, name = "creator", type = RestParameter.Type.STRING),
          @RestParameter(description = "Episode metadata value", isRequired = false, name = "date", type = RestParameter.Type.STRING),
          @RestParameter(description = "Episode metadata value", isRequired = false, name = "description", type = RestParameter.Type.STRING),
          @RestParameter(description = "Episode metadata value", isRequired = false, name = "extent", type = RestParameter.Type.STRING),
          @RestParameter(description = "Episode metadata value", isRequired = false, name = "format", type = RestParameter.Type.STRING),
          @RestParameter(description = "Episode metadata value", isRequired = false, name = "identifier", type = RestParameter.Type.STRING),
          @RestParameter(description = "Episode metadata value", isRequired = false, name = "isPartOf", type = RestParameter.Type.STRING),
          @RestParameter(description = "Episode metadata value", isRequired = false, name = "isReferencedBy", type = RestParameter.Type.STRING),
          @RestParameter(description = "Episode metadata value", isRequired = false, name = "isReplacedBy", type = RestParameter.Type.STRING),
          @RestParameter(description = "Episode metadata value", isRequired = false, name = "language", type = RestParameter.Type.STRING),
          @RestParameter(description = "Episode metadata value", isRequired = false, name = "license", type = RestParameter.Type.STRING),
          @RestParameter(description = "Episode metadata value", isRequired = false, name = "publisher", type = RestParameter.Type.STRING),
          @RestParameter(description = "Episode metadata value", isRequired = false, name = "relation", type = RestParameter.Type.STRING),
          @RestParameter(description = "Episode metadata value", isRequired = false, name = "replaces", type = RestParameter.Type.STRING),
          @RestParameter(description = "Episode metadata value", isRequired = false, name = "rights", type = RestParameter.Type.STRING),
          @RestParameter(description = "Episode metadata value", isRequired = false, name = "rightsHolder", type = RestParameter.Type.STRING),
          @RestParameter(description = "Episode metadata value", isRequired = false, name = "source", type = RestParameter.Type.STRING),
          @RestParameter(description = "Episode metadata value", isRequired = false, name = "spatial", type = RestParameter.Type.STRING),
          @RestParameter(description = "Episode metadata value", isRequired = false, name = "subject", type = RestParameter.Type.STRING),
          @RestParameter(description = "Episode metadata value", isRequired = false, name = "temporal", type = RestParameter.Type.STRING),
          @RestParameter(description = "Episode metadata value", isRequired = false, name = "title", type = RestParameter.Type.STRING),
          @RestParameter(description = "Episode metadata value", isRequired = false, name = "type", type = RestParameter.Type.STRING),
          @RestParameter(description = "URL of episode DublinCore Catalog", isRequired = false, name = "episodeDCCatalogUri", type = RestParameter.Type.STRING),
          @RestParameter(description = "Episode DublinCore Catalog", isRequired = false, name = "episodeDCCatalog", type = RestParameter.Type.STRING),
          @RestParameter(description = "URL of series DublinCore Catalog", isRequired = false, name = "seriesDCCatalogUri", type = RestParameter.Type.STRING),
          @RestParameter(description = "Series DublinCore Catalog", isRequired = false, name = "seriesDCCatalog", type = RestParameter.Type.STRING),
          @RestParameter(description = "Access control list in XACML or JSON form", isRequired = false, name = "acl", type = RestParameter.Type.STRING),
          @RestParameter(description = "Tag of the next media file", isRequired = false, name = "tag", type = RestParameter.Type.STRING),
          @RestParameter(description = "URL of a media track file", isRequired = false, name = "mediaUri", type = RestParameter.Type.STRING) },
      bodyParameter = @RestParameter(description = "The media track file", isRequired = true, name = "BODY", type = RestParameter.Type.FILE),
      responses = {
          @RestResponse(description = "Ingest successful. Returns workflow instance as xml", responseCode = HttpServletResponse.SC_OK),

}

  @Override public Optional<String> getCreator() {
    return creator;
  }

  @Override public Optional<Date> getDate() {
    return date;
  }

  @Override public Optional<Date> getDateAccepted() {
    return dateAccepted;
  }

  @Override public Optional<Date> getDateCopyrighted() {
    return dateCopyrighted;
  }

  @Override public Optional<Date> getDateSubmitted() {
    return dateSubmitted;
  }

  @Override public Optional<String> getDescription() {
    return description;
  }

  @Override public Optional<String> getEducationLevel() {
    return educationLevel;
  }

  @Override public Optional<Long> getExtent() {
    return extent;
  }

  @Override public Optional<String> getFormat() {
    return format;
  }

  @Override public Optional<String> getHasFormat() {
    return hasFormat;
  }

  @Override public Optional<String> getHasPart() {
    return hasPart;
  }

  @Override public Optional<String> getHasVersion() {
    return hasVersion;
  }

  @Override public Optional<String> getIdentifier() {
    return identifier;
  }

  @Override public Optional<String> getInstructionalMethod() {
    return instructionalMethod;
  }

  @Override public Optional<String> getIsFormatOf() {
    return isFormatOf;
  }

  @Override public Optional<String> getIsPartOf() {
    return isPartOf;
  }

  @Override public Optional<String> getIsReferencedBy() {
    return isReferencedBy;
  }

  @Override public Optional<String> getIsReplacedBy() {
    return isReplacedBy;
  }

  @Override public Optional<String> getIsRequiredBy() {
    return isRequiredBy;
  }

  @Override public Optional<String> getIssued() {
    return issued;
  }

  @Override public Optional<String> getIsVersionOf() {
    return isVersionOf;
  }

  @Override public Optional<String> getLanguage() {
    return language;
  }

  @Override public Optional<String> getLicense() {
    return license;
  }

  @Override public Optional<String> getMediator() {
    return mediator;
  }

  @Override public Optional<String> getMedium() {
    return medium;
  }

  @Override public Optional<String> getModified() {
    return modified;
  }

  @Override public Optional<String> getProvenance() {
    return provenance;
  }

  @Override public Optional<String> getPublisher() {
    return publisher;
  }

  @Override public Optional<String> getReferences() {
    return references;
  }

  @Override public Optional<String> getRelation() {
    return relation;
  }

  @Override public Optional<String> getReplaces() {
    return replaces;
  }

  @Override public Optional<String> getRequires() {
    return requires;
  }

  @Override public Optional<String> getRights() {
    return rights;
  }

  @Override public Optional<String> getRightsHolder() {
    return rightsHolder;
  }

  @Override public Optional<String> getSource() {
    return source;
  }

  @Override public Optional<String> getSpatial() {
    return spatial;
  }

  @Override public Optional<String> getSubject() {
    return subject;
  }

  @Override public Optional<String> getTableOfContents() {
    return tableOfContents;
  }

  @Override public Optional<String> getTemporal() {
    return temporal;
  }

  @Override public String getTitle() {
    return title.orElseThrow(() -> new Error("title not set"));

return okJson(MetadataJson.listToJson(metadataList, true));
  }

  /**
   * Loads the metadata for the given series
   *
   * @param series
   *          the source {@link Series}
   * @return a {@link DublinCoreMetadataCollection} instance with all the series metadata
   */
  private DublinCoreMetadataCollection getSeriesMetadata(Series series) {
    DublinCoreMetadataCollection metadata = indexService.getCommonSeriesCatalogUIAdapter().getRawFields();

    MetadataField title = metadata.getOutputFields().get(DublinCore.PROPERTY_TITLE.getLocalName());
    metadata.removeField(title);
    MetadataField newTitle = new MetadataField(title);
    newTitle.setValue(series.getTitle());
    metadata.addField(newTitle);

    MetadataField subject = metadata.getOutputFields().get(DublinCore.PROPERTY_SUBJECT.getLocalName());
    metadata.removeField(subject);
    MetadataField newSubject = new MetadataField(subject);
    newSubject.setValue(series.getSubject());
    metadata.addField(newSubject);

    MetadataField description = metadata.getOutputFields().get(DublinCore.PROPERTY_DESCRIPTION.getLocalName());
    metadata.removeField(description);
    MetadataField newDescription = new MetadataField(description);
    newDescription.setValue(series.getDescription());
    metadata.addField(newDescription);

    MetadataField language = metadata.getOutputFields().get(DublinCore.PROPERTY_LANGUAGE.getLocalName());
    metadata.removeField(language);
    MetadataField newLanguage = new MetadataField(language);
    newLanguage.setValue(series.getLanguage());
    metadata.addField(newLanguage);

    MetadataField rightsHolder = metadata.getOutputFields().get(DublinCore.PROPERTY_RIGHTS_HOLDER.getLocalName());
    metadata.removeField(rightsHolder);
    MetadataField newRightsHolder = new MetadataField(rightsHolder);
    newRightsHolder.setValue(series.getRightsHolder());
    metadata.addField(newRightsHolder);

    MetadataField license = metadata.getOutputFields().get(DublinCore.PROPERTY_LICENSE.getLocalName());
    metadata.removeField(license);
    MetadataField newLicense = new MetadataField(license);
    newLicense.setValue(series.getLicense());
    metadata.addField(newLicense);

    MetadataField organizers = metadata.getOutputFields().get(DublinCore.PROPERTY_CREATOR.getLocalName());
    metadata.removeField(organizers);
    MetadataField newOrganizers = new MetadataField(organizers);
    newOrganizers.setValue(series.getOrganizers());

return distributeSync(channelId, mediaPackage, elementIds, true);
  }

  @Override
  public List<MediaPackageElement> distributeSync(String channelId, MediaPackage mediapackage, Set<String> elementIds,
         boolean checkAvailability) throws DistributionException {
    logger.info("Distributing {} elements to {}@{}", elementIds.size(), channelId, distributionChannel);
    final HttpPost req = post("/distributesync", param(PARAM_CHANNEL_ID, channelId),
        param(PARAM_MEDIAPACKAGE, MediaPackageParser.getAsXml(mediapackage)),
        param(PARAM_ELEMENT_ID, gson.toJson(elementIds)),
        param(PARAM_CHECK_AVAILABILITY, Boolean.toString(checkAvailability)));
    Optional<List<MediaPackageElement>> elements = runRequest(req, RemoteBase::elementsFromHttpResponse);
    if (elements.isPresent()) {
      return elements.get();
    }
    throw new DistributionException(format("Unable to distribute '%s' elements of "
            + "mediapackage '%s' using a remote destribution service proxy",
        elementIds.size(), mediapackage.getIdentifier().toString()));
  }

  @Override
  public List<MediaPackageElement> retractSync(String channelId, MediaPackage mediaPackage, String elementId)
          throws DistributionException {
    Set<String> elementIds = new HashSet<String>();
    elementIds.add(elementId);
    return retractSync(channelId, mediaPackage, elementIds);
  }

  @Override
  public List<MediaPackageElement> retractSync(String channelId, MediaPackage mediaPackage, Set<String> elementIds)
          throws DistributionException {
    logger.info("Retracting {} elements from {}@{}", elementIds.size(), channelId, distributionChannel);
    final HttpPost req = post("/retractsync",
        param(PARAM_MEDIAPACKAGE, MediaPackageParser.getAsXml(mediaPackage)),
        param(PARAM_ELEMENT_ID, gson.toJson(elementIds)),
        param(PARAM_CHANNEL_ID, channelId));
    Optional<List<MediaPackageElement>> elements = runRequest(req, RemoteBase::elementsFromHttpResponse);
    if (elements.isPresent()) {
      return elements.get();
    }
    throw new DistributionException(format("Unable to retract '%s' elements of "
            + "mediapackage '%s' using a remote destribution service proxy",
        elementIds.size(), mediaPackage.getIdentifier().toString()));
  }

  @Override

@RestParameter(name = "name", description = "The theme name", isRequired = true, type = Type.STRING),
          @RestParameter(name = "description", description = "The theme description", isRequired = false, type = Type.TEXT),
          @RestParameter(name = "bumperActive", description = "Whether the theme bumper is active", isRequired = false, type = Type.BOOLEAN),
          @RestParameter(name = "trailerActive", description = "Whether the theme trailer is active", isRequired = false, type = Type.BOOLEAN),
          @RestParameter(name = "titleSlideActive", description = "Whether the theme title slide is active", isRequired = false, type = Type.BOOLEAN),
          @RestParameter(name = "licenseSlideActive", description = "Whether the theme license slide is active", isRequired = false, type = Type.BOOLEAN),
          @RestParameter(name = "watermarkActive", description = "Whether the theme watermark is active", isRequired = false, type = Type.BOOLEAN),
          @RestParameter(name = "bumperFile", description = "The theme bumper file", isRequired = false, type = Type.STRING),
          @RestParameter(name = "trailerFile", description = "The theme trailer file", isRequired = false, type = Type.STRING),
          @RestParameter(name = "watermarkFile", description = "The theme watermark file", isRequired = false, type = Type.STRING),
          @RestParameter(name = "titleSlideBackground", description = "The theme title slide background file", isRequired = false, type = Type.STRING),
          @RestParameter(name = "licenseSlideBackground", description = "The theme license slide background file", isRequired = false, type = Type.STRING),
          @RestParameter(name = "titleSlideMetadata", description = "The theme title slide metadata", isRequired = false, type = Type.STRING),
          @RestParameter(name = "licenseSlideDescription", description = "The theme license slide description", isRequired = false, type = Type.STRING),
          @RestParameter(name = "watermarkPosition", description = "The theme watermark position", isRequired = false, type = Type.STRING), }, responses = {
          @RestResponse(responseCode = SC_OK, description = "Theme created"),

ArrayList<Role> roles = new ArrayList<Role>();
    User user = userReferenceProvider.loadUser(userName);
    if (user != null) {
      roles.addAll(user.getRoles());
    }
    return roles;
  }

  /**
   * @see org.opencastproject.security.api.RoleProvider#getOrganization()
   */
  @Override
  public String getOrganization() {
    return UserProvider.ALL_ORGANIZATIONS;
  }

  /**
   * @see org.opencastproject.security.api.RoleProvider#findRoles(String, Role.Target, int, int)
   */
  @Override
  public Iterator<Role> findRoles(String query, Role.Target target, int offset, int limit) {
    if (query == null) {
      throw new IllegalArgumentException("Query must be set");
    }
    HashSet<Role> foundRoles = new HashSet<Role>();
    for (Iterator<Role> it = getRoles(); it.hasNext();) {
      Role role = it.next();
      if (like(role.getName(), query) || like(role.getDescription(), query)) {
        foundRoles.add(role);
      }
    }
    return offsetLimitCollection(offset, limit, foundRoles).iterator();

  }

  private <T> HashSet<T> offsetLimitCollection(int offset, int limit, HashSet<T> entries) {
    HashSet<T> result = new HashSet<T>();
    int i = 0;
    for (T entry : entries) {
      if (limit != 0 && result.size() >= limit) {
        break;
      }
      if (i >= offset) {
        result.add(entry);
      }
      i++;
    }
    return result;
  }

  private boolean like(String string, final String query) {
    if (string == null) {
      return false;
    }
    String regex = query.replace("_", ".").replace("%", ".*?");
    Pattern p = Pattern.compile(regex, Pattern.CASE_INSENSITIVE | Pattern.DOTALL);
    return p.matcher(string).matches();
  }

  @Override
  public void afterPropertiesSet() throws Exception {

throw new WebApplicationException(Status.INTERNAL_SERVER_ERROR);
  }

  @POST
  @Path("/{seriesId}/property")
  @RestQuery(name = "updateSeriesProperty", description = "Updates a series property", returnDescription = "No content.", restParameters = {
          @RestParameter(name = "name", isRequired = true, description = "The property's name", type = TEXT),
          @RestParameter(name = "value", isRequired = true, description = "The property's value", type = TEXT) }, pathParameters = { @RestParameter(name = "seriesId", isRequired = true, description = "The series identifier", type = STRING) }, responses = {
          @RestResponse(responseCode = SC_NOT_FOUND, description = "No series with this identifier was found."),
          @RestResponse(responseCode = SC_NO_CONTENT, description = "The access control list has been updated."),
          @RestResponse(responseCode = SC_UNAUTHORIZED, description = "If the current user is not authorized to perform this action"),
          @RestResponse(responseCode = SC_BAD_REQUEST, description = "The required path or form params were missing in the request.") })
  public Response updateSeriesProperty(@PathParam("seriesId") String seriesId, @FormParam("name") String name,
          @FormParam("value") String value) throws UnauthorizedException {
    if (StringUtils.isBlank(seriesId)) {
      logger.warn("Series id parameter is blank '{}'.", seriesId);
      return Response.status(BAD_REQUEST).build();
    }
    if (StringUtils.isBlank(name)) {
      logger.warn("Name parameter is blank '{}'.", name);
      return Response.status(BAD_REQUEST).build();
    }
    if (StringUtils.isBlank(value)) {
      logger.warn("Series id parameter is blank '{}'.", value);
      return Response.status(BAD_REQUEST).build();
    }
    try {
      seriesService.updateSeriesProperty(seriesId, name, value);
      return Response.status(NO_CONTENT).build();
    } catch (NotFoundException e) {
      return Response.status(NOT_FOUND).build();
    } catch (SeriesException e) {
      logger.warn("Could not update series property for series {} property {}:{}", seriesId, name, value, e);

if (optSort.isPresent()) {
          ArrayList<SortCriterion> sortCriteria = RestUtils.parseSortQueryParameter(optSort.get());
          for (SortCriterion criterion : sortCriteria) {

            switch (criterion.getFieldName()) {
              case EventIndexSchema.TITLE:
                query.sortByTitle(criterion.getOrder());
                break;
              case EventIndexSchema.PRESENTER:
                query.sortByPresenter(criterion.getOrder());
                break;
              case EventIndexSchema.TECHNICAL_START:
              case "technical_date":
                query.sortByTechnicalStartDate(criterion.getOrder());
                break;
              case EventIndexSchema.TECHNICAL_END:
                query.sortByTechnicalEndDate(criterion.getOrder());
                break;
              case EventIndexSchema.START_DATE:
              case "date":
                query.sortByStartDate(criterion.getOrder());
                break;
              case EventIndexSchema.END_DATE:
                query.sortByEndDate(criterion.getOrder());
                break;
              case EventIndexSchema.WORKFLOW_STATE:
                query.sortByWorkflowState(criterion.getOrder());
                break;
              case EventIndexSchema.SERIES_NAME:
                query.sortBySeriesName(criterion.getOrder());
                break;
              case EventIndexSchema.LOCATION:
                query.sortByLocation(criterion.getOrder());
                break;
              // For compatibility, we mimic to support the old review_status and scheduling_status sort criteria (MH-13407)
              case "review_status":
              case "scheduling_status":
                break;
              default:
                return RestUtil.R.badRequest(String.format("Unknown sort criterion in request: %s", criterion.getFieldName()));
            }
          }
        }

        // TODO: Add the comment resolution filter to the query
        if (StringUtils.isNotBlank(resolutionFilter)) {
          try {
            CommentResolution.valueOf(resolutionFilter);
          } catch (Exception e) {
            logger.debug("Unable to parse comment resolution filter {}", resolutionFilter);
            return Response.status(Status.BAD_REQUEST).build();
          }
        }

        if (optLimit.isPresent())
          query.withLimit(optLimit.get());
        if (optOffset.isPresent())
          query.withOffset(offset);

}

  @Reference
  public void setServiceRegistry(ServiceRegistry serviceRegistry) {
    this.serviceRegistry = serviceRegistry;
  }

  @Reference
  public void setSecurityService(SecurityService securityService) {
    this.securityService = securityService;
  }

  @Reference
  public void setUserDirectoryService(UserDirectoryService userDirectoryService) {
    this.userDirectoryService = userDirectoryService;
  }

  @Reference
  public void setOrganizationDirectoryService(OrganizationDirectoryService organizationDirectoryService) {
    this.organizationDirectoryService = organizationDirectoryService;
  }

  @Reference
  public void setSmtpService(SmtpService service) {
    this.smtpService = service;
  }

  @Reference
  public void setWorkspace(Workspace ws) {
    this.workspace = ws;
  }

  @Reference
  public void setWorkingFileRepository(WorkingFileRepository wfr) {
    this.wfr = wfr;
  }

  @Reference
  public void setDatabase(TranscriptionDatabase service) {
    this.database = service;
  }

  @Reference
  public void setAssetManager(AssetManager service) {
    this.assetManager = service;
  }

  @Reference
  public void setWorkflowService(WorkflowService service) {
    this.workflowService = service;
  }

  @Override
  protected ServiceRegistry getServiceRegistry() {
    return serviceRegistry;
  }

  @Override
  protected SecurityService getSecurityService() {
    return securityService;
  }

  @Override
  protected UserDirectoryService getUserDirectoryService() {
    return userDirectoryService;
  }

  @Override
  protected OrganizationDirectoryService getOrganizationDirectoryService() {
    return organizationDirectoryService;
  }

  // Only used by unit tests!
  void setWfUtil(Workflows wfUtil) {
    this.wfUtil = wfUtil;
  }

  class WorkflowDispatcher implements Runnable {

    /**
     * {@inheritDoc}
     *
     * @see java.lang.Thread#run()
     */
    @Override
    public void run() {
      logger.debug("WorkflowDispatcher waking up...");

      try {
        // Find jobs that are in progress and jobs that had transcription complete

        long providerId;
        TranscriptionProviderControl providerInfo = database.findIdByProvider(PROVIDER);
        if (providerInfo != null) {
          providerId = providerInfo.getId();
        } else {
          logger.debug("No jobs yet for provider {}", PROVIDER);

throw new WebApplicationException(Status.INTERNAL_SERVER_ERROR);
  }

  @GET
  @Produces(MediaType.APPLICATION_JSON)
  @Path("{seriesId}/property/{propertyName}.json")
  @RestQuery(name = "getSeriesProperty", description = "Returns a series property value", returnDescription = "Returns the series property value", pathParameters = {
          @RestParameter(name = "seriesId", description = "ID of series", isRequired = true, type = Type.STRING),
          @RestParameter(name = "propertyName", description = "Name of series property", isRequired = true, type = Type.STRING) }, responses = {
          @RestResponse(responseCode = SC_OK, description = "The access control list."),
          @RestResponse(responseCode = SC_UNAUTHORIZED, description = "If the current user is not authorized to perform this action") })
  public Response getSeriesProperty(@PathParam("seriesId") String seriesId,
          @PathParam("propertyName") String propertyName) throws UnauthorizedException, NotFoundException {
    if (StringUtils.isBlank(seriesId)) {
      logger.warn("Series id parameter is blank '{}'.", seriesId);
      return Response.status(BAD_REQUEST).build();
    }
    if (StringUtils.isBlank(propertyName)) {
      logger.warn("Series property name parameter is blank '{}'.", propertyName);
      return Response.status(BAD_REQUEST).build();
    }
    try {
      String propertyValue = seriesService.getSeriesProperty(seriesId, propertyName);
      return Response.ok(propertyValue).build();
    } catch (UnauthorizedException e) {
      throw e;
    } catch (NotFoundException e) {
      throw e;
    } catch (Exception e) {
      logger.warn("Could not perform search query", e);
    }
    throw new WebApplicationException(Status.INTERNAL_SERVER_ERROR);

param(PARAM_CHECK_AVAILABILITY, Boolean.toString(checkAvailability)));
    Optional<Job> job = runRequest(req, JobUtil::jobFromHttpResponse);
    if (job.isPresent()) {
      return job.get();
    }
    throw new DistributionException(format("Unable to distribute '%s' elements of "
                    + "mediapackage '%s' using a remote destribution service proxy",
            elementIds.size(), mediaPackage.getIdentifier().toString()));
  }

  @Override
  public Job retract(String channelId, MediaPackage mediaPackage, String elementId) throws DistributionException {
    Set<String> elementIds = new HashSet<String>();
    elementIds.add(elementId);
    return retract(channelId, mediaPackage, elementIds);
  }

  @Override
  public Job retract(String channelId, MediaPackage mediaPackage, Set<String> elementIds) throws DistributionException {
    logger.info("Retracting {} elements from {}@{}", elementIds.size(), channelId, distributionChannel);
    final HttpPost req = post("/retract",
            param(PARAM_MEDIAPACKAGE, MediaPackageParser.getAsXml(mediaPackage)),
            param(PARAM_ELEMENT_ID, gson.toJson(elementIds)),
            param(PARAM_CHANNEL_ID, channelId));
    Optional<Job> job = runRequest(req, JobUtil::jobFromHttpResponse);
    if (job.isPresent()) {
      return job.get();
    }
    throw new DistributionException(format("Unable to retract '%s' elements of "
                    + "mediapackage '%s' using a remote destribution service proxy",
            elementIds.size(), mediaPackage.getIdentifier().toString()));
  }

  @Override
  public List<MediaPackageElement>  distributeSync(String channelId, MediaPackage mediaPackage, String elementId)

.<LaidOutElement<Track>> empty(), lowerLaidOutElement, watermarkOption, compositeSettings.getProfile()
              .getIdentifier(), compositeSettings.getOutputBackground(), compositeSettings.getSourceAudioName());

      // Wait for the jobs to return
      if (!waitForStatus(compositeJob).isSuccess())
        throw new WorkflowOperationException("The composite job did not complete successfully");

      if (compositeJob.getPayload().length() > 0) {

        Track compoundTrack = (Track) MediaPackageElementParser.getFromXml(compositeJob.getPayload());

        compoundTrack.setURI(workspace.moveTo(compoundTrack.getURI(), mediaPackage.getIdentifier().toString(),
                compoundTrack.getIdentifier(),
                "composite." + FilenameUtils.getExtension(compoundTrack.getURI().toString())));

        // Adjust the target tags
        applyTargetTagsToElement(compositeSettings.getTargetTags(), compoundTrack);

        // Adjust the target flavor.
        compoundTrack.setFlavor(compositeSettings.getTargetFlavor());
        logger.debug("Compound track has flavor '{}'", compoundTrack.getFlavor());

        // store new tracks to mediaPackage
        mediaPackage.add(compoundTrack);
        WorkflowOperationResult result = createResult(mediaPackage, Action.CONTINUE, compositeJob.getQueueTime());
        logger.debug("Composite operation completed");
        return result;
      } else {
        logger.info("Composite operation unsuccessful, no payload returned: {}", compositeJob);
        return createResult(mediaPackage, Action.SKIP);
      }
    } finally {
      if (compositeSettings.getSourceUrlWatermark() != null)
        workspace.deleteFromCollection(
                COLLECTION,
                compositeSettings.getWatermarkIdentifier() + "."
                        + FilenameUtils.getExtension(compositeSettings.getSourceUrlWatermark()));
    }
  }

}

  /**
   * Handle a new user login.
   *
   * @param id
   *          The identity of the user, ideally the Shibboleth persistent unique identifier
   * @param request
   *          The request, for accessing any other Shibboleth variables
   */
  @Override
  public void newUserLogin(String id, HttpServletRequest request) {
    String name = extractName(request);
    String email = extractEmail(request);
    Date loginDate = new Date();
    JpaOrganization organization = fromOrganization(securityService.getOrganization());

    // Compile the list of roles
    Set<JpaRole> roles = extractRoles(id, request);

    // Create the user reference
    JpaUserReference userReference = new JpaUserReference(id, name, email, MECH_SHIBBOLETH, loginDate, organization,
            roles);

    logger.debug("Shibboleth user '{}' logged in for the first time", id);
    userReferenceProvider.addUserReference(userReference, MECH_SHIBBOLETH);
  }

  /**
   * Handle an existing user login.
   *
   * @param id
   *          The identity of the user, ideally the Shibboleth persistent unique identifier
   * @param request
   *          The request, for accessing any other Shibboleth variables
   */
  @Override
  public void existingUserLogin(String id, HttpServletRequest request) {
    Organization organization = securityService.getOrganization();

    // Load the user reference
    JpaUserReference userReference = userReferenceProvider.findUserReference(id, organization.getId());
    if (userReference == null) {
      throw new UsernameNotFoundException("User reference '" + id + "' was not found");
    }

    // Update the reference
    userReference.setName(extractName(request));
    userReference.setEmail(extractEmail(request));
    userReference.setLastLogin(new Date());
    Set<JpaRole> roles = extractRoles(id, request);
    userReference.setRoles(roles);

    logger.debug("Shibboleth user '{}' logged in", id);
    userReferenceProvider.updateUserReference(userReference);
  }

  /**
   * Sets the security service.
   *
   * @param securityService
   *          the security service
   */
  public void setSecurityService(SecurityService securityService) {
    this.securityService = securityService;
  }

  /**
   * Sets the user reference provider.
   *
   * @param userReferenceProvider
   *          the user reference provider
   */
  public void setUserReferenceProvider(UserReferenceProvider userReferenceProvider) {
    this.userReferenceProvider = userReferenceProvider;
  }

  /**
   * Extracts the name from the request.
   *
   * @param request
   *          the request
   * @return the name
   */
  private String extractName(HttpServletRequest request) {
    String givenName = StringUtils.isBlank(request.getHeader(headerGivenName)) ? ""

} else if (item.getFieldName().toLowerCase().matches(attachmentRegex)) {
              assetList.add(item.getFieldName());
              mp =  ingestService.addAttachment(item.openStream(), item.getName(),
                      new MediaPackageElementFlavor(item.getFieldName(), "*"), mp);
            } else if (item.getFieldName().toLowerCase().matches(catalogRegex)) {
              // Cannot get flavor at this point, so saving with temporary flavor
              assetList.add(item.getFieldName());
              mp =  ingestService.addCatalog(item.openStream(), item.getName(),
                      new MediaPackageElementFlavor(item.getFieldName(), "*"), mp);
            } else if (item.getFieldName().toLowerCase().matches(trackRegex)) {
              // Cannot get flavor at this point, so saving with temporary flavor
              assetList.add(item.getFieldName());
              mp = ingestService.addTrack(item.openStream(), item.getName(),
                      new MediaPackageElementFlavor(item.getFieldName(), "*"), mp);
            } else {
              logger.warn("Unknown field name found {}", item.getFieldName());
            }
          }
        }
        // MH-12085 update the flavors of any newly added assets.
        try {
          JSONArray assetMetadata = (JSONArray)((JSONObject) metadataJson.get("assets")).get("options");
          if (assetMetadata != null) {
            mp = updateMpAssetFlavor(assetList, mp, assetMetadata);
           }

throws IllegalArgumentException, ParseException {
    JSONParser parser = new JSONParser();
    JSONArray aclJson = (JSONArray) parser.parse(json);
    @SuppressWarnings("unchecked")
    ListIterator<Object> iterator = aclJson.listIterator();
    JSONObject aceJson;
    List<AccessControlEntry> entries = new ArrayList<AccessControlEntry>();
    while (iterator.hasNext()) {
      aceJson = (JSONObject) iterator.next();
      String action = aceJson.get(ACTION_JSON_KEY) != null ? aceJson.get(ACTION_JSON_KEY).toString() : "";
      String allow;
      if (assumeAllow) {
        allow = "true";
      } else {
        allow = aceJson.get(ALLOW_JSON_KEY) != null ? aceJson.get(ALLOW_JSON_KEY).toString() : "";
      }
      String role = aceJson.get(ROLE_JSON_KEY) != null ? aceJson.get(ROLE_JSON_KEY).toString() : "";
      if (StringUtils.trimToNull(action) != null && StringUtils.trimToNull(allow) != null
              && StringUtils.trimToNull(role) != null) {
        AccessControlEntry ace = new AccessControlEntry(role, action, Boolean.parseBoolean(allow));
        entries.add(ace);
      } else {
        throw new IllegalArgumentException(
                String.format(
                        "One of the access control elements is missing a property. The action was '%s', allow was '%s' and the role was '%s'",
                        action, allow, role));
      }
    }
    return new AccessControlList(entries);
  }

public JobsListQuery(ResourceListQuery query) {
    this();
    availableFilters.addAll(query.getAvailableFilters());

    for (ResourceListFilter filter : query.getFilters())
      addFilter(filter);

    sortBy = query.getSortBy();
    if (query.getOffset().isPresent())
      setOffset(query.getOffset().get());
    if (query.getLimit().isPresent())
      setLimit(query.getLimit().get());
  }

  /**
   * Add a {@link ResourceListFilter} filter to the query with the given hostname.
   *
   * @param hostname the hostname to filter for
   */
  public void withHostname(String hostname) {
    addFilter(createHostnameFilter(Optional.ofNullable(hostname)));
  }

  /**
   * Add a {@link ResourceListFilter} filter to the query with the given node name.
   *
   * @param nodeName the node name to filter for
   */
  public void withNodeName(String nodeName) {
    addFilter(createNodeNameFilter(Optional.ofNullable(nodeName)));
  }

  /**
   * Add a {@link ResourceListFilter} filter to the query with the given status.
   *
   * @param status the status to filter for
   */
  public void withStatus(String status) {
    addFilter(createStatusFilter(Optional.ofNullable(status)));
  }

  /**
   * Add a {@link ResourceListFilter} filter to the query with the given free text.
   *
   * @param freeText the free text to filter for
   */
  public void withFreeText(String freeText) {
    addFilter(createFreeTextFilter(Optional.ofNullable(freeText)));
  }

  /**
   * Returns an {@link Optional} containing the hostname used to filter if set.
   * {@link Optional#empty()} otherwise.
   *
   * @return an {@link Optional} containing the hostname or none.
   */
  public Optional<String> getHostname() {
    return getFilterValue(FILTER_NAME_HOSTNAME);
  }

  /**
   * Returns an {@link Optional} containing the node name used to filter if set.
   * {@link Optional#empty()} otherwise.
   *
   * @return an {@link Optional} containing the node name or none.
   */
  public Optional<String> getNodeName() {
    return getFilterValue(FILTER_NAME_NODE_NAME);
  }

  /**
   * Returns an {@link Optional} containing the status used to filter if set.
   * {@link Optional#empty()} otherwise.
   *
   * @return an {@link Optional} containing the status or none.
   */
  public Optional<String> getStatus() {
    return getFilterValue(FILTER_NAME_STATUS);
  }

  /**
   * Returns an {@link Optional} containing the free text used to filter if set.
   * {@link Optional#empty()} otherwise.
   *
   * @return an {@link Optional} containing the free text or none.
   */
  public Optional<String> getFreeText() {
    return getFilterValue(ResourceListFilter.FREETEXT);
  }

  /**
   * Create a new {@link ResourceListFilter} based on a hostname.
   *
   * @param value the hostname to filter on wrapped in an {@link Optional} or {@link Optional#empty()}
   * @return a new {@link ResourceListFilter} for a hostname based query
   */
  public static <String> ResourceListFilter<String> createHostnameFilter(Optional<String> value) {

@Path("{id}/properties")
  @RestQuery(name = "getSeriesProperties", description = "Returns the series properties", returnDescription = "Returns the series properties as JSON", pathParameters = { @RestParameter(name = "id", description = "ID of series", isRequired = true, type = Type.STRING) }, responses = {
          @RestResponse(responseCode = SC_OK, description = "The access control list."),
          @RestResponse(responseCode = SC_UNAUTHORIZED, description = "If the current user is not authorized to perform this action") })
  public Response getSeriesPropertiesAsJson(@PathParam("id") String seriesId) throws UnauthorizedException,
          NotFoundException {
    if (StringUtils.isBlank(seriesId)) {
      logger.warn("Series id parameter is blank '{}'.", seriesId);
      return Response.status(BAD_REQUEST).build();
    }
    try {
      Map<String, String> properties = seriesService.getSeriesProperties(seriesId);
      JSONArray jsonProperties = new JSONArray();
      for (String name : properties.keySet()) {
        JSONObject property = new JSONObject();
        property.put(name, properties.get(name));
        jsonProperties.add(property);
      }
      return Response.ok(jsonProperties.toString()).build();
    } catch (UnauthorizedException e) {
      throw e;
    } catch (NotFoundException e) {
      throw e;
    } catch (Exception e) {
      logger.warn("Could not perform search query: {}", e.getMessage());
    }
    throw new WebApplicationException(Status.INTERNAL_SERVER_ERROR);

throw new WebApplicationException(Status.INTERNAL_SERVER_ERROR);
  }

  @DELETE
  @Path("{seriesId}/property/{propertyName}")
  @RestQuery(name = "deleteSeriesProperty", description = "Deletes a series property", returnDescription = "No Content", pathParameters = {
          @RestParameter(name = "seriesId", description = "ID of series", isRequired = true, type = Type.STRING),
          @RestParameter(name = "propertyName", description = "Name of series property", isRequired = true, type = Type.STRING) }, responses = {
          @RestResponse(responseCode = SC_NO_CONTENT, description = "The series property has been deleted."),
          @RestResponse(responseCode = SC_NOT_FOUND, description = "The series or property has not been found."),
          @RestResponse(responseCode = SC_UNAUTHORIZED, description = "If the current user is not authorized to perform this action") })
  public Response deleteSeriesProperty(@PathParam("seriesId") String seriesId,
          @PathParam("propertyName") String propertyName) throws UnauthorizedException, NotFoundException {
    if (StringUtils.isBlank(seriesId)) {
      logger.warn("Series id parameter is blank '{}'.", seriesId);
      return Response.status(BAD_REQUEST).build();
    }
    if (StringUtils.isBlank(propertyName)) {
      logger.warn("Series property name parameter is blank '{}'.", propertyName);
      return Response.status(BAD_REQUEST).build();
    }
    try {
      seriesService.deleteSeriesProperty(seriesId, propertyName);
      return Response.status(NO_CONTENT).build();
    } catch (UnauthorizedException | NotFoundException e) {

public int getFailedIngestOperations() {
    return failed;
  }

  /**
   * @see org.opencastproject.ingest.impl.jmx.IngestStatisticsMXBean#getTotalBytes()
   */
  @Override
  public long getTotalBytes() {
    return totalNumBytesRead;
  }

  /**
   * @see org.opencastproject.ingest.impl.jmx.IngestStatisticsMXBean#getBytesInLastMinute()
   */
  @Override
  public long getBytesInLastMinute() {
    long key = getKeyByTime(new DateTime().minusMinutes(1).getMillis());
    return key != 0 ? totalNumBytesRead - bytesCounter.getIfPresent(key) : 0;
  }

  /**
   * @see org.opencastproject.ingest.impl.jmx.IngestStatisticsMXBean#getBytesInLastFiveMinutes()
   */
  @Override
  public long getBytesInLastFiveMinutes() {
    long key = getKeyByTime(new DateTime().minusMinutes(5).getMillis());
    return key != 0 ? totalNumBytesRead - bytesCounter.getIfPresent(key) : 0;
  }

  /**
   * @see org.opencastproject.ingest.impl.jmx.IngestStatisticsMXBean#getBytesInLastFifteenMinutes()
   */
  @Override
  public long getBytesInLastFifteenMinutes() {
    long key = getKeyByTime(new DateTime().minusMinutes(15).getMillis());
    return key != 0 ? totalNumBytesRead - bytesCounter.getIfPresent(key) : 0;
  }

  private long getKeyByTime(long timeBeforeFiveMinute) {
    long key = 0L;
    List<Long> bytes = new ArrayList<Long>(bytesCounter.asMap().keySet());
    Collections.sort(bytes);
    for (Long milis : bytes) {
      if (milis > timeBeforeFiveMinute) {
        key = milis;
        break;
      }
    }
    return key;
  }

  public void add(long bytes) {
    if (totalNumBytesRead == 0)

final SeriesService seriesService = context.getService(SeriesService.class);

    final AccessControlListInput aclInput = GraphQLObjectMapper.newInstance()
        .convertValue(environment.getArgument("acl"), AccessControlListInput.class);
    if (aclInput != null) {
      try {
        AccessControlList acl = new AccessControlList();
        for (var entry : aclInput.getEntries()) {
          for (var action : entry.getAction()) {
            acl.getEntries().add(new AccessControlEntry(entry.getRole(), action, true));
          }
        }

        if (aclInput.getManagedAclId() != null) {
          AclService aclService = context.getService(AclServiceFactory.class)
              .serviceFor(context.getService(SecurityService.class).getOrganization());
          aclService.getAcl(aclInput.getManagedAclId())
              .ifPresent(value -> acl.merge(value.getAcl()));
        }
        seriesService.updateAccessControl(seriesId, acl);
      } catch (UnauthorizedException e) {
        throw new GraphQLUnauthorizedException(e.getMessage());
      } catch (NotFoundException e) {
        throw new GraphQLNotFoundException(e.getMessage());
      } catch (SeriesException e) {
        throw new GraphQLRuntimeException(e);
      }
    }

    try {

while (i < cmdToken.size()) {
          String opt = cmdToken.get(i);
          if (opt.startsWith("-vf") || opt.startsWith("-filter:v")) { // video filters
            vfilter.set(indx, cmdToken.get(i + 1).replace("\"", "")); // store without quotes
            i++;
          } else if (opt.startsWith("-filter_complex") || opt.startsWith("-lavfi")) { // safer to quit now than to
            // baffle users with strange errors later
            i++;
            logger.error("Command does not support complex filters - only simple -af or -vf filters are supported");
            throw new EncoderException(
                    "Cannot parse complex filters in" + profile.getIdentifier() + " for this operation");
          } else if (opt.startsWith("-af") || opt.startsWith("-filter:a")) { // audio filter
            afilter.set(indx, cmdToken.get(i + 1).replace("\"", "")); // store without quotes
            i++;
          } else if ("-i".equals(opt)) {
            i++; // inputs are now mapped, remove from command
          } else if (opt.startsWith("-c:") || opt.startsWith("-codec:") || opt.contains("-vcodec")
                  || opt.contains("-acodec")) { // cannot copy codec in complex filter
            String str = cmdToken.get(i + 1);
            if (str.contains("copy")) // c
              i++;
            else if (opt.startsWith("-codec:") || opt.contains("-vcodec")) { // becomes -c:v

.orElse(AWS_S3_GLACIER_RESTORE_DAYS_DEFAULT);

      // Explicit credentials are optional.
      AWSCredentialsProvider provider = null;
      Optional<String> accessKeyIdOpt = OsgiUtil.getOptCfg(cc.getProperties(), AWS_S3_ACCESS_KEY_ID_CONFIG);
      Optional<String> accessKeySecretOpt = OsgiUtil.getOptCfg(cc.getProperties(), AWS_S3_SECRET_ACCESS_KEY_CONFIG);

      // Keys not informed so use default credentials provider chain, which
      // will look at the environment variables, java system props, credential files, and instance
      // profile credentials
      if (accessKeyIdOpt.isEmpty() && accessKeySecretOpt.isEmpty()) {
        provider = new DefaultAWSCredentialsProviderChain();
      } else {
        provider = new AWSStaticCredentialsProvider(
                new BasicAWSCredentials(accessKeyIdOpt.get(), accessKeySecretOpt.get()));
      }

      // S3 client configuration
      ClientConfiguration clientConfiguration = new ClientConfiguration();

      int maxConnections = OsgiUtil.getOptCfgAsInt(cc.getProperties(), AWS_S3_MAX_CONNECTIONS)
              .orElse(DEFAULT_MAX_CONNECTIONS);
      logger.debug("Max Connections: {}", maxConnections);
      clientConfiguration.setMaxConnections(maxConnections);

      int connectionTimeout = OsgiUtil.getOptCfgAsInt(cc.getProperties(), AWS_S3_CONNECTION_TIMEOUT)
              .orElse(DEFAULT_CONNECTION_TIMEOUT);
      logger.debug("Connection Output: {}", connectionTimeout);
      clientConfiguration.setConnectionTimeout(connectionTimeout);

      int maxRetries = OsgiUtil.getOptCfgAsInt(cc.getProperties(), AWS_S3_MAX_RETRIES)
              .orElse(DEFAULT_MAX_RETRIES);
      logger.debug("Max Retry: {}", maxRetries);
      clientConfiguration.setMaxErrorRetry(maxRetries);

      // Create AWS client.
      s3 = AmazonS3ClientBuilder.standard()
              .withEndpointConfiguration(new AwsClientBuilder.EndpointConfiguration(endpoint
              , regionName))

@RestQuery(name = "conflictingrecordingsasjson", description = "Searches for conflicting recordings based on parameters", returnDescription = "Returns NO CONTENT if no recordings are in conflict within specified period or list of conflicting recordings in JSON", restParameters = {
          @RestParameter(name = "agent", description = "Device identifier for which conflicts will be searched", isRequired = true, type = Type.STRING),
          @RestParameter(name = "start", description = "Start time of conflicting period, in milliseconds", isRequired = true, type = Type.INTEGER),
          @RestParameter(name = "end", description = "End time of conflicting period, in milliseconds", isRequired = true, type = Type.INTEGER),
          @RestParameter(name = "rrule", description = "Rule for recurrent conflicting, specified as: \"FREQ=WEEKLY;BYDAY=day(s);BYHOUR=hour;BYMINUTE=minute\". FREQ is required. BYDAY may include one or more (separated by commas) of the following: SU,MO,TU,WE,TH,FR,SA.", isRequired = false, type = Type.STRING),
          @RestParameter(name = "duration", description = "If recurrence rule is specified duration of each conflicting period, in milliseconds", isRequired = false, type = Type.INTEGER),
          @RestParameter(name = "timezone", description = "The timezone of the capture device", isRequired = false, type = Type.STRING) }, responses = {
                  @RestResponse(responseCode = HttpServletResponse.SC_NO_CONTENT, description = "No conflicting events found"),
                  @RestResponse(responseCode = HttpServletResponse.SC_OK, description = "Found conflicting events, returned in body of response"),
                  @RestResponse(responseCode = HttpServletResponse.SC_BAD_REQUEST, description = "Missing or invalid parameters"),
                  @RestResponse(responseCode = HttpServletResponse.SC_UNAUTHORIZED, description = "Not authorized to make this request"),
                  @RestResponse(responseCode = HttpServletResponse.SC_INTERNAL_SERVER_ERROR, description = "A detailed stack track of the internal issue.")})
  public Response getConflictingEventsJson(@QueryParam("agent") String device, @QueryParam("rrule") String rrule,

public Job replace(
      MediaPackage mediaPackage,
      String repository,
      Set<? extends MediaPackageElement> downloadElements,
      Set<? extends MediaPackageElement> streamingElements,
      Set<MediaPackageElementFlavor> retractDownloadFlavors,
      Set<MediaPackageElementFlavor> retractStreamingFlavors,
      Set<? extends Publication> publications,
      boolean checkAvailability
  ) throws PublicationException {
    HttpResponse response = null;
    try {
      final String mediapackageXml = MediaPackageParser.getAsXml(mediaPackage);
      final String downloadElementsXml = MediaPackageElementParser.getArrayAsXml(downloadElements);
      final String streamingElementsXml = MediaPackageElementParser.getArrayAsXml(streamingElements);
      final String retractDownloadFlavorsString = StringUtils.join(retractDownloadFlavors, SEPARATOR);
      final String retractStreamingFlavorsString = StringUtils.join(retractStreamingFlavors, SEPARATOR);
      final String publicationsXml = MediaPackageElementParser.getArrayAsXml(publications);
      final List<BasicNameValuePair> params = Arrays.asList(
              new BasicNameValuePair("mediapackage", mediapackageXml),
              new BasicNameValuePair("channel", repository),
              new BasicNameValuePair("downloadElements", downloadElementsXml),
              new BasicNameValuePair("streamingElements", streamingElementsXml),
              new BasicNameValuePair("retractDownloadFlavors", retractDownloadFlavorsString),
              new BasicNameValuePair("retractStreamingFlavors", retractStreamingFlavorsString),
              new BasicNameValuePair("publications", publicationsXml),
              new BasicNameValuePair("checkAvailability", Boolean.toString(checkAvailability)));
      final HttpPost post = new HttpPost("replace");

returnDescription = "The job that can be used to track the publication",
      restParameters = {
          @RestParameter(
              name = "mediapackage",
              isRequired = true,
              description = "The media package",
              type = Type.TEXT
          ),
          @RestParameter(
              name = "channel",
              isRequired = true,
              description = "The channel name",
              type = Type.STRING
          ),
          @RestParameter(
              name = "downloadElements",
              isRequired = true,
              description = "The additional elements to publish to download",
              type = Type.STRING
          ),
          @RestParameter(
              name = "streamingElements",
              isRequired = true,
              description = "The additional elements to publish to streaming",
              type = Type.STRING
          ),
          @RestParameter(
              name = "retractDownloadFlavors",
              isRequired = true,
              description = "The flavors of the elements to retract from download separated by  '" + SEPARATOR + "'",
              type = Type.STRING
          ),
          @RestParameter(
              name = "retractStreamingFlavors",
              isRequired = true,
              description = "The flavors of the elements to retract from streaming separated by  '" + SEPARATOR + "'",
              type = Type.STRING
          ),
          @RestParameter(
              name = "publications",
              isRequired = true,
              description = "The publications to update",
              type = Type.STRING
          ),
          @RestParameter(
              name = "checkAvailability",
              isRequired = false,
              description = "Whether to check for availability",
              type = Type.BOOLEAN,
              defaultValue = "true"
          )
      },
      responses = {
          @RestResponse(responseCode = SC_OK, description = "An XML representation of the publication job")

if (like(role.getName(), query) || like(role.getDescription(), query)) {
        foundRoles.add(role);
      }
    }
    return offsetLimitCollection(offset, limit, foundRoles).iterator();

  }

  private <T> HashSet<T> offsetLimitCollection(int offset, int limit, HashSet<T> entries) {
    HashSet<T> result = new HashSet<T>();
    int i = 0;
    for (T entry : entries) {
      if (limit != 0 && result.size() >= limit) {
        break;
      }
      if (i >= offset) {
        result.add(entry);
      }
      i++;
    }
    return result;
  }

  private boolean like(String string, final String query) {
    if (string == null) {
      return false;
    }
    String regex = query.replace("_", ".").replace("%", ".*?");
    Pattern p = Pattern.compile(regex, Pattern.CASE_INSENSITIVE | Pattern.DOTALL);
    return p.matcher(string).matches();
  }

if (like(role.getName(), query) || like(role.getDescription(), query)) {
        foundRoles.add(role);
      }
    }
    return offsetLimitCollection(offset, limit, foundRoles).iterator();

  }

  /**
   * Slices a given hash set with a given offset and a given limit of entries.
   *
   * @param offset The offset.
   * @param limit The limit for the number of entries.
   * @param entries The original entries.
   * @return The sliced hash set.
   */
  private <T> HashSet<T> offsetLimitCollection(int offset, int limit, HashSet<T> entries) {
    HashSet<T> result = new HashSet<T>();
    int i = 0;
    for (T entry : entries) {
      if (limit != 0 && result.size() >= limit) {
        break;
      }
      if (i >= offset) {
        result.add(entry);
      }
      i++;
    }
    return result;
  }

  /**
   * Evaluates whether a given query matches on a string.
   *
   * @param string The string.
   * @param query The query.
   * @return <code>true</code> if the query matches, <code>false</code> otherwise.
   */
  private boolean like(String string, final String query) {
    if (string == null) {
      return false;
    }

    String regex = query.replace("_", ".").replace("%", ".*?");
    Pattern p = Pattern.compile(regex, Pattern.CASE_INSENSITIVE | Pattern.DOTALL);
    return p.matcher(string).matches();
  }

logger.warn("Error when parsing Google transcriptions result", e);
      throw new CaptionConverterException(e);
    }

    return captionList;
  }

  @Override
  public void exportCaption(OutputStream outputStream, List<Caption> captions, String language) throws IOException {
    throw new UnsupportedOperationException();
  }

  @Override
  public String[] getLanguageList(InputStream inputStream) throws CaptionConverterException {
    throw new UnsupportedOperationException();
  }

  @Override
  public String getExtension() {
    return "json";
  }

  @Override
  public Type getElementType() {
    return MediaPackageElement.Type.Attachment;
  }

  private Time buildTime(long ms) throws IllegalTimeFormatException {
    int h = (int) (ms / 3600000L);
    int m = (int) ((ms % 3600000L) / 60000L);
    int s = (int) ((ms % 60000L) / 1000L);
    ms = (int) (ms % 1000);

    return new TimeImpl(h, m, s, (int) ms);
  }

  private String removeEndCharacter(String str, String end) {
    if (str.endsWith(end)) {
      str = str.replace(end, "");
    }
    return str;
  }

}

queryStringParams.add(new BasicNameValuePair("end", Long.toString(endDate.getTime())));
    HttpGet get = new HttpGet("conflicts.xml?".concat(URLEncodedUtils.format(queryStringParams, UTF_8)));
    HttpResponse response = getResponse(get, SC_OK, SC_NO_CONTENT);
    try {
      if (response != null) {
        if (SC_OK == response.getStatusLine().getStatusCode()) {
          String mediaPackageXml = EntityUtils.toString(response.getEntity(), UTF_8);
          List<MediaPackage> events = MediaPackageParser.getArrayFromXml(mediaPackageXml);
          logger.info("Successfully get conflicts from the remote scheduler service");
          return events;
        } else if (SC_UNAUTHORIZED == response.getStatusLine().getStatusCode()) {
          logger.info("Unauthorized to search for conflicting events");
          throw new UnauthorizedException("Unauthorized to search for conflicting events");
        } else if (SC_NO_CONTENT == response.getStatusLine().getStatusCode()) {
          return Collections.<MediaPackage> emptyList();
        }
      }
    } catch (UnauthorizedException e) {
      throw e;
    } catch (Exception e) {
      throw new SchedulerException("Unable to get conflicts from remote scheduler service", e);
    } finally {
      closeConnection(response);
    }
    throw new SchedulerException("Unable to get conflicts from remote scheduler service");
  }

  @Override
  public List<MediaPackage> findConflictingEvents(String captureAgentId, RRule rrule, Date startDate, Date endDate,

Map<String, String> caProperties = new HashMap<>();
    if (StringUtils.isNotBlank(agentParameters)) {
      try {
        Properties prop = parseProperties(agentParameters);
        caProperties.putAll((Map) prop);
      } catch (Exception e) {
        logger.info("Could not parse capture agent properties: {}", agentParameters);
        return RestUtil.R.badRequest("Could not parse capture agent properties");
      }
    }

    Map<String, String> wfProperties = new HashMap<>();
    if (StringUtils.isNotBlank(workflowProperties)) {
      try {
        Properties prop = parseProperties(workflowProperties);
        wfProperties.putAll((Map) prop);
      } catch (IOException e) {
        logger.info("Could not parse workflow configuration properties: {}", workflowProperties);
        return RestUtil.R.badRequest("Could not parse workflow configuration properties");
      }
    }
    Set<String> userIds = new HashSet<>();
    String[] ids = StringUtils.split(users, ",");
    if (ids != null)
      userIds.addAll(Arrays.asList(ids));

    DateTime startDate = new DateTime(startTime).toDateTime(DateTimeZone.UTC);

}

  @Reference
  public void setWorkspace(Workspace ws) {
    this.workspace = ws;
  }

  @Reference
  public void setWorkingFileRepository(WorkingFileRepository wfr) {
    this.wfr = wfr;
  }

  @Reference
  public void setDatabase(TranscriptionDatabase service) {
    this.database = service;
  }

  @Reference
  public void setAssetManager(AssetManager service) {
    this.assetManager = service;
  }

  @Reference
  public void setWorkflowService(WorkflowService service) {
    this.workflowService = service;
  }

  @Override
  protected ServiceRegistry getServiceRegistry() {
    return serviceRegistry;
  }

  @Override
  protected SecurityService getSecurityService() {
    return securityService;
  }

  @Override
  protected UserDirectoryService getUserDirectoryService() {
    return userDirectoryService;
  }

  @Override
  protected OrganizationDirectoryService getOrganizationDirectoryService() {
    return organizationDirectoryService;
  }

  // Only used by unit tests!
  void setWfUtil(Workflows wfUtil) {
    this.wfUtil = wfUtil;
  }

  class WorkflowDispatcher implements Runnable {

    /**
     * {@inheritDoc}
     *
     * @see java.lang.Thread#run()
     */
    @Override
    public void run() {
      logger.debug("WorkflowDispatcher waking up...");

      try {
        // Find jobs that are in progress and jobs that had transcription complete

        long providerId;
        TranscriptionProviderControl providerInfo = database.findIdByProvider(PROVIDER);
        if (providerInfo != null) {
          providerId = providerInfo.getId();
        } else {
          logger.debug("No jobs yet for provider {}.", PROVIDER);

}

  @Reference
  public void setWorkspace(Workspace ws) {
    this.workspace = ws;
  }

  @Reference
  public void setWorkingFileRepository(WorkingFileRepository wfr) {
    this.wfr = wfr;
  }

  @Reference
  public void setDatabase(TranscriptionDatabase service) {
    this.database = service;
  }

  @Reference
  public void setAssetManager(AssetManager service) {
    this.assetManager = service;
  }

  @Reference
  public void setWorkflowService(WorkflowService service) {
    this.workflowService = service;
  }

  @Override
  protected ServiceRegistry getServiceRegistry() {
    return serviceRegistry;
  }

  @Override
  protected SecurityService getSecurityService() {
    return securityService;
  }

  @Override
  protected UserDirectoryService getUserDirectoryService() {
    return userDirectoryService;
  }

  @Override
  protected OrganizationDirectoryService getOrganizationDirectoryService() {
    return organizationDirectoryService;
  }

  // Only used by unit tests!
  void setWfUtil(Workflows wfUtil) {
    this.wfUtil = wfUtil;
  }

  class WorkflowDispatcher implements Runnable {

    /**
     * {@inheritDoc}
     *
     * @see java.lang.Thread#run()
     */
    @Override
    public void run() {
      logger.debug("WorkflowDispatcher waking up...");

      try {
        // Find jobs that are in progress and jobs that had transcription complete

        long providerId;
        TranscriptionProviderControl providerInfo = database.findIdByProvider(PROVIDER);
        if (providerInfo != null) {
          providerId = providerInfo.getId();
        } else {
          logger.debug("No jobs yet for provider {}.", PROVIDER);

securityService.getUser()).withSeriesId(resourceId).withLimit(limit).withOffset(offset);
    for (Map.Entry<String, String> filter: filters.entrySet()) {
      query = (EventSearchQuery) applyFilter(filter.getKey(), filter.getValue(), query);
    }

    final SearchResult<Event> result = index.getByQuery(query);
    boolean first = offset == 0;
    for (SearchResultItem<Event> currentEvent : result.getItems()) {
      final TimeSeries dataEvent = statisticsService.getTimeSeriesData(eventProvider,
          currentEvent.getSource().getIdentifier(), from, to, dataResolution, zoneId);
      if (fullMetadata) {
        this.printFullEventData(printer, dataEvent, dataResolution,
            currentEvent.getSource().getIdentifier(), zoneId, first);
      } else {
        printData(printer, dataEvent, dataResolution, currentEvent.getSource().getIdentifier(),
                currentEvent.getSource().getTitle(), zoneId, first);
      }
      first = false;
    }
  }

  private void printOrganization(

if (jobId == null) {
      throw new WorkflowOperationException(TRANSCRIPTION_JOB_ID + " missing");
    }

    // Check which tags/flavors have been configured
    ConfiguredTagsAndFlavors tagsAndFlavors = getTagsAndFlavors(
        workflowInstance, Configuration.none, Configuration.none, Configuration.many, Configuration.one);
    ConfiguredTagsAndFlavors.TargetTags targetTagOption = tagsAndFlavors.getTargetTags();
    MediaPackageElementFlavor targetFlavor = tagsAndFlavors.getSingleTargetFlavor();
    String captionFormatOption = StringUtils.trimToNull(operation.getConfiguration(TARGET_CAPTION_FORMAT));
    String typeUnparsed = StringUtils.trimToEmpty(operation.getConfiguration(TARGET_TYPE));
    MediaPackageElement.Type type = null;
    if (!typeUnparsed.isEmpty()) {
      // Case insensitive matching between user input (workflow config key) and enum value
      for (MediaPackageElement.Type t : MediaPackageElement.Type.values()) {
        if (t.name().equalsIgnoreCase(typeUnparsed)) {
          type = t;
        }
      }
      if (type == null || (type != Track.TYPE && type != Attachment.TYPE)) {
        throw new IllegalArgumentException(String.format("The given type '%s' for mediapackage %s was illegal. Please"
                + "check the operations' configuration keys.", type, mediaPackage.getIdentifier()));
      }
    } else {
      type = Track.TYPE;
    }

try {
      AccessControlList acl = new AccessControlList();
      for (var entry : aclInput.getEntries()) {
        for (var action : entry.getAction()) {
          acl.getEntries().add(new AccessControlEntry(entry.getRole(), action, true));
        }
      }

      if (aclInput.getManagedAclId() != null) {
        AclService aclService = context.getService(AclServiceFactory.class)
                                       .serviceFor(context.getService(SecurityService.class).getOrganization());
        aclService.getAcl(aclInput.getManagedAclId())
                  .ifPresent(value -> acl.merge(value.getAcl()));
      }
      indexService.updateEventAcl(eventId, acl, index);
    } catch (IndexServiceException | SearchIndexException e) {
      throw new GraphQLRuntimeException(e);
    } catch (UnauthorizedException e) {
      throw new GraphQLUnauthorizedException(e.getMessage());
    } catch (NotFoundException e) {
      throw new GraphQLNotFoundException(e.getMessage());
    }

try {
      final MediaPackage mediaPackage = MediaPackageParser.getFromXml(mediaPackageXml);
      final Set<? extends MediaPackageElement> downloadElements = new HashSet<MediaPackageElement>(
              MediaPackageElementParser.getArrayFromXml(downloadElementsXml));
      final Set<? extends MediaPackageElement> streamingElements = new HashSet<MediaPackageElement>(
              MediaPackageElementParser.getArrayFromXml(streamingElementsXml));
      final Set<MediaPackageElementFlavor> retractDownloadFlavors = split(retractDownloadFlavorsString).stream()
          .filter(s -> !s.isEmpty())
          .map(MediaPackageElementFlavor::parseFlavor)
          .collect(Collectors.toSet());
      final Set<MediaPackageElementFlavor> retractStreamingFlavors = split(retractStreamingFlavorsString).stream()
          .filter(s -> !s.isEmpty())
          .map(MediaPackageElementFlavor::parseFlavor)
          .collect(Collectors.toSet());
      final Set<? extends Publication> publications = MediaPackageElementParser.getArrayFromXml(publicationsXml)
          .stream().map(p -> (Publication) p).collect(Collectors.toSet());

@Produces(MediaType.APPLICATION_JSON)
  @RestQuery(name = "list", description = "Provides key-value list from the given source", pathParameters = { @RestParameter(name = "source", description = "The source for the key-value list", isRequired = true, type = RestParameter.Type.STRING) }, restParameters = {
          @RestParameter(description = "The maximum number of items to return per page", isRequired = false, name = "limit", type = RestParameter.Type.INTEGER),
          @RestParameter(description = "The offset", isRequired = false, name = "offset", type = RestParameter.Type.INTEGER),
          @RestParameter(description = "Filters", isRequired = false, name = "filter", type = RestParameter.Type.STRING) }, responses = { @RestResponse(description = "Returns the key-value list for the given source.", responseCode = HttpServletResponse.SC_OK) }, returnDescription = "")
  public Response getList(@PathParam("source") final String source, @QueryParam("limit") final int limit,
          @QueryParam("filter") final String filter, @QueryParam("offset") final int offset,
          @Context HttpHeaders headers) {

protected Map<String, String> getListWithTechnicalPresenters(ResourceListQuery query) {
    int offset = 0;
    int limit = 0;

    List<Contributor> contributorsList = new ArrayList<Contributor>();

    HashSet<String> labels = new HashSet<String>();

    if (!excludeUserProvider.contains(ALL_USER_PROVIDERS_VALUE)) {
      Iterator<User> users = userDirectoryService.findUsers("%", offset, limit);
      while (users.hasNext()) {
        User u = users.next();
        if (!excludeUserProvider.contains(u.getProvider())) {
          if (StringUtils.isNotBlank(u.getName())) {
            contributorsList.add(new Contributor(u.getUsername(), u.getName()));
            labels.add(u.getName());
          } else {
            contributorsList.add(new Contributor(u.getUsername(), u.getUsername()));
            labels.add(u.getUsername());
          }
        }
      }
    }

@Override public Optional<String> getAbstract() {
    return abstrakt;
  }

  @Override public Optional<String> getAccessRights() {
    return accessRights;
  }

  @Override public Optional<String> getAccrualMethod() {
    return accrualMethod;
  }

  @Override public Optional<String> getAccrualPeriodicity() {
    return accrualPeriodicity;
  }

  @Override public Optional<String> getAccrualPolicy() {
    return accrualPolicy;
  }

  @Override public Optional<String> getAlternative() {
    return alternative;
  }

  @Override public Optional<String> getAudience() {
    return audience;
  }

  @Override public Optional<String> getAvailable() {
    return available;
  }

  @Override public Optional<String> getBibliographicCitation() {
    return bibliographicCitation;
  }

  @Override public Optional<String> getConformsTo() {
    return conformsTo;
  }

  @Override public Optional<String> getContributor() {
    return contributor;
  }

  @Override public Optional<String> getCoverage() {
    return coverage;
  }

  @Override public Date getCreated() {
    return created.orElseThrow(() -> new Error("created not set"));

if (resultsArray != null) {
      // Save the results into a collection
      workspace.putInCollection(TRANSCRIPT_COLLECTION, jobId + ".json",
              new ByteArrayInputStream(jsonObj.toJSONString().getBytes()));
    }
  }

  @Override
  public MediaPackageElement getGeneratedTranscription(String mpId, String jobId, MediaPackageElement.Type type)
          throws TranscriptionServiceException {
    try {
      // If jobId is unknown, look for all jobs associated to that mpId
      if (jobId == null || "null".equals(jobId)) {
        jobId = null;
        for (TranscriptionJobControl jc : database.findByMediaPackage(mpId)) {
          if (TranscriptionJobControl.Status.Closed.name().equals(jc.getStatus())
                  || TranscriptionJobControl.Status.TranscriptionComplete.name().equals(jc.getStatus())) {
            jobId = jc.getTranscriptionJobId();
          }
        }
      }

      if (jobId == null) {
        throw new TranscriptionServiceException(
                "No completed or closed transcription job found in database for media package " + mpId);
      }

      // Results already saved?
      URI uri = workspace.getCollectionURI(TRANSCRIPT_COLLECTION, jobId + ".json");
      try {
        workspace.get(uri);
      } catch (Exception e) {

HttpPost post = new HttpPost("/encode");
    try {
      List<BasicNameValuePair> params = new ArrayList<>();
      params.add(new BasicNameValuePair("sourceTrack", MediaPackageElementParser.getAsXml(sourceTrack)));
      params.add(new BasicNameValuePair("profileId", profileId));
      post.setEntity(new UrlEncodedFormEntity(params, "UTF-8"));
    } catch (Exception e) {
      throw new EncoderException("Unable to assemble a remote composer request for track " + sourceTrack, e);
    }
    HttpResponse response = null;
    try {
      response = getResponse(post);
      if (response != null) {
        String content = EntityUtils.toString(response.getEntity());
        Job r = JobParser.parseJob(content);
        logger.info("Encoding job {} started on a remote composer", r.getId());
        return r;
      }
    } catch (Exception e) {
      throw new EncoderException("Unable to encode track " + sourceTrack + " using a remote composer service", e);
    } finally {
      closeConnection(response);
    }
    throw new EncoderException("Unable to encode track " + sourceTrack + " using a remote composer service");
  }

  /**
   * {@inheritDoc}
   */
  @Override
  public Job parallelEncode(Track sourceTrack, String profileId) throws EncoderException {

File source;
      try {
        source = workspace.get(element.getURI());
      } catch (NotFoundException e) {
        throw new DistributionException("Unable to find " + element.getURI() + " in the workspace", e);
      } catch (IOException e) {
        throw new DistributionException("Error loading " + element.getURI() + " from the workspace", e);
      }

      // Try to find a duplicated element source
      try {
        source = findDuplicatedElementSource(source, mediapackageId);
      } catch (IOException e) {
        logger.warn("Unable to find duplicated source {}: {}", source, ExceptionUtils.getMessage(e));
      }

      File destination = getDistributionFile(channelId, mediapackage, element);
      if (!destination.equals(source)) {
        // Put the file in place if sourcesfile differs destinationfile
        try {
          FileUtils.forceMkdir(destination.getParentFile());
        } catch (IOException e) {
          throw new DistributionException("Unable to create " + destination.getParentFile(), e);
        }
        logger.debug("Distributing element {} of media package {} to publication channel {} ({})", elementId,
            mediapackageId, channelId, destination);

        try {

public static final String SET_WF_PROPS_PROPERTY = "set-workflow-properties";

  /** The text analyzer */
  protected ExecuteService executeService;

  /** Reference to the media inspection service */
  private MediaInspectionService inspectionService = null;

  /** The workspace service */
  protected Workspace workspace;

  /**
   * {@inheritDoc}
   *
   * @see org.opencastproject.workflow.api.WorkflowOperationHandler#start(org.opencastproject.workflow.api.WorkflowInstance,
   *      JobContext)
   */
  @Override
  public WorkflowOperationResult start(WorkflowInstance workflowInstance, JobContext context)
          throws WorkflowOperationException {

    MediaPackage mediaPackage = workflowInstance.getMediaPackage();
    WorkflowOperationInstance operation = workflowInstance.getCurrentOperation();

    logger.debug("Running execute workflow operation with ID {}", operation.getId());

    // Get operation parameters
    String exec = StringUtils.trimToNull(operation.getConfiguration(EXEC_PROPERTY));
    String params = StringUtils.trimToNull(operation.getConfiguration(PARAMS_PROPERTY));
    float load = 1.0f;
    String loadPropertyStr = StringUtils.trimToEmpty(operation.getConfiguration(LOAD_PROPERTY));
    if (StringUtils.isNotBlank(loadPropertyStr)) {
      try {
        load = Float.parseFloat(loadPropertyStr);
      } catch (NumberFormatException e) {
        String description = StringUtils.trimToEmpty(operation.getDescription());
        logger.warn("Ignoring invalid load value '{}' on execute operation with description '{}'", loadPropertyStr,
                description);
      }
    }
    ConfiguredTagsAndFlavors tagsAndFlavors = getTagsAndFlavors(workflowInstance,
        Configuration.many, Configuration.many, Configuration.many, Configuration.many);

param(PARAM_CHECK_AVAILABILITY, Boolean.toString(checkAvailability)));
    Optional<Job> job = runRequest(req, JobUtil::jobFromHttpResponse);
    if (job.isPresent()) {
      return job.get();
    }
    throw new DistributionException(format("Unable to distribute '%s' elements of "
                    + "mediapackage '%s' using a remote destribution service proxy",
            elementIds.size(), mediaPackage.getIdentifier().toString()));
  }

  @Override
  public Job retract(String channelId, MediaPackage mediaPackage, String elementId) throws DistributionException {
    Set<String> elementIds = new HashSet<String>();
    elementIds.add(elementId);
    return retract(channelId, mediaPackage, elementIds);
  }

  @Override
  public Job retract(String channelId, MediaPackage mediaPackage, Set<String> elementIds) throws DistributionException {
    logger.info("Retracting {} elements from {}@{}", elementIds.size(), channelId, distributionChannel);
    final HttpPost req = post("/retract",
            param(PARAM_MEDIAPACKAGE, MediaPackageParser.getAsXml(mediaPackage)),
            param(PARAM_ELEMENT_ID, gson.toJson(elementIds)),

Set<String> elementIds = new HashSet<>();
    elementIds.add(elementId);
    return retract(channelId, mediapackage, elementIds);
  }

  @Override
  public Job retract(String channelId, MediaPackage mediapackage, Set<String> elementIds) throws DistributionException {
    notNull(mediapackage, "mediapackage");
    notNull(elementIds, "elementIds");
    notNull(channelId, "channelId");
    try {
      return serviceRegistry.createJob(JOB_TYPE, Operation.Retract.toString(),
              Arrays.asList(channelId, MediaPackageParser.getAsXml(mediapackage), gson.toJson(elementIds)),
              retractJobLoad);
    } catch (ServiceRegistryException e) {
      throw new DistributionException("Unable to create a job", e);
    }
  }

  @Override
  public List<MediaPackageElement> distributeSync(String channelId, MediaPackage mediapackage, String elementId)
          throws DistributionException, MediaPackageException {
    Set<String> elementIds = new HashSet<String>();
    elementIds.add(elementId);
    return distributeSync(channelId, mediapackage, elementIds, true);

}

    try {
      return new GqlSeries(
          index.getSeries(seriesId, context.getOrganization().getId(), context.getUser()).get()
      );
    } catch (SearchIndexException e) {
      throw new GraphQLRuntimeException(e);
    }
  }

  private MetadataList createMetadataList(Map<String, Object> seriesMetadata, IndexService indexService) {
    CommonSeriesCatalogUIAdapter adapter = (CommonSeriesCatalogUIAdapter) indexService
        .getCommonSeriesCatalogUIAdapter();

    MetadataList list = new MetadataList();
    list.add(adapter, adapter.getRawFields());

    final MediaPackageElementFlavor flavor = MediaPackageElementFlavor
        .parseFlavor("dublincore/series");

    final DublinCoreMetadataCollection collection = list.getMetadataByFlavor(flavor.toString());

    seriesMetadata.keySet().forEach(k -> {
      final MetadataField target = collection.getOutputFields().get(k);
      target.setValue(seriesMetadata.get(k));
    });

    return list;
  }

  public static Builder create(

if (!verifySakaiUser(query)) {
      return Collections.emptyIterator();
    }

    List<User> users = new LinkedList<User>();
    JaxbOrganization jaxbOrganization = JaxbOrganization.fromOrganization(organization);
    JaxbUser queryUser = new JaxbUser(query, PROVIDER_NAME, jaxbOrganization, new HashSet<JaxbRole>());
    users.add(queryUser);

    return users.iterator();
  }

  @Override
  public Iterator<User> getUsers() {
    // We never enumerate all users
    return Collections.emptyIterator();
  }

  @Override
  public void invalidate(String userName) {
    cache.invalidate(userName);
  }

  @Override
  public long countUsers() {
    // Not meaningful, as we never enumerate users
    return 0;
  }

  // RoleProvider methods

  @Override
  public List<Role> getRolesForUser(String userName) {

    List<Role> roles = new LinkedList<Role>();

    // Don't answer for admin, anonymous or empty user
    if ("admin".equals(userName) || "".equals(userName) || "anonymous".equals(userName)) {
      logger.debug("we don't answer for: " + userName);

return offsetLimitCollection(offset, limit, roles).iterator();
  }

  private <T> HashSet<T> offsetLimitCollection(int offset, int limit, HashSet<T> entries) {
    HashSet<T> result = new HashSet<T>();
    int i = 0;
    for (T entry : entries) {
      if (limit != 0 && result.size() >= limit) {
        break;
      }
      if (i >= offset) {
        result.add(entry);
      }
      i++;
    }
    return result;
  }

  private boolean like(String string, final String query) {
    if (string == null) {
      return false;
    }
    String regex = query.replace("_", ".").replace("%", ".*?");
    Pattern p = Pattern.compile(regex, Pattern.CASE_INSENSITIVE | Pattern.DOTALL);
    return p.matcher(string).matches();
  }

}

param(PARAM_CHECK_AVAILABILITY, Boolean.toString(checkAvailability)));
    Optional<List<MediaPackageElement>> elements = runRequest(req, RemoteBase::elementsFromHttpResponse);
    if (elements.isPresent()) {
      return elements.get();
    }
    throw new DistributionException(format("Unable to distribute '%s' elements of "
            + "mediapackage '%s' using a remote destribution service proxy",
        elementIds.size(), mediapackage.getIdentifier().toString()));
  }

  @Override
  public List<MediaPackageElement> retractSync(String channelId, MediaPackage mediaPackage, String elementId)
          throws DistributionException {
    Set<String> elementIds = new HashSet<String>();
    elementIds.add(elementId);
    return retractSync(channelId, mediaPackage, elementIds);
  }

  @Override
  public List<MediaPackageElement> retractSync(String channelId, MediaPackage mediaPackage, Set<String> elementIds)
          throws DistributionException {
    logger.info("Retracting {} elements from {}@{}", elementIds.size(), channelId, distributionChannel);
    final HttpPost req = post("/retractsync",

param(PARAM_CHECK_AVAILABILITY, Boolean.toString(checkAvailability)));
    Optional<List<MediaPackageElement>> elements = runRequest(req, RemoteBase::elementsFromHttpResponse);
    if (elements.isPresent()) {
      return elements.get();
    }
    throw new DistributionException(format("Unable to distribute '%s' elements of "
            + "mediapackage '%s' using a remote destribution service proxy",
        elementIds.size(), mediapackage.getIdentifier().toString()));
  }

  @Override
  public List<MediaPackageElement> retractSync(String channelId, MediaPackage mediaPackage, String elementId)
          throws DistributionException {
    Set<String> elementIds = new HashSet<String>();
    elementIds.add(elementId);
    return retractSync(channelId, mediaPackage, elementIds);
  }

  @Override
  public List<MediaPackageElement> retractSync(String channelId, MediaPackage mediaPackage, Set<String> elementIds)
          throws DistributionException {
    logger.info("Retracting {} elements from {}@{}", elementIds.size(), channelId, distributionChannel);
    final HttpPost req = post("/retractsync",

logger.warn("Cancel scheduling of workspace cleaner due to invalid scheduling period");
      return;
    }
    logger.debug("Scheduling workspace cleaner to run every {} seconds.", schedulerPeriod);
    try {
      final Trigger trigger = TriggerUtils.makeSecondlyTrigger(schedulerPeriod);
      trigger.setStartTime(new Date());
      trigger.setName(TRIGGER_NAME);
      trigger.setGroup(TRIGGER_GROUP);
      trigger.setJobName(JOB_NAME);
      trigger.setJobGroup(JOB_GROUP);
      if (quartz.getTriggersOfJob(JOB_NAME, JOB_GROUP).length == 0) {
        quartz.scheduleJob(trigger);
      } else {
        quartz.rescheduleJob(TRIGGER_NAME, TRIGGER_GROUP, trigger);
      }
    } catch (Exception e) {
      logger.error("Error scheduling Quartz job", e);
    }
  }

  /** Shutdown the scheduler. */
  public void shutdown() {
    try {
      quartz.shutdown();
    } catch (org.quartz.SchedulerException ignore) {
    }
  }

  // just to make sure Quartz is being shut down...
  @Override
  protected void finalize() throws Throwable {
    super.finalize();
    shutdown();
  }

@RestParameter(name = "mediaPackage", isRequired = true, type = Type.TEXT, description = "The media package of the event"),
          @RestParameter(name = "wfproperties", isRequired = false, type = Type.TEXT, description = "Workflow "
                  + "configuration keys for the event. Each key will be prefixed by 'org.opencastproject.workflow"
                  + ".config.' and added to the capture agent parameters."),
          @RestParameter(name = "agentparameters", isRequired = false, type = Type.TEXT, description = "The capture agent properties for the event"),
          @RestParameter(name = "source", isRequired = false, type = Type.STRING, description = "The scheduling source of the event"),
          }, responses = {
          @RestResponse(responseCode = HttpServletResponse.SC_CREATED, description = "Event is successfully created"),
          @RestResponse(responseCode = HttpServletResponse.SC_CONFLICT, description = "Unable to create event, conflicting events found (ConflicsFound)"),
          @RestResponse(responseCode = HttpServletResponse.SC_CONFLICT, description = "Unable to create event, event locked by a transaction  (TransactionLock)"),
          @RestResponse(responseCode = HttpServletResponse.SC_UNAUTHORIZED, description = "You do not have permission to create the event. Maybe you need to authenticate."),
          @RestResponse(responseCode = HttpServletResponse.SC_BAD_REQUEST, description = "Missing or invalid information for this request") })
  public Response addEvent(@FormParam("start") long startTime, @FormParam("end") long endTime,

var validSort = Arrays.asList("identifier", "title", "contributor", "creator", "created", "modified")
              .contains(sortParam[0]);
      var validOrder = sortParam.length < 2 || Arrays.asList("asc", "desc").contains(sortParam[1]);
      if (sortParam.length > 2 || !validSort || !validOrder) {
        return Response.status(Response.Status.BAD_REQUEST)
            .entity("Invalid sort parameter")
            .build();
      }
      var order = SortOrder.fromString(sortParam.length > 1 ? sortParam[1] : "asc");
      if ("modified".equals(sortParam[0])) {
        searchSource.sort(sortParam[0], order);
      } else {
        searchSource.sort(SearchResult.DUBLINCORE + "." + sortParam[0], order);
      }
    }

Job job = captionService.convert(transcription, "ibm-watson", captionFormatOption, service.getLanguage());
        if (!waitForStatus(job).isSuccess()) {
          throw new WorkflowOperationException("Transcription format conversion job did not complete successfully");
        }
        transcription = MediaPackageElementParser.getFromXml(job.getPayload());
      }

      // Set the target flavor if informed
      transcription.setFlavor(targetFlavor);

      // Add tags
      applyTargetTagsToElement(targetTagOption, transcription);

      // Add to media package
      mediaPackage.add(transcription);

      String uri = transcription.getURI().toString();
      String ext = uri.substring(uri.lastIndexOf("."));
      transcription.setURI(workspace.moveTo(transcription.getURI(), mediaPackage.getIdentifier().toString(),
              transcription.getIdentifier(), "captions." + ext));
    } catch (Exception e) {
      throw new WorkflowOperationException(e);
    }

    return createResult(mediaPackage, Action.CONTINUE);
  }

  @Reference(target = "(provider=ibm.watson)")

String mpId = StringUtils.trimToNull(mediaPackageId);

      Optional<Snapshot> snapshot = assetManager.getLatestSnapshot(mpId);
      if (snapshot.isEmpty()) {
        return notFound();
      }

      StringBuilder info = new StringBuilder();
      for (MediaPackageElement e : snapshot.get().getMediaPackage().elements()) {
        if (e.getElementType() == MediaPackageElement.Type.Publication) {
          continue;
        }

        StoragePath storagePath = new StoragePath(securityService.getOrganization().getId(),
            mpId,
            snapshot.get().getVersion(),
            e.getIdentifier());
        if (awsS3AssetStore.contains(storagePath)) {
          try {
            info.append(String.format("%s,%s\n", awsS3AssetStore.getAssetObjectKey(storagePath),
                                                 awsS3AssetStore.getAssetStorageClass(storagePath)));

Optional<String> defaultBucketNameOpt = OsgiUtil.getOptCfg(cc.getProperties(), AWS_S3_BUCKET_CONFIG);
      if (defaultBucketNameOpt.isPresent()) {
        orgBucketNameMap.put(DEFAULT_ORG_KEY, defaultBucketNameOpt.get());
        logger.info("AWS S3 default bucket name is {}", defaultBucketNameOpt.get());
      }

      // AWS S3 org bucket name mapping
      Collections.list(cc.getProperties().keys()).stream()
          .filter(s -> s.startsWith(AWS_S3_BUCKET_CONFIG_PREFIX))
          .forEach(s -> {
            String orgId = s.substring(AWS_S3_BUCKET_CONFIG_PREFIX.length());
            String bucketName = OsgiUtil.getComponentContextProperty(cc, s);
            orgBucketNameMap.put(orgId, bucketName);
          });

      if (orgBucketNameMap.isEmpty()) {
        throw new ConfigurationException("AWS S3 asset store is enabled, but no buckets are configured");

Marshaller marshaller = MediaPackageImpl.context.createMarshaller();

      Configuration config = new Configuration();
      config.setSupressAtAttributes(true);
      MappedNamespaceConvention con = new MappedNamespaceConvention(config);
      StringWriter writer = new StringWriter();
      XMLStreamWriter xmlStreamWriter = new MappedXMLStreamWriter(con, writer) {
        @Override
        public void writeStartElement(String prefix, String local, String uri) throws XMLStreamException {
          super.writeStartElement("", local, "");
        }

        @Override
        public void writeStartElement(String uri, String local) throws XMLStreamException {
          super.writeStartElement("", local, "");
        }

        @Override
        public void setPrefix(String pfx, String uri) throws XMLStreamException {
        }

        @Override
        public void setDefaultNamespace(String uri) throws XMLStreamException {
        }
      };

      marshaller.marshal(mediaPackage, xmlStreamWriter);

}
          i++;
        }

        /* Remove unused commandline parts */
        cmd = cmd.replaceAll("#\\{.*?\\}", "");
        // Find the output map based on splits and filters
        if (size == 1) { // no split
          if (afilter.get(indx) == null)
            apads.set(indx, adjustForNoComplexFilter(aInputPad));
          else
            apads.set(indx, "[oa" + indx + "]");
          if (vfilter.get(indx) == null)
            vpads.set(indx, adjustForNoComplexFilter(vInputPad)); // No split, no filter - straight from input
          else
            vpads.set(indx, "[ov" + indx + "]");

        } else { // split
          vpads.set(indx, "[ov" + indx + "]"); // name the output pads from split -> input to final format
          apads.set(indx, "[oa" + indx + "]"); // name the output audio pads
        }
        cmd = StringUtils.trimToNull(cmd); // remove all leading/trailing white spaces
        if (cmd != null) {

public Response getStorageClass(@PathParam("mediaPackageId") final String mediaPackageId) {
    return handleException(() -> {
      String mpId = StringUtils.trimToNull(mediaPackageId);

      Optional<Snapshot> snapshot = assetManager.getLatestSnapshot(mpId);
      if (snapshot.isEmpty()) {
        return notFound();
      }

      StringBuilder info = new StringBuilder();
      for (MediaPackageElement e : snapshot.get().getMediaPackage().elements()) {
        if (e.getElementType() == MediaPackageElement.Type.Publication) {
          continue;
        }

        StoragePath storagePath = new StoragePath(securityService.getOrganization().getId(),
            mpId,
            snapshot.get().getVersion(),
            e.getIdentifier());
        if (awsS3AssetStore.contains(storagePath)) {

private void updateGroupMembership(JpaUser user) {
    logger.debug("updateGroupMembership({}, roles={})", user.getUsername(), user.getRoles().size());
    List<String> internalGroupRoles = new ArrayList<>();

    for (Role role : user.getRoles()) {
      if (Role.Type.GROUP.equals(role.getType())
          || (Role.Type.INTERNAL.equals(role.getType()) && role.getName().startsWith(Group.ROLE_PREFIX))) {
        internalGroupRoles.add(role.getName());
      }
    }

    groupRoleProvider.updateGroupMembershipFromRoles(
        user.getUsername(),
        user.getOrganization().getId(),
        internalGroupRoles
    );
  }

  /**
   * Delete the given user
   *
   * @param username
   *          the name of the user to delete
   * @param orgId
   *          the organization id
   * @throws NotFoundException
   *          if the requested user is not exist
   * @throws org.opencastproject.security.api.UnauthorizedException
   *          if you havn't permissions to delete an admin user (only admins may do that)
   * @throws Exception
   */
  public void deleteUser(String username, String orgId) throws NotFoundException, UnauthorizedException, Exception {

query.setOffset(offset);

    String fHostname = null;
    if (query.getHostname().isPresent())
      fHostname = StringUtils.trimToNull(query.getHostname().get());
    String fNodeName = null;
    if (query.getNodeName().isPresent())
      fNodeName = StringUtils.trimToNull(query.getNodeName().get());
    String fStatus = null;
    if (query.getStatus().isPresent())
      fStatus = StringUtils.trimToNull(query.getStatus().get());
    String fFreeText = null;
    if (query.getFreeText().isPresent())
      fFreeText = StringUtils.trimToNull(query.getFreeText().get());

    List<JobExtended> jobs = new ArrayList<>();

@RestParameter(
              name = "start",
              isRequired = true,
              type = RestParameter.Type.STRING,
              defaultValue = "",
              description = "The start date, in the format yyyy-MM-dd'T'HH:mm:ss'Z'."),
          @RestParameter(
              name = "end",
              isRequired = true,
              type = RestParameter.Type.STRING,
              defaultValue = "",
              description = "The end date, in the format yyyy-MM-dd'T'HH:mm:ss'Z'."),
          @RestParameter(
              name = "target",
              isRequired = true,
              type = RestParameter.Type.STRING,
              defaultValue = "",
              description = "The target storage to move the mediapackage to.")},
      responses = {
          @RestResponse(
              description = "The job created to move the snapshots.",
              responseCode = SC_OK),
          @RestResponse(
              description = "Invalid parameters, and the job was not created",
              responseCode = SC_BAD_REQUEST),
          @RestResponse(
              description = "There has been an internal error, and the job was not created",
              responseCode = SC_INTERNAL_SERVER_ERROR)},
      returnDescription = "The Job created")
  public Response moveByDate(

@RestQuery(name = "copy", description = "Copies a file from a collection to a mediapackage", returnDescription = "A URL to the copied file", pathParameters = {
          @RestParameter(name = "fromCollection", description = "the collection identifier hosting the source", isRequired = true, type = STRING),
          @RestParameter(name = "fromFileName", description = "the source file name", isRequired = true, type = STRING),
          @RestParameter(name = "toMediaPackage", description = "the destination mediapackage identifier", isRequired = true, type = STRING),
          @RestParameter(name = "toMediaPackageElement", description = "the destination mediapackage element identifier", isRequired = true, type = STRING),
          @RestParameter(name = "toFileName", description = "the destination file name", isRequired = true, type = STRING) }, responses = {
          @RestResponse(responseCode = SC_OK, description = "URL returned"),
          @RestResponse(responseCode = SC_NOT_FOUND, description = "File to copy not found") })

return getFilterValue(ResourceListFilter.FREETEXT);
  }

  /**
   * Create a new {@link ResourceListFilter} based on a hostname.
   *
   * @param value the hostname to filter on wrapped in an {@link Optional} or {@link Optional#empty()}
   * @return a new {@link ResourceListFilter} for a hostname based query
   */
  public static <String> ResourceListFilter<String> createHostnameFilter(Optional<String> value) {
    return FiltersUtils.generateFilter(
            value,
            FILTER_NAME_HOSTNAME,
            FILTER_LABEL_HOSTNAME,
            ResourceListFilter.SourceType.SELECT,
            Optional.of(ServersListProvider.LIST_HOSTNAME));
  }

  /**
   * Create a new {@link ResourceListFilter} based on a nodeName.
   *
   * @param value the nodeName to filter on wrapped in an {@link Optional} or {@link Optional#empty()}
   * @return a new {@link ResourceListFilter} for a nodeName based query
   */
  public static ResourceListFilter<String> createNodeNameFilter(Optional<String> value) {
    return FiltersUtils.generateFilter(
            value,
            FILTER_NAME_NODE_NAME,
            FILTER_LABEL_NODE_NAME,
            ResourceListFilter.SourceType.SELECT,
            Optional.of(ServersListProvider.LIST_NODE_NAME));
  }

  /**
   * Create a new {@link ResourceListFilter} based on a status.
   *
   * @param value the status to filter on wrapped in an {@link Optional} or {@link Optional#empty()}
   * @return a new {@link ResourceListFilter} for a status based query
   */
  public static <String> ResourceListFilter<String> createStatusFilter(Optional<String> value) {
    return FiltersUtils.generateFilter(
            value,
            FILTER_NAME_STATUS,
            FILTER_LABEL_STATUS,
            ResourceListFilter.SourceType.SELECT,
            Optional.of(JobsListProvider.LIST_STATUS));

@Argument(name = "plugins", description = "The name of the plugin to disable.", required = true, multiValued = true)
  @Completion(PluginNameCompleter.class)
  private List<String> plugins;

  @Option(name = "--persist", description = "Persist changes", required = false, multiValued = false)
  private boolean persist = false;

  @Override
  public Object execute() throws Exception {
    var properties = configRepository.getConfigAdmin()
        .getConfiguration(PluginManagerImpl.class.getName()).getProperties();

    Set<String> available = pluginManager.listAvailablePlugins();
    for (String plugin : plugins) {
      if (!available.contains(plugin)) {
        throw new IllegalArgumentException("Plugin " + plugin + " is invalid");
      } else {
        properties.put(plugin, "off");

private String language = null;

  @Override
  @Activate
  protected void activate(ComponentContext cc) {
    super.activate(cc);
  }

  /**
   * {@inheritDoc}
   *
   * @see
   * org.opencastproject.workflow.api.WorkflowOperationHandler#start(org.opencastproject.workflow.api.WorkflowInstance,
   * JobContext)
   */
  @Override
  public WorkflowOperationResult start(final WorkflowInstance workflowInstance, JobContext context)
          throws WorkflowOperationException {
    MediaPackage mediaPackage = workflowInstance.getMediaPackage();
    WorkflowOperationInstance operation = workflowInstance.getCurrentOperation();

    String skipOption = StringUtils.trimToNull(operation.getConfiguration(SKIP_IF_FLAVOR_EXISTS));
    if (skipOption != null) {
      MediaPackageElement[] mpes = mediaPackage.getElementsByFlavor(MediaPackageElementFlavor.parseFlavor(skipOption));
      if (mpes != null && mpes.length > 0) {
        logger.info(
                "Start transcription operation will be skipped because flavor {} already exists in the media package",
                skipOption);
        return createResult(Action.SKIP);
      }
    }

    logger.debug("Start transcription for mediapackage {} started", mediaPackage);

URL url = new URL(sakaiUrl + "/direct/membership/fastroles/" + userId + ".xml" + "?__auth=basic");
      String encoded = Base64.encodeBase64String((sakaiUsername + ":" + sakaiPassword).getBytes("utf8"));

      HttpURLConnection connection = (HttpURLConnection) url.openConnection();
      connection.setRequestMethod("GET");
      connection.setDoOutput(true);
      connection.setRequestProperty("Authorization", "Basic " + encoded);
      connection.setRequestProperty("User-Agent", OC_USERAGENT);

      String xml = IOUtils.toString(new BufferedInputStream(connection.getInputStream()));
      logger.debug(xml);

      DocumentBuilder parser = XmlSafeParser.newDocumentBuilderFactory().newDocumentBuilder();

      Document document = parser.parse(new org.xml.sax.InputSource(new StringReader(xml)));

      Element root = document.getDocumentElement();

Catalog[] catalogs = mediaPackage
            .getCatalogs(new MediaPackageElementFlavor("dublincore", StringUtils.lowerCase(configuredCatalog)));

    if (catalogs != null && catalogs.length > 0) {
      Boolean foundValue = false;
      EName dcterm = new EName(TERMS_NS_URI, configuredDCTerm);

      // Find DCTerm
      for (Catalog catalog : catalogs) {
        DublinCoreCatalog dc = DublinCoreUtil.loadDublinCore(workspace, catalog);
        // Match Value
        List<DublinCoreValue> values = dc.get(dcterm);
        if (values.isEmpty()) {
          // Use default
          if (configuredDefaultValue != null) {
            foundValue = configuredDefaultValue.equals(configuredMatchValue);
          }
        } else {
          foundValue = values.contains(DublinCoreValue.mk(configuredMatchValue));
        }
      }

      if (foundValue) {

params.add(new BasicNameValuePair("audioSourceTrack", MediaPackageElementParser.getAsXml(sourceAudioTrack)));
      params.add(new BasicNameValuePair("profileId", profileId));
      post.setEntity(new UrlEncodedFormEntity(params, "UTF-8"));
    } catch (Exception e) {
      throw new EncoderException("Unable to assemble a remote composer request", e);
    }
    HttpResponse response = null;
    try {
      response = getResponse(post);
      if (response != null) {
        String content = EntityUtils.toString(response.getEntity());
        Job r = JobParser.parseJob(content);
        logger.info("Muxing job {} started on a remote composer", r.getId());
        return r;
      }
    } catch (IOException e) {
      throw new EncoderException(e);
    } finally {
      closeConnection(response);
    }
    throw new EncoderException("Unable to mux tracks " + sourceVideoTrack + " and " + sourceAudioTrack

for (SmilMediaObject element : smil.getBody().getMediaElements()) {
        // body should contain par elements
        if (element.isContainer()) {
          SmilMediaContainer container = (SmilMediaContainer) element;
          if (SmilMediaContainer.ContainerType.PAR == container.getContainerType()) {
            // par element should contain media elements
            for (SmilMediaObject elementChild : container.getElements()) {
              if (!elementChild.isContainer()) {
                SmilMediaElement media = (SmilMediaElement) elementChild;
                if (trackParamGroupId.equals(media.getParamGroup())) {
                  long begin = media.getClipBeginMS();
                  long end = media.getClipEndMS();
                  URI clipTrackURI = media.getSrc();
                  File clipSourceFile = null;
                  if (clipTrackURI != null) {

}

  /**
   * Callback for the OSGi environment to set the workspace reference.
   *
   * @param workspace
   *          the workspace
   */
  @Reference
  protected void setWorkspace(Workspace workspace) {
    this.workspace = workspace;
  }

  /**
   * Callback for the OSGi environment to set the service registry reference.
   *
   * @param serviceRegistry
   *          the service registry
   */
  @Reference
  protected void setServiceRegistry(ServiceRegistry serviceRegistry) {
    this.serviceRegistry = serviceRegistry;
  }

  /**
   * {@inheritDoc}
   *
   * @see org.opencastproject.job.api.AbstractJobProducer#getServiceRegistry()
   */
  @Override
  protected ServiceRegistry getServiceRegistry() {
    return serviceRegistry;
  }

  /**
   * Callback for setting the security service.
   *
   * @param securityService
   *          the securityService to set
   */
  @Reference
  public void setSecurityService(SecurityService securityService) {
    this.securityService = securityService;
  }

  /**
   * Callback for setting the user directory service.
   *
   * @param userDirectoryService
   *          the userDirectoryService to set
   */
  @Reference
  public void setUserDirectoryService(UserDirectoryService userDirectoryService) {
    this.userDirectoryService = userDirectoryService;
  }

  /**
   * Sets a reference to the organization directory service.
   *
   * @param organizationDirectory
   *          the organization directory
   */
  @Reference
  public void setOrganizationDirectoryService(OrganizationDirectoryService organizationDirectory) {
    this.organizationDirectoryService = organizationDirectory;
  }

  /**
   * {@inheritDoc}
   *
   * @see org.opencastproject.job.api.AbstractJobProducer#getSecurityService()
   */
  @Override
  protected SecurityService getSecurityService() {
    return securityService;
  }

  /**
   * {@inheritDoc}
   *
   * @see org.opencastproject.job.api.AbstractJobProducer#getUserDirectoryService()
   */
  @Override
  protected UserDirectoryService getUserDirectoryService() {
    return userDirectoryService;
  }

  /**
   * {@inheritDoc}
   *
   * @see org.opencastproject.job.api.AbstractJobProducer#getOrganizationDirectoryService()
   */
  @Override
  protected OrganizationDirectoryService getOrganizationDirectoryService() {
    return organizationDirectoryService;
  }

final List<ServiceRegistration> filteredList = new ArrayList<>();

    for (ServiceRegistration service : serviceRegistrations) {
      // Skip service if host not available
      if (!hostBaseUrls.contains(service.getHost())) {
        logger.trace("Not considering {} because it's host {} is not available for dispatching", service,
                service.getHost());
        continue;
      }

      // Skip services that are not of the requested type
      if (!jobType.equals(service.getServiceType())) {
        logger.trace("Not considering {} because it is of the wrong job type", service);
        continue;
      }

      // Skip services that are in error state
      if (service.getServiceState() == ERROR) {
        logger.trace("Not considering {} because it is in error state", service);
        continue;
      }

      // Skip services that are in maintenance mode
      if (service.isInMaintenanceMode()) {
        logger.trace("Not considering {} because it is in maintenance mode", service);
        continue;
      }

      // Skip services that are marked as offline
      if (!service.isOnline()) {
        logger.trace("Not considering {} because it is currently offline", service);
        continue;
      }

public Response createTheme(@FormParam("default") boolean isDefault, @FormParam("name") String name,
          @FormParam("description") String description, @FormParam("bumperActive") Boolean bumperActive,
          @FormParam("trailerActive") Boolean trailerActive, @FormParam("titleSlideActive") Boolean titleSlideActive,
          @FormParam("licenseSlideActive") Boolean licenseSlideActive,
          @FormParam("watermarkActive") Boolean watermarkActive, @FormParam("bumperFile") String bumperFile,
          @FormParam("trailerFile") String trailerFile, @FormParam("watermarkFile") String watermarkFile,
          @FormParam("titleSlideBackground") String titleSlideBackground,
          @FormParam("licenseSlideBackground") String licenseSlideBackground,
          @FormParam("titleSlideMetadata") String titleSlideMetadata,
          @FormParam("licenseSlideDescription") String licenseSlideDescription,
          @FormParam("watermarkPosition") String watermarkPosition) {

param(PARAM_ELEMENT_ID, gson.toJson(elementIds)),
            param(PARAM_CHANNEL_ID, channelId));
    Optional<Job> job = runRequest(req, JobUtil::jobFromHttpResponse);
    if (job.isPresent()) {
      return job.get();
    }
    throw new DistributionException(format("Unable to retract '%s' elements of "
                    + "mediapackage '%s' using a remote destribution service proxy",
            elementIds.size(), mediaPackage.getIdentifier().toString()));
  }

  @Override
  public List<MediaPackageElement>  distributeSync(String channelId, MediaPackage mediaPackage, String elementId)
          throws DistributionException {
    Set<String> elementIds = new HashSet<String>();
    elementIds.add(elementId);
    return distributeSync(channelId, mediaPackage, elementIds, true);

public UserActionList getUserActionsByTypeAndDay(String type, String day, int offset, int limit) {
    UserActionList result = new UserActionListImpl();

    int year = Integer.parseInt(day.substring(0, 4));
    int month = Integer.parseInt(day.substring(4, 6)) - 1;
    int date = Integer.parseInt(day.substring(6, 8));

    Calendar calBegin = new GregorianCalendar();
    calBegin.set(year, month, date, 0, 0);
    Calendar calEnd = new GregorianCalendar();
    calEnd.set(year, month, date, 23, 59);

    db.exec(em -> {
      result.setTotal(getTotalQuery(type, calBegin, calEnd).apply(em));

@RestParameter(name = "eventId", description = "The event id", isRequired = true, type = STRING) }, restParameters = {
                  @RestParameter(name = "sign", isRequired = false, description = "Whether public distribution urls should be signed.", type = Type.BOOLEAN),
                  @RestParameter(name = "withacl", isRequired = false, description = "Whether the acl metadata should be included in the response.", type = Type.BOOLEAN),
                  @RestParameter(name = "withmetadata", isRequired = false, description = "Whether the metadata catalogs should be included in the response.", type = Type.BOOLEAN),
                  @RestParameter(name = "withscheduling", isRequired = false, description = "Whether the scheduling information should be included in the response.", type = Type.BOOLEAN),
                  @RestParameter(name = "withpublications", isRequired = false, description = "Whether the publication ids and urls should be included in the response.", type = Type.BOOLEAN),
                  @RestParameter(name = "includeInternalPublication", isRequired = false, description = "Whether internal publications should be included.", type = Type.BOOLEAN)}, responses = {

queryArgs.add("srt=" + StringUtils.trimToEmpty(signedResourceType));
    Date startDate = signedStart;
    if (startDate == null) {
      startDate = Date.from(Instant.now().minus(15, ChronoUnit.MINUTES));
    }
    stringBuilder.append(df.format(startDate) + "\n");
    queryArgs.add("st=" + df.format(startDate));
    Date endDate = signedExpiry;
    if (endDate == null) {
      endDate = Date.from(Instant.now().plus(1, ChronoUnit.DAYS));
    }
    stringBuilder.append(df.format(endDate) + "\n");
    queryArgs.add("se=" + df.format(endDate));

language = StringUtils.trim(langCode);
    }
    if (!sourceTagOption.isEmpty()) {
      elementSelector.addTag(sourceTagOption.get(0));
    }

    Collection<Track> elements = elementSelector.select(mediaPackage, false);
    Job job = null;
    for (Track track : elements) {
      if (track.hasVideo()) {
        logger.info("Skipping track {} since it contains a video stream", track);
        continue;
      }
      if (!track.hasAudio()) {
        logger.info("Track {} from media package {} doesn't contain audio stream. Skip subtitle generation.",
            track.getFlavor(), mediaPackage.getIdentifier());
        continue;
      }
      try {
        job = service.startTranscription(mediaPackage.getIdentifier().toString(), track, language);

}

  /**
   * Adds extended metadata fields to the input document
   *
   * @param doc
   *          the input document
   * @param extendedMetadata
   *          the extended metadata map
   */
  private static void addExtendedMetadata(SearchMetadataCollection doc, Map<String, Map<String,
          List<String>>> extendedMetadata) {
    for (String type: extendedMetadata.keySet()) {
      Map<String, List<String>> extendedMetadataByType = extendedMetadata.get(type);
      for (String name: extendedMetadataByType.keySet()) {
        List<String> values = extendedMetadataByType.get(name);
        String fieldName = SeriesIndexSchema.EXTENDED_METADATA_PREFIX.concat(type + "_" + name);
        doc.addField(fieldName, values, true);
      }
    }
  }

  /**
   * Adds authorization fields to the input document.
   *
   * @param doc
   *          the input document
   * @param aclString
   *          the access control list string
   */
  private static void addAuthorization(SearchMetadataCollection doc, String aclString,

@RestQuery(name = "addZippedMediaPackage", description = "Create media package from a compressed file containing a manifest.xml document and all media tracks, metadata catalogs and attachments", pathParameters = { @RestParameter(description = "Workflow definition id", isRequired = true, name = WORKFLOW_DEFINITION_ID_PARAM, type = RestParameter.Type.STRING) }, restParameters = { @RestParameter(description = "The workflow instance ID to associate with this zipped mediapackage", isRequired = false, name = WORKFLOW_INSTANCE_ID_PARAM, type = RestParameter.Type.STRING) }, bodyParameter = @RestParameter(description = "The compressed (application/zip) media package file", isRequired = true, name = "BODY", type = RestParameter.Type.FILE), responses = {
          @RestResponse(description = "", responseCode = HttpServletResponse.SC_OK),
          @RestResponse(description = "", responseCode = HttpServletResponse.SC_BAD_REQUEST),
          @RestResponse(description = "", responseCode = HttpServletResponse.SC_NOT_FOUND),
          @RestResponse(description = "", responseCode = HttpServletResponse.SC_SERVICE_UNAVAILABLE) }, returnDescription = "")
  public Response addZippedMediaPackage(@Context HttpServletRequest request,

}

  /**
   *
   * @param mp
   *          the mediapackage to update
   * @param dc
   *          the dublincore metadata to use to update the mediapackage
   * @return the updated mediapackage
   * @throws IOException
   *           Thrown if an IO error occurred adding the dc catalog file
   * @throws MediaPackageException
   *           Thrown if an error occurred updating the mediapackage or the mediapackage does not contain a catalog
   */
  private MediaPackage updateDublincCoreCatalog(MediaPackage mp, DublinCoreCatalog dc)
          throws IOException, MediaPackageException {
    try (InputStream inputStream = IOUtils.toInputStream(dc.toXmlString(), "UTF-8")) {
      // Update dublincore catalog
      Catalog[] catalogs = mp.getCatalogs(MediaPackageElements.EPISODE);
      if (catalogs.length > 0) {
        Catalog catalog = catalogs[0];
        URI uri = workspace.put(mp.getIdentifier().toString(), catalog.getIdentifier(), "dublincore.xml", inputStream);
        catalog.setURI(uri);
        // setting the URI to a new source so the checksum will most like be invalid
        catalog.setChecksum(null);
      } else {
        throw new MediaPackageException("Unable to find catalog");
      }
    }
    return mp;
  }

param(PARAM_ELEMENT_ID, gson.toJson(elementIds)),
        param(PARAM_CHANNEL_ID, channelId));
    Optional<List<MediaPackageElement>> elements = runRequest(req, RemoteBase::elementsFromHttpResponse);
    if (elements.isPresent()) {
      return elements.get();
    }
    throw new DistributionException(format("Unable to retract '%s' elements of "
            + "mediapackage '%s' using a remote destribution service proxy",
        elementIds.size(), mediaPackage.getIdentifier().toString()));
  }

  @Reference
  @Override
  public void setTrustedHttpClient(TrustedHttpClient trustedHttpClient) {
    super.setTrustedHttpClient(trustedHttpClient);
  }

  @Reference
  @Override
  public void setRemoteServiceManager(ServiceRegistry serviceRegistry) {
    super.setRemoteServiceManager(serviceRegistry);
  }

}

static final String SKIP_IF_FLAVOR_EXISTS = "skip-if-flavor-exists";

  /** The transcription service */
  private TranscriptionService service = null;

  @Override
  @Activate
  protected void activate(ComponentContext cc) {
    super.activate(cc);
  }

  @Override
  public WorkflowOperationResult start(final WorkflowInstance workflowInstance, JobContext context)
          throws WorkflowOperationException {
    MediaPackage mediaPackage = workflowInstance.getMediaPackage();
    WorkflowOperationInstance operation = workflowInstance.getCurrentOperation();

    String skipOption = StringUtils.trimToNull(operation.getConfiguration(SKIP_IF_FLAVOR_EXISTS));
    if (skipOption != null) {
      MediaPackageElement[] mpes = mediaPackage.getElementsByFlavor(MediaPackageElementFlavor.parseFlavor(skipOption));
      if (mpes != null && mpes.length > 0) {
        logger.info(

Optional<Event> optEvent = getIndexService().getEvent(eventId, getIndex());
    if (optEvent.isEmpty())
      return notFound("Cannot find an event with id '%s'.", eventId);

    EventComment comment = null;
    EventCommentReply reply = null;
    try {
      comment = getEventCommentService().getComment(commentId);
      for (EventCommentReply r : comment.getReplies()) {
        if (r.getId().isEmpty() || replyId != r.getId().get().longValue())
          continue;
        reply = r;
        break;
      }

      if (reply == null)
        throw new NotFoundException("Reply with id " + replyId + " not found!");

params.add(new BasicNameValuePair("time", buildTimeArray(times)));
      post.setEntity(new UrlEncodedFormEntity(params, "UTF-8"));
    } catch (Exception e) {
      throw new EncoderException(e);
    }
    HttpResponse response = null;
    try {
      response = getResponse(post);
      if (response != null) {
        Job r = JobParser.parseJob(response.getEntity().getContent());
        logger.info("Image extraction job {} started on a remote composer", r.getId());
        return r;
      }
    } catch (Exception e) {
      throw new EncoderException(e);
    } finally {
      closeConnection(response);
    }
    throw new EncoderException("Unable to compose an image from track " + sourceTrack
            + " using the remote composer service proxy");
  }

  @Override
  public List<Attachment> imageSync(Track sourceTrack, String profileId, double... times) throws EncoderException, MediaPackageException {

formStringParams.add(new BasicNameValuePair(INPUT_ELEM_FORM_PARAM, inElementStr));
      if (outFileName != null)
        formStringParams.add(new BasicNameValuePair(OUTPUT_NAME_FORM_PARAMETER, outFileName));
      if (type != null)
        formStringParams.add(new BasicNameValuePair(TYPE_FORM_PARAMETER, type.toString()));

      logger.info("Executing command {} using a remote execute service", exec);

      post = new HttpPost("/" + ExecuteService.ENDPOINT_NAME);
      post.setEntity(new UrlEncodedFormEntity(formStringParams, "UTF-8"));
      response = getResponse(post);

      if (response != null) {
        Job job = JobParser.parseJob(response.getEntity().getContent());
        logger.info("Completing execution of command {} using a remote execute service", exec);
        return job;
      } else

returnDescription = "The job that can be used to track the publication",
      restParameters = {
          @RestParameter(
              name = "mediapackage",
              isRequired = true,
              description = "The media package",
              type = RestParameter.Type.TEXT
          ),
          @RestParameter(
              name = "channel",
              isRequired = true,
              description = "The channel name",
              type = RestParameter.Type.STRING
          ),
          @RestParameter(
              name = "addElements",
              isRequired = true,
              description = "The media package elements to published",
              type = RestParameter.Type.STRING
          ),
          @RestParameter(
              name = "retractElements",
              isRequired = true,
              description = "The identifiers of the media package elements to be retracted from the media package",
              type = RestParameter.Type.STRING
          )
      },
      responses = {
          @RestResponse(
              responseCode = HttpServletResponse.SC_OK,
              description = "An XML representation of the publication job"

newPublishers.setValue(series.getPublishers());
    metadata.addField(newPublishers);

    // Admin UI only field
    MetadataField createdBy = new MetadataField(
      "createdBy",
      null,
      "EVENTS.SERIES.DETAILS.METADATA.CREATED_BY",
      true,
      false,
      null,
      null,
      MetadataField.Type.TEXT,
      null,
      null,
      CREATED_BY_UI_ORDER,
      null,
      null,
      null,
      null);
    createdBy.setValue(series.getCreator());
    metadata.addField(createdBy);

    MetadataField uid = metadata.getOutputFields().get(DublinCore.PROPERTY_IDENTIFIER.getLocalName());
    metadata.removeField(uid);
    MetadataField newUID = new MetadataField(uid);
    newUID.setValue(series.getIdentifier());
    metadata.addField(newUID);

@RestQuery(name = "actionsasxml", description = "Get user actions by type and day", returnDescription = "The user actions.", restParameters = {
          @RestParameter(name = "type", description = "The type of the user action", isRequired = false, type = Type.STRING),
          @RestParameter(name = "day", description = "The day of creation (format: YYYYMMDD)", isRequired = false, type = Type.STRING),
          @RestParameter(name = "limit", description = "The maximum number of items to return per page", isRequired = false, type = Type.INTEGER),
          @RestParameter(name = "offset", description = "The page number", isRequired = false, type = Type.INTEGER) }, responses = { @RestResponse(responseCode = SC_OK, description = "An XML representation of the user actions") })

@RestQuery(name = "reportasxml", description = "Get a report for a time range", returnDescription = "The report.", restParameters = {
          @RestParameter(name = "from", description = "The beginning of the time range", isRequired = false, type = Type.STRING),
          @RestParameter(name = "to", description = "The end of the time range", isRequired = false, type = Type.STRING),
          @RestParameter(name = "limit", description = "The maximum number of items to return per page", isRequired = false, type = Type.INTEGER),
          @RestParameter(name = "offset", description = "The page number", isRequired = false, type = Type.INTEGER) }, responses = { @RestResponse(responseCode = SC_OK, description = "An XML representation of the report") })

}

  @Override
  public float getMaxLoad() {
    return maxLoad;
  }

  @Override
  public void setMaxLoad(float maxLoad) {
    this.maxLoad = maxLoad;
  }

  @Override
  public boolean isActive() {
    return active;
  }

  @Override
  public void setActive(boolean active) {
    this.active = active;
  }

  @Override
  public boolean isOnline() {
    return online;
  }

  @Override
  public void setOnline(boolean online) {
    this.online = online;
  }

  @Override
  public boolean isMaintenanceMode() {
    return maintenanceMode;
  }

  @Override
  public void setMaintenanceMode(boolean maintenanceMode) {
    this.maintenanceMode = maintenanceMode;
  }

  @Override
  public String getIpAddress() {

throw new IllegalArgumentException("Destination file name must be set");
    }

    Vector<java.io.File> files = new Vector<java.io.File>();
    for (String name : sourceFiles) {
      if (name == null) {
        logger.error("One of the input file names is null");
        throw new IllegalArgumentException("One of the input file names is null");
      } else if ("".equals(name)) {
        logger.error("One of the input file names is blank");
        throw new IllegalArgumentException("One of the input file names is blank");
      }
      files.add(new java.io.File(name));
    }

    return zip(files.toArray(new java.io.File[files.size()]), new java.io.File(destination), recursive, level);

HttpPost post = new HttpPost("/stop");
    List<BasicNameValuePair> params = new ArrayList<>();
    params.add(new BasicNameValuePair("id", Long.toString(workflowInstanceId)));
    try {
      post.setEntity(new UrlEncodedFormEntity(params, "UTF-8"));
    } catch (UnsupportedEncodingException e) {
      throw new IllegalStateException("Unable to assemble a remote workflow service request", e);
    }
    HttpResponse response = getResponse(post, SC_OK, SC_NOT_FOUND);
    try {
      if (response != null) {
        if (response.getStatusLine().getStatusCode() == SC_NOT_FOUND) {
          throw new NotFoundException("Workflow instance with id='" + workflowInstanceId + "' not found");
        } else {
          logger.info("Workflow '{}' stopped", workflowInstanceId);

Date start;
    Date end;
    try {
      start = sdf.parse(startString);
      end = sdf.parse(endString);
    } catch (ParseException e) {
      return badRequest("Invalid start or end date format");
    }

    if (end.before(start)) {
      return badRequest("Start date " + start + " must be before end date " + end);
    }

    final String trimmedTarget = StringUtils.trimToNull(target);
    if (null == trimmedTarget) {
      return badRequest("Invalid target store ID: " + trimmedTarget);
    } else if (!tsamjp.datastoreExists(trimmedTarget)) {
      return badRequest("Target store " + trimmedTarget + " not found");
    }

    try {
      Job j = tsamjp.moveByDate(start, end, trimmedTarget);

VideoClip vclip = clips.get(i);
        int fileindx = vclip.getSrc(); // get source file by index
        double inpt = vclip.getStart(); // get in points
        double duration = vclip.getDuration();
        double vend = Math.max(duration - vfade, 0);
        double aend = Math.max(duration - afade, 0);
        if (hasVideo) {
          String vvclip;
          vvclip = "[" + fileindx + ":v]trim=" + f.format(inpt) + ":duration=" + f.format(duration)
                  + ",setpts=PTS-STARTPTS"
                  + ((vfade > 0) ? ",fade=t=in:st=0:d=" + vfade + ",fade=t=out:st=" + f.format(vend) + ":d=" + vfade
                          : "")
                  + "[" + outmap + "v" + i + "]";

return this.distributionChannel;
  }

  @Override
  public Job distribute(String channelId, MediaPackage mediaPackage, String elementId) throws DistributionException {
    return distribute(channelId, mediaPackage, elementId, true);
  }

  @Override
  public Job distribute(String channelId, MediaPackage mediaPackage, String elementId, boolean checkAvailability)
          throws DistributionException {
    Set<String> elementIds = new HashSet<String>();
    elementIds.add(elementId);
    return distribute(channelId, mediaPackage, elementIds, checkAvailability);
  }

  @Override
  public Job distribute(String channelId, final MediaPackage mediaPackage, Set<String> elementIds,
          boolean checkAvailability)
          throws DistributionException {

}

  /**
   * Sets the receipt service
   *
   * @param serviceRegistry
   *          the service registry
   */
  @Reference
  public void setServiceRegistry(ServiceRegistry serviceRegistry) {
    this.serviceRegistry = serviceRegistry;
  }

  /**
   * {@inheritDoc}
   *
   * @see org.opencastproject.job.api.AbstractJobProducer#getServiceRegistry()
   */
  @Override
  protected ServiceRegistry getServiceRegistry() {
    return serviceRegistry;
  }

  /**
   * {@inheritDoc}
   *
   * @see org.opencastproject.job.api.AbstractJobProducer#getSecurityService()
   */
  @Override
  protected SecurityService getSecurityService() {
    return securityService;
  }

  /**
   * Callback for setting the security service.
   *
   * @param securityService
   *          the securityService to set
   */
  @Reference
  public void setSecurityService(SecurityService securityService) {
    this.securityService = securityService;
  }

  /**
   * Callback for setting the user directory service.
   *
   * @param userDirectoryService
   *          the userDirectoryService to set
   */
  @Reference
  public void setUserDirectoryService(UserDirectoryService userDirectoryService) {
    this.userDirectoryService = userDirectoryService;
  }

  /**
   * {@inheritDoc}
   *
   * @see org.opencastproject.job.api.AbstractJobProducer#getUserDirectoryService()
   */
  @Override
  protected UserDirectoryService getUserDirectoryService() {
    return userDirectoryService;
  }

  /**
   * {@inheritDoc}
   *
   * @see org.opencastproject.job.api.AbstractJobProducer#getOrganizationDirectoryService()
   */
  @Override
  protected OrganizationDirectoryService getOrganizationDirectoryService() {
    return organizationDirectoryService;
  }

  /**
   * Sets a reference to the organization directory service.
   *
   * @param organizationDirectory
   *          the organization directory
   */
  @Reference
  public void setOrganizationDirectoryService(OrganizationDirectoryService organizationDirectory) {
    this.organizationDirectoryService = organizationDirectory;
  }

  /**
   * Sets a reference to the workspace service.
   *
   * @param workspace
   */
  @Reference

}

  /**
   * Sets the receipt service
   *
   * @param serviceRegistry
   *            the service registry
   */
  @Reference
  protected void setServiceRegistry(ServiceRegistry serviceRegistry) {
    this.serviceRegistry = serviceRegistry;
  }

  /**
   * {@inheritDoc}
   *
   * @see org.opencastproject.job.api.AbstractJobProducer#getServiceRegistry()
   */
  @Override
  protected ServiceRegistry getServiceRegistry() {
    return serviceRegistry;
  }

  /**
   * Callback for setting the security service.
   *
   * @param securityService
   *            the securityService to set
   */
  @Reference
  public void setSecurityService(SecurityService securityService) {
    this.securityService = securityService;
  }

  /**
   * Callback for setting the user directory service.
   *
   * @param userDirectoryService
   *            the userDirectoryService to set
   */
  @Reference
  public void setUserDirectoryService(
      UserDirectoryService userDirectoryService) {
    this.userDirectoryService = userDirectoryService;
  }

  /**
   * Sets a reference to the organization directory service.
   *
   * @param organizationDirectory
   *            the organization directory
   */
  @Reference
  public void setOrganizationDirectoryService(
      OrganizationDirectoryService organizationDirectory) {
    this.organizationDirectoryService = organizationDirectory;
  }

  /**
   * {@inheritDoc}
   *
   * @see org.opencastproject.job.api.AbstractJobProducer#getSecurityService()
   */
  @Override
  protected SecurityService getSecurityService() {
    return securityService;
  }

  /**
   * {@inheritDoc}
   *
   * @see org.opencastproject.job.api.AbstractJobProducer#getUserDirectoryService()
   */
  @Override
  protected UserDirectoryService getUserDirectoryService() {
    return userDirectoryService;
  }

  /**
   * {@inheritDoc}
   *
   * @see org.opencastproject.job.api.AbstractJobProducer#getOrganizationDirectoryService()
   */
  @Override
  protected OrganizationDirectoryService getOrganizationDirectoryService() {
    return organizationDirectoryService;
  }

}

public Response getEventsMetadata(@FormParam("eventIds") String eventIds) throws Exception {
    if (StringUtils.isBlank(eventIds)) {
      return badRequest("Event ids can't be empty");
    }

    JSONParser parser = new JSONParser();
    List<String> ids;
    try {
      ids = (List<String>) parser.parse(eventIds);
    } catch (org.json.simple.parser.ParseException e) {
      logger.error("Unable to parse '{}'", eventIds, e);
      return badRequest("Unable to parse event ids");
    } catch (ClassCastException e) {
      logger.error("Unable to cast '{}'", eventIds, e);
      return badRequest("Unable to parse event ids");
    }

    Set<String> eventsNotFound = new HashSet();

}

  @Override
  public boolean verifyUrlAccess(final String path) {
    // Always allow access for admin
    final User user = securityService.getUser();
    if (user.hasRole(GLOBAL_ADMIN_ROLE)) {
      logger.debug("Allow access for admin `{}`", user);
      return true;
    }

    // Check pattern
    final Matcher m = staticFilePattern.matcher(path);
    if (!m.matches()) {
      logger.debug("Path does not match pattern. Preventing access.");
      return false;
    }

    // Check organization
    final String organizationId = m.group(1);
    if (!securityService.getOrganization().getId().equals(organizationId)) {
      logger.debug("The user's organization does not match. Preventing access.");
      return false;
    }

}

  /**
   * Callback for the OSGi environment to set the service registry reference.
   *
   * @param serviceRegistry
   *          the service registry
   */
  @Reference
  protected void setServiceRegistry(ServiceRegistry serviceRegistry) {
    this.serviceRegistry = serviceRegistry;
  }

  /**
   * {@inheritDoc}
   *
   * @see org.opencastproject.job.api.AbstractJobProducer#getServiceRegistry()
   */
  @Override
  protected ServiceRegistry getServiceRegistry() {
    return serviceRegistry;
  }

  /**
   * Callback for setting the security service.
   *
   * @param securityService
   *          the securityService to set
   */
  @Reference
  public void setSecurityService(SecurityService securityService) {
    this.securityService = securityService;
  }

  /**
   * Callback for setting the user directory service.
   *
   * @param userDirectoryService
   *          the userDirectoryService to set
   */
  @Reference
  public void setUserDirectoryService(UserDirectoryService userDirectoryService) {
    this.userDirectoryService = userDirectoryService;
  }

  /**
   * Sets a reference to the organization directory service.
   *
   * @param organizationDirectory
   *          the organization directory
   */
  @Reference
  public void setOrganizationDirectoryService(OrganizationDirectoryService organizationDirectory) {
    this.organizationDirectoryService = organizationDirectory;
  }

  /**
   * {@inheritDoc}
   *
   * @see org.opencastproject.job.api.AbstractJobProducer#getSecurityService()
   */
  @Override
  protected SecurityService getSecurityService() {
    return securityService;
  }

  /**
   * {@inheritDoc}
   *
   * @see org.opencastproject.job.api.AbstractJobProducer#getUserDirectoryService()
   */
  @Override
  protected UserDirectoryService getUserDirectoryService() {
    return userDirectoryService;
  }

  /**
   * {@inheritDoc}
   *
   * @see org.opencastproject.job.api.AbstractJobProducer#getOrganizationDirectoryService()
   */
  @Override
  protected OrganizationDirectoryService getOrganizationDirectoryService() {
    return organizationDirectoryService;
  }

}
                  if (start == -1 || end == -1) {
                    logger.warn("Could not build caption object for job {}, result index {}: start/end times not found", jobId, i);
                    continue resultsLoop;
                  }

                  String[] captionLines = new String[1];
                  captionLines[0] = line.toString().replace("%HESITATION", "...");
                  captionList.add(new CaptionImpl(buildTime((long) (start * 1000)), buildTime((long) (end * 1000)), captionLines));
                  indexFirst = -1;
                  indexLast = -1;
                  line.setLength(0);
                }
              }
            }
          }
        }
      }

content: while (audioContentIterator.hasNext()) {
      Audio audioContent = audioContentIterator.next();
      TemporalDecomposition<AudioSegment> audioSegments = (TemporalDecomposition<AudioSegment>) audioContent
              .getTemporalDecomposition();
      Iterator<AudioSegment> audioSegmentIterator = audioSegments.segments();
      if (audioSegmentIterator == null)
        continue content;
      while (audioSegmentIterator.hasNext()) {
        AudioSegment segment = audioSegmentIterator.next();
        Iterator<TextAnnotation> annotationIterator = segment.textAnnotations();
        if (annotationIterator == null)
          continue content;
        while (annotationIterator.hasNext()) {
          TextAnnotation annotation = annotationIterator.next();

public Response encode(@FormParam("sourceTrack") String sourceTrackAsXml, @FormParam("profileId") String profileId)
          throws Exception {
    // Ensure that the POST parameters are present
    if (StringUtils.isBlank(sourceTrackAsXml) || StringUtils.isBlank(profileId))
      return Response.status(Response.Status.BAD_REQUEST).entity("sourceTrack and profileId must not be null").build();

    // Deserialize the track
    MediaPackageElement sourceTrack = MediaPackageElementParser.getFromXml(sourceTrackAsXml);
    if (!Track.TYPE.equals(sourceTrack.getElementType()))
      return Response.status(Response.Status.BAD_REQUEST).entity("sourceTrack element must be of type track").build();

    try {
      // Asynchronously encode the specified tracks
      Job job = composerService.encode((Track) sourceTrack, profileId);

String sc = StringUtils.trimToNull(storageClass);

      Optional<Snapshot> snapshot = assetManager.getLatestSnapshot(mpId);
      if (snapshot.isEmpty()) {
        return notFound();
      }
      StringBuilder info = new StringBuilder();
      for (MediaPackageElement e : snapshot.get().getMediaPackage().elements()) {
        if (e.getElementType() == MediaPackageElement.Type.Publication) {
          continue;
        }

        StoragePath storagePath = new StoragePath(securityService.getOrganization().getId(),
            mpId,
            snapshot.get().getVersion(),
            e.getIdentifier());
        if (awsS3AssetStore.contains(storagePath)) {

}

  /**
   * @param securityService
   *          the securityService to set
   */
  @Reference
  public void setSecurityService(SecurityService securityService) {
    this.securityService = securityService;
  }

  /**
   * @param authorizationService
   *          the authorizationService to set
   */
  @Reference
  public void setAuthorizationService(AuthorizationService authorizationService) {
    this.authorizationService = authorizationService;
  }

  /**
   * @param organizationDirectoryService
   *          the organizationDirectoryService to set
   */
  @Reference
  public void setOrganizationDirectoryService(OrganizationDirectoryService organizationDirectoryService) {
    this.organizationDirectoryService = organizationDirectoryService;
  }

  public void handleEvent(final SeriesItem seriesItem) {
    // A series or its ACL has been updated. Find any mediapackages with that series, and update them.
    logger.debug("Handling {}", seriesItem);
    String seriesId = seriesItem.getSeriesId();

    // We must be an administrative user to make this query
    final User prevUser = securityService.getUser();
    final Organization prevOrg = securityService.getOrganization();
    try {
      securityService.setUser(SecurityUtil.createSystemUser(systemAccount, prevOrg));

Marshaller marshaller = Comment.context.createMarshaller();
      marshaller.marshal(this, writer);
      return writer.toString();
    } catch (JAXBException e) {
      throw new IllegalStateException(e.getLinkedException() != null ? e.getLinkedException() : e);
    }
  }

  /**
   * Create an unmarshaller for comments
   * @return an unmarshaller for comments
   * @throws IOException
   */
  public static Unmarshaller createUnmarshaller() throws IOException {
    try {
      if (context == null) {
        createJAXBContext();
      }
      return context.createUnmarshaller();
    } catch (JAXBException e) {
      throw new IOException(e.getLinkedException() != null ? e.getLinkedException() : e);
    }
  }

}

logger.error("I/O error during execution of query on target {}", request.getURI(), e);
      return false;
    }

    Integer statusCode = response.getStatusLine().getStatusCode();
    if (statusCode == SC_OK || statusCode == SC_NO_CONTENT || statusCode == SC_ACCEPTED) {
      logger.debug("Request successfully executed on target {}, status code: {}", request.getURI(), statusCode);
      return true;
    } else if (maxAttempts > 1) {
      logger.debug("Request failed on target {}, status code: {}, will retry in {} seconds", request.getURI(),
              statusCode, sleepTime / 1000);
      try {
        Thread.sleep(sleepTime);
        return executeRequest(request, --maxAttempts, timeout, sleepTime * SLEEP_SCALE_FACTOR);
      } catch (InterruptedException e) {
        logger.error("Error during sleep time before new notification request try", e);

HttpDelete del = new HttpDelete(seriesID);
    HttpResponse response = getResponse(del, SC_OK, SC_NOT_FOUND, SC_UNAUTHORIZED);
    try {
      if (response != null) {
        int statusCode = response.getStatusLine().getStatusCode();
        if (SC_NOT_FOUND == statusCode) {
          throw new NotFoundException("Series not found: " + seriesID);
        } else if (SC_UNAUTHORIZED == statusCode) {
          throw new UnauthorizedException("Not authorized to delete series " + seriesID);
        } else if (SC_OK == statusCode) {
          logger.info("Successfully deleted {} from the remote series index", seriesID);
          return;
        }
      }
    } finally {
      closeConnection(response);
    }
    throw new SeriesException("Unable to remove " + seriesID + " from a remote series index");
  }

  @GET

private TranscriptionService service = null;

  @Override
  @Activate
  protected void activate(ComponentContext cc) {
    super.activate(cc);
  }

  @Override
  public WorkflowOperationResult start(final WorkflowInstance workflowInstance, JobContext context)
          throws WorkflowOperationException {
    MediaPackage mediaPackage = workflowInstance.getMediaPackage();
    WorkflowOperationInstance operation = workflowInstance.getCurrentOperation();

    String skipOption = StringUtils.trimToNull(operation.getConfiguration(SKIP_IF_FLAVOR_EXISTS));
    if (skipOption != null) {
      MediaPackageElement[] mpes = mediaPackage.getElementsByFlavor(MediaPackageElementFlavor.parseFlavor(skipOption));
      if (mpes != null && mpes.length > 0) {
        logger.info(

@Produces(MediaType.APPLICATION_JSON)
  @RestQuery(name = "health", description = "Checks the status of the registered services", returnDescription = "Returns NO_CONTENT if services are in a proper state", restParameters = {
          @RestParameter(name = "serviceType", isRequired = false, type = Type.STRING, description = "The service type identifier"),
          @RestParameter(name = "host", isRequired = false, type = Type.STRING, description = "The host, including the http(s) protocol") }, responses = {
          @RestResponse(responseCode = SC_OK, description = "Service states returned"),
          @RestResponse(responseCode = SC_NOT_FOUND, description = "No service of that type on that host is registered."),
          @RestResponse(responseCode = SC_SERVICE_UNAVAILABLE, description = "An error has occurred during stats processing") })
  public Response getHealthStatusAsJson(@QueryParam("serviceType") String serviceType, @QueryParam("host") String host)

logger.debug("No jobs yet for provider {}", PROVIDER);
          return;
        }

        List<TranscriptionJobControl> jobs = database.findByStatus(TranscriptionJobControl.Status.InProgress.name(),
                TranscriptionJobControl.Status.TranscriptionComplete.name());
        for (TranscriptionJobControl j : jobs) {

          // Don't process jobs for other services
          if (j.getProviderId() != providerId) {
            continue;
          }

          String mpId = j.getMediaPackageId();
          String jobId = j.getTranscriptionJobId();

          // If the job in progress, check if it should already have finished.
          if (TranscriptionJobControl.Status.InProgress.name().equals(j.getStatus())) {
            // If job should already have been completed, try to get the results. Consider a buffer factor so that we
            // don't try it too early. Results normally should be ready 1/3 of the time of the track duration.
            // The completionCheckBuffer can be used to delay results check.
            if (j.getDateCreated().getTime() + (j.getTrackDuration() / 3) + completionCheckBuffer * 1000 < System

String url = StringUtils.trimToEmpty(transcriptionUrl);
    try (CloseableHttpClient httpClient = HttpUtils.makeHttpClient()) {
      HttpGet httpGet = new HttpGet(url);
      httpGet.addHeader("Ocp-Apim-Subscription-Key", azureCognitiveServicesSubscriptionKey);
      try (CloseableHttpResponse response = httpClient.execute(httpGet)) {
        int code = response.getStatusLine().getStatusCode();
        String responseString = "";
        if (response.getEntity() != null) {
          responseString = EntityUtils.toString(response.getEntity());
        }
        switch (code) {
          case HttpStatus.SC_OK: // 200
            break;
          case HttpStatus.SC_FORBIDDEN: // 403
            throw new MicrosoftAzureNotAllowedException(String.format("Not allowed to get transcription '%s'. "

String langCode = operation.getConfiguration(LANGUAGE_CODE);

    // Check which tags have been configured
    ConfiguredTagsAndFlavors tagsAndFlavors = getTagsAndFlavors(
        workflowInstance, Configuration.many, Configuration.many, Configuration.none, Configuration.none);
    List<String> sourceTagOption = tagsAndFlavors.getSrcTags();
    List<MediaPackageElementFlavor> sourceFlavorOption = tagsAndFlavors.getSrcFlavors();

    AbstractMediaPackageElementSelector<Track> elementSelector = new TrackSelector();

    // Make sure either one of tags or flavors are provided
    if (sourceTagOption.isEmpty() && sourceFlavorOption.isEmpty()) {
      throw new WorkflowOperationException("No source tag or flavor have been specified!");
    }

    if (!sourceFlavorOption.isEmpty()) {
      MediaPackageElementFlavor flavor = sourceFlavorOption.get(0);
      elementSelector.addFlavor(flavor);
    }
    if (StringUtils.isNotBlank(langCode)) {

@Path("")
  @Produces(MediaType.APPLICATION_JSON)
  @RestQuery(name = "createacl", description = "Create an ACL", returnDescription = "Create an ACL", restParameters = {
          @RestParameter(name = "name", isRequired = true, description = "The ACL name", type = STRING),
          @RestParameter(name = "acl", isRequired = true, description = "The access control list", type = STRING) }, responses = {
          @RestResponse(responseCode = SC_OK, description = "The ACL has successfully been added"),
          @RestResponse(responseCode = SC_CONFLICT, description = "An ACL with the same name already exists"),
          @RestResponse(responseCode = SC_BAD_REQUEST, description = "Unable to parse the ACL") })

HttpPost post = new HttpPost("/image");
    try {
      List<BasicNameValuePair> params = new ArrayList<BasicNameValuePair>();
      params.add(new BasicNameValuePair("sourceTrack", MediaPackageElementParser.getAsXml(sourceTrack)));
      params.add(new BasicNameValuePair("profileId", profileId));
      params.add(new BasicNameValuePair("time", buildTimeArray(times)));
      post.setEntity(new UrlEncodedFormEntity(params, "UTF-8"));
    } catch (Exception e) {
      throw new EncoderException(e);
    }
    HttpResponse response = null;
    try {
      response = getResponse(post);
      if (response != null) {

returnDescription = "The job that can be used to track the distribution",
      restParameters = {
          @RestParameter(
              name = "mediapackage",
              isRequired = true,
              description = "The mediapackage",
              type = Type.TEXT
          ),
          @RestParameter(
              name = "channelId",
              isRequired = true,
              description = "The publication channel ID",
              type = Type.TEXT
          ),
          @RestParameter(
              name = "elementId",
              isRequired = true,
              description = "The element to distribute",
              type = Type.STRING
          ),
          @RestParameter(
              name = "checkAvailability",
              isRequired = false,
              description = "If the service should try to access the distributed element",
              type = Type.BOOLEAN
          )
      },
      responses = {
          @RestResponse(responseCode = SC_OK, description = "An XML representation of the distribution job")

SearchResult<Event> results = null;
        try {
          results = elasticsearchIndex.getByQuery(query);
        } catch (SearchIndexException e) {
          logger.error("The External Search Index was not able to get the events list", e);
          throw new WebApplicationException(Status.INTERNAL_SERVER_ERROR);
        }

        SearchResultItem<Event>[] items = results.getItems();
        List<IndexObject> events = new ArrayList<>();
        for (SearchResultItem<Event> item : items) {
          Event source = item.getSource();
          source.updatePreview(previewSubtype);
          events.add(source);
        }
        //Append  filtered results to the list
        allEvents.addAll(events);
      }

@RestParameter(description = "The tags of the media track", isRequired = false, name = "tags", type = RestParameter.Type.STRING),
      @RestParameter(description = "The media package as XML", isRequired = true, name = "mediaPackage", type = RestParameter.Type.TEXT) },
    bodyParameter = @RestParameter(description = "The media track file", isRequired = true, name = "BODY", type = RestParameter.Type.FILE),
    responses = {
      @RestResponse(description = "Returns augmented media package", responseCode = HttpServletResponse.SC_OK),
      @RestResponse(description = "Media package not valid", responseCode = HttpServletResponse.SC_BAD_REQUEST),
      @RestResponse(description = "", responseCode = HttpServletResponse.SC_INTERNAL_SERVER_ERROR) },
    returnDescription = "")
  public Response addMediaPackageTrack(@Context HttpServletRequest request) {

params.add(new BasicNameValuePair("sameCodec", "true"));
      post.setEntity(new UrlEncodedFormEntity(params, "UTF-8"));
    } catch (Exception e) {
      throw new EncoderException(e);
    }
    HttpResponse response = null;
    try {
      response = getResponse(post);
      if (response != null) {
        Job r = JobParser.parseJob(response.getEntity().getContent());
        logger.info("Concat video job {} started on a remote composer", r.getId());
        return r;
      }
    } catch (Exception e) {
      throw new EncoderException(e);
    } finally {
      closeConnection(response);
    }
    throw new EncoderException("Unable to concat videos from tracks " + tracks

throw new SchedulerConflictException("Conflicting events found when adding event " + eventId);
        } else {
          throw new SchedulerException("Unexpected error code " + errorCode);
        }
      } else if (response != null && SC_UNAUTHORIZED == response.getStatusLine().getStatusCode()) {
        logger.info("Unauthorized to create the event");
        throw new UnauthorizedException("Unauthorized to create the event");
      } else {
        throw new SchedulerException("Unable to add event " + eventId + " to the scheduler service");
      }
    } catch (UnauthorizedException | SchedulerConflictException e) {
      throw e;
    } catch (Exception e) {
      throw new SchedulerException("Unable to add event " + eventId + " to the scheduler service", e);
    } finally {
      closeConnection(response);
    }
  }

  @Override
  public Map<String, Period> addMultipleEvents(RRule rRule, Date start, Date end, Long duration, TimeZone tz,

returnDescription = "Returns a XML representation of the list of user accounts",
      restParameters = {
          @RestParameter(
              name = "query",
              description = "The search query, must be at lest 3 characters long.",
              isRequired = false,
              type = RestParameter.Type.STRING
          ),
          @RestParameter(
              name = "limit",
              defaultValue = "100",
              description = "The maximum number of items to return per page.",
              isRequired = false,
              type = RestParameter.Type.INTEGER
          ),
          @RestParameter(
              name = "offset",
              defaultValue = "0",
              description = "The page number.",
              isRequired = false,
              type = RestParameter.Type.INTEGER
          ),
      },
      responses = { @RestResponse(responseCode = SC_OK, description = "The user accounts.") }
  )
  public Response getUsersAsXml(

Theme theme = new Theme(Optional.<Long> empty(), new Date(), isDefault, creator, name,
            StringUtils.trimToNull(description), BooleanUtils.toBoolean(bumperActive),
            StringUtils.trimToNull(bumperFile), BooleanUtils.toBoolean(trailerActive),
            StringUtils.trimToNull(trailerFile), BooleanUtils.toBoolean(titleSlideActive),
            StringUtils.trimToNull(titleSlideMetadata), StringUtils.trimToNull(titleSlideBackground),
            BooleanUtils.toBoolean(licenseSlideActive), StringUtils.trimToNull(licenseSlideBackground),
            StringUtils.trimToNull(licenseSlideDescription), BooleanUtils.toBoolean(watermarkActive),
            StringUtils.trimToNull(watermarkFile), StringUtils.trimToNull(watermarkPosition));

    try {

}

  @POST
  @Path("updateIndex")
  @RestQuery(name = "updateIndex",
      description = "Trigger search index update for event. The usage of this is limited to global administrators.",
      restParameters = {
          @RestParameter(
              name = "id",
              isRequired = true,
              type = STRING,
              description = "The event ID to trigger an index update for.")},
      responses = {
          @RestResponse(
              description = "Update successfully triggered.",
              responseCode = SC_NO_CONTENT),
          @RestResponse(
              description = "Not allowed to trigger update.",
              responseCode = SC_FORBIDDEN),
          @RestResponse(
              description = "No such event found.",
              responseCode = SC_NOT_FOUND)},
      returnDescription = "No content is returned.")
  public Response indexUpdate(@FormParam("id") final String id) {
    try {

}

  /**
   * {@inheritDoc}
   *
   * @see org.opencastproject.job.api.AbstractJobProducer#process(org.opencastproject.job.api.Job)
   */
  @Override
  protected String process(Job job) throws Exception {
    Operation op = null;
    String operation = job.getOperation();
    List<String> arguments = job.getArguments();
    try {
      op = Operation.valueOf(operation);
      String channelId = arguments.get(0);
      MediaPackage mediapackage = MediaPackageParser.getFromXml(arguments.get(1));
      Set<String> elementIds = gson.fromJson(arguments.get(2), new TypeToken<Set<String>>() { }.getType());

URI newUrl = addContentToRepo(mediaPackage, elementId, uri);
      MediaPackage mp = addContentToMediaPackage(mediaPackage, elementId, newUrl, MediaPackageElement.Type.Track,
              flavor);
      job.setStatus(Job.Status.FINISHED);
      // store startTime
      partialTrackStartTimes.put(elementId, startTime);
      logger.debug("Added start time {} for track {}", startTime, elementId);
      logger.info("Successful added partial track {} on mediapackage {} at URL {}", elementId, mediaPackage, newUrl);
      return mp;
    } catch (ServiceRegistryException e) {
      throw new IngestException(e);
    } catch (NotFoundException e) {
      throw new IngestException("Unable to update ingest job", e);
    } finally {
      finallyUpdateJob(job);
    }
  }

  @Override
  public MediaPackage addPartialTrack(InputStream in, String fileName, MediaPackageElementFlavor flavor, long startTime,

this.tags = new TreeSet<String>(Arrays.asList(tags));
  }

  /**
   * @see org.opencastproject.mediapackage.MediaPackageElement#addTag(java.lang.String)
   */
  @Override
  public void addTag(String tag) {
    if (tag == null)
      throw new IllegalArgumentException("Tag must not be null");
    tags.add(tag);
  }

  /**
   * @see org.opencastproject.mediapackage.MediaPackageElement#removeTag(java.lang.String)
   */
  @Override
  public void removeTag(String tag) {
    if (tag == null)
      return;
    tags.remove(tag);
  }

  /**
   * @see org.opencastproject.mediapackage.MediaPackageElement#containsTag(java.lang.String)
   */
  @Override
  public boolean containsTag(String tag) {
    if (tag == null || tags == null)
      return false;
    return tags.contains(tag);
  }

  /**
   * @see org.opencastproject.mediapackage.MediaPackageElement#containsTag(java.util.Collection)
   */
  @Override
  public boolean containsTag(Collection<String> tags) {
    if (tags == null || tags.size() == 0)

}
  )
  public Response getState() {
    if (service != null) {
      JSONObject json  = new JSONObject();
      String state = service.getState().toString();
      json.put("state", state);
      return Response.ok(json.toJSONString()).build();
    } else {
      logger.error("TerminationStateService is not available");
      return Response.status(Response.Status.SERVICE_UNAVAILABLE).build();
    }
  }

  @Override
  @PUT
  @Path("/state")
  @RestQuery(
      name = "setstate",
      description = "Set the termination state. The only permissable value to write to the state is 'wait'",