cat-documents-ng 1.0.5 → 1.0.6

package/src/lib/document/services/document-menu.service.ts

@@ -0,0 +1,277 @@
+import { Injectable } from '@angular/core';
+import { DocumentCategory, DocumentCategoryItem } from '../models/document-category.model';
+import { DocumentStore } from '../state/document.store';
+import { DocumentListResponse } from '../models/document-list-response.model';
+import { SHARED } from '../../../Shared/constant/SHARED';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class DocumentMenuService {
+
+  constructor(private documentStore: DocumentStore) {}
+
+  /**
+   * Sorts categories alphabetically by label
+   * @param categories - The list of document categories to sort
+   * @returns Sorted categories array
+   */
+  sortCategoriesAlphabetically(categories: DocumentCategory[]): DocumentCategory[] {
+    return [...categories].sort((a, b) => a.label.localeCompare(b.label));
+  }
+
+  /**
+   * Sorts menu items within each category alphabetically by label
+   * @param categories - The list of document categories to sort
+   * @returns Categories with sorted menu items
+   */
+  sortMenuItemsAlphabetically(categories: DocumentCategory[]): DocumentCategory[] {
+    return categories.map(category => ({
+      ...category,
+      items: category.items ? [...category.items].sort((a, b) => a.label.localeCompare(b.label)) : category.items
+    }));
+  }
+
+  /**
+   * Sorts both categories and their menu items alphabetically
+   * @param categories - The list of document categories to sort
+   * @returns Fully sorted categories array
+   */
+  sortCategoriesAndMenuItems(categories: DocumentCategory[]): DocumentCategory[] {
+    const sortedCategories = this.sortCategoriesAlphabetically(categories);
+    return this.sortMenuItemsAlphabetically(sortedCategories);
+  }
+
+  /**
+   * Gets the category name for a given menu item _id
+   * @param menuItemId - The _id of the menu item
+   * @param categories - The list of document categories
+   * @returns The category name or null if not found
+   */
+  getMenuItemCategory(menuItemId: string, categories: DocumentCategory[]): string | null {
+    for (const category of categories) {
+      if (category.items?.some((menuItem: DocumentCategoryItem) => menuItem._id === menuItemId)) {
+        return category.label;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Gets the menu item by its _id
+   * @param menuItemId - The _id of the menu item
+   * @param categories - The list of document categories
+   * @returns The menu item or null if not found
+   */
+  getMenuItemById(menuItemId: string, categories: DocumentCategory[]): DocumentCategoryItem | null {
+    for (const category of categories) {
+      if (category.items) {
+        const item = category.items.find((menuItem: DocumentCategoryItem) => menuItem._id === menuItemId);
+        if (item) {
+          return item;
+        }
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Handles user list visibility based on menu item category
+   * @param menuItemId - The _id of the menu item
+   * @param categories - The list of document categories
+   */
+  handleUserListVisibility(menuItemId: string, categories: DocumentCategory[]): void {
+    const category = this.getMenuItemCategory(menuItemId, categories);
+    this.documentStore.setShowUserList(true);
+  }
+
+  /**
+   * Calculates total documents for a menu item
+   * @param item - The menu item
+   * @returns Total number of documents
+   */
+  getTotalDocuments(item: DocumentCategoryItem): number {
+    const status = item.status;
+    // Handle both uppercase and lowercase keys
+    const pending = status.Pending || status.pending || 0;
+    const reviewing = status.Reviewing || status.reviewing || 0;
+    const accepted = status.Accepted || status.approved || 0; // Note: approved maps to Accepted
+    const rejected = status.Rejected || status.rejected || 0;
+    
+    return pending + reviewing + accepted + rejected;
+  }
+
+
+
+  /**
+   * Gets badge value for a menu item
+   * @param item - The menu item
+   * @returns Badge value string (e.g., "2/3")
+   */
+  getBadgeValue(item: DocumentCategoryItem): string {
+    const approved = this.getApprovedDocuments(item);
+    const total = this.getTotalDocuments(item);
+    return `${approved}/${total}`;
+  }
+
+  /**
+   * Gets badge severity based on status
+   * @param item - The menu item
+   * @returns Badge severity for PrimeNG
+   */
+  getBadgeSeverity(item: DocumentCategoryItem): 'success' | 'info' | 'warning' | 'danger' {
+    const status = item.status;
+    const total = this.getTotalDocuments(item);
+    const pending = status.Pending || status.pending || 0;
+    const rejected = status.Rejected || status.rejected || 0;
+    const reviewing = status.Reviewing || status.reviewing || 0;
+    const approved = this.getApprovedDocuments(item);
+    
+    if (total === 0) return 'info';
+    if (pending > 0) return 'info';
+    if (rejected > 0) return 'danger';
+    if (reviewing > 0) return 'warning';
+    if (approved === total && total > 0) return 'success';
+    return 'warning';
+  }
+
+  /**
+   * Checks if badge should be shown for a menu item
+   * @param item - The menu item
+   * @returns True if badge should be shown
+   */
+  shouldShowBadge(item: DocumentCategoryItem): boolean {
+    return this.getTotalDocuments(item) > 0;
+  }
+
+  /**
+   * Calculates approved documents for a menu item
+   * @param item - The menu item
+   * @returns Number of approved documents
+   */
+  getApprovedDocuments(item: DocumentCategoryItem): number {
+    const status = item.status;
+    // Handle both uppercase and lowercase keys, with approved mapping to Accepted
+    return status.Accepted || status.approved || 0;
+  }
+
+  /**
+   * Checks if a menu item's section is visible in the filtered document list
+   * @param menuItemId - The ID of the menu item to check
+   * @param documentListResponse - The filtered document list response
+   * @returns True if the section is visible, false otherwise
+   */
+  isMenuItemSectionVisible(menuItemId: string, documentListResponse: DocumentListResponse[] | null, menuItemLabel?: string): boolean {
+    if (!menuItemId || !documentListResponse || documentListResponse.length === 0) {
+      return false;
+    }
+    
+    return documentListResponse.some(category => {
+      if (!category.label || !category.list || category.list.length === 0) {
+        return false;
+      }
+      
+      const categoryLabelLower = category.label.toLowerCase();
+      if (menuItemLabel) {
+        const menuItemLabelLower = menuItemLabel.toLowerCase();
+        if (categoryLabelLower === menuItemLabelLower) {
+          return true;
+        }
+        if (this.isSmartPartialMatch(menuItemLabelLower, categoryLabelLower)) {
+          return true;
+        }
+      }
+      const menuItemIdLower = menuItemId.toLowerCase();
+      if (this.isSmartPartialMatch(menuItemIdLower, categoryLabelLower)) {
+        return true;
+      }
+      
+      return false;
+    });
+  }
+
+  /**
+   * Performs smart partial matching to prevent substring conflicts
+   * @param menuLabel - The menu item label to match
+   * @param categoryLabel - The category label to match against
+   * @returns True if it's a valid partial match, false otherwise
+   */
+  private isSmartPartialMatch(menuLabel: string, categoryLabel: string): boolean {
+    // If the category label is significantly longer than menu label, it's likely a different section
+    if (categoryLabel.length > menuLabel.length + 3) {
+      return false;
+    }
+    const menuWords = menuLabel.split(/\s+/);
+    const categoryWords = categoryLabel.split(/\s+/);
+    return menuWords.every(word => 
+      categoryWords.some(catWord => 
+        catWord.toLowerCase().startsWith(word.toLowerCase()) || 
+        word.toLowerCase().startsWith(catWord.toLowerCase())
+      )
+    );
+  }
+
+
+  /**
+   * Deselects a menu item if its section is not visible in the filtered document list
+   * @param menuItemId - The ID of the menu item to check
+   * @param documentListResponse - The filtered document list response
+   * @param menuItemLabel - The label of the menu item (optional)
+   * @returns True if the menu item was deselected, false otherwise
+   */
+  deselectMenuItemIfSectionNotVisible(menuItemId: string, documentListResponse: DocumentListResponse[] | null, menuItemLabel?: string): boolean {
+    if (!this.isMenuItemSectionVisible(menuItemId, documentListResponse, menuItemLabel)) {
+      this.documentStore.setSelectedMenuItem(null);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Checks if a menu item should be selectable based on the filtered document list
+   * @param menuItemId - The ID of the menu item to check
+   * @param documentListResponse - The filtered document list response
+   * @param menuItemLabel - The label of the menu item (optional)
+   * @returns True if the menu item should be selectable, false otherwise
+   */
+  isMenuItemSelectable(menuItemId: string, documentListResponse: DocumentListResponse[] | null, menuItemLabel?: string): boolean {
+    return this.isMenuItemSectionVisible(menuItemId, documentListResponse, menuItemLabel);
+  }
+
+  /**
+   * Gets the selectability status for all menu items in categories
+   * @param categories - The document categories containing menu items
+   * @param documentListResponse - The filtered document list response
+   * @returns Map of menu item IDs to their selectability status
+   */
+  getMenuItemsSelectabilityStatus(categories: DocumentCategory[], documentListResponse: DocumentListResponse[] | null): Map<string, boolean> {
+    const selectabilityMap = new Map<string, boolean>();
+    
+    categories.forEach(category => {
+      if (category.items) {
+        category.items.forEach(item => {
+          const isSelectable = this.isMenuItemSelectable(item._id, documentListResponse);
+          selectabilityMap.set(item._id, isSelectable);
+        });
+      }
+    });
+    
+    return selectabilityMap;
+  }
+
+  /**
+   * Updates menu items with selectability status
+   * @param categories - The document categories containing menu items
+   * @param documentListResponse - The filtered document list response
+   * @returns Updated categories with selectability information
+   */
+  updateMenuItemsWithSelectabilityStatus(categories: DocumentCategory[], documentListResponse: DocumentListResponse[] | null): DocumentCategory[] {
+    return categories.map(category => ({
+      ...category,
+      items: category.items?.map(item => ({
+        ...item,
+        isSelectable: this.isMenuItemSelectable(item._id, documentListResponse, item.label)
+      }))
+    }));
+  }
+} 

package/src/lib/document/services/document-scroll.service.ts

@@ -0,0 +1,138 @@
+import { Injectable, OnDestroy } from '@angular/core';
+import { DocumentStore } from '../state/document.store';
+
+export interface ScrollTarget {
+  element: Element;
+  menuItemId: string;
+}
+
+@Injectable({
+  providedIn: 'root'
+})
+export class DocumentScrollService implements OnDestroy {
+  private sectionObserver: IntersectionObserver | null = null;
+  private currentObservedSection: Element | null = null;
+  private isScrolling: boolean = false;
+  private scrollHandler: (() => void) | null = null;
+  private scrollTimeout: any = null;
+
+  constructor(private documentStore: DocumentStore) {}
+
+  /**
+   * Sets up scroll event listeners to track scrolling state
+   * @param containerElement - The container element to monitor for scroll events
+   */
+  setupScrollListeners(containerElement: HTMLElement): void {
+    if (containerElement) {
+      this.scrollHandler = () => {
+        this.isScrolling = true;
+        if (this.scrollTimeout) {
+          clearTimeout(this.scrollTimeout);
+        }
+        this.scrollTimeout = setTimeout(() => {
+          this.isScrolling = false;
+        }, 150);
+      };
+      
+      containerElement.addEventListener('scroll', this.scrollHandler);
+    }
+  }
+
+  /**
+   * Sets up intersection observer to detect when the selected section scrolls out of view
+   * @param sectionElement - The section element to observe
+   * @param menuItemId - The ID of the selected menu item
+   */
+  setupSectionObserver(sectionElement: Element, menuItemId: string): void {
+    this.disconnectSectionObserver();
+    
+    setTimeout(() => {
+      if (!menuItemId || this.isScrolling) {
+        return;
+      }
+      
+      this.sectionObserver = new IntersectionObserver(
+        (entries) => {
+          entries.forEach(entry => {
+            if (entry.intersectionRatio === 0 ) {
+              setTimeout(() => {
+                if (this.sectionObserver && menuItemId && entry.intersectionRatio === 0) {
+                  this.documentStore.setSelectedMenuItem(null);
+                  this.disconnectSectionObserver();
+                }
+              }, 200);
+            }
+          });
+        },
+        {
+          threshold: [0, 0.1, 0.5, 1],
+          rootMargin: '0px'
+        }
+      );
+
+      // Always start observing regardless of current visibility
+      // The IntersectionObserver will handle visibility changes automatically
+      this.sectionObserver.observe(sectionElement);
+      this.currentObservedSection = sectionElement;
+    }, 1200);
+  }
+
+  /**
+   * Disconnects the section observer
+   */
+  disconnectSectionObserver(): void {
+    if (this.sectionObserver) {
+      this.sectionObserver.disconnect();
+      this.sectionObserver = null;
+      this.currentObservedSection = null;
+    }
+  }
+
+  /**
+   * Sets the scrolling flag to true (called when starting a scroll operation)
+   */
+  setScrolling(): void {
+    this.isScrolling = true;
+  }
+
+  /**
+   * Resets the scrolling flag after a specified delay
+   * @param delay - Delay in milliseconds before resetting the flag
+   */
+  resetScrollingAfterDelay(delay: number = 1200): void {
+    setTimeout(() => {
+      this.isScrolling = false;
+    }, delay);
+  }
+
+  /**
+   * Gets the current scrolling state
+   */
+  get isCurrentlyScrolling(): boolean {
+    return this.isScrolling;
+  }
+
+  /**
+   * Cleans up all resources
+   */
+  ngOnDestroy(): void {
+    this.disconnectSectionObserver();
+    this.cleanupScrollListeners();
+  }
+
+  /**
+   * Removes scroll event listeners
+   * @param containerElement - The container element to remove listeners from
+   */
+  cleanupScrollListeners(containerElement?: HTMLElement): void {
+    if (containerElement && this.scrollHandler) {
+      containerElement.removeEventListener('scroll', this.scrollHandler);
+      this.scrollHandler = null;
+    }
+    
+    if (this.scrollTimeout) {
+      clearTimeout(this.scrollTimeout);
+      this.scrollTimeout = null;
+    }
+  }
+}

package/src/lib/document/services/document-severity.service.ts

@@ -0,0 +1,98 @@
+import { Injectable } from '@angular/core';
+import { SHARED } from '../../../Shared/constant/SHARED';
+import { DocumentListItem } from '../models/document-list-response.model';
+
+export type SeverityLevel = 'success' | 'info' | 'warning' | 'danger';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class DocumentSeverityService {
+
+  constructor() {}
+
+  /**
+   * Calculate severity for a list of documents based on their statuses
+   * This is the centralized severity calculation logic used across the application
+   * @param documents The list of documents to calculate severity for
+   * @returns Severity level for the document list
+   */
+  calculateSeverity(documents: DocumentListItem[]): SeverityLevel {
+    if (!documents || documents.length === 0) {
+      return 'info';
+    }
+
+    const total = documents.length;
+    const pending = documents.filter(doc => 
+      doc.status.toLowerCase() === SHARED.PENDING_STATUS
+    ).length;
+    const rejected = documents.filter(doc => 
+      doc.status.toLowerCase() === SHARED.REJECTED_STATUS
+    ).length;
+    const reviewing = documents.filter(doc => 
+      doc.status.toLowerCase() === SHARED.REVIEWING_STATUS
+    ).length;
+    const approved = documents.filter(doc => 
+      doc.status.toLowerCase() === SHARED.APPROVED_STATUS || 
+      doc.status.toLowerCase() === SHARED.UPLOADED_STATUS
+    ).length;
+    
+    // Severity calculation logic:
+    // - info (grey): No documents or has pending documents
+    // - danger (red): Has rejected documents
+    // - warning (orange): Has documents under review or mixed status
+    // - success (green): All documents are approved
+    if (total === 0) return 'info';
+    if (pending > 0) return 'info';
+    if (rejected > 0) return 'danger';
+    if (reviewing > 0) return 'warning';
+    if (approved === total && total > 0) return 'success';
+    return 'warning';
+  }
+
+  /**
+   * Calculate severity for a category based on document statuses
+   * @param category The document category
+   * @returns Severity level for the category
+   */
+  calculateCategorySeverity(category: any): SeverityLevel {
+    if (!category.list || category.list.length === 0) {
+      return 'info';
+    }
+    return this.calculateSeverity(category.list);
+  }
+
+  /**
+   * Calculate severity for a menu item based on status counts
+   * @param status The status object with counts
+   * @returns Severity level for the menu item
+   */
+  calculateMenuItemSeverity(status: any): SeverityLevel {
+    const total = this.getTotalFromStatus(status);
+    const pending = status.Pending || status.pending || 0;
+    const rejected = status.Rejected || status.rejected || 0;
+    const reviewing = status.Reviewing || status.reviewing || 0;
+    const approved = status.Accepted || status.approved || 0;
+    
+    if (total === 0) return 'info';
+    if (pending > 0) return 'info';
+    if (rejected > 0) return 'danger';
+    if (reviewing > 0) return 'warning';
+    if (approved === total && total > 0) return 'success';
+    return 'warning';
+  }
+
+  /**
+   * Helper method to get total count from status object
+   * @param status The status object
+   * @returns Total count
+   */
+  private getTotalFromStatus(status: any): number {
+    const pending = status.Pending || status.pending || 0;
+    const reviewing = status.Reviewing || status.reviewing || 0;
+    const accepted = status.Accepted || status.approved || 0;
+    const rejected = status.Rejected || status.rejected || 0;
+    
+    return pending + reviewing + accepted + rejected;
+  }
+}

package/src/lib/document/services/document-table-builder.service.ts

@@ -0,0 +1,82 @@
+import { Injectable } from '@angular/core';
+import { DocumentListResponse, DocumentListItem } from '../models/document-list-response.model';
+import { SHARED } from '../../../Shared/constant/SHARED';
+import { TableData } from '../../../Shared/components/table-primary/table-primary.model';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class DocumentTableBuilderService {
+
+  constructor() { }
+
+  /**
+   * Builds a single table from document list items
+   * @param documents Array of document list items
+   * @returns TableData object
+   */
+  buildDocumentTable(documents: DocumentListItem[]): TableData {
+    const columns = SHARED.DOCUMENT_TABLE_COLUMNS.filter(col => col.type !== SHARED.ACTIONS);
+    
+    return {
+      columns: columns,
+      data: documents
+    };
+  }
+
+  /**
+   * Gets completion count for a category
+   * @param category Document category
+   * @returns Completion string (e.g., "2/4")
+   */
+  getCompletionCount(category: DocumentListResponse): string {
+    const total = category.list.length;
+    const completed = category.list.filter(doc => 
+      doc.status.toLowerCase() === SHARED.APPROVED || 
+      doc.status.toLowerCase() === SHARED.UPLOADED
+    ).length;
+    return `${completed}/${total}`;
+  }
+
+  /**
+   * Gets pending document count for a category
+   * @param category Document category
+   * @returns Number of pending documents
+   */
+  getPendingDocumentCount(category: DocumentListResponse): number {
+    return category.totalDocs - category.acceptedDocs;
+  }
+
+  /**
+   * Gets approved document count for a category
+   * @param category Document category
+   * @returns Number of approved documents
+   */
+  getApprovedDocumentCount(category: DocumentListResponse): number {
+    return category.acceptedDocs;
+  }
+
+  /**
+   * Transforms document model to document list item
+   * @param documents Array of DocumentModel
+   * @returns Array of DocumentListItem
+   */
+  transformDocumentModelToListItem(documents: any[]): DocumentListItem[] {
+    return documents.map(doc => {
+      return {
+        _id: doc._id || SHARED.EMPTY,
+        fileName: doc.fileName || SHARED.EMPTY,
+        docName: doc.docName || doc.documentName || SHARED.EMPTY,
+        fileSize: doc.fileSize || SHARED.EMPTY,
+        documentUrl: doc.documentUrl || doc.url || SHARED.EMPTY,
+        status: doc.status || SHARED.PENDING,
+        uploadedOn: doc.uploadedOn || doc.uploadDate || SHARED.EMPTY,
+        ownerName: doc.ownerName || doc.applicantName || SHARED.EMPTY,
+        contentType: doc.contentType || SHARED.EMPTY,
+        isUploaded: doc.isUploaded || false,
+        documentType: doc.documentType || SHARED.EMPTY,
+        aliasName: doc.aliasName || SHARED.EMPTY
+      };
+    });
+  }
+}