@researchdatabox/redbox-core 0.0.0-bootstrap.0

package/dist/services/ContrastService.js

@@ -0,0 +1,218 @@
+"use strict";
+// Copyright (c) 2017 Queensland Cyber Infrastructure Foundation (http://www.qcif.edu.au/)
+//
+// GNU GENERAL PUBLIC LICENSE
+//    Version 2, June 1991
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Services = void 0;
+const CoreService_1 = require("../CoreService");
+/**
+ * ContrastService
+ *
+ * Validate color contrast ratios using WCAG AA standards
+ * and provide suggestions for compliant color combinations.
+ *
+ * Usage: await ContrastService.validate(variablesMap)
+ * Returns: { valid: boolean, violations: ContrastViolation[] }
+ *
+ * Usage: await ContrastService.suggestCompliant(colorA, colorB)
+ * Returns: { suggested: string, originalRatio: number, newRatio: number }
+ */
+var Services;
+(function (Services) {
+    class Contrast extends CoreService_1.Services.Core.Service {
+        _exportedMethods = [
+            'validate',
+            'suggestCompliant',
+            'calculateRatio',
+            'getLuminance'
+        ];
+        /**
+         * WCAG AA contrast requirements
+         * Normal text: 4.5:1, Large text: 3:1
+         */
+        WCAG_AA_NORMAL = 4.5;
+        WCAG_AA_LARGE = 3.0;
+        /**
+         * Convert hex color to RGB values
+         */
+        hexToRgb(hex) {
+            const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+            return result ? {
+                r: parseInt(result[1], 16),
+                g: parseInt(result[2], 16),
+                b: parseInt(result[3], 16)
+            } : null;
+        }
+        /**
+         * Calculate relative luminance of a color
+         * Formula: https://www.w3.org/TR/WCAG21/#dfn-relative-luminance
+         */
+        getLuminance(color) {
+            const rgb = this.hexToRgb(color);
+            if (!rgb)
+                return 0;
+            const { r, g, b } = rgb;
+            // Convert to linear RGB values
+            const toLinear = (c) => {
+                c = c / 255;
+                return c <= 0.03928 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+            };
+            const rLinear = toLinear(r);
+            const gLinear = toLinear(g);
+            const bLinear = toLinear(b);
+            // Calculate luminance
+            return 0.2126 * rLinear + 0.7152 * gLinear + 0.0722 * bLinear;
+        }
+        /**
+         * Calculate contrast ratio between two colors
+         * Formula: https://www.w3.org/TR/WCAG21/#dfn-contrast-ratio
+         */
+        calculateRatio(colorA, colorB) {
+            const lumA = this.getLuminance(colorA);
+            const lumB = this.getLuminance(colorB);
+            const lighter = Math.max(lumA, lumB);
+            const darker = Math.min(lumA, lumB);
+            return (lighter + 0.05) / (darker + 0.05);
+        }
+        /**
+         * Validate contrast ratios for defined color pairs
+         * Returns violations for pairs that don't meet WCAG AA standards
+         */
+        validate(variables) {
+            const violations = [];
+            // Define color pairs to validate based on branding requirements
+            const pairs = [
+                // Primary text on primary background
+                {
+                    name: 'primary-text-on-primary-bg',
+                    fg: variables['primary-text-color'] || '#ffffff',
+                    bg: variables['primary-color'] || '#007bff',
+                    textSize: 'normal'
+                },
+                // Secondary text on secondary background
+                {
+                    name: 'secondary-text-on-secondary-bg',
+                    fg: variables['secondary-text-color'] || '#ffffff',
+                    bg: variables['secondary-color'] || '#6c757d',
+                    textSize: 'normal'
+                },
+                // Accent text on accent background
+                {
+                    name: 'accent-text-on-accent-bg',
+                    fg: variables['accent-text-color'] || '#ffffff',
+                    bg: variables['accent-color'] || '#28a745',
+                    textSize: 'normal'
+                },
+                // Body text on surface background
+                {
+                    name: 'body-text-on-surface',
+                    fg: variables['body-text-color'] || '#212529',
+                    bg: variables['surface-color'] || '#ffffff',
+                    textSize: 'normal'
+                },
+                // Large text variations (can use lower contrast ratio)
+                {
+                    name: 'heading-text-on-surface',
+                    fg: variables['heading-text-color'] || '#212529',
+                    bg: variables['surface-color'] || '#ffffff',
+                    textSize: 'large'
+                }
+            ];
+            for (const pair of pairs) {
+                const ratio = this.calculateRatio(pair.fg, pair.bg);
+                const required = pair.textSize === 'large' ? this.WCAG_AA_LARGE : this.WCAG_AA_NORMAL;
+                if (ratio < required) {
+                    violations.push({
+                        pair: pair.name,
+                        ratio: Math.round(ratio * 100) / 100, // Round to 2 decimal places
+                        required,
+                        colors: [pair.fg, pair.bg],
+                        textSize: pair.textSize
+                    });
+                }
+            }
+            return {
+                valid: violations.length === 0,
+                violations
+            };
+        }
+        /**
+         * Suggest a compliant color by adjusting the foreground color
+         * to meet contrast requirements with the background
+         */
+        suggestCompliant(foreground, background, textSize = 'normal') {
+            // Normalise case
+            foreground = foreground.toLowerCase();
+            background = background.toLowerCase();
+            const hexRegex = /^#([0-9a-f]{6})$/i;
+            if (!hexRegex.test(foreground)) {
+                throw new Error('Invalid foreground color format');
+            }
+            if (!hexRegex.test(background)) {
+                throw new Error('Invalid background color format');
+            }
+            const required = textSize === 'large' ? this.WCAG_AA_LARGE : this.WCAG_AA_NORMAL;
+            const originalRatio = this.calculateRatio(foreground, background);
+            if (originalRatio >= required) {
+                return { suggested: foreground, originalRatio, newRatio: originalRatio, adjustments: 0 };
+            }
+            // Determine adjustment direction: if background is light, darken foreground; if dark, lighten foreground
+            const bgLum = this.getLuminance(background);
+            const fgLum = this.getLuminance(foreground);
+            let makeDarker = bgLum > fgLum; // if fg lighter than bg we need to darken; with light bg typical
+            const maxLightRatio = this.calculateRatio('#ffffff', background);
+            const maxDarkRatio = this.calculateRatio('#000000', background);
+            const chosenMax = makeDarker ? maxDarkRatio : maxLightRatio;
+            const alternateMax = makeDarker ? maxLightRatio : maxDarkRatio;
+            if (chosenMax < required && alternateMax > chosenMax) {
+                makeDarker = !makeDarker;
+            }
+            let currentRgb = this.hexToRgb(foreground);
+            let adjustments = 0;
+            let bestHex = foreground;
+            let bestRatio = originalRatio;
+            const step = 8; // adjust each channel by this many values per iteration
+            for (let i = 0; i < 60; i++) { // cap iterations
+                adjustments++;
+                currentRgb = {
+                    r: Math.max(0, Math.min(255, currentRgb.r + (makeDarker ? -step : step))),
+                    g: Math.max(0, Math.min(255, currentRgb.g + (makeDarker ? -step : step))),
+                    b: Math.max(0, Math.min(255, currentRgb.b + (makeDarker ? -step : step)))
+                };
+                const candidateHex = `#${currentRgb.r.toString(16).padStart(2, '0')}${currentRgb.g.toString(16).padStart(2, '0')}${currentRgb.b.toString(16).padStart(2, '0')}`;
+                const ratio = this.calculateRatio(candidateHex, background);
+                if (ratio > bestRatio) {
+                    bestRatio = ratio;
+                    bestHex = candidateHex;
+                }
+                if (ratio >= required) {
+                    return { suggested: candidateHex, originalRatio, newRatio: ratio, adjustments };
+                }
+                // Stop if we reached bounds (pure black or pure white)
+                if ((makeDarker && currentRgb.r === 0 && currentRgb.g === 0 && currentRgb.b === 0) ||
+                    (!makeDarker && currentRgb.r === 255 && currentRgb.g === 255 && currentRgb.b === 255)) {
+                    break;
+                }
+            }
+            // Could not reach required; return best effort
+            return { suggested: bestHex, originalRatio, newRatio: bestRatio, adjustments };
+        }
+    }
+    Services.Contrast = Contrast;
+})(Services || (exports.Services = Services = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ContrastService.js","sourceRoot":"","sources":["../../src/services/ContrastService.ts"],"names":[],"mappings":"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"}

package/dist/services/DashboardTypesService.d.ts

@@ -0,0 +1,98 @@
+import { Observable } from 'rxjs';
+import { Services as services } from '../CoreService';
+import { BrandingModel } from '../model/storage/BrandingModel';
+import { DashboardTypeModel } from '../model/storage/DashboardTypeModel';
+import { TemplateCompileInput } from "@researchdatabox/sails-ng-common";
+import type { DashboardTypeDefinition } from '../config/dashboardtype.config';
+export declare namespace Services {
+    /**
+     * Dashboard row configuration interface
+     */
+    export interface DashboardRowConfig {
+        title: string;
+        variable: string;
+        template: string;
+        initialSort?: 'asc' | 'desc';
+        defaultSort?: boolean;
+        secondarySort?: string;
+    }
+    /**
+     * Dashboard table configuration interface
+     */
+    export interface DashboardTableConfig {
+        rowConfig?: DashboardRowConfig[];
+        rowRulesConfig?: DashboardRuleSet[];
+        groupRowConfig?: DashboardRowConfig[];
+        groupRowRulesConfig?: DashboardRuleSet[];
+        formatRules?: Record<string, unknown>;
+    }
+    /**
+     * Top-level dashboard configuration interface for a record type
+     * This is configured at the recordtype level (not workflow-specific)
+     */
+    export interface RecordTypeDashboardConfig {
+        /** Whether to show the admin sidebar on the dashboard page */
+        showAdminSideBar?: boolean;
+    }
+    export interface DashboardRule {
+        renderItemTemplate?: string;
+        evaluateRulesTemplate?: string;
+        [key: string]: unknown;
+    }
+    export interface DashboardRuleSet {
+        ruleSetName: string;
+        rules?: DashboardRule[];
+        [key: string]: unknown;
+    }
+    type DashboardTypeConfig = DashboardTypeDefinition & {
+        searchFilters?: unknown;
+        searchable?: boolean;
+    };
+    /**
+     * Dashboard Types related functions...
+     */
+    export class DashboardTypes extends services.Core.Service {
+        protected _exportedMethods: string[];
+        protected dashboardTypes: DashboardTypeModel[];
+        bootstrap(defBrand: BrandingModel): Promise<DashboardTypeModel[]>;
+        create(brand: BrandingModel, name: string, config: DashboardTypeConfig): Observable<DashboardTypeModel>;
+        get(brand: BrandingModel, name: string): Observable<DashboardTypeModel | null>;
+        getAll(brand: BrandingModel): Observable<DashboardTypeModel[]>;
+        private defaultRowConfig;
+        /**
+         * Get the dashboard table configuration for a specific record type and workflow stage.
+         * Resolves configuration from workflow config, merging with any branding-specific overrides.
+         *
+         * @param brand The branding model
+         * @param recordType The record type name
+         * @param workflowStage The workflow stage name
+         * @returns The dashboard table configuration
+         */
+        getDashboardTableConfig(brand: BrandingModel, recordType: string, workflowStage: string): Promise<DashboardTableConfig | null>;
+        /**
+         * Get the top-level dashboard configuration for a specific record type.
+         * This configuration is stored at the recordtype level, not the workflow step level.
+         *
+         * @param brand The branding model
+         * @param recordType The record type name
+         * @returns The record type dashboard configuration, or null if not found
+         */
+        getRecordTypeDashboardConfig(brand: BrandingModel, recordType: string): Promise<RecordTypeDashboardConfig | null>;
+        /**
+         * Extract templates from dashboard configuration and prepare them for pre-compilation.
+         * Converts dashboard row templates to TemplateCompileInput format for Handlebars pre-compilation.
+         *
+         * @param brand The branding model
+         * @param recordType The record type name
+         * @param workflowStage The workflow stage name
+         * @param dashboardType The dashboard type name (default: standard)
+         * @returns Array of templates ready for compilation
+         */
+        extractDashboardTemplates(brand: BrandingModel, recordType: string, workflowStage: string, dashboardType?: string): Promise<TemplateCompileInput[]>;
+    }
+    export {};
+}
+declare global {
+    let DashboardTypesService: Services.DashboardTypes;
+}
+//# sourceMappingURL=DashboardTypesService.d.ts.map

package/dist/services/DashboardTypesService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DashboardTypesService.d.ts","sourceRoot":"","sources":["../../src/services/DashboardTypesService.ts"],"names":[],"mappings":"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"}

package/dist/services/DashboardTypesService.js

@@ -0,0 +1,291 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Services = void 0;
+const rxjs_1 = require("rxjs");
+const CoreService_1 = require("../CoreService");
+var Services;
+(function (Services) {
+    /**
+     * Dashboard Types related functions...
+     */
+    class DashboardTypes extends CoreService_1.Services.Core.Service {
+        _exportedMethods = [
+            'bootstrap',
+            'create',
+            'get',
+            'getAll',
+            'getDashboardTableConfig',
+            'getRecordTypeDashboardConfig',
+            'extractDashboardTemplates'
+        ];
+        dashboardTypes = [];
+        async bootstrap(defBrand) {
+            let dashboardTypes = await DashboardType.find({ branding: defBrand.id });
+            if (sails.config.appmode.bootstrapAlways) {
+                await DashboardType.destroy({ branding: defBrand.id });
+                dashboardTypes = [];
+            }
+            // if (_.isUndefined(dashboardTypes)) {
+            //   dashboardTypes = [];
+            // }
+            sails.log.verbose(`DashboardTypes found: ${dashboardTypes} and boostrapAlways set to: ${sails.config.appmode.bootstrapAlways}`);
+            if (_.isEmpty(dashboardTypes)) {
+                const dashTypes = [];
+                sails.log.verbose("Bootstrapping DashboardTypes definitions... ");
+                for (const dashboardType in sails.config.dashboardtype) {
+                    const config = sails.config.dashboardtype[dashboardType];
+                    const createdDashboardType = await (0, rxjs_1.firstValueFrom)(this.create(defBrand, dashboardType, config));
+                    dashTypes.push(createdDashboardType);
+                }
+                ;
+                this.dashboardTypes = dashTypes;
+                return dashTypes;
+            }
+            sails.log.verbose("Default DashboardTypes definition(s) exist.");
+            sails.log.verbose(JSON.stringify(dashboardTypes));
+            this.dashboardTypes = dashboardTypes;
+            return dashboardTypes;
+        }
+        create(brand, name, config) {
+            sails.log.verbose(JSON.stringify(config));
+            return super.getObservable(DashboardType.create({
+                name: name,
+                branding: brand.id,
+                searchFilters: config.searchFilters,
+                formatRules: config.formatRules,
+                searchable: config.searchable
+            }));
+        }
+        get(brand, name) {
+            const criteria = { where: { branding: brand.id, name: name } };
+            return super.getObservable(DashboardType.findOne(criteria));
+        }
+        getAll(brand) {
+            const criteria = { where: { branding: brand.id } };
+            return super.getObservable(DashboardType.find(criteria));
+        }
+        defaultRowConfig = [
+            {
+                title: 'Record Title',
+                variable: 'metadata.title',
+                template: `<a href='{{rootContext}}/{{branding}}/{{portal}}/record/view/{{oid}}'>{{metadata.title}}</a>
+            <span class="dashboard-controls">
+              {{#if hasEditAccess}}
+                <a href='{{rootContext}}/{{branding}}/{{portal}}/record/edit/{{oid}}' aria-label='{{t "edit-link-label"}}'><i class="fa fa-pencil" aria-hidden="true"></i></a>
+              {{/if}}
+            </span>
+          `,
+                initialSort: 'desc'
+            },
+            {
+                title: 'header-ci',
+                variable: 'metadata.contributor_ci.text_full_name',
+                template: '{{#if metadata.contributor_ci}}{{metadata.contributor_ci.text_full_name}}{{/if}}',
+                initialSort: 'desc'
+            },
+            {
+                title: 'header-data-manager',
+                variable: 'metadata.contributor_data_manager.text_full_name',
+                template: '{{#if metadata.contributor_data_manager}}{{metadata.contributor_data_manager.text_full_name}}{{/if}}',
+                initialSort: 'desc'
+            },
+            {
+                title: 'header-created',
+                variable: 'metaMetadata.createdOn',
+                template: '{{formatDateLocale dateCreated "DATETIME_MED"}}',
+                initialSort: 'desc'
+            },
+            {
+                title: 'header-modified',
+                variable: 'metaMetadata.lastSaveDate',
+                template: '{{formatDateLocale dateModified "DATETIME_MED"}}',
+                initialSort: 'desc',
+                defaultSort: true
+            }
+        ];
+        /**
+         * Get the dashboard table configuration for a specific record type and workflow stage.
+         * Resolves configuration from workflow config, merging with any branding-specific overrides.
+         *
+         * @param brand The branding model
+         * @param recordType The record type name
+         * @param workflowStage The workflow stage name
+         * @returns The dashboard table configuration
+         */
+        async getDashboardTableConfig(brand, recordType, workflowStage) {
+            try {
+                // Get record type
+                const recType = await (0, rxjs_1.firstValueFrom)(RecordTypesService.get(brand, recordType));
+                if (!recType) {
+                    sails.log.warn(`Record type not found: ${recordType}`);
+                    return null;
+                }
+                sails.log.verbose(`DashboardTypesService: Found record type ${recordType}`);
+                // Get workflow step config
+                const workflowStep = await (0, rxjs_1.firstValueFrom)(WorkflowStepsService.get(recType, workflowStage));
+                if (!workflowStep) {
+                    sails.log.warn(`Workflow step not found: ${workflowStage} for record type: ${recordType}`);
+                    return null;
+                }
+                sails.log.verbose(`DashboardTypesService: Found workflow step ${workflowStage}`);
+                // Extract dashboard table config from workflow step
+                const dashboardConfig = _.get(workflowStep, 'config.dashboard.table', {});
+                sails.log.verbose(`DashboardTypesService: loaded config for ${recordType}/${workflowStage}, keys: ${Object.keys(dashboardConfig)}`);
+                // TODO: In future, merge with user-configurable overrides from AppConfigService
+                // const userOverrides = await AppConfigService.getAppConfigByBrandAndKey(brand.id, `dashboardTable_${recordType}_${workflowStage}`);
+                // return _.merge({}, dashboardConfig, userOverrides);
+                return dashboardConfig;
+            }
+            catch (error) {
+                sails.log.error(`Error getting dashboard table config for ${recordType}/${workflowStage}:`, error);
+                return null;
+            }
+        }
+        /**
+         * Get the top-level dashboard configuration for a specific record type.
+         * This configuration is stored at the recordtype level, not the workflow step level.
+         *
+         * @param brand The branding model
+         * @param recordType The record type name
+         * @returns The record type dashboard configuration, or null if not found
+         */
+        async getRecordTypeDashboardConfig(brand, recordType) {
+            try {
+                // Get record type - need full config, so not limiting fields
+                const recType = await (0, rxjs_1.firstValueFrom)(RecordTypesService.get(brand, recordType));
+                if (!recType) {
+                    sails.log.warn(`Record type not found: ${recordType}`);
+                    return null;
+                }
+                // Extract top-level dashboard config from record type
+                // This is different from the workflow-specific table config
+                const dashboardConfig = _.get(recType, 'dashboard', {});
+                sails.log.verbose(`DashboardTypesService: loaded record type dashboard config for ${recordType}: ${JSON.stringify(dashboardConfig)}`);
+                return dashboardConfig;
+            }
+            catch (error) {
+                sails.log.error(`Error getting record type dashboard config for ${recordType}:`, error);
+                return null;
+            }
+        }
+        /**
+         * Extract templates from dashboard configuration and prepare them for pre-compilation.
+         * Converts dashboard row templates to TemplateCompileInput format for Handlebars pre-compilation.
+         *
+         * @param brand The branding model
+         * @param recordType The record type name
+         * @param workflowStage The workflow stage name
+         * @param dashboardType The dashboard type name (default: standard)
+         * @returns Array of templates ready for compilation
+         */
+        async extractDashboardTemplates(brand, recordType, workflowStage, dashboardType = 'standard') {
+            const entries = [];
+            const dashboardConfig = await this.getDashboardTableConfig(brand, recordType, workflowStage);
+            // Extract templates from rowConfig
+            if (dashboardConfig) {
+                const rowConfig = (!_.isEmpty(dashboardConfig.rowConfig)) ? dashboardConfig.rowConfig : this.defaultRowConfig;
+                sails.log.verbose(`DashboardTypesService: extracting ${rowConfig.length} row templates. Using default? ${_.isEmpty(dashboardConfig.rowConfig)}`);
+                for (let i = 0; i < rowConfig.length; i++) {
+                    const row = rowConfig[i];
+                    if (row.template) {
+                        entries.push({
+                            key: [recordType, workflowStage, 'rowConfig', i.toString(), row.variable],
+                            kind: 'handlebars',
+                            value: row.template
+                        });
+                    }
+                }
+                // Extract templates from groupRowConfig  
+                const groupRowConfig = dashboardConfig.groupRowConfig || [];
+                for (let i = 0; i < groupRowConfig.length; i++) {
+                    const row = groupRowConfig[i];
+                    if (row.template) {
+                        entries.push({
+                            key: [recordType, workflowStage, 'groupRowConfig', i.toString(), row.variable],
+                            kind: 'handlebars',
+                            value: row.template
+                        });
+                    }
+                }
+                // Extract templates from rowRulesConfig
+                const rowRulesConfig = dashboardConfig.rowRulesConfig || [];
+                for (let ruleSetIdx = 0; ruleSetIdx < rowRulesConfig.length; ruleSetIdx++) {
+                    const ruleSet = rowRulesConfig[ruleSetIdx];
+                    const rules = ruleSet.rules || [];
+                    for (let ruleIdx = 0; ruleIdx < rules.length; ruleIdx++) {
+                        const rule = rules[ruleIdx];
+                        if (rule.renderItemTemplate) {
+                            entries.push({
+                                key: [recordType, workflowStage, 'rowRules', ruleSet.ruleSetName, ruleIdx.toString(), 'render'],
+                                kind: 'handlebars',
+                                value: rule.renderItemTemplate
+                            });
+                        }
+                        if (rule.evaluateRulesTemplate) {
+                            entries.push({
+                                key: [recordType, workflowStage, 'rowRules', ruleSet.ruleSetName, ruleIdx.toString(), 'evaluate'],
+                                kind: 'handlebars',
+                                value: rule.evaluateRulesTemplate
+                            });
+                        }
+                    }
+                }
+                // Extract templates from groupRowRulesConfig
+                const groupRowRulesConfig = dashboardConfig.groupRowRulesConfig || [];
+                for (let ruleSetIdx = 0; ruleSetIdx < groupRowRulesConfig.length; ruleSetIdx++) {
+                    const ruleSet = groupRowRulesConfig[ruleSetIdx];
+                    const rules = ruleSet.rules || [];
+                    for (let ruleIdx = 0; ruleIdx < rules.length; ruleIdx++) {
+                        const rule = rules[ruleIdx];
+                        if (rule.renderItemTemplate) {
+                            entries.push({
+                                key: [recordType, workflowStage, 'groupRowRules', ruleSet.ruleSetName, ruleIdx.toString(), 'render'],
+                                kind: 'handlebars',
+                                value: rule.renderItemTemplate
+                            });
+                        }
+                        if (rule.evaluateRulesTemplate) {
+                            entries.push({
+                                key: [recordType, workflowStage, 'groupRowRules', ruleSet.ruleSetName, ruleIdx.toString(), 'evaluate'],
+                                kind: 'handlebars',
+                                value: rule.evaluateRulesTemplate
+                            });
+                        }
+                    }
+                }
+            }
+            // Extract templates from queryFilters (DashboardType config)
+            try {
+                const dashboardTypeModel = await (0, rxjs_1.firstValueFrom)(this.get(brand, dashboardType));
+                if (dashboardTypeModel) {
+                    const formatRules = dashboardTypeModel.formatRules;
+                    const queryFilters = _.get(formatRules, `queryFilters.${recordType}`);
+                    if (_.isArray(queryFilters)) {
+                        for (let i = 0; i < queryFilters.length; i++) {
+                            const queryFilter = queryFilters[i];
+                            if (_.isArray(queryFilter.filterFields)) {
+                                for (let j = 0; j < queryFilter.filterFields.length; j++) {
+                                    const filterField = queryFilter.filterFields[j];
+                                    if (filterField.template) {
+                                        entries.push({
+                                            key: [recordType, dashboardType, 'filters', i.toString(), 'fields', j.toString(), 'template'],
+                                            kind: 'handlebars',
+                                            value: filterField.template
+                                        });
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            catch (e) {
+                sails.log.warn(`Could not load dashboard type ${dashboardType} for template extraction`, e);
+            }
+            sails.log.verbose(`Extracted ${entries.length} dashboard templates for ${recordType}/${workflowStage}`);
+            return entries;
+        }
+    }
+    Services.DashboardTypes = DashboardTypes;
+})(Services || (exports.Services = Services = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"DashboardTypesService.js","sourceRoot":"","sources":["../../src/services/DashboardTypesService.ts"],"names":[],"mappings":"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"}