cat-documents-ng 1.0.6 → 1.0.7

package/src/lib/document/services/document-upload-business.service.ts

@@ -1,326 +0,0 @@
-import { Injectable } from '@angular/core';
-import { Observable, Subject, takeUntil } from 'rxjs';
-import { DocumentHttpService } from './document-http.service';
-import { FileFormatService } from './file-format.service';
-import { UserListModel } from '../models/user-list.model';
-import { DocumentCategory } from '../models/document-category.model';
-import { DocumentTypeModel } from '../models/document-type.model';
-import { SHARED } from '../../../Shared/constant/SHARED';
-import { UploadedFileResponse } from '../models/uploaded-file-response.model';
-
-export interface UploadedFile {
-  file: File;
-  formattedSize?: string;
-  progress?: number;
-  uploadResponse?: UploadedFileResponse; // Store the upload response for later use
-  url?: string; // Store the file URL from upload response
-  contentType?: string;
-  fileName?: string; // Store the file name from upload response
-  size?: string; // Store the formatted size from upload response
-}
-
-export interface DocumentUploadPayload {
-  source: 'Applicant' | 'Application';
-  categoryId: string;
-  documentTypeId: string;
-  applicantId?: string;
-  contextId: string;
-  documents: {
-    fileName: string;
-    fileSize: number;
-    uploadedFileId?: string;
-    url?: string; // Store the file URL from upload response
-    contentType?: string;
-    size?: string; // Store the formatted size from upload response
-  }[];
-}
-
-@Injectable({
-  providedIn: 'root'
-})
-export class DocumentUploadBusinessService {
-  private destroy$ = new Subject<void>();
-
-  constructor(
-    private documentHttpService: DocumentHttpService,
-    private fileFormatService: FileFormatService
-  ) {}
-
-  /**
-   * Loads applicants for a given context ID
-   */
-  loadApplicants(contextId: string): Observable<UserListModel[]> {
-    return this.documentHttpService.getUserListByContextId(contextId);
-  }
-
-  /**
-   * Loads categories based on assignment type
-   */
-  loadCategories(assignmentType: string): Observable<DocumentCategory[]> {
-    return this.documentHttpService.getCategoriesBySource(assignmentType);
-  }
-
-  /**
-   * Loads document types based on category
-   */
-  loadDocumentTypes(categoryId: string): Observable<DocumentTypeModel[]> {
-    return this.documentHttpService.getDocumentTypesByCategory(categoryId);
-  }
-
-  /**
-   * Filters applicants based on assignment type
-   */
-  filterApplicants(applicantList: UserListModel[], assignmentType: 'Applicant' | 'Application'): UserListModel[] {
-    if (assignmentType === SHARED.APPLICANT) {
-      return applicantList.filter(applicant => applicant.name !== SHARED.APPLICATION_DOCS);
-    } else {
-      return applicantList.filter(applicant => applicant.name === SHARED.APPLICATION_DOCS);
-    }
-  }
-
-  /**
-   * Helper method to validate form data and return validation result
-   */
-  private validateFormData(
-    assignmentType: 'Applicant' | 'Application' | null,
-    selectedCategory: string,
-    selectedDocumentType: string,
-    selectedApplicant: string,
-    uploadedFiles: UploadedFile[],
-    categoryOptions: DocumentCategory[],
-    documentTypeOptions: DocumentTypeModel[]
-  ): { isValid: boolean; message: string } {
-    // Check assignment type
-    if (!assignmentType) {
-      return { isValid: false, message: SHARED.VALIDATION_SELECT_ASSIGNMENT_TYPE };
-    }
-
-    // Check if options are loaded
-    if (!categoryOptions.length || !documentTypeOptions.length) {
-      return { isValid: false, message: SHARED.VALIDATION_OPTIONS_NOT_LOADED };
-    }
-
-    // Check category
-    if (!selectedCategory) {
-      return { isValid: false, message: SHARED.VALIDATION_SELECT_CATEGORY };
-    }
-
-    // Check document type
-    if (!selectedDocumentType) {
-      return { isValid: false, message: SHARED.VALIDATION_SELECT_DOCUMENT_TYPE };
-    }
-
-    // Check files
-    if (uploadedFiles.length === 0) {
-      return { isValid: false, message: SHARED.VALIDATION_UPLOAD_AT_LEAST_ONE };
-    }
-
-    // Check if all files are uploaded
-    const incompleteFiles = uploadedFiles.filter(file => file.progress !== 100);
-    if (incompleteFiles.length > 0) {
-      return { isValid: false, message: SHARED.VALIDATION_WAIT_FOR_UPLOAD };
-    }
-
-    // For Applicant type, check applicant selection
-    if (assignmentType === SHARED.APPLICANT && !selectedApplicant) {
-      return { isValid: false, message: SHARED.VALIDATION_SELECT_APPLICANT };
-    }
-
-    return { isValid: true, message: SHARED.VALIDATION_ALL_FIELDS_COMPLETED };
-  }
-
-  /**
-   * Validates form data
-   */
-  validateForm(
-    assignmentType: 'Applicant' | 'Application' | null,
-    selectedCategory: string,
-    selectedDocumentType: string,
-    selectedApplicant: string,
-    uploadedFiles: UploadedFile[],
-    categoryOptions: DocumentCategory[],
-    documentTypeOptions: DocumentTypeModel[]
-  ): boolean {
-    return this.validateFormData(
-      assignmentType,
-      selectedCategory,
-      selectedDocumentType,
-      selectedApplicant,
-      uploadedFiles,
-      categoryOptions,
-      documentTypeOptions
-    ).isValid;
-  }
-
-  /**
-   * Checks if save button should be disabled
-   */
-  isSaveButtonDisabled(
-    assignmentType: 'Applicant' | 'Application' | null,
-    selectedCategory: string,
-    selectedDocumentType: string,
-    selectedApplicant: string,
-    uploadedFiles: UploadedFile[],
-    isSaving: boolean
-  ): boolean {
-    if (isSaving) {
-      return true;
-    }
-
-    // For button state, we only need to check if required fields are filled
-    // We don't need to validate if options are loaded
-    if (!assignmentType) {
-      return true;
-    }
-
-    if (!selectedCategory) {
-      return true;
-    }
-
-    if (!selectedDocumentType) {
-      return true;
-    }
-
-    if (uploadedFiles.length === 0) {
-      return true;
-    }
-
-    // Check if all files are uploaded
-    const incompleteFiles = uploadedFiles.filter(file => file.progress !== 100);
-    if (incompleteFiles.length > 0) {
-      return true;
-    }
-
-    // For Applicant type, check applicant selection
-    if (assignmentType === SHARED.APPLICANT && !selectedApplicant) {
-      return true;
-    }
-
-    return false; // Button should be enabled
-  }
-
-  /**
-   * Validates the complete payload before save
-   */
-  validatePayload(
-    assignmentType: 'Applicant' | 'Application' | null,
-    selectedCategory: string,
-    selectedDocumentType: string,
-    selectedApplicant: string,
-    uploadedFiles: UploadedFile[]
-  ): { isValid: boolean; message: string } {
-    // Check assignment type
-    if (!assignmentType) {
-      return { isValid: false, message: SHARED.VALIDATION_SELECT_ASSIGNMENT_TYPE };
-    }
-
-    // Check category
-    if (!selectedCategory) {
-      return { isValid: false, message: SHARED.VALIDATION_SELECT_CATEGORY };
-    }
-
-    // Check document type
-    if (!selectedDocumentType) {
-      return { isValid: false, message: SHARED.VALIDATION_SELECT_DOCUMENT_TYPE };
-    }
-
-    // Check files
-    if (uploadedFiles.length === 0) {
-      return { isValid: false, message: SHARED.VALIDATION_UPLOAD_AT_LEAST_ONE };
-    }
-
-    // Check if all files are uploaded
-    const incompleteFiles = uploadedFiles.filter(file => file.progress !== 100);
-    if (incompleteFiles.length > 0) {
-      return { isValid: false, message: SHARED.VALIDATION_WAIT_FOR_UPLOAD };
-    }
-
-    // For Applicant type, check applicant selection
-    if (assignmentType === SHARED.APPLICANT && !selectedApplicant) {
-      return { isValid: false, message: SHARED.VALIDATION_SELECT_APPLICANT };
-    }
-
-    return { isValid: true, message: SHARED.VALIDATION_ALL_FIELDS_COMPLETED };
-  }
-
-  /**
-   * Prepares upload payload
-   */
-  prepareUploadPayload(
-    assignmentType: 'Applicant' | 'Application',
-    selectedCategory: string,
-    selectedDocumentType: string,
-    selectedApplicant: string,
-    uploadedFiles: UploadedFile[],
-    contextId: string
-  ): DocumentUploadPayload {
-    const payload: DocumentUploadPayload = {
-      source: assignmentType,
-      categoryId: selectedCategory,
-      documentTypeId: selectedDocumentType,
-      contextId,
-      documents: uploadedFiles.map(file => ({
-        fileName: file.file.name,
-        fileSize: file.file.size,
-        url: file.url,
-        contentType: file.contentType,
-        size: file.size,
-        uploadedFileId: file.uploadResponse?.id || file.uploadResponse?.fileName
-      }))
-    };
-
-    // For Applicant type, include the applicant ID
-    if (assignmentType === SHARED.APPLICANT && selectedApplicant) {
-      payload.applicantId = selectedApplicant;
-    }
-
-    return payload;
-  }
-
-  /**
-   * Saves document upload
-   */
-  saveDocumentUpload(payload: DocumentUploadPayload): Observable<any> {
-    return this.documentHttpService.saveDocumentUpload(payload);
-  }
-
-  /**
-   * Formats file size
-   */
-  formatFileSize(fileSize: number, config: any): string {
-    return this.fileFormatService.formatFileSize(fileSize, config);
-  }
-
-  /**
-   * Creates uploaded file object
-   */
-  createUploadedFile(file: File, formattedSize: string): UploadedFile {
-    return {
-      file,
-      formattedSize,
-      progress: SHARED.UPLOAD_PROGRESS_10 
-    };
-  }
-
-  /**
-   * Resets form data to initial state
-   */
-  getInitialFormState() {
-    return {
-      selectedAssignmentType: null,
-      selectedApplicant: null,
-      selectedCategory: null,
-      selectedDocumentType: null,
-      uploadedFiles: [] as UploadedFile[],
-      isFormValid: false
-    };
-  }
-
-  /**
-   * Destroys the service
-   */
-  destroy(): void {
-    this.destroy$.next();
-    this.destroy$.complete();
-  }
-}

