public DefectCompacted merge()

in tcbot-engine/src/main/java/org/apache/ignite/tcbot/engine/defect/DefectsStorage.java [82:165]
65 lines of code
14 McCabe index (conditional complexity)

    public DefectCompacted merge(
        int tcSrvCodeCid,
        final int srvId,
        FatBuildCompacted fatBuild,
        BiFunction<Integer, DefectCompacted, DefectCompacted> function) {

        IgniteCache<Integer, DefectCompacted> cache = cache();

        try (QueryCursor<Cache.Entry<Integer, DefectCompacted>> qry = cache.query(new ScanQuery<Integer, DefectCompacted>()
            .setFilter((k, v) -> v.tcSrvId() == srvId))) {
            //here we ignore if issue was resolved or not because defect can be already resolved,
            // and if this(resolved) defect contains same build ID, as we've used earlier, no reason to open new defect for it.
            for (Cache.Entry<Integer, DefectCompacted> next : qry) {
                DefectCompacted openDefect = next.getValue();

                if (openDefect.hasBuild(fatBuild.id()))
                    return processExisting(function, cache, next.getKey(), openDefect);
            }
        }

        int[] changes = fatBuild.changes();
        Map<Integer, ChangeCompacted> changeList = changeDao.getAll(srvId, changes);

        List<CommitCompacted> commitsToUse = changeList
            .values()
            .stream()
            .map(ChangeCompacted::commitVersion)
            .map(CommitCompacted::new)
            .sorted(CommitCompacted::compareTo)
            .collect(toList());

        if (!commitsToUse.isEmpty()) {
            try (QueryCursor<Cache.Entry<Integer, DefectCompacted>> qry = cache.query(new ScanQuery<Integer, DefectCompacted>()
                .setFilter((k, v) -> v.resolvedByUsernameId() < 1 && v.tcSrvId() == srvId))) {
                for (Cache.Entry<Integer, DefectCompacted> next : qry) {
                    DefectCompacted openDefect = next.getValue();

                    if (openDefect.sameCommits(commitsToUse))
                        return processExisting(function, cache, next.getKey(), openDefect);
                }
            }
        }

        List<RevisionCompacted> buildRevisions = fatBuild.revisions();

        if (buildRevisions == null)
            buildRevisions = new ArrayList<>();

        List<CommitCompacted> revisionsToUse = buildRevisions.stream()
            .map(RevisionCompacted::revision)
            .map(CommitCompacted::new)
            .sorted(CommitCompacted::compareTo)
            .collect(toList());

        if (commitsToUse.isEmpty() && !buildRevisions.isEmpty()) {
            try (QueryCursor<Cache.Entry<Integer, DefectCompacted>> qry = cache.query(new ScanQuery<Integer, DefectCompacted>()
                .setFilter((k, v) -> v.resolvedByUsernameId() < 1 && v.tcSrvId() == srvId))) {
                for (Cache.Entry<Integer, DefectCompacted> next : qry) {
                    DefectCompacted openDefect = next.getValue();

                    if (openDefect.sameRevisions(revisionsToUse))
                        return processExisting(function, cache, next.getKey(), openDefect);
                }
            }
        }

        int id = (int)sequence().incrementAndGet();
        if (id == 0)
            id = (int)sequence().incrementAndGet();

        DefectCompacted defect = new DefectCompacted(id)
            .commits(commitsToUse)
            .revisions(revisionsToUse)
            .changeMap(changeList)
            .tcBranch(fatBuild.branchName())
            .tcSrvId(srvId)
            .tcSrvCodeCid(tcSrvCodeCid);

        DefectCompacted defectT = function.apply(id, defect);

        boolean putSuccess = cache.putIfAbsent(id, defectT);

        return defectT;
    }