public ItemFilter getFilter()

in rest-api/src/jetbrains/buildServer/server/rest/data/finder/impl/AgentFinder.java [169:278]
89 lines of code
21 McCabe index (conditional complexity)

  public ItemFilter<SBuildAgent> getFilter(@NotNull final Locator locator) {
    final MultiCheckerFilter<SBuildAgent> result = new MultiCheckerFilter<SBuildAgent>();

    Long id = locator.getSingleDimensionValueAsLong(DIMENSION_ID);
    if (id != null) {
      result.add(item -> id == item.getId());
    }

    String name = locator.getSingleDimensionValue(NAME);
    if (name != null) {
      result.add(item -> name.equals(item.getName()));
    }

    final Boolean authorizedDimension = locator.getSingleDimensionValueAsBoolean(AUTHORIZED);
    if (authorizedDimension != null) {
      result.add(item -> FilterUtil.isIncludedByBooleanFilter(authorizedDimension, item.isAuthorized()));
    }

    final Boolean enabledDimension = locator.getSingleDimensionValueAsBoolean(ENABLED);
    if (enabledDimension != null) {
      result.add(item -> FilterUtil.isIncludedByBooleanFilter(enabledDimension, item.isEnabled()));
    }

    final Boolean connectedDimension = locator.getSingleDimensionValueAsBoolean(CONNECTED);
    if (connectedDimension != null) {
      result.add(item -> FilterUtil.isIncludedByBooleanFilter(connectedDimension, item.isRegistered()));
    }

    final String poolDimension = locator.getSingleDimensionValue(POOL); //see also AgentPoolsFinder.getPoolAgents()
    if (poolDimension != null) {
      AgentPoolFinder agentPoolFinder = myServiceLocator.getSingletonService(AgentPoolFinder.class);
      final AgentPool agentPool = agentPoolFinder.getItem(poolDimension); //get id here to support not existing pools?
      result.add(item -> ((BuildAgentEx)item).getAgentType().getAgentPoolId() == agentPool.getAgentPoolId()); //TeamCity API issue: cast
    }

    if (locator.isUnused(BUILD)) {
      final String buildDimension = locator.getSingleDimensionValue(BUILD);
      if (buildDimension != null) {
        Set<SBuildAgent> agents = getBuildRelatedAgents(buildDimension);
        result.add(item -> agents.contains(item));
      }
    }

    if (locator.isUnused(AGENT_TYPE_ID)) {
      final String agentTypeLocator = locator.getSingleDimensionValue(AGENT_TYPE_ID);
      if (agentTypeLocator != null) {
        int agentTypeId = getAgentType(agentTypeLocator, myServiceLocator.getSingletonService(AgentTypeFinder.class)).getAgentTypeId();
        result.add(item -> agentTypeId == item.getAgentTypeId());
      }
    }

    final String ipDimension = locator.getSingleDimensionValue(IP);
    if (ipDimension != null) {
      result.add(item -> ipDimension.equals(Agent.getFieldValue(item, "ip", myServiceLocator))); //name of the field, not locator dimension
    }

    final String protocolDimension = locator.getSingleDimensionValue(PROTOCOL);
    if (protocolDimension != null) {
      result.add(item -> protocolDimension.equals(Agent.getFieldValue(item, "protocol", myServiceLocator))); //name of the field, not locator dimension
    }

    final String parameterDimension = locator.getSingleDimensionValue(PARAMETER);
    if (parameterDimension != null) {
      final ParameterCondition parameterCondition = ParameterCondition.create(parameterDimension);
      result.add(item -> parameterCondition.matches(new MapParametersProviderImpl(item.getAvailableParameters())));
    }

    if (locator.isUnused(CLOUD_INSTANCE)) {
      final String cloudInstanceLocator = locator.getSingleDimensionValue(CLOUD_INSTANCE);
      if (cloudInstanceLocator != null) {
        List<CloudInstance> instances = myServiceLocator.getSingletonService(CloudInstanceFinder.class)
                                                        .getItems(cloudInstanceLocator).getEntries().stream().map(CloudInstanceData::getInstance).collect(Collectors.toList());
        result.add(a -> instances.stream().anyMatch(i -> i.containsAgent(a)));
        /* CloudInstance might not have equals/hashcode, if it does, it would be better to use in a set like below
        Set<CloudInstance> instances = myServiceLocator.getSingletonService(CloudInstanceFinder.class).getItems(cloudInstanceLocator).myEntries.stream().map(i -> i.getInstance()).collect(
          Collectors.toSet());
        CloudManager cloudManager = myServiceLocator.getSingletonService(CloudManager.class);
        result.add(a -> Util.resolveNull(cloudManager.findInstanceByAgent(a), pair -> instances.contains(pair.getSecond()), false));
        */
      }
    }

    if (locator.isUnused(COMPATIBLE)) {
      final String compatible = locator.getSingleDimensionValue(COMPATIBLE); //compatible with at least with one of the buildTypes
      if (compatible != null) {
        final CompatibleLocatorParseResult compatibleData = getBuildTypesFromCompatibleDimension(compatible);
        if (compatibleData.buildTypes != null) {
          result.add(item -> isCompatibleWithAny(item, compatibleData.buildTypes));
        } else {
          assert compatibleData.buildPromotions != null;
          result.add(item -> isCompatibleWithAnyBuild(item, compatibleData.buildPromotions));
        }
      }
    }

    final String incompatible = locator.getSingleDimensionValue(INCOMPATIBLE); //incompatible with at least with one of the buildTypes
    if (incompatible != null) {
      final CompatibleLocatorParseResult compatibleData = getBuildTypesFromCompatibleDimension(incompatible);
       if (compatibleData.buildTypes != null) {
         result.add(item -> !isCompatibleWithAll(item, compatibleData.buildTypes));
       } else {
         result.add(item -> {
           assert compatibleData.buildPromotions != null;
           return !isCompatibleWithAllBuild(item, compatibleData.buildPromotions);
         });
       }
    }

    return result.toItemFilter();
  }