cat-documents-ng 1.0.4 → 1.0.6

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

@@ -0,0 +1,326 @@
+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

@@ -0,0 +1,82 @@
+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

@@ -0,0 +1,149 @@
+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

@@ -0,0 +1,99 @@
+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();
+  });
+
+});