public Page findJobs()

in genie-web/src/main/java/com/netflix/genie/web/data/services/impl/jpa/JpaPersistenceServiceImpl.java [1352:1491]
126 lines of code
8 McCabe index (conditional complexity)

    public Page<JobSearchResult> findJobs(
        @Nullable final String id,
        @Nullable final String name,
        @Nullable final String user,
        @Nullable final Set<com.netflix.genie.common.dto.JobStatus> statuses,
        @Nullable final Set<String> tags,
        @Nullable final String clusterName,
        @Nullable final String clusterId,
        @Nullable final String commandName,
        @Nullable final String commandId,
        @Nullable final Instant minStarted,
        @Nullable final Instant maxStarted,
        @Nullable final Instant minFinished,
        @Nullable final Instant maxFinished,
        @Nullable final String grouping,
        @Nullable final String groupingInstance,
        @NotNull final Pageable page
    ) {
        log.debug("[findJobs] Called");

        ClusterEntity clusterEntity = null;
        if (clusterId != null) {
            final Optional<ClusterEntity> optionalClusterEntity
                = this.getEntityOrNullForFindJobs(this.clusterRepository, clusterId, clusterName);
            if (optionalClusterEntity.isPresent()) {
                clusterEntity = optionalClusterEntity.get();
            } else {
                // Won't find anything matching the query
                return new PageImpl<>(Lists.newArrayList(), page, 0);
            }
        }
        CommandEntity commandEntity = null;
        if (commandId != null) {
            final Optional<CommandEntity> optionalCommandEntity
                = this.getEntityOrNullForFindJobs(this.commandRepository, commandId, commandName);
            if (optionalCommandEntity.isPresent()) {
                commandEntity = optionalCommandEntity.get();
            } else {
                // Won't find anything matching the query
                return new PageImpl<>(Lists.newArrayList(), page, 0);
            }
        }

        final Set<String> statusStrings = statuses != null
            ? statuses.stream().map(Enum::name).collect(Collectors.toSet())
            : null;

        final CriteriaBuilder cb = this.entityManager.getCriteriaBuilder();
        final CriteriaQuery<Long> countQuery = cb.createQuery(Long.class);
        final Root<JobEntity> root = countQuery.from(JobEntity.class);

        countQuery
            .select(cb.count(root))
            .where(
                JobPredicates
                    .getFindPredicate(
                        root,
                        cb,
                        id,
                        name,
                        user,
                        statusStrings,
                        tags,
                        clusterName,
                        clusterEntity,
                        commandName,
                        commandEntity,
                        minStarted,
                        maxStarted,
                        minFinished,
                        maxFinished,
                        grouping,
                        groupingInstance
                    )
            );

        final long totalCount = this.entityManager.createQuery(countQuery).getSingleResult();
        if (totalCount == 0) {
            // short circuit for no results
            return new PageImpl<>(new ArrayList<>(0));
        }

        final CriteriaQuery<JobSearchResult> contentQuery = cb.createQuery(JobSearchResult.class);
        final Root<JobEntity> contentQueryRoot = contentQuery.from(JobEntity.class);

        contentQuery.multiselect(
            contentQueryRoot.get(JobEntity_.uniqueId),
            contentQueryRoot.get(JobEntity_.name),
            contentQueryRoot.get(JobEntity_.user),
            contentQueryRoot.get(JobEntity_.status),
            contentQueryRoot.get(JobEntity_.started),
            contentQueryRoot.get(JobEntity_.finished),
            contentQueryRoot.get(JobEntity_.clusterName),
            contentQueryRoot.get(JobEntity_.commandName)
        );

        contentQuery.where(
            JobPredicates
                .getFindPredicate(
                    contentQueryRoot,
                    cb,
                    id,
                    name,
                    user,
                    statusStrings,
                    tags,
                    clusterName,
                    clusterEntity,
                    commandName,
                    commandEntity,
                    minStarted,
                    maxStarted,
                    minFinished,
                    maxFinished,
                    grouping,
                    groupingInstance
                )
        );

        final Sort sort = page.getSort();
        final List<Order> orders = new ArrayList<>();
        sort.iterator().forEachRemaining(
            order -> {
                if (order.isAscending()) {
                    orders.add(cb.asc(root.get(order.getProperty())));
                } else {
                    orders.add(cb.desc(root.get(order.getProperty())));
                }
            }
        );
        contentQuery.orderBy(orders);

        final List<JobSearchResult> results = this.entityManager
            .createQuery(contentQuery)
            .setFirstResult(((Long) page.getOffset()).intValue())
            .setMaxResults(page.getPageSize())
            .getResultList();

        return new PageImpl<>(results, page, totalCount);
    }