public ItemFilter getFilter()

in rest-api/src/jetbrains/buildServer/server/rest/data/finder/impl/VcsRootInstanceFinder.java [198:316]
94 lines of code
21 McCabe index (conditional complexity)

  public ItemFilter<VcsRootInstance> getFilter(@NotNull final Locator locator) {

    final MultiCheckerFilter<VcsRootInstance> result = new MultiCheckerFilter<>();

    result.add(item -> canViewSettingsFor(item.getParent()));

    final String type = locator.getSingleDimensionValue(TYPE);
    if (type != null) {
      result.add(item -> type.equals(item.getVcsName()));
    }

    if (locator.isUnused(BUILD)) {
      final String build = locator.getSingleDimensionValue(BUILD);
      if (build != null) {
        Set<Long> vcsRootInstanceIds = getVcsRootInstancesByBuilds(build).map(vcsRE -> vcsRE.getId()).collect(Collectors.toSet());
        result.add(item -> vcsRootInstanceIds.contains(item.getId()));
      }
    }

    if (locator.isUnused(VCS_ROOT_DIMENSION)) {
      final String vcsRootLocator = locator.getSingleDimensionValue(VCS_ROOT_DIMENSION);
      if (vcsRootLocator != null) {
        final List<SVcsRoot> vcsRoots = myVcsRootFinder.getItems(vcsRootLocator).getEntries();
        result.add(item -> vcsRoots.contains(item.getParent()));
      }
    }

    //todo: rework to be "there are usages directly in the project", also add to getPrefilteredItems
    //todo: support usage as versioned settings root
    final String projectLocator = locator.getSingleDimensionValue(PROJECT); //todo: support multiple here for "from all not archived projects" case
    if (projectLocator != null) {
      final SProject project = myProjectFinder.getItem(projectLocator);
      VcsRootInstance settingsInstance = myVersionedSettingsManager.getVersionedSettingsVcsRootInstance(project);
      final Boolean nonVersionedSettings = locator.lookupSingleDimensionValueAsBoolean(HAS_VERSIONED_SETTINGS_ONLY);
      result.add(item -> project.equals(VcsRoot.getProjectByRoot(item.getParent())) || //todo: rework project dimensions for the instance to mean smth. more meaningful
             (nonVersionedSettings == null || nonVersionedSettings) && item.equals(settingsInstance));
    }

    final String repositoryIdString = locator.getSingleDimensionValue(REPOSITORY_ID_STRING);
    if (repositoryIdString != null) {
      result.add(item -> VcsRootFinder.repositoryIdStringMatches(item, repositoryIdString, myVcsManager));
    }

    final List<String> properties = locator.getDimensionValue(PROPERTY);
    if (!properties.isEmpty()) {
      final Matcher<ParametersProvider> parameterCondition = ParameterCondition.create(properties);
      result.add(item -> parameterCondition.matches(new AbstractMapParametersProvider(item.getProperties())));
    }

    final String status = locator.getSingleDimensionValue(STATUS);
    if (status != null) {
      TypedFinderBuilder<VcsRootInstanceEx> builder = new TypedFinderBuilder<>();
      builder.dimensionEnum(StubDimension.single(), VcsRootStatus.Type.class).description("status of the VCS root instance").
             valueForDefaultFilter(root -> root.getStatus().getType());

      final TypedFinderBuilder<VcsRootCheckStatus> statusFilterBuilder = new TypedFinderBuilder<>();
      statusFilterBuilder.dimensionEnum(new StubDimension("status"), VcsRootStatus.Type.class).description("type of operation")
                         .valueForDefaultFilter(vcsRootCheckStatus -> vcsRootCheckStatus.myStatus.getType());
      statusFilterBuilder.dimensionTimeCondition(new StubDimension("timestamp"), myTimeCondition).description("time of the operation start")
                         .valueForDefaultFilter(vcsRootCheckStatus -> vcsRootCheckStatus.myStatus.getTimestamp());
      statusFilterBuilder.dimensionEnum(new StubDimension("requestorType"), OperationRequestor.class).description("requestor of the operation")
                         .valueForDefaultFilter(vcsRootCheckStatus -> vcsRootCheckStatus.myRequestor);
      Finder<VcsRootCheckStatus> vcsRootCheckStatusFinder = statusFilterBuilder.build();

      builder.dimensionFinderFilter(new StubDimension("current"), vcsRootCheckStatusFinder, "VCS check status condition")
             .description("current VCS root status").valueForDefaultFilter(root -> new VcsRootCheckStatus(root.getStatus(), root.getLastRequestor()));
      builder.dimensionFinderFilter(new StubDimension("previous"), vcsRootCheckStatusFinder, "VCS check status condition")
             .description("previous VCS root status").valueForDefaultFilter(root -> new VcsRootCheckStatus(root.getPreviousStatus(), null));

      final ItemFilter<VcsRootInstanceEx> filter = builder.build().getFilter(status);
      result.add(item -> filter.isIncluded((VcsRootInstanceEx)item));
    }

    final Boolean commitHookMode = locator.getSingleDimensionValueAsBoolean(COMMIT_HOOK_MODE);
    if (commitHookMode != null){
      result.add(item -> FilterUtil.isIncludedByBooleanFilter(commitHookMode, !item.isPollingMode()));
    }

    TimeCondition.FilterAndLimitingDate<VcsRootInstance> finishFiltering =
      myTimeCondition.processTimeConditions(FINISH_VCS_CHECKING_FOR_CHANGES, locator, (vcsRootInstance) -> getFinishCheckingForChanges(vcsRootInstance), null);
    if (finishFiltering != null) result.add(finishFiltering.getFilter());

    final String repositoryState = locator.getSingleDimensionValue(REPOSITORY_STATE);
    if (repositoryState != null) {
      TypedFinderBuilder<RepositoryState> builder = new TypedFinderBuilder<RepositoryState>();
      builder.dimensionTimeCondition(new StubDimension("timestamp"), myTimeCondition).description("time of the repository state creation").
             valueForDefaultFilter(item -> item.getCreateTimestamp());

      builder.dimensionValueCondition(new StubDimension("branchName")).description("branch name").filter((valueCondition, item) -> {
        for (String branchName : item.getBranchRevisions().keySet()) {
          if (valueCondition.matches(branchName)) return true;
        }
        return false;
      });

      final ItemFilter<RepositoryState> filter = builder.build().getFilter(repositoryState);
      result.add(item -> filter.isIncluded(((VcsRootInstanceEx)item).getLastUsedState()));

    }

    if (locator.isUnused(BUILD_TYPE)) {
      final String buildTypesLocator = locator.getSingleDimensionValue(BUILD_TYPE);
      if (buildTypesLocator != null) {
        Set<VcsRootInstance> vcsRootInstances = getInstances(buildTypesLocator, locator.lookupSingleDimensionValueAsBoolean(HAS_VERSIONED_SETTINGS_ONLY));
        result.add(item -> vcsRootInstances.contains(item));
      }
    }

    final String affectedProjectLocator = locator.getSingleDimensionValue(AFFECTED_PROJECT); //todo: support multiple here
    if (affectedProjectLocator != null) {
      final Set<VcsRootInstance> vcsRootInstances = getVcsRootInstancesUnderProject(myProjectFinder.getItem(affectedProjectLocator),
                                                                                    locator.getSingleDimensionValueAsBoolean(HAS_VERSIONED_SETTINGS_ONLY));
      result.add(item -> vcsRootInstances.contains(item));
    }

    // should check HAS_VERSIONED_SETTINGS_ONLY only in prefiltered items as it should consider the current scope - no way to filter in Filter

    return result.toItemFilter();
  }