Service.qml

import QtQuick
import Quickshell
import Quickshell.Io

// GitLab dashboard data service. The helper owns API pagination and aggregation;
// this item schedules it and exposes one stable, defensive model to the panel.
Item {
    id: root

    property var settings: ({
    })
    property bool loading: false
    property string state: "loading"
    property string message: "Loading GitLab…"
    property string login: ""
    property string instanceHostname: configuredHostname()
    property string webBaseUrl: configuredWebBaseUrl()
    property string fetchedRepositoryScope: "owned"
    property string fetchedAt: ""
    property var notifications: []
    property int notificationsRevision: 0
    property var reviewRequests: []
    property var assignedIssues: []
    property var myPullRequests: []
    property int myPullRequestsTotal: 0
    property var actions: []
    property var failedActions: []
    property var repositories: []
    property var warnings: []
    property var rateLimit: null
    property string _stdout: ""
    property string _stderr: ""
    property bool refreshQueued: false
    property string markingNotificationId: ""
    property bool markingAllNotifications: false
    property string notificationActionStatus: ""
    property string _markStdout: ""
    property string _markStderr: ""
    // Single-thread and bulk marking share one process, so the panel gates every
    // entry point on this rather than on whichever flag a given call happens to
    // set. A caller added later inherits the guard instead of having to know.
    readonly property bool marking: markProcess.running
    readonly property int refreshIntervalSec: intSetting("refreshIntervalSec", 900, 60, 3600)
    readonly property int unreadCount: notifications.length
    readonly property int actionCount: actions.length
    // A broken check on your own pull request is the kind of thing the bar icon
    // exists to surface, so it counts toward the alarming state. Drafts are
    // excluded: a red check on work you have not offered up yet is expected,
    // and it would leave the icon permanently lit.
    readonly property int failingPullRequestCount: myPullRequests.filter(function(item) {
        return !item.draft && root.isBrokenCheck(item.checks);
    }).length
    readonly property bool iconAlwaysUnlit: boolSetting("iconAlwaysUnlit", false)
    // Unknown values keep the safer web-app default rather than silently
    // switching an existing setup back to a browser tab.
    readonly property string linkBehavior: String(setting("linkBehavior", "Web app window")).toLowerCase() === "browser tab" ? "Browser tab" : "Web app window"
    readonly property bool alarming: !iconAlwaysUnlit && (unreadCount > 0 || actionCount > 0 || reviewRequests.length > 0 || failingPullRequestCount > 0)

    // StatusCheckRollup groupings live here so the alarming count, the row label
    // and the row glyph cannot drift apart when a state is reclassified.
    function isBrokenCheck(checks) {
        var value = String(checks || "");
        return value === "FAILURE" || value === "ERROR";
    }

    function isRunningCheck(checks) {
        var value = String(checks || "");
        return value === "PENDING" || value === "EXPECTED";
    }

    function setting(name, fallback) {
        var value = settings ? settings[name] : undefined;
        return value === undefined || value === null ? fallback : value;
    }

    function configuredHostname() {
        var value = String(setting("hostname", "gitlab.com")).trim();
        value = value.replace(/^[a-z][a-z0-9+.-]*:\/\//i, "");
        value = value.replace(/\/+$/, "");
        var slash = value.indexOf("/");
        if (slash >= 0)
            value = value.substring(0, slash);
        return value || "gitlab.com";
    }

    function configuredWebBaseUrl() {
        var value = String(setting("hostname", "gitlab.com")).trim();
        var scheme = /^http:\/\//i.test(value) ? "http" : "https";
        return scheme + "://" + configuredHostname();
    }

    function intSetting(name, fallback, minimum, maximum) {
        var value = parseInt(String(setting(name, fallback)), 10);
        if (!isFinite(value))
            value = fallback;

        return Math.max(minimum, Math.min(maximum, value));
    }

    function boolSetting(name, fallback) {
        var value = setting(name, fallback);
        if (value === true || value === false)
            return value;

        var text = String(value).toLowerCase();
        return text === "true" || text === "yes" || text === "on" || text === "1";
    }

    // Matched against the known options rather than by substring, so an option
    // added later falls back to the narrower scope instead of silently widening
    // it. `fetchedRepositoryScope` reports what the last payload contained.
    function repositoryMode() {
        return String(setting("repositoryScope", "Owned")).toLowerCase() === "owned and groups" ? "membership" : "owned";
    }

    function actionMode() {
        var value = String(setting("actionScanBehavior", "Recent repositories")).toLowerCase();
        if (value === "off")
            return "off";

        if (value === "all repositories")
            return "all";

        return "recent";
    }

    function helperPath() {
        return Qt.resolvedUrl("omarchy-gitlab-fetch").toString().replace(/^file:\/\//, "");
    }

    function command() {
        return [helperPath(), "--hostname", String(setting("hostname", "gitlab.com")).trim(), "--include-archived", boolSetting("includeArchived", false) ? "true" : "false", "--include-forks", boolSetting("includeForks", false) ? "true" : "false", "--project-scope", repositoryMode(), "--include-archived-reviews", boolSetting("includeArchivedReviewRequests", false) ? "true" : "false", "--include-draft-reviews", boolSetting("includeDraftReviewRequests", false) ? "true" : "false", "--action-scan", actionMode(), "--action-repo-limit", String(intSetting("actionScanRepoLimit", 15, 5, 200)), "--concurrency", String(intSetting("actionScanConcurrency", 6, 1, 12)), "--failed-days", String(intSetting("failedActionDays", 7, 1, 30)), "--failed-limit", String(intSetting("failedActionLimit", 20, 1, 100))];
    }

    function refresh() {
        if (fetchProcess.running || markProcess.running) {
            refreshQueued = true;
            return ;
        }
        refreshQueued = false;
        loading = true;
        _stdout = "";
        _stderr = "";
        fetchProcess.command = command();
        fetchProcess.running = true;
    }

    function apply(raw) {
        try {
            var data = JSON.parse(String(raw || ""));
            state = String(data.state || "error");
            message = String(data.message || "");
            login = String(data.login || "");
            instanceHostname = String(data.hostname || configuredHostname());
            webBaseUrl = String(data.webBaseUrl || configuredWebBaseUrl());
            fetchedRepositoryScope = String(data.repositoryScope || "owned");
            fetchedAt = String(data.fetchedAt || "");
            notifications = Array.isArray(data.notifications) ? data.notifications : [];
            notificationsRevision++;
            reviewRequests = Array.isArray(data.reviewRequests) ? data.reviewRequests : [];
            assignedIssues = Array.isArray(data.assignedIssues) ? data.assignedIssues : [];
            myPullRequests = Array.isArray(data.myPullRequests) ? data.myPullRequests : [];
            myPullRequestsTotal = Number(data.myPullRequestsTotal) || myPullRequests.length;
            actions = Array.isArray(data.actions) ? data.actions : [];
            failedActions = Array.isArray(data.failedActions) ? data.failedActions : [];
            repositories = Array.isArray(data.repositories) ? data.repositories : [];
            warnings = Array.isArray(data.warnings) ? data.warnings : [];
            rateLimit = data.rateLimit || null;
        } catch (error) {
            state = "error";
            message = "GitLab returned an unreadable response.";
            warnings = [String(error)];
        }
    }

    function markNotificationRead(id) {
        var value = String(id || "");
        if (value === "" || loading || fetchProcess.running || markProcess.running)
            return ;

        actionStatusTimer.stop();
        markingNotificationId = value;
        notificationActionStatus = "Marking todo done…";
        _markStdout = "";
        _markStderr = "";
        markProcess.command = [helperPath(), "--mark-todo-done", value];
        markProcess.running = true;
    }

    // Capture the exact on-screen todo IDs on the first click. The panel passes
    // the rendered row count (5 collapsed / 25 expanded), so the snapshot is
    // bounded to what is actually shown. The panel binds confirmation to
    // notificationsRevision, so any refresh invalidates this prepared value
    // before the destructive second click can run.
    function prepareMarkAllNotificationsRead(limit) {
        if (notifications.length === 0 || loading || fetchProcess.running || markProcess.running)
            return "";

        var count = parseInt(String(limit), 10);
        if (!isFinite(count) || count <= 0)
            count = notifications.length;
        count = Math.min(count, notifications.length);

        var ids = [];
        for (var i = 0; i < count; i++) {
            var id = String(notifications[i].id || "");
            if (!/^\d+$/.test(id)) {
                notificationActionStatus = "Refresh before marking everything done.";
                actionStatusTimer.restart();
                return "";
            }
            ids.push(id);
        }
        return JSON.stringify({ids: ids, limit: count, revision: notificationsRevision});
    }

    function markAllNotificationsRead(prepared) {
        var confirmed = String(prepared || "");
        if (confirmed === "" || loading || fetchProcess.running || markProcess.running)
            return ;

        var snapshot;
        try {
            snapshot = JSON.parse(confirmed);
        } catch (error) {
            notificationActionStatus = "Refresh before marking everything done.";
            actionStatusTimer.restart();
            return ;
        }

        // Recompute immediately before starting, using the same display bound.
        // This protects non-panel callers as well as the panel's revision-bound
        // confirmation.
        if (confirmed !== prepareMarkAllNotificationsRead(snapshot.limit)) {
            notificationActionStatus = "Todos changed. Confirm again.";
            actionStatusTimer.restart();
            return ;
        }

        actionStatusTimer.stop();
        markingAllNotifications = true;
        notificationActionStatus = "Marking all todos done…";
        _markStdout = "";
        _markStderr = "";
        var commandLine = [helperPath(), "--mark-todos-done", String((snapshot.ids || []).join(","))];
        markProcess.command = commandLine;
        markProcess.running = true;
    }

    visible: false

    Timer {
        interval: root.refreshIntervalSec * 1000
        repeat: true
        running: true
        triggeredOnStart: true
        onTriggered: root.refresh()
    }

    Timer {
        id: actionStatusTimer

        interval: 3000
        repeat: false
        onTriggered: root.notificationActionStatus = ""
    }

    Process {
        id: fetchProcess

        running: false
        command: []
        onExited: function(exitCode) {
            root.loading = false;
            var stdout = String(output.text || root._stdout || "");
            var stderr = String(errors.text || root._stderr || "").trim();
            if (stdout.trim() !== "") {
                root.apply(stdout);
            } else {
                root.state = "error";
                root.message = stderr !== "" ? stderr : "GitLab data refresh failed.";
            }
            if (root.refreshQueued) {
                root.refreshQueued = false;
                Qt.callLater(root.refresh);
            }
        }

        stdout: StdioCollector {
            id: output

            waitForEnd: true
            onStreamFinished: root._stdout = text
        }

        stderr: StdioCollector {
            id: errors

            waitForEnd: true
            onStreamFinished: root._stderr = text
        }

    }

    Process {
        id: markProcess

        running: false
        command: []
        onExited: function(exitCode) {
            var response = null;
            try {
                response = JSON.parse(String(markOutput.text || root._markStdout || ""));
            } catch (error) {
            }
            var all = root.markingAllNotifications;
            if (exitCode === 0 && response && response.state === "ready") {
                root.notificationActionStatus = all ? "Todos marked done. Refreshing…" : "Todo marked done. Refreshing…";
            } else {
                var fallback = all ? "Could not mark all todos done." : "Could not mark todo done.";
                root.notificationActionStatus = response && response.message ? String(response.message) : String(markErrors.text || root._markStderr || fallback).trim();
            }
            root.markingNotificationId = "";
            root.markingAllNotifications = false;
            actionStatusTimer.restart();
            // GitLab is authoritative after every attempt. This reconciles
            // successful, failed, and partially completed bulk operations.
            root.refreshQueued = false;
            Qt.callLater(root.refresh);
        }

        stdout: StdioCollector {
            id: markOutput

            waitForEnd: true
            onStreamFinished: root._markStdout = text
        }

        stderr: StdioCollector {
            id: markErrors

            waitForEnd: true
            onStreamFinished: root._markStderr = text
        }

    }

}