private List<Repository> getRepositories(final Repository repository) {
   checkNotNull(repository);
   if (groupType.equals(repository.getType())) {
     return repository.facet(GroupFacet.class).leafMembers();
   }
   return ImmutableList.of(repository);
 }
 @Override
 public BrowseResult<Asset> browseAssets(
     final Repository repository,
     @Nullable final String filter,
     @Nullable final String sortProperty,
     @Nullable final String sortDirection,
     @Nullable final Integer start,
     @Nullable final Integer limit) {
   checkNotNull(repository);
   final List<Repository> repositories = getRepositories(repository);
   try (StorageTx storageTx = repository.facet(StorageFacet.class).txSupplier().get()) {
     storageTx.begin();
     QueryOptions options =
         new QueryOptions(filter, sortProperty, sortDirection, start, limit, repository.getName());
     BrowseAssetsSqlBuilder builder = new BrowseAssetsSqlBuilder(options);
     return new BrowseResult<>(
         storageTx.countAssets(
             builder.buildWhereClause(), builder.buildSqlParams(), repositories, null),
         Lists.newArrayList(
             storageTx.findAssets(
                 builder.buildWhereClause(),
                 builder.buildSqlParams(),
                 repositories,
                 builder.buildQuerySuffix())));
   }
 }
 @Override
 public BrowseResult<Asset> browseComponentAssets(
     final Repository repository, final String componentId) {
   checkNotNull(repository);
   checkNotNull(componentId);
   try (StorageTx storageTx = repository.facet(StorageFacet.class).txSupplier().get()) {
     storageTx.begin();
     Component component = storageTx.findComponent(new DetachedEntityId(componentId));
     if (component == null) {
       return new BrowseResult<>(0, Collections.emptyList());
     }
     VariableResolverAdapter variableResolverAdapter =
         variableResolverAdapterManager.get(component.format());
     List<Asset> assets =
         StreamSupport.stream(storageTx.browseAssets(component).spliterator(), false)
             .filter(
                 (Asset asset) ->
                     contentPermissionChecker.isPermitted(
                         repository.getName(),
                         asset.format(),
                         BreadActions.BROWSE,
                         variableResolverAdapter.fromAsset(asset)))
             .collect(Collectors.toList());
     return new BrowseResult<>(assets.size(), assets);
   }
 }
  @Override
  public List<Repository> leafMembers() {
    List<Repository> leafMembers = new ArrayList<>();

    for (Repository repository : members()) {
      try {
        final GroupFacet groupFacet = repository.facet(GroupFacet.class);
        leafMembers.addAll(groupFacet.leafMembers());
      } catch (MissingFacetException e) {
        leafMembers.add(repository);
      }
    }

    return leafMembers;
  }
 /**
  * Find content validator for given repository. If no format-specific validator is configured, the
  * default is used.
  *
  * @param repository The repository for content validator is looked up.
  * @return the repository specific content validator to be used, or the default content validator,
  *     never {@code null}.
  */
 @Nonnull
 public ContentValidator validator(final Repository repository) {
   checkNotNull(repository);
   String format = repository.getFormat().getValue();
   log.trace("Looking for content validator for format: {}", format);
   ContentValidator contentValidator = contentValidators.get(format);
   if (contentValidator == null) {
     return defaultContentValidator;
   }
   return contentValidator;
 }
Example #6
0
  /**
   * Returns the first OK response from member repositories or {@link HttpResponses#notFound()} if
   * none of the members responded with OK.
   */
  protected Response getFirst(
      final @Nonnull Request request,
      final @Nonnull List<Repository> members,
      final @Nonnull DispatchedRepositories dispatched)
      throws Exception {
    for (Repository member : members) {
      log.trace("Trying member: {}", member);
      // track repositories we have dispatched to, prevent circular dispatch for nested groups
      if (dispatched.contains(member)) {
        log.trace("Skipping already dispatched member: {}", member);
        continue;
      }
      dispatched.add(member);

      final ViewFacet view = member.facet(ViewFacet.class);
      final Response response = view.dispatch(request);
      if (response.getStatus().isSuccessful()) {
        return response;
      }
    }
    return HttpResponses.notFound();
  }