package/src/lib/document/services/document-upload-data.service.ts

@@ -1,82 +0,0 @@
-import { Injectable } from '@angular/core';
-import { Observable, Subject, takeUntil } from 'rxjs';
-import { DocumentUploadBusinessService } from './document-upload-business.service';
-import { DocumentUploadFormService } from './document-upload-form.service';
-import { UserListModel } from '../models/user-list.model';
-import { DocumentCategory } from '../models/document-category.model';
-import { DocumentTypeModel } from '../models/document-type.model';
-
-export interface DataLoadingState {
-  isLoadingApplicants: boolean;
-  isLoadingCategories: boolean;
-  isLoadingDocumentTypes: boolean;
-}
-
-@Injectable({
-  providedIn: 'root'
-})
-export class DocumentUploadDataService {
-  private destroy$ = new Subject<void>();
-
-  constructor(
-    private businessService: DocumentUploadBusinessService,
-    private formService: DocumentUploadFormService
-  ) {}
-
-  /**
-   * Loads applicants and handles the response
-   */
-  loadApplicants(
-    contextId: string,
-    onSuccess: (applicants: UserListModel[]) => void,
-    onError: (error: any) => void
-  ): Observable<UserListModel[]> {
-    if (!this.formService.validateContextId(contextId, 'Context ID is required to load applicants.')) {
-      return new Observable();
-    }
-    return this.businessService.loadApplicants(contextId);
-  }
-
-  /**
-   * Loads categories and handles the response
-   */
-  loadCategories(
-    assignmentType: string,
-    onSuccess: (categories: DocumentCategory[]) => void,
-    onError: (error: any) => void
-  ): Observable<DocumentCategory[]> {
-    if (!assignmentType) {
-      return new Observable();
-    }
-    return this.businessService.loadCategories(assignmentType);
-  }
-
-  /**
-   * Loads document types and handles the response
-   */
-  loadDocumentTypes(
-    categoryId: string,
-    onSuccess: (documentTypes: DocumentTypeModel[]) => void,
-    onError: (error: any) => void
-  ): Observable<DocumentTypeModel[]> {
-    return this.businessService.loadDocumentTypes(categoryId);
-  }
-
-  /**
-   * Handles applicants loaded successfully
-   */
-  handleApplicantsLoaded(
-    applicants: UserListModel[],
-    assignmentType: 'Applicant' | 'Application' | null
-  ): UserListModel[] {
-    return this.businessService.filterApplicants(applicants, assignmentType!);
-  }
-
-  /**
-   * Destroys the service
-   */
-  destroy(): void {
-    this.destroy$.next();
-    this.destroy$.complete();
-  }
-}

