@researchdatabox/redbox-core 0.0.0-bootstrap.0 → 0.0.1-beta.10213

package/dist/services/DashboardTypesService.js

@@ -5,56 +5,203 @@ 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',
+            'createDashboardType',
             'get',
             'getAll',
+            'getAllDashboardTypeDefinitions',
+            'getDashboardTypeDefinition',
+            'updateDashboardType',
+            'deleteDashboardType',
             'getDashboardTableConfig',
             'getRecordTypeDashboardConfig',
-            'extractDashboardTemplates'
+            'extractDashboardTemplates',
+            'getDashboardView',
+            'getDashboardViewStep',
+            'extractDashboardViewTemplates'
         ];
         dashboardTypes = [];
+        defaultTableConfig() {
+            return {
+                rowConfig: [
+                    {
+                        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
+                    }
+                ]
+            };
+        }
+        normalizeTableConfig(config) {
+            return _.isEmpty(config) ? this.defaultTableConfig() : _.cloneDeep(config);
+        }
+        isConfiguredSystemDashboardType(name) {
+            return name != null && Object.prototype.hasOwnProperty.call(sails.config.dashboardtype ?? {}, name);
+        }
+        normalizeDashboardTypeRecord(type) {
+            if (!type) {
+                return null;
+            }
+            return {
+                ...type,
+                description: type.description,
+                formatRules: _.cloneDeep(type.formatRules ?? {}),
+                tableConfig: this.normalizeTableConfig(type.tableConfig),
+                searchable: type.searchable ?? true,
+                system: type.system ?? this.isConfiguredSystemDashboardType(type.name)
+            };
+        }
+        normalizeDashboardTypeInput(input) {
+            return {
+                ...input,
+                formatRules: _.cloneDeep(input.formatRules ?? {}),
+                tableConfig: this.normalizeTableConfig(input.tableConfig),
+                searchable: input.searchable ?? true,
+                system: input.system ?? false
+            };
+        }
+        async findDashboardTypeRecord(brand, name) {
+            const record = await (0, rxjs_1.firstValueFrom)(this.get(brand, name));
+            return this.normalizeDashboardTypeRecord(record);
+        }
+        addAssignedDashboardTypesFromConfig(value, assigned) {
+            if (_.isArray(value)) {
+                for (const item of value) {
+                    this.addAssignedDashboardTypesFromConfig(item, assigned);
+                }
+                return;
+            }
+            if (_.isObject(value)) {
+                const record = value;
+                if (typeof record.dashboardType === 'string' && record.dashboardType.trim()) {
+                    assigned.add(record.dashboardType);
+                }
+                for (const child of Object.values(record)) {
+                    this.addAssignedDashboardTypesFromConfig(child, assigned);
+                }
+            }
+        }
+        async listAssignedDashboardTypeNames(brand) {
+            const overrides = await AppConfigService.getAppConfigByBrandAndKey(String(brand.id), 'dashboardTableConfig');
+            const assigned = new Set();
+            for (const recordType of Object.values(overrides.recordTypes ?? {})) {
+                if (recordType.default?.dashboardType) {
+                    assigned.add(recordType.default.dashboardType);
+                }
+                for (const step of Object.values(recordType.steps ?? {})) {
+                    if (step.dashboardType) {
+                        assigned.add(step.dashboardType);
+                    }
+                }
+            }
+            for (const view of Object.values(overrides.views ?? {})) {
+                if (view.default?.dashboardType) {
+                    assigned.add(view.default.dashboardType);
+                }
+                for (const step of Object.values(view.steps ?? {})) {
+                    if (step.dashboardType) {
+                        assigned.add(step.dashboardType);
+                    }
+                }
+            }
+            if (sails.config.dashboardview) {
+                for (const viewDef of Object.values(sails.config.dashboardview)) {
+                    if (viewDef.dashboardType) {
+                        assigned.add(viewDef.dashboardType);
+                    }
+                }
+            }
+            this.addAssignedDashboardTypesFromConfig(sails.config.recordtype, assigned);
+            this.addAssignedDashboardTypesFromConfig(sails.config.workflow, assigned);
+            return assigned;
+        }
         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}`);
+            sails.log.verbose(`DashboardTypes found: ${dashboardTypes.length} and bootstrapAlways 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);
+                for (const dashboardTypeName in sails.config.dashboardtype) {
+                    const config = sails.config.dashboardtype[dashboardTypeName];
+                    const created = await (0, rxjs_1.firstValueFrom)(this.create(defBrand, dashboardTypeName, {
+                        formatRules: config.formatRules,
+                        description: config.description,
+                        searchable: config.searchable,
+                        system: true,
+                        tableConfig: config.tableConfig ?? this.defaultTableConfig()
+                    }));
+                    dashTypes.push(created);
                 }
