public void initFromContext()

in tcbot-engine/src/main/java/org/apache/ignite/tcbot/engine/ui/DsChainUi.java [169:293]
102 lines of code
12 McCabe index (conditional complexity)

    public void initFromContext(ITeamcityIgnited tcIgnited,
        FullChainRunCtx ctx,
        @Nullable String baseBranchTc,
        IStringCompactor compactor,
        boolean calcTrustedTests,
        @Nullable String tagSelected,
        @Nullable DisplayMode displayMode,
        int maxDurationSec,
        @Nullable Map<Integer, Integer> requireParamVal,
        boolean showMuted,
        boolean showIgnored) {
        failedTests = 0;
        failedToFinish = 0;
        totalTests = 0;
        trustedTests = 0;

        String failRateNormalizedBranch = normalizeBranch(baseBranchTc);
        Integer baseBranchId = compactor.getStringIdIfPresent(failRateNormalizedBranch);

        DisplayMode dModeToUse
            = displayMode == null ? DisplayMode.OnlyFailures : displayMode;

        Predicate<MultBuildRunCtx> suiteFilter = suite -> {
            if (Strings.isNullOrEmpty(tagSelected))
                return true;

            return suite.tags().contains(tagSelected);
        };

        ctx.suites()
            .filter(suite -> !suite.isComposite())
            .filter(suiteFilter)
            .peek(suite -> {
                int totalTests = suite.totalTests();
                this.totalTests += totalTests;

                if (calcTrustedTests)
                    trustedTests += suite.trustedTests(tcIgnited, baseBranchId);
            })
            .forEach(suite -> {
                if (dModeToUse == DisplayMode.None)
                    return; //don't convert any suite for UI

                if (suite.isFailed()
                    || dModeToUse == DisplayMode.ShowAllSuites
                    || suite.hasTestToReport(tcIgnited, baseBranchId, showMuted, showIgnored)
                    || suite.hasLongRunningTest(maxDurationSec)) {
                    DsSuiteUi suiteCurStatus = new DsSuiteUi()
                        .initFromContext(tcIgnited,
                            suite,
                            baseBranchTc,
                            compactor,
                            calcTrustedTests,
                            maxDurationSec,
                            requireParamVal,
                            showMuted,
                            showIgnored);

                    failedTests += suiteCurStatus.failedTests != null ? suiteCurStatus.failedTests : 0;

                    if (suite.hasAnyBuildProblemExceptTestOrSnapshot() || suite.onlyCancelledBuilds())
                        failedToFinish++;

                    suites.add(suiteCurStatus);
                }
            });

        totalBlockers = suites.stream().mapToInt(DsSuiteUi::totalBlockers).sum();
        durationPrintable = ctx.getDurationPrintable(suiteFilter);
        testsDurationPrintable = ctx.getTestsDurationPrintable(suiteFilter);
        durationNetTimePrintable = ctx.durationNetTimePrintable(suiteFilter);
        sourceUpdateDurationPrintable = ctx.sourceUpdateDurationPrintable(suiteFilter);
        artifcactPublishingDurationPrintable = ctx.artifcactPublishingDurationPrintable(suiteFilter);
        dependeciesResolvingDurationPrintable = ctx.dependeciesResolvingDurationPrintable(suiteFilter);
        lostInTimeouts = ctx.getLostInTimeoutsPrintable(suiteFilter);

        String suiteId = ctx.suiteId();
        this.suiteId  = suiteId;
        chainName = ctx.suiteName();
        webToHist = DsSuiteUi.buildWebLinkToHist(tcIgnited, suiteId, ctx.branchName());
        webToBuild = buildWebLinkToBuild(tcIgnited, ctx);

        Stream<T2<MultBuildRunCtx, TestCompactedMult>> allLongRunning = ctx.suites()
            .filter(suite -> !suite.isComposite())
            .filter(suiteFilter)
            .flatMap(
            suite -> suite.getTopLongRunning().map(t -> new T2<>(suite, t))
        );
        Comparator<T2<MultBuildRunCtx, TestCompactedMult>> durationComp
            = Comparator.comparing((pair) -> pair.get2().getAvgDurationMs());

        CollectionUtil.top(allLongRunning, 3, durationComp).forEach(
            pairCtxAndOccur -> {
                MultBuildRunCtx suite = pairCtxAndOccur.get1();
                TestCompactedMult longRunningOccur = pairCtxAndOccur.get2();

                DsTestFailureUi failure = createOrrucForLongRun(tcIgnited, compactor, suite, longRunningOccur, baseBranchTc, requireParamVal);

                failure.testName = "[" + suite.suiteName() + "] " + failure.testName; //may be separate field

                topLongRunning.add(failure);
            }
        );

        Stream<T2<MultBuildRunCtx, Map.Entry<String, Long>>> allLogConsumers = ctx.suites()
            .filter(suite -> !suite.isComposite())
            .filter(suiteFilter)
            .flatMap(suite -> suite.getTopLogConsumers().map(t -> new T2<>(suite, t)));

        Comparator<T2<MultBuildRunCtx, Map.Entry<String, Long>>> longConsumingComp
            = Comparator.comparing((pair) -> pair.get2().getValue());

        CollectionUtil.top(allLogConsumers, 3, longConsumingComp).forEach(
            pairCtxAndOccur -> {
                MultBuildRunCtx suite = pairCtxAndOccur.get1();
                Map.Entry<String, Long> testLogConsuming = pairCtxAndOccur.get2();

                DsTestFailureUi failure = createOccurForLogConsumer(testLogConsuming);

                failure.name = "[" + suite.suiteName() + "] " + failure.name; //todo suite as be separate field

                logConsumers.add(failure);
            }
        );
    }