package/src/lib/document/services/document-upload-form.service.ts

@@ -1,149 +0,0 @@
-import { Injectable } from '@angular/core';
-import { MessageService } from 'primeng/api';
-import { UploadedFile } from './document-upload-business.service';
-import { SHARED } from '../../../Shared/constant/SHARED';
-
-@Injectable({
-  providedIn: 'root'
-})
-export class DocumentUploadFormService {
-  constructor(private messageService: MessageService) {}
-
-  /**
-   * Shows error message
-   */
-  showErrorMessage(summary: string, detail: string): void {
-    this.messageService.add({
-      severity: 'error',
-      summary,
-      detail
-    });
-  }
-
-  /**
-   * Shows warning message
-   */
-  showWarningMessage(summary: string, detail: string): void {
-    this.messageService.add({
-      severity: 'warn',
-      summary,
-      detail
-    });
-  }
-
-  /**
-   * Shows success message
-   */
-  showSuccessMessage(summary: string, detail: string): void {
-    this.messageService.add({
-      severity: 'success',
-      summary,
-      detail
-    });
-  }
-
-  /**
-   * Helper method to validate required fields and show appropriate messages
-   */
-  private validateRequiredFieldsWithMessages(
-    assignmentType: 'Applicant' | 'Application' | null,
-    selectedApplicant: string,
-    selectedCategory: string,
-    selectedDocumentType: string,
-    uploadedFiles: UploadedFile[]
-  ): { isValid: boolean; field: string | null } {
-    if (assignmentType === 'Applicant' && !selectedApplicant) {
-      return { isValid: false, field: 'applicant' };
-    }
-
-    if (!selectedCategory) {
-      return { isValid: false, field: 'category' };
-    }
-
-    if (!selectedDocumentType) {
-      return { isValid: false, field: 'documentType' };
-    }
-
-    if (uploadedFiles.length === 0) {
-      return { isValid: false, field: 'documents' };
-    }
-
-    return { isValid: true, field: null };
-  }
-
-  /**
-   * Validates required fields for upload
-   */
-  validateRequiredFields(
-    assignmentType: 'Applicant' | 'Application' | null,
-    selectedApplicant: string,
-    selectedCategory: string,
-    selectedDocumentType: string,
-    uploadedFiles: UploadedFile[]
-  ): boolean {
-    const validation = this.validateRequiredFieldsWithMessages(
-      assignmentType,
-      selectedApplicant,
-      selectedCategory,
-      selectedDocumentType,
-      uploadedFiles
-    );
-
-    if (!validation.isValid) {
-      this.showValidationMessage(validation.field!);
-    }
-
-    return validation.isValid;
-  }
-
-  /**
-   * Shows appropriate validation message based on the field that failed
-   */
-  private showValidationMessage(field: string): void {
-    const messages: Record<string, { summary: string; detail: string }> = {
-      applicant: { 
-        summary: SHARED.VALIDATION_NO_APPLICANT_SELECTED, 
-        detail: SHARED.VALIDATION_NO_APPLICANT_DETAIL 
-      },
-      category: { 
-        summary: SHARED.VALIDATION_NO_CATEGORY_SELECTED, 
-        detail: SHARED.VALIDATION_NO_CATEGORY_DETAIL 
-      },
-      documentType: { 
-        summary: SHARED.VALIDATION_NO_DOCUMENT_TYPE_SELECTED, 
-        detail: SHARED.VALIDATION_NO_DOCUMENT_TYPE_DETAIL 
-      },
-      documents: { 
-        summary: SHARED.VALIDATION_NO_DOCUMENTS_UPLOADED, 
-        detail: SHARED.VALIDATION_NO_DOCUMENTS_DETAIL 
-      }
-    };
-
-    const message = messages[field];
-    if (message) {
-      this.showWarningMessage(message.summary, message.detail);
-    }
-  }
-
-  /**
-   * Validates form completeness
-   */
-  validateFormCompleteness(): boolean {
-    this.showWarningMessage(
-      SHARED.VALIDATION_FORM_INCOMPLETE, 
-      SHARED.VALIDATION_FORM_INCOMPLETE_DETAIL
-    );
-    return false;
-  }
-
-  /**
-   * Validates context ID presence
-   */
-  validateContextId(contextId: string, message: string): boolean {
-    if (!contextId) {
-      this.showErrorMessage(SHARED.VALIDATION_MISSING_REQUIRED_DATA, message);
-      return false;
-    }
-    return true;
-  }
-}