-                ;
-                this.dashboardTypes = dashTypes;
-                return dashTypes;
+                this.dashboardTypes = dashTypes.map((type) => this.normalizeDashboardTypeRecord(type));
+                return this.dashboardTypes;
             }
-            sails.log.verbose("Default DashboardTypes definition(s) exist.");
-            sails.log.verbose(JSON.stringify(dashboardTypes));
-            this.dashboardTypes = dashboardTypes;
-            return dashboardTypes;
+            this.dashboardTypes = dashboardTypes
+                .map((type) => this.normalizeDashboardTypeRecord(type))
+                .filter((type) => type !== null);
+            return this.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
-            }));
+            return this.createDashboardType(brand, { name, ...config });
+        }
+        createDashboardType(brand, input) {
+            return (0, rxjs_1.from)((async () => {
+                const normalized = this.normalizeDashboardTypeInput(input);
+                if (!normalized.name) {
+                    throw new Error('Dashboard type name is required');
+                }
+                const existing = await this.findDashboardTypeRecord(brand, normalized.name);
+                if (existing) {
+                    throw new Error(`Dashboard type '${normalized.name}' already exists for brand '${brand.name}'`);
+                }
+                const created = await DashboardType.create({
+                    name: normalized.name,
+                    branding: brand.id,
+                    description: normalized.description,
+                    formatRules: normalized.formatRules,
+                    tableConfig: normalized.tableConfig,
+                    searchable: normalized.searchable,
+                    system: normalized.system
+                });
+                return this.normalizeDashboardTypeRecord(created);
+            })());
         }
         get(brand, name) {
             const criteria = { where: { branding: brand.id, name: name } };
@@ -64,103 +211,92 @@ var Services;
             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 getAllDashboardTypeDefinitions(brand) {
+            const types = await (0, rxjs_1.firstValueFrom)(this.getAll(brand));
+            return types.map((type) => this.normalizeDashboardTypeRecord(type));
+        }
+        async getDashboardTypeDefinition(brand, name) {
+            const type = await this.findDashboardTypeRecord(brand, name);
+            return type;
+        }
+        updateDashboardType(brand, name, input) {
+            return (0, rxjs_1.from)((async () => {
+                const current = await this.findDashboardTypeRecord(brand, name);
+                if (!current) {
+                    throw new Error(`Dashboard type '${name}' was not found for brand '${brand.name}'`);
+                }
+                if (input.name != null && input.name !== name) {
+                    throw new Error('Dashboard type name is immutable once created');
+                }
+                if (current.system && input.system === false) {
+                    throw new Error('System dashboard types cannot be converted to non-system types');
+                }
+                const updateData = {
+                    description: input.description ?? current.description,
+                    formatRules: this.normalizeDashboardTypeInput({ ...current, ...input }).formatRules,
+                    tableConfig: this.normalizeTableConfig(input.tableConfig ?? current.tableConfig),
+                    searchable: input.searchable ?? current.searchable,
+                    system: input.system ?? current.system
+                };
+                const updated = await DashboardType.updateOne({ branding: brand.id, name }).set(updateData);
+                if (!updated) {
+                    throw new Error(`Dashboard type '${name}' was not updated`);
+                }
+                return this.normalizeDashboardTypeRecord(updated);
+            })());
+        }
+        deleteDashboardType(brand, name) {
+            return (0, rxjs_1.from)((async () => {
+                const current = await this.findDashboardTypeRecord(brand, name);
+                if (!current) {
+                    throw new Error(`Dashboard type '${name}' was not found for brand '${brand.name}'`);
+                }
+                if (current.system) {
+                    throw new Error(`System dashboard type '${name}' cannot be deleted`);
+                }
+                const assigned = await this.listAssignedDashboardTypeNames(brand);
+                if (assigned.has(name)) {
+                    throw new Error(`Dashboard type '${name}' is assigned to one or more workflow states or dashboard views`);
+                }
+                await DashboardType.destroy({ branding: brand.id, name });
+                return { deleted: true };
+            })());
+        }
         async getDashboardTableConfig(brand, recordType, workflowStage) {
             try {
-                // Get record type
+                if (typeof DashboardConfigService !== 'undefined' && DashboardConfigService.getMergedDashboardTableConfig) {
+                    const mergedConfig = await DashboardConfigService.getMergedDashboardTableConfig(brand, recordType, workflowStage);
+                    if (mergedConfig) {
+                        sails.log.verbose(`DashboardTypesService: using merged config for ${recordType}/${workflowStage}`);
+                        return mergedConfig.mergedConfig;
+                    }
+                }
                 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;
+                return this.normalizeTableConfig(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) {
@@ -168,124 +304,151 @@ var Services;
                 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') {
+        getDashboardView(name) {
+            const dashboardView = _.get(sails.config.dashboardview, name);
+            if (dashboardView == null) {
+                sails.log.warn(`Dashboard view not found: ${name}`);
+                return null;
+            }
+            return dashboardView;
+        }
+        getDashboardViewStep(name, stepName) {
+            const dashboardView = this.getDashboardView(name);
+            if (!dashboardView) {
+                return null;
+            }
+            const dashboardStep = (dashboardView.steps || []).find((step) => step.name === stepName) ?? null;
+            if (!dashboardStep) {
+                sails.log.warn(`Dashboard view step not found: ${name}/${stepName}`);
+            }
+            return dashboardStep;
+        }
+        async extractQueryFilterTemplates(brand, queryRecordType, dashboardType, templateKeyPrefix) {
             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) {
+            try {
+                const dashboardTypeModel = typeof DashboardConfigService !== 'undefined' && DashboardConfigService.getMergedDashboardTypeFormatRules
+                    ? await DashboardConfigService.getMergedDashboardTypeFormatRules(brand, dashboardType)
+                    : (await (0, rxjs_1.firstValueFrom)(this.get(brand, dashboardType)))?.formatRules;
+                const queryFilters = _.get(dashboardTypeModel, `queryFilters.${queryRecordType}`);
+                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: [...templateKeyPrefix, 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);
+            }
+            return entries;
+        }
+        extractDashboardTableTemplates(configKeyPrefix, dashboardConfig) {
+            const entries = [];
+            if (!dashboardConfig) {
+                return entries;
+            }
+            const rowConfig = (!_.isEmpty(dashboardConfig.rowConfig)) ? dashboardConfig.rowConfig : this.defaultTableConfig().rowConfig;
+            for (let i = 0; i < rowConfig.length; i++) {
+                const row = rowConfig[i];
+                if (row.template) {
+                    entries.push({
+                        key: [...configKeyPrefix, 'rowConfig', i.toString(), row.variable],
+                        kind: 'handlebars',
+                        value: row.template
+                    });
+                }
+            }
+            const groupRowConfig = dashboardConfig.groupRowConfig || [];
+            for (let i = 0; i < groupRowConfig.length; i++) {
+                const row = groupRowConfig[i];
+                if (row.template) {
+                    entries.push({
+                        key: [...configKeyPrefix, 'groupRowConfig', i.toString(), row.variable],
+                        kind: 'handlebars',
+                        value: row.template
+                    });
+                }
+            }
+            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, 'rowConfig', i.toString(), row.variable],
+                            key: [...configKeyPrefix, 'rowRules', ruleSet.ruleSetName, ruleIdx.toString(), 'render'],
                             kind: 'handlebars',
-                            value: row.template
+                            value: rule.renderItemTemplate
                         });
                     }
-                }
-                // Extract templates from groupRowConfig  
-                const groupRowConfig = dashboardConfig.groupRowConfig || [];
-                for (let i = 0; i < groupRowConfig.length; i++) {
-                    const row = groupRowConfig[i];
-                    if (row.template) {
+                    if (rule.evaluateRulesTemplate) {
                         entries.push({
-                            key: [recordType, workflowStage, 'groupRowConfig', i.toString(), row.variable],
+                            key: [...configKeyPrefix, 'rowRules', ruleSet.ruleSetName, ruleIdx.toString(), 'evaluate'],
                             kind: 'handlebars',
-                            value: row.template
+                            value: rule.evaluateRulesTemplate
                         });
                     }
                 }
-                // 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
-                            });
-                        }
+            }
+            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: [...configKeyPrefix, 'groupRowRules', ruleSet.ruleSetName, ruleIdx.toString(), 'render'],
+                            kind: 'handlebars',
+                            value: rule.renderItemTemplate
+                        });
                     }
