fix: minor adjustment and fixes to search scroll and resultorder

Lucki2g · Lucki2g · commit e08b03bdb7bc · 2026-01-13T18:45:57.000+01:00
diff --git a/Website/components/datamodelview/Attributes.tsx b/Website/components/datamodelview/Attributes.tsx
@@ -18,6 +18,7 @@ import { highlightMatch } from "../datamodelview/List";
 import { Box, Button, FormControl, InputAdornment, InputLabel, MenuItem, Select, Table, TableBody, TableCell, TableHead, TableRow, TextField, Tooltip, Typography, useTheme } from "@mui/material"
 import { ClearRounded, SearchRounded, Visibility, VisibilityOff, ArrowUpwardRounded, ArrowDownwardRounded } from "@mui/icons-material"
 import { useEntityFiltersDispatch } from "@/contexts/EntityFiltersContext"
+import { useDatamodelData } from "@/contexts/DatamodelDataContext"
 
 type SortDirection = 'asc' | 'desc' | null
 type SortColumn = 'displayName' | 'schemaName' | 'type' | 'description' | null
@@ -37,6 +38,7 @@ export const Attributes = ({ entity, search = "", onVisibleCountChange }: IAttri
 
     const theme = useTheme();
     const entityFiltersDispatch = useEntityFiltersDispatch();
+    const { searchScope } = useDatamodelData();
 
     // Report filter state changes to context
     useEffect(() => {
@@ -144,7 +146,10 @@ export const Attributes = ({ entity, search = "", onVisibleCountChange }: IAttri
     }
 
     const sortedAttributes = getSortedAttributes();
-    const highlightTerm = searchQuery || search; // Use internal search or parent search for highlighting
+    // Only highlight if search scope includes columns
+    // Use internal search query first, or parent search if column scopes are enabled
+    const highlightTerm = searchQuery ||
+        (search && (searchScope.columnNames || searchScope.columnDescriptions || searchScope.columnDataTypes) ? search : "");
 
     // Notify parent of visible count changes
     useEffect(() => {
diff --git a/Website/components/datamodelview/DatamodelView.tsx b/Website/components/datamodelview/DatamodelView.tsx
@@ -37,7 +37,7 @@ function DatamodelViewContent() {
     const datamodelDispatch = useDatamodelViewDispatch();
     const { groups, filtered, search } = useDatamodelData();
     const datamodelDataDispatch = useDatamodelDataDispatch();
-    const { filters: entityFilters } = useEntityFilters();
+    const { filters: entityFilters, selectedSecurityRoles } = useEntityFilters();
     const workerRef = useRef<Worker | null>(null);
     const [currentSearchIndex, setCurrentSearchIndex] = useState(0);
     const accumulatedResultsRef = useRef<SearchResultItem[]>([]); // Track all results during search
@@ -67,11 +67,29 @@ function DatamodelViewContent() {
     const totalResults = useMemo(() => {
         if (filtered.length === 0) return 0;
 
-        const attributeCount = filtered.filter(item => item.type === 'attribute').length;
-        const relationshipCount = filtered.filter(item => item.type === 'relationship').length;
-        const itemCount = attributeCount + relationshipCount;
+        // Get combined results and deduplicate to match navigation behavior
+        const combinedResults = filtered.filter((item): item is { type: 'attribute'; group: GroupType; entity: EntityType; attribute: AttributeType } | { type: 'relationship'; group: GroupType; entity: EntityType; relationship: RelationshipType } =>
+            item.type === 'attribute' || item.type === 'relationship'
+        );
 
-        if (itemCount > 0) return itemCount;
+        if (combinedResults.length > 0) {
+            // Deduplicate to match getSortedCombinedResults behavior
+            // Note: We don't check DOM element existence here because relationships on inactive tabs
+            // won't have DOM elements yet, but they should still be counted for navigation
+            const seen = new Set<string>();
+            let count = 0;
+            for (const item of combinedResults) {
+                const key = item.type === 'attribute'
+                    ? `attr-${item.entity.SchemaName}-${item.attribute.SchemaName}`
+                    : `rel-${item.entity.SchemaName}-${item.relationship.RelationshipSchema}`;
+
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    count++;
+                }
+            }
+            return count;
+        }
 
         // If no attributes or relationships, count entity-level matches (for security roles, table descriptions)
         const entityCount = filtered.filter(item => item.type === 'entity').length;
@@ -98,6 +116,7 @@ function DatamodelViewContent() {
                     data: searchValue,
                     entityFilters: filtersObject,
                     searchScope: searchScope,
+                    selectedSecurityRoles: selectedSecurityRoles,
                     requestId: currentRequestId // Send request ID to worker
                 });
             } else {
@@ -113,23 +132,24 @@ function DatamodelViewContent() {
         updateURL({ query: { globalsearch: searchValue.length >= 3 ? searchValue : "" } })
         datamodelDataDispatch({ type: "SET_SEARCH", payload: searchValue.length >= 3 ? searchValue : "" });
         setCurrentSearchIndex(searchValue.length >= 3 ? 1 : 0); // Reset to first result when searching, 0 when cleared
-    }, [groups, datamodelDataDispatch, restoreSection, entityFilters, searchScope]);
+    }, [groups, datamodelDataDispatch, restoreSection, entityFilters, searchScope, selectedSecurityRoles]);
 
     const handleLoadingChange = useCallback((isLoading: boolean) => {
         datamodelDispatch({ type: "SET_LOADING", payload: isLoading });
     }, [datamodelDispatch]);
 
     const handleSearchScopeChange = useCallback((newScope: SearchScope) => {
         setSearchScope(newScope);
-    }, []);
+        datamodelDataDispatch({ type: "SET_SEARCH_SCOPE", payload: newScope });
+    }, [datamodelDataDispatch]);
 
-    // Re-trigger search when scope changes
+    // Re-trigger search when scope or security roles change
     useEffect(() => {
         if (search && search.length >= 3) {
             handleSearch(search);
         }
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [searchScope]); // Only trigger on searchScope change, not handleSearch to avoid infinite loop
+    }, [searchScope, selectedSecurityRoles]); // Only trigger on searchScope or selectedSecurityRoles change, not handleSearch to avoid infinite loop
 
     // Helper function to get sorted combined results (attributes + relationships) on-demand
     // This prevents blocking the main thread during typing - sorting only happens during navigation
@@ -165,44 +185,69 @@ function DatamodelViewContent() {
             resultsByEntity.get(entityKey)!.push(result);
         }
 
-        // Sort entities by the Y position of their first attribute (or use first result if no attributes)
+        // Create a stable sort order based on the groups data structure
+        // This ensures consistent navigation order regardless of scroll position or tab state
+        const entityOrder = new Map<string, number>();
+        let orderIndex = 0;
+        for (const group of groups) {
+            for (const entity of group.Entities) {
+                entityOrder.set(entity.SchemaName, orderIndex++);
+            }
+        }
+
+        // Sort entities by their position in the groups data structure
         const sortedEntities = Array.from(resultsByEntity.entries()).sort((a, b) => {
-            const [, resultsA] = a;
-            const [, resultsB] = b;
+            const [entitySchemaA] = a;
+            const [entitySchemaB] = b;
 
-            // Find first attribute for each entity
-            const firstAttrA = resultsA.find(r => r.type === 'attribute') as { type: 'attribute'; group: GroupType; entity: EntityType; attribute: AttributeType } | undefined;
-            const firstAttrB = resultsB.find(r => r.type === 'attribute') as { type: 'attribute'; group: GroupType; entity: EntityType; attribute: AttributeType } | undefined;
+            const orderA = entityOrder.get(entitySchemaA) ?? Number.MAX_SAFE_INTEGER;
+            const orderB = entityOrder.get(entitySchemaB) ?? Number.MAX_SAFE_INTEGER;
 
-            // If both have attributes, compare by Y position
-            if (firstAttrA && firstAttrB) {
-                const elementA = document.getElementById(`attr-${firstAttrA.entity.SchemaName}-${firstAttrA.attribute.SchemaName}`);
-                const elementB = document.getElementById(`attr-${firstAttrB.entity.SchemaName}-${firstAttrB.attribute.SchemaName}`);
+            return orderA - orderB;
+        });
+
+        // Flatten back to array, keeping attributes BEFORE relationships within each entity
+        const result: Array<{ type: 'attribute'; group: GroupType; entity: EntityType; attribute: AttributeType } | { type: 'relationship'; group: GroupType; entity: EntityType; relationship: RelationshipType }> = [];
+        for (const [, entityResults] of sortedEntities) {
+            // Separate attributes and relationships for this entity
+            const attributes = entityResults.filter((r): r is { type: 'attribute'; group: GroupType; entity: EntityType; attribute: AttributeType } => r.type === 'attribute');
+            const relationships = entityResults.filter((r): r is { type: 'relationship'; group: GroupType; entity: EntityType; relationship: RelationshipType } => r.type === 'relationship');
+
+            // Sort attributes by Y position within the entity (if they exist in DOM)
+            // Note: We don't filter out attributes that don't exist in DOM because the search worker
+            // already applied all component-level filters
+            attributes.sort((a, b) => {
+                const elementA = document.getElementById(`attr-${a.entity.SchemaName}-${a.attribute.SchemaName}`);
+                const elementB = document.getElementById(`attr-${b.entity.SchemaName}-${b.attribute.SchemaName}`);
 
                 if (elementA && elementB) {
                     const rectA = elementA.getBoundingClientRect();
                     const rectB = elementB.getBoundingClientRect();
                     return rectA.top - rectB.top;
                 }
-            }
+                return 0;
+            });
 
-            // Fallback: maintain original order
-            return 0;
-        });
+            // Sort relationships by Y position within the entity (if they exist in DOM)
+            // Note: Relationships on inactive tabs won't have DOM elements, so we keep them in original order
+            relationships.sort((a, b) => {
+                const elementA = document.getElementById(`rel-${a.entity.SchemaName}-${a.relationship.RelationshipSchema}`);
+                const elementB = document.getElementById(`rel-${b.entity.SchemaName}-${b.relationship.RelationshipSchema}`);
 
-        // Flatten back to array, keeping attributes before relationships within each entity
-        const result: Array<{ type: 'attribute'; group: GroupType; entity: EntityType; attribute: AttributeType } | { type: 'relationship'; group: GroupType; entity: EntityType; relationship: RelationshipType }> = [];
-        for (const [, entityResults] of sortedEntities) {
-            // Separate attributes and relationships for this entity
-            const attributes = entityResults.filter((r): r is { type: 'attribute'; group: GroupType; entity: EntityType; attribute: AttributeType } => r.type === 'attribute');
-            const relationships = entityResults.filter((r): r is { type: 'relationship'; group: GroupType; entity: EntityType; relationship: RelationshipType } => r.type === 'relationship');
+                if (elementA && elementB) {
+                    const rectA = elementA.getBoundingClientRect();
+                    const rectB = elementB.getBoundingClientRect();
+                    return rectA.top - rectB.top;
+                }
+                return 0;
+            });
 
-            // Add all attributes first (in their original order), then relationships
+            // Add all attributes first, then all relationships
             result.push(...attributes, ...relationships);
         }
 
         return result;