package/src/lib/document/services/document-upload.service.spec.ts

@@ -1,99 +0,0 @@
-import { fakeAsync, TestBed, tick } from '@angular/core/testing';
-import { DocumentUploadService } from './document-upload.service';
-import { DocumentService } from '../state/document.service';
-import { DocumentStore } from '../state/document.store';
-import { MessageService } from 'primeng/api';
-import { of, throwError } from 'rxjs';
-import { SHARED } from '../../../Shared/constant/SHARED';
-
-describe('DocumentUploadService', () => {
-  let service: DocumentUploadService;
-  let mockDocumentService: jasmine.SpyObj<DocumentService>;
-  let mockDocumentStore: jasmine.SpyObj<DocumentStore>;
-  let mockMessageService: jasmine.SpyObj<MessageService>;
-
-  beforeEach(() => {
-    mockDocumentService = jasmine.createSpyObj('DocumentService', ['create']);
-    mockDocumentStore = jasmine.createSpyObj('DocumentStore', ['setUploadedDocumentFiles', 'setMessage']);
-    mockMessageService = jasmine.createSpyObj('MessageService', ['add']);
-
-    TestBed.configureTestingModule({
-      providers: [
-        DocumentUploadService,
-        { provide: DocumentService, useValue: mockDocumentService },
-        { provide: DocumentStore, useValue: mockDocumentStore },
-        { provide: MessageService, useValue: mockMessageService }
-      ]
-    });
-
-    service = TestBed.inject(DocumentUploadService);
-  });
-
-  it('should be created', () => {
-    expect(service).toBeTruthy();
-  });
-
-  it('should set uploadedFile, contextId, docName, and docTypeId when getUploadFileData is called', () => {
-    const mockFile = new File(['test content'], 'test.pdf', { type: 'application/pdf' });
-    const contextId = '1234';
-    
-    service.getUploadFileData(mockFile, contextId);
-    
-    expect(service.uploadedFile).toBe(mockFile);
-    expect(service.contextId).toBe(contextId);
-  });
-
-  it('should set document name and type when getDocumentNameAndType is called', () => {
-    const documentName = 'Test Document';
-    const documentTypeId = '5678';
-  
-    service.getDocumentNameAndType(documentTypeId);
-  
-    expect(service.docName).toBe(SHARED.EMPTY);
-    expect(service.docTypeId).toBe(documentTypeId);
-  });
-  
-  
-
-  it('should handle null formData in handleTemplatedUpload', () => {
-    const mockFile = new File(['test content'], 'test.pdf', { type: 'application/pdf' });
-    const contextId = '1234';
-    const documentName = 'Test Document';
-    const documentTypeId = '5678';
-    service.getUploadFileData(mockFile, contextId);
-    service.getDocumentNameAndType(documentTypeId);
-    spyOn(service, 'handleCreateFormData').and.returnValue(null);
-    service.handleTemplatedUpload();
-    expect(mockMessageService.add).toHaveBeenCalledWith({
-      severity: 'error',
-      summary: 'Form Data Missing',
-      detail: 'Required form data is missing. Please ensure the document and all required fields are provided.'
-    });
-  });
-  
-
-  it('should return null from handleCreateFormData if data is incomplete', () => {
-    const formData = service.handleCreateFormData();
-    expect(formData).toBeNull();
-  });
-
-  it('should call documentService.create and set uploaded files when handleTemplatedUpload is called', () => {
-    const mockFile = new File(['test content'], 'test.pdf', { type: 'application/pdf' });
-    const contextId = '1234';
-    const documentName = 'Test Document';
-    const documentTypeId = '5678';
-    const formData = new FormData();
-    formData.append(SHARED.FILE, mockFile);
-    
-    service.getUploadFileData(mockFile, contextId);
-    service.getDocumentNameAndType(documentTypeId);
-    
-    mockDocumentService.create.and.returnValue(of({ fileId: 'abcd1234' }));
-    
-    service.handleTemplatedUpload();
-    
-    expect(mockDocumentService.create).toHaveBeenCalledWith(formData);
-    expect(mockDocumentStore.setUploadedDocumentFiles).toHaveBeenCalled();
-  });
-
-});