-                }
-                // 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
-                            });
-                        }
+                    if (rule.evaluateRulesTemplate) {
+                        entries.push({
+                            key: [...configKeyPrefix, '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
-                                        });
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
+            return entries;
+        }
+        async extractDashboardTemplates(brand, recordType, workflowStage, dashboardType = 'standard') {
+            const dashboardConfig = await this.getDashboardTableConfig(brand, recordType, workflowStage);
+            const entries = this.extractDashboardTableTemplates([recordType, workflowStage], dashboardConfig);
+            entries.push(...await this.extractQueryFilterTemplates(brand, recordType, dashboardType, [recordType]));
+            return entries;
+        }
+        async extractDashboardViewTemplates(brand, dashboardView, stepName, dashboardType) {
+            const dashboardViewConfig = this.getDashboardView(dashboardView);
+            const dashboardStepConfig = this.getDashboardViewStep(dashboardView, stepName);
+            if (!dashboardViewConfig || !dashboardStepConfig) {
+                return [];
             }
-            catch (e) {
-                sails.log.warn(`Could not load dashboard type ${dashboardType} for template extraction`, e);
+            const resolvedDashboardType = dashboardType || dashboardViewConfig.dashboardType;
+            let mergedTableConfig = dashboardStepConfig.dashboardTable ?? null;
+            if (typeof DashboardConfigService !== 'undefined' && DashboardConfigService.getMergedDashboardViewTableConfig) {
+                const mergedConfig = await DashboardConfigService.getMergedDashboardViewTableConfig(brand, dashboardView, stepName);
+                mergedTableConfig = mergedConfig?.mergedConfig ?? mergedTableConfig;
             }
-            sails.log.verbose(`Extracted ${entries.length} dashboard templates for ${recordType}/${workflowStage}`);
+            const entries = this.extractDashboardTableTemplates([dashboardView, stepName], mergedTableConfig);
+            entries.push(...await this.extractQueryFilterTemplates(brand, dashboardStepConfig.sourceRecordType, resolvedDashboardType, [dashboardView]));
             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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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"DashboardTypesService.js","sourceRoot":"","sources":["../../src/services/DashboardTypesService.ts"],"names":[],"mappings":"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"}