-    }, [filtered]);
+    }, [filtered, groups]);
 
     // Navigation handlers
     const handleNavigateNext = useCallback(() => {
diff --git a/Website/components/datamodelview/List.tsx b/Website/components/datamodelview/List.tsx
@@ -214,21 +214,25 @@ export const List = ({ setCurrentIndex, entityActiveTabs }: IListProps) => {
 
     const scrollToRelationship = useCallback((sectionId: string, relSchema: string) => {
         const relId = `rel-${sectionId}-${relSchema}`;
-        const relationshipLocation = document.getElementById(relId);
 
-        if (relationshipLocation) {
-            // Relationship is already rendered, scroll directly to it
-            relationshipLocation.scrollIntoView({ behavior: 'smooth', block: 'center' });
-        } else {
-            // Relationship not found, need to scroll to section first
-            scrollToSection(sectionId);
-            setTimeout(() => {
-                const relationshipLocationAfterScroll = document.getElementById(relId);
-                if (relationshipLocationAfterScroll) {
-                    relationshipLocationAfterScroll.scrollIntoView({ behavior: 'smooth', block: 'center' });
-                }
-            }, 100);
-        }
+        // Helper function to attempt scrolling to relationship with retries
+        const attemptScroll = (attemptsLeft: number) => {
+            const relationshipLocation = document.getElementById(relId);
+
+            if (relationshipLocation) {
+                // Relationship found, scroll to it
+                relationshipLocation.scrollIntoView({ behavior: 'smooth', block: 'center' });
+            } else if (attemptsLeft > 0) {
+                // Relationship not rendered yet, retry after delay
+                setTimeout(() => attemptScroll(attemptsLeft - 1), 100);
+            } else {
+                // Give up after all retries, just scroll to section
+                scrollToSection(sectionId);
+            }
+        };
+
+        // Start attempting to scroll with 5 retries (total 500ms wait time)
+        attemptScroll(5);
     }, [scrollToSection]);
 
     const scrollToGroup = useCallback((groupName: string) => {
diff --git a/Website/components/datamodelview/Relationships.tsx b/Website/components/datamodelview/Relationships.tsx
@@ -31,7 +31,7 @@ export const Relationships = ({ entity, search = "", onVisibleCountChange }: IRe
 
     const dispatch = useDatamodelViewDispatch();
     const { scrollToSection } = useDatamodelView();
-    const { groups } = useDatamodelData();
+    const { groups, searchScope } = useDatamodelData();
 
     // Helper function to check if an entity is in the solution
     const isEntityInSolution = (entitySchemaName: string): boolean => {
@@ -147,7 +147,10 @@ export const Relationships = ({ entity, search = "", onVisibleCountChange }: IRe
     ]
 
     const sortedRelationships = getSortedRelationships();
-    const highlightTerm = searchQuery || search; // Use internal search or parent search for highlighting
+    // Only highlight if search scope includes relationships
+    // Use internal search query first, or parent search if relationships scope is enabled
+    const highlightTerm = searchQuery ||
+        (search && searchScope.relationships ? search : "");
 
     // Notify parent of visible count changes
     useEffect(() => {
diff --git a/Website/components/datamodelview/searchWorker.ts b/Website/components/datamodelview/searchWorker.ts
@@ -25,6 +25,7 @@ interface SearchMessage {
   data: string;
   entityFilters?: Record<string, EntityFilterState>;
   searchScope?: SearchScope;
+  selectedSecurityRoles?: string[];
   requestId?: number;
 }
 
@@ -70,6 +71,7 @@ self.onmessage = async function (e: MessageEvent<WorkerMessage>) {
   const search = (typeof e.data === 'string' ? e.data : e.data?.data || '').trim().toLowerCase();
   const entityFilters: Record<string, EntityFilterState> = (typeof e.data === 'object' && 'entityFilters' in e.data) ? e.data.entityFilters || {} : {};
   const requestId = (typeof e.data === 'object' && 'requestId' in e.data) ? e.data.requestId : undefined;
+  const selectedSecurityRoles: string[] = (typeof e.data === 'object' && 'selectedSecurityRoles' in e.data) ? e.data.selectedSecurityRoles || [] : [];
   const searchScope: SearchScope = (typeof e.data === 'object' && 'searchScope' in e.data) ? e.data.searchScope || {
     columnNames: true,
     columnDescriptions: true,
@@ -103,12 +105,27 @@ self.onmessage = async function (e: MessageEvent<WorkerMessage>) {
     | { type: 'relationship'; group: GroupType; entity: EntityType; relationship: RelationshipType }
   > = [];
 
+  // Helper function to check if entity has access from selected security roles
+  const hasSecurityRoleAccess = (entity: EntityType): boolean => {
+    if (selectedSecurityRoles.length === 0) return true; // No filter means show all
+
+    return entity.SecurityRoles.some(role =>
+      selectedSecurityRoles.includes(role.Name) &&
+      (role.Read !== null && role.Read >= 0) // Has any read access
+    );
+  };
+
   ////////////////////////////////////////////////
   // Finding matches part
   ////////////////////////////////////////////////
   for (const group of groups) {
     let groupUsed = false;
     for (const entity of group.Entities) {
+      // Filter by security roles first - skip entity if no access
+      if (!hasSecurityRoleAccess(entity)) {
+        continue;
+      }
+
       // Get entity-specific filters (default to showing all if not set)
       const entityFilter = entityFilters[entity.SchemaName] || { hideStandardFields: true, typeFilter: 'all' };
 
diff --git a/Website/contexts/DatamodelDataContext.tsx b/Website/contexts/DatamodelDataContext.tsx
@@ -3,6 +3,7 @@
 import React, { createContext, useContext, useReducer, ReactNode } from "react";
 import { AttributeType, EntityType, GroupType, RelationshipType, SolutionWarningType } from "@/lib/Types";
 import { useSearchParams } from "next/navigation";
+import { SearchScope } from "@/components/datamodelview/TimeSlicedSearch";
 
 interface DataModelAction {
   getEntityDataBySchemaName: (schemaName: string) => EntityType | undefined;
@@ -14,6 +15,7 @@ interface DatamodelDataState extends DataModelAction {
   warnings: SolutionWarningType[];
   solutionCount: number;
   search: string;
+  searchScope: SearchScope;
   filtered: Array<
     | { type: 'group'; group: GroupType }
     | { type: 'entity'; group: GroupType; entity: EntityType }
@@ -27,6 +29,13 @@ const initialState: DatamodelDataState = {
   warnings: [],
   solutionCount: 0,
   search: "",
+  searchScope: {
+    columnNames: true,
+    columnDescriptions: true,
+    columnDataTypes: false,
+    tableDescriptions: false,
+    relationships: false,
+  },
   filtered: [],
 
   getEntityDataBySchemaName: () => { throw new Error("getEntityDataBySchemaName not implemented.") },
@@ -47,6 +56,8 @@ const datamodelDataReducer = (state: DatamodelDataState, action: any): Datamodel
       return { ...state, solutionCount: action.payload };
     case "SET_SEARCH":
       return { ...state, search: action.payload };
+    case "SET_SEARCH_SCOPE":
+      return { ...state, searchScope: action.payload };
     case "SET_FILTERED":
       return { ...state, filtered: action.payload };
     case "APPEND_FILTERED":
