@team-codeme/crud-forge 0.0.0-stage → 1.0.1

package/src/templates/angular/iam/shared/screen-matrix.util.ts.ejs

@@ -0,0 +1,554 @@
+import { getScreenBaseId } from '@/app/core/auth';
+
+/** CSV-backed screen catalog shapes (no Access Control DB required). */
+export type ComponentType = string;
+
+export interface IScreen {
+    id?: number | null;
+    screenId?: string | null;
+    screenName?: string | null;
+    description?: string | null;
+}
+
+export interface IScreenAndComponent {
+    id?: number | null;
+    screenId?: number | string | null;
+    screen?: IScreen | null;
+    componentId?: string | null;
+    componentName?: string | null;
+    description?: string | null;
+    componentType?: ComponentType | null;
+    ComponentType?: ComponentType | null;
+    screenName?: string | null;
+}
+
+export interface GroupedScreenCluster {
+    screen: IScreen;
+    cleanScreenId: string;
+    screenIds: string[];
+    screenNames: string[];
+    components: IScreenAndComponent[];
+}
+
+export type MatrixSearchScope = 'ALL' | 'SCREEN';
+
+export type CsvRegistryRow = {
+    screenName: string;
+    screenId: string;
+    componentName: string;
+    componentId: string;
+    componentType: string;
+    description: string;
+};
+
+/** componentId → every CSV parent screenId (shared action ids appear on many screens). */
+export type CsvComponentToScreenMap = Record<string, string[]>;
+
+const CANONICAL_SCREEN_SUFFIXES = ['-actions', '-list', '-form', '-filter', '-detail', '-page'];
+
+export function getCleanScreenName(screenName: String | string | null | undefined): string {
+    if (!screenName) {
+        return '';
+    }
+    return String(screenName).replace(/^I-/i, '');
+}
+
+export function getCleanScreenId(
+    screenId: String | string | null | undefined,
+    screenName: String | string | null | undefined
+): string {
+    if (!screenId) {
+        return '';
+    }
+    if (!screenName) {
+        return String(screenId);
+    }
+
+    const cleanScreenName = getCleanScreenName(screenName);
+    const suffix = '-' + cleanScreenName.toLowerCase().replace(/\s+/g, '-');
+    const strScreenId = String(screenId);
+
+    if (strScreenId.endsWith(suffix) && strScreenId !== suffix.substring(1)) {
+        return strScreenId.slice(0, -suffix.length);
+    }
+
+    return strScreenId;
+}
+
+export function pickCanonicalScreen(screens: IScreen[]): IScreen {
+    for (const suffix of CANONICAL_SCREEN_SUFFIXES) {
+        const match = screens.find((screen) => String(screen.screenId || '').toLowerCase().endsWith(suffix));
+        if (match) {
+            return match;
+        }
+    }
+
+    return screens[0];
+}
+
+/**
+ * Cluster key for the permission matrix.
+ * Prefer screenId base (`region-list` → `region`, `ref-region-list` → `ref-region`) so
+ * reference and operational modules with the same CSV screenName (e.g. I-Region) stay
+ * separate. Fall back to normalized screenName when screenId is missing.
+ */
+export function getScreenClusterKey(screen: IScreen): string {
+    const fromId = getScreenBaseId(String(screen.screenId || ''));
+    if (fromId) {
+        return fromId;
+    }
+
+    return getCleanScreenName(screen.screenName)
+        .trim()
+        .toLowerCase()
+        .replace(/\s+/g, '-')
+        .replace(/[^a-z0-9-]+/g, '')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '');
+}
+
+function isScreenAccessComponent(comp: IScreenAndComponent): boolean {
+    const type = String(comp.componentType || '').toUpperCase();
+    const name = String(comp.componentName || '').toLowerCase();
+    return type === 'SCREEN' || name.includes('screen access');
+}
+
+function isCsvScreenAccessRow(row: CsvRegistryRow): boolean {
+    const type = String(row.componentType || '').toUpperCase();
+    return type === 'SCREEN' || (!!row.componentId && row.componentId === row.screenId);
+}
+
+function getComponentRelationFk(comp: IScreenAndComponent): number | null {
+    const flat = comp.screenId != null ? Number(comp.screenId) : NaN;
+    if (Number.isFinite(flat) && flat > 0) {
+        return flat;
+    }
+    const nestedId = (comp.screen as IScreen | null | undefined)?.id;
+    if (nestedId != null) {
+        const nested = Number(nestedId);
+        if (Number.isFinite(nested) && nested > 0) {
+            return nested;
+        }
+    }
+    return null;
+}
+
+function csvScreenIdsForComponent(map: CsvComponentToScreenMap | undefined, componentId: string): string[] {
+    if (!map || !componentId) {
+        return [];
+    }
+    return map[componentId] || [];
+}
+
+/**
+ * Same matching rules as the previous matrix loaders:
+ * 1) If relationship FK is present → match Screen.id
+ * 2) Else CSV component→screen map (a component may belong to many screens)
+ * 3) Else legacy componentId heuristic
+ */
+export function componentBelongsToScreen(
+    comp: IScreenAndComponent,
+    screen: IScreen,
+    csvComponentToScreenMap?: CsvComponentToScreenMap
+): boolean {
+    if (isScreenAccessComponent(comp)) {
+        return false;
+    }
+
+    const scrBusinessId = String(screen.screenId || '');
+    const scrDbId = screen.id != null ? Number(screen.id) : NaN;
+    const relationFk = getComponentRelationFk(comp);
+
+    if (relationFk != null) {
+        return Number.isFinite(scrDbId) && scrDbId > 0 && relationFk === scrDbId;
+    }
+
+    const compId = String(comp.componentId || '');
+    const mappedScreenIds = csvScreenIdsForComponent(csvComponentToScreenMap, compId);
+    if (mappedScreenIds.length > 0) {
+        return mappedScreenIds.includes(scrBusinessId);
+    }
+
+    const cleanId = compId.toLowerCase().replace(/-btn$/, '').replace(/-button$/, '');
+    const targetId = scrBusinessId.toLowerCase();
+    return cleanId === targetId || (targetId.length > 0 && cleanId.startsWith(`${targetId}-`));
+}
+
+function parseComponentType(value: string | null | undefined): ComponentType | null {
+    const raw = String(value || '').trim().toUpperCase();
+    return raw || null;
+}
+
+function hydrateComponentFromCsv(row: CsvRegistryRow, dbComp?: IScreenAndComponent): IScreenAndComponent {
+    const csvType = parseComponentType(row.componentType);
+    if (dbComp) {
+        return {
+            ...dbComp,
+            componentName: row.componentName || dbComp.componentName,
+            description: row.description || dbComp.description,
+            componentType: csvType || dbComp.componentType,
+            ComponentType: csvType || dbComp.ComponentType,
+            screenName: row.screenName || dbComp.screenName,
+        };
+    }
+
+    return {
+        componentName: row.componentName,
+        componentId: row.componentId,
+        componentType: csvType,
+        ComponentType: csvType,
+        description: row.description,
+        screenName: row.screenName,
+    };
+}
+
+function overlayCsvComponentsForScreen(
+    screen: IScreen,
+    existing: IScreenAndComponent[],
+    csvRowsByScreenId: Map<string, CsvRegistryRow[]>,
+    componentsById: Map<string, IScreenAndComponent>
+): IScreenAndComponent[] {
+    const merged = new Map<string, IScreenAndComponent>();
+    existing.forEach((comp) => {
+        const id = String(comp.componentId || '');
+        if (id) {
+            merged.set(id, comp);
+        }
+    });
+
+    const csvRows = csvRowsByScreenId.get(String(screen.screenId || '')) || [];
+    csvRows.forEach((row) => {
+        if (!row.componentId || isCsvScreenAccessRow(row)) {
+            return;
+        }
+        const dbComp = componentsById.get(row.componentId);
+        merged.set(row.componentId, hydrateComponentFromCsv(row, merged.get(row.componentId) || dbComp));
+    });
+
+    return Array.from(merged.values()).sort((a, b) =>
+        String(a.componentName || '').localeCompare(String(b.componentName || ''))
+    );
+}
+
+/**
+ * Build matrix clusters using DB rows plus the CSV catalog.
+ * Shared action IDs (submit, edit, view, …) are shown on every CSV parent screen,
+ * even when the database only stored the first copy.
+ */
+export function buildScreenComponentClusters(
+    screens: IScreen[],
+    components: IScreenAndComponent[],
+    csvComponentToScreenMap?: CsvComponentToScreenMap,
+    csvRows: CsvRegistryRow[] = []
+): GroupedScreenCluster[] {
+    const componentsById = new Map<string, IScreenAndComponent>();
+    components.forEach((comp) => {
+        const id = String(comp.componentId || '');
+        if (id && !componentsById.has(id)) {
+            componentsById.set(id, comp);
+        }
+    });
+
+    const csvRowsByScreenId = new Map<string, CsvRegistryRow[]>();
+    csvRows.forEach((row) => {
+        if (!row.screenId) {
+            return;
+        }
+        const list = csvRowsByScreenId.get(row.screenId) || [];
+        list.push(row);
+        csvRowsByScreenId.set(row.screenId, list);
+    });
+
+    // CSV SCREEN rows fill gaps when Access Control DB never registered a screen
+    // (e.g. identity Regional Office region-list while only ref-region-* exists in DB).
+    const catalogScreens = mergeCsvScreenAccessRows(screens, csvRows);
+
+    const grouped: Array<{ screen: IScreen; components: IScreenAndComponent[] }> = [];
+
+    catalogScreens.forEach((screen) => {
+        const screenComps = components.filter((comp) =>
+            componentBelongsToScreen(comp, screen, csvComponentToScreenMap)
+        );
+
+        grouped.push({
+            screen,
+            components: overlayCsvComponentsForScreen(screen, screenComps, csvRowsByScreenId, componentsById),
+        });
+    });
+
+    return clusterScreensByCleanId(grouped);
+}
+
+/** Add synthetic IScreen rows for CSV Screen Access ids missing from the DB catalog. */
+export function mergeCsvScreenAccessRows(screens: IScreen[], csvRows: CsvRegistryRow[]): IScreen[] {
+    const byId = new Map<string, IScreen>();
+    screens.forEach((screen) => {
+        const id = String(screen.screenId || '').trim();
+        if (id && !byId.has(id)) {
+            byId.set(id, screen);
+        }
+    });
+
+    csvRows.forEach((row) => {
+        if (!isCsvScreenAccessRow(row) || !row.screenId) {
+            return;
+        }
+        const id = String(row.screenId).trim();
+        if (!id || byId.has(id)) {
+            return;
+        }
+        byId.set(id, {
+            screenId: id,
+            screenName: row.screenName || id,
+            description: row.description || null,
+        });
+    });
+
+    return Array.from(byId.values());
+}
+
+export function clusterScreensByCleanId(
+    groups: Array<{ screen: IScreen; components: IScreenAndComponent[] }>
+): GroupedScreenCluster[] {
+    const clusterMap = new Map<string, { screens: IScreen[]; components: Map<string, IScreenAndComponent> }>();
+
+    groups.forEach(({ screen, components }) => {
+        const cleanId = getScreenClusterKey(screen);
+        if (!cleanId) {
+            return;
+        }
+
+        let cluster = clusterMap.get(cleanId);
+        if (!cluster) {
+            cluster = { screens: [], components: new Map() };
+            clusterMap.set(cleanId, cluster);
+        }
+
+        cluster.screens.push(screen);
+        components.forEach((component) => {
+            const componentId = String(component.componentId || '');
+            if (componentId) {
+                cluster!.components.set(componentId, component);
+            }
+        });
+    });
+
+    return Array.from(clusterMap.entries())
+        .map(([cleanScreenId, cluster]) => ({
+            cleanScreenId,
+            screen: pickCanonicalScreen(cluster.screens),
+            screenIds: uniqueStrings(cluster.screens.map((screen) => String(screen.screenId || ''))),
+            screenNames: uniqueStrings(cluster.screens.map((screen) => String(screen.screenName || ''))),
+            components: Array.from(cluster.components.values()).sort((left, right) =>
+                String(left.componentName || '').localeCompare(String(right.componentName || ''))
+            ),
+        }))
+        .sort((left, right) => left.cleanScreenId.localeCompare(right.cleanScreenId));
+}
+
+function uniqueStrings(values: string[]): string[] {
+    return Array.from(new Set(values.filter((value) => value.trim().length > 0)));
+}
+
+export function parseCsvRegistry(csvText: string | null | undefined): CsvRegistryRow[] {
+    if (!csvText) {
+        return [];
+    }
+
+    const rows: CsvRegistryRow[] = [];
+    const lines = csvText.split(/\r?\n/).filter((line) => line.trim().length > 0);
+    for (let i = 1; i < lines.length; i++) {
+        const parts = parseSimpleCsvLine(lines[i]);
+        const fallback = lines[i].split(',').map((part) => part.replace(/^"|"$/g, '').trim());
+        const cols = parts.length >= 4 ? parts : fallback;
+        if (cols.length >= 4) {
+            rows.push({
+                screenName: cols[0] || '',
+                screenId: cols[1] || '',
+                componentName: cols[2] || '',
+                componentId: cols[3] || '',
+                componentType: cols[4] || '',
+                description: cols[5] || '',
+            });
+        }
+    }
+    return rows;
+}
+
+/** Parse scanner CSV into componentId → all parent screenIds. */
+export function parseCsvComponentToScreenMap(csvText: string | null | undefined): CsvComponentToScreenMap {
+    const map: CsvComponentToScreenMap = {};
+    parseCsvRegistry(csvText).forEach((row) => {
+        if (!row.componentId || !row.screenId || isCsvScreenAccessRow(row)) {
+            return;
+        }
+        const list = map[row.componentId] || [];
+        if (!list.includes(row.screenId)) {
+            list.push(row.screenId);
+        }
+        map[row.componentId] = list;
+    });
+    return map;
+}
+
+function parseSimpleCsvLine(line: string): string[] {
+    const parts: string[] = [];
+    let current = '';
+    let inQuotes = false;
+    for (let i = 0; i < line.length; i++) {
+        const char = line[i];
+        if (char === '"') {
+            if (inQuotes && line[i + 1] === '"') {
+                current += '"';
+                i++;
+            } else {
+                inQuotes = !inQuotes;
+            }
+        } else if (char === ',' && !inQuotes) {
+            parts.push(current.trim());
+            current = '';
+        } else {
+            current += char;
+        }
+    }
+    parts.push(current.trim());
+    return parts;
+}
+
+export function textMatchesSearch(value: String | string | null | undefined, search: string): boolean {
+    const haystack = String(value || '').toLowerCase();
+    const needle = search.trim().toLowerCase();
+    if (!needle) {
+        return true;
+    }
+    if (haystack.includes(needle)) {
+        return true;
+    }
+    const haystackNorm = normalizeSearchToken(haystack);
+    const needleNorm = normalizeSearchToken(needle);
+    return haystackNorm.includes(needleNorm);
+}
+
+function normalizeSearchToken(value: string): string {
+    return value
+        .replace(/^i-/, '')
+        .replace(/[\s_]+/g, '-')
+        .replace(/-+/g, '-');
+}
+
+function componentMatchesSearch(comp: IScreenAndComponent, search: string): boolean {
+    return (
+        textMatchesSearch(comp.componentName, search) ||
+        textMatchesSearch(comp.componentId, search) ||
+        textMatchesSearch(comp.description, search)
+    );
+}
+
+function clusterScreenMatchesSearch(group: GroupedScreenCluster, search: string): boolean {
+    const cleanName = getCleanScreenName(group.screen.screenName);
+    const fields = [
+        group.screen.screenName,
+        group.screen.screenId,
+        group.screen.description,
+        group.cleanScreenId,
+        cleanName,
+        ...(group.screenIds || []),
+        ...(group.screenNames || []),
+    ];
+    return fields.some((field) => textMatchesSearch(field, search));
+}
+
+export function filterMatrixClusters(
+    data: GroupedScreenCluster[],
+    searchTerm: string,
+    scope: MatrixSearchScope
+): GroupedScreenCluster[] {
+    const search = searchTerm.trim();
+
+    const sortAlphabetically = (groups: GroupedScreenCluster[]) =>
+        [...groups].sort((left, right) =>
+            String(left.cleanScreenId || '').localeCompare(String(right.cleanScreenId || ''))
+        );
+
+    if (!search) {
+        return sortAlphabetically(data);
+    }
+
+    const filtered = data
+        .map((group) => {
+            const screenMatches = clusterScreenMatchesSearch(group, search);
+            const matchingComponents = group.components.filter((comp) => componentMatchesSearch(comp, search));
+
+            if (scope === 'SCREEN') {
+                if (!screenMatches) {
+                    return null;
+                }
+                return { ...group, screenMatches: true };
+            }
+
+            if (screenMatches) {
+                const sortedComps = [...group.components].sort((a, b) => {
+                    const aMatch = componentMatchesSearch(a, search);
+                    const bMatch = componentMatchesSearch(b, search);
+                    if (aMatch && !bMatch) return -1;
+                    if (!aMatch && bMatch) return 1;
+                    return String(a.componentName || '').localeCompare(String(b.componentName || ''));
+                });
+                return { ...group, components: sortedComps, screenMatches: true };
+            }
+
+            if (matchingComponents.length > 0) {
+                const sortedComps = [...matchingComponents].sort((a, b) =>
+                    String(a.componentName || '').localeCompare(String(b.componentName || ''))
+                );
+                return { ...group, components: sortedComps, screenMatches: false };
+            }
+
+            return null;
+        })
+        .filter((group): group is GroupedScreenCluster & { screenMatches: boolean } => group !== null);
+
+    return filtered.sort((a, b) => {
+        if (a.screenMatches && !b.screenMatches) return -1;
+        if (!a.screenMatches && b.screenMatches) return 1;
+        return String(a.cleanScreenId || '').localeCompare(String(b.cleanScreenId || ''));
+    });
+}
+
+export function highlightMatrixText(text: String | null | undefined, searchTerm: string): string {
+    const val = escapeHtml(text ? String(text) : '');
+    const raw = searchTerm.trim();
+    if (!raw) {
+        return val;
+    }
+
+    const needles = uniqueStrings([
+        raw,
+        raw.replace(/^I-/i, ''),
+        normalizeSearchToken(raw).replace(/-/g, ' '),
+        normalizeSearchToken(raw),
+    ]);
+    for (const needle of needles) {
+        if (!needle || !val.toLowerCase().includes(needle.toLowerCase())) {
+            continue;
+        }
+        const regex = new RegExp(`(${escapeRegExp(needle)})`, 'gi');
+        return val.replace(
+            regex,
+            '<mark class="bg-amber-200 dark:bg-amber-500/30 text-slate-900 dark:text-amber-100 rounded px-0.5 py-0.25 font-medium">$1</mark>'
+        );
+    }
+    return val;
+}
+
+function escapeRegExp(value: string): string {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function escapeHtml(value: string): string {
+    return value
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+}