Example #7
0
  /** Returns all responses from all members as a linked map, where order is group member order. */
  protected LinkedHashMap<Repository, Response> getAll(
      final @Nonnull Request request,
      final @Nonnull List<Repository> members,
      final @Nonnull DispatchedRepositories dispatched)
      throws Exception {
    final LinkedHashMap<Repository, Response> responses = Maps.newLinkedHashMap();
    for (Repository member : members) {
      log.trace("Trying member: {}", member);
      // track repositories we have dispatched to, prevent circular dispatch for nested groups
      if (dispatched.contains(member)) {
        log.trace("Skipping already dispatched member: {}", member);
        continue;
      }
      dispatched.add(member);

      final ViewFacet view = member.facet(ViewFacet.class);
      final Response response = view.dispatch(request);

      responses.put(member, response);
    }
    return responses;
  }
 @Override
 public BrowseResult<Component> browseComponents(
     final Repository repository,
     @Nullable final String filter,
     @Nullable final String sortProperty,
     @Nullable final String sortDirection,
     @Nullable final Integer start,
     @Nullable final Integer limit) {
   checkNotNull(repository);
   final List<Repository> repositories = getRepositories(repository);
   try (StorageTx storageTx = repository.facet(StorageFacet.class).txSupplier().get()) {
     storageTx.begin();
     List<Bucket> buckets = getBuckets(storageTx, repositories);
     QueryOptions options =
         new QueryOptions(filter, sortProperty, sortDirection, start, limit, repository.getName());
     BrowseComponentsSqlBuilder builder =
         new BrowseComponentsSqlBuilder(groupType.equals(repository.getType()), buckets, options);
     return new BrowseResult<>(
         getCount(storageTx.browse(builder.buildCountSql(), builder.buildSqlParams())),
         getComponents(storageTx.browse(builder.buildBrowseSql(), builder.buildSqlParams())));
   }
 }
  @Override
  @Guarded(by = STARTED)
  public List<Repository> members() {
    final Repository repository = getRepository();

    List<Repository> members = new ArrayList<>(config.memberNames.size());
    for (String name : config.memberNames) {
      Repository member = repositoryManager.get(name);
      if (member == null) {
        log.warn("Ignoring missing member repository: {}", name);
      } else if (!repository.getFormat().equals(member.getFormat())) {
        log.warn(
            "Group {} includes an incompatible-format member: {} with format {}",
            repository.getName(),
            name,
            member.getFormat());
      } else {
        members.add(member);
      }
    }
    return members;
  }
 @Override
 public BrowseResult<Asset> previewAssets(
     final List<Repository> repositories,
     final String jexlExpression,
     @Nullable final String filter,
     @Nullable final String sortProperty,
     @Nullable final String sortDirection,
     @Nullable final Integer start,
     @Nullable final Integer limit) {
   checkNotNull(repositories);
   checkNotNull(jexlExpression);
   final Repository repository = repositories.get(0);
   try (StorageTx storageTx = repository.facet(StorageFacet.class).txSupplier().get()) {
     storageTx.begin();
     List<Repository> previewRepositories;
     if (repositories.size() == 1 && groupType.equals(repository.getType())) {
       previewRepositories = repository.facet(GroupFacet.class).leafMembers();
     } else {
       previewRepositories = repositories;
     }
     QueryOptions options =
         new QueryOptions(filter, sortProperty, sortDirection, start, limit, repository.getName());
     PreviewAssetsSqlBuilder builder =
         new PreviewAssetsSqlBuilder(
             repository.getName(),
             jexlExpression,
             previewRepositories.stream().map(Repository::getName).collect(Collectors.toList()),
             options);
     return new BrowseResult<>(
         storageTx.countAssets(
             builder.buildWhereClause(), builder.buildSqlParams(), repositories, null),
         Lists.newArrayList(
             storageTx.findAssets(
                 builder.buildWhereClause(),
                 builder.buildSqlParams(),
                 previewRepositories,
                 builder.buildQuerySuffix())));
   }
 }
Example #11
0
 @Override
 @Guarded(by = STARTED)
 public boolean member(final Repository repository) {
   checkNotNull(repository);
   return config.memberNames.contains(repository.getName());
 }
Example #12
0
 public boolean contains(final Repository repository) {
   return dispatched.contains(repository.getName());
 }
Example #13
0
 public void add(final Repository repository) {
   dispatched.add(repository.getName());
 }