From 43e380e5c10a68be0f381a0dbdad71e13e55ada3 Mon Sep 17 00:00:00 2001 From: admin Date: Sun, 29 Mar 2026 19:04:24 +0700 Subject: [PATCH] 690329:1904 Fixing revision number Kimi K2.5 #01 --- ...119442391-1908b04cd11e739233ee8977de00dc57 | Bin 71038 -> 71015 bytes ...rvicespec_3ec95775e6a66568410dc80a476cb50b | 561 +++++++++++ ...espec_3ec95775e6a66568410dc80a476cb50b.map | 1 + ...ceservice_502139c633196704eef09d9c7ce64dc0 | 893 ++++++++++++++++++ ...rvice_502139c633196704eef09d9c7ce64dc0.map | 1 + ...ceservice_5585ce2f5626b5a93fd64e63909b087f | 893 ++++++++++++++++++ ...rvice_5585ce2f5626b5a93fd64e63909b087f.map | 1 + ...rvicespec_6e17e53289c744ad0b09ce4420c50e0e | 561 +++++++++++ ...espec_6e17e53289c744ad0b09ce4420c50e0e.map | 1 + ...ceservice_d8463801745469340085197633f7ae6b | 893 ++++++++++++++++++ ...rvice_d8463801745469340085197633f7ae6b.map | 1 + ...cac696b99-da39a3ee5e6b4b0d3255bfef95601890 | 2 +- .../correspondence.service.spec.ts | 292 ++++++ .../correspondence/correspondence.service.ts | 15 +- .../01-03-modules/01-03-02-correspondence.md | 8 +- 15 files changed, 4120 insertions(+), 3 deletions(-) create mode 100644 backend/src/.jest-cache/jest-transform-cache-60cab15b743c6776f41d29bcac696b99-12533232bd0f05f65688e7a7764bf3fb/3e/correspondenceservicespec_3ec95775e6a66568410dc80a476cb50b create mode 100644 backend/src/.jest-cache/jest-transform-cache-60cab15b743c6776f41d29bcac696b99-12533232bd0f05f65688e7a7764bf3fb/3e/correspondenceservicespec_3ec95775e6a66568410dc80a476cb50b.map create mode 100644 backend/src/.jest-cache/jest-transform-cache-60cab15b743c6776f41d29bcac696b99-12533232bd0f05f65688e7a7764bf3fb/50/correspondenceservice_502139c633196704eef09d9c7ce64dc0 create mode 100644 backend/src/.jest-cache/jest-transform-cache-60cab15b743c6776f41d29bcac696b99-12533232bd0f05f65688e7a7764bf3fb/50/correspondenceservice_502139c633196704eef09d9c7ce64dc0.map create mode 100644 backend/src/.jest-cache/jest-transform-cache-60cab15b743c6776f41d29bcac696b99-12533232bd0f05f65688e7a7764bf3fb/55/correspondenceservice_5585ce2f5626b5a93fd64e63909b087f create mode 100644 backend/src/.jest-cache/jest-transform-cache-60cab15b743c6776f41d29bcac696b99-12533232bd0f05f65688e7a7764bf3fb/55/correspondenceservice_5585ce2f5626b5a93fd64e63909b087f.map create mode 100644 backend/src/.jest-cache/jest-transform-cache-60cab15b743c6776f41d29bcac696b99-12533232bd0f05f65688e7a7764bf3fb/6e/correspondenceservicespec_6e17e53289c744ad0b09ce4420c50e0e create mode 100644 backend/src/.jest-cache/jest-transform-cache-60cab15b743c6776f41d29bcac696b99-12533232bd0f05f65688e7a7764bf3fb/6e/correspondenceservicespec_6e17e53289c744ad0b09ce4420c50e0e.map create mode 100644 backend/src/.jest-cache/jest-transform-cache-60cab15b743c6776f41d29bcac696b99-12533232bd0f05f65688e7a7764bf3fb/d8/correspondenceservice_d8463801745469340085197633f7ae6b create mode 100644 backend/src/.jest-cache/jest-transform-cache-60cab15b743c6776f41d29bcac696b99-12533232bd0f05f65688e7a7764bf3fb/d8/correspondenceservice_d8463801745469340085197633f7ae6b.map diff --git a/backend/src/.jest-cache/haste-map-60cab15b743c6776f41d29bcac696b99-0ca4a1d6e3dfec1d63b61b0119442391-1908b04cd11e739233ee8977de00dc57 b/backend/src/.jest-cache/haste-map-60cab15b743c6776f41d29bcac696b99-0ca4a1d6e3dfec1d63b61b0119442391-1908b04cd11e739233ee8977de00dc57 index 75295316a61870ba7f7c5a17c05338d7bb34d5be..cf5c0f131d48e7bb3b5139715fea3cfed677fe2a 100644 GIT binary patch delta 1219 zcmYjPeNfa@6y^SQUHC1FyRf_Ng0R3QnvRIAH8i5Irj;-#LPeG%N`jwIB4}udj^oE< zBa%mYDT6YhA|f-$O%`D#pfpJ(&~Ypk(G;*E4YV|Iv|Z7e-XCx7x%ZuW-aYR*3Tj<6T`6+I+jP%r_n7Iz0~P z6J6MgpBOq+IO?|$VHP9z4c|zvU^7+*RUtEY6O6&LVGB8d3d>TyACgAs54OWI>=@6n z9+vn_d6I;VPMKT6+LZxQR926f9tE*+`R7-^Hq*nsa=x|4O4jR0+&_W;7!yDUiB=-! z(;+CCtik1?p==!cl7iE1wS@R+Gg4j+fK&G64Utv_a_ij*El+!SK%!UB-e7V=wAww9 zY4;jFs8)4U`trG&efveX+D;X&%Vw^$Kay1AM|h~LehH5w{X`7;Y zR**!Ypjjqvey7rtY-mpnLBU*a_dxh;UL%FOGh8s&Ni_OtxO9GZxUwKFE}!4d|3}F? z3VRgFMmJo$Yk|aZm@e_PqA!Ry@7vSAJ2oA^9tG;0v0dhn_US}Zkab}MN1UJHI&|)90lvC|)xD_T?~>#(lLhmDsLWc>b{KbPLh zQMi4s=*@$v_j4ZoXSjs+JITnsZ9wv!MLg=SO+@1m+BXbG`{QYXD>C8xzDtPgH?jHd z-61IacNzK~Y^{D+Lm2re1ycu%s2P~U8y_W0n)$A;;QF7j2gk-ruscK9=gD3Ytr7(Y z2a(fly{J@@Z{bP0=*X6+MIml^Q6=K%$zqxp?GsK<@)yl23RagqYt=T=(Wjy~5|dPv zDdwojPn5}YQe05eVo~Akf|+Vcc1-rB2tv#aSzOZ4ZDAWqCj881QKX?H$4wuKCZY19 z4)+!$YV;H>Zun7+$o8cmN3oWcNW!Y66md^a%S4xfHb~Y<$SO69#|D?eRs+2+78%L( E9~s^CRR910 delta 1249 zcmYLIX-t$?6!m^HGJeBM`DTM*b4J91wICA}H#E4lkS%GTCo}_VnE{PMMrj85wwV%TG|?&R;;OFK?UMcBh}6ro4#M~o_o)|FZY~xy-NM4 zO6`u*vMTr+LY&semAXADoHm)T)0l|_vk5;KzQZL`CaxO)#Cwr%AXxDsW7GJ3Zk*g~;z*rKu8{xXtm*{B}98Idum*k(J$9{WmS z^VmZY7RS`FG5(?&mkYJ#fe6!u^B>MlSEskR(u2~a^ieTqQ82-dz3WZrk2j-uW-#_l zh(zy(Xp|(J#6E|HU5PVPXdNei-Vu!3^JGY6VQih(Cvm0Y1aVt(j0%IPRZen^LAVkT2E`H0-dRy9bZyZfXOflWIhP36 zrY9p~j5c&cN9|K$^B?q-_=TS+TRCIKu!J>{8ZjY=WY{m7*!IF?9rt8KOS~|%NJV3C zB`b_A*)wbHYVO;eCQ$;G3p+ROYFDY9 z9e0X&+n2c#T!}KLe7%kMrE-hJZF{$>cv-~|iQW(jhp$4x;dl)@s}>Tw53VJYSC2*h zbRBvp>Ul?HOaR!xt>ZE!wjG+G#(=w%5;5qGz&iH^av;@WhWE$;Z0wcM#0o}oI9A`+ z1}7E#p6h+Gv2J*M@&4QznvR=Ct;pdlxNgbVc+`c}S7n}3Tjrrqb7wkER z?h_3NYhRB0?H}QT_KkSIqY!P$R#et4!5a-x__*GOzJ@(m-%tQmeIajc^h)e(9Zz_@ z^<>t_b4cC)pOG23>nYY z%ILb-?|+_*@xENtUCQI_zNHfKZiI7b?>d#=9Wu)LKS58HjI}p(DCv{&Tz@_#`vo-z zB2Kv(BH`HWJWRd43cuV^P&43P(7-zc_0SNu`(&iJw5T0)^1UH#5H>$pi)(*x=DQD$ z6Gjg&#iGbwuFAA4pA?Vr*z>4@JvknTH?kB>^=> zh|h?ArMO+G6u#>iHF{P^bVel%GPwfEiX9r7XzZCY_#p7TK6}fs^h3;4b{yL%;#X4$2ah)ud z>d55j($j1bcMKFRN=>wYW?^}S)nhb}OM<;BTr5$@g!%%5NDHBTVxB_BpL~t{3Pq4Y kb7^* { + let service; + let numberingService; + let correspondenceRepo; + let revisionRepo; + let testingModule; + let _dataSource; + const createMockRepository = () => ({ + find: jest.fn(), + findOne: jest.fn(), + create: jest.fn(), + save: jest.fn(), + update: jest.fn(), + delete: jest.fn(), + softDelete: jest.fn(), + createQueryBuilder: jest.fn(() => ({ + leftJoinAndSelect: jest.fn().mockReturnThis(), + where: jest.fn().mockReturnThis(), + andWhere: jest.fn().mockReturnThis(), + orderBy: jest.fn().mockReturnThis(), + skip: jest.fn().mockReturnThis(), + take: jest.fn().mockReturnThis(), + getOne: jest.fn().mockResolvedValue(null), + getMany: jest.fn().mockResolvedValue([]), + getManyAndCount: jest.fn().mockResolvedValue([[], 0]), + })), + }); + const mockDataSource = { + createQueryRunner: jest.fn(() => ({ + connect: jest.fn(), + startTransaction: jest.fn(), + commitTransaction: jest.fn(), + rollbackTransaction: jest.fn(), + release: jest.fn(), + manager: { + create: jest.fn(), + save: jest.fn(), + findOne: jest.fn(), + }, + })), + getRepository: jest.fn(() => createMockRepository()), + manager: { + findOne: jest.fn(), + }, + }; + beforeEach(async () => { + testingModule = await testing_1.Test.createTestingModule({ + providers: [ + correspondence_service_1.CorrespondenceService, + { + provide: (0, typeorm_1.getRepositoryToken)(correspondence_entity_1.Correspondence), + useValue: createMockRepository(), + }, + { + provide: (0, typeorm_1.getRepositoryToken)(correspondence_revision_entity_1.CorrespondenceRevision), + useValue: createMockRepository(), + }, + { + provide: (0, typeorm_1.getRepositoryToken)(correspondence_type_entity_1.CorrespondenceType), + useValue: createMockRepository(), + }, + { + provide: (0, typeorm_1.getRepositoryToken)(correspondence_status_entity_1.CorrespondenceStatus), + useValue: createMockRepository(), + }, + { + provide: (0, typeorm_1.getRepositoryToken)(correspondence_reference_entity_1.CorrespondenceReference), + useValue: createMockRepository(), + }, + { + provide: (0, typeorm_1.getRepositoryToken)(correspondence_tag_entity_1.CorrespondenceTag), + useValue: createMockRepository(), + }, + { + provide: (0, typeorm_1.getRepositoryToken)(organization_entity_1.Organization), + useValue: createMockRepository(), + }, + { + provide: (0, typeorm_1.getRepositoryToken)(correspondence_recipient_entity_1.CorrespondenceRecipient), + useValue: createMockRepository(), + }, + { + provide: document_numbering_service_1.DocumentNumberingService, + useValue: { + generateNextNumber: jest.fn(), + updateNumberForDraft: jest.fn(), + previewNextNumber: jest.fn(), + }, + }, + { + provide: json_schema_service_1.JsonSchemaService, + useValue: { validate: jest.fn() }, + }, + { + provide: workflow_engine_service_1.WorkflowEngineService, + useValue: { createInstance: jest.fn() }, + }, + { + provide: user_service_1.UserService, + useValue: { + findOne: jest.fn(), + getUserPermissions: jest.fn().mockResolvedValue([]), + }, + }, + { + provide: typeorm_2.DataSource, + useValue: mockDataSource, + }, + { + provide: search_service_1.SearchService, + useValue: { indexDocument: jest.fn() }, + }, + { + provide: file_storage_service_1.FileStorageService, + useValue: { commit: jest.fn().mockResolvedValue([]) }, + }, + { + provide: uuid_resolver_service_1.UuidResolverService, + useValue: { + resolveProjectId: jest.fn().mockResolvedValue(1), + resolveOrganizationId: jest.fn().mockResolvedValue(1), + }, + }, + { + provide: notification_service_1.NotificationService, + useValue: { send: jest.fn().mockResolvedValue(undefined) }, + }, + ], + }).compile(); + service = testingModule.get(correspondence_service_1.CorrespondenceService); + numberingService = testingModule.get(document_numbering_service_1.DocumentNumberingService); + correspondenceRepo = testingModule.get((0, typeorm_1.getRepositoryToken)(correspondence_entity_1.Correspondence)); + revisionRepo = testingModule.get((0, typeorm_1.getRepositoryToken)(correspondence_revision_entity_1.CorrespondenceRevision)); + _dataSource = testingModule.get(typeorm_2.DataSource); + }); + it('should be defined', () => { + expect(service).toBeDefined(); + }); + describe('update', () => { + it('should NOT regenerate number if critical fields unchanged', async () => { + const mockUser = { id: 1, primaryOrganizationId: 10 }; + const mockRevision = { + id: 100, + correspondenceId: 1, + isCurrent: true, + statusId: 5, + }; + jest + .spyOn(revisionRepo, 'findOne') + .mockResolvedValue(mockRevision); + const mockCorr = { + id: 1, + projectId: 1, + correspondenceTypeId: 2, + disciplineId: 3, + originatorId: 10, + correspondenceNumber: 'OLD-NUM', + recipients: [{ recipientType: 'TO', recipientOrganizationId: 99 }], + }; + jest + .spyOn(correspondenceRepo, 'findOne') + .mockResolvedValue(mockCorr); + const updateDto = { + projectId: 1, + disciplineId: 3, + }; + await service.update(1, updateDto, mockUser); + expect(numberingService.updateNumberForDraft).not.toHaveBeenCalled(); + }); + it('should regenerate number if Project ID changes', async () => { + const mockUser = { id: 1, primaryOrganizationId: 10 }; + const mockRevision = { + id: 100, + correspondenceId: 1, + isCurrent: true, + statusId: 5, + }; + jest + .spyOn(revisionRepo, 'findOne') + .mockResolvedValue(mockRevision); + const mockCorr = { + id: 1, + projectId: 1, + correspondenceTypeId: 2, + disciplineId: 3, + originatorId: 10, + correspondenceNumber: 'OLD-NUM', + recipients: [{ recipientType: 'TO', recipientOrganizationId: 99 }], + }; + jest + .spyOn(correspondenceRepo, 'findOne') + .mockResolvedValue(mockCorr); + const updateDto = { + projectId: 2, + }; + const uuidResolver = testingModule.get(uuid_resolver_service_1.UuidResolverService); + uuidResolver.resolveProjectId.mockResolvedValue(2); + await service.update(1, updateDto, mockUser); + expect(numberingService.updateNumberForDraft).toHaveBeenCalled(); + }); + it('should regenerate number if Document Type changes', async () => { + const mockUser = { id: 1, primaryOrganizationId: 10 }; + const mockRevision = { + id: 100, + correspondenceId: 1, + isCurrent: true, + statusId: 5, + }; + jest + .spyOn(revisionRepo, 'findOne') + .mockResolvedValue(mockRevision); + const mockCorr = { + id: 1, + projectId: 1, + correspondenceTypeId: 2, + disciplineId: 3, + originatorId: 10, + correspondenceNumber: 'OLD-NUM', + recipients: [{ recipientType: 'TO', recipientOrganizationId: 99 }], + }; + jest + .spyOn(correspondenceRepo, 'findOne') + .mockResolvedValue(mockCorr); + const updateDto = { + typeId: 999, + }; + const typeRepo = testingModule.get((0, typeorm_1.getRepositoryToken)(correspondence_type_entity_1.CorrespondenceType)); + typeRepo.findOne.mockResolvedValue({ + id: 999, + typeCode: 'NEW-TYPE', + }); + await service.update(1, updateDto, mockUser); + expect(numberingService.updateNumberForDraft).toHaveBeenCalled(); + }); + it('should regenerate number if Recipient Organization changes', async () => { + const mockUser = { id: 1, primaryOrganizationId: 10 }; + const mockRevision = { + id: 100, + correspondenceId: 1, + isCurrent: true, + statusId: 5, + }; + jest + .spyOn(revisionRepo, 'findOne') + .mockResolvedValue(mockRevision); + const mockCorr = { + id: 1, + projectId: 1, + correspondenceTypeId: 2, + disciplineId: 3, + originatorId: 10, + correspondenceNumber: 'OLD-NUM', + recipients: [{ recipientType: 'TO', recipientOrganizationId: 99 }], + }; + jest + .spyOn(correspondenceRepo, 'findOne') + .mockResolvedValue(mockCorr); + // Access DataSource manager for mocking + mockDataSource.manager.findOne.mockResolvedValue({ + id: 88, + organizationCode: 'NEW-ORG', + }); + const updateDto = { + recipients: [{ type: 'TO', organizationId: 88 }], + }; + await service.update(1, updateDto, mockUser); + expect(numberingService.updateNumberForDraft).toHaveBeenCalled(); + }); + }); + describe('create', () => { + it('should allow system.manage_all user without primaryOrganizationId when originatorId is provided', async () => { + const mockUser = { + user_id: 1, + primaryOrganizationId: null, + }; + const createDto = { + projectId: 'project-uuid', + typeId: 1, + subject: 'Test Subject', + originatorId: 'originator-uuid', + recipients: [{ organizationId: 'recipient-uuid', type: 'TO' }], + }; + const userService = testingModule.get(user_service_1.UserService); + const typeRepo = testingModule.get((0, typeorm_1.getRepositoryToken)(correspondence_type_entity_1.CorrespondenceType)); + const statusRepo = testingModule.get((0, typeorm_1.getRepositoryToken)(correspondence_status_entity_1.CorrespondenceStatus)); + const uuidResolver = testingModule.get(uuid_resolver_service_1.UuidResolverService); + userService.findOne.mockResolvedValue({ + user_id: 1, + primaryOrganizationId: null, + }); + userService.getUserPermissions.mockResolvedValue([ + 'system.manage_all', + ]); + uuidResolver.resolveProjectId.mockResolvedValue(100); + uuidResolver.resolveOrganizationId.mockImplementation((value) => { + if (value === 'originator-uuid') + return 10; + if (value === 'recipient-uuid') + return 20; + return 0; + }); + typeRepo.findOne.mockResolvedValue({ + id: 1, + typeCode: 'LTR', + }); + statusRepo.findOne.mockResolvedValue({ + id: 1, + statusCode: 'DRAFT', + }); + numberingService.generateNextNumber.mockResolvedValue({ + number: 'DOC-001', + }); + mockDataSource.manager.findOne + .mockResolvedValueOnce({ id: 10, organizationCode: 'ORG' }) + .mockResolvedValueOnce({ id: 20, organizationCode: 'REC' }); + const queryRunner = { + connect: jest.fn(), + startTransaction: jest.fn(), + commitTransaction: jest.fn(), + rollbackTransaction: jest.fn(), + release: jest.fn(), + manager: { + create: jest.fn((_entity, payload) => payload), + save: jest + .fn() + .mockResolvedValueOnce({ id: 999, publicId: 'corr-uuid' }) + .mockResolvedValueOnce({ id: 1000 }) + .mockResolvedValueOnce([]), + findOne: jest.fn(), + }, + }; + mockDataSource.createQueryRunner.mockReturnValue(queryRunner); + await service.create(createDto, mockUser); + expect(queryRunner.manager.create).toHaveBeenCalledWith(correspondence_entity_1.Correspondence, expect.objectContaining({ originatorId: 10 })); + }); + it('should set revisionLabel to "A" for RFA type', async () => { + const mockUser = { + user_id: 1, + primaryOrganizationId: 10, + }; + const createDto = { + projectId: 'project-uuid', + typeId: 1, + subject: 'Test Subject', + recipients: [{ organizationId: 'recipient-uuid', type: 'TO' }], + }; + const typeRepo = testingModule.get((0, typeorm_1.getRepositoryToken)(correspondence_type_entity_1.CorrespondenceType)); + const statusRepo = testingModule.get((0, typeorm_1.getRepositoryToken)(correspondence_status_entity_1.CorrespondenceStatus)); + const uuidResolver = testingModule.get(uuid_resolver_service_1.UuidResolverService); + uuidResolver.resolveProjectId.mockResolvedValue(100); + uuidResolver.resolveOrganizationId.mockResolvedValue(20); + typeRepo.findOne.mockResolvedValue({ + id: 1, + typeCode: 'RFA', + }); + statusRepo.findOne.mockResolvedValue({ + id: 1, + statusCode: 'DRAFT', + }); + numberingService.generateNextNumber.mockResolvedValue({ + number: 'DOC-001', + }); + mockDataSource.manager.findOne + .mockResolvedValueOnce({ id: 10, organizationCode: 'ORG' }) + .mockResolvedValueOnce({ id: 20, organizationCode: 'REC' }); + const queryRunner = { + connect: jest.fn(), + startTransaction: jest.fn(), + commitTransaction: jest.fn(), + rollbackTransaction: jest.fn(), + release: jest.fn(), + manager: { + create: jest.fn((_entity, payload) => payload), + save: jest + .fn() + .mockResolvedValueOnce({ id: 999, publicId: 'corr-uuid' }) + .mockResolvedValueOnce({ id: 1000 }) + .mockResolvedValueOnce([]), + findOne: jest.fn(), + }, + }; + mockDataSource.createQueryRunner.mockReturnValue(queryRunner); + await service.create(createDto, mockUser); + expect(queryRunner.manager.create).toHaveBeenCalledWith(correspondence_revision_entity_1.CorrespondenceRevision, expect.objectContaining({ revisionLabel: 'A' })); + }); + it('should set revisionLabel to "A" for RFI type', async () => { + const mockUser = { + user_id: 1, + primaryOrganizationId: 10, + }; + const createDto = { + projectId: 'project-uuid', + typeId: 1, + subject: 'Test Subject', + recipients: [{ organizationId: 'recipient-uuid', type: 'TO' }], + }; + const typeRepo = testingModule.get((0, typeorm_1.getRepositoryToken)(correspondence_type_entity_1.CorrespondenceType)); + const statusRepo = testingModule.get((0, typeorm_1.getRepositoryToken)(correspondence_status_entity_1.CorrespondenceStatus)); + const uuidResolver = testingModule.get(uuid_resolver_service_1.UuidResolverService); + uuidResolver.resolveProjectId.mockResolvedValue(100); + uuidResolver.resolveOrganizationId.mockResolvedValue(20); + typeRepo.findOne.mockResolvedValue({ + id: 1, + typeCode: 'RFI', + }); + statusRepo.findOne.mockResolvedValue({ + id: 1, + statusCode: 'DRAFT', + }); + numberingService.generateNextNumber.mockResolvedValue({ + number: 'DOC-001', + }); + mockDataSource.manager.findOne + .mockResolvedValueOnce({ id: 10, organizationCode: 'ORG' }) + .mockResolvedValueOnce({ id: 20, organizationCode: 'REC' }); + const queryRunner = { + connect: jest.fn(), + startTransaction: jest.fn(), + commitTransaction: jest.fn(), + rollbackTransaction: jest.fn(), + release: jest.fn(), + manager: { + create: jest.fn((_entity, payload) => payload), + save: jest + .fn() + .mockResolvedValueOnce({ id: 999, publicId: 'corr-uuid' }) + .mockResolvedValueOnce({ id: 1000 }) + .mockResolvedValueOnce([]), + findOne: jest.fn(), + }, + }; + mockDataSource.createQueryRunner.mockReturnValue(queryRunner); + await service.create(createDto, mockUser); + expect(queryRunner.manager.create).toHaveBeenCalledWith(correspondence_revision_entity_1.CorrespondenceRevision, expect.objectContaining({ revisionLabel: 'A' })); + }); + it('should set revisionLabel to null for LETTER type', async () => { + const mockUser = { + user_id: 1, + primaryOrganizationId: 10, + }; + const createDto = { + projectId: 'project-uuid', + typeId: 1, + subject: 'Test Subject', + recipients: [{ organizationId: 'recipient-uuid', type: 'TO' }], + }; + const typeRepo = testingModule.get((0, typeorm_1.getRepositoryToken)(correspondence_type_entity_1.CorrespondenceType)); + const statusRepo = testingModule.get((0, typeorm_1.getRepositoryToken)(correspondence_status_entity_1.CorrespondenceStatus)); + const uuidResolver = testingModule.get(uuid_resolver_service_1.UuidResolverService); + uuidResolver.resolveProjectId.mockResolvedValue(100); + uuidResolver.resolveOrganizationId.mockResolvedValue(20); + typeRepo.findOne.mockResolvedValue({ + id: 1, + typeCode: 'LETTER', + }); + statusRepo.findOne.mockResolvedValue({ + id: 1, + statusCode: 'DRAFT', + }); + numberingService.generateNextNumber.mockResolvedValue({ + number: 'DOC-001', + }); + mockDataSource.manager.findOne + .mockResolvedValueOnce({ id: 10, organizationCode: 'ORG' }) + .mockResolvedValueOnce({ id: 20, organizationCode: 'REC' }); + const queryRunner = { + connect: jest.fn(), + startTransaction: jest.fn(), + commitTransaction: jest.fn(), + rollbackTransaction: jest.fn(), + release: jest.fn(), + manager: { + create: jest.fn((_entity, payload) => payload), + save: jest + .fn() + .mockResolvedValueOnce({ id: 999, publicId: 'corr-uuid' }) + .mockResolvedValueOnce({ id: 1000 }) + .mockResolvedValueOnce([]), + findOne: jest.fn(), + }, + }; + mockDataSource.createQueryRunner.mockReturnValue(queryRunner); + await service.create(createDto, mockUser); + expect(queryRunner.manager.create).toHaveBeenCalledWith(correspondence_revision_entity_1.CorrespondenceRevision, expect.objectContaining({ revisionLabel: null })); + }); + it('should set revisionLabel to null for MEMO type', async () => { + const mockUser = { + user_id: 1, + primaryOrganizationId: 10, + }; + const createDto = { + projectId: 'project-uuid', + typeId: 1, + subject: 'Test Subject', + recipients: [{ organizationId: 'recipient-uuid', type: 'TO' }], + }; + const typeRepo = testingModule.get((0, typeorm_1.getRepositoryToken)(correspondence_type_entity_1.CorrespondenceType)); + const statusRepo = testingModule.get((0, typeorm_1.getRepositoryToken)(correspondence_status_entity_1.CorrespondenceStatus)); + const uuidResolver = testingModule.get(uuid_resolver_service_1.UuidResolverService); + uuidResolver.resolveProjectId.mockResolvedValue(100); + uuidResolver.resolveOrganizationId.mockResolvedValue(20); + typeRepo.findOne.mockResolvedValue({ + id: 1, + typeCode: 'MEMO', + }); + statusRepo.findOne.mockResolvedValue({ + id: 1, + statusCode: 'DRAFT', + }); + numberingService.generateNextNumber.mockResolvedValue({ + number: 'DOC-001', + }); + mockDataSource.manager.findOne + .mockResolvedValueOnce({ id: 10, organizationCode: 'ORG' }) + .mockResolvedValueOnce({ id: 20, organizationCode: 'REC' }); + const queryRunner = { + connect: jest.fn(), + startTransaction: jest.fn(), + commitTransaction: jest.fn(), + rollbackTransaction: jest.fn(), + release: jest.fn(), + manager: { + create: jest.fn((_entity, payload) => payload), + save: jest + .fn() + .mockResolvedValueOnce({ id: 999, publicId: 'corr-uuid' }) + .mockResolvedValueOnce({ id: 1000 }) + .mockResolvedValueOnce([]), + findOne: jest.fn(), + }, + }; + mockDataSource.createQueryRunner.mockReturnValue(queryRunner); + await service.create(createDto, mockUser); + expect(queryRunner.manager.create).toHaveBeenCalledWith(correspondence_revision_entity_1.CorrespondenceRevision, expect.objectContaining({ revisionLabel: null })); + }); + }); +}); +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"file":"E:\\np-dms\\lcbp3\\backend\\src\\modules\\correspondence\\correspondence.service.spec.ts","mappings":"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","names":[],"sources":["E:\\np-dms\\lcbp3\\backend\\src\\modules\\correspondence\\correspondence.service.spec.ts"],"sourcesContent":["import { Test, TestingModule } from '@nestjs/testing';\r\nimport { getRepositoryToken } from '@nestjs/typeorm';\r\nimport { DataSource, Repository } from 'typeorm';\r\nimport { CorrespondenceService } from './correspondence.service';\r\nimport { Correspondence } from './entities/correspondence.entity';\r\nimport { CorrespondenceRevision } from './entities/correspondence-revision.entity';\r\nimport { CorrespondenceType } from './entities/correspondence-type.entity';\r\nimport { CorrespondenceStatus } from './entities/correspondence-status.entity';\r\nimport { CorrespondenceReference } from './entities/correspondence-reference.entity';\r\nimport { CorrespondenceTag } from './entities/correspondence-tag.entity';\r\nimport { Organization } from '../organization/entities/organization.entity';\r\nimport { CorrespondenceRecipient } from './entities/correspondence-recipient.entity';\r\nimport { DocumentNumberingService } from '../document-numbering/services/document-numbering.service';\r\nimport { JsonSchemaService } from '../json-schema/json-schema.service';\r\nimport { WorkflowEngineService } from '../workflow-engine/workflow-engine.service';\r\nimport { UserService } from '../user/user.service';\r\nimport { SearchService } from '../search/search.service';\r\nimport { FileStorageService } from '../../common/file-storage/file-storage.service';\r\nimport { UuidResolverService } from '../../common/services/uuid-resolver.service';\r\nimport { NotificationService } from '../notification/notification.service';\r\nimport { UpdateCorrespondenceDto } from './dto/update-correspondence.dto';\r\nimport { CreateCorrespondenceDto } from './dto/create-correspondence.dto';\r\nimport { User } from '../user/entities/user.entity';\r\n\r\ndescribe('CorrespondenceService', () => {\r\n  let service: CorrespondenceService;\r\n  let numberingService: DocumentNumberingService;\r\n  let correspondenceRepo: Repository<Correspondence>;\r\n  let revisionRepo: Repository<CorrespondenceRevision>;\r\n  let testingModule: TestingModule;\r\n  let _dataSource: DataSource;\r\n\r\n  const createMockRepository = () => ({\r\n    find: jest.fn(),\r\n    findOne: jest.fn(),\r\n    create: jest.fn(),\r\n    save: jest.fn(),\r\n    update: jest.fn(),\r\n    delete: jest.fn(),\r\n    softDelete: jest.fn(),\r\n    createQueryBuilder: jest.fn(() => ({\r\n      leftJoinAndSelect: jest.fn().mockReturnThis(),\r\n      where: jest.fn().mockReturnThis(),\r\n      andWhere: jest.fn().mockReturnThis(),\r\n      orderBy: jest.fn().mockReturnThis(),\r\n      skip: jest.fn().mockReturnThis(),\r\n      take: jest.fn().mockReturnThis(),\r\n      getOne: jest.fn().mockResolvedValue(null),\r\n      getMany: jest.fn().mockResolvedValue([]),\r\n      getManyAndCount: jest.fn().mockResolvedValue([[], 0]),\r\n    })),\r\n  });\r\n\r\n  const mockDataSource = {\r\n    createQueryRunner: jest.fn(() => ({\r\n      connect: jest.fn(),\r\n      startTransaction: jest.fn(),\r\n      commitTransaction: jest.fn(),\r\n      rollbackTransaction: jest.fn(),\r\n      release: jest.fn(),\r\n      manager: {\r\n        create: jest.fn(),\r\n        save: jest.fn(),\r\n        findOne: jest.fn(),\r\n      },\r\n    })),\r\n    getRepository: jest.fn(() => createMockRepository()),\r\n    manager: {\r\n      findOne: jest.fn(),\r\n    },\r\n  };\r\n\r\n  beforeEach(async () => {\r\n    testingModule = await Test.createTestingModule({\r\n      providers: [\r\n        CorrespondenceService,\r\n        {\r\n          provide: getRepositoryToken(Correspondence),\r\n          useValue: createMockRepository(),\r\n        },\r\n        {\r\n          provide: getRepositoryToken(CorrespondenceRevision),\r\n          useValue: createMockRepository(),\r\n        },\r\n        {\r\n          provide: getRepositoryToken(CorrespondenceType),\r\n          useValue: createMockRepository(),\r\n        },\r\n        {\r\n          provide: getRepositoryToken(CorrespondenceStatus),\r\n          useValue: createMockRepository(),\r\n        },\r\n        {\r\n          provide: getRepositoryToken(CorrespondenceReference),\r\n          useValue: createMockRepository(),\r\n        },\r\n        {\r\n          provide: getRepositoryToken(CorrespondenceTag),\r\n          useValue: createMockRepository(),\r\n        },\r\n        {\r\n          provide: getRepositoryToken(Organization),\r\n          useValue: createMockRepository(),\r\n        },\r\n        {\r\n          provide: getRepositoryToken(CorrespondenceRecipient),\r\n          useValue: createMockRepository(),\r\n        },\r\n        {\r\n          provide: DocumentNumberingService,\r\n          useValue: {\r\n            generateNextNumber: jest.fn(),\r\n            updateNumberForDraft: jest.fn(),\r\n            previewNextNumber: jest.fn(),\r\n          },\r\n        },\r\n        {\r\n          provide: JsonSchemaService,\r\n          useValue: { validate: jest.fn() },\r\n        },\r\n        {\r\n          provide: WorkflowEngineService,\r\n          useValue: { createInstance: jest.fn() },\r\n        },\r\n        {\r\n          provide: UserService,\r\n          useValue: {\r\n            findOne: jest.fn(),\r\n            getUserPermissions: jest.fn().mockResolvedValue([]),\r\n          },\r\n        },\r\n        {\r\n          provide: DataSource,\r\n          useValue: mockDataSource,\r\n        },\r\n        {\r\n          provide: SearchService,\r\n          useValue: { indexDocument: jest.fn() },\r\n        },\r\n        {\r\n          provide: FileStorageService,\r\n          useValue: { commit: jest.fn().mockResolvedValue([]) },\r\n        },\r\n        {\r\n          provide: UuidResolverService,\r\n          useValue: {\r\n            resolveProjectId: jest.fn().mockResolvedValue(1),\r\n            resolveOrganizationId: jest.fn().mockResolvedValue(1),\r\n          },\r\n        },\r\n        {\r\n          provide: NotificationService,\r\n          useValue: { send: jest.fn().mockResolvedValue(undefined) },\r\n        },\r\n      ],\r\n    }).compile();\r\n\r\n    service = testingModule.get<CorrespondenceService>(CorrespondenceService);\r\n    numberingService = testingModule.get<DocumentNumberingService>(\r\n      DocumentNumberingService\r\n    );\r\n    correspondenceRepo = testingModule.get<Repository<Correspondence>>(\r\n      getRepositoryToken(Correspondence)\r\n    );\r\n    revisionRepo = testingModule.get<Repository<CorrespondenceRevision>>(\r\n      getRepositoryToken(CorrespondenceRevision)\r\n    );\r\n    _dataSource = testingModule.get<DataSource>(DataSource);\r\n  });\r\n\r\n  it('should be defined', () => {\r\n    expect(service).toBeDefined();\r\n  });\r\n\r\n  describe('update', () => {\r\n    it('should NOT regenerate number if critical fields unchanged', async () => {\r\n      const mockUser = { id: 1, primaryOrganizationId: 10 } as unknown as User;\r\n      const mockRevision = {\r\n        id: 100,\r\n        correspondenceId: 1,\r\n        isCurrent: true,\r\n        statusId: 5,\r\n      };\r\n\r\n      jest\r\n        .spyOn(revisionRepo, 'findOne')\r\n        .mockResolvedValue(mockRevision as unknown as CorrespondenceRevision);\r\n\r\n      const mockCorr = {\r\n        id: 1,\r\n        projectId: 1,\r\n        correspondenceTypeId: 2,\r\n        disciplineId: 3,\r\n        originatorId: 10,\r\n        correspondenceNumber: 'OLD-NUM',\r\n        recipients: [{ recipientType: 'TO', recipientOrganizationId: 99 }],\r\n      };\r\n      jest\r\n        .spyOn(correspondenceRepo, 'findOne')\r\n        .mockResolvedValue(mockCorr as unknown as Correspondence);\r\n\r\n      const updateDto: UpdateCorrespondenceDto = {\r\n        projectId: 1,\r\n        disciplineId: 3,\r\n      };\r\n\r\n      await service.update(1, updateDto, mockUser);\r\n\r\n      expect(\r\n        numberingService.updateNumberForDraft as jest.Mock\r\n      ).not.toHaveBeenCalled();\r\n    });\r\n\r\n    it('should regenerate number if Project ID changes', async () => {\r\n      const mockUser = { id: 1, primaryOrganizationId: 10 } as unknown as User;\r\n      const mockRevision = {\r\n        id: 100,\r\n        correspondenceId: 1,\r\n        isCurrent: true,\r\n        statusId: 5,\r\n      };\r\n      jest\r\n        .spyOn(revisionRepo, 'findOne')\r\n        .mockResolvedValue(mockRevision as unknown as CorrespondenceRevision);\r\n\r\n      const mockCorr = {\r\n        id: 1,\r\n        projectId: 1,\r\n        correspondenceTypeId: 2,\r\n        disciplineId: 3,\r\n        originatorId: 10,\r\n        correspondenceNumber: 'OLD-NUM',\r\n        recipients: [{ recipientType: 'TO', recipientOrganizationId: 99 }],\r\n      };\r\n      jest\r\n        .spyOn(correspondenceRepo, 'findOne')\r\n        .mockResolvedValue(mockCorr as unknown as Correspondence);\r\n\r\n      const updateDto: UpdateCorrespondenceDto = {\r\n        projectId: 2,\r\n      };\r\n\r\n      const uuidResolver =\r\n        testingModule.get<UuidResolverService>(UuidResolverService);\r\n      (uuidResolver.resolveProjectId as jest.Mock).mockResolvedValue(2);\r\n\r\n      await service.update(1, updateDto, mockUser);\r\n\r\n      expect(\r\n        numberingService.updateNumberForDraft as jest.Mock\r\n      ).toHaveBeenCalled();\r\n    });\r\n\r\n    it('should regenerate number if Document Type changes', async () => {\r\n      const mockUser = { id: 1, primaryOrganizationId: 10 } as unknown as User;\r\n      const mockRevision = {\r\n        id: 100,\r\n        correspondenceId: 1,\r\n        isCurrent: true,\r\n        statusId: 5,\r\n      };\r\n      jest\r\n        .spyOn(revisionRepo, 'findOne')\r\n        .mockResolvedValue(mockRevision as unknown as CorrespondenceRevision);\r\n\r\n      const mockCorr = {\r\n        id: 1,\r\n        projectId: 1,\r\n        correspondenceTypeId: 2,\r\n        disciplineId: 3,\r\n        originatorId: 10,\r\n        correspondenceNumber: 'OLD-NUM',\r\n        recipients: [{ recipientType: 'TO', recipientOrganizationId: 99 }],\r\n      };\r\n      jest\r\n        .spyOn(correspondenceRepo, 'findOne')\r\n        .mockResolvedValue(mockCorr as unknown as Correspondence);\r\n\r\n      const updateDto: UpdateCorrespondenceDto = {\r\n        typeId: 999,\r\n      };\r\n\r\n      const typeRepo = testingModule.get<Repository<CorrespondenceType>>(\r\n        getRepositoryToken(CorrespondenceType)\r\n      );\r\n      (typeRepo.findOne as jest.Mock).mockResolvedValue({\r\n        id: 999,\r\n        typeCode: 'NEW-TYPE',\r\n      });\r\n\r\n      await service.update(1, updateDto, mockUser);\r\n\r\n      expect(\r\n        numberingService.updateNumberForDraft as jest.Mock\r\n      ).toHaveBeenCalled();\r\n    });\r\n\r\n    it('should regenerate number if Recipient Organization changes', async () => {\r\n      const mockUser = { id: 1, primaryOrganizationId: 10 } as unknown as User;\r\n      const mockRevision = {\r\n        id: 100,\r\n        correspondenceId: 1,\r\n        isCurrent: true,\r\n        statusId: 5,\r\n      };\r\n      jest\r\n        .spyOn(revisionRepo, 'findOne')\r\n        .mockResolvedValue(mockRevision as unknown as CorrespondenceRevision);\r\n\r\n      const mockCorr = {\r\n        id: 1,\r\n        projectId: 1,\r\n        correspondenceTypeId: 2,\r\n        disciplineId: 3,\r\n        originatorId: 10,\r\n        correspondenceNumber: 'OLD-NUM',\r\n        recipients: [{ recipientType: 'TO', recipientOrganizationId: 99 }],\r\n      };\r\n      jest\r\n        .spyOn(correspondenceRepo, 'findOne')\r\n        .mockResolvedValue(mockCorr as unknown as Correspondence);\r\n\r\n      // Access DataSource manager for mocking\r\n      mockDataSource.manager.findOne.mockResolvedValue({\r\n        id: 88,\r\n        organizationCode: 'NEW-ORG',\r\n      } as unknown as Organization);\r\n\r\n      const updateDto: UpdateCorrespondenceDto = {\r\n        recipients: [{ type: 'TO', organizationId: 88 }],\r\n      };\r\n\r\n      await service.update(1, updateDto, mockUser);\r\n\r\n      expect(\r\n        numberingService.updateNumberForDraft as jest.Mock\r\n      ).toHaveBeenCalled();\r\n    });\r\n  });\r\n\r\n  describe('create', () => {\r\n    it('should allow system.manage_all user without primaryOrganizationId when originatorId is provided', async () => {\r\n      const mockUser = {\r\n        user_id: 1,\r\n        primaryOrganizationId: null,\r\n      } as unknown as User;\r\n\r\n      const createDto: CreateCorrespondenceDto = {\r\n        projectId: 'project-uuid',\r\n        typeId: 1,\r\n        subject: 'Test Subject',\r\n        originatorId: 'originator-uuid',\r\n        recipients: [{ organizationId: 'recipient-uuid', type: 'TO' }],\r\n      };\r\n\r\n      const userService = testingModule.get<UserService>(UserService);\r\n      const typeRepo = testingModule.get<Repository<CorrespondenceType>>(\r\n        getRepositoryToken(CorrespondenceType)\r\n      );\r\n      const statusRepo = testingModule.get<Repository<CorrespondenceStatus>>(\r\n        getRepositoryToken(CorrespondenceStatus)\r\n      );\r\n      const uuidResolver =\r\n        testingModule.get<UuidResolverService>(UuidResolverService);\r\n\r\n      (userService.findOne as jest.Mock).mockResolvedValue({\r\n        user_id: 1,\r\n        primaryOrganizationId: null,\r\n      });\r\n      (userService.getUserPermissions as jest.Mock).mockResolvedValue([\r\n        'system.manage_all',\r\n      ]);\r\n\r\n      (uuidResolver.resolveProjectId as jest.Mock).mockResolvedValue(100);\r\n      (uuidResolver.resolveOrganizationId as jest.Mock).mockImplementation(\r\n        (value: number | string) => {\r\n          if (value === 'originator-uuid') return 10;\r\n          if (value === 'recipient-uuid') return 20;\r\n          return 0;\r\n        }\r\n      );\r\n\r\n      (typeRepo.findOne as jest.Mock).mockResolvedValue({\r\n        id: 1,\r\n        typeCode: 'LTR',\r\n      });\r\n      (statusRepo.findOne as jest.Mock).mockResolvedValue({\r\n        id: 1,\r\n        statusCode: 'DRAFT',\r\n      });\r\n\r\n      (numberingService.generateNextNumber as jest.Mock).mockResolvedValue({\r\n        number: 'DOC-001',\r\n      });\r\n\r\n      mockDataSource.manager.findOne\r\n        .mockResolvedValueOnce({ id: 10, organizationCode: 'ORG' })\r\n        .mockResolvedValueOnce({ id: 20, organizationCode: 'REC' });\r\n\r\n      const queryRunner = {\r\n        connect: jest.fn(),\r\n        startTransaction: jest.fn(),\r\n        commitTransaction: jest.fn(),\r\n        rollbackTransaction: jest.fn(),\r\n        release: jest.fn(),\r\n        manager: {\r\n          create: jest.fn(\r\n            (_entity: unknown, payload: Record<string, unknown>) => payload\r\n          ),\r\n          save: jest\r\n            .fn()\r\n            .mockResolvedValueOnce({ id: 999, publicId: 'corr-uuid' })\r\n            .mockResolvedValueOnce({ id: 1000 })\r\n            .mockResolvedValueOnce([]),\r\n          findOne: jest.fn(),\r\n        },\r\n      };\r\n\r\n      (mockDataSource.createQueryRunner as jest.Mock).mockReturnValue(\r\n        queryRunner\r\n      );\r\n\r\n      await service.create(createDto, mockUser);\r\n\r\n      expect(queryRunner.manager.create).toHaveBeenCalledWith(\r\n        Correspondence,\r\n        expect.objectContaining({ originatorId: 10 })\r\n      );\r\n    });\r\n\r\n    it('should set revisionLabel to \"A\" for RFA type', async () => {\r\n      const mockUser = {\r\n        user_id: 1,\r\n        primaryOrganizationId: 10,\r\n      } as unknown as User;\r\n\r\n      const createDto: CreateCorrespondenceDto = {\r\n        projectId: 'project-uuid',\r\n        typeId: 1,\r\n        subject: 'Test Subject',\r\n        recipients: [{ organizationId: 'recipient-uuid', type: 'TO' }],\r\n      };\r\n\r\n      const typeRepo = testingModule.get<Repository<CorrespondenceType>>(\r\n        getRepositoryToken(CorrespondenceType)\r\n      );\r\n      const statusRepo = testingModule.get<Repository<CorrespondenceStatus>>(\r\n        getRepositoryToken(CorrespondenceStatus)\r\n      );\r\n      const uuidResolver =\r\n        testingModule.get<UuidResolverService>(UuidResolverService);\r\n\r\n      (uuidResolver.resolveProjectId as jest.Mock).mockResolvedValue(100);\r\n      (uuidResolver.resolveOrganizationId as jest.Mock).mockResolvedValue(20);\r\n\r\n      (typeRepo.findOne as jest.Mock).mockResolvedValue({\r\n        id: 1,\r\n        typeCode: 'RFA',\r\n      });\r\n      (statusRepo.findOne as jest.Mock).mockResolvedValue({\r\n        id: 1,\r\n        statusCode: 'DRAFT',\r\n      });\r\n\r\n      (numberingService.generateNextNumber as jest.Mock).mockResolvedValue({\r\n        number: 'DOC-001',\r\n      });\r\n\r\n      mockDataSource.manager.findOne\r\n        .mockResolvedValueOnce({ id: 10, organizationCode: 'ORG' })\r\n        .mockResolvedValueOnce({ id: 20, organizationCode: 'REC' });\r\n\r\n      const queryRunner = {\r\n        connect: jest.fn(),\r\n        startTransaction: jest.fn(),\r\n        commitTransaction: jest.fn(),\r\n        rollbackTransaction: jest.fn(),\r\n        release: jest.fn(),\r\n        manager: {\r\n          create: jest.fn(\r\n            (_entity: unknown, payload: Record<string, unknown>) => payload\r\n          ),\r\n          save: jest\r\n            .fn()\r\n            .mockResolvedValueOnce({ id: 999, publicId: 'corr-uuid' })\r\n            .mockResolvedValueOnce({ id: 1000 })\r\n            .mockResolvedValueOnce([]),\r\n          findOne: jest.fn(),\r\n        },\r\n      };\r\n\r\n      (mockDataSource.createQueryRunner as jest.Mock).mockReturnValue(\r\n        queryRunner\r\n      );\r\n\r\n      await service.create(createDto, mockUser);\r\n\r\n      expect(queryRunner.manager.create).toHaveBeenCalledWith(\r\n        CorrespondenceRevision,\r\n        expect.objectContaining({ revisionLabel: 'A' })\r\n      );\r\n    });\r\n\r\n    it('should set revisionLabel to \"A\" for RFI type', async () => {\r\n      const mockUser = {\r\n        user_id: 1,\r\n        primaryOrganizationId: 10,\r\n      } as unknown as User;\r\n\r\n      const createDto: CreateCorrespondenceDto = {\r\n        projectId: 'project-uuid',\r\n        typeId: 1,\r\n        subject: 'Test Subject',\r\n        recipients: [{ organizationId: 'recipient-uuid', type: 'TO' }],\r\n      };\r\n\r\n      const typeRepo = testingModule.get<Repository<CorrespondenceType>>(\r\n        getRepositoryToken(CorrespondenceType)\r\n      );\r\n      const statusRepo = testingModule.get<Repository<CorrespondenceStatus>>(\r\n        getRepositoryToken(CorrespondenceStatus)\r\n      );\r\n      const uuidResolver =\r\n        testingModule.get<UuidResolverService>(UuidResolverService);\r\n\r\n      (uuidResolver.resolveProjectId as jest.Mock).mockResolvedValue(100);\r\n      (uuidResolver.resolveOrganizationId as jest.Mock).mockResolvedValue(20);\r\n\r\n      (typeRepo.findOne as jest.Mock).mockResolvedValue({\r\n        id: 1,\r\n        typeCode: 'RFI',\r\n      });\r\n      (statusRepo.findOne as jest.Mock).mockResolvedValue({\r\n        id: 1,\r\n        statusCode: 'DRAFT',\r\n      });\r\n\r\n      (numberingService.generateNextNumber as jest.Mock).mockResolvedValue({\r\n        number: 'DOC-001',\r\n      });\r\n\r\n      mockDataSource.manager.findOne\r\n        .mockResolvedValueOnce({ id: 10, organizationCode: 'ORG' })\r\n        .mockResolvedValueOnce({ id: 20, organizationCode: 'REC' });\r\n\r\n      const queryRunner = {\r\n        connect: jest.fn(),\r\n        startTransaction: jest.fn(),\r\n        commitTransaction: jest.fn(),\r\n        rollbackTransaction: jest.fn(),\r\n        release: jest.fn(),\r\n        manager: {\r\n          create: jest.fn(\r\n            (_entity: unknown, payload: Record<string, unknown>) => payload\r\n          ),\r\n          save: jest\r\n            .fn()\r\n            .mockResolvedValueOnce({ id: 999, publicId: 'corr-uuid' })\r\n            .mockResolvedValueOnce({ id: 1000 })\r\n            .mockResolvedValueOnce([]),\r\n          findOne: jest.fn(),\r\n        },\r\n      };\r\n\r\n      (mockDataSource.createQueryRunner as jest.Mock).mockReturnValue(\r\n        queryRunner\r\n      );\r\n\r\n      await service.create(createDto, mockUser);\r\n\r\n      expect(queryRunner.manager.create).toHaveBeenCalledWith(\r\n        CorrespondenceRevision,\r\n        expect.objectContaining({ revisionLabel: 'A' })\r\n      );\r\n    });\r\n\r\n    it('should set revisionLabel to null for LETTER type', async () => {\r\n      const mockUser = {\r\n        user_id: 1,\r\n        primaryOrganizationId: 10,\r\n      } as unknown as User;\r\n\r\n      const createDto: CreateCorrespondenceDto = {\r\n        projectId: 'project-uuid',\r\n        typeId: 1,\r\n        subject: 'Test Subject',\r\n        recipients: [{ organizationId: 'recipient-uuid', type: 'TO' }],\r\n      };\r\n\r\n      const typeRepo = testingModule.get<Repository<CorrespondenceType>>(\r\n        getRepositoryToken(CorrespondenceType)\r\n      );\r\n      const statusRepo = testingModule.get<Repository<CorrespondenceStatus>>(\r\n        getRepositoryToken(CorrespondenceStatus)\r\n      );\r\n      const uuidResolver =\r\n        testingModule.get<UuidResolverService>(UuidResolverService);\r\n\r\n      (uuidResolver.resolveProjectId as jest.Mock).mockResolvedValue(100);\r\n      (uuidResolver.resolveOrganizationId as jest.Mock).mockResolvedValue(20);\r\n\r\n      (typeRepo.findOne as jest.Mock).mockResolvedValue({\r\n        id: 1,\r\n        typeCode: 'LETTER',\r\n      });\r\n      (statusRepo.findOne as jest.Mock).mockResolvedValue({\r\n        id: 1,\r\n        statusCode: 'DRAFT',\r\n      });\r\n\r\n      (numberingService.generateNextNumber as jest.Mock).mockResolvedValue({\r\n        number: 'DOC-001',\r\n      });\r\n\r\n      mockDataSource.manager.findOne\r\n        .mockResolvedValueOnce({ id: 10, organizationCode: 'ORG' })\r\n        .mockResolvedValueOnce({ id: 20, organizationCode: 'REC' });\r\n\r\n      const queryRunner = {\r\n        connect: jest.fn(),\r\n        startTransaction: jest.fn(),\r\n        commitTransaction: jest.fn(),\r\n        rollbackTransaction: jest.fn(),\r\n        release: jest.fn(),\r\n        manager: {\r\n          create: jest.fn(\r\n            (_entity: unknown, payload: Record<string, unknown>) => payload\r\n          ),\r\n          save: jest\r\n            .fn()\r\n            .mockResolvedValueOnce({ id: 999, publicId: 'corr-uuid' })\r\n            .mockResolvedValueOnce({ id: 1000 })\r\n            .mockResolvedValueOnce([]),\r\n          findOne: jest.fn(),\r\n        },\r\n      };\r\n\r\n      (mockDataSource.createQueryRunner as jest.Mock).mockReturnValue(\r\n        queryRunner\r\n      );\r\n\r\n      await service.create(createDto, mockUser);\r\n\r\n      expect(queryRunner.manager.create).toHaveBeenCalledWith(\r\n        CorrespondenceRevision,\r\n        expect.objectContaining({ revisionLabel: null })\r\n      );\r\n    });\r\n\r\n    it('should set revisionLabel to null for MEMO type', async () => {\r\n      const mockUser = {\r\n        user_id: 1,\r\n        primaryOrganizationId: 10,\r\n      } as unknown as User;\r\n\r\n      const createDto: CreateCorrespondenceDto = {\r\n        projectId: 'project-uuid',\r\n        typeId: 1,\r\n        subject: 'Test Subject',\r\n        recipients: [{ organizationId: 'recipient-uuid', type: 'TO' }],\r\n      };\r\n\r\n      const typeRepo = testingModule.get<Repository<CorrespondenceType>>(\r\n        getRepositoryToken(CorrespondenceType)\r\n      );\r\n      const statusRepo = testingModule.get<Repository<CorrespondenceStatus>>(\r\n        getRepositoryToken(CorrespondenceStatus)\r\n      );\r\n      const uuidResolver =\r\n        testingModule.get<UuidResolverService>(UuidResolverService);\r\n\r\n      (uuidResolver.resolveProjectId as jest.Mock).mockResolvedValue(100);\r\n      (uuidResolver.resolveOrganizationId as jest.Mock).mockResolvedValue(20);\r\n\r\n      (typeRepo.findOne as jest.Mock).mockResolvedValue({\r\n        id: 1,\r\n        typeCode: 'MEMO',\r\n      });\r\n      (statusRepo.findOne as jest.Mock).mockResolvedValue({\r\n        id: 1,\r\n        statusCode: 'DRAFT',\r\n      });\r\n\r\n      (numberingService.generateNextNumber as jest.Mock).mockResolvedValue({\r\n        number: 'DOC-001',\r\n      });\r\n\r\n      mockDataSource.manager.findOne\r\n        .mockResolvedValueOnce({ id: 10, organizationCode: 'ORG' })\r\n        .mockResolvedValueOnce({ id: 20, organizationCode: 'REC' });\r\n\r\n      const queryRunner = {\r\n        connect: jest.fn(),\r\n        startTransaction: jest.fn(),\r\n        commitTransaction: jest.fn(),\r\n        rollbackTransaction: jest.fn(),\r\n        release: jest.fn(),\r\n        manager: {\r\n          create: jest.fn(\r\n            (_entity: unknown, payload: Record<string, unknown>) => payload\r\n          ),\r\n          save: jest\r\n            .fn()\r\n            .mockResolvedValueOnce({ id: 999, publicId: 'corr-uuid' })\r\n            .mockResolvedValueOnce({ id: 1000 })\r\n            .mockResolvedValueOnce([]),\r\n          findOne: jest.fn(),\r\n        },\r\n      };\r\n\r\n      (mockDataSource.createQueryRunner as jest.Mock).mockReturnValue(\r\n        queryRunner\r\n      );\r\n\r\n      await service.create(createDto, mockUser);\r\n\r\n      expect(queryRunner.manager.create).toHaveBeenCalledWith(\r\n        CorrespondenceRevision,\r\n        expect.objectContaining({ revisionLabel: null })\r\n      );\r\n    });\r\n  });\r\n});\r\n"],"version":3} \ No newline at end of file diff --git a/backend/src/.jest-cache/jest-transform-cache-60cab15b743c6776f41d29bcac696b99-12533232bd0f05f65688e7a7764bf3fb/3e/correspondenceservicespec_3ec95775e6a66568410dc80a476cb50b.map b/backend/src/.jest-cache/jest-transform-cache-60cab15b743c6776f41d29bcac696b99-12533232bd0f05f65688e7a7764bf3fb/3e/correspondenceservicespec_3ec95775e6a66568410dc80a476cb50b.map new file mode 100644 index 0000000..53056ca --- /dev/null +++ b/backend/src/.jest-cache/jest-transform-cache-60cab15b743c6776f41d29bcac696b99-12533232bd0f05f65688e7a7764bf3fb/3e/correspondenceservicespec_3ec95775e6a66568410dc80a476cb50b.map @@ -0,0 +1 @@ +{"file":"E:\\np-dms\\lcbp3\\backend\\src\\modules\\correspondence\\correspondence.service.spec.ts","mappings":"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","names":[],"sources":["E:\\np-dms\\lcbp3\\backend\\src\\modules\\correspondence\\correspondence.service.spec.ts"],"sourcesContent":["import { Test, TestingModule } from '@nestjs/testing';\r\nimport { getRepositoryToken } from '@nestjs/typeorm';\r\nimport { DataSource, Repository } from 'typeorm';\r\nimport { CorrespondenceService } from './correspondence.service';\r\nimport { Correspondence } from './entities/correspondence.entity';\r\nimport { CorrespondenceRevision } from './entities/correspondence-revision.entity';\r\nimport { CorrespondenceType } from './entities/correspondence-type.entity';\r\nimport { CorrespondenceStatus } from './entities/correspondence-status.entity';\r\nimport { CorrespondenceReference } from './entities/correspondence-reference.entity';\r\nimport { CorrespondenceTag } from './entities/correspondence-tag.entity';\r\nimport { Organization } from '../organization/entities/organization.entity';\r\nimport { CorrespondenceRecipient } from './entities/correspondence-recipient.entity';\r\nimport { DocumentNumberingService } from '../document-numbering/services/document-numbering.service';\r\nimport { JsonSchemaService } from '../json-schema/json-schema.service';\r\nimport { WorkflowEngineService } from '../workflow-engine/workflow-engine.service';\r\nimport { UserService } from '../user/user.service';\r\nimport { SearchService } from '../search/search.service';\r\nimport { FileStorageService } from '../../common/file-storage/file-storage.service';\r\nimport { UuidResolverService } from '../../common/services/uuid-resolver.service';\r\nimport { NotificationService } from '../notification/notification.service';\r\nimport { UpdateCorrespondenceDto } from './dto/update-correspondence.dto';\r\nimport { CreateCorrespondenceDto } from './dto/create-correspondence.dto';\r\nimport { User } from '../user/entities/user.entity';\r\n\r\ndescribe('CorrespondenceService', () => {\r\n let service: CorrespondenceService;\r\n let numberingService: DocumentNumberingService;\r\n let correspondenceRepo: Repository;\r\n let revisionRepo: Repository;\r\n let testingModule: TestingModule;\r\n let _dataSource: DataSource;\r\n\r\n const createMockRepository = () => ({\r\n find: jest.fn(),\r\n findOne: jest.fn(),\r\n create: jest.fn(),\r\n save: jest.fn(),\r\n update: jest.fn(),\r\n delete: jest.fn(),\r\n softDelete: jest.fn(),\r\n createQueryBuilder: jest.fn(() => ({\r\n leftJoinAndSelect: jest.fn().mockReturnThis(),\r\n where: jest.fn().mockReturnThis(),\r\n andWhere: jest.fn().mockReturnThis(),\r\n orderBy: jest.fn().mockReturnThis(),\r\n skip: jest.fn().mockReturnThis(),\r\n take: jest.fn().mockReturnThis(),\r\n getOne: jest.fn().mockResolvedValue(null),\r\n getMany: jest.fn().mockResolvedValue([]),\r\n getManyAndCount: jest.fn().mockResolvedValue([[], 0]),\r\n })),\r\n });\r\n\r\n const mockDataSource = {\r\n createQueryRunner: jest.fn(() => ({\r\n connect: jest.fn(),\r\n startTransaction: jest.fn(),\r\n commitTransaction: jest.fn(),\r\n rollbackTransaction: jest.fn(),\r\n release: jest.fn(),\r\n manager: {\r\n create: jest.fn(),\r\n save: jest.fn(),\r\n findOne: jest.fn(),\r\n },\r\n })),\r\n getRepository: jest.fn(() => createMockRepository()),\r\n manager: {\r\n findOne: jest.fn(),\r\n },\r\n };\r\n\r\n beforeEach(async () => {\r\n testingModule = await Test.createTestingModule({\r\n providers: [\r\n CorrespondenceService,\r\n {\r\n provide: getRepositoryToken(Correspondence),\r\n useValue: createMockRepository(),\r\n },\r\n {\r\n provide: getRepositoryToken(CorrespondenceRevision),\r\n useValue: createMockRepository(),\r\n },\r\n {\r\n provide: getRepositoryToken(CorrespondenceType),\r\n useValue: createMockRepository(),\r\n },\r\n {\r\n provide: getRepositoryToken(CorrespondenceStatus),\r\n useValue: createMockRepository(),\r\n },\r\n {\r\n provide: getRepositoryToken(CorrespondenceReference),\r\n useValue: createMockRepository(),\r\n },\r\n {\r\n provide: getRepositoryToken(CorrespondenceTag),\r\n useValue: createMockRepository(),\r\n },\r\n {\r\n provide: getRepositoryToken(Organization),\r\n useValue: createMockRepository(),\r\n },\r\n {\r\n provide: getRepositoryToken(CorrespondenceRecipient),\r\n useValue: createMockRepository(),\r\n },\r\n {\r\n provide: DocumentNumberingService,\r\n useValue: {\r\n generateNextNumber: jest.fn(),\r\n updateNumberForDraft: jest.fn(),\r\n previewNextNumber: jest.fn(),\r\n },\r\n },\r\n {\r\n provide: JsonSchemaService,\r\n useValue: { validate: jest.fn() },\r\n },\r\n {\r\n provide: WorkflowEngineService,\r\n useValue: { createInstance: jest.fn() },\r\n },\r\n {\r\n provide: UserService,\r\n useValue: {\r\n findOne: jest.fn(),\r\n getUserPermissions: jest.fn().mockResolvedValue([]),\r\n },\r\n },\r\n {\r\n provide: DataSource,\r\n useValue: mockDataSource,\r\n },\r\n {\r\n provide: SearchService,\r\n useValue: { indexDocument: jest.fn() },\r\n },\r\n {\r\n provide: FileStorageService,\r\n useValue: { commit: jest.fn().mockResolvedValue([]) },\r\n },\r\n {\r\n provide: UuidResolverService,\r\n useValue: {\r\n resolveProjectId: jest.fn().mockResolvedValue(1),\r\n resolveOrganizationId: jest.fn().mockResolvedValue(1),\r\n },\r\n },\r\n {\r\n provide: NotificationService,\r\n useValue: { send: jest.fn().mockResolvedValue(undefined) },\r\n },\r\n ],\r\n }).compile();\r\n\r\n service = testingModule.get(CorrespondenceService);\r\n numberingService = testingModule.get(\r\n DocumentNumberingService\r\n );\r\n correspondenceRepo = testingModule.get>(\r\n getRepositoryToken(Correspondence)\r\n );\r\n revisionRepo = testingModule.get>(\r\n getRepositoryToken(CorrespondenceRevision)\r\n );\r\n _dataSource = testingModule.get(DataSource);\r\n });\r\n\r\n it('should be defined', () => {\r\n expect(service).toBeDefined();\r\n });\r\n\r\n describe('update', () => {\r\n it('should NOT regenerate number if critical fields unchanged', async () => {\r\n const mockUser = { id: 1, primaryOrganizationId: 10 } as unknown as User;\r\n const mockRevision = {\r\n id: 100,\r\n correspondenceId: 1,\r\n isCurrent: true,\r\n statusId: 5,\r\n };\r\n\r\n jest\r\n .spyOn(revisionRepo, 'findOne')\r\n .mockResolvedValue(mockRevision as unknown as CorrespondenceRevision);\r\n\r\n const mockCorr = {\r\n id: 1,\r\n projectId: 1,\r\n correspondenceTypeId: 2,\r\n disciplineId: 3,\r\n originatorId: 10,\r\n correspondenceNumber: 'OLD-NUM',\r\n recipients: [{ recipientType: 'TO', recipientOrganizationId: 99 }],\r\n };\r\n jest\r\n .spyOn(correspondenceRepo, 'findOne')\r\n .mockResolvedValue(mockCorr as unknown as Correspondence);\r\n\r\n const updateDto: UpdateCorrespondenceDto = {\r\n projectId: 1,\r\n disciplineId: 3,\r\n };\r\n\r\n await service.update(1, updateDto, mockUser);\r\n\r\n expect(\r\n numberingService.updateNumberForDraft as jest.Mock\r\n ).not.toHaveBeenCalled();\r\n });\r\n\r\n it('should regenerate number if Project ID changes', async () => {\r\n const mockUser = { id: 1, primaryOrganizationId: 10 } as unknown as User;\r\n const mockRevision = {\r\n id: 100,\r\n correspondenceId: 1,\r\n isCurrent: true,\r\n statusId: 5,\r\n };\r\n jest\r\n .spyOn(revisionRepo, 'findOne')\r\n .mockResolvedValue(mockRevision as unknown as CorrespondenceRevision);\r\n\r\n const mockCorr = {\r\n id: 1,\r\n projectId: 1,\r\n correspondenceTypeId: 2,\r\n disciplineId: 3,\r\n originatorId: 10,\r\n correspondenceNumber: 'OLD-NUM',\r\n recipients: [{ recipientType: 'TO', recipientOrganizationId: 99 }],\r\n };\r\n jest\r\n .spyOn(correspondenceRepo, 'findOne')\r\n .mockResolvedValue(mockCorr as unknown as Correspondence);\r\n\r\n const updateDto: UpdateCorrespondenceDto = {\r\n projectId: 2,\r\n };\r\n\r\n const uuidResolver =\r\n testingModule.get(UuidResolverService);\r\n (uuidResolver.resolveProjectId as jest.Mock).mockResolvedValue(2);\r\n\r\n await service.update(1, updateDto, mockUser);\r\n\r\n expect(\r\n numberingService.updateNumberForDraft as jest.Mock\r\n ).toHaveBeenCalled();\r\n });\r\n\r\n it('should regenerate number if Document Type changes', async () => {\r\n const mockUser = { id: 1, primaryOrganizationId: 10 } as unknown as User;\r\n const mockRevision = {\r\n id: 100,\r\n correspondenceId: 1,\r\n isCurrent: true,\r\n statusId: 5,\r\n };\r\n jest\r\n .spyOn(revisionRepo, 'findOne')\r\n .mockResolvedValue(mockRevision as unknown as CorrespondenceRevision);\r\n\r\n const mockCorr = {\r\n id: 1,\r\n projectId: 1,\r\n correspondenceTypeId: 2,\r\n disciplineId: 3,\r\n originatorId: 10,\r\n correspondenceNumber: 'OLD-NUM',\r\n recipients: [{ recipientType: 'TO', recipientOrganizationId: 99 }],\r\n };\r\n jest\r\n .spyOn(correspondenceRepo, 'findOne')\r\n .mockResolvedValue(mockCorr as unknown as Correspondence);\r\n\r\n const updateDto: UpdateCorrespondenceDto = {\r\n typeId: 999,\r\n };\r\n\r\n const typeRepo = testingModule.get>(\r\n getRepositoryToken(CorrespondenceType)\r\n );\r\n (typeRepo.findOne as jest.Mock).mockResolvedValue({\r\n id: 999,\r\n typeCode: 'NEW-TYPE',\r\n });\r\n\r\n await service.update(1, updateDto, mockUser);\r\n\r\n expect(\r\n numberingService.updateNumberForDraft as jest.Mock\r\n ).toHaveBeenCalled();\r\n });\r\n\r\n it('should regenerate number if Recipient Organization changes', async () => {\r\n const mockUser = { id: 1, primaryOrganizationId: 10 } as unknown as User;\r\n const mockRevision = {\r\n id: 100,\r\n correspondenceId: 1,\r\n isCurrent: true,\r\n statusId: 5,\r\n };\r\n jest\r\n .spyOn(revisionRepo, 'findOne')\r\n .mockResolvedValue(mockRevision as unknown as CorrespondenceRevision);\r\n\r\n const mockCorr = {\r\n id: 1,\r\n projectId: 1,\r\n correspondenceTypeId: 2,\r\n disciplineId: 3,\r\n originatorId: 10,\r\n correspondenceNumber: 'OLD-NUM',\r\n recipients: [{ recipientType: 'TO', recipientOrganizationId: 99 }],\r\n };\r\n jest\r\n .spyOn(correspondenceRepo, 'findOne')\r\n .mockResolvedValue(mockCorr as unknown as Correspondence);\r\n\r\n // Access DataSource manager for mocking\r\n mockDataSource.manager.findOne.mockResolvedValue({\r\n id: 88,\r\n organizationCode: 'NEW-ORG',\r\n } as unknown as Organization);\r\n\r\n const updateDto: UpdateCorrespondenceDto = {\r\n recipients: [{ type: 'TO', organizationId: 88 }],\r\n };\r\n\r\n await service.update(1, updateDto, mockUser);\r\n\r\n expect(\r\n numberingService.updateNumberForDraft as jest.Mock\r\n ).toHaveBeenCalled();\r\n });\r\n });\r\n\r\n describe('create', () => {\r\n it('should allow system.manage_all user without primaryOrganizationId when originatorId is provided', async () => {\r\n const mockUser = {\r\n user_id: 1,\r\n primaryOrganizationId: null,\r\n } as unknown as User;\r\n\r\n const createDto: CreateCorrespondenceDto = {\r\n projectId: 'project-uuid',\r\n typeId: 1,\r\n subject: 'Test Subject',\r\n originatorId: 'originator-uuid',\r\n recipients: [{ organizationId: 'recipient-uuid', type: 'TO' }],\r\n };\r\n\r\n const userService = testingModule.get(UserService);\r\n const typeRepo = testingModule.get>(\r\n getRepositoryToken(CorrespondenceType)\r\n );\r\n const statusRepo = testingModule.get>(\r\n getRepositoryToken(CorrespondenceStatus)\r\n );\r\n const uuidResolver =\r\n testingModule.get(UuidResolverService);\r\n\r\n (userService.findOne as jest.Mock).mockResolvedValue({\r\n user_id: 1,\r\n primaryOrganizationId: null,\r\n });\r\n (userService.getUserPermissions as jest.Mock).mockResolvedValue([\r\n 'system.manage_all',\r\n ]);\r\n\r\n (uuidResolver.resolveProjectId as jest.Mock).mockResolvedValue(100);\r\n (uuidResolver.resolveOrganizationId as jest.Mock).mockImplementation(\r\n (value: number | string) => {\r\n if (value === 'originator-uuid') return 10;\r\n if (value === 'recipient-uuid') return 20;\r\n return 0;\r\n }\r\n );\r\n\r\n (typeRepo.findOne as jest.Mock).mockResolvedValue({\r\n id: 1,\r\n typeCode: 'LTR',\r\n });\r\n (statusRepo.findOne as jest.Mock).mockResolvedValue({\r\n id: 1,\r\n statusCode: 'DRAFT',\r\n });\r\n\r\n (numberingService.generateNextNumber as jest.Mock).mockResolvedValue({\r\n number: 'DOC-001',\r\n });\r\n\r\n mockDataSource.manager.findOne\r\n .mockResolvedValueOnce({ id: 10, organizationCode: 'ORG' })\r\n .mockResolvedValueOnce({ id: 20, organizationCode: 'REC' });\r\n\r\n const queryRunner = {\r\n connect: jest.fn(),\r\n startTransaction: jest.fn(),\r\n commitTransaction: jest.fn(),\r\n rollbackTransaction: jest.fn(),\r\n release: jest.fn(),\r\n manager: {\r\n create: jest.fn(\r\n (_entity: unknown, payload: Record) => payload\r\n ),\r\n save: jest\r\n .fn()\r\n .mockResolvedValueOnce({ id: 999, publicId: 'corr-uuid' })\r\n .mockResolvedValueOnce({ id: 1000 })\r\n .mockResolvedValueOnce([]),\r\n findOne: jest.fn(),\r\n },\r\n };\r\n\r\n (mockDataSource.createQueryRunner as jest.Mock).mockReturnValue(\r\n queryRunner\r\n );\r\n\r\n await service.create(createDto, mockUser);\r\n\r\n expect(queryRunner.manager.create).toHaveBeenCalledWith(\r\n Correspondence,\r\n expect.objectContaining({ originatorId: 10 })\r\n );\r\n });\r\n\r\n it('should set revisionLabel to \"A\" for RFA type', async () => {\r\n const mockUser = {\r\n user_id: 1,\r\n primaryOrganizationId: 10,\r\n } as unknown as User;\r\n\r\n const createDto: CreateCorrespondenceDto = {\r\n projectId: 'project-uuid',\r\n typeId: 1,\r\n subject: 'Test Subject',\r\n recipients: [{ organizationId: 'recipient-uuid', type: 'TO' }],\r\n };\r\n\r\n const typeRepo = testingModule.get>(\r\n getRepositoryToken(CorrespondenceType)\r\n );\r\n const statusRepo = testingModule.get>(\r\n getRepositoryToken(CorrespondenceStatus)\r\n );\r\n const uuidResolver =\r\n testingModule.get(UuidResolverService);\r\n\r\n (uuidResolver.resolveProjectId as jest.Mock).mockResolvedValue(100);\r\n (uuidResolver.resolveOrganizationId as jest.Mock).mockResolvedValue(20);\r\n\r\n (typeRepo.findOne as jest.Mock).mockResolvedValue({\r\n id: 1,\r\n typeCode: 'RFA',\r\n });\r\n (statusRepo.findOne as jest.Mock).mockResolvedValue({\r\n id: 1,\r\n statusCode: 'DRAFT',\r\n });\r\n\r\n (numberingService.generateNextNumber as jest.Mock).mockResolvedValue({\r\n number: 'DOC-001',\r\n });\r\n\r\n mockDataSource.manager.findOne\r\n .mockResolvedValueOnce({ id: 10, organizationCode: 'ORG' })\r\n .mockResolvedValueOnce({ id: 20, organizationCode: 'REC' });\r\n\r\n const queryRunner = {\r\n connect: jest.fn(),\r\n startTransaction: jest.fn(),\r\n commitTransaction: jest.fn(),\r\n rollbackTransaction: jest.fn(),\r\n release: jest.fn(),\r\n manager: {\r\n create: jest.fn(\r\n (_entity: unknown, payload: Record) => payload\r\n ),\r\n save: jest\r\n .fn()\r\n .mockResolvedValueOnce({ id: 999, publicId: 'corr-uuid' })\r\n .mockResolvedValueOnce({ id: 1000 })\r\n .mockResolvedValueOnce([]),\r\n findOne: jest.fn(),\r\n },\r\n };\r\n\r\n (mockDataSource.createQueryRunner as jest.Mock).mockReturnValue(\r\n queryRunner\r\n );\r\n\r\n await service.create(createDto, mockUser);\r\n\r\n expect(queryRunner.manager.create).toHaveBeenCalledWith(\r\n CorrespondenceRevision,\r\n expect.objectContaining({ revisionLabel: 'A' })\r\n );\r\n });\r\n\r\n it('should set revisionLabel to \"A\" for RFI type', async () => {\r\n const mockUser = {\r\n user_id: 1,\r\n primaryOrganizationId: 10,\r\n } as unknown as User;\r\n\r\n const createDto: CreateCorrespondenceDto = {\r\n projectId: 'project-uuid',\r\n typeId: 1,\r\n subject: 'Test Subject',\r\n recipients: [{ organizationId: 'recipient-uuid', type: 'TO' }],\r\n };\r\n\r\n const typeRepo = testingModule.get>(\r\n getRepositoryToken(CorrespondenceType)\r\n );\r\n const statusRepo = testingModule.get>(\r\n getRepositoryToken(CorrespondenceStatus)\r\n );\r\n const uuidResolver =\r\n testingModule.get(UuidResolverService);\r\n\r\n (uuidResolver.resolveProjectId as jest.Mock).mockResolvedValue(100);\r\n (uuidResolver.resolveOrganizationId as jest.Mock).mockResolvedValue(20);\r\n\r\n (typeRepo.findOne as jest.Mock).mockResolvedValue({\r\n id: 1,\r\n typeCode: 'RFI',\r\n });\r\n (statusRepo.findOne as jest.Mock).mockResolvedValue({\r\n id: 1,\r\n statusCode: 'DRAFT',\r\n });\r\n\r\n (numberingService.generateNextNumber as jest.Mock).mockResolvedValue({\r\n number: 'DOC-001',\r\n });\r\n\r\n mockDataSource.manager.findOne\r\n .mockResolvedValueOnce({ id: 10, organizationCode: 'ORG' })\r\n .mockResolvedValueOnce({ id: 20, organizationCode: 'REC' });\r\n\r\n const queryRunner = {\r\n connect: jest.fn(),\r\n startTransaction: jest.fn(),\r\n commitTransaction: jest.fn(),\r\n rollbackTransaction: jest.fn(),\r\n release: jest.fn(),\r\n manager: {\r\n create: jest.fn(\r\n (_entity: unknown, payload: Record) => payload\r\n ),\r\n save: jest\r\n .fn()\r\n .mockResolvedValueOnce({ id: 999, publicId: 'corr-uuid' })\r\n .mockResolvedValueOnce({ id: 1000 })\r\n .mockResolvedValueOnce([]),\r\n findOne: jest.fn(),\r\n },\r\n };\r\n\r\n (mockDataSource.createQueryRunner as jest.Mock).mockReturnValue(\r\n queryRunner\r\n );\r\n\r\n await service.create(createDto, mockUser);\r\n\r\n expect(queryRunner.manager.create).toHaveBeenCalledWith(\r\n CorrespondenceRevision,\r\n expect.objectContaining({ revisionLabel: 'A' })\r\n );\r\n });\r\n\r\n it('should set revisionLabel to null for LETTER type', async () => {\r\n const mockUser = {\r\n user_id: 1,\r\n primaryOrganizationId: 10,\r\n } as unknown as User;\r\n\r\n const createDto: CreateCorrespondenceDto = {\r\n projectId: 'project-uuid',\r\n typeId: 1,\r\n subject: 'Test Subject',\r\n recipients: [{ organizationId: 'recipient-uuid', type: 'TO' }],\r\n };\r\n\r\n const typeRepo = testingModule.get>(\r\n getRepositoryToken(CorrespondenceType)\r\n );\r\n const statusRepo = testingModule.get>(\r\n getRepositoryToken(CorrespondenceStatus)\r\n );\r\n const uuidResolver =\r\n testingModule.get(UuidResolverService);\r\n\r\n (uuidResolver.resolveProjectId as jest.Mock).mockResolvedValue(100);\r\n (uuidResolver.resolveOrganizationId as jest.Mock).mockResolvedValue(20);\r\n\r\n (typeRepo.findOne as jest.Mock).mockResolvedValue({\r\n id: 1,\r\n typeCode: 'LETTER',\r\n });\r\n (statusRepo.findOne as jest.Mock).mockResolvedValue({\r\n id: 1,\r\n statusCode: 'DRAFT',\r\n });\r\n\r\n (numberingService.generateNextNumber as jest.Mock).mockResolvedValue({\r\n number: 'DOC-001',\r\n });\r\n\r\n mockDataSource.manager.findOne\r\n .mockResolvedValueOnce({ id: 10, organizationCode: 'ORG' })\r\n .mockResolvedValueOnce({ id: 20, organizationCode: 'REC' });\r\n\r\n const queryRunner = {\r\n connect: jest.fn(),\r\n startTransaction: jest.fn(),\r\n commitTransaction: jest.fn(),\r\n rollbackTransaction: jest.fn(),\r\n release: jest.fn(),\r\n manager: {\r\n create: jest.fn(\r\n (_entity: unknown, payload: Record) => payload\r\n ),\r\n save: jest\r\n .fn()\r\n .mockResolvedValueOnce({ id: 999, publicId: 'corr-uuid' })\r\n .mockResolvedValueOnce({ id: 1000 })\r\n .mockResolvedValueOnce([]),\r\n findOne: jest.fn(),\r\n },\r\n };\r\n\r\n (mockDataSource.createQueryRunner as jest.Mock).mockReturnValue(\r\n queryRunner\r\n );\r\n\r\n await service.create(createDto, mockUser);\r\n\r\n expect(queryRunner.manager.create).toHaveBeenCalledWith(\r\n CorrespondenceRevision,\r\n expect.objectContaining({ revisionLabel: null })\r\n );\r\n });\r\n\r\n it('should set revisionLabel to null for MEMO type', async () => {\r\n const mockUser = {\r\n user_id: 1,\r\n primaryOrganizationId: 10,\r\n } as unknown as User;\r\n\r\n const createDto: CreateCorrespondenceDto = {\r\n projectId: 'project-uuid',\r\n typeId: 1,\r\n subject: 'Test Subject',\r\n recipients: [{ organizationId: 'recipient-uuid', type: 'TO' }],\r\n };\r\n\r\n const typeRepo = testingModule.get>(\r\n getRepositoryToken(CorrespondenceType)\r\n );\r\n const statusRepo = testingModule.get>(\r\n getRepositoryToken(CorrespondenceStatus)\r\n );\r\n const uuidResolver =\r\n testingModule.get(UuidResolverService);\r\n\r\n (uuidResolver.resolveProjectId as jest.Mock).mockResolvedValue(100);\r\n (uuidResolver.resolveOrganizationId as jest.Mock).mockResolvedValue(20);\r\n\r\n (typeRepo.findOne as jest.Mock).mockResolvedValue({\r\n id: 1,\r\n typeCode: 'MEMO',\r\n });\r\n (statusRepo.findOne as jest.Mock).mockResolvedValue({\r\n id: 1,\r\n statusCode: 'DRAFT',\r\n });\r\n\r\n (numberingService.generateNextNumber as jest.Mock).mockResolvedValue({\r\n number: 'DOC-001',\r\n });\r\n\r\n mockDataSource.manager.findOne\r\n .mockResolvedValueOnce({ id: 10, organizationCode: 'ORG' })\r\n .mockResolvedValueOnce({ id: 20, organizationCode: 'REC' });\r\n\r\n const queryRunner = {\r\n connect: jest.fn(),\r\n startTransaction: jest.fn(),\r\n commitTransaction: jest.fn(),\r\n rollbackTransaction: jest.fn(),\r\n release: jest.fn(),\r\n manager: {\r\n create: jest.fn(\r\n (_entity: unknown, payload: Record) => payload\r\n ),\r\n save: jest\r\n .fn()\r\n .mockResolvedValueOnce({ id: 999, publicId: 'corr-uuid' })\r\n .mockResolvedValueOnce({ id: 1000 })\r\n .mockResolvedValueOnce([]),\r\n findOne: jest.fn(),\r\n },\r\n };\r\n\r\n (mockDataSource.createQueryRunner as jest.Mock).mockReturnValue(\r\n queryRunner\r\n );\r\n\r\n await service.create(createDto, mockUser);\r\n\r\n expect(queryRunner.manager.create).toHaveBeenCalledWith(\r\n CorrespondenceRevision,\r\n expect.objectContaining({ revisionLabel: null })\r\n );\r\n });\r\n });\r\n});\r\n"],"version":3} \ No newline at end of file diff --git a/backend/src/.jest-cache/jest-transform-cache-60cab15b743c6776f41d29bcac696b99-12533232bd0f05f65688e7a7764bf3fb/50/correspondenceservice_502139c633196704eef09d9c7ce64dc0 b/backend/src/.jest-cache/jest-transform-cache-60cab15b743c6776f41d29bcac696b99-12533232bd0f05f65688e7a7764bf3fb/50/correspondenceservice_502139c633196704eef09d9c7ce64dc0 new file mode 100644 index 0000000..2d2ada4 --- /dev/null +++ b/backend/src/.jest-cache/jest-transform-cache-60cab15b743c6776f41d29bcac696b99-12533232bd0f05f65688e7a7764bf3fb/50/correspondenceservice_502139c633196704eef09d9c7ce64dc0 @@ -0,0 +1,893 @@ +f6b8b3a06a5f56cde244a136c6d4bc18 +"use strict"; +// File: src/modules/correspondence/correspondence.service.ts +var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; +}; +var __metadata = (this && this.__metadata) || function (k, v) { + if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v); +}; +var __param = (this && this.__param) || function (paramIndex, decorator) { + return function (target, key) { decorator(target, key, paramIndex); } +}; +var CorrespondenceService_1; +var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.CorrespondenceService = void 0; +const common_1 = require("@nestjs/common"); +const typeorm_1 = require("@nestjs/typeorm"); +const typeorm_2 = require("typeorm"); +// Entities +const correspondence_entity_1 = require("./entities/correspondence.entity"); +const correspondence_revision_entity_1 = require("./entities/correspondence-revision.entity"); +const correspondence_type_entity_1 = require("./entities/correspondence-type.entity"); +const correspondence_status_entity_1 = require("./entities/correspondence-status.entity"); +const correspondence_reference_entity_1 = require("./entities/correspondence-reference.entity"); +const correspondence_recipient_entity_1 = require("./entities/correspondence-recipient.entity"); +const correspondence_tag_entity_1 = require("./entities/correspondence-tag.entity"); +const tag_entity_1 = require("../master/entities/tag.entity"); +const organization_entity_1 = require("../organization/entities/organization.entity"); +// Services +const document_numbering_service_1 = require("../document-numbering/services/document-numbering.service"); +const json_schema_service_1 = require("../json-schema/json-schema.service"); +const workflow_engine_service_1 = require("../workflow-engine/workflow-engine.service"); +const user_service_1 = require("../user/user.service"); +const search_service_1 = require("../search/search.service"); +const file_storage_service_1 = require("../../common/file-storage/file-storage.service"); +const uuid_resolver_service_1 = require("../../common/services/uuid-resolver.service"); +const notification_service_1 = require("../notification/notification.service"); +let CorrespondenceService = CorrespondenceService_1 = class CorrespondenceService { + async hasSystemManageAllPermission(userId) { + const permissions = await this.userService.getUserPermissions(userId); + return permissions.includes('system.manage_all'); + } + /** + * Business Rule: Revision Label Strategy + * - RFA, RFI: Use alphabet starting with 'A' (A, B, C...) + * - Other types (LETTER, MEMO, etc.): Use numeric (null for first, then 1, 2, 3...) + */ + getInitialRevisionLabel(typeCode) { + const alphabetTypes = ['RFA', 'RFI']; + if (alphabetTypes.includes(typeCode.toUpperCase())) { + return 'A'; // Alphabet for RFA, RFI + } + return null; // Numeric (null for revision 0) + } + constructor(correspondenceRepo, revisionRepo, typeRepo, statusRepo, referenceRepo, tagRepo, numberingService, jsonSchemaService, workflowEngine, userService, dataSource, searchService, fileStorageService, uuidResolver, notificationService) { + this.correspondenceRepo = correspondenceRepo; + this.revisionRepo = revisionRepo; + this.typeRepo = typeRepo; + this.statusRepo = statusRepo; + this.referenceRepo = referenceRepo; + this.tagRepo = tagRepo; + this.numberingService = numberingService; + this.jsonSchemaService = jsonSchemaService; + this.workflowEngine = workflowEngine; + this.userService = userService; + this.dataSource = dataSource; + this.searchService = searchService; + this.fileStorageService = fileStorageService; + this.uuidResolver = uuidResolver; + this.notificationService = notificationService; + this.logger = new common_1.Logger(CorrespondenceService_1.name); + } + /** + * Business Rule Validation: EC-CORR-003 - Correspondence to Self + * Prevent external correspondence to same organization + */ + async validateCorrespondenceRecipients(createDto, user) { + // Get user's organization + let userOrgId = user.primaryOrganizationId; + if (!userOrgId) { + const fullUser = await this.userService.findOne(user.user_id); + if (fullUser) { + userOrgId = fullUser.primaryOrganizationId; + } + } + if (!userOrgId) { + if (createDto.originatorId) { + const canManageAll = await this.hasSystemManageAllPermission(user.user_id); + if (canManageAll) { + userOrgId = await this.uuidResolver.resolveOrganizationId(createDto.originatorId); + } + } + if (!userOrgId) { + throw new common_1.BadRequestException('User must belong to an organization to create documents'); + } + } + // For impersonation, use the specified originator + const originatorOrgId = createDto.originatorId + ? await this.uuidResolver.resolveOrganizationId(createDto.originatorId) + : userOrgId; + // Check if it's internal communication + if (createDto.isInternal) { + // Internal communications should use Circulation instead + throw new common_1.BadRequestException('Internal communications should use Circulation Sheet instead of Correspondence'); + } + // Validate recipients + if (!createDto.recipients || createDto.recipients.length === 0) { + throw new common_1.BadRequestException('At least one recipient (TO or CC) is required'); + } + const toRecipients = createDto.recipients.filter((r) => r.type === 'TO'); + const ccRecipients = createDto.recipients.filter((r) => r.type === 'CC'); + if (toRecipients.length === 0 && ccRecipients.length === 0) { + throw new common_1.BadRequestException('At least one TO or CC recipient is required'); + } + // Check for same organization correspondence + for (const recipient of createDto.recipients) { + const recipientOrgId = await this.uuidResolver.resolveOrganizationId(recipient.organizationId); + if (recipientOrgId === originatorOrgId) { + throw new common_1.BadRequestException('Cannot send correspondence to your own organization. Use Circulation Sheet for internal communication.'); + } + } + } + async create(createDto, user) { + // Business Rule Validation: EC-CORR-003 - Correspondence to Self + await this.validateCorrespondenceRecipients(createDto, user); + // ADR-019: Resolve UUID references to internal INT IDs + const resolvedProjectId = await this.uuidResolver.resolveProjectId(createDto.projectId); + const resolvedOriginatorId = createDto.originatorId + ? await this.uuidResolver.resolveOrganizationId(createDto.originatorId) + : undefined; + const resolvedRecipients = createDto.recipients + ? await Promise.all(createDto.recipients.map(async (r) => ({ + organizationId: await this.uuidResolver.resolveOrganizationId(r.organizationId), + type: r.type, + }))) + : undefined; + const type = await this.typeRepo.findOne({ + where: { id: createDto.typeId }, + }); + if (!type) + throw new common_1.NotFoundException('Document Type not found'); + const statusDraft = await this.statusRepo.findOne({ + where: { statusCode: 'DRAFT' }, + }); + if (!statusDraft) { + throw new common_1.InternalServerErrorException('Status DRAFT not found in Master Data'); + } + let userOrgId = user.primaryOrganizationId; + if (!userOrgId) { + const fullUser = await this.userService.findOne(user.user_id); + if (fullUser) { + userOrgId = fullUser.primaryOrganizationId; + } + } + // Impersonation Logic + if (resolvedOriginatorId && resolvedOriginatorId !== userOrgId) { + const canManageAll = await this.hasSystemManageAllPermission(user.user_id); + if (!canManageAll) { + throw new common_1.ForbiddenException('You do not have permission to create documents on behalf of other organizations.'); + } + userOrgId = resolvedOriginatorId; + } + if (!userOrgId) { + throw new common_1.BadRequestException('User must belong to an organization to create documents'); + } + if (createDto.details) { + try { + await this.jsonSchemaService.validate(type.typeCode, createDto.details); + } + catch (error) { + this.logger.warn(`Schema validation warning for ${type.typeCode}: ${error.message}`); + } + } + const queryRunner = this.dataSource.createQueryRunner(); + await queryRunner.connect(); + await queryRunner.startTransaction(); + try { + // [Fix #6] Fetch real ORG Code from Organization entity + const originatorOrg = await this.dataSource.manager.findOne(organization_entity_1.Organization, { + where: { id: userOrgId }, + }); + const orgCode = originatorOrg?.organizationCode ?? 'UNK'; + // [v1.5.1] Extract recipient organization from recipients array (Primary TO) + const toRecipient = resolvedRecipients?.find((r) => r.type === 'TO'); + const recipientOrganizationId = toRecipient?.organizationId; + let recipientCode = ''; + if (recipientOrganizationId) { + const recOrg = await this.dataSource.manager.findOne(organization_entity_1.Organization, { + where: { id: recipientOrganizationId }, + }); + if (recOrg) + recipientCode = recOrg.organizationCode; + } + const docNumber = await this.numberingService.generateNextNumber({ + projectId: resolvedProjectId, + originatorOrganizationId: userOrgId, + typeId: createDto.typeId, + disciplineId: createDto.disciplineId, + subTypeId: createDto.subTypeId, + recipientOrganizationId, // [v1.5.1] Pass recipient for document number format + year: new Date().getFullYear(), + customTokens: { + TYPE_CODE: type.typeCode, + ORG_CODE: orgCode, + RECIPIENT_CODE: recipientCode, + REC_CODE: recipientCode, + }, + }); + const correspondence = queryRunner.manager.create(correspondence_entity_1.Correspondence, { + correspondenceNumber: docNumber.number, + correspondenceTypeId: createDto.typeId, + disciplineId: createDto.disciplineId, + projectId: resolvedProjectId, + originatorId: userOrgId, + isInternal: createDto.isInternal || false, + createdBy: user.user_id, + }); + const savedCorr = await queryRunner.manager.save(correspondence); + const revision = queryRunner.manager.create(correspondence_revision_entity_1.CorrespondenceRevision, { + correspondenceId: savedCorr.id, + revisionNumber: 0, + revisionLabel: 'A', + isCurrent: true, + statusId: statusDraft.id, + subject: createDto.subject, + body: createDto.body, + remarks: createDto.remarks, + dueDate: createDto.dueDate ? new Date(createDto.dueDate) : undefined, + documentDate: createDto.documentDate + ? new Date(createDto.documentDate) + : undefined, + issuedDate: createDto.issuedDate + ? new Date(createDto.issuedDate) + : undefined, + receivedDate: createDto.receivedDate + ? new Date(createDto.receivedDate) + : undefined, + description: createDto.description, + details: createDto.details, + createdBy: user.user_id, + schemaVersion: 1, + }); + await queryRunner.manager.save(revision); + // Save Recipients (using resolved INT IDs) + if (resolvedRecipients && resolvedRecipients.length > 0) { + const recipients = resolvedRecipients.map((r) => queryRunner.manager.create(correspondence_recipient_entity_1.CorrespondenceRecipient, { + correspondenceId: savedCorr.id, + recipientOrganizationId: r.organizationId, + recipientType: r.type, + })); + await queryRunner.manager.save(recipients); + } + // Commit attachments from Temp → Permanent (Two-Phase Storage) + if (createDto.attachmentTempIds?.length) { + const issueDate = createDto.issuedDate + ? new Date(createDto.issuedDate) + : createDto.documentDate + ? new Date(createDto.documentDate) + : undefined; + await this.fileStorageService.commit(createDto.attachmentTempIds, { + issueDate, + documentType: 'Correspondence', + }); + } + await queryRunner.commitTransaction(); + // Start Workflow Instance (non-blocking) + try { + const workflowCode = `CORRESPONDENCE_${type.typeCode}`; + await this.workflowEngine.createInstance(workflowCode, 'correspondence', savedCorr.id.toString(), { + projectId: resolvedProjectId, + originatorId: userOrgId, + disciplineId: createDto.disciplineId, + initiatorId: user.user_id, + }); + } + catch (error) { + this.logger.warn(`Workflow not started for ${docNumber.number} (Code: CORRESPONDENCE_${type.typeCode}): ${error.message}`); + } + // Fire-and-forget search indexing (non-blocking, void intentional) + void this.searchService.indexDocument({ + id: savedCorr.id, + publicId: savedCorr.publicId, + type: 'correspondence', + docNumber: docNumber.number, + title: createDto.subject, + description: createDto.description, + status: 'DRAFT', + projectId: resolvedProjectId, + createdAt: new Date(), + }); + return { + ...savedCorr, + currentRevision: revision, + }; + } + catch (err) { + await queryRunner.rollbackTransaction(); + this.logger.error(`Failed to create correspondence: ${err.message}`); + throw err; + } + finally { + await queryRunner.release(); + } + } + async findAll(searchDto = {}) { + const { search, typeId, projectId, statusId, status, page = 1, limit = 10, } = searchDto; + const skip = (page - 1) * limit; + // Change: Query from Revision Repo + const query = this.revisionRepo + .createQueryBuilder('rev') + .leftJoinAndSelect('rev.correspondence', 'corr') + .leftJoinAndSelect('corr.type', 'type') + .leftJoinAndSelect('corr.project', 'project') + .leftJoinAndSelect('corr.originator', 'org') + .leftJoinAndSelect('rev.status', 'status'); + // Filter by Revision Status + const revStatus = searchDto.revisionStatus || 'CURRENT'; + if (revStatus === 'CURRENT') { + query.where('rev.isCurrent = :isCurrent', { isCurrent: true }); + } + else if (revStatus === 'OLD') { + query.where('rev.isCurrent = :isCurrent', { isCurrent: false }); + } + // If 'ALL', no filter needed on isCurrent + if (projectId) { + query.andWhere('corr.projectId = :projectId', { projectId }); + } + if (typeId) { + query.andWhere('corr.correspondenceTypeId = :typeId', { typeId }); + } + if (statusId) { + query.andWhere('rev.statusId = :statusId', { statusId }); + } + if (status) { + query.andWhere('status.statusCode = :status', { status }); + } + if (search) { + query.andWhere('(corr.correspondenceNumber LIKE :search OR rev.subject LIKE :search)', { search: `%${search}%` }); + } + // Default Sort: Latest Created + query.orderBy('rev.createdAt', 'DESC').skip(skip).take(limit); + const [items, total] = await query.getManyAndCount(); + return { + data: items, + meta: { + total, + page, + limit, + totalPages: Math.ceil(total / limit), + }, + }; + } + async findOne(id) { + const correspondence = await this.correspondenceRepo.findOne({ + where: { id }, + relations: [ + 'revisions', + 'revisions.status', + 'type', + 'project', + 'originator', + 'recipients', + 'recipients.recipientOrganization', // [v1.5.1] Fixed relation name + ], + }); + if (!correspondence) { + throw new common_1.NotFoundException(`Correspondence with ID ${id} not found`); + } + return correspondence; + } + async findOneByUuid(publicId) { + const correspondence = await this.correspondenceRepo.findOne({ + where: { publicId }, + relations: [ + 'revisions', + 'revisions.status', + 'type', + 'project', + 'originator', + 'recipients', + 'recipients.recipientOrganization', + ], + }); + if (!correspondence) { + throw new common_1.NotFoundException(`Correspondence with UUID ${publicId} not found`); + } + return correspondence; + } + async addReference(id, dto) { + const source = await this.correspondenceRepo.findOne({ where: { id } }); + // ADR-019: Resolve target publicId → internal INT id + const target = await this.correspondenceRepo.findOne({ + where: { publicId: dto.targetUuid }, + }); + if (!source || !target) { + throw new common_1.NotFoundException('Source or Target correspondence not found'); + } + if (source.id === target.id) { + throw new common_1.BadRequestException('Cannot reference self'); + } + const exists = await this.referenceRepo.findOne({ + where: { + sourceId: id, + targetId: target.id, + }, + }); + if (exists) { + return exists; + } + const ref = this.referenceRepo.create({ + sourceId: id, + targetId: target.id, + }); + return this.referenceRepo.save(ref); + } + async removeReference(id, targetId) { + const result = await this.referenceRepo.delete({ + sourceId: id, + targetId: targetId, + }); + if (result.affected === 0) { + throw new common_1.NotFoundException('Reference not found'); + } + } + async getTags(id) { + const rows = await this.tagRepo.find({ + where: { correspondenceId: id }, + relations: ['tag'], + }); + return rows.map((r) => r.tag).filter(Boolean); + } + async addTag(id, tagId) { + const correspondence = await this.correspondenceRepo.findOne({ + where: { id }, + }); + if (!correspondence) { + throw new common_1.NotFoundException(`Correspondence ${id} not found`); + } + const tag = await this.dataSource.manager.findOne(tag_entity_1.Tag, { + where: { id: tagId }, + }); + if (!tag) { + throw new common_1.NotFoundException(`Tag ${tagId} not found`); + } + const exists = await this.tagRepo.findOne({ + where: { correspondenceId: id, tagId }, + }); + if (exists) + return exists; + const row = this.tagRepo.create({ correspondenceId: id, tagId }); + return this.tagRepo.save(row); + } + async removeTag(id, tagId) { + const result = await this.tagRepo.delete({ correspondenceId: id, tagId }); + if (result.affected === 0) { + throw new common_1.NotFoundException('Tag assignment not found'); + } + } + async getReferences(id) { + const outgoing = await this.referenceRepo.find({ + where: { sourceId: id }, + relations: ['target', 'target.type'], + }); + const incoming = await this.referenceRepo.find({ + where: { targetId: id }, + relations: ['source', 'source.type'], + }); + return { outgoing, incoming }; + } + async update(id, updateDto, user) { + // 1. Find Current Revision + const revision = await this.revisionRepo.findOne({ + where: { + correspondenceId: id, + isCurrent: true, + }, + relations: ['correspondence'], + }); + if (!revision) { + throw new common_1.NotFoundException(`Current revision for correspondence ${id} not found`); + } + // 2. Check Permission + if (revision.statusId) { + const status = await this.statusRepo.findOne({ + where: { id: revision.statusId }, + }); + if (status && status.statusCode !== 'DRAFT') { + throw new common_1.BadRequestException('Only DRAFT documents can be updated'); + } + } + // ADR-019: Resolve UUID references in update DTO + const updResolvedProjectId = updateDto.projectId + ? await this.uuidResolver.resolveProjectId(updateDto.projectId) + : undefined; + const updResolvedOriginatorId = updateDto.originatorId + ? await this.uuidResolver.resolveOrganizationId(updateDto.originatorId) + : undefined; + const updResolvedRecipients = updateDto.recipients + ? await Promise.all(updateDto.recipients.map(async (r) => ({ + organizationId: await this.uuidResolver.resolveOrganizationId(r.organizationId), + type: r.type, + }))) + : undefined; + // 3. Update Correspondence Entity if needed + const correspondenceUpdate = {}; + if (updateDto.disciplineId) + correspondenceUpdate.disciplineId = updateDto.disciplineId; + if (updResolvedProjectId) + correspondenceUpdate.projectId = updResolvedProjectId; + if (updResolvedOriginatorId) + correspondenceUpdate.originatorId = updResolvedOriginatorId; + if (Object.keys(correspondenceUpdate).length > 0) { + await this.correspondenceRepo.update(id, correspondenceUpdate); + } + // 4. Update Revision Entity + const revisionUpdate = {}; + if (updateDto.subject) + revisionUpdate.subject = updateDto.subject; + if (updateDto.body) + revisionUpdate.body = updateDto.body; + if (updateDto.remarks) + revisionUpdate.remarks = updateDto.remarks; + // Format Date correctly if string + if (updateDto.dueDate) + revisionUpdate.dueDate = new Date(updateDto.dueDate); + if (updateDto.documentDate) + revisionUpdate.documentDate = new Date(updateDto.documentDate); + if (updateDto.issuedDate) + revisionUpdate.issuedDate = new Date(updateDto.issuedDate); + if (updateDto.receivedDate) + revisionUpdate.receivedDate = new Date(updateDto.receivedDate); + if (updateDto.description) + revisionUpdate.description = updateDto.description; + if (updateDto.details) + revisionUpdate.details = updateDto.details; + if (Object.keys(revisionUpdate).length > 0) { + await this.revisionRepo.update(revision.id, revisionUpdate); + } + // 4.5 Commit new attachments from Temp → Permanent (Two-Phase Storage) + if (updateDto.attachmentTempIds?.length) { + const issueDate = updateDto.issuedDate + ? new Date(updateDto.issuedDate) + : updateDto.documentDate + ? new Date(updateDto.documentDate) + : revision.issuedDate || revision.documentDate || undefined; + await this.fileStorageService.commit(updateDto.attachmentTempIds, { + issueDate: issueDate ? new Date(issueDate) : undefined, + documentType: 'Correspondence', + }); + } + // 5. Update Recipients if provided + if (updResolvedRecipients) { + const recipientRepo = this.dataSource.getRepository(correspondence_recipient_entity_1.CorrespondenceRecipient); + await recipientRepo.delete({ correspondenceId: id }); + const newRecipients = updResolvedRecipients.map((r) => recipientRepo.create({ + correspondenceId: id, + recipientOrganizationId: r.organizationId, + recipientType: r.type, + })); + await recipientRepo.save(newRecipients); + } + // 6. Regenerate Document Number if structural fields changed (Recipient, Discipline, Type, Project) + // AND it is a DRAFT. + // Fetch fresh data for context and comparison + const currentCorr = await this.correspondenceRepo.findOne({ + where: { id }, + relations: ['type', 'recipients', 'recipients.recipientOrganization'], + }); + if (currentCorr) { + const currentToRecipient = currentCorr.recipients?.find((r) => r.recipientType === 'TO'); + const currentRecipientId = currentToRecipient?.recipientOrganizationId; + // Check for ACTUAL value changes + const isProjectChanged = updResolvedProjectId !== undefined && + updResolvedProjectId !== currentCorr.projectId; + const isOriginatorChanged = updResolvedOriginatorId !== undefined && + updResolvedOriginatorId !== currentCorr.originatorId; + const isDisciplineChanged = updateDto.disciplineId !== undefined && + updateDto.disciplineId !== currentCorr.disciplineId; + const isTypeChanged = updateDto.typeId !== undefined && + updateDto.typeId !== currentCorr.correspondenceTypeId; + let isRecipientChanged = false; + let newRecipientId; + if (updResolvedRecipients) { + const newToRecipient = updResolvedRecipients.find((r) => r.type === 'TO'); + newRecipientId = newToRecipient?.organizationId; + if (newRecipientId !== currentRecipientId) { + isRecipientChanged = true; + } + } + if (isProjectChanged || + isDisciplineChanged || + isTypeChanged || + isRecipientChanged || + isOriginatorChanged) { + const targetRecipientId = isRecipientChanged + ? newRecipientId + : currentRecipientId; + // Resolve Recipient Code for the NEW context + let recipientCode = ''; + if (targetRecipientId) { + const recOrg = await this.dataSource.manager.findOne(organization_entity_1.Organization, { + where: { id: targetRecipientId }, + }); + if (recOrg) + recipientCode = recOrg.organizationCode; + } + // [Fix #6] Fetch real ORG Code from originator organization + const originatorOrgForUpdate = await this.dataSource.manager.findOne(organization_entity_1.Organization, { + where: { + id: updResolvedOriginatorId ?? currentCorr.originatorId ?? 0, + }, + }); + const orgCode = originatorOrgForUpdate?.organizationCode ?? 'UNK'; + // Prepare Contexts + const oldCtx = { + projectId: currentCorr.projectId, + originatorOrganizationId: currentCorr.originatorId ?? 0, + typeId: currentCorr.correspondenceTypeId, + disciplineId: currentCorr.disciplineId, + recipientOrganizationId: currentRecipientId, + year: new Date().getFullYear(), + }; + const newCtx = { + projectId: updResolvedProjectId ?? currentCorr.projectId, + originatorOrganizationId: updResolvedOriginatorId ?? currentCorr.originatorId ?? 0, + typeId: updateDto.typeId ?? currentCorr.correspondenceTypeId, + disciplineId: updateDto.disciplineId ?? currentCorr.disciplineId, + recipientOrganizationId: targetRecipientId, + year: new Date().getFullYear(), + userId: user.user_id, // Pass User ID for Audit + customTokens: { + TYPE_CODE: currentCorr.type?.typeCode || '', + ORG_CODE: orgCode, + RECIPIENT_CODE: recipientCode, + REC_CODE: recipientCode, + }, + }; + // If Type Changed, need NEW Type Code + if (isTypeChanged) { + const newType = await this.typeRepo.findOne({ + where: { id: newCtx.typeId }, + }); + if (newType) + newCtx.customTokens.TYPE_CODE = newType.typeCode; + } + const newDocNumber = await this.numberingService.updateNumberForDraft(currentCorr.correspondenceNumber, oldCtx, newCtx); + await this.correspondenceRepo.update(id, { + correspondenceNumber: newDocNumber, + }); + } + } + const updated = await this.findOne(id); + // Re-index updated document in Elasticsearch (fire-and-forget) + void this.searchService.indexDocument({ + id: updated.id, + publicId: updated.publicId, + type: 'correspondence', + docNumber: updated.correspondenceNumber, + title: updateDto.subject ?? updated.revisions?.[0]?.subject, + description: updateDto.description ?? updated.revisions?.[0]?.description, + status: 'DRAFT', + projectId: updated.projectId, + createdAt: updated.createdAt, + }); + return updated; + } + async previewDocumentNumber(createDto, user) { + // ADR-019: Resolve UUID references + const previewProjectId = await this.uuidResolver.resolveProjectId(createDto.projectId); + const previewOriginatorId = createDto.originatorId + ? await this.uuidResolver.resolveOrganizationId(createDto.originatorId) + : undefined; + const previewRecipients = createDto.recipients + ? await Promise.all(createDto.recipients.map(async (r) => ({ + organizationId: await this.uuidResolver.resolveOrganizationId(r.organizationId), + type: r.type, + }))) + : undefined; + const type = await this.typeRepo.findOne({ + where: { id: createDto.typeId }, + }); + if (!type) + throw new common_1.NotFoundException('Document Type not found'); + let userOrgId = user.primaryOrganizationId; + if (!userOrgId) { + const fullUser = await this.userService.findOne(user.user_id); + if (fullUser) + userOrgId = fullUser.primaryOrganizationId; + } + if (previewOriginatorId && previewOriginatorId !== userOrgId) { + // Allow impersonation for preview + userOrgId = previewOriginatorId; + } + // Extract recipient from recipients array + const toRecipient = previewRecipients?.find((r) => r.type === 'TO'); + const recipientOrganizationId = toRecipient?.organizationId; + let recipientCode = ''; + if (recipientOrganizationId) { + const recOrg = await this.dataSource.manager.findOne(organization_entity_1.Organization, { + where: { id: recipientOrganizationId }, + }); + if (recOrg) + recipientCode = recOrg.organizationCode; + } + return this.numberingService.previewNumber({ + projectId: previewProjectId, + originatorOrganizationId: userOrgId, + typeId: createDto.typeId, + disciplineId: createDto.disciplineId, + subTypeId: createDto.subTypeId, + recipientOrganizationId, + year: new Date().getFullYear(), + customTokens: { + TYPE_CODE: type.typeCode, + RECIPIENT_CODE: recipientCode, + REC_CODE: recipientCode, + }, + }); + } + /** + * Business Rule Implementation: EC-CORR-001 - Cancel Correspondence with Downstream Circulation + * Cancel correspondence and handle related circulations + */ + async cancel(publicId, reason, user) { + const correspondence = await this.findOneByUuid(publicId); + // Check if user has permission to cancel (Org Admin or Superadmin only) + const permissions = await this.userService.getUserPermissions(user.user_id); + const canCancel = permissions.includes('correspondence.cancel') || + permissions.includes('system.manage_all'); + if (!canCancel) { + throw new common_1.ForbiddenException('Only administrators can cancel correspondences'); + } + // Check if there are any active circulations + const circulationRepo = this.dataSource.getRepository('Circulation'); + const activeCirculations = await circulationRepo.find({ + where: { + correspondenceId: correspondence.id, + status: 'OPEN', + }, + }); + const warningMessage = activeCirculations.length > 0 + ? `There are ${activeCirculations.length} active circulation(s) for this correspondence. Canceling will force close all related circulations.` + : ''; + // Get the current revision to update status + const currentRevision = await this.revisionRepo.findOne({ + where: { + correspondenceId: correspondence.id, + isCurrent: true, + }, + }); + if (!currentRevision) { + throw new common_1.NotFoundException('Current revision not found'); + } + // Get cancelled status + const cancelledStatus = await this.statusRepo.findOne({ + where: { statusCode: 'CANCELLED' }, + }); + if (!cancelledStatus) { + throw new common_1.InternalServerErrorException('CANCELLED status not found'); + } + const queryRunner = this.dataSource.createQueryRunner(); + await queryRunner.connect(); + await queryRunner.startTransaction(); + try { + // Update correspondence revision status to CANCELLED + await queryRunner.manager.update(correspondence_revision_entity_1.CorrespondenceRevision, currentRevision.id, { + statusId: cancelledStatus.id, + remarks: `Cancelled: ${reason}`, + }); + // Force close all active circulations + if (activeCirculations.length > 0) { + await queryRunner.manager.update('Circulation', { + correspondenceId: correspondence.id, + status: 'OPEN', + }, { + status: 'FORCE_CLOSED', + closedAt: new Date(), + closedBy: user.user_id, + closeReason: `Correspondence cancelled: ${reason}`, + }); + } + await queryRunner.commitTransaction(); + // Re-index cancelled status in Elasticsearch (fire-and-forget) + void this.searchService.indexDocument({ + id: correspondence.id, + publicId: correspondence.publicId, + type: 'correspondence', + docNumber: correspondence.correspondenceNumber, + title: currentRevision.subject, + status: 'CANCELLED', + projectId: correspondence.projectId, + createdAt: correspondence.createdAt, + }); + // Notify originator's doc-control user about cancellation (fire-and-forget) + if (correspondence.originatorId) { + void this.userService + .findDocControlIdByOrg(correspondence.originatorId) + .then((targetUserId) => { + if (targetUserId) { + void this.notificationService.send({ + userId: targetUserId, + title: 'Correspondence Cancelled', + message: `${correspondence.correspondenceNumber} — ${currentRevision.subject} has been cancelled. Reason: ${reason}`, + type: 'EMAIL', + entityType: 'correspondence', + entityId: correspondence.id, + link: `/correspondences/${correspondence.publicId}`, + }); + } + }) + .catch((err) => this.logger.warn(`Cancel notification failed: ${err.message}`)); + } + return { + success: true, + message: warningMessage || 'Correspondence cancelled successfully', + activeCirculationsCount: activeCirculations.length, + }; + } + catch (error) { + await queryRunner.rollbackTransaction(); + this.logger.error(`Failed to cancel correspondence: ${error.message}`); + throw error; + } + finally { + await queryRunner.release(); + } + } + async bulkCancel(publicIds, reason, user) { + const succeeded = []; + const failed = []; + for (const publicId of publicIds) { + try { + await this.cancel(publicId, reason, user); + succeeded.push(publicId); + } + catch { + failed.push(publicId); + } + } + return { succeeded, failed }; + } + async exportCsv(searchDto) { + const { data } = await this.findAll(searchDto); + const header = [ + 'Document No.', + 'Rev', + 'Subject', + 'Type', + 'Status', + 'Project', + 'From', + 'Due Date', + 'Created At', + ]; + const rows = data.map((rev) => { + const corr = rev.correspondence ?? rev; + return [ + this.escapeCsv(corr.correspondenceNumber ?? ''), + this.escapeCsv(rev.revisionLabel ?? String(rev.revisionNumber ?? 0)), + this.escapeCsv(rev.subject ?? ''), + this.escapeCsv(corr.type?.typeCode ?? ''), + this.escapeCsv(rev.status?.statusCode ?? ''), + this.escapeCsv(corr.project?.projectCode ?? ''), + this.escapeCsv(corr.originator?.organizationCode ?? ''), + rev.dueDate ? new Date(rev.dueDate).toISOString().split('T')[0] : '', + new Date(rev.createdAt).toISOString().split('T')[0], + ].join(','); + }); + return [header.join(','), ...rows].join('\n'); + } + escapeCsv(value) { + if (value.includes(',') || value.includes('"') || value.includes('\n')) { + return `"${value.replace(/"/g, '""')}"`; + } + return value; + } +}; +exports.CorrespondenceService = CorrespondenceService; +exports.CorrespondenceService = CorrespondenceService = CorrespondenceService_1 = __decorate([ + (0, common_1.Injectable)(), + __param(0, (0, typeorm_1.InjectRepository)(correspondence_entity_1.Correspondence)), + __param(1, (0, typeorm_1.InjectRepository)(correspondence_revision_entity_1.CorrespondenceRevision)), + __param(2, (0, typeorm_1.InjectRepository)(correspondence_type_entity_1.CorrespondenceType)), + __param(3, (0, typeorm_1.InjectRepository)(correspondence_status_entity_1.CorrespondenceStatus)), + __param(4, (0, typeorm_1.InjectRepository)(correspondence_reference_entity_1.CorrespondenceReference)), + __param(5, (0, typeorm_1.InjectRepository)(correspondence_tag_entity_1.CorrespondenceTag)), + __metadata("design:paramtypes", [typeof (_a = typeof typeorm_2.Repository !== "undefined" && typeorm_2.Repository) === "function" ? _a : Object, typeof (_b = typeof typeorm_2.Repository !== "undefined" && typeorm_2.Repository) === "function" ? _b : Object, typeof (_c = typeof typeorm_2.Repository !== "undefined" && typeorm_2.Repository) === "function" ? _c : Object, typeof (_d = typeof typeorm_2.Repository !== "undefined" && typeorm_2.Repository) === "function" ? _d : Object, typeof (_e = typeof typeorm_2.Repository !== "undefined" && typeorm_2.Repository) === "function" ? _e : Object, typeof (_f = typeof typeorm_2.Repository !== "undefined" && typeorm_2.Repository) === "function" ? _f : Object, typeof (_g = typeof document_numbering_service_1.DocumentNumberingService !== "undefined" && document_numbering_service_1.DocumentNumberingService) === "function" ? _g : Object, typeof (_h = typeof json_schema_service_1.JsonSchemaService !== "undefined" && json_schema_service_1.JsonSchemaService) === "function" ? _h : Object, typeof (_j = typeof workflow_engine_service_1.WorkflowEngineService !== "undefined" && workflow_engine_service_1.WorkflowEngineService) === "function" ? _j : Object, typeof (_k = typeof user_service_1.UserService !== "undefined" && user_service_1.UserService) === "function" ? _k : Object, typeof (_l = typeof typeorm_2.DataSource !== "undefined" && typeorm_2.DataSource) === "function" ? _l : Object, typeof (_m = typeof search_service_1.SearchService !== "undefined" && search_service_1.SearchService) === "function" ? _m : Object, typeof (_o = typeof file_storage_service_1.FileStorageService !== "undefined" && file_storage_service_1.FileStorageService) === "function" ? _o : Object, typeof (_p = typeof uuid_resolver_service_1.UuidResolverService !== "undefined" && uuid_resolver_service_1.UuidResolverService) === "function" ? _p : Object, typeof (_q = typeof notification_service_1.NotificationService !== "undefined" && notification_service_1.NotificationService) === "function" ? _q : Object]) +], CorrespondenceService); +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"file":"E:\\np-dms\\lcbp3\\backend\\src\\modules\\correspondence\\correspondence.service.ts","mappings":";AAAA,6DAA6D;;;;;;;;;;;;;;;;;AAE7D,2CAOwB;AACxB,6CAAmD;AACnD,qCAAiD;AAEjD,WAAW;AACX,4EAAkE;AAClE,8FAAmF;AACnF,sFAA2E;AAC3E,0FAA+E;AAC/E,gGAAqF;AACrF,gGAAqF;AACrF,oFAAyE;AACzE,8DAAoD;AAEpD,sFAA4E;AAQ5E,WAAW;AACX,0GAAqG;AACrG,4EAAuE;AACvE,wFAAmF;AACnF,uDAAmD;AACnD,6DAAyD;AACzD,yFAAoF;AACpF,uFAAkF;AAClF,+EAA2E;AAUpE,IAAM,qBAAqB,6BAA3B,MAAM,qBAAqB;IAGxB,KAAK,CAAC,4BAA4B,CAAC,MAAc;QACvD,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAC;QACtE,OAAO,WAAW,CAAC,QAAQ,CAAC,mBAAmB,CAAC,CAAC;IACnD,CAAC;IAED;;;;OAIG;IACK,uBAAuB,CAAC,QAAgB;QAC9C,MAAM,aAAa,GAAG,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;QACrC,IAAI,aAAa,CAAC,QAAQ,CAAC,QAAQ,CAAC,WAAW,EAAE,CAAC,EAAE,CAAC;YACnD,OAAO,GAAG,CAAC,CAAC,wBAAwB;QACtC,CAAC;QACD,OAAO,IAAI,CAAC,CAAC,gCAAgC;IAC/C,CAAC;IAED,YAEE,kBAAsD,EAEtD,YAAwD,EAExD,QAAgD,EAEhD,UAAoD,EAEpD,aAA0D,EAE1D,OAA8C,EACtC,gBAA0C,EAC1C,iBAAoC,EACpC,cAAqC,EACrC,WAAwB,EACxB,UAAsB,EACtB,aAA4B,EAC5B,kBAAsC,EACtC,YAAiC,EACjC,mBAAwC;QAnBxC,uBAAkB,GAAlB,kBAAkB,CAA4B;QAE9C,iBAAY,GAAZ,YAAY,CAAoC;QAEhD,aAAQ,GAAR,QAAQ,CAAgC;QAExC,eAAU,GAAV,UAAU,CAAkC;QAE5C,kBAAa,GAAb,aAAa,CAAqC;QAElD,YAAO,GAAP,OAAO,CAA+B;QACtC,qBAAgB,GAAhB,gBAAgB,CAA0B;QAC1C,sBAAiB,GAAjB,iBAAiB,CAAmB;QACpC,mBAAc,GAAd,cAAc,CAAuB;QACrC,gBAAW,GAAX,WAAW,CAAa;QACxB,eAAU,GAAV,UAAU,CAAY;QACtB,kBAAa,GAAb,aAAa,CAAe;QAC5B,uBAAkB,GAAlB,kBAAkB,CAAoB;QACtC,iBAAY,GAAZ,YAAY,CAAqB;QACjC,wBAAmB,GAAnB,mBAAmB,CAAqB;QAzCjC,WAAM,GAAG,IAAI,eAAM,CAAC,uBAAqB,CAAC,IAAI,CAAC,CAAC;IA0C9D,CAAC;IAEJ;;;OAGG;IACK,KAAK,CAAC,gCAAgC,CAC5C,SAAkC,EAClC,IAAU;QAEV,0BAA0B;QAC1B,IAAI,SAAS,GAAG,IAAI,CAAC,qBAAqB,CAAC;QAC3C,IAAI,CAAC,SAAS,EAAE,CAAC;YACf,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YAC9D,IAAI,QAAQ,EAAE,CAAC;gBACb,SAAS,GAAG,QAAQ,CAAC,qBAAqB,CAAC;YAC7C,CAAC;QACH,CAAC;QAED,IAAI,CAAC,SAAS,EAAE,CAAC;YACf,IAAI,SAAS,CAAC,YAAY,EAAE,CAAC;gBAC3B,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,4BAA4B,CAC1D,IAAI,CAAC,OAAO,CACb,CAAC;gBACF,IAAI,YAAY,EAAE,CAAC;oBACjB,SAAS,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,qBAAqB,CACvD,SAAS,CAAC,YAAY,CACvB,CAAC;gBACJ,CAAC;YACH,CAAC;YAED,IAAI,CAAC,SAAS,EAAE,CAAC;gBACf,MAAM,IAAI,4BAAmB,CAC3B,yDAAyD,CAC1D,CAAC;YACJ,CAAC;QACH,CAAC;QAED,kDAAkD;QAClD,MAAM,eAAe,GAAG,SAAS,CAAC,YAAY;YAC5C,CAAC,CAAC,MAAM,IAAI,CAAC,YAAY,CAAC,qBAAqB,CAAC,SAAS,CAAC,YAAY,CAAC;YACvE,CAAC,CAAC,SAAS,CAAC;QAEd,uCAAuC;QACvC,IAAI,SAAS,CAAC,UAAU,EAAE,CAAC;YACzB,yDAAyD;YACzD,MAAM,IAAI,4BAAmB,CAC3B,gFAAgF,CACjF,CAAC;QACJ,CAAC;QAED,sBAAsB;QACtB,IAAI,CAAC,SAAS,CAAC,UAAU,IAAI,SAAS,CAAC,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC/D,MAAM,IAAI,4BAAmB,CAC3B,+CAA+C,CAChD,CAAC;QACJ,CAAC;QAED,MAAM,YAAY,GAAG,SAAS,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;QACzE,MAAM,YAAY,GAAG,SAAS,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;QAEzE,IAAI,YAAY,CAAC,MAAM,KAAK,CAAC,IAAI,YAAY,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC3D,MAAM,IAAI,4BAAmB,CAC3B,6CAA6C,CAC9C,CAAC;QACJ,CAAC;QAED,6CAA6C;QAC7C,KAAK,MAAM,SAAS,IAAI,SAAS,CAAC,UAAU,EAAE,CAAC;YAC7C,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,qBAAqB,CAClE,SAAS,CAAC,cAAc,CACzB,CAAC;YAEF,IAAI,cAAc,KAAK,eAAe,EAAE,CAAC;gBACvC,MAAM,IAAI,4BAAmB,CAC3B,wGAAwG,CACzG,CAAC;YACJ,CAAC;QACH,CAAC;IACH,CAAC;IAED,KAAK,CAAC,MAAM,CAAC,SAAkC,EAAE,IAAU;QACzD,iEAAiE;QACjE,MAAM,IAAI,CAAC,gCAAgC,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;QAC7D,uDAAuD;QACvD,MAAM,iBAAiB,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,gBAAgB,CAChE,SAAS,CAAC,SAAS,CACpB,CAAC;QACF,MAAM,oBAAoB,GAAG,SAAS,CAAC,YAAY;YACjD,CAAC,CAAC,MAAM,IAAI,CAAC,YAAY,CAAC,qBAAqB,CAAC,SAAS,CAAC,YAAY,CAAC;YACvE,CAAC,CAAC,SAAS,CAAC;QACd,MAAM,kBAAkB,GAAG,SAAS,CAAC,UAAU;YAC7C,CAAC,CAAC,MAAM,OAAO,CAAC,GAAG,CACf,SAAS,CAAC,UAAU,CAAC,GAAG,CACtB,KAAK,EAAE,CAAC,EAA8B,EAAE,CAAC,CAAC;gBACxC,cAAc,EAAE,MAAM,IAAI,CAAC,YAAY,CAAC,qBAAqB,CAC3D,CAAC,CAAC,cAAc,CACjB;gBACD,IAAI,EAAE,CAAC,CAAC,IAAI;aACb,CAAC,CACH,CACF;YACH,CAAC,CAAC,SAAS,CAAC;QACd,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC;YACvC,KAAK,EAAE,EAAE,EAAE,EAAE,SAAS,CAAC,MAAM,EAAE;SAChC,CAAC,CAAC;QACH,IAAI,CAAC,IAAI;YAAE,MAAM,IAAI,0BAAiB,CAAC,yBAAyB,CAAC,CAAC;QAElE,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC;YAChD,KAAK,EAAE,EAAE,UAAU,EAAE,OAAO,EAAE;SAC/B,CAAC,CAAC;QACH,IAAI,CAAC,WAAW,EAAE,CAAC;YACjB,MAAM,IAAI,qCAA4B,CACpC,uCAAuC,CACxC,CAAC;QACJ,CAAC;QAED,IAAI,SAAS,GAAG,IAAI,CAAC,qBAAqB,CAAC;QAE3C,IAAI,CAAC,SAAS,EAAE,CAAC;YACf,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YAC9D,IAAI,QAAQ,EAAE,CAAC;gBACb,SAAS,GAAG,QAAQ,CAAC,qBAAqB,CAAC;YAC7C,CAAC;QACH,CAAC;QAED,sBAAsB;QACtB,IAAI,oBAAoB,IAAI,oBAAoB,KAAK,SAAS,EAAE,CAAC;YAC/D,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,4BAA4B,CAC1D,IAAI,CAAC,OAAO,CACb,CAAC;YACF,IAAI,CAAC,YAAY,EAAE,CAAC;gBAClB,MAAM,IAAI,2BAAkB,CAC1B,kFAAkF,CACnF,CAAC;YACJ,CAAC;YACD,SAAS,GAAG,oBAAoB,CAAC;QACnC,CAAC;QAED,IAAI,CAAC,SAAS,EAAE,CAAC;YACf,MAAM,IAAI,4BAAmB,CAC3B,yDAAyD,CAC1D,CAAC;QACJ,CAAC;QAED,IAAI,SAAS,CAAC,OAAO,EAAE,CAAC;YACtB,IAAI,CAAC;gBACH,MAAM,IAAI,CAAC,iBAAiB,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,EAAE,SAAS,CAAC,OAAO,CAAC,CAAC;YAC1E,CAAC;YAAC,OAAO,KAAc,EAAE,CAAC;gBACxB,IAAI,CAAC,MAAM,CAAC,IAAI,CACd,iCAAiC,IAAI,CAAC,QAAQ,KAAM,KAAe,CAAC,OAAO,EAAE,CAC9E,CAAC;YACJ,CAAC;QACH,CAAC;QAED,MAAM,WAAW,GAAG,IAAI,CAAC,UAAU,CAAC,iBAAiB,EAAE,CAAC;QACxD,MAAM,WAAW,CAAC,OAAO,EAAE,CAAC;QAC5B,MAAM,WAAW,CAAC,gBAAgB,EAAE,CAAC;QAErC,IAAI,CAAC;YACH,wDAAwD;YACxD,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,OAAO,CACzD,kCAAY,EACZ;gBACE,KAAK,EAAE,EAAE,EAAE,EAAE,SAAS,EAAE;aACzB,CACF,CAAC;YACF,MAAM,OAAO,GAAG,aAAa,EAAE,gBAAgB,IAAI,KAAK,CAAC;YAEzD,6EAA6E;YAC7E,MAAM,WAAW,GAAG,kBAAkB,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;YACrE,MAAM,uBAAuB,GAAG,WAAW,EAAE,cAAc,CAAC;YAE5D,IAAI,aAAa,GAAG,EAAE,CAAC;YACvB,IAAI,uBAAuB,EAAE,CAAC;gBAC5B,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,OAAO,CAAC,kCAAY,EAAE;oBACjE,KAAK,EAAE,EAAE,EAAE,EAAE,uBAAuB,EAAE;iBACvC,CAAC,CAAC;gBACH,IAAI,MAAM;oBAAE,aAAa,GAAG,MAAM,CAAC,gBAAgB,CAAC;YACtD,CAAC;YAED,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,gBAAgB,CAAC,kBAAkB,CAAC;gBAC/D,SAAS,EAAE,iBAAiB;gBAC5B,wBAAwB,EAAE,SAAS;gBACnC,MAAM,EAAE,SAAS,CAAC,MAAM;gBACxB,YAAY,EAAE,SAAS,CAAC,YAAY;gBACpC,SAAS,EAAE,SAAS,CAAC,SAAS;gBAC9B,uBAAuB,EAAE,qDAAqD;gBAC9E,IAAI,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;gBAC9B,YAAY,EAAE;oBACZ,SAAS,EAAE,IAAI,CAAC,QAAQ;oBACxB,QAAQ,EAAE,OAAO;oBACjB,cAAc,EAAE,aAAa;oBAC7B,QAAQ,EAAE,aAAa;iBACxB;aACF,CAAC,CAAC;YAEH,MAAM,cAAc,GAAG,WAAW,CAAC,OAAO,CAAC,MAAM,CAAC,sCAAc,EAAE;gBAChE,oBAAoB,EAAE,SAAS,CAAC,MAAM;gBACtC,oBAAoB,EAAE,SAAS,CAAC,MAAM;gBACtC,YAAY,EAAE,SAAS,CAAC,YAAY;gBACpC,SAAS,EAAE,iBAAiB;gBAC5B,YAAY,EAAE,SAAS;gBACvB,UAAU,EAAE,SAAS,CAAC,UAAU,IAAI,KAAK;gBACzC,SAAS,EAAE,IAAI,CAAC,OAAO;aACxB,CAAC,CAAC;YACH,MAAM,SAAS,GAAG,MAAM,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;YAEjE,MAAM,QAAQ,GAAG,WAAW,CAAC,OAAO,CAAC,MAAM,CAAC,uDAAsB,EAAE;gBAClE,gBAAgB,EAAE,SAAS,CAAC,EAAE;gBAC9B,cAAc,EAAE,CAAC;gBACjB,aAAa,EAAE,GAAG;gBAClB,SAAS,EAAE,IAAI;gBACf,QAAQ,EAAE,WAAW,CAAC,EAAE;gBACxB,OAAO,EAAE,SAAS,CAAC,OAAO;gBAC1B,IAAI,EAAE,SAAS,CAAC,IAAI;gBACpB,OAAO,EAAE,SAAS,CAAC,OAAO;gBAC1B,OAAO,EAAE,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS;gBACpE,YAAY,EAAE,SAAS,CAAC,YAAY;oBAClC,CAAC,CAAC,IAAI,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC;oBAClC,CAAC,CAAC,SAAS;gBACb,UAAU,EAAE,SAAS,CAAC,UAAU;oBAC9B,CAAC,CAAC,IAAI,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC;oBAChC,CAAC,CAAC,SAAS;gBACb,YAAY,EAAE,SAAS,CAAC,YAAY;oBAClC,CAAC,CAAC,IAAI,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC;oBAClC,CAAC,CAAC,SAAS;gBACb,WAAW,EAAE,SAAS,CAAC,WAAW;gBAClC,OAAO,EAAE,SAAS,CAAC,OAAO;gBAC1B,SAAS,EAAE,IAAI,CAAC,OAAO;gBACvB,aAAa,EAAE,CAAC;aACjB,CAAC,CAAC;YACH,MAAM,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YAEzC,2CAA2C;YAC3C,IAAI,kBAAkB,IAAI,kBAAkB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACxD,MAAM,UAAU,GAAG,kBAAkB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAC9C,WAAW,CAAC,OAAO,CAAC,MAAM,CAAC,yDAAuB,EAAE;oBAClD,gBAAgB,EAAE,SAAS,CAAC,EAAE;oBAC9B,uBAAuB,EAAE,CAAC,CAAC,cAAc;oBACzC,aAAa,EAAE,CAAC,CAAC,IAAI;iBACtB,CAAC,CACH,CAAC;gBACF,MAAM,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YAC7C,CAAC;YAED,+DAA+D;YAC/D,IAAI,SAAS,CAAC,iBAAiB,EAAE,MAAM,EAAE,CAAC;gBACxC,MAAM,SAAS,GAAG,SAAS,CAAC,UAAU;oBACpC,CAAC,CAAC,IAAI,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC;oBAChC,CAAC,CAAC,SAAS,CAAC,YAAY;wBACtB,CAAC,CAAC,IAAI,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC;wBAClC,CAAC,CAAC,SAAS,CAAC;gBAEhB,MAAM,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,SAAS,CAAC,iBAAiB,EAAE;oBAChE,SAAS;oBACT,YAAY,EAAE,gBAAgB;iBAC/B,CAAC,CAAC;YACL,CAAC;YAED,MAAM,WAAW,CAAC,iBAAiB,EAAE,CAAC;YAEtC,yCAAyC;YACzC,IAAI,CAAC;gBACH,MAAM,YAAY,GAAG,kBAAkB,IAAI,CAAC,QAAQ,EAAE,CAAC;gBACvD,MAAM,IAAI,CAAC,cAAc,CAAC,cAAc,CACtC,YAAY,EACZ,gBAAgB,EAChB,SAAS,CAAC,EAAE,CAAC,QAAQ,EAAE,EACvB;oBACE,SAAS,EAAE,iBAAiB;oBAC5B,YAAY,EAAE,SAAS;oBACvB,YAAY,EAAE,SAAS,CAAC,YAAY;oBACpC,WAAW,EAAE,IAAI,CAAC,OAAO;iBACC,CAC7B,CAAC;YACJ,CAAC;YAAC,OAAO,KAAc,EAAE,CAAC;gBACxB,IAAI,CAAC,MAAM,CAAC,IAAI,CACd,4BAA4B,SAAS,CAAC,MAAM,0BAA0B,IAAI,CAAC,QAAQ,MAAO,KAAe,CAAC,OAAO,EAAE,CACpH,CAAC;YACJ,CAAC;YAED,mEAAmE;YACnE,KAAK,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC;gBACpC,EAAE,EAAE,SAAS,CAAC,EAAE;gBAChB,QAAQ,EAAE,SAAS,CAAC,QAAQ;gBAC5B,IAAI,EAAE,gBAAgB;gBACtB,SAAS,EAAE,SAAS,CAAC,MAAM;gBAC3B,KAAK,EAAE,SAAS,CAAC,OAAO;gBACxB,WAAW,EAAE,SAAS,CAAC,WAAW;gBAClC,MAAM,EAAE,OAAO;gBACf,SAAS,EAAE,iBAAiB;gBAC5B,SAAS,EAAE,IAAI,IAAI,EAAE;aACtB,CAAC,CAAC;YAEH,OAAO;gBACL,GAAG,SAAS;gBACZ,eAAe,EAAE,QAAQ;aAC1B,CAAC;QACJ,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,MAAM,WAAW,CAAC,mBAAmB,EAAE,CAAC;YACxC,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,oCAAqC,GAAa,CAAC,OAAO,EAAE,CAC7D,CAAC;YACF,MAAM,GAAG,CAAC;QACZ,CAAC;gBAAS,CAAC;YACT,MAAM,WAAW,CAAC,OAAO,EAAE,CAAC;QAC9B,CAAC;IACH,CAAC;IAED,KAAK,CAAC,OAAO,CAAC,YAAqC,EAAE;QACnD,MAAM,EACJ,MAAM,EACN,MAAM,EACN,SAAS,EACT,QAAQ,EACR,MAAM,EACN,IAAI,GAAG,CAAC,EACR,KAAK,GAAG,EAAE,GACX,GAAG,SAAS,CAAC;QACd,MAAM,IAAI,GAAG,CAAC,IAAI,GAAG,CAAC,CAAC,GAAG,KAAK,CAAC;QAEhC,mCAAmC;QACnC,MAAM,KAAK,GAAG,IAAI,CAAC,YAAY;aAC5B,kBAAkB,CAAC,KAAK,CAAC;aACzB,iBAAiB,CAAC,oBAAoB,EAAE,MAAM,CAAC;aAC/C,iBAAiB,CAAC,WAAW,EAAE,MAAM,CAAC;aACtC,iBAAiB,CAAC,cAAc,EAAE,SAAS,CAAC;aAC5C,iBAAiB,CAAC,iBAAiB,EAAE,KAAK,CAAC;aAC3C,iBAAiB,CAAC,YAAY,EAAE,QAAQ,CAAC,CAAC;QAE7C,4BAA4B;QAC5B,MAAM,SAAS,GAAG,SAAS,CAAC,cAAc,IAAI,SAAS,CAAC;QAExD,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;YAC5B,KAAK,CAAC,KAAK,CAAC,4BAA4B,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QACjE,CAAC;aAAM,IAAI,SAAS,KAAK,KAAK,EAAE,CAAC;YAC/B,KAAK,CAAC,KAAK,CAAC,4BAA4B,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC;QAClE,CAAC;QACD,0CAA0C;QAE1C,IAAI,SAAS,EAAE,CAAC;YACd,KAAK,CAAC,QAAQ,CAAC,6BAA6B,EAAE,EAAE,SAAS,EAAE,CAAC,CAAC;QAC/D,CAAC;QAED,IAAI,MAAM,EAAE,CAAC;YACX,KAAK,CAAC,QAAQ,CAAC,qCAAqC,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC;QACpE,CAAC;QAED,IAAI,QAAQ,EAAE,CAAC;YACb,KAAK,CAAC,QAAQ,CAAC,0BAA0B,EAAE,EAAE,QAAQ,EAAE,CAAC,CAAC;QAC3D,CAAC;QAED,IAAI,MAAM,EAAE,CAAC;YACX,KAAK,CAAC,QAAQ,CAAC,6BAA6B,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC;QAC5D,CAAC;QAED,IAAI,MAAM,EAAE,CAAC;YACX,KAAK,CAAC,QAAQ,CACZ,sEAAsE,EACtE,EAAE,MAAM,EAAE,IAAI,MAAM,GAAG,EAAE,CAC1B,CAAC;QACJ,CAAC;QAED,+BAA+B;QAC/B,KAAK,CAAC,OAAO,CAAC,eAAe,EAAE,MAAM,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAE9D,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,MAAM,KAAK,CAAC,eAAe,EAAE,CAAC;QAErD,OAAO;YACL,IAAI,EAAE,KAAK;YACX,IAAI,EAAE;gBACJ,KAAK;gBACL,IAAI;gBACJ,KAAK;gBACL,UAAU,EAAE,IAAI,CAAC,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;aACrC;SACF,CAAC;IACJ,CAAC;IAED,KAAK,CAAC,OAAO,CAAC,EAAU;QACtB,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC;YAC3D,KAAK,EAAE,EAAE,EAAE,EAAE;YACb,SAAS,EAAE;gBACT,WAAW;gBACX,kBAAkB;gBAClB,MAAM;gBACN,SAAS;gBACT,YAAY;gBACZ,YAAY;gBACZ,kCAAkC,EAAE,+BAA+B;aACpE;SACF,CAAC,CAAC;QAEH,IAAI,CAAC,cAAc,EAAE,CAAC;YACpB,MAAM,IAAI,0BAAiB,CAAC,0BAA0B,EAAE,YAAY,CAAC,CAAC;QACxE,CAAC;QACD,OAAO,cAAc,CAAC;IACxB,CAAC;IAED,KAAK,CAAC,aAAa,CAAC,QAAgB;QAClC,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC;YAC3D,KAAK,EAAE,EAAE,QAAQ,EAAE;YACnB,SAAS,EAAE;gBACT,WAAW;gBACX,kBAAkB;gBAClB,MAAM;gBACN,SAAS;gBACT,YAAY;gBACZ,YAAY;gBACZ,kCAAkC;aACnC;SACF,CAAC,CAAC;QAEH,IAAI,CAAC,cAAc,EAAE,CAAC;YACpB,MAAM,IAAI,0BAAiB,CACzB,4BAA4B,QAAQ,YAAY,CACjD,CAAC;QACJ,CAAC;QACD,OAAO,cAAc,CAAC;IACxB,CAAC;IAED,KAAK,CAAC,YAAY,CAAC,EAAU,EAAE,GAAoB;QACjD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;QACxE,qDAAqD;QACrD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC;YACnD,KAAK,EAAE,EAAE,QAAQ,EAAE,GAAG,CAAC,UAAU,EAAE;SACpC,CAAC,CAAC;QAEH,IAAI,CAAC,MAAM,IAAI,CAAC,MAAM,EAAE,CAAC;YACvB,MAAM,IAAI,0BAAiB,CAAC,2CAA2C,CAAC,CAAC;QAC3E,CAAC;QAED,IAAI,MAAM,CAAC,EAAE,KAAK,MAAM,CAAC,EAAE,EAAE,CAAC;YAC5B,MAAM,IAAI,4BAAmB,CAAC,uBAAuB,CAAC,CAAC;QACzD,CAAC;QAED,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC;YAC9C,KAAK,EAAE;gBACL,QAAQ,EAAE,EAAE;gBACZ,QAAQ,EAAE,MAAM,CAAC,EAAE;aACpB;SACF,CAAC,CAAC;QAEH,IAAI,MAAM,EAAE,CAAC;YACX,OAAO,MAAM,CAAC;QAChB,CAAC;QAED,MAAM,GAAG,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC;YACpC,QAAQ,EAAE,EAAE;YACZ,QAAQ,EAAE,MAAM,CAAC,EAAE;SACpB,CAAC,CAAC;QAEH,OAAO,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACtC,CAAC;IAED,KAAK,CAAC,eAAe,CAAC,EAAU,EAAE,QAAgB;QAChD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC;YAC7C,QAAQ,EAAE,EAAE;YACZ,QAAQ,EAAE,QAAQ;SACnB,CAAC,CAAC;QAEH,IAAI,MAAM,CAAC,QAAQ,KAAK,CAAC,EAAE,CAAC;YAC1B,MAAM,IAAI,0BAAiB,CAAC,qBAAqB,CAAC,CAAC;QACrD,CAAC;IACH,CAAC;IAED,KAAK,CAAC,OAAO,CAAC,EAAU;QACtB,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC;YACnC,KAAK,EAAE,EAAE,gBAAgB,EAAE,EAAE,EAAE;YAC/B,SAAS,EAAE,CAAC,KAAK,CAAC;SACnB,CAAC,CAAC;QACH,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IAChD,CAAC;IAED,KAAK,CAAC,MAAM,CAAC,EAAU,EAAE,KAAa;QACpC,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC;YAC3D,KAAK,EAAE,EAAE,EAAE,EAAE;SACd,CAAC,CAAC;QACH,IAAI,CAAC,cAAc,EAAE,CAAC;YACpB,MAAM,IAAI,0BAAiB,CAAC,kBAAkB,EAAE,YAAY,CAAC,CAAC;QAChE,CAAC;QAED,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,OAAO,CAAC,gBAAG,EAAE;YACrD,KAAK,EAAE,EAAE,EAAE,EAAE,KAAK,EAAE;SACrB,CAAC,CAAC;QACH,IAAI,CAAC,GAAG,EAAE,CAAC;YACT,MAAM,IAAI,0BAAiB,CAAC,OAAO,KAAK,YAAY,CAAC,CAAC;QACxD,CAAC;QAED,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC;YACxC,KAAK,EAAE,EAAE,gBAAgB,EAAE,EAAE,EAAE,KAAK,EAAE;SACvC,CAAC,CAAC;QACH,IAAI,MAAM;YAAE,OAAO,MAAM,CAAC;QAE1B,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,gBAAgB,EAAE,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;QACjE,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAChC,CAAC;IAED,KAAK,CAAC,SAAS,CAAC,EAAU,EAAE,KAAa;QACvC,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,gBAAgB,EAAE,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;QAC1E,IAAI,MAAM,CAAC,QAAQ,KAAK,CAAC,EAAE,CAAC;YAC1B,MAAM,IAAI,0BAAiB,CAAC,0BAA0B,CAAC,CAAC;QAC1D,CAAC;IACH,CAAC;IAED,KAAK,CAAC,aAAa,CAAC,EAAU;QAC5B,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC;YAC7C,KAAK,EAAE,EAAE,QAAQ,EAAE,EAAE,EAAE;YACvB,SAAS,EAAE,CAAC,QAAQ,EAAE,aAAa,CAAC;SACrC,CAAC,CAAC;QAEH,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC;YAC7C,KAAK,EAAE,EAAE,QAAQ,EAAE,EAAE,EAAE;YACvB,SAAS,EAAE,CAAC,QAAQ,EAAE,aAAa,CAAC;SACrC,CAAC,CAAC;QAEH,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC;IAChC,CAAC;IAED,KAAK,CAAC,MAAM,CAAC,EAAU,EAAE,SAAkC,EAAE,IAAU;QACrE,2BAA2B;QAC3B,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC;YAC/C,KAAK,EAAE;gBACL,gBAAgB,EAAE,EAAE;gBACpB,SAAS,EAAE,IAAI;aAChB;YACD,SAAS,EAAE,CAAC,gBAAgB,CAAC;SAC9B,CAAC,CAAC;QAEH,IAAI,CAAC,QAAQ,EAAE,CAAC;YACd,MAAM,IAAI,0BAAiB,CACzB,uCAAuC,EAAE,YAAY,CACtD,CAAC;QACJ,CAAC;QAED,sBAAsB;QACtB,IAAI,QAAQ,CAAC,QAAQ,EAAE,CAAC;YACtB,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC;gBAC3C,KAAK,EAAE,EAAE,EAAE,EAAE,QAAQ,CAAC,QAAQ,EAAE;aACjC,CAAC,CAAC;YACH,IAAI,MAAM,IAAI,MAAM,CAAC,UAAU,KAAK,OAAO,EAAE,CAAC;gBAC5C,MAAM,IAAI,4BAAmB,CAAC,qCAAqC,CAAC,CAAC;YACvE,CAAC;QACH,CAAC;QAED,iDAAiD;QACjD,MAAM,oBAAoB,GAAG,SAAS,CAAC,SAAS;YAC9C,CAAC,CAAC,MAAM,IAAI,CAAC,YAAY,CAAC,gBAAgB,CAAC,SAAS,CAAC,SAAS,CAAC;YAC/D,CAAC,CAAC,SAAS,CAAC;QACd,MAAM,uBAAuB,GAAG,SAAS,CAAC,YAAY;YACpD,CAAC,CAAC,MAAM,IAAI,CAAC,YAAY,CAAC,qBAAqB,CAAC,SAAS,CAAC,YAAY,CAAC;YACvE,CAAC,CAAC,SAAS,CAAC;QACd,MAAM,qBAAqB,GAAG,SAAS,CAAC,UAAU;YAChD,CAAC,CAAC,MAAM,OAAO,CAAC,GAAG,CACf,SAAS,CAAC,UAAU,CAAC,GAAG,CACtB,KAAK,EAAE,CAAC,EAA8B,EAAE,CAAC,CAAC;gBACxC,cAAc,EAAE,MAAM,IAAI,CAAC,YAAY,CAAC,qBAAqB,CAC3D,CAAC,CAAC,cAAc,CACjB;gBACD,IAAI,EAAE,CAAC,CAAC,IAAI;aACb,CAAC,CACH,CACF;YACH,CAAC,CAAC,SAAS,CAAC;QAEd,4CAA4C;QAC5C,MAAM,oBAAoB,GAA4B,EAAE,CAAC;QACzD,IAAI,SAAS,CAAC,YAAY;YACxB,oBAAoB,CAAC,YAAY,GAAG,SAAS,CAAC,YAAY,CAAC;QAC7D,IAAI,oBAAoB;YACtB,oBAAoB,CAAC,SAAS,GAAG,oBAAoB,CAAC;QACxD,IAAI,uBAAuB;YACzB,oBAAoB,CAAC,YAAY,GAAG,uBAAuB,CAAC;QAE9D,IAAI,MAAM,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACjD,MAAM,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,EAAE,EAAE,oBAAoB,CAAC,CAAC;QACjE,CAAC;QAED,4BAA4B;QAC5B,MAAM,cAAc,GAA4B,EAAE,CAAC;QACnD,IAAI,SAAS,CAAC,OAAO;YAAE,cAAc,CAAC,OAAO,GAAG,SAAS,CAAC,OAAO,CAAC;QAClE,IAAI,SAAS,CAAC,IAAI;YAAE,cAAc,CAAC,IAAI,GAAG,SAAS,CAAC,IAAI,CAAC;QACzD,IAAI,SAAS,CAAC,OAAO;YAAE,cAAc,CAAC,OAAO,GAAG,SAAS,CAAC,OAAO,CAAC;QAClE,kCAAkC;QAClC,IAAI,SAAS,CAAC,OAAO;YAAE,cAAc,CAAC,OAAO,GAAG,IAAI,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;QAC5E,IAAI,SAAS,CAAC,YAAY;YACxB,cAAc,CAAC,YAAY,GAAG,IAAI,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC;QACjE,IAAI,SAAS,CAAC,UAAU;YACtB,cAAc,CAAC,UAAU,GAAG,IAAI,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;QAC7D,IAAI,SAAS,CAAC,YAAY;YACxB,cAAc,CAAC,YAAY,GAAG,IAAI,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC;QACjE,IAAI,SAAS,CAAC,WAAW;YACvB,cAAc,CAAC,WAAW,GAAG,SAAS,CAAC,WAAW,CAAC;QACrD,IAAI,SAAS,CAAC,OAAO;YAAE,cAAc,CAAC,OAAO,GAAG,SAAS,CAAC,OAAO,CAAC;QAElE,IAAI,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC3C,MAAM,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,EAAE,cAAc,CAAC,CAAC;QAC9D,CAAC;QAED,uEAAuE;QACvE,IAAI,SAAS,CAAC,iBAAiB,EAAE,MAAM,EAAE,CAAC;YACxC,MAAM,SAAS,GAAG,SAAS,CAAC,UAAU;gBACpC,CAAC,CAAC,IAAI,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC;gBAChC,CAAC,CAAC,SAAS,CAAC,YAAY;oBACtB,CAAC,CAAC,IAAI,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC;oBAClC,CAAC,CAAC,QAAQ,CAAC,UAAU,IAAI,QAAQ,CAAC,YAAY,IAAI,SAAS,CAAC;YAEhE,MAAM,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,SAAS,CAAC,iBAAiB,EAAE;gBAChE,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS;gBACtD,YAAY,EAAE,gBAAgB;aAC/B,CAAC,CAAC;QACL,CAAC;QAED,mCAAmC;QACnC,IAAI,qBAAqB,EAAE,CAAC;YAC1B,MAAM,aAAa,GAAG,IAAI,CAAC,UAAU,CAAC,aAAa,CACjD,yDAAuB,CACxB,CAAC;YACF,MAAM,aAAa,CAAC,MAAM,CAAC,EAAE,gBAAgB,EAAE,EAAE,EAAE,CAAC,CAAC;YAErD,MAAM,aAAa,GAAG,qBAAqB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CACpD,aAAa,CAAC,MAAM,CAAC;gBACnB,gBAAgB,EAAE,EAAE;gBACpB,uBAAuB,EAAE,CAAC,CAAC,cAAc;gBACzC,aAAa,EAAE,CAAC,CAAC,IAAI;aACtB,CAAC,CACH,CAAC;YACF,MAAM,aAAa,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QAC1C,CAAC;QAED,oGAAoG;QACpG,qBAAqB;QAErB,8CAA8C;QAC9C,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC;YACxD,KAAK,EAAE,EAAE,EAAE,EAAE;YACb,SAAS,EAAE,CAAC,MAAM,EAAE,YAAY,EAAE,kCAAkC,CAAC;SACtE,CAAC,CAAC;QAEH,IAAI,WAAW,EAAE,CAAC;YAChB,MAAM,kBAAkB,GAAG,WAAW,CAAC,UAAU,EAAE,IAAI,CACrD,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,aAAa,KAAK,IAAI,CAChC,CAAC;YACF,MAAM,kBAAkB,GAAG,kBAAkB,EAAE,uBAAuB,CAAC;YAEvE,iCAAiC;YACjC,MAAM,gBAAgB,GACpB,oBAAoB,KAAK,SAAS;gBAClC,oBAAoB,KAAK,WAAW,CAAC,SAAS,CAAC;YACjD,MAAM,mBAAmB,GACvB,uBAAuB,KAAK,SAAS;gBACrC,uBAAuB,KAAK,WAAW,CAAC,YAAY,CAAC;YACvD,MAAM,mBAAmB,GACvB,SAAS,CAAC,YAAY,KAAK,SAAS;gBACpC,SAAS,CAAC,YAAY,KAAK,WAAW,CAAC,YAAY,CAAC;YACtD,MAAM,aAAa,GACjB,SAAS,CAAC,MAAM,KAAK,SAAS;gBAC9B,SAAS,CAAC,MAAM,KAAK,WAAW,CAAC,oBAAoB,CAAC;YAExD,IAAI,kBAAkB,GAAG,KAAK,CAAC;YAC/B,IAAI,cAAkC,CAAC;YAEvC,IAAI,qBAAqB,EAAE,CAAC;gBAC1B,MAAM,cAAc,GAAG,qBAAqB,CAAC,IAAI,CAC/C,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CACvB,CAAC;gBACF,cAAc,GAAG,cAAc,EAAE,cAAc,CAAC;gBAEhD,IAAI,cAAc,KAAK,kBAAkB,EAAE,CAAC;oBAC1C,kBAAkB,GAAG,IAAI,CAAC;gBAC5B,CAAC;YACH,CAAC;YAED,IACE,gBAAgB;gBAChB,mBAAmB;gBACnB,aAAa;gBACb,kBAAkB;gBAClB,mBAAmB,EACnB,CAAC;gBACD,MAAM,iBAAiB,GAAG,kBAAkB;oBAC1C,CAAC,CAAC,cAAc;oBAChB,CAAC,CAAC,kBAAkB,CAAC;gBAEvB,6CAA6C;gBAC7C,IAAI,aAAa,GAAG,EAAE,CAAC;gBACvB,IAAI,iBAAiB,EAAE,CAAC;oBACtB,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,OAAO,CAAC,kCAAY,EAAE;wBACjE,KAAK,EAAE,EAAE,EAAE,EAAE,iBAAiB,EAAE;qBACjC,CAAC,CAAC;oBACH,IAAI,MAAM;wBAAE,aAAa,GAAG,MAAM,CAAC,gBAAgB,CAAC;gBACtD,CAAC;gBAED,4DAA4D;gBAC5D,MAAM,sBAAsB,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,OAAO,CAClE,kCAAY,EACZ;oBACE,KAAK,EAAE;wBACL,EAAE,EAAE,uBAAuB,IAAI,WAAW,CAAC,YAAY,IAAI,CAAC;qBAC7D;iBACF,CACF,CAAC;gBACF,MAAM,OAAO,GAAG,sBAAsB,EAAE,gBAAgB,IAAI,KAAK,CAAC;gBAElE,mBAAmB;gBACnB,MAAM,MAAM,GAAG;oBACb,SAAS,EAAE,WAAW,CAAC,SAAS;oBAChC,wBAAwB,EAAE,WAAW,CAAC,YAAY,IAAI,CAAC;oBACvD,MAAM,EAAE,WAAW,CAAC,oBAAoB;oBACxC,YAAY,EAAE,WAAW,CAAC,YAAY;oBACtC,uBAAuB,EAAE,kBAAkB;oBAC3C,IAAI,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;iBAC/B,CAAC;gBAEF,MAAM,MAAM,GAAG;oBACb,SAAS,EAAE,oBAAoB,IAAI,WAAW,CAAC,SAAS;oBACxD,wBAAwB,EACtB,uBAAuB,IAAI,WAAW,CAAC,YAAY,IAAI,CAAC;oBAC1D,MAAM,EAAE,SAAS,CAAC,MAAM,IAAI,WAAW,CAAC,oBAAoB;oBAC5D,YAAY,EAAE,SAAS,CAAC,YAAY,IAAI,WAAW,CAAC,YAAY;oBAChE,uBAAuB,EAAE,iBAAiB;oBAC1C,IAAI,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;oBAC9B,MAAM,EAAE,IAAI,CAAC,OAAO,EAAE,yBAAyB;oBAC/C,YAAY,EAAE;wBACZ,SAAS,EAAE,WAAW,CAAC,IAAI,EAAE,QAAQ,IAAI,EAAE;wBAC3C,QAAQ,EAAE,OAAO;wBACjB,cAAc,EAAE,aAAa;wBAC7B,QAAQ,EAAE,aAAa;qBACxB;iBACF,CAAC;gBAEF,sCAAsC;gBACtC,IAAI,aAAa,EAAE,CAAC;oBAClB,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC;wBAC1C,KAAK,EAAE,EAAE,EAAE,EAAE,MAAM,CAAC,MAAM,EAAE;qBAC7B,CAAC,CAAC;oBACH,IAAI,OAAO;wBAAE,MAAM,CAAC,YAAY,CAAC,SAAS,GAAG,OAAO,CAAC,QAAQ,CAAC;gBAChE,CAAC;gBAED,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,gBAAgB,CAAC,oBAAoB,CACnE,WAAW,CAAC,oBAAoB,EAChC,MAAM,EACN,MAAM,CACP,CAAC;gBAEF,MAAM,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,EAAE,EAAE;oBACvC,oBAAoB,EAAE,YAAY;iBACnC,CAAC,CAAC;YACL,CAAC;QACH,CAAC;QAED,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;QAEvC,+DAA+D;QAC/D,KAAK,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC;YACpC,EAAE,EAAE,OAAO,CAAC,EAAE;YACd,QAAQ,EAAE,OAAO,CAAC,QAAQ;YAC1B,IAAI,EAAE,gBAAgB;YACtB,SAAS,EAAE,OAAO,CAAC,oBAAoB;YACvC,KAAK,EAAE,SAAS,CAAC,OAAO,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,OAAO;YAC3D,WAAW,EAAE,SAAS,CAAC,WAAW,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,WAAW;YACzE,MAAM,EAAE,OAAO;YACf,SAAS,EAAE,OAAO,CAAC,SAAS;YAC5B,SAAS,EAAE,OAAO,CAAC,SAAS;SAC7B,CAAC,CAAC;QAEH,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,KAAK,CAAC,qBAAqB,CAAC,SAAkC,EAAE,IAAU;QACxE,mCAAmC;QACnC,MAAM,gBAAgB,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,gBAAgB,CAC/D,SAAS,CAAC,SAAS,CACpB,CAAC;QACF,MAAM,mBAAmB,GAAG,SAAS,CAAC,YAAY;YAChD,CAAC,CAAC,MAAM,IAAI,CAAC,YAAY,CAAC,qBAAqB,CAAC,SAAS,CAAC,YAAY,CAAC;YACvE,CAAC,CAAC,SAAS,CAAC;QACd,MAAM,iBAAiB,GAAG,SAAS,CAAC,UAAU;YAC5C,CAAC,CAAC,MAAM,OAAO,CAAC,GAAG,CACf,SAAS,CAAC,UAAU,CAAC,GAAG,CACtB,KAAK,EAAE,CAAC,EAA8B,EAAE,CAAC,CAAC;gBACxC,cAAc,EAAE,MAAM,IAAI,CAAC,YAAY,CAAC,qBAAqB,CAC3D,CAAC,CAAC,cAAc,CACjB;gBACD,IAAI,EAAE,CAAC,CAAC,IAAI;aACb,CAAC,CACH,CACF;YACH,CAAC,CAAC,SAAS,CAAC;QAEd,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC;YACvC,KAAK,EAAE,EAAE,EAAE,EAAE,SAAS,CAAC,MAAM,EAAE;SAChC,CAAC,CAAC;QACH,IAAI,CAAC,IAAI;YAAE,MAAM,IAAI,0BAAiB,CAAC,yBAAyB,CAAC,CAAC;QAElE,IAAI,SAAS,GAAG,IAAI,CAAC,qBAAqB,CAAC;QAC3C,IAAI,CAAC,SAAS,EAAE,CAAC;YACf,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YAC9D,IAAI,QAAQ;gBAAE,SAAS,GAAG,QAAQ,CAAC,qBAAqB,CAAC;QAC3D,CAAC;QAED,IAAI,mBAAmB,IAAI,mBAAmB,KAAK,SAAS,EAAE,CAAC;YAC7D,kCAAkC;YAClC,SAAS,GAAG,mBAAmB,CAAC;QAClC,CAAC;QAED,0CAA0C;QAC1C,MAAM,WAAW,GAAG,iBAAiB,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;QACpE,MAAM,uBAAuB,GAAG,WAAW,EAAE,cAAc,CAAC;QAE5D,IAAI,aAAa,GAAG,EAAE,CAAC;QACvB,IAAI,uBAAuB,EAAE,CAAC;YAC5B,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,OAAO,CAAC,kCAAY,EAAE;gBACjE,KAAK,EAAE,EAAE,EAAE,EAAE,uBAAuB,EAAE;aACvC,CAAC,CAAC;YACH,IAAI,MAAM;gBAAE,aAAa,GAAG,MAAM,CAAC,gBAAgB,CAAC;QACtD,CAAC;QAED,OAAO,IAAI,CAAC,gBAAgB,CAAC,aAAa,CAAC;YACzC,SAAS,EAAE,gBAAgB;YAC3B,wBAAwB,EAAE,SAAU;YACpC,MAAM,EAAE,SAAS,CAAC,MAAM;YACxB,YAAY,EAAE,SAAS,CAAC,YAAY;YACpC,SAAS,EAAE,SAAS,CAAC,SAAS;YAC9B,uBAAuB;YACvB,IAAI,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YAC9B,YAAY,EAAE;gBACZ,SAAS,EAAE,IAAI,CAAC,QAAQ;gBACxB,cAAc,EAAE,aAAa;gBAC7B,QAAQ,EAAE,aAAa;aACxB;SACF,CAAC,CAAC;IACL,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,MAAM,CAAC,QAAgB,EAAE,MAAc,EAAE,IAAU;QACvD,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;QAE1D,wEAAwE;QACxE,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,kBAAkB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC5E,MAAM,SAAS,GACb,WAAW,CAAC,QAAQ,CAAC,uBAAuB,CAAC;YAC7C,WAAW,CAAC,QAAQ,CAAC,mBAAmB,CAAC,CAAC;QAE5C,IAAI,CAAC,SAAS,EAAE,CAAC;YACf,MAAM,IAAI,2BAAkB,CAC1B,gDAAgD,CACjD,CAAC;QACJ,CAAC;QAED,6CAA6C;QAC7C,MAAM,eAAe,GAAG,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,aAAa,CAAC,CAAC;QACrE,MAAM,kBAAkB,GAAG,MAAM,eAAe,CAAC,IAAI,CAAC;YACpD,KAAK,EAAE;gBACL,gBAAgB,EAAE,cAAc,CAAC,EAAE;gBACnC,MAAM,EAAE,MAAM;aACf;SACF,CAAC,CAAC;QAEH,MAAM,cAAc,GAClB,kBAAkB,CAAC,MAAM,GAAG,CAAC;YAC3B,CAAC,CAAC,aAAa,kBAAkB,CAAC,MAAM,sGAAsG;YAC9I,CAAC,CAAC,EAAE,CAAC;QAET,4CAA4C;QAC5C,MAAM,eAAe,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC;YACtD,KAAK,EAAE;gBACL,gBAAgB,EAAE,cAAc,CAAC,EAAE;gBACnC,SAAS,EAAE,IAAI;aAChB;SACF,CAAC,CAAC;QAEH,IAAI,CAAC,eAAe,EAAE,CAAC;YACrB,MAAM,IAAI,0BAAiB,CAAC,4BAA4B,CAAC,CAAC;QAC5D,CAAC;QAED,uBAAuB;QACvB,MAAM,eAAe,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC;YACpD,KAAK,EAAE,EAAE,UAAU,EAAE,WAAW,EAAE;SACnC,CAAC,CAAC;QAEH,IAAI,CAAC,eAAe,EAAE,CAAC;YACrB,MAAM,IAAI,qCAA4B,CAAC,4BAA4B,CAAC,CAAC;QACvE,CAAC;QAED,MAAM,WAAW,GAAG,IAAI,CAAC,UAAU,CAAC,iBAAiB,EAAE,CAAC;QACxD,MAAM,WAAW,CAAC,OAAO,EAAE,CAAC;QAC5B,MAAM,WAAW,CAAC,gBAAgB,EAAE,CAAC;QAErC,IAAI,CAAC;YACH,qDAAqD;YACrD,MAAM,WAAW,CAAC,OAAO,CAAC,MAAM,CAC9B,uDAAsB,EACtB,eAAe,CAAC,EAAE,EAClB;gBACE,QAAQ,EAAE,eAAe,CAAC,EAAE;gBAC5B,OAAO,EAAE,cAAc,MAAM,EAAE;aAChC,CACF,CAAC;YAEF,sCAAsC;YACtC,IAAI,kBAAkB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBAClC,MAAM,WAAW,CAAC,OAAO,CAAC,MAAM,CAC9B,aAAa,EACb;oBACE,gBAAgB,EAAE,cAAc,CAAC,EAAE;oBACnC,MAAM,EAAE,MAAM;iBACf,EACD;oBACE,MAAM,EAAE,cAAc;oBACtB,QAAQ,EAAE,IAAI,IAAI,EAAE;oBACpB,QAAQ,EAAE,IAAI,CAAC,OAAO;oBACtB,WAAW,EAAE,6BAA6B,MAAM,EAAE;iBACnD,CACF,CAAC;YACJ,CAAC;YAED,MAAM,WAAW,CAAC,iBAAiB,EAAE,CAAC;YAEtC,+DAA+D;YAC/D,KAAK,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC;gBACpC,EAAE,EAAE,cAAc,CAAC,EAAE;gBACrB,QAAQ,EAAE,cAAc,CAAC,QAAQ;gBACjC,IAAI,EAAE,gBAAgB;gBACtB,SAAS,EAAE,cAAc,CAAC,oBAAoB;gBAC9C,KAAK,EAAE,eAAe,CAAC,OAAO;gBAC9B,MAAM,EAAE,WAAW;gBACnB,SAAS,EAAE,cAAc,CAAC,SAAS;gBACnC,SAAS,EAAE,cAAc,CAAC,SAAS;aACpC,CAAC,CAAC;YAEH,4EAA4E;YAC5E,IAAI,cAAc,CAAC,YAAY,EAAE,CAAC;gBAChC,KAAK,IAAI,CAAC,WAAW;qBAClB,qBAAqB,CAAC,cAAc,CAAC,YAAY,CAAC;qBAClD,IAAI,CAAC,CAAC,YAAY,EAAE,EAAE;oBACrB,IAAI,YAAY,EAAE,CAAC;wBACjB,KAAK,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC;4BACjC,MAAM,EAAE,YAAY;4BACpB,KAAK,EAAE,0BAA0B;4BACjC,OAAO,EAAE,GAAG,cAAc,CAAC,oBAAoB,MAAM,eAAe,CAAC,OAAO,gCAAgC,MAAM,EAAE;4BACpH,IAAI,EAAE,OAAO;4BACb,UAAU,EAAE,gBAAgB;4BAC5B,QAAQ,EAAE,cAAc,CAAC,EAAE;4BAC3B,IAAI,EAAE,oBAAoB,cAAc,CAAC,QAAQ,EAAE;yBACpD,CAAC,CAAC;oBACL,CAAC;gBACH,CAAC,CAAC;qBACD,KAAK,CAAC,CAAC,GAAU,EAAE,EAAE,CACpB,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,+BAA+B,GAAG,CAAC,OAAO,EAAE,CAAC,CAC/D,CAAC;YACN,CAAC;YAED,OAAO;gBACL,OAAO,EAAE,IAAI;gBACb,OAAO,EAAE,cAAc,IAAI,uCAAuC;gBAClE,uBAAuB,EAAE,kBAAkB,CAAC,MAAM;aACnD,CAAC;QACJ,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,WAAW,CAAC,mBAAmB,EAAE,CAAC;YACxC,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,oCAAqC,KAAe,CAAC,OAAO,EAAE,CAC/D,CAAC;YACF,MAAM,KAAK,CAAC;QACd,CAAC;gBAAS,CAAC;YACT,MAAM,WAAW,CAAC,OAAO,EAAE,CAAC;QAC9B,CAAC;IACH,CAAC;IAED,KAAK,CAAC,UAAU,CACd,SAAmB,EACnB,MAAc,EACd,IAAU;QAEV,MAAM,SAAS,GAAa,EAAE,CAAC;QAC/B,MAAM,MAAM,GAAa,EAAE,CAAC;QAE5B,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE,CAAC;YACjC,IAAI,CAAC;gBACH,MAAM,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC;gBAC1C,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YAC3B,CAAC;YAAC,MAAM,CAAC;gBACP,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YACxB,CAAC;QACH,CAAC;QAED,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,CAAC;IAC/B,CAAC;IAED,KAAK,CAAC,SAAS,CAAC,SAAkC;QAChD,MAAM,EAAE,IAAI,EAAE,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;QAE/C,MAAM,MAAM,GAAG;YACb,cAAc;YACd,KAAK;YACL,SAAS;YACT,MAAM;YACN,QAAQ;YACR,SAAS;YACT,MAAM;YACN,UAAU;YACV,YAAY;SACb,CAAC;QACF,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE;YAC5B,MAAM,IAAI,GAAG,GAAG,CAAC,cAAc,IAAK,GAAiC,CAAC;YACtE,OAAO;gBACL,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,oBAAoB,IAAI,EAAE,CAAC;gBAC/C,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,aAAa,IAAI,MAAM,CAAC,GAAG,CAAC,cAAc,IAAI,CAAC,CAAC,CAAC;gBACpE,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,OAAO,IAAI,EAAE,CAAC;gBACjC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,QAAQ,IAAI,EAAE,CAAC;gBACzC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,MAAM,EAAE,UAAU,IAAI,EAAE,CAAC;gBAC5C,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,EAAE,WAAW,IAAI,EAAE,CAAC;gBAC/C,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,UAAU,EAAE,gBAAgB,IAAI,EAAE,CAAC;gBACvD,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE;gBACpE,IAAI,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;aACpD,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACd,CAAC,CAAC,CAAC;QAEH,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAChD,CAAC;IAEO,SAAS,CAAC,KAAa;QAC7B,IAAI,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;YACvE,OAAO,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,GAAG,CAAC;QAC1C,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;CACF,CAAA;AAljCY,sDAAqB;gCAArB,qBAAqB;IADjC,IAAA,mBAAU,GAAE;IAuBR,WAAA,IAAA,0BAAgB,EAAC,sCAAc,CAAC,CAAA;IAEhC,WAAA,IAAA,0BAAgB,EAAC,uDAAsB,CAAC,CAAA;IAExC,WAAA,IAAA,0BAAgB,EAAC,+CAAkB,CAAC,CAAA;IAEpC,WAAA,IAAA,0BAAgB,EAAC,mDAAoB,CAAC,CAAA;IAEtC,WAAA,IAAA,0BAAgB,EAAC,yDAAuB,CAAC,CAAA;IAEzC,WAAA,IAAA,0BAAgB,EAAC,6CAAiB,CAAC,CAAA;yDATR,oBAAU,oBAAV,oBAAU,oDAEhB,oBAAU,oBAAV,oBAAU,oDAEd,oBAAU,oBAAV,oBAAU,oDAER,oBAAU,oBAAV,oBAAU,oDAEP,oBAAU,oBAAV,oBAAU,oDAEhB,oBAAU,oBAAV,oBAAU,oDACD,qDAAwB,oBAAxB,qDAAwB,oDACvB,uCAAiB,oBAAjB,uCAAiB,oDACpB,+CAAqB,oBAArB,+CAAqB,oDACxB,0BAAW,oBAAX,0BAAW,oDACZ,oBAAU,oBAAV,oBAAU,oDACP,8BAAa,oBAAb,8BAAa,oDACR,yCAAkB,oBAAlB,yCAAkB,oDACxB,2CAAmB,oBAAnB,2CAAmB,oDACZ,0CAAmB,oBAAnB,0CAAmB;GA1CvC,qBAAqB,CAkjCjC","names":[],"sources":["E:\\np-dms\\lcbp3\\backend\\src\\modules\\correspondence\\correspondence.service.ts"],"sourcesContent":["// File: src/modules/correspondence/correspondence.service.ts\r\n\r\nimport {\r\n  Injectable,\r\n  NotFoundException,\r\n  BadRequestException,\r\n  InternalServerErrorException,\r\n  ForbiddenException,\r\n  Logger,\r\n} from '@nestjs/common';\r\nimport { InjectRepository } from '@nestjs/typeorm';\r\nimport { Repository, DataSource } from 'typeorm';\r\n\r\n// Entities\r\nimport { Correspondence } from './entities/correspondence.entity';\r\nimport { CorrespondenceRevision } from './entities/correspondence-revision.entity';\r\nimport { CorrespondenceType } from './entities/correspondence-type.entity';\r\nimport { CorrespondenceStatus } from './entities/correspondence-status.entity';\r\nimport { CorrespondenceReference } from './entities/correspondence-reference.entity';\r\nimport { CorrespondenceRecipient } from './entities/correspondence-recipient.entity';\r\nimport { CorrespondenceTag } from './entities/correspondence-tag.entity';\r\nimport { Tag } from '../master/entities/tag.entity';\r\nimport { User } from '../user/entities/user.entity';\r\nimport { Organization } from '../organization/entities/organization.entity';\r\n\r\n// DTOs\r\nimport { CreateCorrespondenceDto } from './dto/create-correspondence.dto';\r\nimport { UpdateCorrespondenceDto } from './dto/update-correspondence.dto';\r\nimport { AddReferenceDto } from './dto/add-reference.dto';\r\nimport { SearchCorrespondenceDto } from './dto/search-correspondence.dto';\r\n\r\n// Services\r\nimport { DocumentNumberingService } from '../document-numbering/services/document-numbering.service';\r\nimport { JsonSchemaService } from '../json-schema/json-schema.service';\r\nimport { WorkflowEngineService } from '../workflow-engine/workflow-engine.service';\r\nimport { UserService } from '../user/user.service';\r\nimport { SearchService } from '../search/search.service';\r\nimport { FileStorageService } from '../../common/file-storage/file-storage.service';\r\nimport { UuidResolverService } from '../../common/services/uuid-resolver.service';\r\nimport { NotificationService } from '../notification/notification.service';\r\n\r\n/**\r\n * CorrespondenceService - Document management (CRUD)\r\n */\r\ninterface ResolvedRecipient {\r\n  organizationId: number;\r\n  type: 'TO' | 'CC';\r\n}\r\n@Injectable()\r\nexport class CorrespondenceService {\r\n  private readonly logger = new Logger(CorrespondenceService.name);\r\n\r\n  private async hasSystemManageAllPermission(userId: number): Promise<boolean> {\r\n    const permissions = await this.userService.getUserPermissions(userId);\r\n    return permissions.includes('system.manage_all');\r\n  }\r\n\r\n  /**\r\n   * Business Rule: Revision Label Strategy\r\n   * - RFA, RFI: Use alphabet starting with 'A' (A, B, C...)\r\n   * - Other types (LETTER, MEMO, etc.): Use numeric (null for first, then 1, 2, 3...)\r\n   */\r\n  private getInitialRevisionLabel(typeCode: string): string | null {\r\n    const alphabetTypes = ['RFA', 'RFI'];\r\n    if (alphabetTypes.includes(typeCode.toUpperCase())) {\r\n      return 'A'; // Alphabet for RFA, RFI\r\n    }\r\n    return null; // Numeric (null for revision 0)\r\n  }\r\n\r\n  constructor(\r\n    @InjectRepository(Correspondence)\r\n    private correspondenceRepo: Repository<Correspondence>,\r\n    @InjectRepository(CorrespondenceRevision)\r\n    private revisionRepo: Repository<CorrespondenceRevision>,\r\n    @InjectRepository(CorrespondenceType)\r\n    private typeRepo: Repository<CorrespondenceType>,\r\n    @InjectRepository(CorrespondenceStatus)\r\n    private statusRepo: Repository<CorrespondenceStatus>,\r\n    @InjectRepository(CorrespondenceReference)\r\n    private referenceRepo: Repository<CorrespondenceReference>,\r\n    @InjectRepository(CorrespondenceTag)\r\n    private tagRepo: Repository<CorrespondenceTag>,\r\n    private numberingService: DocumentNumberingService,\r\n    private jsonSchemaService: JsonSchemaService,\r\n    private workflowEngine: WorkflowEngineService,\r\n    private userService: UserService,\r\n    private dataSource: DataSource,\r\n    private searchService: SearchService,\r\n    private fileStorageService: FileStorageService,\r\n    private uuidResolver: UuidResolverService,\r\n    private notificationService: NotificationService\r\n  ) {}\r\n\r\n  /**\r\n   * Business Rule Validation: EC-CORR-003 - Correspondence to Self\r\n   * Prevent external correspondence to same organization\r\n   */\r\n  private async validateCorrespondenceRecipients(\r\n    createDto: CreateCorrespondenceDto,\r\n    user: User\r\n  ): Promise<void> {\r\n    // Get user's organization\r\n    let userOrgId = user.primaryOrganizationId;\r\n    if (!userOrgId) {\r\n      const fullUser = await this.userService.findOne(user.user_id);\r\n      if (fullUser) {\r\n        userOrgId = fullUser.primaryOrganizationId;\r\n      }\r\n    }\r\n\r\n    if (!userOrgId) {\r\n      if (createDto.originatorId) {\r\n        const canManageAll = await this.hasSystemManageAllPermission(\r\n          user.user_id\r\n        );\r\n        if (canManageAll) {\r\n          userOrgId = await this.uuidResolver.resolveOrganizationId(\r\n            createDto.originatorId\r\n          );\r\n        }\r\n      }\r\n\r\n      if (!userOrgId) {\r\n        throw new BadRequestException(\r\n          'User must belong to an organization to create documents'\r\n        );\r\n      }\r\n    }\r\n\r\n    // For impersonation, use the specified originator\r\n    const originatorOrgId = createDto.originatorId\r\n      ? await this.uuidResolver.resolveOrganizationId(createDto.originatorId)\r\n      : userOrgId;\r\n\r\n    // Check if it's internal communication\r\n    if (createDto.isInternal) {\r\n      // Internal communications should use Circulation instead\r\n      throw new BadRequestException(\r\n        'Internal communications should use Circulation Sheet instead of Correspondence'\r\n      );\r\n    }\r\n\r\n    // Validate recipients\r\n    if (!createDto.recipients || createDto.recipients.length === 0) {\r\n      throw new BadRequestException(\r\n        'At least one recipient (TO or CC) is required'\r\n      );\r\n    }\r\n\r\n    const toRecipients = createDto.recipients.filter((r) => r.type === 'TO');\r\n    const ccRecipients = createDto.recipients.filter((r) => r.type === 'CC');\r\n\r\n    if (toRecipients.length === 0 && ccRecipients.length === 0) {\r\n      throw new BadRequestException(\r\n        'At least one TO or CC recipient is required'\r\n      );\r\n    }\r\n\r\n    // Check for same organization correspondence\r\n    for (const recipient of createDto.recipients) {\r\n      const recipientOrgId = await this.uuidResolver.resolveOrganizationId(\r\n        recipient.organizationId\r\n      );\r\n\r\n      if (recipientOrgId === originatorOrgId) {\r\n        throw new BadRequestException(\r\n          'Cannot send correspondence to your own organization. Use Circulation Sheet for internal communication.'\r\n        );\r\n      }\r\n    }\r\n  }\r\n\r\n  async create(createDto: CreateCorrespondenceDto, user: User) {\r\n    // Business Rule Validation: EC-CORR-003 - Correspondence to Self\r\n    await this.validateCorrespondenceRecipients(createDto, user);\r\n    // ADR-019: Resolve UUID references to internal INT IDs\r\n    const resolvedProjectId = await this.uuidResolver.resolveProjectId(\r\n      createDto.projectId\r\n    );\r\n    const resolvedOriginatorId = createDto.originatorId\r\n      ? await this.uuidResolver.resolveOrganizationId(createDto.originatorId)\r\n      : undefined;\r\n    const resolvedRecipients = createDto.recipients\r\n      ? await Promise.all(\r\n          createDto.recipients.map(\r\n            async (r): Promise<ResolvedRecipient> => ({\r\n              organizationId: await this.uuidResolver.resolveOrganizationId(\r\n                r.organizationId\r\n              ),\r\n              type: r.type,\r\n            })\r\n          )\r\n        )\r\n      : undefined;\r\n    const type = await this.typeRepo.findOne({\r\n      where: { id: createDto.typeId },\r\n    });\r\n    if (!type) throw new NotFoundException('Document Type not found');\r\n\r\n    const statusDraft = await this.statusRepo.findOne({\r\n      where: { statusCode: 'DRAFT' },\r\n    });\r\n    if (!statusDraft) {\r\n      throw new InternalServerErrorException(\r\n        'Status DRAFT not found in Master Data'\r\n      );\r\n    }\r\n\r\n    let userOrgId = user.primaryOrganizationId;\r\n\r\n    if (!userOrgId) {\r\n      const fullUser = await this.userService.findOne(user.user_id);\r\n      if (fullUser) {\r\n        userOrgId = fullUser.primaryOrganizationId;\r\n      }\r\n    }\r\n\r\n    // Impersonation Logic\r\n    if (resolvedOriginatorId && resolvedOriginatorId !== userOrgId) {\r\n      const canManageAll = await this.hasSystemManageAllPermission(\r\n        user.user_id\r\n      );\r\n      if (!canManageAll) {\r\n        throw new ForbiddenException(\r\n          'You do not have permission to create documents on behalf of other organizations.'\r\n        );\r\n      }\r\n      userOrgId = resolvedOriginatorId;\r\n    }\r\n\r\n    if (!userOrgId) {\r\n      throw new BadRequestException(\r\n        'User must belong to an organization to create documents'\r\n      );\r\n    }\r\n\r\n    if (createDto.details) {\r\n      try {\r\n        await this.jsonSchemaService.validate(type.typeCode, createDto.details);\r\n      } catch (error: unknown) {\r\n        this.logger.warn(\r\n          `Schema validation warning for ${type.typeCode}: ${(error as Error).message}`\r\n        );\r\n      }\r\n    }\r\n\r\n    const queryRunner = this.dataSource.createQueryRunner();\r\n    await queryRunner.connect();\r\n    await queryRunner.startTransaction();\r\n\r\n    try {\r\n      // [Fix #6] Fetch real ORG Code from Organization entity\r\n      const originatorOrg = await this.dataSource.manager.findOne(\r\n        Organization,\r\n        {\r\n          where: { id: userOrgId },\r\n        }\r\n      );\r\n      const orgCode = originatorOrg?.organizationCode ?? 'UNK';\r\n\r\n      // [v1.5.1] Extract recipient organization from recipients array (Primary TO)\r\n      const toRecipient = resolvedRecipients?.find((r) => r.type === 'TO');\r\n      const recipientOrganizationId = toRecipient?.organizationId;\r\n\r\n      let recipientCode = '';\r\n      if (recipientOrganizationId) {\r\n        const recOrg = await this.dataSource.manager.findOne(Organization, {\r\n          where: { id: recipientOrganizationId },\r\n        });\r\n        if (recOrg) recipientCode = recOrg.organizationCode;\r\n      }\r\n\r\n      const docNumber = await this.numberingService.generateNextNumber({\r\n        projectId: resolvedProjectId,\r\n        originatorOrganizationId: userOrgId,\r\n        typeId: createDto.typeId,\r\n        disciplineId: createDto.disciplineId,\r\n        subTypeId: createDto.subTypeId,\r\n        recipientOrganizationId, // [v1.5.1] Pass recipient for document number format\r\n        year: new Date().getFullYear(),\r\n        customTokens: {\r\n          TYPE_CODE: type.typeCode,\r\n          ORG_CODE: orgCode,\r\n          RECIPIENT_CODE: recipientCode,\r\n          REC_CODE: recipientCode,\r\n        },\r\n      });\r\n\r\n      const correspondence = queryRunner.manager.create(Correspondence, {\r\n        correspondenceNumber: docNumber.number,\r\n        correspondenceTypeId: createDto.typeId,\r\n        disciplineId: createDto.disciplineId,\r\n        projectId: resolvedProjectId,\r\n        originatorId: userOrgId,\r\n        isInternal: createDto.isInternal || false,\r\n        createdBy: user.user_id,\r\n      });\r\n      const savedCorr = await queryRunner.manager.save(correspondence);\r\n\r\n      const revision = queryRunner.manager.create(CorrespondenceRevision, {\r\n        correspondenceId: savedCorr.id,\r\n        revisionNumber: 0,\r\n        revisionLabel: 'A',\r\n        isCurrent: true,\r\n        statusId: statusDraft.id,\r\n        subject: createDto.subject,\r\n        body: createDto.body,\r\n        remarks: createDto.remarks,\r\n        dueDate: createDto.dueDate ? new Date(createDto.dueDate) : undefined,\r\n        documentDate: createDto.documentDate\r\n          ? new Date(createDto.documentDate)\r\n          : undefined,\r\n        issuedDate: createDto.issuedDate\r\n          ? new Date(createDto.issuedDate)\r\n          : undefined,\r\n        receivedDate: createDto.receivedDate\r\n          ? new Date(createDto.receivedDate)\r\n          : undefined,\r\n        description: createDto.description,\r\n        details: createDto.details,\r\n        createdBy: user.user_id,\r\n        schemaVersion: 1,\r\n      });\r\n      await queryRunner.manager.save(revision);\r\n\r\n      // Save Recipients (using resolved INT IDs)\r\n      if (resolvedRecipients && resolvedRecipients.length > 0) {\r\n        const recipients = resolvedRecipients.map((r) =>\r\n          queryRunner.manager.create(CorrespondenceRecipient, {\r\n            correspondenceId: savedCorr.id,\r\n            recipientOrganizationId: r.organizationId,\r\n            recipientType: r.type,\r\n          })\r\n        );\r\n        await queryRunner.manager.save(recipients);\r\n      }\r\n\r\n      // Commit attachments from Temp → Permanent (Two-Phase Storage)\r\n      if (createDto.attachmentTempIds?.length) {\r\n        const issueDate = createDto.issuedDate\r\n          ? new Date(createDto.issuedDate)\r\n          : createDto.documentDate\r\n            ? new Date(createDto.documentDate)\r\n            : undefined;\r\n\r\n        await this.fileStorageService.commit(createDto.attachmentTempIds, {\r\n          issueDate,\r\n          documentType: 'Correspondence',\r\n        });\r\n      }\r\n\r\n      await queryRunner.commitTransaction();\r\n\r\n      // Start Workflow Instance (non-blocking)\r\n      try {\r\n        const workflowCode = `CORRESPONDENCE_${type.typeCode}`;\r\n        await this.workflowEngine.createInstance(\r\n          workflowCode,\r\n          'correspondence',\r\n          savedCorr.id.toString(),\r\n          {\r\n            projectId: resolvedProjectId,\r\n            originatorId: userOrgId,\r\n            disciplineId: createDto.disciplineId,\r\n            initiatorId: user.user_id,\r\n          } as Record<string, unknown>\r\n        );\r\n      } catch (error: unknown) {\r\n        this.logger.warn(\r\n          `Workflow not started for ${docNumber.number} (Code: CORRESPONDENCE_${type.typeCode}): ${(error as Error).message}`\r\n        );\r\n      }\r\n\r\n      // Fire-and-forget search indexing (non-blocking, void intentional)\r\n      void this.searchService.indexDocument({\r\n        id: savedCorr.id,\r\n        publicId: savedCorr.publicId,\r\n        type: 'correspondence',\r\n        docNumber: docNumber.number,\r\n        title: createDto.subject,\r\n        description: createDto.description,\r\n        status: 'DRAFT',\r\n        projectId: resolvedProjectId,\r\n        createdAt: new Date(),\r\n      });\r\n\r\n      return {\r\n        ...savedCorr,\r\n        currentRevision: revision,\r\n      };\r\n    } catch (err) {\r\n      await queryRunner.rollbackTransaction();\r\n      this.logger.error(\r\n        `Failed to create correspondence: ${(err as Error).message}`\r\n      );\r\n      throw err;\r\n    } finally {\r\n      await queryRunner.release();\r\n    }\r\n  }\r\n\r\n  async findAll(searchDto: SearchCorrespondenceDto = {}) {\r\n    const {\r\n      search,\r\n      typeId,\r\n      projectId,\r\n      statusId,\r\n      status,\r\n      page = 1,\r\n      limit = 10,\r\n    } = searchDto;\r\n    const skip = (page - 1) * limit;\r\n\r\n    // Change: Query from Revision Repo\r\n    const query = this.revisionRepo\r\n      .createQueryBuilder('rev')\r\n      .leftJoinAndSelect('rev.correspondence', 'corr')\r\n      .leftJoinAndSelect('corr.type', 'type')\r\n      .leftJoinAndSelect('corr.project', 'project')\r\n      .leftJoinAndSelect('corr.originator', 'org')\r\n      .leftJoinAndSelect('rev.status', 'status');\r\n\r\n    // Filter by Revision Status\r\n    const revStatus = searchDto.revisionStatus || 'CURRENT';\r\n\r\n    if (revStatus === 'CURRENT') {\r\n      query.where('rev.isCurrent = :isCurrent', { isCurrent: true });\r\n    } else if (revStatus === 'OLD') {\r\n      query.where('rev.isCurrent = :isCurrent', { isCurrent: false });\r\n    }\r\n    // If 'ALL', no filter needed on isCurrent\r\n\r\n    if (projectId) {\r\n      query.andWhere('corr.projectId = :projectId', { projectId });\r\n    }\r\n\r\n    if (typeId) {\r\n      query.andWhere('corr.correspondenceTypeId = :typeId', { typeId });\r\n    }\r\n\r\n    if (statusId) {\r\n      query.andWhere('rev.statusId = :statusId', { statusId });\r\n    }\r\n\r\n    if (status) {\r\n      query.andWhere('status.statusCode = :status', { status });\r\n    }\r\n\r\n    if (search) {\r\n      query.andWhere(\r\n        '(corr.correspondenceNumber LIKE :search OR rev.subject LIKE :search)',\r\n        { search: `%${search}%` }\r\n      );\r\n    }\r\n\r\n    // Default Sort: Latest Created\r\n    query.orderBy('rev.createdAt', 'DESC').skip(skip).take(limit);\r\n\r\n    const [items, total] = await query.getManyAndCount();\r\n\r\n    return {\r\n      data: items,\r\n      meta: {\r\n        total,\r\n        page,\r\n        limit,\r\n        totalPages: Math.ceil(total / limit),\r\n      },\r\n    };\r\n  }\r\n\r\n  async findOne(id: number) {\r\n    const correspondence = await this.correspondenceRepo.findOne({\r\n      where: { id },\r\n      relations: [\r\n        'revisions',\r\n        'revisions.status',\r\n        'type',\r\n        'project',\r\n        'originator',\r\n        'recipients',\r\n        'recipients.recipientOrganization', // [v1.5.1] Fixed relation name\r\n      ],\r\n    });\r\n\r\n    if (!correspondence) {\r\n      throw new NotFoundException(`Correspondence with ID ${id} not found`);\r\n    }\r\n    return correspondence;\r\n  }\r\n\r\n  async findOneByUuid(publicId: string) {\r\n    const correspondence = await this.correspondenceRepo.findOne({\r\n      where: { publicId },\r\n      relations: [\r\n        'revisions',\r\n        'revisions.status',\r\n        'type',\r\n        'project',\r\n        'originator',\r\n        'recipients',\r\n        'recipients.recipientOrganization',\r\n      ],\r\n    });\r\n\r\n    if (!correspondence) {\r\n      throw new NotFoundException(\r\n        `Correspondence with UUID ${publicId} not found`\r\n      );\r\n    }\r\n    return correspondence;\r\n  }\r\n\r\n  async addReference(id: number, dto: AddReferenceDto) {\r\n    const source = await this.correspondenceRepo.findOne({ where: { id } });\r\n    // ADR-019: Resolve target publicId → internal INT id\r\n    const target = await this.correspondenceRepo.findOne({\r\n      where: { publicId: dto.targetUuid },\r\n    });\r\n\r\n    if (!source || !target) {\r\n      throw new NotFoundException('Source or Target correspondence not found');\r\n    }\r\n\r\n    if (source.id === target.id) {\r\n      throw new BadRequestException('Cannot reference self');\r\n    }\r\n\r\n    const exists = await this.referenceRepo.findOne({\r\n      where: {\r\n        sourceId: id,\r\n        targetId: target.id,\r\n      },\r\n    });\r\n\r\n    if (exists) {\r\n      return exists;\r\n    }\r\n\r\n    const ref = this.referenceRepo.create({\r\n      sourceId: id,\r\n      targetId: target.id,\r\n    });\r\n\r\n    return this.referenceRepo.save(ref);\r\n  }\r\n\r\n  async removeReference(id: number, targetId: number) {\r\n    const result = await this.referenceRepo.delete({\r\n      sourceId: id,\r\n      targetId: targetId,\r\n    });\r\n\r\n    if (result.affected === 0) {\r\n      throw new NotFoundException('Reference not found');\r\n    }\r\n  }\r\n\r\n  async getTags(id: number) {\r\n    const rows = await this.tagRepo.find({\r\n      where: { correspondenceId: id },\r\n      relations: ['tag'],\r\n    });\r\n    return rows.map((r) => r.tag).filter(Boolean);\r\n  }\r\n\r\n  async addTag(id: number, tagId: number) {\r\n    const correspondence = await this.correspondenceRepo.findOne({\r\n      where: { id },\r\n    });\r\n    if (!correspondence) {\r\n      throw new NotFoundException(`Correspondence ${id} not found`);\r\n    }\r\n\r\n    const tag = await this.dataSource.manager.findOne(Tag, {\r\n      where: { id: tagId },\r\n    });\r\n    if (!tag) {\r\n      throw new NotFoundException(`Tag ${tagId} not found`);\r\n    }\r\n\r\n    const exists = await this.tagRepo.findOne({\r\n      where: { correspondenceId: id, tagId },\r\n    });\r\n    if (exists) return exists;\r\n\r\n    const row = this.tagRepo.create({ correspondenceId: id, tagId });\r\n    return this.tagRepo.save(row);\r\n  }\r\n\r\n  async removeTag(id: number, tagId: number) {\r\n    const result = await this.tagRepo.delete({ correspondenceId: id, tagId });\r\n    if (result.affected === 0) {\r\n      throw new NotFoundException('Tag assignment not found');\r\n    }\r\n  }\r\n\r\n  async getReferences(id: number) {\r\n    const outgoing = await this.referenceRepo.find({\r\n      where: { sourceId: id },\r\n      relations: ['target', 'target.type'],\r\n    });\r\n\r\n    const incoming = await this.referenceRepo.find({\r\n      where: { targetId: id },\r\n      relations: ['source', 'source.type'],\r\n    });\r\n\r\n    return { outgoing, incoming };\r\n  }\r\n\r\n  async update(id: number, updateDto: UpdateCorrespondenceDto, user: User) {\r\n    // 1. Find Current Revision\r\n    const revision = await this.revisionRepo.findOne({\r\n      where: {\r\n        correspondenceId: id,\r\n        isCurrent: true,\r\n      },\r\n      relations: ['correspondence'],\r\n    });\r\n\r\n    if (!revision) {\r\n      throw new NotFoundException(\r\n        `Current revision for correspondence ${id} not found`\r\n      );\r\n    }\r\n\r\n    // 2. Check Permission\r\n    if (revision.statusId) {\r\n      const status = await this.statusRepo.findOne({\r\n        where: { id: revision.statusId },\r\n      });\r\n      if (status && status.statusCode !== 'DRAFT') {\r\n        throw new BadRequestException('Only DRAFT documents can be updated');\r\n      }\r\n    }\r\n\r\n    // ADR-019: Resolve UUID references in update DTO\r\n    const updResolvedProjectId = updateDto.projectId\r\n      ? await this.uuidResolver.resolveProjectId(updateDto.projectId)\r\n      : undefined;\r\n    const updResolvedOriginatorId = updateDto.originatorId\r\n      ? await this.uuidResolver.resolveOrganizationId(updateDto.originatorId)\r\n      : undefined;\r\n    const updResolvedRecipients = updateDto.recipients\r\n      ? await Promise.all(\r\n          updateDto.recipients.map(\r\n            async (r): Promise<ResolvedRecipient> => ({\r\n              organizationId: await this.uuidResolver.resolveOrganizationId(\r\n                r.organizationId\r\n              ),\r\n              type: r.type,\r\n            })\r\n          )\r\n        )\r\n      : undefined;\r\n\r\n    // 3. Update Correspondence Entity if needed\r\n    const correspondenceUpdate: Record<string, unknown> = {};\r\n    if (updateDto.disciplineId)\r\n      correspondenceUpdate.disciplineId = updateDto.disciplineId;\r\n    if (updResolvedProjectId)\r\n      correspondenceUpdate.projectId = updResolvedProjectId;\r\n    if (updResolvedOriginatorId)\r\n      correspondenceUpdate.originatorId = updResolvedOriginatorId;\r\n\r\n    if (Object.keys(correspondenceUpdate).length > 0) {\r\n      await this.correspondenceRepo.update(id, correspondenceUpdate);\r\n    }\r\n\r\n    // 4. Update Revision Entity\r\n    const revisionUpdate: Record<string, unknown> = {};\r\n    if (updateDto.subject) revisionUpdate.subject = updateDto.subject;\r\n    if (updateDto.body) revisionUpdate.body = updateDto.body;\r\n    if (updateDto.remarks) revisionUpdate.remarks = updateDto.remarks;\r\n    // Format Date correctly if string\r\n    if (updateDto.dueDate) revisionUpdate.dueDate = new Date(updateDto.dueDate);\r\n    if (updateDto.documentDate)\r\n      revisionUpdate.documentDate = new Date(updateDto.documentDate);\r\n    if (updateDto.issuedDate)\r\n      revisionUpdate.issuedDate = new Date(updateDto.issuedDate);\r\n    if (updateDto.receivedDate)\r\n      revisionUpdate.receivedDate = new Date(updateDto.receivedDate);\r\n    if (updateDto.description)\r\n      revisionUpdate.description = updateDto.description;\r\n    if (updateDto.details) revisionUpdate.details = updateDto.details;\r\n\r\n    if (Object.keys(revisionUpdate).length > 0) {\r\n      await this.revisionRepo.update(revision.id, revisionUpdate);\r\n    }\r\n\r\n    // 4.5 Commit new attachments from Temp → Permanent (Two-Phase Storage)\r\n    if (updateDto.attachmentTempIds?.length) {\r\n      const issueDate = updateDto.issuedDate\r\n        ? new Date(updateDto.issuedDate)\r\n        : updateDto.documentDate\r\n          ? new Date(updateDto.documentDate)\r\n          : revision.issuedDate || revision.documentDate || undefined;\r\n\r\n      await this.fileStorageService.commit(updateDto.attachmentTempIds, {\r\n        issueDate: issueDate ? new Date(issueDate) : undefined,\r\n        documentType: 'Correspondence',\r\n      });\r\n    }\r\n\r\n    // 5. Update Recipients if provided\r\n    if (updResolvedRecipients) {\r\n      const recipientRepo = this.dataSource.getRepository(\r\n        CorrespondenceRecipient\r\n      );\r\n      await recipientRepo.delete({ correspondenceId: id });\r\n\r\n      const newRecipients = updResolvedRecipients.map((r) =>\r\n        recipientRepo.create({\r\n          correspondenceId: id,\r\n          recipientOrganizationId: r.organizationId,\r\n          recipientType: r.type,\r\n        })\r\n      );\r\n      await recipientRepo.save(newRecipients);\r\n    }\r\n\r\n    // 6. Regenerate Document Number if structural fields changed (Recipient, Discipline, Type, Project)\r\n    // AND it is a DRAFT.\r\n\r\n    // Fetch fresh data for context and comparison\r\n    const currentCorr = await this.correspondenceRepo.findOne({\r\n      where: { id },\r\n      relations: ['type', 'recipients', 'recipients.recipientOrganization'],\r\n    });\r\n\r\n    if (currentCorr) {\r\n      const currentToRecipient = currentCorr.recipients?.find(\r\n        (r) => r.recipientType === 'TO'\r\n      );\r\n      const currentRecipientId = currentToRecipient?.recipientOrganizationId;\r\n\r\n      // Check for ACTUAL value changes\r\n      const isProjectChanged =\r\n        updResolvedProjectId !== undefined &&\r\n        updResolvedProjectId !== currentCorr.projectId;\r\n      const isOriginatorChanged =\r\n        updResolvedOriginatorId !== undefined &&\r\n        updResolvedOriginatorId !== currentCorr.originatorId;\r\n      const isDisciplineChanged =\r\n        updateDto.disciplineId !== undefined &&\r\n        updateDto.disciplineId !== currentCorr.disciplineId;\r\n      const isTypeChanged =\r\n        updateDto.typeId !== undefined &&\r\n        updateDto.typeId !== currentCorr.correspondenceTypeId;\r\n\r\n      let isRecipientChanged = false;\r\n      let newRecipientId: number | undefined;\r\n\r\n      if (updResolvedRecipients) {\r\n        const newToRecipient = updResolvedRecipients.find(\r\n          (r) => r.type === 'TO'\r\n        );\r\n        newRecipientId = newToRecipient?.organizationId;\r\n\r\n        if (newRecipientId !== currentRecipientId) {\r\n          isRecipientChanged = true;\r\n        }\r\n      }\r\n\r\n      if (\r\n        isProjectChanged ||\r\n        isDisciplineChanged ||\r\n        isTypeChanged ||\r\n        isRecipientChanged ||\r\n        isOriginatorChanged\r\n      ) {\r\n        const targetRecipientId = isRecipientChanged\r\n          ? newRecipientId\r\n          : currentRecipientId;\r\n\r\n        // Resolve Recipient Code for the NEW context\r\n        let recipientCode = '';\r\n        if (targetRecipientId) {\r\n          const recOrg = await this.dataSource.manager.findOne(Organization, {\r\n            where: { id: targetRecipientId },\r\n          });\r\n          if (recOrg) recipientCode = recOrg.organizationCode;\r\n        }\r\n\r\n        // [Fix #6] Fetch real ORG Code from originator organization\r\n        const originatorOrgForUpdate = await this.dataSource.manager.findOne(\r\n          Organization,\r\n          {\r\n            where: {\r\n              id: updResolvedOriginatorId ?? currentCorr.originatorId ?? 0,\r\n            },\r\n          }\r\n        );\r\n        const orgCode = originatorOrgForUpdate?.organizationCode ?? 'UNK';\r\n\r\n        // Prepare Contexts\r\n        const oldCtx = {\r\n          projectId: currentCorr.projectId,\r\n          originatorOrganizationId: currentCorr.originatorId ?? 0,\r\n          typeId: currentCorr.correspondenceTypeId,\r\n          disciplineId: currentCorr.disciplineId,\r\n          recipientOrganizationId: currentRecipientId,\r\n          year: new Date().getFullYear(),\r\n        };\r\n\r\n        const newCtx = {\r\n          projectId: updResolvedProjectId ?? currentCorr.projectId,\r\n          originatorOrganizationId:\r\n            updResolvedOriginatorId ?? currentCorr.originatorId ?? 0,\r\n          typeId: updateDto.typeId ?? currentCorr.correspondenceTypeId,\r\n          disciplineId: updateDto.disciplineId ?? currentCorr.disciplineId,\r\n          recipientOrganizationId: targetRecipientId,\r\n          year: new Date().getFullYear(),\r\n          userId: user.user_id, // Pass User ID for Audit\r\n          customTokens: {\r\n            TYPE_CODE: currentCorr.type?.typeCode || '',\r\n            ORG_CODE: orgCode,\r\n            RECIPIENT_CODE: recipientCode,\r\n            REC_CODE: recipientCode,\r\n          },\r\n        };\r\n\r\n        // If Type Changed, need NEW Type Code\r\n        if (isTypeChanged) {\r\n          const newType = await this.typeRepo.findOne({\r\n            where: { id: newCtx.typeId },\r\n          });\r\n          if (newType) newCtx.customTokens.TYPE_CODE = newType.typeCode;\r\n        }\r\n\r\n        const newDocNumber = await this.numberingService.updateNumberForDraft(\r\n          currentCorr.correspondenceNumber,\r\n          oldCtx,\r\n          newCtx\r\n        );\r\n\r\n        await this.correspondenceRepo.update(id, {\r\n          correspondenceNumber: newDocNumber,\r\n        });\r\n      }\r\n    }\r\n\r\n    const updated = await this.findOne(id);\r\n\r\n    // Re-index updated document in Elasticsearch (fire-and-forget)\r\n    void this.searchService.indexDocument({\r\n      id: updated.id,\r\n      publicId: updated.publicId,\r\n      type: 'correspondence',\r\n      docNumber: updated.correspondenceNumber,\r\n      title: updateDto.subject ?? updated.revisions?.[0]?.subject,\r\n      description: updateDto.description ?? updated.revisions?.[0]?.description,\r\n      status: 'DRAFT',\r\n      projectId: updated.projectId,\r\n      createdAt: updated.createdAt,\r\n    });\r\n\r\n    return updated;\r\n  }\r\n\r\n  async previewDocumentNumber(createDto: CreateCorrespondenceDto, user: User) {\r\n    // ADR-019: Resolve UUID references\r\n    const previewProjectId = await this.uuidResolver.resolveProjectId(\r\n      createDto.projectId\r\n    );\r\n    const previewOriginatorId = createDto.originatorId\r\n      ? await this.uuidResolver.resolveOrganizationId(createDto.originatorId)\r\n      : undefined;\r\n    const previewRecipients = createDto.recipients\r\n      ? await Promise.all(\r\n          createDto.recipients.map(\r\n            async (r): Promise<ResolvedRecipient> => ({\r\n              organizationId: await this.uuidResolver.resolveOrganizationId(\r\n                r.organizationId\r\n              ),\r\n              type: r.type,\r\n            })\r\n          )\r\n        )\r\n      : undefined;\r\n\r\n    const type = await this.typeRepo.findOne({\r\n      where: { id: createDto.typeId },\r\n    });\r\n    if (!type) throw new NotFoundException('Document Type not found');\r\n\r\n    let userOrgId = user.primaryOrganizationId;\r\n    if (!userOrgId) {\r\n      const fullUser = await this.userService.findOne(user.user_id);\r\n      if (fullUser) userOrgId = fullUser.primaryOrganizationId;\r\n    }\r\n\r\n    if (previewOriginatorId && previewOriginatorId !== userOrgId) {\r\n      // Allow impersonation for preview\r\n      userOrgId = previewOriginatorId;\r\n    }\r\n\r\n    // Extract recipient from recipients array\r\n    const toRecipient = previewRecipients?.find((r) => r.type === 'TO');\r\n    const recipientOrganizationId = toRecipient?.organizationId;\r\n\r\n    let recipientCode = '';\r\n    if (recipientOrganizationId) {\r\n      const recOrg = await this.dataSource.manager.findOne(Organization, {\r\n        where: { id: recipientOrganizationId },\r\n      });\r\n      if (recOrg) recipientCode = recOrg.organizationCode;\r\n    }\r\n\r\n    return this.numberingService.previewNumber({\r\n      projectId: previewProjectId,\r\n      originatorOrganizationId: userOrgId!,\r\n      typeId: createDto.typeId,\r\n      disciplineId: createDto.disciplineId,\r\n      subTypeId: createDto.subTypeId,\r\n      recipientOrganizationId,\r\n      year: new Date().getFullYear(),\r\n      customTokens: {\r\n        TYPE_CODE: type.typeCode,\r\n        RECIPIENT_CODE: recipientCode,\r\n        REC_CODE: recipientCode,\r\n      },\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Business Rule Implementation: EC-CORR-001 - Cancel Correspondence with Downstream Circulation\r\n   * Cancel correspondence and handle related circulations\r\n   */\r\n  async cancel(publicId: string, reason: string, user: User) {\r\n    const correspondence = await this.findOneByUuid(publicId);\r\n\r\n    // Check if user has permission to cancel (Org Admin or Superadmin only)\r\n    const permissions = await this.userService.getUserPermissions(user.user_id);\r\n    const canCancel =\r\n      permissions.includes('correspondence.cancel') ||\r\n      permissions.includes('system.manage_all');\r\n\r\n    if (!canCancel) {\r\n      throw new ForbiddenException(\r\n        'Only administrators can cancel correspondences'\r\n      );\r\n    }\r\n\r\n    // Check if there are any active circulations\r\n    const circulationRepo = this.dataSource.getRepository('Circulation');\r\n    const activeCirculations = await circulationRepo.find({\r\n      where: {\r\n        correspondenceId: correspondence.id,\r\n        status: 'OPEN',\r\n      },\r\n    });\r\n\r\n    const warningMessage =\r\n      activeCirculations.length > 0\r\n        ? `There are ${activeCirculations.length} active circulation(s) for this correspondence. Canceling will force close all related circulations.`\r\n        : '';\r\n\r\n    // Get the current revision to update status\r\n    const currentRevision = await this.revisionRepo.findOne({\r\n      where: {\r\n        correspondenceId: correspondence.id,\r\n        isCurrent: true,\r\n      },\r\n    });\r\n\r\n    if (!currentRevision) {\r\n      throw new NotFoundException('Current revision not found');\r\n    }\r\n\r\n    // Get cancelled status\r\n    const cancelledStatus = await this.statusRepo.findOne({\r\n      where: { statusCode: 'CANCELLED' },\r\n    });\r\n\r\n    if (!cancelledStatus) {\r\n      throw new InternalServerErrorException('CANCELLED status not found');\r\n    }\r\n\r\n    const queryRunner = this.dataSource.createQueryRunner();\r\n    await queryRunner.connect();\r\n    await queryRunner.startTransaction();\r\n\r\n    try {\r\n      // Update correspondence revision status to CANCELLED\r\n      await queryRunner.manager.update(\r\n        CorrespondenceRevision,\r\n        currentRevision.id,\r\n        {\r\n          statusId: cancelledStatus.id,\r\n          remarks: `Cancelled: ${reason}`,\r\n        }\r\n      );\r\n\r\n      // Force close all active circulations\r\n      if (activeCirculations.length > 0) {\r\n        await queryRunner.manager.update(\r\n          'Circulation',\r\n          {\r\n            correspondenceId: correspondence.id,\r\n            status: 'OPEN',\r\n          },\r\n          {\r\n            status: 'FORCE_CLOSED',\r\n            closedAt: new Date(),\r\n            closedBy: user.user_id,\r\n            closeReason: `Correspondence cancelled: ${reason}`,\r\n          }\r\n        );\r\n      }\r\n\r\n      await queryRunner.commitTransaction();\r\n\r\n      // Re-index cancelled status in Elasticsearch (fire-and-forget)\r\n      void this.searchService.indexDocument({\r\n        id: correspondence.id,\r\n        publicId: correspondence.publicId,\r\n        type: 'correspondence',\r\n        docNumber: correspondence.correspondenceNumber,\r\n        title: currentRevision.subject,\r\n        status: 'CANCELLED',\r\n        projectId: correspondence.projectId,\r\n        createdAt: correspondence.createdAt,\r\n      });\r\n\r\n      // Notify originator's doc-control user about cancellation (fire-and-forget)\r\n      if (correspondence.originatorId) {\r\n        void this.userService\r\n          .findDocControlIdByOrg(correspondence.originatorId)\r\n          .then((targetUserId) => {\r\n            if (targetUserId) {\r\n              void this.notificationService.send({\r\n                userId: targetUserId,\r\n                title: 'Correspondence Cancelled',\r\n                message: `${correspondence.correspondenceNumber} — ${currentRevision.subject} has been cancelled. Reason: ${reason}`,\r\n                type: 'EMAIL',\r\n                entityType: 'correspondence',\r\n                entityId: correspondence.id,\r\n                link: `/correspondences/${correspondence.publicId}`,\r\n              });\r\n            }\r\n          })\r\n          .catch((err: Error) =>\r\n            this.logger.warn(`Cancel notification failed: ${err.message}`)\r\n          );\r\n      }\r\n\r\n      return {\r\n        success: true,\r\n        message: warningMessage || 'Correspondence cancelled successfully',\r\n        activeCirculationsCount: activeCirculations.length,\r\n      };\r\n    } catch (error) {\r\n      await queryRunner.rollbackTransaction();\r\n      this.logger.error(\r\n        `Failed to cancel correspondence: ${(error as Error).message}`\r\n      );\r\n      throw error;\r\n    } finally {\r\n      await queryRunner.release();\r\n    }\r\n  }\r\n\r\n  async bulkCancel(\r\n    publicIds: string[],\r\n    reason: string,\r\n    user: User\r\n  ): Promise<{ succeeded: string[]; failed: string[] }> {\r\n    const succeeded: string[] = [];\r\n    const failed: string[] = [];\r\n\r\n    for (const publicId of publicIds) {\r\n      try {\r\n        await this.cancel(publicId, reason, user);\r\n        succeeded.push(publicId);\r\n      } catch {\r\n        failed.push(publicId);\r\n      }\r\n    }\r\n\r\n    return { succeeded, failed };\r\n  }\r\n\r\n  async exportCsv(searchDto: SearchCorrespondenceDto): Promise<string> {\r\n    const { data } = await this.findAll(searchDto);\r\n\r\n    const header = [\r\n      'Document No.',\r\n      'Rev',\r\n      'Subject',\r\n      'Type',\r\n      'Status',\r\n      'Project',\r\n      'From',\r\n      'Due Date',\r\n      'Created At',\r\n    ];\r\n    const rows = data.map((rev) => {\r\n      const corr = rev.correspondence ?? (rev as unknown as Correspondence);\r\n      return [\r\n        this.escapeCsv(corr.correspondenceNumber ?? ''),\r\n        this.escapeCsv(rev.revisionLabel ?? String(rev.revisionNumber ?? 0)),\r\n        this.escapeCsv(rev.subject ?? ''),\r\n        this.escapeCsv(corr.type?.typeCode ?? ''),\r\n        this.escapeCsv(rev.status?.statusCode ?? ''),\r\n        this.escapeCsv(corr.project?.projectCode ?? ''),\r\n        this.escapeCsv(corr.originator?.organizationCode ?? ''),\r\n        rev.dueDate ? new Date(rev.dueDate).toISOString().split('T')[0] : '',\r\n        new Date(rev.createdAt).toISOString().split('T')[0],\r\n      ].join(',');\r\n    });\r\n\r\n    return [header.join(','), ...rows].join('\\n');\r\n  }\r\n\r\n  private escapeCsv(value: string): string {\r\n    if (value.includes(',') || value.includes('\"') || value.includes('\\n')) {\r\n      return `\"${value.replace(/\"/g, '\"\"')}\"`;\r\n    }\r\n    return value;\r\n  }\r\n}\r\n"],"version":3} \ No newline at end of file diff --git a/backend/src/.jest-cache/jest-transform-cache-60cab15b743c6776f41d29bcac696b99-12533232bd0f05f65688e7a7764bf3fb/50/correspondenceservice_502139c633196704eef09d9c7ce64dc0.map b/backend/src/.jest-cache/jest-transform-cache-60cab15b743c6776f41d29bcac696b99-12533232bd0f05f65688e7a7764bf3fb/50/correspondenceservice_502139c633196704eef09d9c7ce64dc0.map new file mode 100644 index 0000000..84cf18f --- /dev/null +++ b/backend/src/.jest-cache/jest-transform-cache-60cab15b743c6776f41d29bcac696b99-12533232bd0f05f65688e7a7764bf3fb/50/correspondenceservice_502139c633196704eef09d9c7ce64dc0.map @@ -0,0 +1 @@ +{"file":"E:\\np-dms\\lcbp3\\backend\\src\\modules\\correspondence\\correspondence.service.ts","mappings":"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","names":[],"sources":["E:\\np-dms\\lcbp3\\backend\\src\\modules\\correspondence\\correspondence.service.ts"],"sourcesContent":["// File: src/modules/correspondence/correspondence.service.ts\r\n\r\nimport {\r\n Injectable,\r\n NotFoundException,\r\n BadRequestException,\r\n InternalServerErrorException,\r\n ForbiddenException,\r\n Logger,\r\n} from '@nestjs/common';\r\nimport { InjectRepository } from '@nestjs/typeorm';\r\nimport { Repository, DataSource } from 'typeorm';\r\n\r\n// Entities\r\nimport { Correspondence } from './entities/correspondence.entity';\r\nimport { CorrespondenceRevision } from './entities/correspondence-revision.entity';\r\nimport { CorrespondenceType } from './entities/correspondence-type.entity';\r\nimport { CorrespondenceStatus } from './entities/correspondence-status.entity';\r\nimport { CorrespondenceReference } from './entities/correspondence-reference.entity';\r\nimport { CorrespondenceRecipient } from './entities/correspondence-recipient.entity';\r\nimport { CorrespondenceTag } from './entities/correspondence-tag.entity';\r\nimport { Tag } from '../master/entities/tag.entity';\r\nimport { User } from '../user/entities/user.entity';\r\nimport { Organization } from '../organization/entities/organization.entity';\r\n\r\n// DTOs\r\nimport { CreateCorrespondenceDto } from './dto/create-correspondence.dto';\r\nimport { UpdateCorrespondenceDto } from './dto/update-correspondence.dto';\r\nimport { AddReferenceDto } from './dto/add-reference.dto';\r\nimport { SearchCorrespondenceDto } from './dto/search-correspondence.dto';\r\n\r\n// Services\r\nimport { DocumentNumberingService } from '../document-numbering/services/document-numbering.service';\r\nimport { JsonSchemaService } from '../json-schema/json-schema.service';\r\nimport { WorkflowEngineService } from '../workflow-engine/workflow-engine.service';\r\nimport { UserService } from '../user/user.service';\r\nimport { SearchService } from '../search/search.service';\r\nimport { FileStorageService } from '../../common/file-storage/file-storage.service';\r\nimport { UuidResolverService } from '../../common/services/uuid-resolver.service';\r\nimport { NotificationService } from '../notification/notification.service';\r\n\r\n/**\r\n * CorrespondenceService - Document management (CRUD)\r\n */\r\ninterface ResolvedRecipient {\r\n organizationId: number;\r\n type: 'TO' | 'CC';\r\n}\r\n@Injectable()\r\nexport class CorrespondenceService {\r\n private readonly logger = new Logger(CorrespondenceService.name);\r\n\r\n private async hasSystemManageAllPermission(userId: number): Promise {\r\n const permissions = await this.userService.getUserPermissions(userId);\r\n return permissions.includes('system.manage_all');\r\n }\r\n\r\n /**\r\n * Business Rule: Revision Label Strategy\r\n * - RFA, RFI: Use alphabet starting with 'A' (A, B, C...)\r\n * - Other types (LETTER, MEMO, etc.): Use numeric (null for first, then 1, 2, 3...)\r\n */\r\n private getInitialRevisionLabel(typeCode: string): string | null {\r\n const alphabetTypes = ['RFA', 'RFI'];\r\n if (alphabetTypes.includes(typeCode.toUpperCase())) {\r\n return 'A'; // Alphabet for RFA, RFI\r\n }\r\n return null; // Numeric (null for revision 0)\r\n }\r\n\r\n constructor(\r\n @InjectRepository(Correspondence)\r\n private correspondenceRepo: Repository,\r\n @InjectRepository(CorrespondenceRevision)\r\n private revisionRepo: Repository,\r\n @InjectRepository(CorrespondenceType)\r\n private typeRepo: Repository,\r\n @InjectRepository(CorrespondenceStatus)\r\n private statusRepo: Repository,\r\n @InjectRepository(CorrespondenceReference)\r\n private referenceRepo: Repository,\r\n @InjectRepository(CorrespondenceTag)\r\n private tagRepo: Repository,\r\n private numberingService: DocumentNumberingService,\r\n private jsonSchemaService: JsonSchemaService,\r\n private workflowEngine: WorkflowEngineService,\r\n private userService: UserService,\r\n private dataSource: DataSource,\r\n private searchService: SearchService,\r\n private fileStorageService: FileStorageService,\r\n private uuidResolver: UuidResolverService,\r\n private notificationService: NotificationService\r\n ) {}\r\n\r\n /**\r\n * Business Rule Validation: EC-CORR-003 - Correspondence to Self\r\n * Prevent external correspondence to same organization\r\n */\r\n private async validateCorrespondenceRecipients(\r\n createDto: CreateCorrespondenceDto,\r\n user: User\r\n ): Promise {\r\n // Get user's organization\r\n let userOrgId = user.primaryOrganizationId;\r\n if (!userOrgId) {\r\n const fullUser = await this.userService.findOne(user.user_id);\r\n if (fullUser) {\r\n userOrgId = fullUser.primaryOrganizationId;\r\n }\r\n }\r\n\r\n if (!userOrgId) {\r\n if (createDto.originatorId) {\r\n const canManageAll = await this.hasSystemManageAllPermission(\r\n user.user_id\r\n );\r\n if (canManageAll) {\r\n userOrgId = await this.uuidResolver.resolveOrganizationId(\r\n createDto.originatorId\r\n );\r\n }\r\n }\r\n\r\n if (!userOrgId) {\r\n throw new BadRequestException(\r\n 'User must belong to an organization to create documents'\r\n );\r\n }\r\n }\r\n\r\n // For impersonation, use the specified originator\r\n const originatorOrgId = createDto.originatorId\r\n ? await this.uuidResolver.resolveOrganizationId(createDto.originatorId)\r\n : userOrgId;\r\n\r\n // Check if it's internal communication\r\n if (createDto.isInternal) {\r\n // Internal communications should use Circulation instead\r\n throw new BadRequestException(\r\n 'Internal communications should use Circulation Sheet instead of Correspondence'\r\n );\r\n }\r\n\r\n // Validate recipients\r\n if (!createDto.recipients || createDto.recipients.length === 0) {\r\n throw new BadRequestException(\r\n 'At least one recipient (TO or CC) is required'\r\n );\r\n }\r\n\r\n const toRecipients = createDto.recipients.filter((r) => r.type === 'TO');\r\n const ccRecipients = createDto.recipients.filter((r) => r.type === 'CC');\r\n\r\n if (toRecipients.length === 0 && ccRecipients.length === 0) {\r\n throw new BadRequestException(\r\n 'At least one TO or CC recipient is required'\r\n );\r\n }\r\n\r\n // Check for same organization correspondence\r\n for (const recipient of createDto.recipients) {\r\n const recipientOrgId = await this.uuidResolver.resolveOrganizationId(\r\n recipient.organizationId\r\n );\r\n\r\n if (recipientOrgId === originatorOrgId) {\r\n throw new BadRequestException(\r\n 'Cannot send correspondence to your own organization. Use Circulation Sheet for internal communication.'\r\n );\r\n }\r\n }\r\n }\r\n\r\n async create(createDto: CreateCorrespondenceDto, user: User) {\r\n // Business Rule Validation: EC-CORR-003 - Correspondence to Self\r\n await this.validateCorrespondenceRecipients(createDto, user);\r\n // ADR-019: Resolve UUID references to internal INT IDs\r\n const resolvedProjectId = await this.uuidResolver.resolveProjectId(\r\n createDto.projectId\r\n );\r\n const resolvedOriginatorId = createDto.originatorId\r\n ? await this.uuidResolver.resolveOrganizationId(createDto.originatorId)\r\n : undefined;\r\n const resolvedRecipients = createDto.recipients\r\n ? await Promise.all(\r\n createDto.recipients.map(\r\n async (r): Promise => ({\r\n organizationId: await this.uuidResolver.resolveOrganizationId(\r\n r.organizationId\r\n ),\r\n type: r.type,\r\n })\r\n )\r\n )\r\n : undefined;\r\n const type = await this.typeRepo.findOne({\r\n where: { id: createDto.typeId },\r\n });\r\n if (!type) throw new NotFoundException('Document Type not found');\r\n\r\n const statusDraft = await this.statusRepo.findOne({\r\n where: { statusCode: 'DRAFT' },\r\n });\r\n if (!statusDraft) {\r\n throw new InternalServerErrorException(\r\n 'Status DRAFT not found in Master Data'\r\n );\r\n }\r\n\r\n let userOrgId = user.primaryOrganizationId;\r\n\r\n if (!userOrgId) {\r\n const fullUser = await this.userService.findOne(user.user_id);\r\n if (fullUser) {\r\n userOrgId = fullUser.primaryOrganizationId;\r\n }\r\n }\r\n\r\n // Impersonation Logic\r\n if (resolvedOriginatorId && resolvedOriginatorId !== userOrgId) {\r\n const canManageAll = await this.hasSystemManageAllPermission(\r\n user.user_id\r\n );\r\n if (!canManageAll) {\r\n throw new ForbiddenException(\r\n 'You do not have permission to create documents on behalf of other organizations.'\r\n );\r\n }\r\n userOrgId = resolvedOriginatorId;\r\n }\r\n\r\n if (!userOrgId) {\r\n throw new BadRequestException(\r\n 'User must belong to an organization to create documents'\r\n );\r\n }\r\n\r\n if (createDto.details) {\r\n try {\r\n await this.jsonSchemaService.validate(type.typeCode, createDto.details);\r\n } catch (error: unknown) {\r\n this.logger.warn(\r\n `Schema validation warning for ${type.typeCode}: ${(error as Error).message}`\r\n );\r\n }\r\n }\r\n\r\n const queryRunner = this.dataSource.createQueryRunner();\r\n await queryRunner.connect();\r\n await queryRunner.startTransaction();\r\n\r\n try {\r\n // [Fix #6] Fetch real ORG Code from Organization entity\r\n const originatorOrg = await this.dataSource.manager.findOne(\r\n Organization,\r\n {\r\n where: { id: userOrgId },\r\n }\r\n );\r\n const orgCode = originatorOrg?.organizationCode ?? 'UNK';\r\n\r\n // [v1.5.1] Extract recipient organization from recipients array (Primary TO)\r\n const toRecipient = resolvedRecipients?.find((r) => r.type === 'TO');\r\n const recipientOrganizationId = toRecipient?.organizationId;\r\n\r\n let recipientCode = '';\r\n if (recipientOrganizationId) {\r\n const recOrg = await this.dataSource.manager.findOne(Organization, {\r\n where: { id: recipientOrganizationId },\r\n });\r\n if (recOrg) recipientCode = recOrg.organizationCode;\r\n }\r\n\r\n const docNumber = await this.numberingService.generateNextNumber({\r\n projectId: resolvedProjectId,\r\n originatorOrganizationId: userOrgId,\r\n typeId: createDto.typeId,\r\n disciplineId: createDto.disciplineId,\r\n subTypeId: createDto.subTypeId,\r\n recipientOrganizationId, // [v1.5.1] Pass recipient for document number format\r\n year: new Date().getFullYear(),\r\n customTokens: {\r\n TYPE_CODE: type.typeCode,\r\n ORG_CODE: orgCode,\r\n RECIPIENT_CODE: recipientCode,\r\n REC_CODE: recipientCode,\r\n },\r\n });\r\n\r\n const correspondence = queryRunner.manager.create(Correspondence, {\r\n correspondenceNumber: docNumber.number,\r\n correspondenceTypeId: createDto.typeId,\r\n disciplineId: createDto.disciplineId,\r\n projectId: resolvedProjectId,\r\n originatorId: userOrgId,\r\n isInternal: createDto.isInternal || false,\r\n createdBy: user.user_id,\r\n });\r\n const savedCorr = await queryRunner.manager.save(correspondence);\r\n\r\n const revision = queryRunner.manager.create(CorrespondenceRevision, {\r\n correspondenceId: savedCorr.id,\r\n revisionNumber: 0,\r\n revisionLabel: 'A',\r\n isCurrent: true,\r\n statusId: statusDraft.id,\r\n subject: createDto.subject,\r\n body: createDto.body,\r\n remarks: createDto.remarks,\r\n dueDate: createDto.dueDate ? new Date(createDto.dueDate) : undefined,\r\n documentDate: createDto.documentDate\r\n ? new Date(createDto.documentDate)\r\n : undefined,\r\n issuedDate: createDto.issuedDate\r\n ? new Date(createDto.issuedDate)\r\n : undefined,\r\n receivedDate: createDto.receivedDate\r\n ? new Date(createDto.receivedDate)\r\n : undefined,\r\n description: createDto.description,\r\n details: createDto.details,\r\n createdBy: user.user_id,\r\n schemaVersion: 1,\r\n });\r\n await queryRunner.manager.save(revision);\r\n\r\n // Save Recipients (using resolved INT IDs)\r\n if (resolvedRecipients && resolvedRecipients.length > 0) {\r\n const recipients = resolvedRecipients.map((r) =>\r\n queryRunner.manager.create(CorrespondenceRecipient, {\r\n correspondenceId: savedCorr.id,\r\n recipientOrganizationId: r.organizationId,\r\n recipientType: r.type,\r\n })\r\n );\r\n await queryRunner.manager.save(recipients);\r\n }\r\n\r\n // Commit attachments from Temp → Permanent (Two-Phase Storage)\r\n if (createDto.attachmentTempIds?.length) {\r\n const issueDate = createDto.issuedDate\r\n ? new Date(createDto.issuedDate)\r\n : createDto.documentDate\r\n ? new Date(createDto.documentDate)\r\n : undefined;\r\n\r\n await this.fileStorageService.commit(createDto.attachmentTempIds, {\r\n issueDate,\r\n documentType: 'Correspondence',\r\n });\r\n }\r\n\r\n await queryRunner.commitTransaction();\r\n\r\n // Start Workflow Instance (non-blocking)\r\n try {\r\n const workflowCode = `CORRESPONDENCE_${type.typeCode}`;\r\n await this.workflowEngine.createInstance(\r\n workflowCode,\r\n 'correspondence',\r\n savedCorr.id.toString(),\r\n {\r\n projectId: resolvedProjectId,\r\n originatorId: userOrgId,\r\n disciplineId: createDto.disciplineId,\r\n initiatorId: user.user_id,\r\n } as Record\r\n );\r\n } catch (error: unknown) {\r\n this.logger.warn(\r\n `Workflow not started for ${docNumber.number} (Code: CORRESPONDENCE_${type.typeCode}): ${(error as Error).message}`\r\n );\r\n }\r\n\r\n // Fire-and-forget search indexing (non-blocking, void intentional)\r\n void this.searchService.indexDocument({\r\n id: savedCorr.id,\r\n publicId: savedCorr.publicId,\r\n type: 'correspondence',\r\n docNumber: docNumber.number,\r\n title: createDto.subject,\r\n description: createDto.description,\r\n status: 'DRAFT',\r\n projectId: resolvedProjectId,\r\n createdAt: new Date(),\r\n });\r\n\r\n return {\r\n ...savedCorr,\r\n currentRevision: revision,\r\n };\r\n } catch (err) {\r\n await queryRunner.rollbackTransaction();\r\n this.logger.error(\r\n `Failed to create correspondence: ${(err as Error).message}`\r\n );\r\n throw err;\r\n } finally {\r\n await queryRunner.release();\r\n }\r\n }\r\n\r\n async findAll(searchDto: SearchCorrespondenceDto = {}) {\r\n const {\r\n search,\r\n typeId,\r\n projectId,\r\n statusId,\r\n status,\r\n page = 1,\r\n limit = 10,\r\n } = searchDto;\r\n const skip = (page - 1) * limit;\r\n\r\n // Change: Query from Revision Repo\r\n const query = this.revisionRepo\r\n .createQueryBuilder('rev')\r\n .leftJoinAndSelect('rev.correspondence', 'corr')\r\n .leftJoinAndSelect('corr.type', 'type')\r\n .leftJoinAndSelect('corr.project', 'project')\r\n .leftJoinAndSelect('corr.originator', 'org')\r\n .leftJoinAndSelect('rev.status', 'status');\r\n\r\n // Filter by Revision Status\r\n const revStatus = searchDto.revisionStatus || 'CURRENT';\r\n\r\n if (revStatus === 'CURRENT') {\r\n query.where('rev.isCurrent = :isCurrent', { isCurrent: true });\r\n } else if (revStatus === 'OLD') {\r\n query.where('rev.isCurrent = :isCurrent', { isCurrent: false });\r\n }\r\n // If 'ALL', no filter needed on isCurrent\r\n\r\n if (projectId) {\r\n query.andWhere('corr.projectId = :projectId', { projectId });\r\n }\r\n\r\n if (typeId) {\r\n query.andWhere('corr.correspondenceTypeId = :typeId', { typeId });\r\n }\r\n\r\n if (statusId) {\r\n query.andWhere('rev.statusId = :statusId', { statusId });\r\n }\r\n\r\n if (status) {\r\n query.andWhere('status.statusCode = :status', { status });\r\n }\r\n\r\n if (search) {\r\n query.andWhere(\r\n '(corr.correspondenceNumber LIKE :search OR rev.subject LIKE :search)',\r\n { search: `%${search}%` }\r\n );\r\n }\r\n\r\n // Default Sort: Latest Created\r\n query.orderBy('rev.createdAt', 'DESC').skip(skip).take(limit);\r\n\r\n const [items, total] = await query.getManyAndCount();\r\n\r\n return {\r\n data: items,\r\n meta: {\r\n total,\r\n page,\r\n limit,\r\n totalPages: Math.ceil(total / limit),\r\n },\r\n };\r\n }\r\n\r\n async findOne(id: number) {\r\n const correspondence = await this.correspondenceRepo.findOne({\r\n where: { id },\r\n relations: [\r\n 'revisions',\r\n 'revisions.status',\r\n 'type',\r\n 'project',\r\n 'originator',\r\n 'recipients',\r\n 'recipients.recipientOrganization', // [v1.5.1] Fixed relation name\r\n ],\r\n });\r\n\r\n if (!correspondence) {\r\n throw new NotFoundException(`Correspondence with ID ${id} not found`);\r\n }\r\n return correspondence;\r\n }\r\n\r\n async findOneByUuid(publicId: string) {\r\n const correspondence = await this.correspondenceRepo.findOne({\r\n where: { publicId },\r\n relations: [\r\n 'revisions',\r\n 'revisions.status',\r\n 'type',\r\n 'project',\r\n 'originator',\r\n 'recipients',\r\n 'recipients.recipientOrganization',\r\n ],\r\n });\r\n\r\n if (!correspondence) {\r\n throw new NotFoundException(\r\n `Correspondence with UUID ${publicId} not found`\r\n );\r\n }\r\n return correspondence;\r\n }\r\n\r\n async addReference(id: number, dto: AddReferenceDto) {\r\n const source = await this.correspondenceRepo.findOne({ where: { id } });\r\n // ADR-019: Resolve target publicId → internal INT id\r\n const target = await this.correspondenceRepo.findOne({\r\n where: { publicId: dto.targetUuid },\r\n });\r\n\r\n if (!source || !target) {\r\n throw new NotFoundException('Source or Target correspondence not found');\r\n }\r\n\r\n if (source.id === target.id) {\r\n throw new BadRequestException('Cannot reference self');\r\n }\r\n\r\n const exists = await this.referenceRepo.findOne({\r\n where: {\r\n sourceId: id,\r\n targetId: target.id,\r\n },\r\n });\r\n\r\n if (exists) {\r\n return exists;\r\n }\r\n\r\n const ref = this.referenceRepo.create({\r\n sourceId: id,\r\n targetId: target.id,\r\n });\r\n\r\n return this.referenceRepo.save(ref);\r\n }\r\n\r\n async removeReference(id: number, targetId: number) {\r\n const result = await this.referenceRepo.delete({\r\n sourceId: id,\r\n targetId: targetId,\r\n });\r\n\r\n if (result.affected === 0) {\r\n throw new NotFoundException('Reference not found');\r\n }\r\n }\r\n\r\n async getTags(id: number) {\r\n const rows = await this.tagRepo.find({\r\n where: { correspondenceId: id },\r\n relations: ['tag'],\r\n });\r\n return rows.map((r) => r.tag).filter(Boolean);\r\n }\r\n\r\n async addTag(id: number, tagId: number) {\r\n const correspondence = await this.correspondenceRepo.findOne({\r\n where: { id },\r\n });\r\n if (!correspondence) {\r\n throw new NotFoundException(`Correspondence ${id} not found`);\r\n }\r\n\r\n const tag = await this.dataSource.manager.findOne(Tag, {\r\n where: { id: tagId },\r\n });\r\n if (!tag) {\r\n throw new NotFoundException(`Tag ${tagId} not found`);\r\n }\r\n\r\n const exists = await this.tagRepo.findOne({\r\n where: { correspondenceId: id, tagId },\r\n });\r\n if (exists) return exists;\r\n\r\n const row = this.tagRepo.create({ correspondenceId: id, tagId });\r\n return this.tagRepo.save(row);\r\n }\r\n\r\n async removeTag(id: number, tagId: number) {\r\n const result = await this.tagRepo.delete({ correspondenceId: id, tagId });\r\n if (result.affected === 0) {\r\n throw new NotFoundException('Tag assignment not found');\r\n }\r\n }\r\n\r\n async getReferences(id: number) {\r\n const outgoing = await this.referenceRepo.find({\r\n where: { sourceId: id },\r\n relations: ['target', 'target.type'],\r\n });\r\n\r\n const incoming = await this.referenceRepo.find({\r\n where: { targetId: id },\r\n relations: ['source', 'source.type'],\r\n });\r\n\r\n return { outgoing, incoming };\r\n }\r\n\r\n async update(id: number, updateDto: UpdateCorrespondenceDto, user: User) {\r\n // 1. Find Current Revision\r\n const revision = await this.revisionRepo.findOne({\r\n where: {\r\n correspondenceId: id,\r\n isCurrent: true,\r\n },\r\n relations: ['correspondence'],\r\n });\r\n\r\n if (!revision) {\r\n throw new NotFoundException(\r\n `Current revision for correspondence ${id} not found`\r\n );\r\n }\r\n\r\n // 2. Check Permission\r\n if (revision.statusId) {\r\n const status = await this.statusRepo.findOne({\r\n where: { id: revision.statusId },\r\n });\r\n if (status && status.statusCode !== 'DRAFT') {\r\n throw new BadRequestException('Only DRAFT documents can be updated');\r\n }\r\n }\r\n\r\n // ADR-019: Resolve UUID references in update DTO\r\n const updResolvedProjectId = updateDto.projectId\r\n ? await this.uuidResolver.resolveProjectId(updateDto.projectId)\r\n : undefined;\r\n const updResolvedOriginatorId = updateDto.originatorId\r\n ? await this.uuidResolver.resolveOrganizationId(updateDto.originatorId)\r\n : undefined;\r\n const updResolvedRecipients = updateDto.recipients\r\n ? await Promise.all(\r\n updateDto.recipients.map(\r\n async (r): Promise => ({\r\n organizationId: await this.uuidResolver.resolveOrganizationId(\r\n r.organizationId\r\n ),\r\n type: r.type,\r\n })\r\n )\r\n )\r\n : undefined;\r\n\r\n // 3. Update Correspondence Entity if needed\r\n const correspondenceUpdate: Record = {};\r\n if (updateDto.disciplineId)\r\n correspondenceUpdate.disciplineId = updateDto.disciplineId;\r\n if (updResolvedProjectId)\r\n correspondenceUpdate.projectId = updResolvedProjectId;\r\n if (updResolvedOriginatorId)\r\n correspondenceUpdate.originatorId = updResolvedOriginatorId;\r\n\r\n if (Object.keys(correspondenceUpdate).length > 0) {\r\n await this.correspondenceRepo.update(id, correspondenceUpdate);\r\n }\r\n\r\n // 4. Update Revision Entity\r\n const revisionUpdate: Record = {};\r\n if (updateDto.subject) revisionUpdate.subject = updateDto.subject;\r\n if (updateDto.body) revisionUpdate.body = updateDto.body;\r\n if (updateDto.remarks) revisionUpdate.remarks = updateDto.remarks;\r\n // Format Date correctly if string\r\n if (updateDto.dueDate) revisionUpdate.dueDate = new Date(updateDto.dueDate);\r\n if (updateDto.documentDate)\r\n revisionUpdate.documentDate = new Date(updateDto.documentDate);\r\n if (updateDto.issuedDate)\r\n revisionUpdate.issuedDate = new Date(updateDto.issuedDate);\r\n if (updateDto.receivedDate)\r\n revisionUpdate.receivedDate = new Date(updateDto.receivedDate);\r\n if (updateDto.description)\r\n revisionUpdate.description = updateDto.description;\r\n if (updateDto.details) revisionUpdate.details = updateDto.details;\r\n\r\n if (Object.keys(revisionUpdate).length > 0) {\r\n await this.revisionRepo.update(revision.id, revisionUpdate);\r\n }\r\n\r\n // 4.5 Commit new attachments from Temp → Permanent (Two-Phase Storage)\r\n if (updateDto.attachmentTempIds?.length) {\r\n const issueDate = updateDto.issuedDate\r\n ? new Date(updateDto.issuedDate)\r\n : updateDto.documentDate\r\n ? new Date(updateDto.documentDate)\r\n : revision.issuedDate || revision.documentDate || undefined;\r\n\r\n await this.fileStorageService.commit(updateDto.attachmentTempIds, {\r\n issueDate: issueDate ? new Date(issueDate) : undefined,\r\n documentType: 'Correspondence',\r\n });\r\n }\r\n\r\n // 5. Update Recipients if provided\r\n if (updResolvedRecipients) {\r\n const recipientRepo = this.dataSource.getRepository(\r\n CorrespondenceRecipient\r\n );\r\n await recipientRepo.delete({ correspondenceId: id });\r\n\r\n const newRecipients = updResolvedRecipients.map((r) =>\r\n recipientRepo.create({\r\n correspondenceId: id,\r\n recipientOrganizationId: r.organizationId,\r\n recipientType: r.type,\r\n })\r\n );\r\n await recipientRepo.save(newRecipients);\r\n }\r\n\r\n // 6. Regenerate Document Number if structural fields changed (Recipient, Discipline, Type, Project)\r\n // AND it is a DRAFT.\r\n\r\n // Fetch fresh data for context and comparison\r\n const currentCorr = await this.correspondenceRepo.findOne({\r\n where: { id },\r\n relations: ['type', 'recipients', 'recipients.recipientOrganization'],\r\n });\r\n\r\n if (currentCorr) {\r\n const currentToRecipient = currentCorr.recipients?.find(\r\n (r) => r.recipientType === 'TO'\r\n );\r\n const currentRecipientId = currentToRecipient?.recipientOrganizationId;\r\n\r\n // Check for ACTUAL value changes\r\n const isProjectChanged =\r\n updResolvedProjectId !== undefined &&\r\n updResolvedProjectId !== currentCorr.projectId;\r\n const isOriginatorChanged =\r\n updResolvedOriginatorId !== undefined &&\r\n updResolvedOriginatorId !== currentCorr.originatorId;\r\n const isDisciplineChanged =\r\n updateDto.disciplineId !== undefined &&\r\n updateDto.disciplineId !== currentCorr.disciplineId;\r\n const isTypeChanged =\r\n updateDto.typeId !== undefined &&\r\n updateDto.typeId !== currentCorr.correspondenceTypeId;\r\n\r\n let isRecipientChanged = false;\r\n let newRecipientId: number | undefined;\r\n\r\n if (updResolvedRecipients) {\r\n const newToRecipient = updResolvedRecipients.find(\r\n (r) => r.type === 'TO'\r\n );\r\n newRecipientId = newToRecipient?.organizationId;\r\n\r\n if (newRecipientId !== currentRecipientId) {\r\n isRecipientChanged = true;\r\n }\r\n }\r\n\r\n if (\r\n isProjectChanged ||\r\n isDisciplineChanged ||\r\n isTypeChanged ||\r\n isRecipientChanged ||\r\n isOriginatorChanged\r\n ) {\r\n const targetRecipientId = isRecipientChanged\r\n ? newRecipientId\r\n : currentRecipientId;\r\n\r\n // Resolve Recipient Code for the NEW context\r\n let recipientCode = '';\r\n if (targetRecipientId) {\r\n const recOrg = await this.dataSource.manager.findOne(Organization, {\r\n where: { id: targetRecipientId },\r\n });\r\n if (recOrg) recipientCode = recOrg.organizationCode;\r\n }\r\n\r\n // [Fix #6] Fetch real ORG Code from originator organization\r\n const originatorOrgForUpdate = await this.dataSource.manager.findOne(\r\n Organization,\r\n {\r\n where: {\r\n id: updResolvedOriginatorId ?? currentCorr.originatorId ?? 0,\r\n },\r\n }\r\n );\r\n const orgCode = originatorOrgForUpdate?.organizationCode ?? 'UNK';\r\n\r\n // Prepare Contexts\r\n const oldCtx = {\r\n projectId: currentCorr.projectId,\r\n originatorOrganizationId: currentCorr.originatorId ?? 0,\r\n typeId: currentCorr.correspondenceTypeId,\r\n disciplineId: currentCorr.disciplineId,\r\n recipientOrganizationId: currentRecipientId,\r\n year: new Date().getFullYear(),\r\n };\r\n\r\n const newCtx = {\r\n projectId: updResolvedProjectId ?? currentCorr.projectId,\r\n originatorOrganizationId:\r\n updResolvedOriginatorId ?? currentCorr.originatorId ?? 0,\r\n typeId: updateDto.typeId ?? currentCorr.correspondenceTypeId,\r\n disciplineId: updateDto.disciplineId ?? currentCorr.disciplineId,\r\n recipientOrganizationId: targetRecipientId,\r\n year: new Date().getFullYear(),\r\n userId: user.user_id, // Pass User ID for Audit\r\n customTokens: {\r\n TYPE_CODE: currentCorr.type?.typeCode || '',\r\n ORG_CODE: orgCode,\r\n RECIPIENT_CODE: recipientCode,\r\n REC_CODE: recipientCode,\r\n },\r\n };\r\n\r\n // If Type Changed, need NEW Type Code\r\n if (isTypeChanged) {\r\n const newType = await this.typeRepo.findOne({\r\n where: { id: newCtx.typeId },\r\n });\r\n if (newType) newCtx.customTokens.TYPE_CODE = newType.typeCode;\r\n }\r\n\r\n const newDocNumber = await this.numberingService.updateNumberForDraft(\r\n currentCorr.correspondenceNumber,\r\n oldCtx,\r\n newCtx\r\n );\r\n\r\n await this.correspondenceRepo.update(id, {\r\n correspondenceNumber: newDocNumber,\r\n });\r\n }\r\n }\r\n\r\n const updated = await this.findOne(id);\r\n\r\n // Re-index updated document in Elasticsearch (fire-and-forget)\r\n void this.searchService.indexDocument({\r\n id: updated.id,\r\n publicId: updated.publicId,\r\n type: 'correspondence',\r\n docNumber: updated.correspondenceNumber,\r\n title: updateDto.subject ?? updated.revisions?.[0]?.subject,\r\n description: updateDto.description ?? updated.revisions?.[0]?.description,\r\n status: 'DRAFT',\r\n projectId: updated.projectId,\r\n createdAt: updated.createdAt,\r\n });\r\n\r\n return updated;\r\n }\r\n\r\n async previewDocumentNumber(createDto: CreateCorrespondenceDto, user: User) {\r\n // ADR-019: Resolve UUID references\r\n const previewProjectId = await this.uuidResolver.resolveProjectId(\r\n createDto.projectId\r\n );\r\n const previewOriginatorId = createDto.originatorId\r\n ? await this.uuidResolver.resolveOrganizationId(createDto.originatorId)\r\n : undefined;\r\n const previewRecipients = createDto.recipients\r\n ? await Promise.all(\r\n createDto.recipients.map(\r\n async (r): Promise => ({\r\n organizationId: await this.uuidResolver.resolveOrganizationId(\r\n r.organizationId\r\n ),\r\n type: r.type,\r\n })\r\n )\r\n )\r\n : undefined;\r\n\r\n const type = await this.typeRepo.findOne({\r\n where: { id: createDto.typeId },\r\n });\r\n if (!type) throw new NotFoundException('Document Type not found');\r\n\r\n let userOrgId = user.primaryOrganizationId;\r\n if (!userOrgId) {\r\n const fullUser = await this.userService.findOne(user.user_id);\r\n if (fullUser) userOrgId = fullUser.primaryOrganizationId;\r\n }\r\n\r\n if (previewOriginatorId && previewOriginatorId !== userOrgId) {\r\n // Allow impersonation for preview\r\n userOrgId = previewOriginatorId;\r\n }\r\n\r\n // Extract recipient from recipients array\r\n const toRecipient = previewRecipients?.find((r) => r.type === 'TO');\r\n const recipientOrganizationId = toRecipient?.organizationId;\r\n\r\n let recipientCode = '';\r\n if (recipientOrganizationId) {\r\n const recOrg = await this.dataSource.manager.findOne(Organization, {\r\n where: { id: recipientOrganizationId },\r\n });\r\n if (recOrg) recipientCode = recOrg.organizationCode;\r\n }\r\n\r\n return this.numberingService.previewNumber({\r\n projectId: previewProjectId,\r\n originatorOrganizationId: userOrgId!,\r\n typeId: createDto.typeId,\r\n disciplineId: createDto.disciplineId,\r\n subTypeId: createDto.subTypeId,\r\n recipientOrganizationId,\r\n year: new Date().getFullYear(),\r\n customTokens: {\r\n TYPE_CODE: type.typeCode,\r\n RECIPIENT_CODE: recipientCode,\r\n REC_CODE: recipientCode,\r\n },\r\n });\r\n }\r\n\r\n /**\r\n * Business Rule Implementation: EC-CORR-001 - Cancel Correspondence with Downstream Circulation\r\n * Cancel correspondence and handle related circulations\r\n */\r\n async cancel(publicId: string, reason: string, user: User) {\r\n const correspondence = await this.findOneByUuid(publicId);\r\n\r\n // Check if user has permission to cancel (Org Admin or Superadmin only)\r\n const permissions = await this.userService.getUserPermissions(user.user_id);\r\n const canCancel =\r\n permissions.includes('correspondence.cancel') ||\r\n permissions.includes('system.manage_all');\r\n\r\n if (!canCancel) {\r\n throw new ForbiddenException(\r\n 'Only administrators can cancel correspondences'\r\n );\r\n }\r\n\r\n // Check if there are any active circulations\r\n const circulationRepo = this.dataSource.getRepository('Circulation');\r\n const activeCirculations = await circulationRepo.find({\r\n where: {\r\n correspondenceId: correspondence.id,\r\n status: 'OPEN',\r\n },\r\n });\r\n\r\n const warningMessage =\r\n activeCirculations.length > 0\r\n ? `There are ${activeCirculations.length} active circulation(s) for this correspondence. Canceling will force close all related circulations.`\r\n : '';\r\n\r\n // Get the current revision to update status\r\n const currentRevision = await this.revisionRepo.findOne({\r\n where: {\r\n correspondenceId: correspondence.id,\r\n isCurrent: true,\r\n },\r\n });\r\n\r\n if (!currentRevision) {\r\n throw new NotFoundException('Current revision not found');\r\n }\r\n\r\n // Get cancelled status\r\n const cancelledStatus = await this.statusRepo.findOne({\r\n where: { statusCode: 'CANCELLED' },\r\n });\r\n\r\n if (!cancelledStatus) {\r\n throw new InternalServerErrorException('CANCELLED status not found');\r\n }\r\n\r\n const queryRunner = this.dataSource.createQueryRunner();\r\n await queryRunner.connect();\r\n await queryRunner.startTransaction();\r\n\r\n try {\r\n // Update correspondence revision status to CANCELLED\r\n await queryRunner.manager.update(\r\n CorrespondenceRevision,\r\n currentRevision.id,\r\n {\r\n statusId: cancelledStatus.id,\r\n remarks: `Cancelled: ${reason}`,\r\n }\r\n );\r\n\r\n // Force close all active circulations\r\n if (activeCirculations.length > 0) {\r\n await queryRunner.manager.update(\r\n 'Circulation',\r\n {\r\n correspondenceId: correspondence.id,\r\n status: 'OPEN',\r\n },\r\n {\r\n status: 'FORCE_CLOSED',\r\n closedAt: new Date(),\r\n closedBy: user.user_id,\r\n closeReason: `Correspondence cancelled: ${reason}`,\r\n }\r\n );\r\n }\r\n\r\n await queryRunner.commitTransaction();\r\n\r\n // Re-index cancelled status in Elasticsearch (fire-and-forget)\r\n void this.searchService.indexDocument({\r\n id: correspondence.id,\r\n publicId: correspondence.publicId,\r\n type: 'correspondence',\r\n docNumber: correspondence.correspondenceNumber,\r\n title: currentRevision.subject,\r\n status: 'CANCELLED',\r\n projectId: correspondence.projectId,\r\n createdAt: correspondence.createdAt,\r\n });\r\n\r\n // Notify originator's doc-control user about cancellation (fire-and-forget)\r\n if (correspondence.originatorId) {\r\n void this.userService\r\n .findDocControlIdByOrg(correspondence.originatorId)\r\n .then((targetUserId) => {\r\n if (targetUserId) {\r\n void this.notificationService.send({\r\n userId: targetUserId,\r\n title: 'Correspondence Cancelled',\r\n message: `${correspondence.correspondenceNumber} — ${currentRevision.subject} has been cancelled. Reason: ${reason}`,\r\n type: 'EMAIL',\r\n entityType: 'correspondence',\r\n entityId: correspondence.id,\r\n link: `/correspondences/${correspondence.publicId}`,\r\n });\r\n }\r\n })\r\n .catch((err: Error) =>\r\n this.logger.warn(`Cancel notification failed: ${err.message}`)\r\n );\r\n }\r\n\r\n return {\r\n success: true,\r\n message: warningMessage || 'Correspondence cancelled successfully',\r\n activeCirculationsCount: activeCirculations.length,\r\n };\r\n } catch (error) {\r\n await queryRunner.rollbackTransaction();\r\n this.logger.error(\r\n `Failed to cancel correspondence: ${(error as Error).message}`\r\n );\r\n throw error;\r\n } finally {\r\n await queryRunner.release();\r\n }\r\n }\r\n\r\n async bulkCancel(\r\n publicIds: string[],\r\n reason: string,\r\n user: User\r\n ): Promise<{ succeeded: string[]; failed: string[] }> {\r\n const succeeded: string[] = [];\r\n const failed: string[] = [];\r\n\r\n for (const publicId of publicIds) {\r\n try {\r\n await this.cancel(publicId, reason, user);\r\n succeeded.push(publicId);\r\n } catch {\r\n failed.push(publicId);\r\n }\r\n }\r\n\r\n return { succeeded, failed };\r\n }\r\n\r\n async exportCsv(searchDto: SearchCorrespondenceDto): Promise {\r\n const { data } = await this.findAll(searchDto);\r\n\r\n const header = [\r\n 'Document No.',\r\n 'Rev',\r\n 'Subject',\r\n 'Type',\r\n 'Status',\r\n 'Project',\r\n 'From',\r\n 'Due Date',\r\n 'Created At',\r\n ];\r\n const rows = data.map((rev) => {\r\n const corr = rev.correspondence ?? (rev as unknown as Correspondence);\r\n return [\r\n this.escapeCsv(corr.correspondenceNumber ?? ''),\r\n this.escapeCsv(rev.revisionLabel ?? String(rev.revisionNumber ?? 0)),\r\n this.escapeCsv(rev.subject ?? ''),\r\n this.escapeCsv(corr.type?.typeCode ?? ''),\r\n this.escapeCsv(rev.status?.statusCode ?? ''),\r\n this.escapeCsv(corr.project?.projectCode ?? ''),\r\n this.escapeCsv(corr.originator?.organizationCode ?? ''),\r\n rev.dueDate ? new Date(rev.dueDate).toISOString().split('T')[0] : '',\r\n new Date(rev.createdAt).toISOString().split('T')[0],\r\n ].join(',');\r\n });\r\n\r\n return [header.join(','), ...rows].join('\\n');\r\n }\r\n\r\n private escapeCsv(value: string): string {\r\n if (value.includes(',') || value.includes('\"') || value.includes('\\n')) {\r\n return `\"${value.replace(/\"/g, '\"\"')}\"`;\r\n }\r\n return value;\r\n }\r\n}\r\n"],"version":3} \ No newline at end of file diff --git a/backend/src/.jest-cache/jest-transform-cache-60cab15b743c6776f41d29bcac696b99-12533232bd0f05f65688e7a7764bf3fb/55/correspondenceservice_5585ce2f5626b5a93fd64e63909b087f b/backend/src/.jest-cache/jest-transform-cache-60cab15b743c6776f41d29bcac696b99-12533232bd0f05f65688e7a7764bf3fb/55/correspondenceservice_5585ce2f5626b5a93fd64e63909b087f new file mode 100644 index 0000000..333767e --- /dev/null +++ b/backend/src/.jest-cache/jest-transform-cache-60cab15b743c6776f41d29bcac696b99-12533232bd0f05f65688e7a7764bf3fb/55/correspondenceservice_5585ce2f5626b5a93fd64e63909b087f @@ -0,0 +1,893 @@ +f958e3e0fd6fd813cf9552bbff491967 +"use strict"; +// File: src/modules/correspondence/correspondence.service.ts +var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; +}; +var __metadata = (this && this.__metadata) || function (k, v) { + if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v); +}; +var __param = (this && this.__param) || function (paramIndex, decorator) { + return function (target, key) { decorator(target, key, paramIndex); } +}; +var CorrespondenceService_1; +var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.CorrespondenceService = void 0; +const common_1 = require("@nestjs/common"); +const typeorm_1 = require("@nestjs/typeorm"); +const typeorm_2 = require("typeorm"); +// Entities +const correspondence_entity_1 = require("./entities/correspondence.entity"); +const correspondence_revision_entity_1 = require("./entities/correspondence-revision.entity"); +const correspondence_type_entity_1 = require("./entities/correspondence-type.entity"); +const correspondence_status_entity_1 = require("./entities/correspondence-status.entity"); +const correspondence_reference_entity_1 = require("./entities/correspondence-reference.entity"); +const correspondence_recipient_entity_1 = require("./entities/correspondence-recipient.entity"); +const correspondence_tag_entity_1 = require("./entities/correspondence-tag.entity"); +const tag_entity_1 = require("../master/entities/tag.entity"); +const organization_entity_1 = require("../organization/entities/organization.entity"); +// Services +const document_numbering_service_1 = require("../document-numbering/services/document-numbering.service"); +const json_schema_service_1 = require("../json-schema/json-schema.service"); +const workflow_engine_service_1 = require("../workflow-engine/workflow-engine.service"); +const user_service_1 = require("../user/user.service"); +const search_service_1 = require("../search/search.service"); +const file_storage_service_1 = require("../../common/file-storage/file-storage.service"); +const uuid_resolver_service_1 = require("../../common/services/uuid-resolver.service"); +const notification_service_1 = require("../notification/notification.service"); +let CorrespondenceService = CorrespondenceService_1 = class CorrespondenceService { + async hasSystemManageAllPermission(userId) { + const permissions = await this.userService.getUserPermissions(userId); + return permissions.includes('system.manage_all'); + } + /** + * Business Rule: Revision Label Strategy + * - RFA, RFI: Use alphabet starting with 'A' (A, B, C...) + * - Other types (LETTER, MEMO, etc.): Use numeric (null for first, then 1, 2, 3...) + */ + getInitialRevisionLabel(typeCode) { + const alphabetTypes = ['RFA', 'RFI']; + if (alphabetTypes.includes(typeCode.toUpperCase())) { + return 'A'; // Alphabet for RFA, RFI + } + return null; // Numeric (null for revision 0) + } + constructor(correspondenceRepo, revisionRepo, typeRepo, statusRepo, referenceRepo, tagRepo, numberingService, jsonSchemaService, workflowEngine, userService, dataSource, searchService, fileStorageService, uuidResolver, notificationService) { + this.correspondenceRepo = correspondenceRepo; + this.revisionRepo = revisionRepo; + this.typeRepo = typeRepo; + this.statusRepo = statusRepo; + this.referenceRepo = referenceRepo; + this.tagRepo = tagRepo; + this.numberingService = numberingService; + this.jsonSchemaService = jsonSchemaService; + this.workflowEngine = workflowEngine; + this.userService = userService; + this.dataSource = dataSource; + this.searchService = searchService; + this.fileStorageService = fileStorageService; + this.uuidResolver = uuidResolver; + this.notificationService = notificationService; + this.logger = new common_1.Logger(CorrespondenceService_1.name); + } + /** + * Business Rule Validation: EC-CORR-003 - Correspondence to Self + * Prevent external correspondence to same organization + */ + async validateCorrespondenceRecipients(createDto, user) { + // Get user's organization + let userOrgId = user.primaryOrganizationId; + if (!userOrgId) { + const fullUser = await this.userService.findOne(user.user_id); + if (fullUser) { + userOrgId = fullUser.primaryOrganizationId; + } + } + if (!userOrgId) { + if (createDto.originatorId) { + const canManageAll = await this.hasSystemManageAllPermission(user.user_id); + if (canManageAll) { + userOrgId = await this.uuidResolver.resolveOrganizationId(createDto.originatorId); + } + } + if (!userOrgId) { + throw new common_1.BadRequestException('User must belong to an organization to create documents'); + } + } + // For impersonation, use the specified originator + const originatorOrgId = createDto.originatorId + ? await this.uuidResolver.resolveOrganizationId(createDto.originatorId) + : userOrgId; + // Check if it's internal communication + if (createDto.isInternal) { + // Internal communications should use Circulation instead + throw new common_1.BadRequestException('Internal communications should use Circulation Sheet instead of Correspondence'); + } + // Validate recipients + if (!createDto.recipients || createDto.recipients.length === 0) { + throw new common_1.BadRequestException('At least one recipient (TO or CC) is required'); + } + const toRecipients = createDto.recipients.filter((r) => r.type === 'TO'); + const ccRecipients = createDto.recipients.filter((r) => r.type === 'CC'); + if (toRecipients.length === 0 && ccRecipients.length === 0) { + throw new common_1.BadRequestException('At least one TO or CC recipient is required'); + } + // Check for same organization correspondence + for (const recipient of createDto.recipients) { + const recipientOrgId = await this.uuidResolver.resolveOrganizationId(recipient.organizationId); + if (recipientOrgId === originatorOrgId) { + throw new common_1.BadRequestException('Cannot send correspondence to your own organization. Use Circulation Sheet for internal communication.'); + } + } + } + async create(createDto, user) { + // Business Rule Validation: EC-CORR-003 - Correspondence to Self + await this.validateCorrespondenceRecipients(createDto, user); + // ADR-019: Resolve UUID references to internal INT IDs + const resolvedProjectId = await this.uuidResolver.resolveProjectId(createDto.projectId); + const resolvedOriginatorId = createDto.originatorId + ? await this.uuidResolver.resolveOrganizationId(createDto.originatorId) + : undefined; + const resolvedRecipients = createDto.recipients + ? await Promise.all(createDto.recipients.map(async (r) => ({ + organizationId: await this.uuidResolver.resolveOrganizationId(r.organizationId), + type: r.type, + }))) + : undefined; + const type = await this.typeRepo.findOne({ + where: { id: createDto.typeId }, + }); + if (!type) + throw new common_1.NotFoundException('Document Type not found'); + const statusDraft = await this.statusRepo.findOne({ + where: { statusCode: 'DRAFT' }, + }); + if (!statusDraft) { + throw new common_1.InternalServerErrorException('Status DRAFT not found in Master Data'); + } + let userOrgId = user.primaryOrganizationId; + if (!userOrgId) { + const fullUser = await this.userService.findOne(user.user_id); + if (fullUser) { + userOrgId = fullUser.primaryOrganizationId; + } + } + // Impersonation Logic + if (resolvedOriginatorId && resolvedOriginatorId !== userOrgId) { + const canManageAll = await this.hasSystemManageAllPermission(user.user_id); + if (!canManageAll) { + throw new common_1.ForbiddenException('You do not have permission to create documents on behalf of other organizations.'); + } + userOrgId = resolvedOriginatorId; + } + if (!userOrgId) { + throw new common_1.BadRequestException('User must belong to an organization to create documents'); + } + if (createDto.details) { + try { + await this.jsonSchemaService.validate(type.typeCode, createDto.details); + } + catch (error) { + this.logger.warn(`Schema validation warning for ${type.typeCode}: ${error.message}`); + } + } + const queryRunner = this.dataSource.createQueryRunner(); + await queryRunner.connect(); + await queryRunner.startTransaction(); + try { + // [Fix #6] Fetch real ORG Code from Organization entity + const originatorOrg = await this.dataSource.manager.findOne(organization_entity_1.Organization, { + where: { id: userOrgId }, + }); + const orgCode = originatorOrg?.organizationCode ?? 'UNK'; + // [v1.5.1] Extract recipient organization from recipients array (Primary TO) + const toRecipient = resolvedRecipients?.find((r) => r.type === 'TO'); + const recipientOrganizationId = toRecipient?.organizationId; + let recipientCode = ''; + if (recipientOrganizationId) { + const recOrg = await this.dataSource.manager.findOne(organization_entity_1.Organization, { + where: { id: recipientOrganizationId }, + }); + if (recOrg) + recipientCode = recOrg.organizationCode; + } + const docNumber = await this.numberingService.generateNextNumber({ + projectId: resolvedProjectId, + originatorOrganizationId: userOrgId, + typeId: createDto.typeId, + disciplineId: createDto.disciplineId, + subTypeId: createDto.subTypeId, + recipientOrganizationId, // [v1.5.1] Pass recipient for document number format + year: new Date().getFullYear(), + customTokens: { + TYPE_CODE: type.typeCode, + ORG_CODE: orgCode, + RECIPIENT_CODE: recipientCode, + REC_CODE: recipientCode, + }, + }); + const correspondence = queryRunner.manager.create(correspondence_entity_1.Correspondence, { + correspondenceNumber: docNumber.number, + correspondenceTypeId: createDto.typeId, + disciplineId: createDto.disciplineId, + projectId: resolvedProjectId, + originatorId: userOrgId, + isInternal: createDto.isInternal || false, + createdBy: user.user_id, + }); + const savedCorr = await queryRunner.manager.save(correspondence); + const revision = queryRunner.manager.create(correspondence_revision_entity_1.CorrespondenceRevision, { + correspondenceId: savedCorr.id, + revisionNumber: 0, + revisionLabel: this.getInitialRevisionLabel(type.typeCode), + isCurrent: true, + statusId: statusDraft.id, + subject: createDto.subject, + body: createDto.body, + remarks: createDto.remarks, + dueDate: createDto.dueDate ? new Date(createDto.dueDate) : undefined, + documentDate: createDto.documentDate + ? new Date(createDto.documentDate) + : undefined, + issuedDate: createDto.issuedDate + ? new Date(createDto.issuedDate) + : undefined, + receivedDate: createDto.receivedDate + ? new Date(createDto.receivedDate) + : undefined, + description: createDto.description, + details: createDto.details, + createdBy: user.user_id, + schemaVersion: 1, + }); + await queryRunner.manager.save(revision); + // Save Recipients (using resolved INT IDs) + if (resolvedRecipients && resolvedRecipients.length > 0) { + const recipients = resolvedRecipients.map((r) => queryRunner.manager.create(correspondence_recipient_entity_1.CorrespondenceRecipient, { + correspondenceId: savedCorr.id, + recipientOrganizationId: r.organizationId, + recipientType: r.type, + })); + await queryRunner.manager.save(recipients); + } + // Commit attachments from Temp → Permanent (Two-Phase Storage) + if (createDto.attachmentTempIds?.length) { + const issueDate = createDto.issuedDate + ? new Date(createDto.issuedDate) + : createDto.documentDate + ? new Date(createDto.documentDate) + : undefined; + await this.fileStorageService.commit(createDto.attachmentTempIds, { + issueDate, + documentType: 'Correspondence', + }); + } + await queryRunner.commitTransaction(); + // Start Workflow Instance (non-blocking) + try { + const workflowCode = `CORRESPONDENCE_${type.typeCode}`; + await this.workflowEngine.createInstance(workflowCode, 'correspondence', savedCorr.id.toString(), { + projectId: resolvedProjectId, + originatorId: userOrgId, + disciplineId: createDto.disciplineId, + initiatorId: user.user_id, + }); + } + catch (error) { + this.logger.warn(`Workflow not started for ${docNumber.number} (Code: CORRESPONDENCE_${type.typeCode}): ${error.message}`); + } + // Fire-and-forget search indexing (non-blocking, void intentional) + void this.searchService.indexDocument({ + id: savedCorr.id, + publicId: savedCorr.publicId, + type: 'correspondence', + docNumber: docNumber.number, + title: createDto.subject, + description: createDto.description, + status: 'DRAFT', + projectId: resolvedProjectId, + createdAt: new Date(), + }); + return { + ...savedCorr, + currentRevision: revision, + }; + } + catch (err) { + await queryRunner.rollbackTransaction(); + this.logger.error(`Failed to create correspondence: ${err.message}`); + throw err; + } + finally { + await queryRunner.release(); + } + } + async findAll(searchDto = {}) { + const { search, typeId, projectId, statusId, status, page = 1, limit = 10, } = searchDto; + const skip = (page - 1) * limit; + // Change: Query from Revision Repo + const query = this.revisionRepo + .createQueryBuilder('rev') + .leftJoinAndSelect('rev.correspondence', 'corr') + .leftJoinAndSelect('corr.type', 'type') + .leftJoinAndSelect('corr.project', 'project') + .leftJoinAndSelect('corr.originator', 'org') + .leftJoinAndSelect('rev.status', 'status'); + // Filter by Revision Status + const revStatus = searchDto.revisionStatus || 'CURRENT'; + if (revStatus === 'CURRENT') { + query.where('rev.isCurrent = :isCurrent', { isCurrent: true }); + } + else if (revStatus === 'OLD') { + query.where('rev.isCurrent = :isCurrent', { isCurrent: false }); + } + // If 'ALL', no filter needed on isCurrent + if (projectId) { + query.andWhere('corr.projectId = :projectId', { projectId }); + } + if (typeId) { + query.andWhere('corr.correspondenceTypeId = :typeId', { typeId }); + } + if (statusId) { + query.andWhere('rev.statusId = :statusId', { statusId }); + } + if (status) { + query.andWhere('status.statusCode = :status', { status }); + } + if (search) { + query.andWhere('(corr.correspondenceNumber LIKE :search OR rev.subject LIKE :search)', { search: `%${search}%` }); + } + // Default Sort: Latest Created + query.orderBy('rev.createdAt', 'DESC').skip(skip).take(limit); + const [items, total] = await query.getManyAndCount(); + return { + data: items, + meta: { + total, + page, + limit, + totalPages: Math.ceil(total / limit), + }, + }; + } + async findOne(id) { + const correspondence = await this.correspondenceRepo.findOne({ + where: { id }, + relations: [ + 'revisions', + 'revisions.status', + 'type', + 'project', + 'originator', + 'recipients', + 'recipients.recipientOrganization', // [v1.5.1] Fixed relation name + ], + }); + if (!correspondence) { + throw new common_1.NotFoundException(`Correspondence with ID ${id} not found`); + } + return correspondence; + } + async findOneByUuid(publicId) { + const correspondence = await this.correspondenceRepo.findOne({ + where: { publicId }, + relations: [ + 'revisions', + 'revisions.status', + 'type', + 'project', + 'originator', + 'recipients', + 'recipients.recipientOrganization', + ], + }); + if (!correspondence) { + throw new common_1.NotFoundException(`Correspondence with UUID ${publicId} not found`); + } + return correspondence; + } + async addReference(id, dto) { + const source = await this.correspondenceRepo.findOne({ where: { id } }); + // ADR-019: Resolve target publicId → internal INT id + const target = await this.correspondenceRepo.findOne({ + where: { publicId: dto.targetUuid }, + }); + if (!source || !target) { + throw new common_1.NotFoundException('Source or Target correspondence not found'); + } + if (source.id === target.id) { + throw new common_1.BadRequestException('Cannot reference self'); + } + const exists = await this.referenceRepo.findOne({ + where: { + sourceId: id, + targetId: target.id, + }, + }); + if (exists) { + return exists; + } + const ref = this.referenceRepo.create({ + sourceId: id, + targetId: target.id, + }); + return this.referenceRepo.save(ref); + } + async removeReference(id, targetId) { + const result = await this.referenceRepo.delete({ + sourceId: id, + targetId: targetId, + }); + if (result.affected === 0) { + throw new common_1.NotFoundException('Reference not found'); + } + } + async getTags(id) { + const rows = await this.tagRepo.find({ + where: { correspondenceId: id }, + relations: ['tag'], + }); + return rows.map((r) => r.tag).filter(Boolean); + } + async addTag(id, tagId) { + const correspondence = await this.correspondenceRepo.findOne({ + where: { id }, + }); + if (!correspondence) { + throw new common_1.NotFoundException(`Correspondence ${id} not found`); + } + const tag = await this.dataSource.manager.findOne(tag_entity_1.Tag, { + where: { id: tagId }, + }); + if (!tag) { + throw new common_1.NotFoundException(`Tag ${tagId} not found`); + } + const exists = await this.tagRepo.findOne({ + where: { correspondenceId: id, tagId }, + }); + if (exists) + return exists; + const row = this.tagRepo.create({ correspondenceId: id, tagId }); + return this.tagRepo.save(row); + } + async removeTag(id, tagId) { + const result = await this.tagRepo.delete({ correspondenceId: id, tagId }); + if (result.affected === 0) { + throw new common_1.NotFoundException('Tag assignment not found'); + } + } + async getReferences(id) { + const outgoing = await this.referenceRepo.find({ + where: { sourceId: id }, + relations: ['target', 'target.type'], + }); + const incoming = await this.referenceRepo.find({ + where: { targetId: id }, + relations: ['source', 'source.type'], + }); + return { outgoing, incoming }; + } + async update(id, updateDto, user) { + // 1. Find Current Revision + const revision = await this.revisionRepo.findOne({ + where: { + correspondenceId: id, + isCurrent: true, + }, + relations: ['correspondence'], + }); + if (!revision) { + throw new common_1.NotFoundException(`Current revision for correspondence ${id} not found`); + } + // 2. Check Permission + if (revision.statusId) { + const status = await this.statusRepo.findOne({ + where: { id: revision.statusId }, + }); + if (status && status.statusCode !== 'DRAFT') { + throw new common_1.BadRequestException('Only DRAFT documents can be updated'); + } + } + // ADR-019: Resolve UUID references in update DTO + const updResolvedProjectId = updateDto.projectId + ? await this.uuidResolver.resolveProjectId(updateDto.projectId) + : undefined; + const updResolvedOriginatorId = updateDto.originatorId + ? await this.uuidResolver.resolveOrganizationId(updateDto.originatorId) + : undefined; + const updResolvedRecipients = updateDto.recipients + ? await Promise.all(updateDto.recipients.map(async (r) => ({ + organizationId: await this.uuidResolver.resolveOrganizationId(r.organizationId), + type: r.type, + }))) + : undefined; + // 3. Update Correspondence Entity if needed + const correspondenceUpdate = {}; + if (updateDto.disciplineId) + correspondenceUpdate.disciplineId = updateDto.disciplineId; + if (updResolvedProjectId) + correspondenceUpdate.projectId = updResolvedProjectId; + if (updResolvedOriginatorId) + correspondenceUpdate.originatorId = updResolvedOriginatorId; + if (Object.keys(correspondenceUpdate).length > 0) { + await this.correspondenceRepo.update(id, correspondenceUpdate); + } + // 4. Update Revision Entity + const revisionUpdate = {}; + if (updateDto.subject) + revisionUpdate.subject = updateDto.subject; + if (updateDto.body) + revisionUpdate.body = updateDto.body; + if (updateDto.remarks) + revisionUpdate.remarks = updateDto.remarks; + // Format Date correctly if string + if (updateDto.dueDate) + revisionUpdate.dueDate = new Date(updateDto.dueDate); + if (updateDto.documentDate) + revisionUpdate.documentDate = new Date(updateDto.documentDate); + if (updateDto.issuedDate) + revisionUpdate.issuedDate = new Date(updateDto.issuedDate); + if (updateDto.receivedDate) + revisionUpdate.receivedDate = new Date(updateDto.receivedDate); + if (updateDto.description) + revisionUpdate.description = updateDto.description; + if (updateDto.details) + revisionUpdate.details = updateDto.details; + if (Object.keys(revisionUpdate).length > 0) { + await this.revisionRepo.update(revision.id, revisionUpdate); + } + // 4.5 Commit new attachments from Temp → Permanent (Two-Phase Storage) + if (updateDto.attachmentTempIds?.length) { + const issueDate = updateDto.issuedDate + ? new Date(updateDto.issuedDate) + : updateDto.documentDate + ? new Date(updateDto.documentDate) + : revision.issuedDate || revision.documentDate || undefined; + await this.fileStorageService.commit(updateDto.attachmentTempIds, { + issueDate: issueDate ? new Date(issueDate) : undefined, + documentType: 'Correspondence', + }); + } + // 5. Update Recipients if provided + if (updResolvedRecipients) { + const recipientRepo = this.dataSource.getRepository(correspondence_recipient_entity_1.CorrespondenceRecipient); + await recipientRepo.delete({ correspondenceId: id }); + const newRecipients = updResolvedRecipients.map((r) => recipientRepo.create({ + correspondenceId: id, + recipientOrganizationId: r.organizationId, + recipientType: r.type, + })); + await recipientRepo.save(newRecipients); + } + // 6. Regenerate Document Number if structural fields changed (Recipient, Discipline, Type, Project) + // AND it is a DRAFT. + // Fetch fresh data for context and comparison + const currentCorr = await this.correspondenceRepo.findOne({ + where: { id }, + relations: ['type', 'recipients', 'recipients.recipientOrganization'], + }); + if (currentCorr) { + const currentToRecipient = currentCorr.recipients?.find((r) => r.recipientType === 'TO'); + const currentRecipientId = currentToRecipient?.recipientOrganizationId; + // Check for ACTUAL value changes + const isProjectChanged = updResolvedProjectId !== undefined && + updResolvedProjectId !== currentCorr.projectId; + const isOriginatorChanged = updResolvedOriginatorId !== undefined && + updResolvedOriginatorId !== currentCorr.originatorId; + const isDisciplineChanged = updateDto.disciplineId !== undefined && + updateDto.disciplineId !== currentCorr.disciplineId; + const isTypeChanged = updateDto.typeId !== undefined && + updateDto.typeId !== currentCorr.correspondenceTypeId; + let isRecipientChanged = false; + let newRecipientId; + if (updResolvedRecipients) { + const newToRecipient = updResolvedRecipients.find((r) => r.type === 'TO'); + newRecipientId = newToRecipient?.organizationId; + if (newRecipientId !== currentRecipientId) { + isRecipientChanged = true; + } + } + if (isProjectChanged || + isDisciplineChanged || + isTypeChanged || + isRecipientChanged || + isOriginatorChanged) { + const targetRecipientId = isRecipientChanged + ? newRecipientId + : currentRecipientId; + // Resolve Recipient Code for the NEW context + let recipientCode = ''; + if (targetRecipientId) { + const recOrg = await this.dataSource.manager.findOne(organization_entity_1.Organization, { + where: { id: targetRecipientId }, + }); + if (recOrg) + recipientCode = recOrg.organizationCode; + } + // [Fix #6] Fetch real ORG Code from originator organization + const originatorOrgForUpdate = await this.dataSource.manager.findOne(organization_entity_1.Organization, { + where: { + id: updResolvedOriginatorId ?? currentCorr.originatorId ?? 0, + }, + }); + const orgCode = originatorOrgForUpdate?.organizationCode ?? 'UNK'; + // Prepare Contexts + const oldCtx = { + projectId: currentCorr.projectId, + originatorOrganizationId: currentCorr.originatorId ?? 0, + typeId: currentCorr.correspondenceTypeId, + disciplineId: currentCorr.disciplineId, + recipientOrganizationId: currentRecipientId, + year: new Date().getFullYear(), + }; + const newCtx = { + projectId: updResolvedProjectId ?? currentCorr.projectId, + originatorOrganizationId: updResolvedOriginatorId ?? currentCorr.originatorId ?? 0, + typeId: updateDto.typeId ?? currentCorr.correspondenceTypeId, + disciplineId: updateDto.disciplineId ?? currentCorr.disciplineId, + recipientOrganizationId: targetRecipientId, + year: new Date().getFullYear(), + userId: user.user_id, // Pass User ID for Audit + customTokens: { + TYPE_CODE: currentCorr.type?.typeCode || '', + ORG_CODE: orgCode, + RECIPIENT_CODE: recipientCode, + REC_CODE: recipientCode, + }, + }; + // If Type Changed, need NEW Type Code + if (isTypeChanged) { + const newType = await this.typeRepo.findOne({ + where: { id: newCtx.typeId }, + }); + if (newType) + newCtx.customTokens.TYPE_CODE = newType.typeCode; + } + const newDocNumber = await this.numberingService.updateNumberForDraft(currentCorr.correspondenceNumber, oldCtx, newCtx); + await this.correspondenceRepo.update(id, { + correspondenceNumber: newDocNumber, + }); + } + } + const updated = await this.findOne(id); + // Re-index updated document in Elasticsearch (fire-and-forget) + void this.searchService.indexDocument({ + id: updated.id, + publicId: updated.publicId, + type: 'correspondence', + docNumber: updated.correspondenceNumber, + title: updateDto.subject ?? updated.revisions?.[0]?.subject, + description: updateDto.description ?? updated.revisions?.[0]?.description, + status: 'DRAFT', + projectId: updated.projectId, + createdAt: updated.createdAt, + }); + return updated; + } + async previewDocumentNumber(createDto, user) { + // ADR-019: Resolve UUID references + const previewProjectId = await this.uuidResolver.resolveProjectId(createDto.projectId); + const previewOriginatorId = createDto.originatorId + ? await this.uuidResolver.resolveOrganizationId(createDto.originatorId) + : undefined; + const previewRecipients = createDto.recipients + ? await Promise.all(createDto.recipients.map(async (r) => ({ + organizationId: await this.uuidResolver.resolveOrganizationId(r.organizationId), + type: r.type, + }))) + : undefined; + const type = await this.typeRepo.findOne({ + where: { id: createDto.typeId }, + }); + if (!type) + throw new common_1.NotFoundException('Document Type not found'); + let userOrgId = user.primaryOrganizationId; + if (!userOrgId) { + const fullUser = await this.userService.findOne(user.user_id); + if (fullUser) + userOrgId = fullUser.primaryOrganizationId; + } + if (previewOriginatorId && previewOriginatorId !== userOrgId) { + // Allow impersonation for preview + userOrgId = previewOriginatorId; + } + // Extract recipient from recipients array + const toRecipient = previewRecipients?.find((r) => r.type === 'TO'); + const recipientOrganizationId = toRecipient?.organizationId; + let recipientCode = ''; + if (recipientOrganizationId) { + const recOrg = await this.dataSource.manager.findOne(organization_entity_1.Organization, { + where: { id: recipientOrganizationId }, + }); + if (recOrg) + recipientCode = recOrg.organizationCode; + } + return this.numberingService.previewNumber({ + projectId: previewProjectId, + originatorOrganizationId: userOrgId, + typeId: createDto.typeId, + disciplineId: createDto.disciplineId, + subTypeId: createDto.subTypeId, + recipientOrganizationId, + year: new Date().getFullYear(), + customTokens: { + TYPE_CODE: type.typeCode, + RECIPIENT_CODE: recipientCode, + REC_CODE: recipientCode, + }, + }); + } + /** + * Business Rule Implementation: EC-CORR-001 - Cancel Correspondence with Downstream Circulation + * Cancel correspondence and handle related circulations + */ + async cancel(publicId, reason, user) { + const correspondence = await this.findOneByUuid(publicId); + // Check if user has permission to cancel (Org Admin or Superadmin only) + const permissions = await this.userService.getUserPermissions(user.user_id); + const canCancel = permissions.includes('correspondence.cancel') || + permissions.includes('system.manage_all'); + if (!canCancel) { + throw new common_1.ForbiddenException('Only administrators can cancel correspondences'); + } + // Check if there are any active circulations + const circulationRepo = this.dataSource.getRepository('Circulation'); + const activeCirculations = await circulationRepo.find({ + where: { + correspondenceId: correspondence.id, + status: 'OPEN', + }, + }); + const warningMessage = activeCirculations.length > 0 + ? `There are ${activeCirculations.length} active circulation(s) for this correspondence. Canceling will force close all related circulations.` + : ''; + // Get the current revision to update status + const currentRevision = await this.revisionRepo.findOne({ + where: { + correspondenceId: correspondence.id, + isCurrent: true, + }, + }); + if (!currentRevision) { + throw new common_1.NotFoundException('Current revision not found'); + } + // Get cancelled status + const cancelledStatus = await this.statusRepo.findOne({ + where: { statusCode: 'CANCELLED' }, + }); + if (!cancelledStatus) { + throw new common_1.InternalServerErrorException('CANCELLED status not found'); + } + const queryRunner = this.dataSource.createQueryRunner(); + await queryRunner.connect(); + await queryRunner.startTransaction(); + try { + // Update correspondence revision status to CANCELLED + await queryRunner.manager.update(correspondence_revision_entity_1.CorrespondenceRevision, currentRevision.id, { + statusId: cancelledStatus.id, + remarks: `Cancelled: ${reason}`, + }); + // Force close all active circulations + if (activeCirculations.length > 0) { + await queryRunner.manager.update('Circulation', { + correspondenceId: correspondence.id, + status: 'OPEN', + }, { + status: 'FORCE_CLOSED', + closedAt: new Date(), + closedBy: user.user_id, + closeReason: `Correspondence cancelled: ${reason}`, + }); + } + await queryRunner.commitTransaction(); + // Re-index cancelled status in Elasticsearch (fire-and-forget) + void this.searchService.indexDocument({ + id: correspondence.id, + publicId: correspondence.publicId, + type: 'correspondence', + docNumber: correspondence.correspondenceNumber, + title: currentRevision.subject, + status: 'CANCELLED', + projectId: correspondence.projectId, + createdAt: correspondence.createdAt, + }); + // Notify originator's doc-control user about cancellation (fire-and-forget) + if (correspondence.originatorId) { + void this.userService + .findDocControlIdByOrg(correspondence.originatorId) + .then((targetUserId) => { + if (targetUserId) { + void this.notificationService.send({ + userId: targetUserId, + title: 'Correspondence Cancelled', + message: `${correspondence.correspondenceNumber} — ${currentRevision.subject} has been cancelled. Reason: ${reason}`, + type: 'EMAIL', + entityType: 'correspondence', + entityId: correspondence.id, + link: `/correspondences/${correspondence.publicId}`, + }); + } + }) + .catch((err) => this.logger.warn(`Cancel notification failed: ${err.message}`)); + } + return { + success: true, + message: warningMessage || 'Correspondence cancelled successfully', + activeCirculationsCount: activeCirculations.length, + }; + } + catch (error) { + await queryRunner.rollbackTransaction(); + this.logger.error(`Failed to cancel correspondence: ${error.message}`); + throw error; + } + finally { + await queryRunner.release(); + } + } + async bulkCancel(publicIds, reason, user) { + const succeeded = []; + const failed = []; + for (const publicId of publicIds) { + try { + await this.cancel(publicId, reason, user); + succeeded.push(publicId); + } + catch { + failed.push(publicId); + } + } + return { succeeded, failed }; + } + async exportCsv(searchDto) { + const { data } = await this.findAll(searchDto); + const header = [ + 'Document No.', + 'Rev', + 'Subject', + 'Type', + 'Status', + 'Project', + 'From', + 'Due Date', + 'Created At', + ]; + const rows = data.map((rev) => { + const corr = rev.correspondence ?? rev; + return [ + this.escapeCsv(corr.correspondenceNumber ?? ''), + this.escapeCsv(rev.revisionLabel ?? String(rev.revisionNumber ?? 0)), + this.escapeCsv(rev.subject ?? ''), + this.escapeCsv(corr.type?.typeCode ?? ''), + this.escapeCsv(rev.status?.statusCode ?? ''), + this.escapeCsv(corr.project?.projectCode ?? ''), + this.escapeCsv(corr.originator?.organizationCode ?? ''), + rev.dueDate ? new Date(rev.dueDate).toISOString().split('T')[0] : '', + new Date(rev.createdAt).toISOString().split('T')[0], + ].join(','); + }); + return [header.join(','), ...rows].join('\n'); + } + escapeCsv(value) { + if (value.includes(',') || value.includes('"') || value.includes('\n')) { + return `"${value.replace(/"/g, '""')}"`; + } + return value; + } +}; +exports.CorrespondenceService = CorrespondenceService; +exports.CorrespondenceService = CorrespondenceService = CorrespondenceService_1 = __decorate([ + (0, common_1.Injectable)(), + __param(0, (0, typeorm_1.InjectRepository)(correspondence_entity_1.Correspondence)), + __param(1, (0, typeorm_1.InjectRepository)(correspondence_revision_entity_1.CorrespondenceRevision)), + __param(2, (0, typeorm_1.InjectRepository)(correspondence_type_entity_1.CorrespondenceType)), + __param(3, (0, typeorm_1.InjectRepository)(correspondence_status_entity_1.CorrespondenceStatus)), + __param(4, (0, typeorm_1.InjectRepository)(correspondence_reference_entity_1.CorrespondenceReference)), + __param(5, (0, typeorm_1.InjectRepository)(correspondence_tag_entity_1.CorrespondenceTag)), + __metadata("design:paramtypes", [typeof (_a = typeof typeorm_2.Repository !== "undefined" && typeorm_2.Repository) === "function" ? _a : Object, typeof (_b = typeof typeorm_2.Repository !== "undefined" && typeorm_2.Repository) === "function" ? _b : Object, typeof (_c = typeof typeorm_2.Repository !== "undefined" && typeorm_2.Repository) === "function" ? _c : Object, typeof (_d = typeof typeorm_2.Repository !== "undefined" && typeorm_2.Repository) === "function" ? _d : Object, typeof (_e = typeof typeorm_2.Repository !== "undefined" && typeorm_2.Repository) === "function" ? _e : Object, typeof (_f = typeof typeorm_2.Repository !== "undefined" && typeorm_2.Repository) === "function" ? _f : Object, typeof (_g = typeof document_numbering_service_1.DocumentNumberingService !== "undefined" && document_numbering_service_1.DocumentNumberingService) === "function" ? _g : Object, typeof (_h = typeof json_schema_service_1.JsonSchemaService !== "undefined" && json_schema_service_1.JsonSchemaService) === "function" ? _h : Object, typeof (_j = typeof workflow_engine_service_1.WorkflowEngineService !== "undefined" && workflow_engine_service_1.WorkflowEngineService) === "function" ? _j : Object, typeof (_k = typeof user_service_1.UserService !== "undefined" && user_service_1.UserService) === "function" ? _k : Object, typeof (_l = typeof typeorm_2.DataSource !== "undefined" && typeorm_2.DataSource) === "function" ? _l : Object, typeof (_m = typeof search_service_1.SearchService !== "undefined" && search_service_1.SearchService) === "function" ? _m : Object, typeof (_o = typeof file_storage_service_1.FileStorageService !== "undefined" && file_storage_service_1.FileStorageService) === "function" ? _o : Object, typeof (_p = typeof uuid_resolver_service_1.UuidResolverService !== "undefined" && uuid_resolver_service_1.UuidResolverService) === "function" ? _p : Object, typeof (_q = typeof notification_service_1.NotificationService !== "undefined" && notification_service_1.NotificationService) === "function" ? _q : Object]) +], CorrespondenceService); +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"file":"E:\\np-dms\\lcbp3\\backend\\src\\modules\\correspondence\\correspondence.service.ts","mappings":"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","names":[],"sources":["E:\\np-dms\\lcbp3\\backend\\src\\modules\\correspondence\\correspondence.service.ts"],"sourcesContent":["// File: src/modules/correspondence/correspondence.service.ts\r\n\r\nimport {\r\n  Injectable,\r\n  NotFoundException,\r\n  BadRequestException,\r\n  InternalServerErrorException,\r\n  ForbiddenException,\r\n  Logger,\r\n} from '@nestjs/common';\r\nimport { InjectRepository } from '@nestjs/typeorm';\r\nimport { Repository, DataSource } from 'typeorm';\r\n\r\n// Entities\r\nimport { Correspondence } from './entities/correspondence.entity';\r\nimport { CorrespondenceRevision } from './entities/correspondence-revision.entity';\r\nimport { CorrespondenceType } from './entities/correspondence-type.entity';\r\nimport { CorrespondenceStatus } from './entities/correspondence-status.entity';\r\nimport { CorrespondenceReference } from './entities/correspondence-reference.entity';\r\nimport { CorrespondenceRecipient } from './entities/correspondence-recipient.entity';\r\nimport { CorrespondenceTag } from './entities/correspondence-tag.entity';\r\nimport { Tag } from '../master/entities/tag.entity';\r\nimport { User } from '../user/entities/user.entity';\r\nimport { Organization } from '../organization/entities/organization.entity';\r\n\r\n// DTOs\r\nimport { CreateCorrespondenceDto } from './dto/create-correspondence.dto';\r\nimport { UpdateCorrespondenceDto } from './dto/update-correspondence.dto';\r\nimport { AddReferenceDto } from './dto/add-reference.dto';\r\nimport { SearchCorrespondenceDto } from './dto/search-correspondence.dto';\r\n\r\n// Services\r\nimport { DocumentNumberingService } from '../document-numbering/services/document-numbering.service';\r\nimport { JsonSchemaService } from '../json-schema/json-schema.service';\r\nimport { WorkflowEngineService } from '../workflow-engine/workflow-engine.service';\r\nimport { UserService } from '../user/user.service';\r\nimport { SearchService } from '../search/search.service';\r\nimport { FileStorageService } from '../../common/file-storage/file-storage.service';\r\nimport { UuidResolverService } from '../../common/services/uuid-resolver.service';\r\nimport { NotificationService } from '../notification/notification.service';\r\n\r\n/**\r\n * CorrespondenceService - Document management (CRUD)\r\n */\r\ninterface ResolvedRecipient {\r\n  organizationId: number;\r\n  type: 'TO' | 'CC';\r\n}\r\n@Injectable()\r\nexport class CorrespondenceService {\r\n  private readonly logger = new Logger(CorrespondenceService.name);\r\n\r\n  private async hasSystemManageAllPermission(userId: number): Promise<boolean> {\r\n    const permissions = await this.userService.getUserPermissions(userId);\r\n    return permissions.includes('system.manage_all');\r\n  }\r\n\r\n  /**\r\n   * Business Rule: Revision Label Strategy\r\n   * - RFA, RFI: Use alphabet starting with 'A' (A, B, C...)\r\n   * - Other types (LETTER, MEMO, etc.): Use numeric (null for first, then 1, 2, 3...)\r\n   */\r\n  private getInitialRevisionLabel(typeCode: string): string | null {\r\n    const alphabetTypes = ['RFA', 'RFI'];\r\n    if (alphabetTypes.includes(typeCode.toUpperCase())) {\r\n      return 'A'; // Alphabet for RFA, RFI\r\n    }\r\n    return null; // Numeric (null for revision 0)\r\n  }\r\n\r\n  constructor(\r\n    @InjectRepository(Correspondence)\r\n    private correspondenceRepo: Repository<Correspondence>,\r\n    @InjectRepository(CorrespondenceRevision)\r\n    private revisionRepo: Repository<CorrespondenceRevision>,\r\n    @InjectRepository(CorrespondenceType)\r\n    private typeRepo: Repository<CorrespondenceType>,\r\n    @InjectRepository(CorrespondenceStatus)\r\n    private statusRepo: Repository<CorrespondenceStatus>,\r\n    @InjectRepository(CorrespondenceReference)\r\n    private referenceRepo: Repository<CorrespondenceReference>,\r\n    @InjectRepository(CorrespondenceTag)\r\n    private tagRepo: Repository<CorrespondenceTag>,\r\n    private numberingService: DocumentNumberingService,\r\n    private jsonSchemaService: JsonSchemaService,\r\n    private workflowEngine: WorkflowEngineService,\r\n    private userService: UserService,\r\n    private dataSource: DataSource,\r\n    private searchService: SearchService,\r\n    private fileStorageService: FileStorageService,\r\n    private uuidResolver: UuidResolverService,\r\n    private notificationService: NotificationService\r\n  ) {}\r\n\r\n  /**\r\n   * Business Rule Validation: EC-CORR-003 - Correspondence to Self\r\n   * Prevent external correspondence to same organization\r\n   */\r\n  private async validateCorrespondenceRecipients(\r\n    createDto: CreateCorrespondenceDto,\r\n    user: User\r\n  ): Promise<void> {\r\n    // Get user's organization\r\n    let userOrgId = user.primaryOrganizationId;\r\n    if (!userOrgId) {\r\n      const fullUser = await this.userService.findOne(user.user_id);\r\n      if (fullUser) {\r\n        userOrgId = fullUser.primaryOrganizationId;\r\n      }\r\n    }\r\n\r\n    if (!userOrgId) {\r\n      if (createDto.originatorId) {\r\n        const canManageAll = await this.hasSystemManageAllPermission(\r\n          user.user_id\r\n        );\r\n        if (canManageAll) {\r\n          userOrgId = await this.uuidResolver.resolveOrganizationId(\r\n            createDto.originatorId\r\n          );\r\n        }\r\n      }\r\n\r\n      if (!userOrgId) {\r\n        throw new BadRequestException(\r\n          'User must belong to an organization to create documents'\r\n        );\r\n      }\r\n    }\r\n\r\n    // For impersonation, use the specified originator\r\n    const originatorOrgId = createDto.originatorId\r\n      ? await this.uuidResolver.resolveOrganizationId(createDto.originatorId)\r\n      : userOrgId;\r\n\r\n    // Check if it's internal communication\r\n    if (createDto.isInternal) {\r\n      // Internal communications should use Circulation instead\r\n      throw new BadRequestException(\r\n        'Internal communications should use Circulation Sheet instead of Correspondence'\r\n      );\r\n    }\r\n\r\n    // Validate recipients\r\n    if (!createDto.recipients || createDto.recipients.length === 0) {\r\n      throw new BadRequestException(\r\n        'At least one recipient (TO or CC) is required'\r\n      );\r\n    }\r\n\r\n    const toRecipients = createDto.recipients.filter((r) => r.type === 'TO');\r\n    const ccRecipients = createDto.recipients.filter((r) => r.type === 'CC');\r\n\r\n    if (toRecipients.length === 0 && ccRecipients.length === 0) {\r\n      throw new BadRequestException(\r\n        'At least one TO or CC recipient is required'\r\n      );\r\n    }\r\n\r\n    // Check for same organization correspondence\r\n    for (const recipient of createDto.recipients) {\r\n      const recipientOrgId = await this.uuidResolver.resolveOrganizationId(\r\n        recipient.organizationId\r\n      );\r\n\r\n      if (recipientOrgId === originatorOrgId) {\r\n        throw new BadRequestException(\r\n          'Cannot send correspondence to your own organization. Use Circulation Sheet for internal communication.'\r\n        );\r\n      }\r\n    }\r\n  }\r\n\r\n  async create(createDto: CreateCorrespondenceDto, user: User) {\r\n    // Business Rule Validation: EC-CORR-003 - Correspondence to Self\r\n    await this.validateCorrespondenceRecipients(createDto, user);\r\n    // ADR-019: Resolve UUID references to internal INT IDs\r\n    const resolvedProjectId = await this.uuidResolver.resolveProjectId(\r\n      createDto.projectId\r\n    );\r\n    const resolvedOriginatorId = createDto.originatorId\r\n      ? await this.uuidResolver.resolveOrganizationId(createDto.originatorId)\r\n      : undefined;\r\n    const resolvedRecipients = createDto.recipients\r\n      ? await Promise.all(\r\n          createDto.recipients.map(\r\n            async (r): Promise<ResolvedRecipient> => ({\r\n              organizationId: await this.uuidResolver.resolveOrganizationId(\r\n                r.organizationId\r\n              ),\r\n              type: r.type,\r\n            })\r\n          )\r\n        )\r\n      : undefined;\r\n    const type = await this.typeRepo.findOne({\r\n      where: { id: createDto.typeId },\r\n    });\r\n    if (!type) throw new NotFoundException('Document Type not found');\r\n\r\n    const statusDraft = await this.statusRepo.findOne({\r\n      where: { statusCode: 'DRAFT' },\r\n    });\r\n    if (!statusDraft) {\r\n      throw new InternalServerErrorException(\r\n        'Status DRAFT not found in Master Data'\r\n      );\r\n    }\r\n\r\n    let userOrgId = user.primaryOrganizationId;\r\n\r\n    if (!userOrgId) {\r\n      const fullUser = await this.userService.findOne(user.user_id);\r\n      if (fullUser) {\r\n        userOrgId = fullUser.primaryOrganizationId;\r\n      }\r\n    }\r\n\r\n    // Impersonation Logic\r\n    if (resolvedOriginatorId && resolvedOriginatorId !== userOrgId) {\r\n      const canManageAll = await this.hasSystemManageAllPermission(\r\n        user.user_id\r\n      );\r\n      if (!canManageAll) {\r\n        throw new ForbiddenException(\r\n          'You do not have permission to create documents on behalf of other organizations.'\r\n        );\r\n      }\r\n      userOrgId = resolvedOriginatorId;\r\n    }\r\n\r\n    if (!userOrgId) {\r\n      throw new BadRequestException(\r\n        'User must belong to an organization to create documents'\r\n      );\r\n    }\r\n\r\n    if (createDto.details) {\r\n      try {\r\n        await this.jsonSchemaService.validate(type.typeCode, createDto.details);\r\n      } catch (error: unknown) {\r\n        this.logger.warn(\r\n          `Schema validation warning for ${type.typeCode}: ${(error as Error).message}`\r\n        );\r\n      }\r\n    }\r\n\r\n    const queryRunner = this.dataSource.createQueryRunner();\r\n    await queryRunner.connect();\r\n    await queryRunner.startTransaction();\r\n\r\n    try {\r\n      // [Fix #6] Fetch real ORG Code from Organization entity\r\n      const originatorOrg = await this.dataSource.manager.findOne(\r\n        Organization,\r\n        {\r\n          where: { id: userOrgId },\r\n        }\r\n      );\r\n      const orgCode = originatorOrg?.organizationCode ?? 'UNK';\r\n\r\n      // [v1.5.1] Extract recipient organization from recipients array (Primary TO)\r\n      const toRecipient = resolvedRecipients?.find((r) => r.type === 'TO');\r\n      const recipientOrganizationId = toRecipient?.organizationId;\r\n\r\n      let recipientCode = '';\r\n      if (recipientOrganizationId) {\r\n        const recOrg = await this.dataSource.manager.findOne(Organization, {\r\n          where: { id: recipientOrganizationId },\r\n        });\r\n        if (recOrg) recipientCode = recOrg.organizationCode;\r\n      }\r\n\r\n      const docNumber = await this.numberingService.generateNextNumber({\r\n        projectId: resolvedProjectId,\r\n        originatorOrganizationId: userOrgId,\r\n        typeId: createDto.typeId,\r\n        disciplineId: createDto.disciplineId,\r\n        subTypeId: createDto.subTypeId,\r\n        recipientOrganizationId, // [v1.5.1] Pass recipient for document number format\r\n        year: new Date().getFullYear(),\r\n        customTokens: {\r\n          TYPE_CODE: type.typeCode,\r\n          ORG_CODE: orgCode,\r\n          RECIPIENT_CODE: recipientCode,\r\n          REC_CODE: recipientCode,\r\n        },\r\n      });\r\n\r\n      const correspondence = queryRunner.manager.create(Correspondence, {\r\n        correspondenceNumber: docNumber.number,\r\n        correspondenceTypeId: createDto.typeId,\r\n        disciplineId: createDto.disciplineId,\r\n        projectId: resolvedProjectId,\r\n        originatorId: userOrgId,\r\n        isInternal: createDto.isInternal || false,\r\n        createdBy: user.user_id,\r\n      });\r\n      const savedCorr = await queryRunner.manager.save(correspondence);\r\n\r\n      const revision = queryRunner.manager.create(CorrespondenceRevision, {\r\n        correspondenceId: savedCorr.id,\r\n        revisionNumber: 0,\r\n        revisionLabel: this.getInitialRevisionLabel(type.typeCode),\r\n        isCurrent: true,\r\n        statusId: statusDraft.id,\r\n        subject: createDto.subject,\r\n        body: createDto.body,\r\n        remarks: createDto.remarks,\r\n        dueDate: createDto.dueDate ? new Date(createDto.dueDate) : undefined,\r\n        documentDate: createDto.documentDate\r\n          ? new Date(createDto.documentDate)\r\n          : undefined,\r\n        issuedDate: createDto.issuedDate\r\n          ? new Date(createDto.issuedDate)\r\n          : undefined,\r\n        receivedDate: createDto.receivedDate\r\n          ? new Date(createDto.receivedDate)\r\n          : undefined,\r\n        description: createDto.description,\r\n        details: createDto.details,\r\n        createdBy: user.user_id,\r\n        schemaVersion: 1,\r\n      });\r\n      await queryRunner.manager.save(revision);\r\n\r\n      // Save Recipients (using resolved INT IDs)\r\n      if (resolvedRecipients && resolvedRecipients.length > 0) {\r\n        const recipients = resolvedRecipients.map((r) =>\r\n          queryRunner.manager.create(CorrespondenceRecipient, {\r\n            correspondenceId: savedCorr.id,\r\n            recipientOrganizationId: r.organizationId,\r\n            recipientType: r.type,\r\n          })\r\n        );\r\n        await queryRunner.manager.save(recipients);\r\n      }\r\n\r\n      // Commit attachments from Temp → Permanent (Two-Phase Storage)\r\n      if (createDto.attachmentTempIds?.length) {\r\n        const issueDate = createDto.issuedDate\r\n          ? new Date(createDto.issuedDate)\r\n          : createDto.documentDate\r\n            ? new Date(createDto.documentDate)\r\n            : undefined;\r\n\r\n        await this.fileStorageService.commit(createDto.attachmentTempIds, {\r\n          issueDate,\r\n          documentType: 'Correspondence',\r\n        });\r\n      }\r\n\r\n      await queryRunner.commitTransaction();\r\n\r\n      // Start Workflow Instance (non-blocking)\r\n      try {\r\n        const workflowCode = `CORRESPONDENCE_${type.typeCode}`;\r\n        await this.workflowEngine.createInstance(\r\n          workflowCode,\r\n          'correspondence',\r\n          savedCorr.id.toString(),\r\n          {\r\n            projectId: resolvedProjectId,\r\n            originatorId: userOrgId,\r\n            disciplineId: createDto.disciplineId,\r\n            initiatorId: user.user_id,\r\n          } as Record<string, unknown>\r\n        );\r\n      } catch (error: unknown) {\r\n        this.logger.warn(\r\n          `Workflow not started for ${docNumber.number} (Code: CORRESPONDENCE_${type.typeCode}): ${(error as Error).message}`\r\n        );\r\n      }\r\n\r\n      // Fire-and-forget search indexing (non-blocking, void intentional)\r\n      void this.searchService.indexDocument({\r\n        id: savedCorr.id,\r\n        publicId: savedCorr.publicId,\r\n        type: 'correspondence',\r\n        docNumber: docNumber.number,\r\n        title: createDto.subject,\r\n        description: createDto.description,\r\n        status: 'DRAFT',\r\n        projectId: resolvedProjectId,\r\n        createdAt: new Date(),\r\n      });\r\n\r\n      return {\r\n        ...savedCorr,\r\n        currentRevision: revision,\r\n      };\r\n    } catch (err) {\r\n      await queryRunner.rollbackTransaction();\r\n      this.logger.error(\r\n        `Failed to create correspondence: ${(err as Error).message}`\r\n      );\r\n      throw err;\r\n    } finally {\r\n      await queryRunner.release();\r\n    }\r\n  }\r\n\r\n  async findAll(searchDto: SearchCorrespondenceDto = {}) {\r\n    const {\r\n      search,\r\n      typeId,\r\n      projectId,\r\n      statusId,\r\n      status,\r\n      page = 1,\r\n      limit = 10,\r\n    } = searchDto;\r\n    const skip = (page - 1) * limit;\r\n\r\n    // Change: Query from Revision Repo\r\n    const query = this.revisionRepo\r\n      .createQueryBuilder('rev')\r\n      .leftJoinAndSelect('rev.correspondence', 'corr')\r\n      .leftJoinAndSelect('corr.type', 'type')\r\n      .leftJoinAndSelect('corr.project', 'project')\r\n      .leftJoinAndSelect('corr.originator', 'org')\r\n      .leftJoinAndSelect('rev.status', 'status');\r\n\r\n    // Filter by Revision Status\r\n    const revStatus = searchDto.revisionStatus || 'CURRENT';\r\n\r\n    if (revStatus === 'CURRENT') {\r\n      query.where('rev.isCurrent = :isCurrent', { isCurrent: true });\r\n    } else if (revStatus === 'OLD') {\r\n      query.where('rev.isCurrent = :isCurrent', { isCurrent: false });\r\n    }\r\n    // If 'ALL', no filter needed on isCurrent\r\n\r\n    if (projectId) {\r\n      query.andWhere('corr.projectId = :projectId', { projectId });\r\n    }\r\n\r\n    if (typeId) {\r\n      query.andWhere('corr.correspondenceTypeId = :typeId', { typeId });\r\n    }\r\n\r\n    if (statusId) {\r\n      query.andWhere('rev.statusId = :statusId', { statusId });\r\n    }\r\n\r\n    if (status) {\r\n      query.andWhere('status.statusCode = :status', { status });\r\n    }\r\n\r\n    if (search) {\r\n      query.andWhere(\r\n        '(corr.correspondenceNumber LIKE :search OR rev.subject LIKE :search)',\r\n        { search: `%${search}%` }\r\n      );\r\n    }\r\n\r\n    // Default Sort: Latest Created\r\n    query.orderBy('rev.createdAt', 'DESC').skip(skip).take(limit);\r\n\r\n    const [items, total] = await query.getManyAndCount();\r\n\r\n    return {\r\n      data: items,\r\n      meta: {\r\n        total,\r\n        page,\r\n        limit,\r\n        totalPages: Math.ceil(total / limit),\r\n      },\r\n    };\r\n  }\r\n\r\n  async findOne(id: number) {\r\n    const correspondence = await this.correspondenceRepo.findOne({\r\n      where: { id },\r\n      relations: [\r\n        'revisions',\r\n        'revisions.status',\r\n        'type',\r\n        'project',\r\n        'originator',\r\n        'recipients',\r\n        'recipients.recipientOrganization', // [v1.5.1] Fixed relation name\r\n      ],\r\n    });\r\n\r\n    if (!correspondence) {\r\n      throw new NotFoundException(`Correspondence with ID ${id} not found`);\r\n    }\r\n    return correspondence;\r\n  }\r\n\r\n  async findOneByUuid(publicId: string) {\r\n    const correspondence = await this.correspondenceRepo.findOne({\r\n      where: { publicId },\r\n      relations: [\r\n        'revisions',\r\n        'revisions.status',\r\n        'type',\r\n        'project',\r\n        'originator',\r\n        'recipients',\r\n        'recipients.recipientOrganization',\r\n      ],\r\n    });\r\n\r\n    if (!correspondence) {\r\n      throw new NotFoundException(\r\n        `Correspondence with UUID ${publicId} not found`\r\n      );\r\n    }\r\n    return correspondence;\r\n  }\r\n\r\n  async addReference(id: number, dto: AddReferenceDto) {\r\n    const source = await this.correspondenceRepo.findOne({ where: { id } });\r\n    // ADR-019: Resolve target publicId → internal INT id\r\n    const target = await this.correspondenceRepo.findOne({\r\n      where: { publicId: dto.targetUuid },\r\n    });\r\n\r\n    if (!source || !target) {\r\n      throw new NotFoundException('Source or Target correspondence not found');\r\n    }\r\n\r\n    if (source.id === target.id) {\r\n      throw new BadRequestException('Cannot reference self');\r\n    }\r\n\r\n    const exists = await this.referenceRepo.findOne({\r\n      where: {\r\n        sourceId: id,\r\n        targetId: target.id,\r\n      },\r\n    });\r\n\r\n    if (exists) {\r\n      return exists;\r\n    }\r\n\r\n    const ref = this.referenceRepo.create({\r\n      sourceId: id,\r\n      targetId: target.id,\r\n    });\r\n\r\n    return this.referenceRepo.save(ref);\r\n  }\r\n\r\n  async removeReference(id: number, targetId: number) {\r\n    const result = await this.referenceRepo.delete({\r\n      sourceId: id,\r\n      targetId: targetId,\r\n    });\r\n\r\n    if (result.affected === 0) {\r\n      throw new NotFoundException('Reference not found');\r\n    }\r\n  }\r\n\r\n  async getTags(id: number) {\r\n    const rows = await this.tagRepo.find({\r\n      where: { correspondenceId: id },\r\n      relations: ['tag'],\r\n    });\r\n    return rows.map((r) => r.tag).filter(Boolean);\r\n  }\r\n\r\n  async addTag(id: number, tagId: number) {\r\n    const correspondence = await this.correspondenceRepo.findOne({\r\n      where: { id },\r\n    });\r\n    if (!correspondence) {\r\n      throw new NotFoundException(`Correspondence ${id} not found`);\r\n    }\r\n\r\n    const tag = await this.dataSource.manager.findOne(Tag, {\r\n      where: { id: tagId },\r\n    });\r\n    if (!tag) {\r\n      throw new NotFoundException(`Tag ${tagId} not found`);\r\n    }\r\n\r\n    const exists = await this.tagRepo.findOne({\r\n      where: { correspondenceId: id, tagId },\r\n    });\r\n    if (exists) return exists;\r\n\r\n    const row = this.tagRepo.create({ correspondenceId: id, tagId });\r\n    return this.tagRepo.save(row);\r\n  }\r\n\r\n  async removeTag(id: number, tagId: number) {\r\n    const result = await this.tagRepo.delete({ correspondenceId: id, tagId });\r\n    if (result.affected === 0) {\r\n      throw new NotFoundException('Tag assignment not found');\r\n    }\r\n  }\r\n\r\n  async getReferences(id: number) {\r\n    const outgoing = await this.referenceRepo.find({\r\n      where: { sourceId: id },\r\n      relations: ['target', 'target.type'],\r\n    });\r\n\r\n    const incoming = await this.referenceRepo.find({\r\n      where: { targetId: id },\r\n      relations: ['source', 'source.type'],\r\n    });\r\n\r\n    return { outgoing, incoming };\r\n  }\r\n\r\n  async update(id: number, updateDto: UpdateCorrespondenceDto, user: User) {\r\n    // 1. Find Current Revision\r\n    const revision = await this.revisionRepo.findOne({\r\n      where: {\r\n        correspondenceId: id,\r\n        isCurrent: true,\r\n      },\r\n      relations: ['correspondence'],\r\n    });\r\n\r\n    if (!revision) {\r\n      throw new NotFoundException(\r\n        `Current revision for correspondence ${id} not found`\r\n      );\r\n    }\r\n\r\n    // 2. Check Permission\r\n    if (revision.statusId) {\r\n      const status = await this.statusRepo.findOne({\r\n        where: { id: revision.statusId },\r\n      });\r\n      if (status && status.statusCode !== 'DRAFT') {\r\n        throw new BadRequestException('Only DRAFT documents can be updated');\r\n      }\r\n    }\r\n\r\n    // ADR-019: Resolve UUID references in update DTO\r\n    const updResolvedProjectId = updateDto.projectId\r\n      ? await this.uuidResolver.resolveProjectId(updateDto.projectId)\r\n      : undefined;\r\n    const updResolvedOriginatorId = updateDto.originatorId\r\n      ? await this.uuidResolver.resolveOrganizationId(updateDto.originatorId)\r\n      : undefined;\r\n    const updResolvedRecipients = updateDto.recipients\r\n      ? await Promise.all(\r\n          updateDto.recipients.map(\r\n            async (r): Promise<ResolvedRecipient> => ({\r\n              organizationId: await this.uuidResolver.resolveOrganizationId(\r\n                r.organizationId\r\n              ),\r\n              type: r.type,\r\n            })\r\n          )\r\n        )\r\n      : undefined;\r\n\r\n    // 3. Update Correspondence Entity if needed\r\n    const correspondenceUpdate: Record<string, unknown> = {};\r\n    if (updateDto.disciplineId)\r\n      correspondenceUpdate.disciplineId = updateDto.disciplineId;\r\n    if (updResolvedProjectId)\r\n      correspondenceUpdate.projectId = updResolvedProjectId;\r\n    if (updResolvedOriginatorId)\r\n      correspondenceUpdate.originatorId = updResolvedOriginatorId;\r\n\r\n    if (Object.keys(correspondenceUpdate).length > 0) {\r\n      await this.correspondenceRepo.update(id, correspondenceUpdate);\r\n    }\r\n\r\n    // 4. Update Revision Entity\r\n    const revisionUpdate: Record<string, unknown> = {};\r\n    if (updateDto.subject) revisionUpdate.subject = updateDto.subject;\r\n    if (updateDto.body) revisionUpdate.body = updateDto.body;\r\n    if (updateDto.remarks) revisionUpdate.remarks = updateDto.remarks;\r\n    // Format Date correctly if string\r\n    if (updateDto.dueDate) revisionUpdate.dueDate = new Date(updateDto.dueDate);\r\n    if (updateDto.documentDate)\r\n      revisionUpdate.documentDate = new Date(updateDto.documentDate);\r\n    if (updateDto.issuedDate)\r\n      revisionUpdate.issuedDate = new Date(updateDto.issuedDate);\r\n    if (updateDto.receivedDate)\r\n      revisionUpdate.receivedDate = new Date(updateDto.receivedDate);\r\n    if (updateDto.description)\r\n      revisionUpdate.description = updateDto.description;\r\n    if (updateDto.details) revisionUpdate.details = updateDto.details;\r\n\r\n    if (Object.keys(revisionUpdate).length > 0) {\r\n      await this.revisionRepo.update(revision.id, revisionUpdate);\r\n    }\r\n\r\n    // 4.5 Commit new attachments from Temp → Permanent (Two-Phase Storage)\r\n    if (updateDto.attachmentTempIds?.length) {\r\n      const issueDate = updateDto.issuedDate\r\n        ? new Date(updateDto.issuedDate)\r\n        : updateDto.documentDate\r\n          ? new Date(updateDto.documentDate)\r\n          : revision.issuedDate || revision.documentDate || undefined;\r\n\r\n      await this.fileStorageService.commit(updateDto.attachmentTempIds, {\r\n        issueDate: issueDate ? new Date(issueDate) : undefined,\r\n        documentType: 'Correspondence',\r\n      });\r\n    }\r\n\r\n    // 5. Update Recipients if provided\r\n    if (updResolvedRecipients) {\r\n      const recipientRepo = this.dataSource.getRepository(\r\n        CorrespondenceRecipient\r\n      );\r\n      await recipientRepo.delete({ correspondenceId: id });\r\n\r\n      const newRecipients = updResolvedRecipients.map((r) =>\r\n        recipientRepo.create({\r\n          correspondenceId: id,\r\n          recipientOrganizationId: r.organizationId,\r\n          recipientType: r.type,\r\n        })\r\n      );\r\n      await recipientRepo.save(newRecipients);\r\n    }\r\n\r\n    // 6. Regenerate Document Number if structural fields changed (Recipient, Discipline, Type, Project)\r\n    // AND it is a DRAFT.\r\n\r\n    // Fetch fresh data for context and comparison\r\n    const currentCorr = await this.correspondenceRepo.findOne({\r\n      where: { id },\r\n      relations: ['type', 'recipients', 'recipients.recipientOrganization'],\r\n    });\r\n\r\n    if (currentCorr) {\r\n      const currentToRecipient = currentCorr.recipients?.find(\r\n        (r) => r.recipientType === 'TO'\r\n      );\r\n      const currentRecipientId = currentToRecipient?.recipientOrganizationId;\r\n\r\n      // Check for ACTUAL value changes\r\n      const isProjectChanged =\r\n        updResolvedProjectId !== undefined &&\r\n        updResolvedProjectId !== currentCorr.projectId;\r\n      const isOriginatorChanged =\r\n        updResolvedOriginatorId !== undefined &&\r\n        updResolvedOriginatorId !== currentCorr.originatorId;\r\n      const isDisciplineChanged =\r\n        updateDto.disciplineId !== undefined &&\r\n        updateDto.disciplineId !== currentCorr.disciplineId;\r\n      const isTypeChanged =\r\n        updateDto.typeId !== undefined &&\r\n        updateDto.typeId !== currentCorr.correspondenceTypeId;\r\n\r\n      let isRecipientChanged = false;\r\n      let newRecipientId: number | undefined;\r\n\r\n      if (updResolvedRecipients) {\r\n        const newToRecipient = updResolvedRecipients.find(\r\n          (r) => r.type === 'TO'\r\n        );\r\n        newRecipientId = newToRecipient?.organizationId;\r\n\r\n        if (newRecipientId !== currentRecipientId) {\r\n          isRecipientChanged = true;\r\n        }\r\n      }\r\n\r\n      if (\r\n        isProjectChanged ||\r\n        isDisciplineChanged ||\r\n        isTypeChanged ||\r\n        isRecipientChanged ||\r\n        isOriginatorChanged\r\n      ) {\r\n        const targetRecipientId = isRecipientChanged\r\n          ? newRecipientId\r\n          : currentRecipientId;\r\n\r\n        // Resolve Recipient Code for the NEW context\r\n        let recipientCode = '';\r\n        if (targetRecipientId) {\r\n          const recOrg = await this.dataSource.manager.findOne(Organization, {\r\n            where: { id: targetRecipientId },\r\n          });\r\n          if (recOrg) recipientCode = recOrg.organizationCode;\r\n        }\r\n\r\n        // [Fix #6] Fetch real ORG Code from originator organization\r\n        const originatorOrgForUpdate = await this.dataSource.manager.findOne(\r\n          Organization,\r\n          {\r\n            where: {\r\n              id: updResolvedOriginatorId ?? currentCorr.originatorId ?? 0,\r\n            },\r\n          }\r\n        );\r\n        const orgCode = originatorOrgForUpdate?.organizationCode ?? 'UNK';\r\n\r\n        // Prepare Contexts\r\n        const oldCtx = {\r\n          projectId: currentCorr.projectId,\r\n          originatorOrganizationId: currentCorr.originatorId ?? 0,\r\n          typeId: currentCorr.correspondenceTypeId,\r\n          disciplineId: currentCorr.disciplineId,\r\n          recipientOrganizationId: currentRecipientId,\r\n          year: new Date().getFullYear(),\r\n        };\r\n\r\n        const newCtx = {\r\n          projectId: updResolvedProjectId ?? currentCorr.projectId,\r\n          originatorOrganizationId:\r\n            updResolvedOriginatorId ?? currentCorr.originatorId ?? 0,\r\n          typeId: updateDto.typeId ?? currentCorr.correspondenceTypeId,\r\n          disciplineId: updateDto.disciplineId ?? currentCorr.disciplineId,\r\n          recipientOrganizationId: targetRecipientId,\r\n          year: new Date().getFullYear(),\r\n          userId: user.user_id, // Pass User ID for Audit\r\n          customTokens: {\r\n            TYPE_CODE: currentCorr.type?.typeCode || '',\r\n            ORG_CODE: orgCode,\r\n            RECIPIENT_CODE: recipientCode,\r\n            REC_CODE: recipientCode,\r\n          },\r\n        };\r\n\r\n        // If Type Changed, need NEW Type Code\r\n        if (isTypeChanged) {\r\n          const newType = await this.typeRepo.findOne({\r\n            where: { id: newCtx.typeId },\r\n          });\r\n          if (newType) newCtx.customTokens.TYPE_CODE = newType.typeCode;\r\n        }\r\n\r\n        const newDocNumber = await this.numberingService.updateNumberForDraft(\r\n          currentCorr.correspondenceNumber,\r\n          oldCtx,\r\n          newCtx\r\n        );\r\n\r\n        await this.correspondenceRepo.update(id, {\r\n          correspondenceNumber: newDocNumber,\r\n        });\r\n      }\r\n    }\r\n\r\n    const updated = await this.findOne(id);\r\n\r\n    // Re-index updated document in Elasticsearch (fire-and-forget)\r\n    void this.searchService.indexDocument({\r\n      id: updated.id,\r\n      publicId: updated.publicId,\r\n      type: 'correspondence',\r\n      docNumber: updated.correspondenceNumber,\r\n      title: updateDto.subject ?? updated.revisions?.[0]?.subject,\r\n      description: updateDto.description ?? updated.revisions?.[0]?.description,\r\n      status: 'DRAFT',\r\n      projectId: updated.projectId,\r\n      createdAt: updated.createdAt,\r\n    });\r\n\r\n    return updated;\r\n  }\r\n\r\n  async previewDocumentNumber(createDto: CreateCorrespondenceDto, user: User) {\r\n    // ADR-019: Resolve UUID references\r\n    const previewProjectId = await this.uuidResolver.resolveProjectId(\r\n      createDto.projectId\r\n    );\r\n    const previewOriginatorId = createDto.originatorId\r\n      ? await this.uuidResolver.resolveOrganizationId(createDto.originatorId)\r\n      : undefined;\r\n    const previewRecipients = createDto.recipients\r\n      ? await Promise.all(\r\n          createDto.recipients.map(\r\n            async (r): Promise<ResolvedRecipient> => ({\r\n              organizationId: await this.uuidResolver.resolveOrganizationId(\r\n                r.organizationId\r\n              ),\r\n              type: r.type,\r\n            })\r\n          )\r\n        )\r\n      : undefined;\r\n\r\n    const type = await this.typeRepo.findOne({\r\n      where: { id: createDto.typeId },\r\n    });\r\n    if (!type) throw new NotFoundException('Document Type not found');\r\n\r\n    let userOrgId = user.primaryOrganizationId;\r\n    if (!userOrgId) {\r\n      const fullUser = await this.userService.findOne(user.user_id);\r\n      if (fullUser) userOrgId = fullUser.primaryOrganizationId;\r\n    }\r\n\r\n    if (previewOriginatorId && previewOriginatorId !== userOrgId) {\r\n      // Allow impersonation for preview\r\n      userOrgId = previewOriginatorId;\r\n    }\r\n\r\n    // Extract recipient from recipients array\r\n    const toRecipient = previewRecipients?.find((r) => r.type === 'TO');\r\n    const recipientOrganizationId = toRecipient?.organizationId;\r\n\r\n    let recipientCode = '';\r\n    if (recipientOrganizationId) {\r\n      const recOrg = await this.dataSource.manager.findOne(Organization, {\r\n        where: { id: recipientOrganizationId },\r\n      });\r\n      if (recOrg) recipientCode = recOrg.organizationCode;\r\n    }\r\n\r\n    return this.numberingService.previewNumber({\r\n      projectId: previewProjectId,\r\n      originatorOrganizationId: userOrgId!,\r\n      typeId: createDto.typeId,\r\n      disciplineId: createDto.disciplineId,\r\n      subTypeId: createDto.subTypeId,\r\n      recipientOrganizationId,\r\n      year: new Date().getFullYear(),\r\n      customTokens: {\r\n        TYPE_CODE: type.typeCode,\r\n        RECIPIENT_CODE: recipientCode,\r\n        REC_CODE: recipientCode,\r\n      },\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Business Rule Implementation: EC-CORR-001 - Cancel Correspondence with Downstream Circulation\r\n   * Cancel correspondence and handle related circulations\r\n   */\r\n  async cancel(publicId: string, reason: string, user: User) {\r\n    const correspondence = await this.findOneByUuid(publicId);\r\n\r\n    // Check if user has permission to cancel (Org Admin or Superadmin only)\r\n    const permissions = await this.userService.getUserPermissions(user.user_id);\r\n    const canCancel =\r\n      permissions.includes('correspondence.cancel') ||\r\n      permissions.includes('system.manage_all');\r\n\r\n    if (!canCancel) {\r\n      throw new ForbiddenException(\r\n        'Only administrators can cancel correspondences'\r\n      );\r\n    }\r\n\r\n    // Check if there are any active circulations\r\n    const circulationRepo = this.dataSource.getRepository('Circulation');\r\n    const activeCirculations = await circulationRepo.find({\r\n      where: {\r\n        correspondenceId: correspondence.id,\r\n        status: 'OPEN',\r\n      },\r\n    });\r\n\r\n    const warningMessage =\r\n      activeCirculations.length > 0\r\n        ? `There are ${activeCirculations.length} active circulation(s) for this correspondence. Canceling will force close all related circulations.`\r\n        : '';\r\n\r\n    // Get the current revision to update status\r\n    const currentRevision = await this.revisionRepo.findOne({\r\n      where: {\r\n        correspondenceId: correspondence.id,\r\n        isCurrent: true,\r\n      },\r\n    });\r\n\r\n    if (!currentRevision) {\r\n      throw new NotFoundException('Current revision not found');\r\n    }\r\n\r\n    // Get cancelled status\r\n    const cancelledStatus = await this.statusRepo.findOne({\r\n      where: { statusCode: 'CANCELLED' },\r\n    });\r\n\r\n    if (!cancelledStatus) {\r\n      throw new InternalServerErrorException('CANCELLED status not found');\r\n    }\r\n\r\n    const queryRunner = this.dataSource.createQueryRunner();\r\n    await queryRunner.connect();\r\n    await queryRunner.startTransaction();\r\n\r\n    try {\r\n      // Update correspondence revision status to CANCELLED\r\n      await queryRunner.manager.update(\r\n        CorrespondenceRevision,\r\n        currentRevision.id,\r\n        {\r\n          statusId: cancelledStatus.id,\r\n          remarks: `Cancelled: ${reason}`,\r\n        }\r\n      );\r\n\r\n      // Force close all active circulations\r\n      if (activeCirculations.length > 0) {\r\n        await queryRunner.manager.update(\r\n          'Circulation',\r\n          {\r\n            correspondenceId: correspondence.id,\r\n            status: 'OPEN',\r\n          },\r\n          {\r\n            status: 'FORCE_CLOSED',\r\n            closedAt: new Date(),\r\n            closedBy: user.user_id,\r\n            closeReason: `Correspondence cancelled: ${reason}`,\r\n          }\r\n        );\r\n      }\r\n\r\n      await queryRunner.commitTransaction();\r\n\r\n      // Re-index cancelled status in Elasticsearch (fire-and-forget)\r\n      void this.searchService.indexDocument({\r\n        id: correspondence.id,\r\n        publicId: correspondence.publicId,\r\n        type: 'correspondence',\r\n        docNumber: correspondence.correspondenceNumber,\r\n        title: currentRevision.subject,\r\n        status: 'CANCELLED',\r\n        projectId: correspondence.projectId,\r\n        createdAt: correspondence.createdAt,\r\n      });\r\n\r\n      // Notify originator's doc-control user about cancellation (fire-and-forget)\r\n      if (correspondence.originatorId) {\r\n        void this.userService\r\n          .findDocControlIdByOrg(correspondence.originatorId)\r\n          .then((targetUserId) => {\r\n            if (targetUserId) {\r\n              void this.notificationService.send({\r\n                userId: targetUserId,\r\n                title: 'Correspondence Cancelled',\r\n                message: `${correspondence.correspondenceNumber} — ${currentRevision.subject} has been cancelled. Reason: ${reason}`,\r\n                type: 'EMAIL',\r\n                entityType: 'correspondence',\r\n                entityId: correspondence.id,\r\n                link: `/correspondences/${correspondence.publicId}`,\r\n              });\r\n            }\r\n          })\r\n          .catch((err: Error) =>\r\n            this.logger.warn(`Cancel notification failed: ${err.message}`)\r\n          );\r\n      }\r\n\r\n      return {\r\n        success: true,\r\n        message: warningMessage || 'Correspondence cancelled successfully',\r\n        activeCirculationsCount: activeCirculations.length,\r\n      };\r\n    } catch (error) {\r\n      await queryRunner.rollbackTransaction();\r\n      this.logger.error(\r\n        `Failed to cancel correspondence: ${(error as Error).message}`\r\n      );\r\n      throw error;\r\n    } finally {\r\n      await queryRunner.release();\r\n    }\r\n  }\r\n\r\n  async bulkCancel(\r\n    publicIds: string[],\r\n    reason: string,\r\n    user: User\r\n  ): Promise<{ succeeded: string[]; failed: string[] }> {\r\n    const succeeded: string[] = [];\r\n    const failed: string[] = [];\r\n\r\n    for (const publicId of publicIds) {\r\n      try {\r\n        await this.cancel(publicId, reason, user);\r\n        succeeded.push(publicId);\r\n      } catch {\r\n        failed.push(publicId);\r\n      }\r\n    }\r\n\r\n    return { succeeded, failed };\r\n  }\r\n\r\n  async exportCsv(searchDto: SearchCorrespondenceDto): Promise<string> {\r\n    const { data } = await this.findAll(searchDto);\r\n\r\n    const header = [\r\n      'Document No.',\r\n      'Rev',\r\n      'Subject',\r\n      'Type',\r\n      'Status',\r\n      'Project',\r\n      'From',\r\n      'Due Date',\r\n      'Created At',\r\n    ];\r\n    const rows = data.map((rev) => {\r\n      const corr = rev.correspondence ?? (rev as unknown as Correspondence);\r\n      return [\r\n        this.escapeCsv(corr.correspondenceNumber ?? ''),\r\n        this.escapeCsv(rev.revisionLabel ?? String(rev.revisionNumber ?? 0)),\r\n        this.escapeCsv(rev.subject ?? ''),\r\n        this.escapeCsv(corr.type?.typeCode ?? ''),\r\n        this.escapeCsv(rev.status?.statusCode ?? ''),\r\n        this.escapeCsv(corr.project?.projectCode ?? ''),\r\n        this.escapeCsv(corr.originator?.organizationCode ?? ''),\r\n        rev.dueDate ? new Date(rev.dueDate).toISOString().split('T')[0] : '',\r\n        new Date(rev.createdAt).toISOString().split('T')[0],\r\n      ].join(',');\r\n    });\r\n\r\n    return [header.join(','), ...rows].join('\\n');\r\n  }\r\n\r\n  private escapeCsv(value: string): string {\r\n    if (value.includes(',') || value.includes('\"') || value.includes('\\n')) {\r\n      return `\"${value.replace(/\"/g, '\"\"')}\"`;\r\n    }\r\n    return value;\r\n  }\r\n}\r\n"],"version":3} \ No newline at end of file diff --git a/backend/src/.jest-cache/jest-transform-cache-60cab15b743c6776f41d29bcac696b99-12533232bd0f05f65688e7a7764bf3fb/55/correspondenceservice_5585ce2f5626b5a93fd64e63909b087f.map b/backend/src/.jest-cache/jest-transform-cache-60cab15b743c6776f41d29bcac696b99-12533232bd0f05f65688e7a7764bf3fb/55/correspondenceservice_5585ce2f5626b5a93fd64e63909b087f.map new file mode 100644 index 0000000..1de2baa --- /dev/null +++ b/backend/src/.jest-cache/jest-transform-cache-60cab15b743c6776f41d29bcac696b99-12533232bd0f05f65688e7a7764bf3fb/55/correspondenceservice_5585ce2f5626b5a93fd64e63909b087f.map @@ -0,0 +1 @@ +{"file":"E:\\np-dms\\lcbp3\\backend\\src\\modules\\correspondence\\correspondence.service.ts","mappings":"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","names":[],"sources":["E:\\np-dms\\lcbp3\\backend\\src\\modules\\correspondence\\correspondence.service.ts"],"sourcesContent":["// File: src/modules/correspondence/correspondence.service.ts\r\n\r\nimport {\r\n Injectable,\r\n NotFoundException,\r\n BadRequestException,\r\n InternalServerErrorException,\r\n ForbiddenException,\r\n Logger,\r\n} from '@nestjs/common';\r\nimport { InjectRepository } from '@nestjs/typeorm';\r\nimport { Repository, DataSource } from 'typeorm';\r\n\r\n// Entities\r\nimport { Correspondence } from './entities/correspondence.entity';\r\nimport { CorrespondenceRevision } from './entities/correspondence-revision.entity';\r\nimport { CorrespondenceType } from './entities/correspondence-type.entity';\r\nimport { CorrespondenceStatus } from './entities/correspondence-status.entity';\r\nimport { CorrespondenceReference } from './entities/correspondence-reference.entity';\r\nimport { CorrespondenceRecipient } from './entities/correspondence-recipient.entity';\r\nimport { CorrespondenceTag } from './entities/correspondence-tag.entity';\r\nimport { Tag } from '../master/entities/tag.entity';\r\nimport { User } from '../user/entities/user.entity';\r\nimport { Organization } from '../organization/entities/organization.entity';\r\n\r\n// DTOs\r\nimport { CreateCorrespondenceDto } from './dto/create-correspondence.dto';\r\nimport { UpdateCorrespondenceDto } from './dto/update-correspondence.dto';\r\nimport { AddReferenceDto } from './dto/add-reference.dto';\r\nimport { SearchCorrespondenceDto } from './dto/search-correspondence.dto';\r\n\r\n// Services\r\nimport { DocumentNumberingService } from '../document-numbering/services/document-numbering.service';\r\nimport { JsonSchemaService } from '../json-schema/json-schema.service';\r\nimport { WorkflowEngineService } from '../workflow-engine/workflow-engine.service';\r\nimport { UserService } from '../user/user.service';\r\nimport { SearchService } from '../search/search.service';\r\nimport { FileStorageService } from '../../common/file-storage/file-storage.service';\r\nimport { UuidResolverService } from '../../common/services/uuid-resolver.service';\r\nimport { NotificationService } from '../notification/notification.service';\r\n\r\n/**\r\n * CorrespondenceService - Document management (CRUD)\r\n */\r\ninterface ResolvedRecipient {\r\n organizationId: number;\r\n type: 'TO' | 'CC';\r\n}\r\n@Injectable()\r\nexport class CorrespondenceService {\r\n private readonly logger = new Logger(CorrespondenceService.name);\r\n\r\n private async hasSystemManageAllPermission(userId: number): Promise {\r\n const permissions = await this.userService.getUserPermissions(userId);\r\n return permissions.includes('system.manage_all');\r\n }\r\n\r\n /**\r\n * Business Rule: Revision Label Strategy\r\n * - RFA, RFI: Use alphabet starting with 'A' (A, B, C...)\r\n * - Other types (LETTER, MEMO, etc.): Use numeric (null for first, then 1, 2, 3...)\r\n */\r\n private getInitialRevisionLabel(typeCode: string): string | null {\r\n const alphabetTypes = ['RFA', 'RFI'];\r\n if (alphabetTypes.includes(typeCode.toUpperCase())) {\r\n return 'A'; // Alphabet for RFA, RFI\r\n }\r\n return null; // Numeric (null for revision 0)\r\n }\r\n\r\n constructor(\r\n @InjectRepository(Correspondence)\r\n private correspondenceRepo: Repository,\r\n @InjectRepository(CorrespondenceRevision)\r\n private revisionRepo: Repository,\r\n @InjectRepository(CorrespondenceType)\r\n private typeRepo: Repository,\r\n @InjectRepository(CorrespondenceStatus)\r\n private statusRepo: Repository,\r\n @InjectRepository(CorrespondenceReference)\r\n private referenceRepo: Repository,\r\n @InjectRepository(CorrespondenceTag)\r\n private tagRepo: Repository,\r\n private numberingService: DocumentNumberingService,\r\n private jsonSchemaService: JsonSchemaService,\r\n private workflowEngine: WorkflowEngineService,\r\n private userService: UserService,\r\n private dataSource: DataSource,\r\n private searchService: SearchService,\r\n private fileStorageService: FileStorageService,\r\n private uuidResolver: UuidResolverService,\r\n private notificationService: NotificationService\r\n ) {}\r\n\r\n /**\r\n * Business Rule Validation: EC-CORR-003 - Correspondence to Self\r\n * Prevent external correspondence to same organization\r\n */\r\n private async validateCorrespondenceRecipients(\r\n createDto: CreateCorrespondenceDto,\r\n user: User\r\n ): Promise {\r\n // Get user's organization\r\n let userOrgId = user.primaryOrganizationId;\r\n if (!userOrgId) {\r\n const fullUser = await this.userService.findOne(user.user_id);\r\n if (fullUser) {\r\n userOrgId = fullUser.primaryOrganizationId;\r\n }\r\n }\r\n\r\n if (!userOrgId) {\r\n if (createDto.originatorId) {\r\n const canManageAll = await this.hasSystemManageAllPermission(\r\n user.user_id\r\n );\r\n if (canManageAll) {\r\n userOrgId = await this.uuidResolver.resolveOrganizationId(\r\n createDto.originatorId\r\n );\r\n }\r\n }\r\n\r\n if (!userOrgId) {\r\n throw new BadRequestException(\r\n 'User must belong to an organization to create documents'\r\n );\r\n }\r\n }\r\n\r\n // For impersonation, use the specified originator\r\n const originatorOrgId = createDto.originatorId\r\n ? await this.uuidResolver.resolveOrganizationId(createDto.originatorId)\r\n : userOrgId;\r\n\r\n // Check if it's internal communication\r\n if (createDto.isInternal) {\r\n // Internal communications should use Circulation instead\r\n throw new BadRequestException(\r\n 'Internal communications should use Circulation Sheet instead of Correspondence'\r\n );\r\n }\r\n\r\n // Validate recipients\r\n if (!createDto.recipients || createDto.recipients.length === 0) {\r\n throw new BadRequestException(\r\n 'At least one recipient (TO or CC) is required'\r\n );\r\n }\r\n\r\n const toRecipients = createDto.recipients.filter((r) => r.type === 'TO');\r\n const ccRecipients = createDto.recipients.filter((r) => r.type === 'CC');\r\n\r\n if (toRecipients.length === 0 && ccRecipients.length === 0) {\r\n throw new BadRequestException(\r\n 'At least one TO or CC recipient is required'\r\n );\r\n }\r\n\r\n // Check for same organization correspondence\r\n for (const recipient of createDto.recipients) {\r\n const recipientOrgId = await this.uuidResolver.resolveOrganizationId(\r\n recipient.organizationId\r\n );\r\n\r\n if (recipientOrgId === originatorOrgId) {\r\n throw new BadRequestException(\r\n 'Cannot send correspondence to your own organization. Use Circulation Sheet for internal communication.'\r\n );\r\n }\r\n }\r\n }\r\n\r\n async create(createDto: CreateCorrespondenceDto, user: User) {\r\n // Business Rule Validation: EC-CORR-003 - Correspondence to Self\r\n await this.validateCorrespondenceRecipients(createDto, user);\r\n // ADR-019: Resolve UUID references to internal INT IDs\r\n const resolvedProjectId = await this.uuidResolver.resolveProjectId(\r\n createDto.projectId\r\n );\r\n const resolvedOriginatorId = createDto.originatorId\r\n ? await this.uuidResolver.resolveOrganizationId(createDto.originatorId)\r\n : undefined;\r\n const resolvedRecipients = createDto.recipients\r\n ? await Promise.all(\r\n createDto.recipients.map(\r\n async (r): Promise => ({\r\n organizationId: await this.uuidResolver.resolveOrganizationId(\r\n r.organizationId\r\n ),\r\n type: r.type,\r\n })\r\n )\r\n )\r\n : undefined;\r\n const type = await this.typeRepo.findOne({\r\n where: { id: createDto.typeId },\r\n });\r\n if (!type) throw new NotFoundException('Document Type not found');\r\n\r\n const statusDraft = await this.statusRepo.findOne({\r\n where: { statusCode: 'DRAFT' },\r\n });\r\n if (!statusDraft) {\r\n throw new InternalServerErrorException(\r\n 'Status DRAFT not found in Master Data'\r\n );\r\n }\r\n\r\n let userOrgId = user.primaryOrganizationId;\r\n\r\n if (!userOrgId) {\r\n const fullUser = await this.userService.findOne(user.user_id);\r\n if (fullUser) {\r\n userOrgId = fullUser.primaryOrganizationId;\r\n }\r\n }\r\n\r\n // Impersonation Logic\r\n if (resolvedOriginatorId && resolvedOriginatorId !== userOrgId) {\r\n const canManageAll = await this.hasSystemManageAllPermission(\r\n user.user_id\r\n );\r\n if (!canManageAll) {\r\n throw new ForbiddenException(\r\n 'You do not have permission to create documents on behalf of other organizations.'\r\n );\r\n }\r\n userOrgId = resolvedOriginatorId;\r\n }\r\n\r\n if (!userOrgId) {\r\n throw new BadRequestException(\r\n 'User must belong to an organization to create documents'\r\n );\r\n }\r\n\r\n if (createDto.details) {\r\n try {\r\n await this.jsonSchemaService.validate(type.typeCode, createDto.details);\r\n } catch (error: unknown) {\r\n this.logger.warn(\r\n `Schema validation warning for ${type.typeCode}: ${(error as Error).message}`\r\n );\r\n }\r\n }\r\n\r\n const queryRunner = this.dataSource.createQueryRunner();\r\n await queryRunner.connect();\r\n await queryRunner.startTransaction();\r\n\r\n try {\r\n // [Fix #6] Fetch real ORG Code from Organization entity\r\n const originatorOrg = await this.dataSource.manager.findOne(\r\n Organization,\r\n {\r\n where: { id: userOrgId },\r\n }\r\n );\r\n const orgCode = originatorOrg?.organizationCode ?? 'UNK';\r\n\r\n // [v1.5.1] Extract recipient organization from recipients array (Primary TO)\r\n const toRecipient = resolvedRecipients?.find((r) => r.type === 'TO');\r\n const recipientOrganizationId = toRecipient?.organizationId;\r\n\r\n let recipientCode = '';\r\n if (recipientOrganizationId) {\r\n const recOrg = await this.dataSource.manager.findOne(Organization, {\r\n where: { id: recipientOrganizationId },\r\n });\r\n if (recOrg) recipientCode = recOrg.organizationCode;\r\n }\r\n\r\n const docNumber = await this.numberingService.generateNextNumber({\r\n projectId: resolvedProjectId,\r\n originatorOrganizationId: userOrgId,\r\n typeId: createDto.typeId,\r\n disciplineId: createDto.disciplineId,\r\n subTypeId: createDto.subTypeId,\r\n recipientOrganizationId, // [v1.5.1] Pass recipient for document number format\r\n year: new Date().getFullYear(),\r\n customTokens: {\r\n TYPE_CODE: type.typeCode,\r\n ORG_CODE: orgCode,\r\n RECIPIENT_CODE: recipientCode,\r\n REC_CODE: recipientCode,\r\n },\r\n });\r\n\r\n const correspondence = queryRunner.manager.create(Correspondence, {\r\n correspondenceNumber: docNumber.number,\r\n correspondenceTypeId: createDto.typeId,\r\n disciplineId: createDto.disciplineId,\r\n projectId: resolvedProjectId,\r\n originatorId: userOrgId,\r\n isInternal: createDto.isInternal || false,\r\n createdBy: user.user_id,\r\n });\r\n const savedCorr = await queryRunner.manager.save(correspondence);\r\n\r\n const revision = queryRunner.manager.create(CorrespondenceRevision, {\r\n correspondenceId: savedCorr.id,\r\n revisionNumber: 0,\r\n revisionLabel: this.getInitialRevisionLabel(type.typeCode),\r\n isCurrent: true,\r\n statusId: statusDraft.id,\r\n subject: createDto.subject,\r\n body: createDto.body,\r\n remarks: createDto.remarks,\r\n dueDate: createDto.dueDate ? new Date(createDto.dueDate) : undefined,\r\n documentDate: createDto.documentDate\r\n ? new Date(createDto.documentDate)\r\n : undefined,\r\n issuedDate: createDto.issuedDate\r\n ? new Date(createDto.issuedDate)\r\n : undefined,\r\n receivedDate: createDto.receivedDate\r\n ? new Date(createDto.receivedDate)\r\n : undefined,\r\n description: createDto.description,\r\n details: createDto.details,\r\n createdBy: user.user_id,\r\n schemaVersion: 1,\r\n });\r\n await queryRunner.manager.save(revision);\r\n\r\n // Save Recipients (using resolved INT IDs)\r\n if (resolvedRecipients && resolvedRecipients.length > 0) {\r\n const recipients = resolvedRecipients.map((r) =>\r\n queryRunner.manager.create(CorrespondenceRecipient, {\r\n correspondenceId: savedCorr.id,\r\n recipientOrganizationId: r.organizationId,\r\n recipientType: r.type,\r\n })\r\n );\r\n await queryRunner.manager.save(recipients);\r\n }\r\n\r\n // Commit attachments from Temp → Permanent (Two-Phase Storage)\r\n if (createDto.attachmentTempIds?.length) {\r\n const issueDate = createDto.issuedDate\r\n ? new Date(createDto.issuedDate)\r\n : createDto.documentDate\r\n ? new Date(createDto.documentDate)\r\n : undefined;\r\n\r\n await this.fileStorageService.commit(createDto.attachmentTempIds, {\r\n issueDate,\r\n documentType: 'Correspondence',\r\n });\r\n }\r\n\r\n await queryRunner.commitTransaction();\r\n\r\n // Start Workflow Instance (non-blocking)\r\n try {\r\n const workflowCode = `CORRESPONDENCE_${type.typeCode}`;\r\n await this.workflowEngine.createInstance(\r\n workflowCode,\r\n 'correspondence',\r\n savedCorr.id.toString(),\r\n {\r\n projectId: resolvedProjectId,\r\n originatorId: userOrgId,\r\n disciplineId: createDto.disciplineId,\r\n initiatorId: user.user_id,\r\n } as Record\r\n );\r\n } catch (error: unknown) {\r\n this.logger.warn(\r\n `Workflow not started for ${docNumber.number} (Code: CORRESPONDENCE_${type.typeCode}): ${(error as Error).message}`\r\n );\r\n }\r\n\r\n // Fire-and-forget search indexing (non-blocking, void intentional)\r\n void this.searchService.indexDocument({\r\n id: savedCorr.id,\r\n publicId: savedCorr.publicId,\r\n type: 'correspondence',\r\n docNumber: docNumber.number,\r\n title: createDto.subject,\r\n description: createDto.description,\r\n status: 'DRAFT',\r\n projectId: resolvedProjectId,\r\n createdAt: new Date(),\r\n });\r\n\r\n return {\r\n ...savedCorr,\r\n currentRevision: revision,\r\n };\r\n } catch (err) {\r\n await queryRunner.rollbackTransaction();\r\n this.logger.error(\r\n `Failed to create correspondence: ${(err as Error).message}`\r\n );\r\n throw err;\r\n } finally {\r\n await queryRunner.release();\r\n }\r\n }\r\n\r\n async findAll(searchDto: SearchCorrespondenceDto = {}) {\r\n const {\r\n search,\r\n typeId,\r\n projectId,\r\n statusId,\r\n status,\r\n page = 1,\r\n limit = 10,\r\n } = searchDto;\r\n const skip = (page - 1) * limit;\r\n\r\n // Change: Query from Revision Repo\r\n const query = this.revisionRepo\r\n .createQueryBuilder('rev')\r\n .leftJoinAndSelect('rev.correspondence', 'corr')\r\n .leftJoinAndSelect('corr.type', 'type')\r\n .leftJoinAndSelect('corr.project', 'project')\r\n .leftJoinAndSelect('corr.originator', 'org')\r\n .leftJoinAndSelect('rev.status', 'status');\r\n\r\n // Filter by Revision Status\r\n const revStatus = searchDto.revisionStatus || 'CURRENT';\r\n\r\n if (revStatus === 'CURRENT') {\r\n query.where('rev.isCurrent = :isCurrent', { isCurrent: true });\r\n } else if (revStatus === 'OLD') {\r\n query.where('rev.isCurrent = :isCurrent', { isCurrent: false });\r\n }\r\n // If 'ALL', no filter needed on isCurrent\r\n\r\n if (projectId) {\r\n query.andWhere('corr.projectId = :projectId', { projectId });\r\n }\r\n\r\n if (typeId) {\r\n query.andWhere('corr.correspondenceTypeId = :typeId', { typeId });\r\n }\r\n\r\n if (statusId) {\r\n query.andWhere('rev.statusId = :statusId', { statusId });\r\n }\r\n\r\n if (status) {\r\n query.andWhere('status.statusCode = :status', { status });\r\n }\r\n\r\n if (search) {\r\n query.andWhere(\r\n '(corr.correspondenceNumber LIKE :search OR rev.subject LIKE :search)',\r\n { search: `%${search}%` }\r\n );\r\n }\r\n\r\n // Default Sort: Latest Created\r\n query.orderBy('rev.createdAt', 'DESC').skip(skip).take(limit);\r\n\r\n const [items, total] = await query.getManyAndCount();\r\n\r\n return {\r\n data: items,\r\n meta: {\r\n total,\r\n page,\r\n limit,\r\n totalPages: Math.ceil(total / limit),\r\n },\r\n };\r\n }\r\n\r\n async findOne(id: number) {\r\n const correspondence = await this.correspondenceRepo.findOne({\r\n where: { id },\r\n relations: [\r\n 'revisions',\r\n 'revisions.status',\r\n 'type',\r\n 'project',\r\n 'originator',\r\n 'recipients',\r\n 'recipients.recipientOrganization', // [v1.5.1] Fixed relation name\r\n ],\r\n });\r\n\r\n if (!correspondence) {\r\n throw new NotFoundException(`Correspondence with ID ${id} not found`);\r\n }\r\n return correspondence;\r\n }\r\n\r\n async findOneByUuid(publicId: string) {\r\n const correspondence = await this.correspondenceRepo.findOne({\r\n where: { publicId },\r\n relations: [\r\n 'revisions',\r\n 'revisions.status',\r\n 'type',\r\n 'project',\r\n 'originator',\r\n 'recipients',\r\n 'recipients.recipientOrganization',\r\n ],\r\n });\r\n\r\n if (!correspondence) {\r\n throw new NotFoundException(\r\n `Correspondence with UUID ${publicId} not found`\r\n );\r\n }\r\n return correspondence;\r\n }\r\n\r\n async addReference(id: number, dto: AddReferenceDto) {\r\n const source = await this.correspondenceRepo.findOne({ where: { id } });\r\n // ADR-019: Resolve target publicId → internal INT id\r\n const target = await this.correspondenceRepo.findOne({\r\n where: { publicId: dto.targetUuid },\r\n });\r\n\r\n if (!source || !target) {\r\n throw new NotFoundException('Source or Target correspondence not found');\r\n }\r\n\r\n if (source.id === target.id) {\r\n throw new BadRequestException('Cannot reference self');\r\n }\r\n\r\n const exists = await this.referenceRepo.findOne({\r\n where: {\r\n sourceId: id,\r\n targetId: target.id,\r\n },\r\n });\r\n\r\n if (exists) {\r\n return exists;\r\n }\r\n\r\n const ref = this.referenceRepo.create({\r\n sourceId: id,\r\n targetId: target.id,\r\n });\r\n\r\n return this.referenceRepo.save(ref);\r\n }\r\n\r\n async removeReference(id: number, targetId: number) {\r\n const result = await this.referenceRepo.delete({\r\n sourceId: id,\r\n targetId: targetId,\r\n });\r\n\r\n if (result.affected === 0) {\r\n throw new NotFoundException('Reference not found');\r\n }\r\n }\r\n\r\n async getTags(id: number) {\r\n const rows = await this.tagRepo.find({\r\n where: { correspondenceId: id },\r\n relations: ['tag'],\r\n });\r\n return rows.map((r) => r.tag).filter(Boolean);\r\n }\r\n\r\n async addTag(id: number, tagId: number) {\r\n const correspondence = await this.correspondenceRepo.findOne({\r\n where: { id },\r\n });\r\n if (!correspondence) {\r\n throw new NotFoundException(`Correspondence ${id} not found`);\r\n }\r\n\r\n const tag = await this.dataSource.manager.findOne(Tag, {\r\n where: { id: tagId },\r\n });\r\n if (!tag) {\r\n throw new NotFoundException(`Tag ${tagId} not found`);\r\n }\r\n\r\n const exists = await this.tagRepo.findOne({\r\n where: { correspondenceId: id, tagId },\r\n });\r\n if (exists) return exists;\r\n\r\n const row = this.tagRepo.create({ correspondenceId: id, tagId });\r\n return this.tagRepo.save(row);\r\n }\r\n\r\n async removeTag(id: number, tagId: number) {\r\n const result = await this.tagRepo.delete({ correspondenceId: id, tagId });\r\n if (result.affected === 0) {\r\n throw new NotFoundException('Tag assignment not found');\r\n }\r\n }\r\n\r\n async getReferences(id: number) {\r\n const outgoing = await this.referenceRepo.find({\r\n where: { sourceId: id },\r\n relations: ['target', 'target.type'],\r\n });\r\n\r\n const incoming = await this.referenceRepo.find({\r\n where: { targetId: id },\r\n relations: ['source', 'source.type'],\r\n });\r\n\r\n return { outgoing, incoming };\r\n }\r\n\r\n async update(id: number, updateDto: UpdateCorrespondenceDto, user: User) {\r\n // 1. Find Current Revision\r\n const revision = await this.revisionRepo.findOne({\r\n where: {\r\n correspondenceId: id,\r\n isCurrent: true,\r\n },\r\n relations: ['correspondence'],\r\n });\r\n\r\n if (!revision) {\r\n throw new NotFoundException(\r\n `Current revision for correspondence ${id} not found`\r\n );\r\n }\r\n\r\n // 2. Check Permission\r\n if (revision.statusId) {\r\n const status = await this.statusRepo.findOne({\r\n where: { id: revision.statusId },\r\n });\r\n if (status && status.statusCode !== 'DRAFT') {\r\n throw new BadRequestException('Only DRAFT documents can be updated');\r\n }\r\n }\r\n\r\n // ADR-019: Resolve UUID references in update DTO\r\n const updResolvedProjectId = updateDto.projectId\r\n ? await this.uuidResolver.resolveProjectId(updateDto.projectId)\r\n : undefined;\r\n const updResolvedOriginatorId = updateDto.originatorId\r\n ? await this.uuidResolver.resolveOrganizationId(updateDto.originatorId)\r\n : undefined;\r\n const updResolvedRecipients = updateDto.recipients\r\n ? await Promise.all(\r\n updateDto.recipients.map(\r\n async (r): Promise => ({\r\n organizationId: await this.uuidResolver.resolveOrganizationId(\r\n r.organizationId\r\n ),\r\n type: r.type,\r\n })\r\n )\r\n )\r\n : undefined;\r\n\r\n // 3. Update Correspondence Entity if needed\r\n const correspondenceUpdate: Record = {};\r\n if (updateDto.disciplineId)\r\n correspondenceUpdate.disciplineId = updateDto.disciplineId;\r\n if (updResolvedProjectId)\r\n correspondenceUpdate.projectId = updResolvedProjectId;\r\n if (updResolvedOriginatorId)\r\n correspondenceUpdate.originatorId = updResolvedOriginatorId;\r\n\r\n if (Object.keys(correspondenceUpdate).length > 0) {\r\n await this.correspondenceRepo.update(id, correspondenceUpdate);\r\n }\r\n\r\n // 4. Update Revision Entity\r\n const revisionUpdate: Record = {};\r\n if (updateDto.subject) revisionUpdate.subject = updateDto.subject;\r\n if (updateDto.body) revisionUpdate.body = updateDto.body;\r\n if (updateDto.remarks) revisionUpdate.remarks = updateDto.remarks;\r\n // Format Date correctly if string\r\n if (updateDto.dueDate) revisionUpdate.dueDate = new Date(updateDto.dueDate);\r\n if (updateDto.documentDate)\r\n revisionUpdate.documentDate = new Date(updateDto.documentDate);\r\n if (updateDto.issuedDate)\r\n revisionUpdate.issuedDate = new Date(updateDto.issuedDate);\r\n if (updateDto.receivedDate)\r\n revisionUpdate.receivedDate = new Date(updateDto.receivedDate);\r\n if (updateDto.description)\r\n revisionUpdate.description = updateDto.description;\r\n if (updateDto.details) revisionUpdate.details = updateDto.details;\r\n\r\n if (Object.keys(revisionUpdate).length > 0) {\r\n await this.revisionRepo.update(revision.id, revisionUpdate);\r\n }\r\n\r\n // 4.5 Commit new attachments from Temp → Permanent (Two-Phase Storage)\r\n if (updateDto.attachmentTempIds?.length) {\r\n const issueDate = updateDto.issuedDate\r\n ? new Date(updateDto.issuedDate)\r\n : updateDto.documentDate\r\n ? new Date(updateDto.documentDate)\r\n : revision.issuedDate || revision.documentDate || undefined;\r\n\r\n await this.fileStorageService.commit(updateDto.attachmentTempIds, {\r\n issueDate: issueDate ? new Date(issueDate) : undefined,\r\n documentType: 'Correspondence',\r\n });\r\n }\r\n\r\n // 5. Update Recipients if provided\r\n if (updResolvedRecipients) {\r\n const recipientRepo = this.dataSource.getRepository(\r\n CorrespondenceRecipient\r\n );\r\n await recipientRepo.delete({ correspondenceId: id });\r\n\r\n const newRecipients = updResolvedRecipients.map((r) =>\r\n recipientRepo.create({\r\n correspondenceId: id,\r\n recipientOrganizationId: r.organizationId,\r\n recipientType: r.type,\r\n })\r\n );\r\n await recipientRepo.save(newRecipients);\r\n }\r\n\r\n // 6. Regenerate Document Number if structural fields changed (Recipient, Discipline, Type, Project)\r\n // AND it is a DRAFT.\r\n\r\n // Fetch fresh data for context and comparison\r\n const currentCorr = await this.correspondenceRepo.findOne({\r\n where: { id },\r\n relations: ['type', 'recipients', 'recipients.recipientOrganization'],\r\n });\r\n\r\n if (currentCorr) {\r\n const currentToRecipient = currentCorr.recipients?.find(\r\n (r) => r.recipientType === 'TO'\r\n );\r\n const currentRecipientId = currentToRecipient?.recipientOrganizationId;\r\n\r\n // Check for ACTUAL value changes\r\n const isProjectChanged =\r\n updResolvedProjectId !== undefined &&\r\n updResolvedProjectId !== currentCorr.projectId;\r\n const isOriginatorChanged =\r\n updResolvedOriginatorId !== undefined &&\r\n updResolvedOriginatorId !== currentCorr.originatorId;\r\n const isDisciplineChanged =\r\n updateDto.disciplineId !== undefined &&\r\n updateDto.disciplineId !== currentCorr.disciplineId;\r\n const isTypeChanged =\r\n updateDto.typeId !== undefined &&\r\n updateDto.typeId !== currentCorr.correspondenceTypeId;\r\n\r\n let isRecipientChanged = false;\r\n let newRecipientId: number | undefined;\r\n\r\n if (updResolvedRecipients) {\r\n const newToRecipient = updResolvedRecipients.find(\r\n (r) => r.type === 'TO'\r\n );\r\n newRecipientId = newToRecipient?.organizationId;\r\n\r\n if (newRecipientId !== currentRecipientId) {\r\n isRecipientChanged = true;\r\n }\r\n }\r\n\r\n if (\r\n isProjectChanged ||\r\n isDisciplineChanged ||\r\n isTypeChanged ||\r\n isRecipientChanged ||\r\n isOriginatorChanged\r\n ) {\r\n const targetRecipientId = isRecipientChanged\r\n ? newRecipientId\r\n : currentRecipientId;\r\n\r\n // Resolve Recipient Code for the NEW context\r\n let recipientCode = '';\r\n if (targetRecipientId) {\r\n const recOrg = await this.dataSource.manager.findOne(Organization, {\r\n where: { id: targetRecipientId },\r\n });\r\n if (recOrg) recipientCode = recOrg.organizationCode;\r\n }\r\n\r\n // [Fix #6] Fetch real ORG Code from originator organization\r\n const originatorOrgForUpdate = await this.dataSource.manager.findOne(\r\n Organization,\r\n {\r\n where: {\r\n id: updResolvedOriginatorId ?? currentCorr.originatorId ?? 0,\r\n },\r\n }\r\n );\r\n const orgCode = originatorOrgForUpdate?.organizationCode ?? 'UNK';\r\n\r\n // Prepare Contexts\r\n const oldCtx = {\r\n projectId: currentCorr.projectId,\r\n originatorOrganizationId: currentCorr.originatorId ?? 0,\r\n typeId: currentCorr.correspondenceTypeId,\r\n disciplineId: currentCorr.disciplineId,\r\n recipientOrganizationId: currentRecipientId,\r\n year: new Date().getFullYear(),\r\n };\r\n\r\n const newCtx = {\r\n projectId: updResolvedProjectId ?? currentCorr.projectId,\r\n originatorOrganizationId:\r\n updResolvedOriginatorId ?? currentCorr.originatorId ?? 0,\r\n typeId: updateDto.typeId ?? currentCorr.correspondenceTypeId,\r\n disciplineId: updateDto.disciplineId ?? currentCorr.disciplineId,\r\n recipientOrganizationId: targetRecipientId,\r\n year: new Date().getFullYear(),\r\n userId: user.user_id, // Pass User ID for Audit\r\n customTokens: {\r\n TYPE_CODE: currentCorr.type?.typeCode || '',\r\n ORG_CODE: orgCode,\r\n RECIPIENT_CODE: recipientCode,\r\n REC_CODE: recipientCode,\r\n },\r\n };\r\n\r\n // If Type Changed, need NEW Type Code\r\n if (isTypeChanged) {\r\n const newType = await this.typeRepo.findOne({\r\n where: { id: newCtx.typeId },\r\n });\r\n if (newType) newCtx.customTokens.TYPE_CODE = newType.typeCode;\r\n }\r\n\r\n const newDocNumber = await this.numberingService.updateNumberForDraft(\r\n currentCorr.correspondenceNumber,\r\n oldCtx,\r\n newCtx\r\n );\r\n\r\n await this.correspondenceRepo.update(id, {\r\n correspondenceNumber: newDocNumber,\r\n });\r\n }\r\n }\r\n\r\n const updated = await this.findOne(id);\r\n\r\n // Re-index updated document in Elasticsearch (fire-and-forget)\r\n void this.searchService.indexDocument({\r\n id: updated.id,\r\n publicId: updated.publicId,\r\n type: 'correspondence',\r\n docNumber: updated.correspondenceNumber,\r\n title: updateDto.subject ?? updated.revisions?.[0]?.subject,\r\n description: updateDto.description ?? updated.revisions?.[0]?.description,\r\n status: 'DRAFT',\r\n projectId: updated.projectId,\r\n createdAt: updated.createdAt,\r\n });\r\n\r\n return updated;\r\n }\r\n\r\n async previewDocumentNumber(createDto: CreateCorrespondenceDto, user: User) {\r\n // ADR-019: Resolve UUID references\r\n const previewProjectId = await this.uuidResolver.resolveProjectId(\r\n createDto.projectId\r\n );\r\n const previewOriginatorId = createDto.originatorId\r\n ? await this.uuidResolver.resolveOrganizationId(createDto.originatorId)\r\n : undefined;\r\n const previewRecipients = createDto.recipients\r\n ? await Promise.all(\r\n createDto.recipients.map(\r\n async (r): Promise => ({\r\n organizationId: await this.uuidResolver.resolveOrganizationId(\r\n r.organizationId\r\n ),\r\n type: r.type,\r\n })\r\n )\r\n )\r\n : undefined;\r\n\r\n const type = await this.typeRepo.findOne({\r\n where: { id: createDto.typeId },\r\n });\r\n if (!type) throw new NotFoundException('Document Type not found');\r\n\r\n let userOrgId = user.primaryOrganizationId;\r\n if (!userOrgId) {\r\n const fullUser = await this.userService.findOne(user.user_id);\r\n if (fullUser) userOrgId = fullUser.primaryOrganizationId;\r\n }\r\n\r\n if (previewOriginatorId && previewOriginatorId !== userOrgId) {\r\n // Allow impersonation for preview\r\n userOrgId = previewOriginatorId;\r\n }\r\n\r\n // Extract recipient from recipients array\r\n const toRecipient = previewRecipients?.find((r) => r.type === 'TO');\r\n const recipientOrganizationId = toRecipient?.organizationId;\r\n\r\n let recipientCode = '';\r\n if (recipientOrganizationId) {\r\n const recOrg = await this.dataSource.manager.findOne(Organization, {\r\n where: { id: recipientOrganizationId },\r\n });\r\n if (recOrg) recipientCode = recOrg.organizationCode;\r\n }\r\n\r\n return this.numberingService.previewNumber({\r\n projectId: previewProjectId,\r\n originatorOrganizationId: userOrgId!,\r\n typeId: createDto.typeId,\r\n disciplineId: createDto.disciplineId,\r\n subTypeId: createDto.subTypeId,\r\n recipientOrganizationId,\r\n year: new Date().getFullYear(),\r\n customTokens: {\r\n TYPE_CODE: type.typeCode,\r\n RECIPIENT_CODE: recipientCode,\r\n REC_CODE: recipientCode,\r\n },\r\n });\r\n }\r\n\r\n /**\r\n * Business Rule Implementation: EC-CORR-001 - Cancel Correspondence with Downstream Circulation\r\n * Cancel correspondence and handle related circulations\r\n */\r\n async cancel(publicId: string, reason: string, user: User) {\r\n const correspondence = await this.findOneByUuid(publicId);\r\n\r\n // Check if user has permission to cancel (Org Admin or Superadmin only)\r\n const permissions = await this.userService.getUserPermissions(user.user_id);\r\n const canCancel =\r\n permissions.includes('correspondence.cancel') ||\r\n permissions.includes('system.manage_all');\r\n\r\n if (!canCancel) {\r\n throw new ForbiddenException(\r\n 'Only administrators can cancel correspondences'\r\n );\r\n }\r\n\r\n // Check if there are any active circulations\r\n const circulationRepo = this.dataSource.getRepository('Circulation');\r\n const activeCirculations = await circulationRepo.find({\r\n where: {\r\n correspondenceId: correspondence.id,\r\n status: 'OPEN',\r\n },\r\n });\r\n\r\n const warningMessage =\r\n activeCirculations.length > 0\r\n ? `There are ${activeCirculations.length} active circulation(s) for this correspondence. Canceling will force close all related circulations.`\r\n : '';\r\n\r\n // Get the current revision to update status\r\n const currentRevision = await this.revisionRepo.findOne({\r\n where: {\r\n correspondenceId: correspondence.id,\r\n isCurrent: true,\r\n },\r\n });\r\n\r\n if (!currentRevision) {\r\n throw new NotFoundException('Current revision not found');\r\n }\r\n\r\n // Get cancelled status\r\n const cancelledStatus = await this.statusRepo.findOne({\r\n where: { statusCode: 'CANCELLED' },\r\n });\r\n\r\n if (!cancelledStatus) {\r\n throw new InternalServerErrorException('CANCELLED status not found');\r\n }\r\n\r\n const queryRunner = this.dataSource.createQueryRunner();\r\n await queryRunner.connect();\r\n await queryRunner.startTransaction();\r\n\r\n try {\r\n // Update correspondence revision status to CANCELLED\r\n await queryRunner.manager.update(\r\n CorrespondenceRevision,\r\n currentRevision.id,\r\n {\r\n statusId: cancelledStatus.id,\r\n remarks: `Cancelled: ${reason}`,\r\n }\r\n );\r\n\r\n // Force close all active circulations\r\n if (activeCirculations.length > 0) {\r\n await queryRunner.manager.update(\r\n 'Circulation',\r\n {\r\n correspondenceId: correspondence.id,\r\n status: 'OPEN',\r\n },\r\n {\r\n status: 'FORCE_CLOSED',\r\n closedAt: new Date(),\r\n closedBy: user.user_id,\r\n closeReason: `Correspondence cancelled: ${reason}`,\r\n }\r\n );\r\n }\r\n\r\n await queryRunner.commitTransaction();\r\n\r\n // Re-index cancelled status in Elasticsearch (fire-and-forget)\r\n void this.searchService.indexDocument({\r\n id: correspondence.id,\r\n publicId: correspondence.publicId,\r\n type: 'correspondence',\r\n docNumber: correspondence.correspondenceNumber,\r\n title: currentRevision.subject,\r\n status: 'CANCELLED',\r\n projectId: correspondence.projectId,\r\n createdAt: correspondence.createdAt,\r\n });\r\n\r\n // Notify originator's doc-control user about cancellation (fire-and-forget)\r\n if (correspondence.originatorId) {\r\n void this.userService\r\n .findDocControlIdByOrg(correspondence.originatorId)\r\n .then((targetUserId) => {\r\n if (targetUserId) {\r\n void this.notificationService.send({\r\n userId: targetUserId,\r\n title: 'Correspondence Cancelled',\r\n message: `${correspondence.correspondenceNumber} — ${currentRevision.subject} has been cancelled. Reason: ${reason}`,\r\n type: 'EMAIL',\r\n entityType: 'correspondence',\r\n entityId: correspondence.id,\r\n link: `/correspondences/${correspondence.publicId}`,\r\n });\r\n }\r\n })\r\n .catch((err: Error) =>\r\n this.logger.warn(`Cancel notification failed: ${err.message}`)\r\n );\r\n }\r\n\r\n return {\r\n success: true,\r\n message: warningMessage || 'Correspondence cancelled successfully',\r\n activeCirculationsCount: activeCirculations.length,\r\n };\r\n } catch (error) {\r\n await queryRunner.rollbackTransaction();\r\n this.logger.error(\r\n `Failed to cancel correspondence: ${(error as Error).message}`\r\n );\r\n throw error;\r\n } finally {\r\n await queryRunner.release();\r\n }\r\n }\r\n\r\n async bulkCancel(\r\n publicIds: string[],\r\n reason: string,\r\n user: User\r\n ): Promise<{ succeeded: string[]; failed: string[] }> {\r\n const succeeded: string[] = [];\r\n const failed: string[] = [];\r\n\r\n for (const publicId of publicIds) {\r\n try {\r\n await this.cancel(publicId, reason, user);\r\n succeeded.push(publicId);\r\n } catch {\r\n failed.push(publicId);\r\n }\r\n }\r\n\r\n return { succeeded, failed };\r\n }\r\n\r\n async exportCsv(searchDto: SearchCorrespondenceDto): Promise {\r\n const { data } = await this.findAll(searchDto);\r\n\r\n const header = [\r\n 'Document No.',\r\n 'Rev',\r\n 'Subject',\r\n 'Type',\r\n 'Status',\r\n 'Project',\r\n 'From',\r\n 'Due Date',\r\n 'Created At',\r\n ];\r\n const rows = data.map((rev) => {\r\n const corr = rev.correspondence ?? (rev as unknown as Correspondence);\r\n return [\r\n this.escapeCsv(corr.correspondenceNumber ?? ''),\r\n this.escapeCsv(rev.revisionLabel ?? String(rev.revisionNumber ?? 0)),\r\n this.escapeCsv(rev.subject ?? ''),\r\n this.escapeCsv(corr.type?.typeCode ?? ''),\r\n this.escapeCsv(rev.status?.statusCode ?? ''),\r\n this.escapeCsv(corr.project?.projectCode ?? ''),\r\n this.escapeCsv(corr.originator?.organizationCode ?? ''),\r\n rev.dueDate ? new Date(rev.dueDate).toISOString().split('T')[0] : '',\r\n new Date(rev.createdAt).toISOString().split('T')[0],\r\n ].join(',');\r\n });\r\n\r\n return [header.join(','), ...rows].join('\\n');\r\n }\r\n\r\n private escapeCsv(value: string): string {\r\n if (value.includes(',') || value.includes('\"') || value.includes('\\n')) {\r\n return `\"${value.replace(/\"/g, '\"\"')}\"`;\r\n }\r\n return value;\r\n }\r\n}\r\n"],"version":3} \ No newline at end of file diff --git a/backend/src/.jest-cache/jest-transform-cache-60cab15b743c6776f41d29bcac696b99-12533232bd0f05f65688e7a7764bf3fb/6e/correspondenceservicespec_6e17e53289c744ad0b09ce4420c50e0e b/backend/src/.jest-cache/jest-transform-cache-60cab15b743c6776f41d29bcac696b99-12533232bd0f05f65688e7a7764bf3fb/6e/correspondenceservicespec_6e17e53289c744ad0b09ce4420c50e0e new file mode 100644 index 0000000..4ad2f15 --- /dev/null +++ b/backend/src/.jest-cache/jest-transform-cache-60cab15b743c6776f41d29bcac696b99-12533232bd0f05f65688e7a7764bf3fb/6e/correspondenceservicespec_6e17e53289c744ad0b09ce4420c50e0e @@ -0,0 +1,561 @@ +418931856593ad4d29dae51441c354ab +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const testing_1 = require("@nestjs/testing"); +const typeorm_1 = require("@nestjs/typeorm"); +const typeorm_2 = require("typeorm"); +const correspondence_service_1 = require("./correspondence.service"); +const correspondence_entity_1 = require("./entities/correspondence.entity"); +const correspondence_revision_entity_1 = require("./entities/correspondence-revision.entity"); +const correspondence_type_entity_1 = require("./entities/correspondence-type.entity"); +const correspondence_status_entity_1 = require("./entities/correspondence-status.entity"); +const correspondence_reference_entity_1 = require("./entities/correspondence-reference.entity"); +const correspondence_tag_entity_1 = require("./entities/correspondence-tag.entity"); +const organization_entity_1 = require("../organization/entities/organization.entity"); +const correspondence_recipient_entity_1 = require("./entities/correspondence-recipient.entity"); +const document_numbering_service_1 = require("../document-numbering/services/document-numbering.service"); +const json_schema_service_1 = require("../json-schema/json-schema.service"); +const workflow_engine_service_1 = require("../workflow-engine/workflow-engine.service"); +const user_service_1 = require("../user/user.service"); +const search_service_1 = require("../search/search.service"); +const file_storage_service_1 = require("../../common/file-storage/file-storage.service"); +const uuid_resolver_service_1 = require("../../common/services/uuid-resolver.service"); +const notification_service_1 = require("../notification/notification.service"); +describe('CorrespondenceService', () => { + let service; + let numberingService; + let correspondenceRepo; + let revisionRepo; + let testingModule; + let _dataSource; + const createMockRepository = () => ({ + find: jest.fn(), + findOne: jest.fn(), + create: jest.fn(), + save: jest.fn(), + update: jest.fn(), + delete: jest.fn(), + softDelete: jest.fn(), + createQueryBuilder: jest.fn(() => ({ + leftJoinAndSelect: jest.fn().mockReturnThis(), + where: jest.fn().mockReturnThis(), + andWhere: jest.fn().mockReturnThis(), + orderBy: jest.fn().mockReturnThis(), + skip: jest.fn().mockReturnThis(), + take: jest.fn().mockReturnThis(), + getOne: jest.fn().mockResolvedValue(null), + getMany: jest.fn().mockResolvedValue([]), + getManyAndCount: jest.fn().mockResolvedValue([[], 0]), + })), + }); + const mockDataSource = { + createQueryRunner: jest.fn(() => ({ + connect: jest.fn(), + startTransaction: jest.fn(), + commitTransaction: jest.fn(), + rollbackTransaction: jest.fn(), + release: jest.fn(), + manager: { + create: jest.fn(), + save: jest.fn(), + findOne: jest.fn(), + }, + })), + getRepository: jest.fn(() => createMockRepository()), + manager: { + findOne: jest.fn(), + }, + }; + beforeEach(async () => { + testingModule = await testing_1.Test.createTestingModule({ + providers: [ + correspondence_service_1.CorrespondenceService, + { + provide: (0, typeorm_1.getRepositoryToken)(correspondence_entity_1.Correspondence), + useValue: createMockRepository(), + }, + { + provide: (0, typeorm_1.getRepositoryToken)(correspondence_revision_entity_1.CorrespondenceRevision), + useValue: createMockRepository(), + }, + { + provide: (0, typeorm_1.getRepositoryToken)(correspondence_type_entity_1.CorrespondenceType), + useValue: createMockRepository(), + }, + { + provide: (0, typeorm_1.getRepositoryToken)(correspondence_status_entity_1.CorrespondenceStatus), + useValue: createMockRepository(), + }, + { + provide: (0, typeorm_1.getRepositoryToken)(correspondence_reference_entity_1.CorrespondenceReference), + useValue: createMockRepository(), + }, + { + provide: (0, typeorm_1.getRepositoryToken)(correspondence_tag_entity_1.CorrespondenceTag), + useValue: createMockRepository(), + }, + { + provide: (0, typeorm_1.getRepositoryToken)(organization_entity_1.Organization), + useValue: createMockRepository(), + }, + { + provide: (0, typeorm_1.getRepositoryToken)(correspondence_recipient_entity_1.CorrespondenceRecipient), + useValue: createMockRepository(), + }, + { + provide: document_numbering_service_1.DocumentNumberingService, + useValue: { + generateNextNumber: jest.fn(), + updateNumberForDraft: jest.fn(), + previewNextNumber: jest.fn(), + }, + }, + { + provide: json_schema_service_1.JsonSchemaService, + useValue: { validate: jest.fn() }, + }, + { + provide: workflow_engine_service_1.WorkflowEngineService, + useValue: { createInstance: jest.fn() }, + }, + { + provide: user_service_1.UserService, + useValue: { + findOne: jest.fn(), + getUserPermissions: jest.fn().mockResolvedValue([]), + }, + }, + { + provide: typeorm_2.DataSource, + useValue: mockDataSource, + }, + { + provide: search_service_1.SearchService, + useValue: { indexDocument: jest.fn() }, + }, + { + provide: file_storage_service_1.FileStorageService, + useValue: { commit: jest.fn().mockResolvedValue([]) }, + }, + { + provide: uuid_resolver_service_1.UuidResolverService, + useValue: { + resolveProjectId: jest.fn().mockResolvedValue(1), + resolveOrganizationId: jest.fn().mockResolvedValue(1), + }, + }, + { + provide: notification_service_1.NotificationService, + useValue: { send: jest.fn().mockResolvedValue(undefined) }, + }, + ], + }).compile(); + service = testingModule.get(correspondence_service_1.CorrespondenceService); + numberingService = testingModule.get(document_numbering_service_1.DocumentNumberingService); + correspondenceRepo = testingModule.get((0, typeorm_1.getRepositoryToken)(correspondence_entity_1.Correspondence)); + revisionRepo = testingModule.get((0, typeorm_1.getRepositoryToken)(correspondence_revision_entity_1.CorrespondenceRevision)); + _dataSource = testingModule.get(typeorm_2.DataSource); + }); + it('should be defined', () => { + expect(service).toBeDefined(); + }); + describe('update', () => { + it('should NOT regenerate number if critical fields unchanged', async () => { + const mockUser = { id: 1, primaryOrganizationId: 10 }; + const mockRevision = { + id: 100, + correspondenceId: 1, + isCurrent: true, + statusId: 5, + }; + jest + .spyOn(revisionRepo, 'findOne') + .mockResolvedValue(mockRevision); + const mockCorr = { + id: 1, + projectId: 1, + correspondenceTypeId: 2, + disciplineId: 3, + originatorId: 10, + correspondenceNumber: 'OLD-NUM', + recipients: [{ recipientType: 'TO', recipientOrganizationId: 99 }], + }; + jest + .spyOn(correspondenceRepo, 'findOne') + .mockResolvedValue(mockCorr); + const updateDto = { + projectId: 1, + disciplineId: 3, + }; + await service.update(1, updateDto, mockUser); + expect(numberingService.updateNumberForDraft).not.toHaveBeenCalled(); + }); + it('should regenerate number if Project ID changes', async () => { + const mockUser = { id: 1, primaryOrganizationId: 10 }; + const mockRevision = { + id: 100, + correspondenceId: 1, + isCurrent: true, + statusId: 5, + }; + jest + .spyOn(revisionRepo, 'findOne') + .mockResolvedValue(mockRevision); + const mockCorr = { + id: 1, + projectId: 1, + correspondenceTypeId: 2, + disciplineId: 3, + originatorId: 10, + correspondenceNumber: 'OLD-NUM', + recipients: [{ recipientType: 'TO', recipientOrganizationId: 99 }], + }; + jest + .spyOn(correspondenceRepo, 'findOne') + .mockResolvedValue(mockCorr); + const updateDto = { + projectId: 2, + }; + const uuidResolver = testingModule.get(uuid_resolver_service_1.UuidResolverService); + uuidResolver.resolveProjectId.mockResolvedValue(2); + await service.update(1, updateDto, mockUser); + expect(numberingService.updateNumberForDraft).toHaveBeenCalled(); + }); + it('should regenerate number if Document Type changes', async () => { + const mockUser = { id: 1, primaryOrganizationId: 10 }; + const mockRevision = { + id: 100, + correspondenceId: 1, + isCurrent: true, + statusId: 5, + }; + jest + .spyOn(revisionRepo, 'findOne') + .mockResolvedValue(mockRevision); + const mockCorr = { + id: 1, + projectId: 1, + correspondenceTypeId: 2, + disciplineId: 3, + originatorId: 10, + correspondenceNumber: 'OLD-NUM', + recipients: [{ recipientType: 'TO', recipientOrganizationId: 99 }], + }; + jest + .spyOn(correspondenceRepo, 'findOne') + .mockResolvedValue(mockCorr); + const updateDto = { + typeId: 999, + }; + const typeRepo = testingModule.get((0, typeorm_1.getRepositoryToken)(correspondence_type_entity_1.CorrespondenceType)); + typeRepo.findOne.mockResolvedValue({ + id: 999, + typeCode: 'NEW-TYPE', + }); + await service.update(1, updateDto, mockUser); + expect(numberingService.updateNumberForDraft).toHaveBeenCalled(); + }); + it('should regenerate number if Recipient Organization changes', async () => { + const mockUser = { id: 1, primaryOrganizationId: 10 }; + const mockRevision = { + id: 100, + correspondenceId: 1, + isCurrent: true, + statusId: 5, + }; + jest + .spyOn(revisionRepo, 'findOne') + .mockResolvedValue(mockRevision); + const mockCorr = { + id: 1, + projectId: 1, + correspondenceTypeId: 2, + disciplineId: 3, + originatorId: 10, + correspondenceNumber: 'OLD-NUM', + recipients: [{ recipientType: 'TO', recipientOrganizationId: 99 }], + }; + jest + .spyOn(correspondenceRepo, 'findOne') + .mockResolvedValue(mockCorr); + // Access DataSource manager for mocking + mockDataSource.manager.findOne.mockResolvedValue({ + id: 88, + organizationCode: 'NEW-ORG', + }); + const updateDto = { + recipients: [{ type: 'TO', organizationId: 88 }], + }; + await service.update(1, updateDto, mockUser); + expect(numberingService.updateNumberForDraft).toHaveBeenCalled(); + }); + }); + describe('create', () => { + it('should allow system.manage_all user without primaryOrganizationId when originatorId is provided', async () => { + const mockUser = { + user_id: 1, + primaryOrganizationId: null, + }; + const createDto = { + projectId: 'project-uuid', + typeId: 1, + subject: 'Test Subject', + originatorId: 'originator-uuid', + recipients: [{ organizationId: 'recipient-uuid', type: 'TO' }], + }; + const userService = testingModule.get(user_service_1.UserService); + const typeRepo = testingModule.get((0, typeorm_1.getRepositoryToken)(correspondence_type_entity_1.CorrespondenceType)); + const statusRepo = testingModule.get((0, typeorm_1.getRepositoryToken)(correspondence_status_entity_1.CorrespondenceStatus)); + const uuidResolver = testingModule.get(uuid_resolver_service_1.UuidResolverService); + userService.findOne.mockResolvedValue({ + user_id: 1, + primaryOrganizationId: null, + }); + userService.getUserPermissions.mockResolvedValue([ + 'system.manage_all', + ]); + uuidResolver.resolveProjectId.mockResolvedValue(100); + uuidResolver.resolveOrganizationId.mockImplementation((value) => { + if (value === 'originator-uuid') + return 10; + if (value === 'recipient-uuid') + return 20; + return 0; + }); + typeRepo.findOne.mockResolvedValue({ + id: 1, + typeCode: 'LTR', + }); + statusRepo.findOne.mockResolvedValue({ + id: 1, + statusCode: 'DRAFT', + }); + numberingService.generateNextNumber.mockResolvedValue({ + number: 'DOC-001', + }); + mockDataSource.manager.findOne + .mockResolvedValueOnce({ id: 10, organizationCode: 'ORG' }) + .mockResolvedValueOnce({ id: 20, organizationCode: 'REC' }); + const queryRunner = { + connect: jest.fn(), + startTransaction: jest.fn(), + commitTransaction: jest.fn(), + rollbackTransaction: jest.fn(), + release: jest.fn(), + manager: { + create: jest.fn((_entity, payload) => payload), + save: jest + .fn() + .mockResolvedValueOnce({ id: 999, publicId: 'corr-uuid' }) + .mockResolvedValueOnce({ id: 1000 }) + .mockResolvedValueOnce([]), + findOne: jest.fn(), + }, + }; + mockDataSource.createQueryRunner.mockReturnValue(queryRunner); + await service.create(createDto, mockUser); + expect(queryRunner.manager.create).toHaveBeenCalledWith(correspondence_entity_1.Correspondence, expect.objectContaining({ originatorId: 10 })); + }); + it('should set revisionLabel to "A" for RFA type', async () => { + const mockUser = { + user_id: 1, + primaryOrganizationId: 10, + }; + const createDto = { + projectId: 'project-uuid', + typeId: 1, + subject: 'Test Subject', + recipients: [{ organizationId: 'recipient-uuid', type: 'TO' }], + }; + const typeRepo = testingModule.get((0, typeorm_1.getRepositoryToken)(correspondence_type_entity_1.CorrespondenceType)); + const statusRepo = testingModule.get((0, typeorm_1.getRepositoryToken)(correspondence_status_entity_1.CorrespondenceStatus)); + const uuidResolver = testingModule.get(uuid_resolver_service_1.UuidResolverService); + uuidResolver.resolveProjectId.mockResolvedValue(100); + uuidResolver.resolveOrganizationId.mockResolvedValue(20); + typeRepo.findOne.mockResolvedValue({ + id: 1, + typeCode: 'RFA', + }); + statusRepo.findOne.mockResolvedValue({ + id: 1, + statusCode: 'DRAFT', + }); + numberingService.generateNextNumber.mockResolvedValue({ + number: 'DOC-001', + }); + mockDataSource.manager.findOne + .mockResolvedValueOnce({ id: 10, organizationCode: 'ORG' }) + .mockResolvedValueOnce({ id: 20, organizationCode: 'REC' }); + const queryRunner = { + connect: jest.fn(), + startTransaction: jest.fn(), + commitTransaction: jest.fn(), + rollbackTransaction: jest.fn(), + release: jest.fn(), + manager: { + create: jest.fn((_entity, payload) => payload), + save: jest + .fn() + .mockResolvedValueOnce({ id: 999, publicId: 'corr-uuid' }) + .mockResolvedValueOnce({ id: 1000 }) + .mockResolvedValueOnce([]), + findOne: jest.fn(), + }, + }; + mockDataSource.createQueryRunner.mockReturnValue(queryRunner); + await service.create(createDto, mockUser); + expect(queryRunner.manager.create).toHaveBeenCalledWith(correspondence_revision_entity_1.CorrespondenceRevision, expect.objectContaining({ revisionLabel: 'A' })); + }); + it('should set revisionLabel to "A" for RFI type', async () => { + const mockUser = { + user_id: 1, + primaryOrganizationId: 10, + }; + const createDto = { + projectId: 'project-uuid', + typeId: 1, + subject: 'Test Subject', + recipients: [{ organizationId: 'recipient-uuid', type: 'TO' }], + }; + const typeRepo = testingModule.get((0, typeorm_1.getRepositoryToken)(correspondence_type_entity_1.CorrespondenceType)); + const statusRepo = testingModule.get((0, typeorm_1.getRepositoryToken)(correspondence_status_entity_1.CorrespondenceStatus)); + const uuidResolver = testingModule.get(uuid_resolver_service_1.UuidResolverService); + uuidResolver.resolveProjectId.mockResolvedValue(100); + uuidResolver.resolveOrganizationId.mockResolvedValue(20); + typeRepo.findOne.mockResolvedValue({ + id: 1, + typeCode: 'RFI', + }); + statusRepo.findOne.mockResolvedValue({ + id: 1, + statusCode: 'DRAFT', + }); + numberingService.generateNextNumber.mockResolvedValue({ + number: 'DOC-001', + }); + mockDataSource.manager.findOne + .mockResolvedValueOnce({ id: 10, organizationCode: 'ORG' }) + .mockResolvedValueOnce({ id: 20, organizationCode: 'REC' }); + const queryRunner = { + connect: jest.fn(), + startTransaction: jest.fn(), + commitTransaction: jest.fn(), + rollbackTransaction: jest.fn(), + release: jest.fn(), + manager: { + create: jest.fn((_entity, payload) => payload), + save: jest + .fn() + .mockResolvedValueOnce({ id: 999, publicId: 'corr-uuid' }) + .mockResolvedValueOnce({ id: 1000 }) + .mockResolvedValueOnce([]), + findOne: jest.fn(), + }, + }; + mockDataSource.createQueryRunner.mockReturnValue(queryRunner); + await service.create(createDto, mockUser); + expect(queryRunner.manager.create).toHaveBeenCalledWith(correspondence_revision_entity_1.CorrespondenceRevision, expect.objectContaining({ revisionLabel: 'A' })); + }); + it('should set revisionLabel to null for LETTER type', async () => { + const mockUser = { + user_id: 1, + primaryOrganizationId: 10, + }; + const createDto = { + projectId: 'project-uuid', + typeId: 1, + subject: 'Test Subject', + recipients: [{ organizationId: 'recipient-uuid', type: 'TO' }], + }; + const typeRepo = testingModule.get((0, typeorm_1.getRepositoryToken)(correspondence_type_entity_1.CorrespondenceType)); + const statusRepo = testingModule.get((0, typeorm_1.getRepositoryToken)(correspondence_status_entity_1.CorrespondenceStatus)); + const uuidResolver = testingModule.get(uuid_resolver_service_1.UuidResolverService); + uuidResolver.resolveProjectId.mockResolvedValue(100); + uuidResolver.resolveOrganizationId.mockResolvedValue(20); + typeRepo.findOne.mockResolvedValue({ + id: 1, + typeCode: 'LETTER', + }); + statusRepo.findOne.mockResolvedValue({ + id: 1, + statusCode: 'DRAFT', + }); + numberingService.generateNextNumber.mockResolvedValue({ + number: 'DOC-001', + }); + mockDataSource.manager.findOne + .mockResolvedValueOnce({ id: 10, organizationCode: 'ORG' }) + .mockResolvedValueOnce({ id: 20, organizationCode: 'REC' }); + const queryRunner = { + connect: jest.fn(), + startTransaction: jest.fn(), + commitTransaction: jest.fn(), + rollbackTransaction: jest.fn(), + release: jest.fn(), + manager: { + create: jest.fn((_entity, payload) => payload), + save: jest + .fn() + .mockResolvedValueOnce({ id: 999, publicId: 'corr-uuid' }) + .mockResolvedValueOnce({ id: 1000 }) + .mockResolvedValueOnce([]), + findOne: jest.fn(), + }, + }; + mockDataSource.createQueryRunner.mockReturnValue(queryRunner); + await service.create(createDto, mockUser); + expect(queryRunner.manager.create).toHaveBeenCalledWith(correspondence_revision_entity_1.CorrespondenceRevision, expect.objectContaining({ revisionLabel: null })); + }); + it('should set revisionLabel to null for MEMO type', async () => { + const mockUser = { + user_id: 1, + primaryOrganizationId: 10, + }; + const createDto = { + projectId: 'project-uuid', + typeId: 1, + subject: 'Test Subject', + recipients: [{ organizationId: 'recipient-uuid', type: 'TO' }], + }; + const typeRepo = testingModule.get((0, typeorm_1.getRepositoryToken)(correspondence_type_entity_1.CorrespondenceType)); + const statusRepo = testingModule.get((0, typeorm_1.getRepositoryToken)(correspondence_status_entity_1.CorrespondenceStatus)); + const uuidResolver = testingModule.get(uuid_resolver_service_1.UuidResolverService); + uuidResolver.resolveProjectId.mockResolvedValue(100); + uuidResolver.resolveOrganizationId.mockResolvedValue(20); + typeRepo.findOne.mockResolvedValue({ + id: 1, + typeCode: 'MEMO', + }); + statusRepo.findOne.mockResolvedValue({ + id: 1, + statusCode: 'DRAFT', + }); + numberingService.generateNextNumber.mockResolvedValue({ + number: 'DOC-001', + }); + mockDataSource.manager.findOne + .mockResolvedValueOnce({ id: 10, organizationCode: 'ORG' }) + .mockResolvedValueOnce({ id: 20, organizationCode: 'REC' }); + const queryRunner = { + connect: jest.fn(), + startTransaction: jest.fn(), + commitTransaction: jest.fn(), + rollbackTransaction: jest.fn(), + release: jest.fn(), + manager: { + create: jest.fn((_entity, payload) => payload), + save: jest + .fn() + .mockResolvedValueOnce({ id: 999, publicId: 'corr-uuid' }) + .mockResolvedValueOnce({ id: 1000 }) + .mockResolvedValueOnce([]), + findOne: jest.fn(), + }, + }; + mockDataSource.createQueryRunner.mockReturnValue(queryRunner); + await service.create(createDto, mockUser); + expect(queryRunner.manager.create).toHaveBeenCalledWith(correspondence_revision_entity_1.CorrespondenceRevision, expect.objectContaining({ revisionLabel: null })); + }); + }); +}); +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"file":"E:\\np-dms\\lcbp3\\backend\\src\\modules\\correspondence\\correspondence.service.spec.ts","mappings":"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","names":[],"sources":["E:\\np-dms\\lcbp3\\backend\\src\\modules\\correspondence\\correspondence.service.spec.ts"],"sourcesContent":["import { Test, TestingModule } from '@nestjs/testing';\r\nimport { getRepositoryToken } from '@nestjs/typeorm';\r\nimport { DataSource, Repository } from 'typeorm';\r\nimport { CorrespondenceService } from './correspondence.service';\r\nimport { Correspondence } from './entities/correspondence.entity';\r\nimport { CorrespondenceRevision } from './entities/correspondence-revision.entity';\r\nimport { CorrespondenceType } from './entities/correspondence-type.entity';\r\nimport { CorrespondenceStatus } from './entities/correspondence-status.entity';\r\nimport { CorrespondenceReference } from './entities/correspondence-reference.entity';\r\nimport { CorrespondenceTag } from './entities/correspondence-tag.entity';\r\nimport { Organization } from '../organization/entities/organization.entity';\r\nimport { CorrespondenceRecipient } from './entities/correspondence-recipient.entity';\r\nimport { DocumentNumberingService } from '../document-numbering/services/document-numbering.service';\r\nimport { JsonSchemaService } from '../json-schema/json-schema.service';\r\nimport { WorkflowEngineService } from '../workflow-engine/workflow-engine.service';\r\nimport { UserService } from '../user/user.service';\r\nimport { SearchService } from '../search/search.service';\r\nimport { FileStorageService } from '../../common/file-storage/file-storage.service';\r\nimport { UuidResolverService } from '../../common/services/uuid-resolver.service';\r\nimport { NotificationService } from '../notification/notification.service';\r\nimport { UpdateCorrespondenceDto } from './dto/update-correspondence.dto';\r\nimport { CreateCorrespondenceDto } from './dto/create-correspondence.dto';\r\nimport { User } from '../user/entities/user.entity';\r\n\r\ndescribe('CorrespondenceService', () => {\r\n  let service: CorrespondenceService;\r\n  let numberingService: DocumentNumberingService;\r\n  let correspondenceRepo: Repository<Correspondence>;\r\n  let revisionRepo: Repository<CorrespondenceRevision>;\r\n  let testingModule: TestingModule;\r\n  let _dataSource: DataSource;\r\n\r\n  const createMockRepository = () => ({\r\n    find: jest.fn(),\r\n    findOne: jest.fn(),\r\n    create: jest.fn(),\r\n    save: jest.fn(),\r\n    update: jest.fn(),\r\n    delete: jest.fn(),\r\n    softDelete: jest.fn(),\r\n    createQueryBuilder: jest.fn(() => ({\r\n      leftJoinAndSelect: jest.fn().mockReturnThis(),\r\n      where: jest.fn().mockReturnThis(),\r\n      andWhere: jest.fn().mockReturnThis(),\r\n      orderBy: jest.fn().mockReturnThis(),\r\n      skip: jest.fn().mockReturnThis(),\r\n      take: jest.fn().mockReturnThis(),\r\n      getOne: jest.fn().mockResolvedValue(null),\r\n      getMany: jest.fn().mockResolvedValue([]),\r\n      getManyAndCount: jest.fn().mockResolvedValue([[], 0]),\r\n    })),\r\n  });\r\n\r\n  const mockDataSource = {\r\n    createQueryRunner: jest.fn(() => ({\r\n      connect: jest.fn(),\r\n      startTransaction: jest.fn(),\r\n      commitTransaction: jest.fn(),\r\n      rollbackTransaction: jest.fn(),\r\n      release: jest.fn(),\r\n      manager: {\r\n        create: jest.fn(),\r\n        save: jest.fn(),\r\n        findOne: jest.fn(),\r\n      },\r\n    })),\r\n    getRepository: jest.fn(() => createMockRepository()),\r\n    manager: {\r\n      findOne: jest.fn(),\r\n    },\r\n  };\r\n\r\n  beforeEach(async () => {\r\n    testingModule = await Test.createTestingModule({\r\n      providers: [\r\n        CorrespondenceService,\r\n        {\r\n          provide: getRepositoryToken(Correspondence),\r\n          useValue: createMockRepository(),\r\n        },\r\n        {\r\n          provide: getRepositoryToken(CorrespondenceRevision),\r\n          useValue: createMockRepository(),\r\n        },\r\n        {\r\n          provide: getRepositoryToken(CorrespondenceType),\r\n          useValue: createMockRepository(),\r\n        },\r\n        {\r\n          provide: getRepositoryToken(CorrespondenceStatus),\r\n          useValue: createMockRepository(),\r\n        },\r\n        {\r\n          provide: getRepositoryToken(CorrespondenceReference),\r\n          useValue: createMockRepository(),\r\n        },\r\n        {\r\n          provide: getRepositoryToken(CorrespondenceTag),\r\n          useValue: createMockRepository(),\r\n        },\r\n        {\r\n          provide: getRepositoryToken(Organization),\r\n          useValue: createMockRepository(),\r\n        },\r\n        {\r\n          provide: getRepositoryToken(CorrespondenceRecipient),\r\n          useValue: createMockRepository(),\r\n        },\r\n        {\r\n          provide: DocumentNumberingService,\r\n          useValue: {\r\n            generateNextNumber: jest.fn(),\r\n            updateNumberForDraft: jest.fn(),\r\n            previewNextNumber: jest.fn(),\r\n          },\r\n        },\r\n        {\r\n          provide: JsonSchemaService,\r\n          useValue: { validate: jest.fn() },\r\n        },\r\n        {\r\n          provide: WorkflowEngineService,\r\n          useValue: { createInstance: jest.fn() },\r\n        },\r\n        {\r\n          provide: UserService,\r\n          useValue: {\r\n            findOne: jest.fn(),\r\n            getUserPermissions: jest.fn().mockResolvedValue([]),\r\n          },\r\n        },\r\n        {\r\n          provide: DataSource,\r\n          useValue: mockDataSource,\r\n        },\r\n        {\r\n          provide: SearchService,\r\n          useValue: { indexDocument: jest.fn() },\r\n        },\r\n        {\r\n          provide: FileStorageService,\r\n          useValue: { commit: jest.fn().mockResolvedValue([]) },\r\n        },\r\n        {\r\n          provide: UuidResolverService,\r\n          useValue: {\r\n            resolveProjectId: jest.fn().mockResolvedValue(1),\r\n            resolveOrganizationId: jest.fn().mockResolvedValue(1),\r\n          },\r\n        },\r\n        {\r\n          provide: NotificationService,\r\n          useValue: { send: jest.fn().mockResolvedValue(undefined) },\r\n        },\r\n      ],\r\n    }).compile();\r\n\r\n    service = testingModule.get<CorrespondenceService>(CorrespondenceService);\r\n    numberingService = testingModule.get<DocumentNumberingService>(\r\n      DocumentNumberingService\r\n    );\r\n    correspondenceRepo = testingModule.get<Repository<Correspondence>>(\r\n      getRepositoryToken(Correspondence)\r\n    );\r\n    revisionRepo = testingModule.get<Repository<CorrespondenceRevision>>(\r\n      getRepositoryToken(CorrespondenceRevision)\r\n    );\r\n    _dataSource = testingModule.get<DataSource>(DataSource);\r\n  });\r\n\r\n  it('should be defined', () => {\r\n    expect(service).toBeDefined();\r\n  });\r\n\r\n  describe('update', () => {\r\n    it('should NOT regenerate number if critical fields unchanged', async () => {\r\n      const mockUser = { id: 1, primaryOrganizationId: 10 } as unknown as User;\r\n      const mockRevision = {\r\n        id: 100,\r\n        correspondenceId: 1,\r\n        isCurrent: true,\r\n        statusId: 5,\r\n      };\r\n\r\n      jest\r\n        .spyOn(revisionRepo, 'findOne')\r\n        .mockResolvedValue(mockRevision as unknown as CorrespondenceRevision);\r\n\r\n      const mockCorr = {\r\n        id: 1,\r\n        projectId: 1,\r\n        correspondenceTypeId: 2,\r\n        disciplineId: 3,\r\n        originatorId: 10,\r\n        correspondenceNumber: 'OLD-NUM',\r\n        recipients: [{ recipientType: 'TO', recipientOrganizationId: 99 }],\r\n      };\r\n      jest\r\n        .spyOn(correspondenceRepo, 'findOne')\r\n        .mockResolvedValue(mockCorr as unknown as Correspondence);\r\n\r\n      const updateDto: UpdateCorrespondenceDto = {\r\n        projectId: 1,\r\n        disciplineId: 3,\r\n      };\r\n\r\n      await service.update(1, updateDto, mockUser);\r\n\r\n      expect(\r\n        numberingService.updateNumberForDraft as jest.Mock\r\n      ).not.toHaveBeenCalled();\r\n    });\r\n\r\n    it('should regenerate number if Project ID changes', async () => {\r\n      const mockUser = { id: 1, primaryOrganizationId: 10 } as unknown as User;\r\n      const mockRevision = {\r\n        id: 100,\r\n        correspondenceId: 1,\r\n        isCurrent: true,\r\n        statusId: 5,\r\n      };\r\n      jest\r\n        .spyOn(revisionRepo, 'findOne')\r\n        .mockResolvedValue(mockRevision as unknown as CorrespondenceRevision);\r\n\r\n      const mockCorr = {\r\n        id: 1,\r\n        projectId: 1,\r\n        correspondenceTypeId: 2,\r\n        disciplineId: 3,\r\n        originatorId: 10,\r\n        correspondenceNumber: 'OLD-NUM',\r\n        recipients: [{ recipientType: 'TO', recipientOrganizationId: 99 }],\r\n      };\r\n      jest\r\n        .spyOn(correspondenceRepo, 'findOne')\r\n        .mockResolvedValue(mockCorr as unknown as Correspondence);\r\n\r\n      const updateDto: UpdateCorrespondenceDto = {\r\n        projectId: 2,\r\n      };\r\n\r\n      const uuidResolver =\r\n        testingModule.get<UuidResolverService>(UuidResolverService);\r\n      (uuidResolver.resolveProjectId as jest.Mock).mockResolvedValue(2);\r\n\r\n      await service.update(1, updateDto, mockUser);\r\n\r\n      expect(\r\n        numberingService.updateNumberForDraft as jest.Mock\r\n      ).toHaveBeenCalled();\r\n    });\r\n\r\n    it('should regenerate number if Document Type changes', async () => {\r\n      const mockUser = { id: 1, primaryOrganizationId: 10 } as unknown as User;\r\n      const mockRevision = {\r\n        id: 100,\r\n        correspondenceId: 1,\r\n        isCurrent: true,\r\n        statusId: 5,\r\n      };\r\n      jest\r\n        .spyOn(revisionRepo, 'findOne')\r\n        .mockResolvedValue(mockRevision as unknown as CorrespondenceRevision);\r\n\r\n      const mockCorr = {\r\n        id: 1,\r\n        projectId: 1,\r\n        correspondenceTypeId: 2,\r\n        disciplineId: 3,\r\n        originatorId: 10,\r\n        correspondenceNumber: 'OLD-NUM',\r\n        recipients: [{ recipientType: 'TO', recipientOrganizationId: 99 }],\r\n      };\r\n      jest\r\n        .spyOn(correspondenceRepo, 'findOne')\r\n        .mockResolvedValue(mockCorr as unknown as Correspondence);\r\n\r\n      const updateDto: UpdateCorrespondenceDto = {\r\n        typeId: 999,\r\n      };\r\n\r\n      const typeRepo = testingModule.get<Repository<CorrespondenceType>>(\r\n        getRepositoryToken(CorrespondenceType)\r\n      );\r\n      (typeRepo.findOne as jest.Mock).mockResolvedValue({\r\n        id: 999,\r\n        typeCode: 'NEW-TYPE',\r\n      });\r\n\r\n      await service.update(1, updateDto, mockUser);\r\n\r\n      expect(\r\n        numberingService.updateNumberForDraft as jest.Mock\r\n      ).toHaveBeenCalled();\r\n    });\r\n\r\n    it('should regenerate number if Recipient Organization changes', async () => {\r\n      const mockUser = { id: 1, primaryOrganizationId: 10 } as unknown as User;\r\n      const mockRevision = {\r\n        id: 100,\r\n        correspondenceId: 1,\r\n        isCurrent: true,\r\n        statusId: 5,\r\n      };\r\n      jest\r\n        .spyOn(revisionRepo, 'findOne')\r\n        .mockResolvedValue(mockRevision as unknown as CorrespondenceRevision);\r\n\r\n      const mockCorr = {\r\n        id: 1,\r\n        projectId: 1,\r\n        correspondenceTypeId: 2,\r\n        disciplineId: 3,\r\n        originatorId: 10,\r\n        correspondenceNumber: 'OLD-NUM',\r\n        recipients: [{ recipientType: 'TO', recipientOrganizationId: 99 }],\r\n      };\r\n      jest\r\n        .spyOn(correspondenceRepo, 'findOne')\r\n        .mockResolvedValue(mockCorr as unknown as Correspondence);\r\n\r\n      // Access DataSource manager for mocking\r\n      mockDataSource.manager.findOne.mockResolvedValue({\r\n        id: 88,\r\n        organizationCode: 'NEW-ORG',\r\n      } as unknown as Organization);\r\n\r\n      const updateDto: UpdateCorrespondenceDto = {\r\n        recipients: [{ type: 'TO', organizationId: 88 }],\r\n      };\r\n\r\n      await service.update(1, updateDto, mockUser);\r\n\r\n      expect(\r\n        numberingService.updateNumberForDraft as jest.Mock\r\n      ).toHaveBeenCalled();\r\n    });\r\n  });\r\n\r\n  describe('create', () => {\r\n    it('should allow system.manage_all user without primaryOrganizationId when originatorId is provided', async () => {\r\n      const mockUser = {\r\n        user_id: 1,\r\n        primaryOrganizationId: null,\r\n      } as unknown as User;\r\n\r\n      const createDto: CreateCorrespondenceDto = {\r\n        projectId: 'project-uuid',\r\n        typeId: 1,\r\n        subject: 'Test Subject',\r\n        originatorId: 'originator-uuid',\r\n        recipients: [{ organizationId: 'recipient-uuid', type: 'TO' }],\r\n      };\r\n\r\n      const userService = testingModule.get<UserService>(UserService);\r\n      const typeRepo = testingModule.get<Repository<CorrespondenceType>>(\r\n        getRepositoryToken(CorrespondenceType)\r\n      );\r\n      const statusRepo = testingModule.get<Repository<CorrespondenceStatus>>(\r\n        getRepositoryToken(CorrespondenceStatus)\r\n      );\r\n      const uuidResolver =\r\n        testingModule.get<UuidResolverService>(UuidResolverService);\r\n\r\n      (userService.findOne as jest.Mock).mockResolvedValue({\r\n        user_id: 1,\r\n        primaryOrganizationId: null,\r\n      });\r\n      (userService.getUserPermissions as jest.Mock).mockResolvedValue([\r\n        'system.manage_all',\r\n      ]);\r\n\r\n      (uuidResolver.resolveProjectId as jest.Mock).mockResolvedValue(100);\r\n      (uuidResolver.resolveOrganizationId as jest.Mock).mockImplementation(\r\n        (value: number | string) => {\r\n          if (value === 'originator-uuid') return 10;\r\n          if (value === 'recipient-uuid') return 20;\r\n          return 0;\r\n        }\r\n      );\r\n\r\n      (typeRepo.findOne as jest.Mock).mockResolvedValue({\r\n        id: 1,\r\n        typeCode: 'LTR',\r\n      });\r\n      (statusRepo.findOne as jest.Mock).mockResolvedValue({\r\n        id: 1,\r\n        statusCode: 'DRAFT',\r\n      });\r\n\r\n      (numberingService.generateNextNumber as jest.Mock).mockResolvedValue({\r\n        number: 'DOC-001',\r\n      });\r\n\r\n      mockDataSource.manager.findOne\r\n        .mockResolvedValueOnce({ id: 10, organizationCode: 'ORG' })\r\n        .mockResolvedValueOnce({ id: 20, organizationCode: 'REC' });\r\n\r\n      const queryRunner = {\r\n        connect: jest.fn(),\r\n        startTransaction: jest.fn(),\r\n        commitTransaction: jest.fn(),\r\n        rollbackTransaction: jest.fn(),\r\n        release: jest.fn(),\r\n        manager: {\r\n          create: jest.fn(\r\n            (_entity: unknown, payload: Record<string, unknown>) => payload\r\n          ),\r\n          save: jest\r\n            .fn()\r\n            .mockResolvedValueOnce({ id: 999, publicId: 'corr-uuid' })\r\n            .mockResolvedValueOnce({ id: 1000 })\r\n            .mockResolvedValueOnce([]),\r\n          findOne: jest.fn(),\r\n        },\r\n      };\r\n\r\n      (mockDataSource.createQueryRunner as jest.Mock).mockReturnValue(\r\n        queryRunner\r\n      );\r\n\r\n      await service.create(createDto, mockUser);\r\n\r\n      expect(queryRunner.manager.create).toHaveBeenCalledWith(\r\n        Correspondence,\r\n        expect.objectContaining({ originatorId: 10 })\r\n      );\r\n    });\r\n\r\n    it('should set revisionLabel to \"A\" for RFA type', async () => {\r\n      const mockUser = {\r\n        user_id: 1,\r\n        primaryOrganizationId: 10,\r\n      } as unknown as User;\r\n\r\n      const createDto: CreateCorrespondenceDto = {\r\n        projectId: 'project-uuid',\r\n        typeId: 1,\r\n        subject: 'Test Subject',\r\n        recipients: [{ organizationId: 'recipient-uuid', type: 'TO' }],\r\n      };\r\n\r\n      const typeRepo = testingModule.get<Repository<CorrespondenceType>>(\r\n        getRepositoryToken(CorrespondenceType)\r\n      );\r\n      const statusRepo = testingModule.get<Repository<CorrespondenceStatus>>(\r\n        getRepositoryToken(CorrespondenceStatus)\r\n      );\r\n      const uuidResolver =\r\n        testingModule.get<UuidResolverService>(UuidResolverService);\r\n\r\n      (uuidResolver.resolveProjectId as jest.Mock).mockResolvedValue(100);\r\n      (uuidResolver.resolveOrganizationId as jest.Mock).mockResolvedValue(20);\r\n\r\n      (typeRepo.findOne as jest.Mock).mockResolvedValue({\r\n        id: 1,\r\n        typeCode: 'RFA',\r\n      });\r\n      (statusRepo.findOne as jest.Mock).mockResolvedValue({\r\n        id: 1,\r\n        statusCode: 'DRAFT',\r\n      });\r\n\r\n      (numberingService.generateNextNumber as jest.Mock).mockResolvedValue({\r\n        number: 'DOC-001',\r\n      });\r\n\r\n      mockDataSource.manager.findOne\r\n        .mockResolvedValueOnce({ id: 10, organizationCode: 'ORG' })\r\n        .mockResolvedValueOnce({ id: 20, organizationCode: 'REC' });\r\n\r\n      const queryRunner = {\r\n        connect: jest.fn(),\r\n        startTransaction: jest.fn(),\r\n        commitTransaction: jest.fn(),\r\n        rollbackTransaction: jest.fn(),\r\n        release: jest.fn(),\r\n        manager: {\r\n          create: jest.fn(\r\n            (_entity: unknown, payload: Record<string, unknown>) => payload\r\n          ),\r\n          save: jest\r\n            .fn()\r\n            .mockResolvedValueOnce({ id: 999, publicId: 'corr-uuid' })\r\n            .mockResolvedValueOnce({ id: 1000 })\r\n            .mockResolvedValueOnce([]),\r\n          findOne: jest.fn(),\r\n        },\r\n      };\r\n\r\n      (mockDataSource.createQueryRunner as jest.Mock).mockReturnValue(\r\n        queryRunner\r\n      );\r\n\r\n      await service.create(createDto, mockUser);\r\n\r\n      expect(queryRunner.manager.create).toHaveBeenCalledWith(\r\n        CorrespondenceRevision,\r\n        expect.objectContaining({ revisionLabel: 'A' })\r\n      );\r\n    });\r\n\r\n    it('should set revisionLabel to \"A\" for RFI type', async () => {\r\n      const mockUser = {\r\n        user_id: 1,\r\n        primaryOrganizationId: 10,\r\n      } as unknown as User;\r\n\r\n      const createDto: CreateCorrespondenceDto = {\r\n        projectId: 'project-uuid',\r\n        typeId: 1,\r\n        subject: 'Test Subject',\r\n        recipients: [{ organizationId: 'recipient-uuid', type: 'TO' }],\r\n      };\r\n\r\n      const typeRepo = testingModule.get<Repository<CorrespondenceType>>(\r\n        getRepositoryToken(CorrespondenceType)\r\n      );\r\n      const statusRepo = testingModule.get<Repository<CorrespondenceStatus>>(\r\n        getRepositoryToken(CorrespondenceStatus)\r\n      );\r\n      const uuidResolver =\r\n        testingModule.get<UuidResolverService>(UuidResolverService);\r\n\r\n      (uuidResolver.resolveProjectId as jest.Mock).mockResolvedValue(100);\r\n      (uuidResolver.resolveOrganizationId as jest.Mock).mockResolvedValue(20);\r\n\r\n      (typeRepo.findOne as jest.Mock).mockResolvedValue({\r\n        id: 1,\r\n        typeCode: 'RFI',\r\n      });\r\n      (statusRepo.findOne as jest.Mock).mockResolvedValue({\r\n        id: 1,\r\n        statusCode: 'DRAFT',\r\n      });\r\n\r\n      (numberingService.generateNextNumber as jest.Mock).mockResolvedValue({\r\n        number: 'DOC-001',\r\n      });\r\n\r\n      mockDataSource.manager.findOne\r\n        .mockResolvedValueOnce({ id: 10, organizationCode: 'ORG' })\r\n        .mockResolvedValueOnce({ id: 20, organizationCode: 'REC' });\r\n\r\n      const queryRunner = {\r\n        connect: jest.fn(),\r\n        startTransaction: jest.fn(),\r\n        commitTransaction: jest.fn(),\r\n        rollbackTransaction: jest.fn(),\r\n        release: jest.fn(),\r\n        manager: {\r\n          create: jest.fn(\r\n            (_entity: unknown, payload: Record<string, unknown>) => payload\r\n          ),\r\n          save: jest\r\n            .fn()\r\n            .mockResolvedValueOnce({ id: 999, publicId: 'corr-uuid' })\r\n            .mockResolvedValueOnce({ id: 1000 })\r\n            .mockResolvedValueOnce([]),\r\n          findOne: jest.fn(),\r\n        },\r\n      };\r\n\r\n      (mockDataSource.createQueryRunner as jest.Mock).mockReturnValue(\r\n        queryRunner\r\n      );\r\n\r\n      await service.create(createDto, mockUser);\r\n\r\n      expect(queryRunner.manager.create).toHaveBeenCalledWith(\r\n        CorrespondenceRevision,\r\n        expect.objectContaining({ revisionLabel: 'A' })\r\n      );\r\n    });\r\n\r\n    it('should set revisionLabel to null for LETTER type', async () => {\r\n      const mockUser = {\r\n        user_id: 1,\r\n        primaryOrganizationId: 10,\r\n      } as unknown as User;\r\n\r\n      const createDto: CreateCorrespondenceDto = {\r\n        projectId: 'project-uuid',\r\n        typeId: 1,\r\n        subject: 'Test Subject',\r\n        recipients: [{ organizationId: 'recipient-uuid', type: 'TO' }],\r\n      };\r\n\r\n      const typeRepo = testingModule.get<Repository<CorrespondenceType>>(\r\n        getRepositoryToken(CorrespondenceType)\r\n      );\r\n      const statusRepo = testingModule.get<Repository<CorrespondenceStatus>>(\r\n        getRepositoryToken(CorrespondenceStatus)\r\n      );\r\n      const uuidResolver =\r\n        testingModule.get<UuidResolverService>(UuidResolverService);\r\n\r\n      (uuidResolver.resolveProjectId as jest.Mock).mockResolvedValue(100);\r\n      (uuidResolver.resolveOrganizationId as jest.Mock).mockResolvedValue(20);\r\n\r\n      (typeRepo.findOne as jest.Mock).mockResolvedValue({\r\n        id: 1,\r\n        typeCode: 'LETTER',\r\n      });\r\n      (statusRepo.findOne as jest.Mock).mockResolvedValue({\r\n        id: 1,\r\n        statusCode: 'DRAFT',\r\n      });\r\n\r\n      (numberingService.generateNextNumber as jest.Mock).mockResolvedValue({\r\n        number: 'DOC-001',\r\n      });\r\n\r\n      mockDataSource.manager.findOne\r\n        .mockResolvedValueOnce({ id: 10, organizationCode: 'ORG' })\r\n        .mockResolvedValueOnce({ id: 20, organizationCode: 'REC' });\r\n\r\n      const queryRunner = {\r\n        connect: jest.fn(),\r\n        startTransaction: jest.fn(),\r\n        commitTransaction: jest.fn(),\r\n        rollbackTransaction: jest.fn(),\r\n        release: jest.fn(),\r\n        manager: {\r\n          create: jest.fn(\r\n            (_entity: unknown, payload: Record<string, unknown>) => payload\r\n          ),\r\n          save: jest\r\n            .fn()\r\n            .mockResolvedValueOnce({ id: 999, publicId: 'corr-uuid' })\r\n            .mockResolvedValueOnce({ id: 1000 })\r\n            .mockResolvedValueOnce([]),\r\n          findOne: jest.fn(),\r\n        },\r\n      };\r\n\r\n      (mockDataSource.createQueryRunner as jest.Mock).mockReturnValue(\r\n        queryRunner\r\n      );\r\n\r\n      await service.create(createDto, mockUser);\r\n\r\n      expect(queryRunner.manager.create).toHaveBeenCalledWith(\r\n        CorrespondenceRevision,\r\n        expect.objectContaining({ revisionLabel: null })\r\n      );\r\n    });\r\n\r\n    it('should set revisionLabel to null for MEMO type', async () => {\r\n      const mockUser = {\r\n        user_id: 1,\r\n        primaryOrganizationId: 10,\r\n      } as unknown as User;\r\n\r\n      const createDto: CreateCorrespondenceDto = {\r\n        projectId: 'project-uuid',\r\n        typeId: 1,\r\n        subject: 'Test Subject',\r\n        recipients: [{ organizationId: 'recipient-uuid', type: 'TO' }],\r\n      };\r\n\r\n      const typeRepo = testingModule.get<Repository<CorrespondenceType>>(\r\n        getRepositoryToken(CorrespondenceType)\r\n      );\r\n      const statusRepo = testingModule.get<Repository<CorrespondenceStatus>>(\r\n        getRepositoryToken(CorrespondenceStatus)\r\n      );\r\n      const uuidResolver =\r\n        testingModule.get<UuidResolverService>(UuidResolverService);\r\n\r\n      (uuidResolver.resolveProjectId as jest.Mock).mockResolvedValue(100);\r\n      (uuidResolver.resolveOrganizationId as jest.Mock).mockResolvedValue(20);\r\n\r\n      (typeRepo.findOne as jest.Mock).mockResolvedValue({\r\n        id: 1,\r\n        typeCode: 'MEMO',\r\n      });\r\n      (statusRepo.findOne as jest.Mock).mockResolvedValue({\r\n        id: 1,\r\n        statusCode: 'DRAFT',\r\n      });\r\n\r\n      (numberingService.generateNextNumber as jest.Mock).mockResolvedValue({\r\n        number: 'DOC-001',\r\n      });\r\n\r\n      mockDataSource.manager.findOne\r\n        .mockResolvedValueOnce({ id: 10, organizationCode: 'ORG' })\r\n        .mockResolvedValueOnce({ id: 20, organizationCode: 'REC' });\r\n\r\n      const queryRunner = {\r\n        connect: jest.fn(),\r\n        startTransaction: jest.fn(),\r\n        commitTransaction: jest.fn(),\r\n        rollbackTransaction: jest.fn(),\r\n        release: jest.fn(),\r\n        manager: {\r\n          create: jest.fn(\r\n            (_entity: unknown, payload: Record<string, unknown>) => payload\r\n          ),\r\n          save: jest\r\n            .fn()\r\n            .mockResolvedValueOnce({ id: 999, publicId: 'corr-uuid' })\r\n            .mockResolvedValueOnce({ id: 1000 })\r\n            .mockResolvedValueOnce([]),\r\n          findOne: jest.fn(),\r\n        },\r\n      };\r\n\r\n      (mockDataSource.createQueryRunner as jest.Mock).mockReturnValue(\r\n        queryRunner\r\n      );\r\n\r\n      await service.create(createDto, mockUser);\r\n\r\n      expect(queryRunner.manager.create).toHaveBeenCalledWith(\r\n        CorrespondenceRevision,\r\n        expect.objectContaining({ revisionLabel: null })\r\n      );\r\n    });\r\n  });\r\n});\r\n"],"version":3} \ No newline at end of file diff --git a/backend/src/.jest-cache/jest-transform-cache-60cab15b743c6776f41d29bcac696b99-12533232bd0f05f65688e7a7764bf3fb/6e/correspondenceservicespec_6e17e53289c744ad0b09ce4420c50e0e.map b/backend/src/.jest-cache/jest-transform-cache-60cab15b743c6776f41d29bcac696b99-12533232bd0f05f65688e7a7764bf3fb/6e/correspondenceservicespec_6e17e53289c744ad0b09ce4420c50e0e.map new file mode 100644 index 0000000..53056ca --- /dev/null +++ b/backend/src/.jest-cache/jest-transform-cache-60cab15b743c6776f41d29bcac696b99-12533232bd0f05f65688e7a7764bf3fb/6e/correspondenceservicespec_6e17e53289c744ad0b09ce4420c50e0e.map @@ -0,0 +1 @@ +{"file":"E:\\np-dms\\lcbp3\\backend\\src\\modules\\correspondence\\correspondence.service.spec.ts","mappings":"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","names":[],"sources":["E:\\np-dms\\lcbp3\\backend\\src\\modules\\correspondence\\correspondence.service.spec.ts"],"sourcesContent":["import { Test, TestingModule } from '@nestjs/testing';\r\nimport { getRepositoryToken } from '@nestjs/typeorm';\r\nimport { DataSource, Repository } from 'typeorm';\r\nimport { CorrespondenceService } from './correspondence.service';\r\nimport { Correspondence } from './entities/correspondence.entity';\r\nimport { CorrespondenceRevision } from './entities/correspondence-revision.entity';\r\nimport { CorrespondenceType } from './entities/correspondence-type.entity';\r\nimport { CorrespondenceStatus } from './entities/correspondence-status.entity';\r\nimport { CorrespondenceReference } from './entities/correspondence-reference.entity';\r\nimport { CorrespondenceTag } from './entities/correspondence-tag.entity';\r\nimport { Organization } from '../organization/entities/organization.entity';\r\nimport { CorrespondenceRecipient } from './entities/correspondence-recipient.entity';\r\nimport { DocumentNumberingService } from '../document-numbering/services/document-numbering.service';\r\nimport { JsonSchemaService } from '../json-schema/json-schema.service';\r\nimport { WorkflowEngineService } from '../workflow-engine/workflow-engine.service';\r\nimport { UserService } from '../user/user.service';\r\nimport { SearchService } from '../search/search.service';\r\nimport { FileStorageService } from '../../common/file-storage/file-storage.service';\r\nimport { UuidResolverService } from '../../common/services/uuid-resolver.service';\r\nimport { NotificationService } from '../notification/notification.service';\r\nimport { UpdateCorrespondenceDto } from './dto/update-correspondence.dto';\r\nimport { CreateCorrespondenceDto } from './dto/create-correspondence.dto';\r\nimport { User } from '../user/entities/user.entity';\r\n\r\ndescribe('CorrespondenceService', () => {\r\n let service: CorrespondenceService;\r\n let numberingService: DocumentNumberingService;\r\n let correspondenceRepo: Repository;\r\n let revisionRepo: Repository;\r\n let testingModule: TestingModule;\r\n let _dataSource: DataSource;\r\n\r\n const createMockRepository = () => ({\r\n find: jest.fn(),\r\n findOne: jest.fn(),\r\n create: jest.fn(),\r\n save: jest.fn(),\r\n update: jest.fn(),\r\n delete: jest.fn(),\r\n softDelete: jest.fn(),\r\n createQueryBuilder: jest.fn(() => ({\r\n leftJoinAndSelect: jest.fn().mockReturnThis(),\r\n where: jest.fn().mockReturnThis(),\r\n andWhere: jest.fn().mockReturnThis(),\r\n orderBy: jest.fn().mockReturnThis(),\r\n skip: jest.fn().mockReturnThis(),\r\n take: jest.fn().mockReturnThis(),\r\n getOne: jest.fn().mockResolvedValue(null),\r\n getMany: jest.fn().mockResolvedValue([]),\r\n getManyAndCount: jest.fn().mockResolvedValue([[], 0]),\r\n })),\r\n });\r\n\r\n const mockDataSource = {\r\n createQueryRunner: jest.fn(() => ({\r\n connect: jest.fn(),\r\n startTransaction: jest.fn(),\r\n commitTransaction: jest.fn(),\r\n rollbackTransaction: jest.fn(),\r\n release: jest.fn(),\r\n manager: {\r\n create: jest.fn(),\r\n save: jest.fn(),\r\n findOne: jest.fn(),\r\n },\r\n })),\r\n getRepository: jest.fn(() => createMockRepository()),\r\n manager: {\r\n findOne: jest.fn(),\r\n },\r\n };\r\n\r\n beforeEach(async () => {\r\n testingModule = await Test.createTestingModule({\r\n providers: [\r\n CorrespondenceService,\r\n {\r\n provide: getRepositoryToken(Correspondence),\r\n useValue: createMockRepository(),\r\n },\r\n {\r\n provide: getRepositoryToken(CorrespondenceRevision),\r\n useValue: createMockRepository(),\r\n },\r\n {\r\n provide: getRepositoryToken(CorrespondenceType),\r\n useValue: createMockRepository(),\r\n },\r\n {\r\n provide: getRepositoryToken(CorrespondenceStatus),\r\n useValue: createMockRepository(),\r\n },\r\n {\r\n provide: getRepositoryToken(CorrespondenceReference),\r\n useValue: createMockRepository(),\r\n },\r\n {\r\n provide: getRepositoryToken(CorrespondenceTag),\r\n useValue: createMockRepository(),\r\n },\r\n {\r\n provide: getRepositoryToken(Organization),\r\n useValue: createMockRepository(),\r\n },\r\n {\r\n provide: getRepositoryToken(CorrespondenceRecipient),\r\n useValue: createMockRepository(),\r\n },\r\n {\r\n provide: DocumentNumberingService,\r\n useValue: {\r\n generateNextNumber: jest.fn(),\r\n updateNumberForDraft: jest.fn(),\r\n previewNextNumber: jest.fn(),\r\n },\r\n },\r\n {\r\n provide: JsonSchemaService,\r\n useValue: { validate: jest.fn() },\r\n },\r\n {\r\n provide: WorkflowEngineService,\r\n useValue: { createInstance: jest.fn() },\r\n },\r\n {\r\n provide: UserService,\r\n useValue: {\r\n findOne: jest.fn(),\r\n getUserPermissions: jest.fn().mockResolvedValue([]),\r\n },\r\n },\r\n {\r\n provide: DataSource,\r\n useValue: mockDataSource,\r\n },\r\n {\r\n provide: SearchService,\r\n useValue: { indexDocument: jest.fn() },\r\n },\r\n {\r\n provide: FileStorageService,\r\n useValue: { commit: jest.fn().mockResolvedValue([]) },\r\n },\r\n {\r\n provide: UuidResolverService,\r\n useValue: {\r\n resolveProjectId: jest.fn().mockResolvedValue(1),\r\n resolveOrganizationId: jest.fn().mockResolvedValue(1),\r\n },\r\n },\r\n {\r\n provide: NotificationService,\r\n useValue: { send: jest.fn().mockResolvedValue(undefined) },\r\n },\r\n ],\r\n }).compile();\r\n\r\n service = testingModule.get(CorrespondenceService);\r\n numberingService = testingModule.get(\r\n DocumentNumberingService\r\n );\r\n correspondenceRepo = testingModule.get>(\r\n getRepositoryToken(Correspondence)\r\n );\r\n revisionRepo = testingModule.get>(\r\n getRepositoryToken(CorrespondenceRevision)\r\n );\r\n _dataSource = testingModule.get(DataSource);\r\n });\r\n\r\n it('should be defined', () => {\r\n expect(service).toBeDefined();\r\n });\r\n\r\n describe('update', () => {\r\n it('should NOT regenerate number if critical fields unchanged', async () => {\r\n const mockUser = { id: 1, primaryOrganizationId: 10 } as unknown as User;\r\n const mockRevision = {\r\n id: 100,\r\n correspondenceId: 1,\r\n isCurrent: true,\r\n statusId: 5,\r\n };\r\n\r\n jest\r\n .spyOn(revisionRepo, 'findOne')\r\n .mockResolvedValue(mockRevision as unknown as CorrespondenceRevision);\r\n\r\n const mockCorr = {\r\n id: 1,\r\n projectId: 1,\r\n correspondenceTypeId: 2,\r\n disciplineId: 3,\r\n originatorId: 10,\r\n correspondenceNumber: 'OLD-NUM',\r\n recipients: [{ recipientType: 'TO', recipientOrganizationId: 99 }],\r\n };\r\n jest\r\n .spyOn(correspondenceRepo, 'findOne')\r\n .mockResolvedValue(mockCorr as unknown as Correspondence);\r\n\r\n const updateDto: UpdateCorrespondenceDto = {\r\n projectId: 1,\r\n disciplineId: 3,\r\n };\r\n\r\n await service.update(1, updateDto, mockUser);\r\n\r\n expect(\r\n numberingService.updateNumberForDraft as jest.Mock\r\n ).not.toHaveBeenCalled();\r\n });\r\n\r\n it('should regenerate number if Project ID changes', async () => {\r\n const mockUser = { id: 1, primaryOrganizationId: 10 } as unknown as User;\r\n const mockRevision = {\r\n id: 100,\r\n correspondenceId: 1,\r\n isCurrent: true,\r\n statusId: 5,\r\n };\r\n jest\r\n .spyOn(revisionRepo, 'findOne')\r\n .mockResolvedValue(mockRevision as unknown as CorrespondenceRevision);\r\n\r\n const mockCorr = {\r\n id: 1,\r\n projectId: 1,\r\n correspondenceTypeId: 2,\r\n disciplineId: 3,\r\n originatorId: 10,\r\n correspondenceNumber: 'OLD-NUM',\r\n recipients: [{ recipientType: 'TO', recipientOrganizationId: 99 }],\r\n };\r\n jest\r\n .spyOn(correspondenceRepo, 'findOne')\r\n .mockResolvedValue(mockCorr as unknown as Correspondence);\r\n\r\n const updateDto: UpdateCorrespondenceDto = {\r\n projectId: 2,\r\n };\r\n\r\n const uuidResolver =\r\n testingModule.get(UuidResolverService);\r\n (uuidResolver.resolveProjectId as jest.Mock).mockResolvedValue(2);\r\n\r\n await service.update(1, updateDto, mockUser);\r\n\r\n expect(\r\n numberingService.updateNumberForDraft as jest.Mock\r\n ).toHaveBeenCalled();\r\n });\r\n\r\n it('should regenerate number if Document Type changes', async () => {\r\n const mockUser = { id: 1, primaryOrganizationId: 10 } as unknown as User;\r\n const mockRevision = {\r\n id: 100,\r\n correspondenceId: 1,\r\n isCurrent: true,\r\n statusId: 5,\r\n };\r\n jest\r\n .spyOn(revisionRepo, 'findOne')\r\n .mockResolvedValue(mockRevision as unknown as CorrespondenceRevision);\r\n\r\n const mockCorr = {\r\n id: 1,\r\n projectId: 1,\r\n correspondenceTypeId: 2,\r\n disciplineId: 3,\r\n originatorId: 10,\r\n correspondenceNumber: 'OLD-NUM',\r\n recipients: [{ recipientType: 'TO', recipientOrganizationId: 99 }],\r\n };\r\n jest\r\n .spyOn(correspondenceRepo, 'findOne')\r\n .mockResolvedValue(mockCorr as unknown as Correspondence);\r\n\r\n const updateDto: UpdateCorrespondenceDto = {\r\n typeId: 999,\r\n };\r\n\r\n const typeRepo = testingModule.get>(\r\n getRepositoryToken(CorrespondenceType)\r\n );\r\n (typeRepo.findOne as jest.Mock).mockResolvedValue({\r\n id: 999,\r\n typeCode: 'NEW-TYPE',\r\n });\r\n\r\n await service.update(1, updateDto, mockUser);\r\n\r\n expect(\r\n numberingService.updateNumberForDraft as jest.Mock\r\n ).toHaveBeenCalled();\r\n });\r\n\r\n it('should regenerate number if Recipient Organization changes', async () => {\r\n const mockUser = { id: 1, primaryOrganizationId: 10 } as unknown as User;\r\n const mockRevision = {\r\n id: 100,\r\n correspondenceId: 1,\r\n isCurrent: true,\r\n statusId: 5,\r\n };\r\n jest\r\n .spyOn(revisionRepo, 'findOne')\r\n .mockResolvedValue(mockRevision as unknown as CorrespondenceRevision);\r\n\r\n const mockCorr = {\r\n id: 1,\r\n projectId: 1,\r\n correspondenceTypeId: 2,\r\n disciplineId: 3,\r\n originatorId: 10,\r\n correspondenceNumber: 'OLD-NUM',\r\n recipients: [{ recipientType: 'TO', recipientOrganizationId: 99 }],\r\n };\r\n jest\r\n .spyOn(correspondenceRepo, 'findOne')\r\n .mockResolvedValue(mockCorr as unknown as Correspondence);\r\n\r\n // Access DataSource manager for mocking\r\n mockDataSource.manager.findOne.mockResolvedValue({\r\n id: 88,\r\n organizationCode: 'NEW-ORG',\r\n } as unknown as Organization);\r\n\r\n const updateDto: UpdateCorrespondenceDto = {\r\n recipients: [{ type: 'TO', organizationId: 88 }],\r\n };\r\n\r\n await service.update(1, updateDto, mockUser);\r\n\r\n expect(\r\n numberingService.updateNumberForDraft as jest.Mock\r\n ).toHaveBeenCalled();\r\n });\r\n });\r\n\r\n describe('create', () => {\r\n it('should allow system.manage_all user without primaryOrganizationId when originatorId is provided', async () => {\r\n const mockUser = {\r\n user_id: 1,\r\n primaryOrganizationId: null,\r\n } as unknown as User;\r\n\r\n const createDto: CreateCorrespondenceDto = {\r\n projectId: 'project-uuid',\r\n typeId: 1,\r\n subject: 'Test Subject',\r\n originatorId: 'originator-uuid',\r\n recipients: [{ organizationId: 'recipient-uuid', type: 'TO' }],\r\n };\r\n\r\n const userService = testingModule.get(UserService);\r\n const typeRepo = testingModule.get>(\r\n getRepositoryToken(CorrespondenceType)\r\n );\r\n const statusRepo = testingModule.get>(\r\n getRepositoryToken(CorrespondenceStatus)\r\n );\r\n const uuidResolver =\r\n testingModule.get(UuidResolverService);\r\n\r\n (userService.findOne as jest.Mock).mockResolvedValue({\r\n user_id: 1,\r\n primaryOrganizationId: null,\r\n });\r\n (userService.getUserPermissions as jest.Mock).mockResolvedValue([\r\n 'system.manage_all',\r\n ]);\r\n\r\n (uuidResolver.resolveProjectId as jest.Mock).mockResolvedValue(100);\r\n (uuidResolver.resolveOrganizationId as jest.Mock).mockImplementation(\r\n (value: number | string) => {\r\n if (value === 'originator-uuid') return 10;\r\n if (value === 'recipient-uuid') return 20;\r\n return 0;\r\n }\r\n );\r\n\r\n (typeRepo.findOne as jest.Mock).mockResolvedValue({\r\n id: 1,\r\n typeCode: 'LTR',\r\n });\r\n (statusRepo.findOne as jest.Mock).mockResolvedValue({\r\n id: 1,\r\n statusCode: 'DRAFT',\r\n });\r\n\r\n (numberingService.generateNextNumber as jest.Mock).mockResolvedValue({\r\n number: 'DOC-001',\r\n });\r\n\r\n mockDataSource.manager.findOne\r\n .mockResolvedValueOnce({ id: 10, organizationCode: 'ORG' })\r\n .mockResolvedValueOnce({ id: 20, organizationCode: 'REC' });\r\n\r\n const queryRunner = {\r\n connect: jest.fn(),\r\n startTransaction: jest.fn(),\r\n commitTransaction: jest.fn(),\r\n rollbackTransaction: jest.fn(),\r\n release: jest.fn(),\r\n manager: {\r\n create: jest.fn(\r\n (_entity: unknown, payload: Record) => payload\r\n ),\r\n save: jest\r\n .fn()\r\n .mockResolvedValueOnce({ id: 999, publicId: 'corr-uuid' })\r\n .mockResolvedValueOnce({ id: 1000 })\r\n .mockResolvedValueOnce([]),\r\n findOne: jest.fn(),\r\n },\r\n };\r\n\r\n (mockDataSource.createQueryRunner as jest.Mock).mockReturnValue(\r\n queryRunner\r\n );\r\n\r\n await service.create(createDto, mockUser);\r\n\r\n expect(queryRunner.manager.create).toHaveBeenCalledWith(\r\n Correspondence,\r\n expect.objectContaining({ originatorId: 10 })\r\n );\r\n });\r\n\r\n it('should set revisionLabel to \"A\" for RFA type', async () => {\r\n const mockUser = {\r\n user_id: 1,\r\n primaryOrganizationId: 10,\r\n } as unknown as User;\r\n\r\n const createDto: CreateCorrespondenceDto = {\r\n projectId: 'project-uuid',\r\n typeId: 1,\r\n subject: 'Test Subject',\r\n recipients: [{ organizationId: 'recipient-uuid', type: 'TO' }],\r\n };\r\n\r\n const typeRepo = testingModule.get>(\r\n getRepositoryToken(CorrespondenceType)\r\n );\r\n const statusRepo = testingModule.get>(\r\n getRepositoryToken(CorrespondenceStatus)\r\n );\r\n const uuidResolver =\r\n testingModule.get(UuidResolverService);\r\n\r\n (uuidResolver.resolveProjectId as jest.Mock).mockResolvedValue(100);\r\n (uuidResolver.resolveOrganizationId as jest.Mock).mockResolvedValue(20);\r\n\r\n (typeRepo.findOne as jest.Mock).mockResolvedValue({\r\n id: 1,\r\n typeCode: 'RFA',\r\n });\r\n (statusRepo.findOne as jest.Mock).mockResolvedValue({\r\n id: 1,\r\n statusCode: 'DRAFT',\r\n });\r\n\r\n (numberingService.generateNextNumber as jest.Mock).mockResolvedValue({\r\n number: 'DOC-001',\r\n });\r\n\r\n mockDataSource.manager.findOne\r\n .mockResolvedValueOnce({ id: 10, organizationCode: 'ORG' })\r\n .mockResolvedValueOnce({ id: 20, organizationCode: 'REC' });\r\n\r\n const queryRunner = {\r\n connect: jest.fn(),\r\n startTransaction: jest.fn(),\r\n commitTransaction: jest.fn(),\r\n rollbackTransaction: jest.fn(),\r\n release: jest.fn(),\r\n manager: {\r\n create: jest.fn(\r\n (_entity: unknown, payload: Record) => payload\r\n ),\r\n save: jest\r\n .fn()\r\n .mockResolvedValueOnce({ id: 999, publicId: 'corr-uuid' })\r\n .mockResolvedValueOnce({ id: 1000 })\r\n .mockResolvedValueOnce([]),\r\n findOne: jest.fn(),\r\n },\r\n };\r\n\r\n (mockDataSource.createQueryRunner as jest.Mock).mockReturnValue(\r\n queryRunner\r\n );\r\n\r\n await service.create(createDto, mockUser);\r\n\r\n expect(queryRunner.manager.create).toHaveBeenCalledWith(\r\n CorrespondenceRevision,\r\n expect.objectContaining({ revisionLabel: 'A' })\r\n );\r\n });\r\n\r\n it('should set revisionLabel to \"A\" for RFI type', async () => {\r\n const mockUser = {\r\n user_id: 1,\r\n primaryOrganizationId: 10,\r\n } as unknown as User;\r\n\r\n const createDto: CreateCorrespondenceDto = {\r\n projectId: 'project-uuid',\r\n typeId: 1,\r\n subject: 'Test Subject',\r\n recipients: [{ organizationId: 'recipient-uuid', type: 'TO' }],\r\n };\r\n\r\n const typeRepo = testingModule.get>(\r\n getRepositoryToken(CorrespondenceType)\r\n );\r\n const statusRepo = testingModule.get>(\r\n getRepositoryToken(CorrespondenceStatus)\r\n );\r\n const uuidResolver =\r\n testingModule.get(UuidResolverService);\r\n\r\n (uuidResolver.resolveProjectId as jest.Mock).mockResolvedValue(100);\r\n (uuidResolver.resolveOrganizationId as jest.Mock).mockResolvedValue(20);\r\n\r\n (typeRepo.findOne as jest.Mock).mockResolvedValue({\r\n id: 1,\r\n typeCode: 'RFI',\r\n });\r\n (statusRepo.findOne as jest.Mock).mockResolvedValue({\r\n id: 1,\r\n statusCode: 'DRAFT',\r\n });\r\n\r\n (numberingService.generateNextNumber as jest.Mock).mockResolvedValue({\r\n number: 'DOC-001',\r\n });\r\n\r\n mockDataSource.manager.findOne\r\n .mockResolvedValueOnce({ id: 10, organizationCode: 'ORG' })\r\n .mockResolvedValueOnce({ id: 20, organizationCode: 'REC' });\r\n\r\n const queryRunner = {\r\n connect: jest.fn(),\r\n startTransaction: jest.fn(),\r\n commitTransaction: jest.fn(),\r\n rollbackTransaction: jest.fn(),\r\n release: jest.fn(),\r\n manager: {\r\n create: jest.fn(\r\n (_entity: unknown, payload: Record) => payload\r\n ),\r\n save: jest\r\n .fn()\r\n .mockResolvedValueOnce({ id: 999, publicId: 'corr-uuid' })\r\n .mockResolvedValueOnce({ id: 1000 })\r\n .mockResolvedValueOnce([]),\r\n findOne: jest.fn(),\r\n },\r\n };\r\n\r\n (mockDataSource.createQueryRunner as jest.Mock).mockReturnValue(\r\n queryRunner\r\n );\r\n\r\n await service.create(createDto, mockUser);\r\n\r\n expect(queryRunner.manager.create).toHaveBeenCalledWith(\r\n CorrespondenceRevision,\r\n expect.objectContaining({ revisionLabel: 'A' })\r\n );\r\n });\r\n\r\n it('should set revisionLabel to null for LETTER type', async () => {\r\n const mockUser = {\r\n user_id: 1,\r\n primaryOrganizationId: 10,\r\n } as unknown as User;\r\n\r\n const createDto: CreateCorrespondenceDto = {\r\n projectId: 'project-uuid',\r\n typeId: 1,\r\n subject: 'Test Subject',\r\n recipients: [{ organizationId: 'recipient-uuid', type: 'TO' }],\r\n };\r\n\r\n const typeRepo = testingModule.get>(\r\n getRepositoryToken(CorrespondenceType)\r\n );\r\n const statusRepo = testingModule.get>(\r\n getRepositoryToken(CorrespondenceStatus)\r\n );\r\n const uuidResolver =\r\n testingModule.get(UuidResolverService);\r\n\r\n (uuidResolver.resolveProjectId as jest.Mock).mockResolvedValue(100);\r\n (uuidResolver.resolveOrganizationId as jest.Mock).mockResolvedValue(20);\r\n\r\n (typeRepo.findOne as jest.Mock).mockResolvedValue({\r\n id: 1,\r\n typeCode: 'LETTER',\r\n });\r\n (statusRepo.findOne as jest.Mock).mockResolvedValue({\r\n id: 1,\r\n statusCode: 'DRAFT',\r\n });\r\n\r\n (numberingService.generateNextNumber as jest.Mock).mockResolvedValue({\r\n number: 'DOC-001',\r\n });\r\n\r\n mockDataSource.manager.findOne\r\n .mockResolvedValueOnce({ id: 10, organizationCode: 'ORG' })\r\n .mockResolvedValueOnce({ id: 20, organizationCode: 'REC' });\r\n\r\n const queryRunner = {\r\n connect: jest.fn(),\r\n startTransaction: jest.fn(),\r\n commitTransaction: jest.fn(),\r\n rollbackTransaction: jest.fn(),\r\n release: jest.fn(),\r\n manager: {\r\n create: jest.fn(\r\n (_entity: unknown, payload: Record) => payload\r\n ),\r\n save: jest\r\n .fn()\r\n .mockResolvedValueOnce({ id: 999, publicId: 'corr-uuid' })\r\n .mockResolvedValueOnce({ id: 1000 })\r\n .mockResolvedValueOnce([]),\r\n findOne: jest.fn(),\r\n },\r\n };\r\n\r\n (mockDataSource.createQueryRunner as jest.Mock).mockReturnValue(\r\n queryRunner\r\n );\r\n\r\n await service.create(createDto, mockUser);\r\n\r\n expect(queryRunner.manager.create).toHaveBeenCalledWith(\r\n CorrespondenceRevision,\r\n expect.objectContaining({ revisionLabel: null })\r\n );\r\n });\r\n\r\n it('should set revisionLabel to null for MEMO type', async () => {\r\n const mockUser = {\r\n user_id: 1,\r\n primaryOrganizationId: 10,\r\n } as unknown as User;\r\n\r\n const createDto: CreateCorrespondenceDto = {\r\n projectId: 'project-uuid',\r\n typeId: 1,\r\n subject: 'Test Subject',\r\n recipients: [{ organizationId: 'recipient-uuid', type: 'TO' }],\r\n };\r\n\r\n const typeRepo = testingModule.get>(\r\n getRepositoryToken(CorrespondenceType)\r\n );\r\n const statusRepo = testingModule.get>(\r\n getRepositoryToken(CorrespondenceStatus)\r\n );\r\n const uuidResolver =\r\n testingModule.get(UuidResolverService);\r\n\r\n (uuidResolver.resolveProjectId as jest.Mock).mockResolvedValue(100);\r\n (uuidResolver.resolveOrganizationId as jest.Mock).mockResolvedValue(20);\r\n\r\n (typeRepo.findOne as jest.Mock).mockResolvedValue({\r\n id: 1,\r\n typeCode: 'MEMO',\r\n });\r\n (statusRepo.findOne as jest.Mock).mockResolvedValue({\r\n id: 1,\r\n statusCode: 'DRAFT',\r\n });\r\n\r\n (numberingService.generateNextNumber as jest.Mock).mockResolvedValue({\r\n number: 'DOC-001',\r\n });\r\n\r\n mockDataSource.manager.findOne\r\n .mockResolvedValueOnce({ id: 10, organizationCode: 'ORG' })\r\n .mockResolvedValueOnce({ id: 20, organizationCode: 'REC' });\r\n\r\n const queryRunner = {\r\n connect: jest.fn(),\r\n startTransaction: jest.fn(),\r\n commitTransaction: jest.fn(),\r\n rollbackTransaction: jest.fn(),\r\n release: jest.fn(),\r\n manager: {\r\n create: jest.fn(\r\n (_entity: unknown, payload: Record) => payload\r\n ),\r\n save: jest\r\n .fn()\r\n .mockResolvedValueOnce({ id: 999, publicId: 'corr-uuid' })\r\n .mockResolvedValueOnce({ id: 1000 })\r\n .mockResolvedValueOnce([]),\r\n findOne: jest.fn(),\r\n },\r\n };\r\n\r\n (mockDataSource.createQueryRunner as jest.Mock).mockReturnValue(\r\n queryRunner\r\n );\r\n\r\n await service.create(createDto, mockUser);\r\n\r\n expect(queryRunner.manager.create).toHaveBeenCalledWith(\r\n CorrespondenceRevision,\r\n expect.objectContaining({ revisionLabel: null })\r\n );\r\n });\r\n });\r\n});\r\n"],"version":3} \ No newline at end of file diff --git a/backend/src/.jest-cache/jest-transform-cache-60cab15b743c6776f41d29bcac696b99-12533232bd0f05f65688e7a7764bf3fb/d8/correspondenceservice_d8463801745469340085197633f7ae6b b/backend/src/.jest-cache/jest-transform-cache-60cab15b743c6776f41d29bcac696b99-12533232bd0f05f65688e7a7764bf3fb/d8/correspondenceservice_d8463801745469340085197633f7ae6b new file mode 100644 index 0000000..333767e --- /dev/null +++ b/backend/src/.jest-cache/jest-transform-cache-60cab15b743c6776f41d29bcac696b99-12533232bd0f05f65688e7a7764bf3fb/d8/correspondenceservice_d8463801745469340085197633f7ae6b @@ -0,0 +1,893 @@ +f958e3e0fd6fd813cf9552bbff491967 +"use strict"; +// File: src/modules/correspondence/correspondence.service.ts +var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; +}; +var __metadata = (this && this.__metadata) || function (k, v) { + if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v); +}; +var __param = (this && this.__param) || function (paramIndex, decorator) { + return function (target, key) { decorator(target, key, paramIndex); } +}; +var CorrespondenceService_1; +var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.CorrespondenceService = void 0; +const common_1 = require("@nestjs/common"); +const typeorm_1 = require("@nestjs/typeorm"); +const typeorm_2 = require("typeorm"); +// Entities +const correspondence_entity_1 = require("./entities/correspondence.entity"); +const correspondence_revision_entity_1 = require("./entities/correspondence-revision.entity"); +const correspondence_type_entity_1 = require("./entities/correspondence-type.entity"); +const correspondence_status_entity_1 = require("./entities/correspondence-status.entity"); +const correspondence_reference_entity_1 = require("./entities/correspondence-reference.entity"); +const correspondence_recipient_entity_1 = require("./entities/correspondence-recipient.entity"); +const correspondence_tag_entity_1 = require("./entities/correspondence-tag.entity"); +const tag_entity_1 = require("../master/entities/tag.entity"); +const organization_entity_1 = require("../organization/entities/organization.entity"); +// Services +const document_numbering_service_1 = require("../document-numbering/services/document-numbering.service"); +const json_schema_service_1 = require("../json-schema/json-schema.service"); +const workflow_engine_service_1 = require("../workflow-engine/workflow-engine.service"); +const user_service_1 = require("../user/user.service"); +const search_service_1 = require("../search/search.service"); +const file_storage_service_1 = require("../../common/file-storage/file-storage.service"); +const uuid_resolver_service_1 = require("../../common/services/uuid-resolver.service"); +const notification_service_1 = require("../notification/notification.service"); +let CorrespondenceService = CorrespondenceService_1 = class CorrespondenceService { + async hasSystemManageAllPermission(userId) { + const permissions = await this.userService.getUserPermissions(userId); + return permissions.includes('system.manage_all'); + } + /** + * Business Rule: Revision Label Strategy + * - RFA, RFI: Use alphabet starting with 'A' (A, B, C...) + * - Other types (LETTER, MEMO, etc.): Use numeric (null for first, then 1, 2, 3...) + */ + getInitialRevisionLabel(typeCode) { + const alphabetTypes = ['RFA', 'RFI']; + if (alphabetTypes.includes(typeCode.toUpperCase())) { + return 'A'; // Alphabet for RFA, RFI + } + return null; // Numeric (null for revision 0) + } + constructor(correspondenceRepo, revisionRepo, typeRepo, statusRepo, referenceRepo, tagRepo, numberingService, jsonSchemaService, workflowEngine, userService, dataSource, searchService, fileStorageService, uuidResolver, notificationService) { + this.correspondenceRepo = correspondenceRepo; + this.revisionRepo = revisionRepo; + this.typeRepo = typeRepo; + this.statusRepo = statusRepo; + this.referenceRepo = referenceRepo; + this.tagRepo = tagRepo; + this.numberingService = numberingService; + this.jsonSchemaService = jsonSchemaService; + this.workflowEngine = workflowEngine; + this.userService = userService; + this.dataSource = dataSource; + this.searchService = searchService; + this.fileStorageService = fileStorageService; + this.uuidResolver = uuidResolver; + this.notificationService = notificationService; + this.logger = new common_1.Logger(CorrespondenceService_1.name); + } + /** + * Business Rule Validation: EC-CORR-003 - Correspondence to Self + * Prevent external correspondence to same organization + */ + async validateCorrespondenceRecipients(createDto, user) { + // Get user's organization + let userOrgId = user.primaryOrganizationId; + if (!userOrgId) { + const fullUser = await this.userService.findOne(user.user_id); + if (fullUser) { + userOrgId = fullUser.primaryOrganizationId; + } + } + if (!userOrgId) { + if (createDto.originatorId) { + const canManageAll = await this.hasSystemManageAllPermission(user.user_id); + if (canManageAll) { + userOrgId = await this.uuidResolver.resolveOrganizationId(createDto.originatorId); + } + } + if (!userOrgId) { + throw new common_1.BadRequestException('User must belong to an organization to create documents'); + } + } + // For impersonation, use the specified originator + const originatorOrgId = createDto.originatorId + ? await this.uuidResolver.resolveOrganizationId(createDto.originatorId) + : userOrgId; + // Check if it's internal communication + if (createDto.isInternal) { + // Internal communications should use Circulation instead + throw new common_1.BadRequestException('Internal communications should use Circulation Sheet instead of Correspondence'); + } + // Validate recipients + if (!createDto.recipients || createDto.recipients.length === 0) { + throw new common_1.BadRequestException('At least one recipient (TO or CC) is required'); + } + const toRecipients = createDto.recipients.filter((r) => r.type === 'TO'); + const ccRecipients = createDto.recipients.filter((r) => r.type === 'CC'); + if (toRecipients.length === 0 && ccRecipients.length === 0) { + throw new common_1.BadRequestException('At least one TO or CC recipient is required'); + } + // Check for same organization correspondence + for (const recipient of createDto.recipients) { + const recipientOrgId = await this.uuidResolver.resolveOrganizationId(recipient.organizationId); + if (recipientOrgId === originatorOrgId) { + throw new common_1.BadRequestException('Cannot send correspondence to your own organization. Use Circulation Sheet for internal communication.'); + } + } + } + async create(createDto, user) { + // Business Rule Validation: EC-CORR-003 - Correspondence to Self + await this.validateCorrespondenceRecipients(createDto, user); + // ADR-019: Resolve UUID references to internal INT IDs + const resolvedProjectId = await this.uuidResolver.resolveProjectId(createDto.projectId); + const resolvedOriginatorId = createDto.originatorId + ? await this.uuidResolver.resolveOrganizationId(createDto.originatorId) + : undefined; + const resolvedRecipients = createDto.recipients + ? await Promise.all(createDto.recipients.map(async (r) => ({ + organizationId: await this.uuidResolver.resolveOrganizationId(r.organizationId), + type: r.type, + }))) + : undefined; + const type = await this.typeRepo.findOne({ + where: { id: createDto.typeId }, + }); + if (!type) + throw new common_1.NotFoundException('Document Type not found'); + const statusDraft = await this.statusRepo.findOne({ + where: { statusCode: 'DRAFT' }, + }); + if (!statusDraft) { + throw new common_1.InternalServerErrorException('Status DRAFT not found in Master Data'); + } + let userOrgId = user.primaryOrganizationId; + if (!userOrgId) { + const fullUser = await this.userService.findOne(user.user_id); + if (fullUser) { + userOrgId = fullUser.primaryOrganizationId; + } + } + // Impersonation Logic + if (resolvedOriginatorId && resolvedOriginatorId !== userOrgId) { + const canManageAll = await this.hasSystemManageAllPermission(user.user_id); + if (!canManageAll) { + throw new common_1.ForbiddenException('You do not have permission to create documents on behalf of other organizations.'); + } + userOrgId = resolvedOriginatorId; + } + if (!userOrgId) { + throw new common_1.BadRequestException('User must belong to an organization to create documents'); + } + if (createDto.details) { + try { + await this.jsonSchemaService.validate(type.typeCode, createDto.details); + } + catch (error) { + this.logger.warn(`Schema validation warning for ${type.typeCode}: ${error.message}`); + } + } + const queryRunner = this.dataSource.createQueryRunner(); + await queryRunner.connect(); + await queryRunner.startTransaction(); + try { + // [Fix #6] Fetch real ORG Code from Organization entity + const originatorOrg = await this.dataSource.manager.findOne(organization_entity_1.Organization, { + where: { id: userOrgId }, + }); + const orgCode = originatorOrg?.organizationCode ?? 'UNK'; + // [v1.5.1] Extract recipient organization from recipients array (Primary TO) + const toRecipient = resolvedRecipients?.find((r) => r.type === 'TO'); + const recipientOrganizationId = toRecipient?.organizationId; + let recipientCode = ''; + if (recipientOrganizationId) { + const recOrg = await this.dataSource.manager.findOne(organization_entity_1.Organization, { + where: { id: recipientOrganizationId }, + }); + if (recOrg) + recipientCode = recOrg.organizationCode; + } + const docNumber = await this.numberingService.generateNextNumber({ + projectId: resolvedProjectId, + originatorOrganizationId: userOrgId, + typeId: createDto.typeId, + disciplineId: createDto.disciplineId, + subTypeId: createDto.subTypeId, + recipientOrganizationId, // [v1.5.1] Pass recipient for document number format + year: new Date().getFullYear(), + customTokens: { + TYPE_CODE: type.typeCode, + ORG_CODE: orgCode, + RECIPIENT_CODE: recipientCode, + REC_CODE: recipientCode, + }, + }); + const correspondence = queryRunner.manager.create(correspondence_entity_1.Correspondence, { + correspondenceNumber: docNumber.number, + correspondenceTypeId: createDto.typeId, + disciplineId: createDto.disciplineId, + projectId: resolvedProjectId, + originatorId: userOrgId, + isInternal: createDto.isInternal || false, + createdBy: user.user_id, + }); + const savedCorr = await queryRunner.manager.save(correspondence); + const revision = queryRunner.manager.create(correspondence_revision_entity_1.CorrespondenceRevision, { + correspondenceId: savedCorr.id, + revisionNumber: 0, + revisionLabel: this.getInitialRevisionLabel(type.typeCode), + isCurrent: true, + statusId: statusDraft.id, + subject: createDto.subject, + body: createDto.body, + remarks: createDto.remarks, + dueDate: createDto.dueDate ? new Date(createDto.dueDate) : undefined, + documentDate: createDto.documentDate + ? new Date(createDto.documentDate) + : undefined, + issuedDate: createDto.issuedDate + ? new Date(createDto.issuedDate) + : undefined, + receivedDate: createDto.receivedDate + ? new Date(createDto.receivedDate) + : undefined, + description: createDto.description, + details: createDto.details, + createdBy: user.user_id, + schemaVersion: 1, + }); + await queryRunner.manager.save(revision); + // Save Recipients (using resolved INT IDs) + if (resolvedRecipients && resolvedRecipients.length > 0) { + const recipients = resolvedRecipients.map((r) => queryRunner.manager.create(correspondence_recipient_entity_1.CorrespondenceRecipient, { + correspondenceId: savedCorr.id, + recipientOrganizationId: r.organizationId, + recipientType: r.type, + })); + await queryRunner.manager.save(recipients); + } + // Commit attachments from Temp → Permanent (Two-Phase Storage) + if (createDto.attachmentTempIds?.length) { + const issueDate = createDto.issuedDate + ? new Date(createDto.issuedDate) + : createDto.documentDate + ? new Date(createDto.documentDate) + : undefined; + await this.fileStorageService.commit(createDto.attachmentTempIds, { + issueDate, + documentType: 'Correspondence', + }); + } + await queryRunner.commitTransaction(); + // Start Workflow Instance (non-blocking) + try { + const workflowCode = `CORRESPONDENCE_${type.typeCode}`; + await this.workflowEngine.createInstance(workflowCode, 'correspondence', savedCorr.id.toString(), { + projectId: resolvedProjectId, + originatorId: userOrgId, + disciplineId: createDto.disciplineId, + initiatorId: user.user_id, + }); + } + catch (error) { + this.logger.warn(`Workflow not started for ${docNumber.number} (Code: CORRESPONDENCE_${type.typeCode}): ${error.message}`); + } + // Fire-and-forget search indexing (non-blocking, void intentional) + void this.searchService.indexDocument({ + id: savedCorr.id, + publicId: savedCorr.publicId, + type: 'correspondence', + docNumber: docNumber.number, + title: createDto.subject, + description: createDto.description, + status: 'DRAFT', + projectId: resolvedProjectId, + createdAt: new Date(), + }); + return { + ...savedCorr, + currentRevision: revision, + }; + } + catch (err) { + await queryRunner.rollbackTransaction(); + this.logger.error(`Failed to create correspondence: ${err.message}`); + throw err; + } + finally { + await queryRunner.release(); + } + } + async findAll(searchDto = {}) { + const { search, typeId, projectId, statusId, status, page = 1, limit = 10, } = searchDto; + const skip = (page - 1) * limit; + // Change: Query from Revision Repo + const query = this.revisionRepo + .createQueryBuilder('rev') + .leftJoinAndSelect('rev.correspondence', 'corr') + .leftJoinAndSelect('corr.type', 'type') + .leftJoinAndSelect('corr.project', 'project') + .leftJoinAndSelect('corr.originator', 'org') + .leftJoinAndSelect('rev.status', 'status'); + // Filter by Revision Status + const revStatus = searchDto.revisionStatus || 'CURRENT'; + if (revStatus === 'CURRENT') { + query.where('rev.isCurrent = :isCurrent', { isCurrent: true }); + } + else if (revStatus === 'OLD') { + query.where('rev.isCurrent = :isCurrent', { isCurrent: false }); + } + // If 'ALL', no filter needed on isCurrent + if (projectId) { + query.andWhere('corr.projectId = :projectId', { projectId }); + } + if (typeId) { + query.andWhere('corr.correspondenceTypeId = :typeId', { typeId }); + } + if (statusId) { + query.andWhere('rev.statusId = :statusId', { statusId }); + } + if (status) { + query.andWhere('status.statusCode = :status', { status }); + } + if (search) { + query.andWhere('(corr.correspondenceNumber LIKE :search OR rev.subject LIKE :search)', { search: `%${search}%` }); + } + // Default Sort: Latest Created + query.orderBy('rev.createdAt', 'DESC').skip(skip).take(limit); + const [items, total] = await query.getManyAndCount(); + return { + data: items, + meta: { + total, + page, + limit, + totalPages: Math.ceil(total / limit), + }, + }; + } + async findOne(id) { + const correspondence = await this.correspondenceRepo.findOne({ + where: { id }, + relations: [ + 'revisions', + 'revisions.status', + 'type', + 'project', + 'originator', + 'recipients', + 'recipients.recipientOrganization', // [v1.5.1] Fixed relation name + ], + }); + if (!correspondence) { + throw new common_1.NotFoundException(`Correspondence with ID ${id} not found`); + } + return correspondence; + } + async findOneByUuid(publicId) { + const correspondence = await this.correspondenceRepo.findOne({ + where: { publicId }, + relations: [ + 'revisions', + 'revisions.status', + 'type', + 'project', + 'originator', + 'recipients', + 'recipients.recipientOrganization', + ], + }); + if (!correspondence) { + throw new common_1.NotFoundException(`Correspondence with UUID ${publicId} not found`); + } + return correspondence; + } + async addReference(id, dto) { + const source = await this.correspondenceRepo.findOne({ where: { id } }); + // ADR-019: Resolve target publicId → internal INT id + const target = await this.correspondenceRepo.findOne({ + where: { publicId: dto.targetUuid }, + }); + if (!source || !target) { + throw new common_1.NotFoundException('Source or Target correspondence not found'); + } + if (source.id === target.id) { + throw new common_1.BadRequestException('Cannot reference self'); + } + const exists = await this.referenceRepo.findOne({ + where: { + sourceId: id, + targetId: target.id, + }, + }); + if (exists) { + return exists; + } + const ref = this.referenceRepo.create({ + sourceId: id, + targetId: target.id, + }); + return this.referenceRepo.save(ref); + } + async removeReference(id, targetId) { + const result = await this.referenceRepo.delete({ + sourceId: id, + targetId: targetId, + }); + if (result.affected === 0) { + throw new common_1.NotFoundException('Reference not found'); + } + } + async getTags(id) { + const rows = await this.tagRepo.find({ + where: { correspondenceId: id }, + relations: ['tag'], + }); + return rows.map((r) => r.tag).filter(Boolean); + } + async addTag(id, tagId) { + const correspondence = await this.correspondenceRepo.findOne({ + where: { id }, + }); + if (!correspondence) { + throw new common_1.NotFoundException(`Correspondence ${id} not found`); + } + const tag = await this.dataSource.manager.findOne(tag_entity_1.Tag, { + where: { id: tagId }, + }); + if (!tag) { + throw new common_1.NotFoundException(`Tag ${tagId} not found`); + } + const exists = await this.tagRepo.findOne({ + where: { correspondenceId: id, tagId }, + }); + if (exists) + return exists; + const row = this.tagRepo.create({ correspondenceId: id, tagId }); + return this.tagRepo.save(row); + } + async removeTag(id, tagId) { + const result = await this.tagRepo.delete({ correspondenceId: id, tagId }); + if (result.affected === 0) { + throw new common_1.NotFoundException('Tag assignment not found'); + } + } + async getReferences(id) { + const outgoing = await this.referenceRepo.find({ + where: { sourceId: id }, + relations: ['target', 'target.type'], + }); + const incoming = await this.referenceRepo.find({ + where: { targetId: id }, + relations: ['source', 'source.type'], + }); + return { outgoing, incoming }; + } + async update(id, updateDto, user) { + // 1. Find Current Revision + const revision = await this.revisionRepo.findOne({ + where: { + correspondenceId: id, + isCurrent: true, + }, + relations: ['correspondence'], + }); + if (!revision) { + throw new common_1.NotFoundException(`Current revision for correspondence ${id} not found`); + } + // 2. Check Permission + if (revision.statusId) { + const status = await this.statusRepo.findOne({ + where: { id: revision.statusId }, + }); + if (status && status.statusCode !== 'DRAFT') { + throw new common_1.BadRequestException('Only DRAFT documents can be updated'); + } + } + // ADR-019: Resolve UUID references in update DTO + const updResolvedProjectId = updateDto.projectId + ? await this.uuidResolver.resolveProjectId(updateDto.projectId) + : undefined; + const updResolvedOriginatorId = updateDto.originatorId + ? await this.uuidResolver.resolveOrganizationId(updateDto.originatorId) + : undefined; + const updResolvedRecipients = updateDto.recipients + ? await Promise.all(updateDto.recipients.map(async (r) => ({ + organizationId: await this.uuidResolver.resolveOrganizationId(r.organizationId), + type: r.type, + }))) + : undefined; + // 3. Update Correspondence Entity if needed + const correspondenceUpdate = {}; + if (updateDto.disciplineId) + correspondenceUpdate.disciplineId = updateDto.disciplineId; + if (updResolvedProjectId) + correspondenceUpdate.projectId = updResolvedProjectId; + if (updResolvedOriginatorId) + correspondenceUpdate.originatorId = updResolvedOriginatorId; + if (Object.keys(correspondenceUpdate).length > 0) { + await this.correspondenceRepo.update(id, correspondenceUpdate); + } + // 4. Update Revision Entity + const revisionUpdate = {}; + if (updateDto.subject) + revisionUpdate.subject = updateDto.subject; + if (updateDto.body) + revisionUpdate.body = updateDto.body; + if (updateDto.remarks) + revisionUpdate.remarks = updateDto.remarks; + // Format Date correctly if string + if (updateDto.dueDate) + revisionUpdate.dueDate = new Date(updateDto.dueDate); + if (updateDto.documentDate) + revisionUpdate.documentDate = new Date(updateDto.documentDate); + if (updateDto.issuedDate) + revisionUpdate.issuedDate = new Date(updateDto.issuedDate); + if (updateDto.receivedDate) + revisionUpdate.receivedDate = new Date(updateDto.receivedDate); + if (updateDto.description) + revisionUpdate.description = updateDto.description; + if (updateDto.details) + revisionUpdate.details = updateDto.details; + if (Object.keys(revisionUpdate).length > 0) { + await this.revisionRepo.update(revision.id, revisionUpdate); + } + // 4.5 Commit new attachments from Temp → Permanent (Two-Phase Storage) + if (updateDto.attachmentTempIds?.length) { + const issueDate = updateDto.issuedDate + ? new Date(updateDto.issuedDate) + : updateDto.documentDate + ? new Date(updateDto.documentDate) + : revision.issuedDate || revision.documentDate || undefined; + await this.fileStorageService.commit(updateDto.attachmentTempIds, { + issueDate: issueDate ? new Date(issueDate) : undefined, + documentType: 'Correspondence', + }); + } + // 5. Update Recipients if provided + if (updResolvedRecipients) { + const recipientRepo = this.dataSource.getRepository(correspondence_recipient_entity_1.CorrespondenceRecipient); + await recipientRepo.delete({ correspondenceId: id }); + const newRecipients = updResolvedRecipients.map((r) => recipientRepo.create({ + correspondenceId: id, + recipientOrganizationId: r.organizationId, + recipientType: r.type, + })); + await recipientRepo.save(newRecipients); + } + // 6. Regenerate Document Number if structural fields changed (Recipient, Discipline, Type, Project) + // AND it is a DRAFT. + // Fetch fresh data for context and comparison + const currentCorr = await this.correspondenceRepo.findOne({ + where: { id }, + relations: ['type', 'recipients', 'recipients.recipientOrganization'], + }); + if (currentCorr) { + const currentToRecipient = currentCorr.recipients?.find((r) => r.recipientType === 'TO'); + const currentRecipientId = currentToRecipient?.recipientOrganizationId; + // Check for ACTUAL value changes + const isProjectChanged = updResolvedProjectId !== undefined && + updResolvedProjectId !== currentCorr.projectId; + const isOriginatorChanged = updResolvedOriginatorId !== undefined && + updResolvedOriginatorId !== currentCorr.originatorId; + const isDisciplineChanged = updateDto.disciplineId !== undefined && + updateDto.disciplineId !== currentCorr.disciplineId; + const isTypeChanged = updateDto.typeId !== undefined && + updateDto.typeId !== currentCorr.correspondenceTypeId; + let isRecipientChanged = false; + let newRecipientId; + if (updResolvedRecipients) { + const newToRecipient = updResolvedRecipients.find((r) => r.type === 'TO'); + newRecipientId = newToRecipient?.organizationId; + if (newRecipientId !== currentRecipientId) { + isRecipientChanged = true; + } + } + if (isProjectChanged || + isDisciplineChanged || + isTypeChanged || + isRecipientChanged || + isOriginatorChanged) { + const targetRecipientId = isRecipientChanged + ? newRecipientId + : currentRecipientId; + // Resolve Recipient Code for the NEW context + let recipientCode = ''; + if (targetRecipientId) { + const recOrg = await this.dataSource.manager.findOne(organization_entity_1.Organization, { + where: { id: targetRecipientId }, + }); + if (recOrg) + recipientCode = recOrg.organizationCode; + } + // [Fix #6] Fetch real ORG Code from originator organization + const originatorOrgForUpdate = await this.dataSource.manager.findOne(organization_entity_1.Organization, { + where: { + id: updResolvedOriginatorId ?? currentCorr.originatorId ?? 0, + }, + }); + const orgCode = originatorOrgForUpdate?.organizationCode ?? 'UNK'; + // Prepare Contexts + const oldCtx = { + projectId: currentCorr.projectId, + originatorOrganizationId: currentCorr.originatorId ?? 0, + typeId: currentCorr.correspondenceTypeId, + disciplineId: currentCorr.disciplineId, + recipientOrganizationId: currentRecipientId, + year: new Date().getFullYear(), + }; + const newCtx = { + projectId: updResolvedProjectId ?? currentCorr.projectId, + originatorOrganizationId: updResolvedOriginatorId ?? currentCorr.originatorId ?? 0, + typeId: updateDto.typeId ?? currentCorr.correspondenceTypeId, + disciplineId: updateDto.disciplineId ?? currentCorr.disciplineId, + recipientOrganizationId: targetRecipientId, + year: new Date().getFullYear(), + userId: user.user_id, // Pass User ID for Audit + customTokens: { + TYPE_CODE: currentCorr.type?.typeCode || '', + ORG_CODE: orgCode, + RECIPIENT_CODE: recipientCode, + REC_CODE: recipientCode, + }, + }; + // If Type Changed, need NEW Type Code + if (isTypeChanged) { + const newType = await this.typeRepo.findOne({ + where: { id: newCtx.typeId }, + }); + if (newType) + newCtx.customTokens.TYPE_CODE = newType.typeCode; + } + const newDocNumber = await this.numberingService.updateNumberForDraft(currentCorr.correspondenceNumber, oldCtx, newCtx); + await this.correspondenceRepo.update(id, { + correspondenceNumber: newDocNumber, + }); + } + } + const updated = await this.findOne(id); + // Re-index updated document in Elasticsearch (fire-and-forget) + void this.searchService.indexDocument({ + id: updated.id, + publicId: updated.publicId, + type: 'correspondence', + docNumber: updated.correspondenceNumber, + title: updateDto.subject ?? updated.revisions?.[0]?.subject, + description: updateDto.description ?? updated.revisions?.[0]?.description, + status: 'DRAFT', + projectId: updated.projectId, + createdAt: updated.createdAt, + }); + return updated; + } + async previewDocumentNumber(createDto, user) { + // ADR-019: Resolve UUID references + const previewProjectId = await this.uuidResolver.resolveProjectId(createDto.projectId); + const previewOriginatorId = createDto.originatorId + ? await this.uuidResolver.resolveOrganizationId(createDto.originatorId) + : undefined; + const previewRecipients = createDto.recipients + ? await Promise.all(createDto.recipients.map(async (r) => ({ + organizationId: await this.uuidResolver.resolveOrganizationId(r.organizationId), + type: r.type, + }))) + : undefined; + const type = await this.typeRepo.findOne({ + where: { id: createDto.typeId }, + }); + if (!type) + throw new common_1.NotFoundException('Document Type not found'); + let userOrgId = user.primaryOrganizationId; + if (!userOrgId) { + const fullUser = await this.userService.findOne(user.user_id); + if (fullUser) + userOrgId = fullUser.primaryOrganizationId; + } + if (previewOriginatorId && previewOriginatorId !== userOrgId) { + // Allow impersonation for preview + userOrgId = previewOriginatorId; + } + // Extract recipient from recipients array + const toRecipient = previewRecipients?.find((r) => r.type === 'TO'); + const recipientOrganizationId = toRecipient?.organizationId; + let recipientCode = ''; + if (recipientOrganizationId) { + const recOrg = await this.dataSource.manager.findOne(organization_entity_1.Organization, { + where: { id: recipientOrganizationId }, + }); + if (recOrg) + recipientCode = recOrg.organizationCode; + } + return this.numberingService.previewNumber({ + projectId: previewProjectId, + originatorOrganizationId: userOrgId, + typeId: createDto.typeId, + disciplineId: createDto.disciplineId, + subTypeId: createDto.subTypeId, + recipientOrganizationId, + year: new Date().getFullYear(), + customTokens: { + TYPE_CODE: type.typeCode, + RECIPIENT_CODE: recipientCode, + REC_CODE: recipientCode, + }, + }); + } + /** + * Business Rule Implementation: EC-CORR-001 - Cancel Correspondence with Downstream Circulation + * Cancel correspondence and handle related circulations + */ + async cancel(publicId, reason, user) { + const correspondence = await this.findOneByUuid(publicId); + // Check if user has permission to cancel (Org Admin or Superadmin only) + const permissions = await this.userService.getUserPermissions(user.user_id); + const canCancel = permissions.includes('correspondence.cancel') || + permissions.includes('system.manage_all'); + if (!canCancel) { + throw new common_1.ForbiddenException('Only administrators can cancel correspondences'); + } + // Check if there are any active circulations + const circulationRepo = this.dataSource.getRepository('Circulation'); + const activeCirculations = await circulationRepo.find({ + where: { + correspondenceId: correspondence.id, + status: 'OPEN', + }, + }); + const warningMessage = activeCirculations.length > 0 + ? `There are ${activeCirculations.length} active circulation(s) for this correspondence. Canceling will force close all related circulations.` + : ''; + // Get the current revision to update status + const currentRevision = await this.revisionRepo.findOne({ + where: { + correspondenceId: correspondence.id, + isCurrent: true, + }, + }); + if (!currentRevision) { + throw new common_1.NotFoundException('Current revision not found'); + } + // Get cancelled status + const cancelledStatus = await this.statusRepo.findOne({ + where: { statusCode: 'CANCELLED' }, + }); + if (!cancelledStatus) { + throw new common_1.InternalServerErrorException('CANCELLED status not found'); + } + const queryRunner = this.dataSource.createQueryRunner(); + await queryRunner.connect(); + await queryRunner.startTransaction(); + try { + // Update correspondence revision status to CANCELLED + await queryRunner.manager.update(correspondence_revision_entity_1.CorrespondenceRevision, currentRevision.id, { + statusId: cancelledStatus.id, + remarks: `Cancelled: ${reason}`, + }); + // Force close all active circulations + if (activeCirculations.length > 0) { + await queryRunner.manager.update('Circulation', { + correspondenceId: correspondence.id, + status: 'OPEN', + }, { + status: 'FORCE_CLOSED', + closedAt: new Date(), + closedBy: user.user_id, + closeReason: `Correspondence cancelled: ${reason}`, + }); + } + await queryRunner.commitTransaction(); + // Re-index cancelled status in Elasticsearch (fire-and-forget) + void this.searchService.indexDocument({ + id: correspondence.id, + publicId: correspondence.publicId, + type: 'correspondence', + docNumber: correspondence.correspondenceNumber, + title: currentRevision.subject, + status: 'CANCELLED', + projectId: correspondence.projectId, + createdAt: correspondence.createdAt, + }); + // Notify originator's doc-control user about cancellation (fire-and-forget) + if (correspondence.originatorId) { + void this.userService + .findDocControlIdByOrg(correspondence.originatorId) + .then((targetUserId) => { + if (targetUserId) { + void this.notificationService.send({ + userId: targetUserId, + title: 'Correspondence Cancelled', + message: `${correspondence.correspondenceNumber} — ${currentRevision.subject} has been cancelled. Reason: ${reason}`, + type: 'EMAIL', + entityType: 'correspondence', + entityId: correspondence.id, + link: `/correspondences/${correspondence.publicId}`, + }); + } + }) + .catch((err) => this.logger.warn(`Cancel notification failed: ${err.message}`)); + } + return { + success: true, + message: warningMessage || 'Correspondence cancelled successfully', + activeCirculationsCount: activeCirculations.length, + }; + } + catch (error) { + await queryRunner.rollbackTransaction(); + this.logger.error(`Failed to cancel correspondence: ${error.message}`); + throw error; + } + finally { + await queryRunner.release(); + } + } + async bulkCancel(publicIds, reason, user) { + const succeeded = []; + const failed = []; + for (const publicId of publicIds) { + try { + await this.cancel(publicId, reason, user); + succeeded.push(publicId); + } + catch { + failed.push(publicId); + } + } + return { succeeded, failed }; + } + async exportCsv(searchDto) { + const { data } = await this.findAll(searchDto); + const header = [ + 'Document No.', + 'Rev', + 'Subject', + 'Type', + 'Status', + 'Project', + 'From', + 'Due Date', + 'Created At', + ]; + const rows = data.map((rev) => { + const corr = rev.correspondence ?? rev; + return [ + this.escapeCsv(corr.correspondenceNumber ?? ''), + this.escapeCsv(rev.revisionLabel ?? String(rev.revisionNumber ?? 0)), + this.escapeCsv(rev.subject ?? ''), + this.escapeCsv(corr.type?.typeCode ?? ''), + this.escapeCsv(rev.status?.statusCode ?? ''), + this.escapeCsv(corr.project?.projectCode ?? ''), + this.escapeCsv(corr.originator?.organizationCode ?? ''), + rev.dueDate ? new Date(rev.dueDate).toISOString().split('T')[0] : '', + new Date(rev.createdAt).toISOString().split('T')[0], + ].join(','); + }); + return [header.join(','), ...rows].join('\n'); + } + escapeCsv(value) { + if (value.includes(',') || value.includes('"') || value.includes('\n')) { + return `"${value.replace(/"/g, '""')}"`; + } + return value; + } +}; +exports.CorrespondenceService = CorrespondenceService; +exports.CorrespondenceService = CorrespondenceService = CorrespondenceService_1 = __decorate([ + (0, common_1.Injectable)(), + __param(0, (0, typeorm_1.InjectRepository)(correspondence_entity_1.Correspondence)), + __param(1, (0, typeorm_1.InjectRepository)(correspondence_revision_entity_1.CorrespondenceRevision)), + __param(2, (0, typeorm_1.InjectRepository)(correspondence_type_entity_1.CorrespondenceType)), + __param(3, (0, typeorm_1.InjectRepository)(correspondence_status_entity_1.CorrespondenceStatus)), + __param(4, (0, typeorm_1.InjectRepository)(correspondence_reference_entity_1.CorrespondenceReference)), + __param(5, (0, typeorm_1.InjectRepository)(correspondence_tag_entity_1.CorrespondenceTag)), + __metadata("design:paramtypes", [typeof (_a = typeof typeorm_2.Repository !== "undefined" && typeorm_2.Repository) === "function" ? _a : Object, typeof (_b = typeof typeorm_2.Repository !== "undefined" && typeorm_2.Repository) === "function" ? _b : Object, typeof (_c = typeof typeorm_2.Repository !== "undefined" && typeorm_2.Repository) === "function" ? _c : Object, typeof (_d = typeof typeorm_2.Repository !== "undefined" && typeorm_2.Repository) === "function" ? _d : Object, typeof (_e = typeof typeorm_2.Repository !== "undefined" && typeorm_2.Repository) === "function" ? _e : Object, typeof (_f = typeof typeorm_2.Repository !== "undefined" && typeorm_2.Repository) === "function" ? _f : Object, typeof (_g = typeof document_numbering_service_1.DocumentNumberingService !== "undefined" && document_numbering_service_1.DocumentNumberingService) === "function" ? _g : Object, typeof (_h = typeof json_schema_service_1.JsonSchemaService !== "undefined" && json_schema_service_1.JsonSchemaService) === "function" ? _h : Object, typeof (_j = typeof workflow_engine_service_1.WorkflowEngineService !== "undefined" && workflow_engine_service_1.WorkflowEngineService) === "function" ? _j : Object, typeof (_k = typeof user_service_1.UserService !== "undefined" && user_service_1.UserService) === "function" ? _k : Object, typeof (_l = typeof typeorm_2.DataSource !== "undefined" && typeorm_2.DataSource) === "function" ? _l : Object, typeof (_m = typeof search_service_1.SearchService !== "undefined" && search_service_1.SearchService) === "function" ? _m : Object, typeof (_o = typeof file_storage_service_1.FileStorageService !== "undefined" && file_storage_service_1.FileStorageService) === "function" ? _o : Object, typeof (_p = typeof uuid_resolver_service_1.UuidResolverService !== "undefined" && uuid_resolver_service_1.UuidResolverService) === "function" ? _p : Object, typeof (_q = typeof notification_service_1.NotificationService !== "undefined" && notification_service_1.NotificationService) === "function" ? _q : Object]) +], CorrespondenceService); +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"file":"E:\\np-dms\\lcbp3\\backend\\src\\modules\\correspondence\\correspondence.service.ts","mappings":"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","names":[],"sources":["E:\\np-dms\\lcbp3\\backend\\src\\modules\\correspondence\\correspondence.service.ts"],"sourcesContent":["// File: src/modules/correspondence/correspondence.service.ts\r\n\r\nimport {\r\n  Injectable,\r\n  NotFoundException,\r\n  BadRequestException,\r\n  InternalServerErrorException,\r\n  ForbiddenException,\r\n  Logger,\r\n} from '@nestjs/common';\r\nimport { InjectRepository } from '@nestjs/typeorm';\r\nimport { Repository, DataSource } from 'typeorm';\r\n\r\n// Entities\r\nimport { Correspondence } from './entities/correspondence.entity';\r\nimport { CorrespondenceRevision } from './entities/correspondence-revision.entity';\r\nimport { CorrespondenceType } from './entities/correspondence-type.entity';\r\nimport { CorrespondenceStatus } from './entities/correspondence-status.entity';\r\nimport { CorrespondenceReference } from './entities/correspondence-reference.entity';\r\nimport { CorrespondenceRecipient } from './entities/correspondence-recipient.entity';\r\nimport { CorrespondenceTag } from './entities/correspondence-tag.entity';\r\nimport { Tag } from '../master/entities/tag.entity';\r\nimport { User } from '../user/entities/user.entity';\r\nimport { Organization } from '../organization/entities/organization.entity';\r\n\r\n// DTOs\r\nimport { CreateCorrespondenceDto } from './dto/create-correspondence.dto';\r\nimport { UpdateCorrespondenceDto } from './dto/update-correspondence.dto';\r\nimport { AddReferenceDto } from './dto/add-reference.dto';\r\nimport { SearchCorrespondenceDto } from './dto/search-correspondence.dto';\r\n\r\n// Services\r\nimport { DocumentNumberingService } from '../document-numbering/services/document-numbering.service';\r\nimport { JsonSchemaService } from '../json-schema/json-schema.service';\r\nimport { WorkflowEngineService } from '../workflow-engine/workflow-engine.service';\r\nimport { UserService } from '../user/user.service';\r\nimport { SearchService } from '../search/search.service';\r\nimport { FileStorageService } from '../../common/file-storage/file-storage.service';\r\nimport { UuidResolverService } from '../../common/services/uuid-resolver.service';\r\nimport { NotificationService } from '../notification/notification.service';\r\n\r\n/**\r\n * CorrespondenceService - Document management (CRUD)\r\n */\r\ninterface ResolvedRecipient {\r\n  organizationId: number;\r\n  type: 'TO' | 'CC';\r\n}\r\n@Injectable()\r\nexport class CorrespondenceService {\r\n  private readonly logger = new Logger(CorrespondenceService.name);\r\n\r\n  private async hasSystemManageAllPermission(userId: number): Promise<boolean> {\r\n    const permissions = await this.userService.getUserPermissions(userId);\r\n    return permissions.includes('system.manage_all');\r\n  }\r\n\r\n  /**\r\n   * Business Rule: Revision Label Strategy\r\n   * - RFA, RFI: Use alphabet starting with 'A' (A, B, C...)\r\n   * - Other types (LETTER, MEMO, etc.): Use numeric (null for first, then 1, 2, 3...)\r\n   */\r\n  private getInitialRevisionLabel(typeCode: string): string | null {\r\n    const alphabetTypes = ['RFA', 'RFI'];\r\n    if (alphabetTypes.includes(typeCode.toUpperCase())) {\r\n      return 'A'; // Alphabet for RFA, RFI\r\n    }\r\n    return null; // Numeric (null for revision 0)\r\n  }\r\n\r\n  constructor(\r\n    @InjectRepository(Correspondence)\r\n    private correspondenceRepo: Repository<Correspondence>,\r\n    @InjectRepository(CorrespondenceRevision)\r\n    private revisionRepo: Repository<CorrespondenceRevision>,\r\n    @InjectRepository(CorrespondenceType)\r\n    private typeRepo: Repository<CorrespondenceType>,\r\n    @InjectRepository(CorrespondenceStatus)\r\n    private statusRepo: Repository<CorrespondenceStatus>,\r\n    @InjectRepository(CorrespondenceReference)\r\n    private referenceRepo: Repository<CorrespondenceReference>,\r\n    @InjectRepository(CorrespondenceTag)\r\n    private tagRepo: Repository<CorrespondenceTag>,\r\n    private numberingService: DocumentNumberingService,\r\n    private jsonSchemaService: JsonSchemaService,\r\n    private workflowEngine: WorkflowEngineService,\r\n    private userService: UserService,\r\n    private dataSource: DataSource,\r\n    private searchService: SearchService,\r\n    private fileStorageService: FileStorageService,\r\n    private uuidResolver: UuidResolverService,\r\n    private notificationService: NotificationService\r\n  ) {}\r\n\r\n  /**\r\n   * Business Rule Validation: EC-CORR-003 - Correspondence to Self\r\n   * Prevent external correspondence to same organization\r\n   */\r\n  private async validateCorrespondenceRecipients(\r\n    createDto: CreateCorrespondenceDto,\r\n    user: User\r\n  ): Promise<void> {\r\n    // Get user's organization\r\n    let userOrgId = user.primaryOrganizationId;\r\n    if (!userOrgId) {\r\n      const fullUser = await this.userService.findOne(user.user_id);\r\n      if (fullUser) {\r\n        userOrgId = fullUser.primaryOrganizationId;\r\n      }\r\n    }\r\n\r\n    if (!userOrgId) {\r\n      if (createDto.originatorId) {\r\n        const canManageAll = await this.hasSystemManageAllPermission(\r\n          user.user_id\r\n        );\r\n        if (canManageAll) {\r\n          userOrgId = await this.uuidResolver.resolveOrganizationId(\r\n            createDto.originatorId\r\n          );\r\n        }\r\n      }\r\n\r\n      if (!userOrgId) {\r\n        throw new BadRequestException(\r\n          'User must belong to an organization to create documents'\r\n        );\r\n      }\r\n    }\r\n\r\n    // For impersonation, use the specified originator\r\n    const originatorOrgId = createDto.originatorId\r\n      ? await this.uuidResolver.resolveOrganizationId(createDto.originatorId)\r\n      : userOrgId;\r\n\r\n    // Check if it's internal communication\r\n    if (createDto.isInternal) {\r\n      // Internal communications should use Circulation instead\r\n      throw new BadRequestException(\r\n        'Internal communications should use Circulation Sheet instead of Correspondence'\r\n      );\r\n    }\r\n\r\n    // Validate recipients\r\n    if (!createDto.recipients || createDto.recipients.length === 0) {\r\n      throw new BadRequestException(\r\n        'At least one recipient (TO or CC) is required'\r\n      );\r\n    }\r\n\r\n    const toRecipients = createDto.recipients.filter((r) => r.type === 'TO');\r\n    const ccRecipients = createDto.recipients.filter((r) => r.type === 'CC');\r\n\r\n    if (toRecipients.length === 0 && ccRecipients.length === 0) {\r\n      throw new BadRequestException(\r\n        'At least one TO or CC recipient is required'\r\n      );\r\n    }\r\n\r\n    // Check for same organization correspondence\r\n    for (const recipient of createDto.recipients) {\r\n      const recipientOrgId = await this.uuidResolver.resolveOrganizationId(\r\n        recipient.organizationId\r\n      );\r\n\r\n      if (recipientOrgId === originatorOrgId) {\r\n        throw new BadRequestException(\r\n          'Cannot send correspondence to your own organization. Use Circulation Sheet for internal communication.'\r\n        );\r\n      }\r\n    }\r\n  }\r\n\r\n  async create(createDto: CreateCorrespondenceDto, user: User) {\r\n    // Business Rule Validation: EC-CORR-003 - Correspondence to Self\r\n    await this.validateCorrespondenceRecipients(createDto, user);\r\n    // ADR-019: Resolve UUID references to internal INT IDs\r\n    const resolvedProjectId = await this.uuidResolver.resolveProjectId(\r\n      createDto.projectId\r\n    );\r\n    const resolvedOriginatorId = createDto.originatorId\r\n      ? await this.uuidResolver.resolveOrganizationId(createDto.originatorId)\r\n      : undefined;\r\n    const resolvedRecipients = createDto.recipients\r\n      ? await Promise.all(\r\n          createDto.recipients.map(\r\n            async (r): Promise<ResolvedRecipient> => ({\r\n              organizationId: await this.uuidResolver.resolveOrganizationId(\r\n                r.organizationId\r\n              ),\r\n              type: r.type,\r\n            })\r\n          )\r\n        )\r\n      : undefined;\r\n    const type = await this.typeRepo.findOne({\r\n      where: { id: createDto.typeId },\r\n    });\r\n    if (!type) throw new NotFoundException('Document Type not found');\r\n\r\n    const statusDraft = await this.statusRepo.findOne({\r\n      where: { statusCode: 'DRAFT' },\r\n    });\r\n    if (!statusDraft) {\r\n      throw new InternalServerErrorException(\r\n        'Status DRAFT not found in Master Data'\r\n      );\r\n    }\r\n\r\n    let userOrgId = user.primaryOrganizationId;\r\n\r\n    if (!userOrgId) {\r\n      const fullUser = await this.userService.findOne(user.user_id);\r\n      if (fullUser) {\r\n        userOrgId = fullUser.primaryOrganizationId;\r\n      }\r\n    }\r\n\r\n    // Impersonation Logic\r\n    if (resolvedOriginatorId && resolvedOriginatorId !== userOrgId) {\r\n      const canManageAll = await this.hasSystemManageAllPermission(\r\n        user.user_id\r\n      );\r\n      if (!canManageAll) {\r\n        throw new ForbiddenException(\r\n          'You do not have permission to create documents on behalf of other organizations.'\r\n        );\r\n      }\r\n      userOrgId = resolvedOriginatorId;\r\n    }\r\n\r\n    if (!userOrgId) {\r\n      throw new BadRequestException(\r\n        'User must belong to an organization to create documents'\r\n      );\r\n    }\r\n\r\n    if (createDto.details) {\r\n      try {\r\n        await this.jsonSchemaService.validate(type.typeCode, createDto.details);\r\n      } catch (error: unknown) {\r\n        this.logger.warn(\r\n          `Schema validation warning for ${type.typeCode}: ${(error as Error).message}`\r\n        );\r\n      }\r\n    }\r\n\r\n    const queryRunner = this.dataSource.createQueryRunner();\r\n    await queryRunner.connect();\r\n    await queryRunner.startTransaction();\r\n\r\n    try {\r\n      // [Fix #6] Fetch real ORG Code from Organization entity\r\n      const originatorOrg = await this.dataSource.manager.findOne(\r\n        Organization,\r\n        {\r\n          where: { id: userOrgId },\r\n        }\r\n      );\r\n      const orgCode = originatorOrg?.organizationCode ?? 'UNK';\r\n\r\n      // [v1.5.1] Extract recipient organization from recipients array (Primary TO)\r\n      const toRecipient = resolvedRecipients?.find((r) => r.type === 'TO');\r\n      const recipientOrganizationId = toRecipient?.organizationId;\r\n\r\n      let recipientCode = '';\r\n      if (recipientOrganizationId) {\r\n        const recOrg = await this.dataSource.manager.findOne(Organization, {\r\n          where: { id: recipientOrganizationId },\r\n        });\r\n        if (recOrg) recipientCode = recOrg.organizationCode;\r\n      }\r\n\r\n      const docNumber = await this.numberingService.generateNextNumber({\r\n        projectId: resolvedProjectId,\r\n        originatorOrganizationId: userOrgId,\r\n        typeId: createDto.typeId,\r\n        disciplineId: createDto.disciplineId,\r\n        subTypeId: createDto.subTypeId,\r\n        recipientOrganizationId, // [v1.5.1] Pass recipient for document number format\r\n        year: new Date().getFullYear(),\r\n        customTokens: {\r\n          TYPE_CODE: type.typeCode,\r\n          ORG_CODE: orgCode,\r\n          RECIPIENT_CODE: recipientCode,\r\n          REC_CODE: recipientCode,\r\n        },\r\n      });\r\n\r\n      const correspondence = queryRunner.manager.create(Correspondence, {\r\n        correspondenceNumber: docNumber.number,\r\n        correspondenceTypeId: createDto.typeId,\r\n        disciplineId: createDto.disciplineId,\r\n        projectId: resolvedProjectId,\r\n        originatorId: userOrgId,\r\n        isInternal: createDto.isInternal || false,\r\n        createdBy: user.user_id,\r\n      });\r\n      const savedCorr = await queryRunner.manager.save(correspondence);\r\n\r\n      const revision = queryRunner.manager.create(CorrespondenceRevision, {\r\n        correspondenceId: savedCorr.id,\r\n        revisionNumber: 0,\r\n        revisionLabel: this.getInitialRevisionLabel(type.typeCode),\r\n        isCurrent: true,\r\n        statusId: statusDraft.id,\r\n        subject: createDto.subject,\r\n        body: createDto.body,\r\n        remarks: createDto.remarks,\r\n        dueDate: createDto.dueDate ? new Date(createDto.dueDate) : undefined,\r\n        documentDate: createDto.documentDate\r\n          ? new Date(createDto.documentDate)\r\n          : undefined,\r\n        issuedDate: createDto.issuedDate\r\n          ? new Date(createDto.issuedDate)\r\n          : undefined,\r\n        receivedDate: createDto.receivedDate\r\n          ? new Date(createDto.receivedDate)\r\n          : undefined,\r\n        description: createDto.description,\r\n        details: createDto.details,\r\n        createdBy: user.user_id,\r\n        schemaVersion: 1,\r\n      });\r\n      await queryRunner.manager.save(revision);\r\n\r\n      // Save Recipients (using resolved INT IDs)\r\n      if (resolvedRecipients && resolvedRecipients.length > 0) {\r\n        const recipients = resolvedRecipients.map((r) =>\r\n          queryRunner.manager.create(CorrespondenceRecipient, {\r\n            correspondenceId: savedCorr.id,\r\n            recipientOrganizationId: r.organizationId,\r\n            recipientType: r.type,\r\n          })\r\n        );\r\n        await queryRunner.manager.save(recipients);\r\n      }\r\n\r\n      // Commit attachments from Temp → Permanent (Two-Phase Storage)\r\n      if (createDto.attachmentTempIds?.length) {\r\n        const issueDate = createDto.issuedDate\r\n          ? new Date(createDto.issuedDate)\r\n          : createDto.documentDate\r\n            ? new Date(createDto.documentDate)\r\n            : undefined;\r\n\r\n        await this.fileStorageService.commit(createDto.attachmentTempIds, {\r\n          issueDate,\r\n          documentType: 'Correspondence',\r\n        });\r\n      }\r\n\r\n      await queryRunner.commitTransaction();\r\n\r\n      // Start Workflow Instance (non-blocking)\r\n      try {\r\n        const workflowCode = `CORRESPONDENCE_${type.typeCode}`;\r\n        await this.workflowEngine.createInstance(\r\n          workflowCode,\r\n          'correspondence',\r\n          savedCorr.id.toString(),\r\n          {\r\n            projectId: resolvedProjectId,\r\n            originatorId: userOrgId,\r\n            disciplineId: createDto.disciplineId,\r\n            initiatorId: user.user_id,\r\n          } as Record<string, unknown>\r\n        );\r\n      } catch (error: unknown) {\r\n        this.logger.warn(\r\n          `Workflow not started for ${docNumber.number} (Code: CORRESPONDENCE_${type.typeCode}): ${(error as Error).message}`\r\n        );\r\n      }\r\n\r\n      // Fire-and-forget search indexing (non-blocking, void intentional)\r\n      void this.searchService.indexDocument({\r\n        id: savedCorr.id,\r\n        publicId: savedCorr.publicId,\r\n        type: 'correspondence',\r\n        docNumber: docNumber.number,\r\n        title: createDto.subject,\r\n        description: createDto.description,\r\n        status: 'DRAFT',\r\n        projectId: resolvedProjectId,\r\n        createdAt: new Date(),\r\n      });\r\n\r\n      return {\r\n        ...savedCorr,\r\n        currentRevision: revision,\r\n      };\r\n    } catch (err) {\r\n      await queryRunner.rollbackTransaction();\r\n      this.logger.error(\r\n        `Failed to create correspondence: ${(err as Error).message}`\r\n      );\r\n      throw err;\r\n    } finally {\r\n      await queryRunner.release();\r\n    }\r\n  }\r\n\r\n  async findAll(searchDto: SearchCorrespondenceDto = {}) {\r\n    const {\r\n      search,\r\n      typeId,\r\n      projectId,\r\n      statusId,\r\n      status,\r\n      page = 1,\r\n      limit = 10,\r\n    } = searchDto;\r\n    const skip = (page - 1) * limit;\r\n\r\n    // Change: Query from Revision Repo\r\n    const query = this.revisionRepo\r\n      .createQueryBuilder('rev')\r\n      .leftJoinAndSelect('rev.correspondence', 'corr')\r\n      .leftJoinAndSelect('corr.type', 'type')\r\n      .leftJoinAndSelect('corr.project', 'project')\r\n      .leftJoinAndSelect('corr.originator', 'org')\r\n      .leftJoinAndSelect('rev.status', 'status');\r\n\r\n    // Filter by Revision Status\r\n    const revStatus = searchDto.revisionStatus || 'CURRENT';\r\n\r\n    if (revStatus === 'CURRENT') {\r\n      query.where('rev.isCurrent = :isCurrent', { isCurrent: true });\r\n    } else if (revStatus === 'OLD') {\r\n      query.where('rev.isCurrent = :isCurrent', { isCurrent: false });\r\n    }\r\n    // If 'ALL', no filter needed on isCurrent\r\n\r\n    if (projectId) {\r\n      query.andWhere('corr.projectId = :projectId', { projectId });\r\n    }\r\n\r\n    if (typeId) {\r\n      query.andWhere('corr.correspondenceTypeId = :typeId', { typeId });\r\n    }\r\n\r\n    if (statusId) {\r\n      query.andWhere('rev.statusId = :statusId', { statusId });\r\n    }\r\n\r\n    if (status) {\r\n      query.andWhere('status.statusCode = :status', { status });\r\n    }\r\n\r\n    if (search) {\r\n      query.andWhere(\r\n        '(corr.correspondenceNumber LIKE :search OR rev.subject LIKE :search)',\r\n        { search: `%${search}%` }\r\n      );\r\n    }\r\n\r\n    // Default Sort: Latest Created\r\n    query.orderBy('rev.createdAt', 'DESC').skip(skip).take(limit);\r\n\r\n    const [items, total] = await query.getManyAndCount();\r\n\r\n    return {\r\n      data: items,\r\n      meta: {\r\n        total,\r\n        page,\r\n        limit,\r\n        totalPages: Math.ceil(total / limit),\r\n      },\r\n    };\r\n  }\r\n\r\n  async findOne(id: number) {\r\n    const correspondence = await this.correspondenceRepo.findOne({\r\n      where: { id },\r\n      relations: [\r\n        'revisions',\r\n        'revisions.status',\r\n        'type',\r\n        'project',\r\n        'originator',\r\n        'recipients',\r\n        'recipients.recipientOrganization', // [v1.5.1] Fixed relation name\r\n      ],\r\n    });\r\n\r\n    if (!correspondence) {\r\n      throw new NotFoundException(`Correspondence with ID ${id} not found`);\r\n    }\r\n    return correspondence;\r\n  }\r\n\r\n  async findOneByUuid(publicId: string) {\r\n    const correspondence = await this.correspondenceRepo.findOne({\r\n      where: { publicId },\r\n      relations: [\r\n        'revisions',\r\n        'revisions.status',\r\n        'type',\r\n        'project',\r\n        'originator',\r\n        'recipients',\r\n        'recipients.recipientOrganization',\r\n      ],\r\n    });\r\n\r\n    if (!correspondence) {\r\n      throw new NotFoundException(\r\n        `Correspondence with UUID ${publicId} not found`\r\n      );\r\n    }\r\n    return correspondence;\r\n  }\r\n\r\n  async addReference(id: number, dto: AddReferenceDto) {\r\n    const source = await this.correspondenceRepo.findOne({ where: { id } });\r\n    // ADR-019: Resolve target publicId → internal INT id\r\n    const target = await this.correspondenceRepo.findOne({\r\n      where: { publicId: dto.targetUuid },\r\n    });\r\n\r\n    if (!source || !target) {\r\n      throw new NotFoundException('Source or Target correspondence not found');\r\n    }\r\n\r\n    if (source.id === target.id) {\r\n      throw new BadRequestException('Cannot reference self');\r\n    }\r\n\r\n    const exists = await this.referenceRepo.findOne({\r\n      where: {\r\n        sourceId: id,\r\n        targetId: target.id,\r\n      },\r\n    });\r\n\r\n    if (exists) {\r\n      return exists;\r\n    }\r\n\r\n    const ref = this.referenceRepo.create({\r\n      sourceId: id,\r\n      targetId: target.id,\r\n    });\r\n\r\n    return this.referenceRepo.save(ref);\r\n  }\r\n\r\n  async removeReference(id: number, targetId: number) {\r\n    const result = await this.referenceRepo.delete({\r\n      sourceId: id,\r\n      targetId: targetId,\r\n    });\r\n\r\n    if (result.affected === 0) {\r\n      throw new NotFoundException('Reference not found');\r\n    }\r\n  }\r\n\r\n  async getTags(id: number) {\r\n    const rows = await this.tagRepo.find({\r\n      where: { correspondenceId: id },\r\n      relations: ['tag'],\r\n    });\r\n    return rows.map((r) => r.tag).filter(Boolean);\r\n  }\r\n\r\n  async addTag(id: number, tagId: number) {\r\n    const correspondence = await this.correspondenceRepo.findOne({\r\n      where: { id },\r\n    });\r\n    if (!correspondence) {\r\n      throw new NotFoundException(`Correspondence ${id} not found`);\r\n    }\r\n\r\n    const tag = await this.dataSource.manager.findOne(Tag, {\r\n      where: { id: tagId },\r\n    });\r\n    if (!tag) {\r\n      throw new NotFoundException(`Tag ${tagId} not found`);\r\n    }\r\n\r\n    const exists = await this.tagRepo.findOne({\r\n      where: { correspondenceId: id, tagId },\r\n    });\r\n    if (exists) return exists;\r\n\r\n    const row = this.tagRepo.create({ correspondenceId: id, tagId });\r\n    return this.tagRepo.save(row);\r\n  }\r\n\r\n  async removeTag(id: number, tagId: number) {\r\n    const result = await this.tagRepo.delete({ correspondenceId: id, tagId });\r\n    if (result.affected === 0) {\r\n      throw new NotFoundException('Tag assignment not found');\r\n    }\r\n  }\r\n\r\n  async getReferences(id: number) {\r\n    const outgoing = await this.referenceRepo.find({\r\n      where: { sourceId: id },\r\n      relations: ['target', 'target.type'],\r\n    });\r\n\r\n    const incoming = await this.referenceRepo.find({\r\n      where: { targetId: id },\r\n      relations: ['source', 'source.type'],\r\n    });\r\n\r\n    return { outgoing, incoming };\r\n  }\r\n\r\n  async update(id: number, updateDto: UpdateCorrespondenceDto, user: User) {\r\n    // 1. Find Current Revision\r\n    const revision = await this.revisionRepo.findOne({\r\n      where: {\r\n        correspondenceId: id,\r\n        isCurrent: true,\r\n      },\r\n      relations: ['correspondence'],\r\n    });\r\n\r\n    if (!revision) {\r\n      throw new NotFoundException(\r\n        `Current revision for correspondence ${id} not found`\r\n      );\r\n    }\r\n\r\n    // 2. Check Permission\r\n    if (revision.statusId) {\r\n      const status = await this.statusRepo.findOne({\r\n        where: { id: revision.statusId },\r\n      });\r\n      if (status && status.statusCode !== 'DRAFT') {\r\n        throw new BadRequestException('Only DRAFT documents can be updated');\r\n      }\r\n    }\r\n\r\n    // ADR-019: Resolve UUID references in update DTO\r\n    const updResolvedProjectId = updateDto.projectId\r\n      ? await this.uuidResolver.resolveProjectId(updateDto.projectId)\r\n      : undefined;\r\n    const updResolvedOriginatorId = updateDto.originatorId\r\n      ? await this.uuidResolver.resolveOrganizationId(updateDto.originatorId)\r\n      : undefined;\r\n    const updResolvedRecipients = updateDto.recipients\r\n      ? await Promise.all(\r\n          updateDto.recipients.map(\r\n            async (r): Promise<ResolvedRecipient> => ({\r\n              organizationId: await this.uuidResolver.resolveOrganizationId(\r\n                r.organizationId\r\n              ),\r\n              type: r.type,\r\n            })\r\n          )\r\n        )\r\n      : undefined;\r\n\r\n    // 3. Update Correspondence Entity if needed\r\n    const correspondenceUpdate: Record<string, unknown> = {};\r\n    if (updateDto.disciplineId)\r\n      correspondenceUpdate.disciplineId = updateDto.disciplineId;\r\n    if (updResolvedProjectId)\r\n      correspondenceUpdate.projectId = updResolvedProjectId;\r\n    if (updResolvedOriginatorId)\r\n      correspondenceUpdate.originatorId = updResolvedOriginatorId;\r\n\r\n    if (Object.keys(correspondenceUpdate).length > 0) {\r\n      await this.correspondenceRepo.update(id, correspondenceUpdate);\r\n    }\r\n\r\n    // 4. Update Revision Entity\r\n    const revisionUpdate: Record<string, unknown> = {};\r\n    if (updateDto.subject) revisionUpdate.subject = updateDto.subject;\r\n    if (updateDto.body) revisionUpdate.body = updateDto.body;\r\n    if (updateDto.remarks) revisionUpdate.remarks = updateDto.remarks;\r\n    // Format Date correctly if string\r\n    if (updateDto.dueDate) revisionUpdate.dueDate = new Date(updateDto.dueDate);\r\n    if (updateDto.documentDate)\r\n      revisionUpdate.documentDate = new Date(updateDto.documentDate);\r\n    if (updateDto.issuedDate)\r\n      revisionUpdate.issuedDate = new Date(updateDto.issuedDate);\r\n    if (updateDto.receivedDate)\r\n      revisionUpdate.receivedDate = new Date(updateDto.receivedDate);\r\n    if (updateDto.description)\r\n      revisionUpdate.description = updateDto.description;\r\n    if (updateDto.details) revisionUpdate.details = updateDto.details;\r\n\r\n    if (Object.keys(revisionUpdate).length > 0) {\r\n      await this.revisionRepo.update(revision.id, revisionUpdate);\r\n    }\r\n\r\n    // 4.5 Commit new attachments from Temp → Permanent (Two-Phase Storage)\r\n    if (updateDto.attachmentTempIds?.length) {\r\n      const issueDate = updateDto.issuedDate\r\n        ? new Date(updateDto.issuedDate)\r\n        : updateDto.documentDate\r\n          ? new Date(updateDto.documentDate)\r\n          : revision.issuedDate || revision.documentDate || undefined;\r\n\r\n      await this.fileStorageService.commit(updateDto.attachmentTempIds, {\r\n        issueDate: issueDate ? new Date(issueDate) : undefined,\r\n        documentType: 'Correspondence',\r\n      });\r\n    }\r\n\r\n    // 5. Update Recipients if provided\r\n    if (updResolvedRecipients) {\r\n      const recipientRepo = this.dataSource.getRepository(\r\n        CorrespondenceRecipient\r\n      );\r\n      await recipientRepo.delete({ correspondenceId: id });\r\n\r\n      const newRecipients = updResolvedRecipients.map((r) =>\r\n        recipientRepo.create({\r\n          correspondenceId: id,\r\n          recipientOrganizationId: r.organizationId,\r\n          recipientType: r.type,\r\n        })\r\n      );\r\n      await recipientRepo.save(newRecipients);\r\n    }\r\n\r\n    // 6. Regenerate Document Number if structural fields changed (Recipient, Discipline, Type, Project)\r\n    // AND it is a DRAFT.\r\n\r\n    // Fetch fresh data for context and comparison\r\n    const currentCorr = await this.correspondenceRepo.findOne({\r\n      where: { id },\r\n      relations: ['type', 'recipients', 'recipients.recipientOrganization'],\r\n    });\r\n\r\n    if (currentCorr) {\r\n      const currentToRecipient = currentCorr.recipients?.find(\r\n        (r) => r.recipientType === 'TO'\r\n      );\r\n      const currentRecipientId = currentToRecipient?.recipientOrganizationId;\r\n\r\n      // Check for ACTUAL value changes\r\n      const isProjectChanged =\r\n        updResolvedProjectId !== undefined &&\r\n        updResolvedProjectId !== currentCorr.projectId;\r\n      const isOriginatorChanged =\r\n        updResolvedOriginatorId !== undefined &&\r\n        updResolvedOriginatorId !== currentCorr.originatorId;\r\n      const isDisciplineChanged =\r\n        updateDto.disciplineId !== undefined &&\r\n        updateDto.disciplineId !== currentCorr.disciplineId;\r\n      const isTypeChanged =\r\n        updateDto.typeId !== undefined &&\r\n        updateDto.typeId !== currentCorr.correspondenceTypeId;\r\n\r\n      let isRecipientChanged = false;\r\n      let newRecipientId: number | undefined;\r\n\r\n      if (updResolvedRecipients) {\r\n        const newToRecipient = updResolvedRecipients.find(\r\n          (r) => r.type === 'TO'\r\n        );\r\n        newRecipientId = newToRecipient?.organizationId;\r\n\r\n        if (newRecipientId !== currentRecipientId) {\r\n          isRecipientChanged = true;\r\n        }\r\n      }\r\n\r\n      if (\r\n        isProjectChanged ||\r\n        isDisciplineChanged ||\r\n        isTypeChanged ||\r\n        isRecipientChanged ||\r\n        isOriginatorChanged\r\n      ) {\r\n        const targetRecipientId = isRecipientChanged\r\n          ? newRecipientId\r\n          : currentRecipientId;\r\n\r\n        // Resolve Recipient Code for the NEW context\r\n        let recipientCode = '';\r\n        if (targetRecipientId) {\r\n          const recOrg = await this.dataSource.manager.findOne(Organization, {\r\n            where: { id: targetRecipientId },\r\n          });\r\n          if (recOrg) recipientCode = recOrg.organizationCode;\r\n        }\r\n\r\n        // [Fix #6] Fetch real ORG Code from originator organization\r\n        const originatorOrgForUpdate = await this.dataSource.manager.findOne(\r\n          Organization,\r\n          {\r\n            where: {\r\n              id: updResolvedOriginatorId ?? currentCorr.originatorId ?? 0,\r\n            },\r\n          }\r\n        );\r\n        const orgCode = originatorOrgForUpdate?.organizationCode ?? 'UNK';\r\n\r\n        // Prepare Contexts\r\n        const oldCtx = {\r\n          projectId: currentCorr.projectId,\r\n          originatorOrganizationId: currentCorr.originatorId ?? 0,\r\n          typeId: currentCorr.correspondenceTypeId,\r\n          disciplineId: currentCorr.disciplineId,\r\n          recipientOrganizationId: currentRecipientId,\r\n          year: new Date().getFullYear(),\r\n        };\r\n\r\n        const newCtx = {\r\n          projectId: updResolvedProjectId ?? currentCorr.projectId,\r\n          originatorOrganizationId:\r\n            updResolvedOriginatorId ?? currentCorr.originatorId ?? 0,\r\n          typeId: updateDto.typeId ?? currentCorr.correspondenceTypeId,\r\n          disciplineId: updateDto.disciplineId ?? currentCorr.disciplineId,\r\n          recipientOrganizationId: targetRecipientId,\r\n          year: new Date().getFullYear(),\r\n          userId: user.user_id, // Pass User ID for Audit\r\n          customTokens: {\r\n            TYPE_CODE: currentCorr.type?.typeCode || '',\r\n            ORG_CODE: orgCode,\r\n            RECIPIENT_CODE: recipientCode,\r\n            REC_CODE: recipientCode,\r\n          },\r\n        };\r\n\r\n        // If Type Changed, need NEW Type Code\r\n        if (isTypeChanged) {\r\n          const newType = await this.typeRepo.findOne({\r\n            where: { id: newCtx.typeId },\r\n          });\r\n          if (newType) newCtx.customTokens.TYPE_CODE = newType.typeCode;\r\n        }\r\n\r\n        const newDocNumber = await this.numberingService.updateNumberForDraft(\r\n          currentCorr.correspondenceNumber,\r\n          oldCtx,\r\n          newCtx\r\n        );\r\n\r\n        await this.correspondenceRepo.update(id, {\r\n          correspondenceNumber: newDocNumber,\r\n        });\r\n      }\r\n    }\r\n\r\n    const updated = await this.findOne(id);\r\n\r\n    // Re-index updated document in Elasticsearch (fire-and-forget)\r\n    void this.searchService.indexDocument({\r\n      id: updated.id,\r\n      publicId: updated.publicId,\r\n      type: 'correspondence',\r\n      docNumber: updated.correspondenceNumber,\r\n      title: updateDto.subject ?? updated.revisions?.[0]?.subject,\r\n      description: updateDto.description ?? updated.revisions?.[0]?.description,\r\n      status: 'DRAFT',\r\n      projectId: updated.projectId,\r\n      createdAt: updated.createdAt,\r\n    });\r\n\r\n    return updated;\r\n  }\r\n\r\n  async previewDocumentNumber(createDto: CreateCorrespondenceDto, user: User) {\r\n    // ADR-019: Resolve UUID references\r\n    const previewProjectId = await this.uuidResolver.resolveProjectId(\r\n      createDto.projectId\r\n    );\r\n    const previewOriginatorId = createDto.originatorId\r\n      ? await this.uuidResolver.resolveOrganizationId(createDto.originatorId)\r\n      : undefined;\r\n    const previewRecipients = createDto.recipients\r\n      ? await Promise.all(\r\n          createDto.recipients.map(\r\n            async (r): Promise<ResolvedRecipient> => ({\r\n              organizationId: await this.uuidResolver.resolveOrganizationId(\r\n                r.organizationId\r\n              ),\r\n              type: r.type,\r\n            })\r\n          )\r\n        )\r\n      : undefined;\r\n\r\n    const type = await this.typeRepo.findOne({\r\n      where: { id: createDto.typeId },\r\n    });\r\n    if (!type) throw new NotFoundException('Document Type not found');\r\n\r\n    let userOrgId = user.primaryOrganizationId;\r\n    if (!userOrgId) {\r\n      const fullUser = await this.userService.findOne(user.user_id);\r\n      if (fullUser) userOrgId = fullUser.primaryOrganizationId;\r\n    }\r\n\r\n    if (previewOriginatorId && previewOriginatorId !== userOrgId) {\r\n      // Allow impersonation for preview\r\n      userOrgId = previewOriginatorId;\r\n    }\r\n\r\n    // Extract recipient from recipients array\r\n    const toRecipient = previewRecipients?.find((r) => r.type === 'TO');\r\n    const recipientOrganizationId = toRecipient?.organizationId;\r\n\r\n    let recipientCode = '';\r\n    if (recipientOrganizationId) {\r\n      const recOrg = await this.dataSource.manager.findOne(Organization, {\r\n        where: { id: recipientOrganizationId },\r\n      });\r\n      if (recOrg) recipientCode = recOrg.organizationCode;\r\n    }\r\n\r\n    return this.numberingService.previewNumber({\r\n      projectId: previewProjectId,\r\n      originatorOrganizationId: userOrgId!,\r\n      typeId: createDto.typeId,\r\n      disciplineId: createDto.disciplineId,\r\n      subTypeId: createDto.subTypeId,\r\n      recipientOrganizationId,\r\n      year: new Date().getFullYear(),\r\n      customTokens: {\r\n        TYPE_CODE: type.typeCode,\r\n        RECIPIENT_CODE: recipientCode,\r\n        REC_CODE: recipientCode,\r\n      },\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Business Rule Implementation: EC-CORR-001 - Cancel Correspondence with Downstream Circulation\r\n   * Cancel correspondence and handle related circulations\r\n   */\r\n  async cancel(publicId: string, reason: string, user: User) {\r\n    const correspondence = await this.findOneByUuid(publicId);\r\n\r\n    // Check if user has permission to cancel (Org Admin or Superadmin only)\r\n    const permissions = await this.userService.getUserPermissions(user.user_id);\r\n    const canCancel =\r\n      permissions.includes('correspondence.cancel') ||\r\n      permissions.includes('system.manage_all');\r\n\r\n    if (!canCancel) {\r\n      throw new ForbiddenException(\r\n        'Only administrators can cancel correspondences'\r\n      );\r\n    }\r\n\r\n    // Check if there are any active circulations\r\n    const circulationRepo = this.dataSource.getRepository('Circulation');\r\n    const activeCirculations = await circulationRepo.find({\r\n      where: {\r\n        correspondenceId: correspondence.id,\r\n        status: 'OPEN',\r\n      },\r\n    });\r\n\r\n    const warningMessage =\r\n      activeCirculations.length > 0\r\n        ? `There are ${activeCirculations.length} active circulation(s) for this correspondence. Canceling will force close all related circulations.`\r\n        : '';\r\n\r\n    // Get the current revision to update status\r\n    const currentRevision = await this.revisionRepo.findOne({\r\n      where: {\r\n        correspondenceId: correspondence.id,\r\n        isCurrent: true,\r\n      },\r\n    });\r\n\r\n    if (!currentRevision) {\r\n      throw new NotFoundException('Current revision not found');\r\n    }\r\n\r\n    // Get cancelled status\r\n    const cancelledStatus = await this.statusRepo.findOne({\r\n      where: { statusCode: 'CANCELLED' },\r\n    });\r\n\r\n    if (!cancelledStatus) {\r\n      throw new InternalServerErrorException('CANCELLED status not found');\r\n    }\r\n\r\n    const queryRunner = this.dataSource.createQueryRunner();\r\n    await queryRunner.connect();\r\n    await queryRunner.startTransaction();\r\n\r\n    try {\r\n      // Update correspondence revision status to CANCELLED\r\n      await queryRunner.manager.update(\r\n        CorrespondenceRevision,\r\n        currentRevision.id,\r\n        {\r\n          statusId: cancelledStatus.id,\r\n          remarks: `Cancelled: ${reason}`,\r\n        }\r\n      );\r\n\r\n      // Force close all active circulations\r\n      if (activeCirculations.length > 0) {\r\n        await queryRunner.manager.update(\r\n          'Circulation',\r\n          {\r\n            correspondenceId: correspondence.id,\r\n            status: 'OPEN',\r\n          },\r\n          {\r\n            status: 'FORCE_CLOSED',\r\n            closedAt: new Date(),\r\n            closedBy: user.user_id,\r\n            closeReason: `Correspondence cancelled: ${reason}`,\r\n          }\r\n        );\r\n      }\r\n\r\n      await queryRunner.commitTransaction();\r\n\r\n      // Re-index cancelled status in Elasticsearch (fire-and-forget)\r\n      void this.searchService.indexDocument({\r\n        id: correspondence.id,\r\n        publicId: correspondence.publicId,\r\n        type: 'correspondence',\r\n        docNumber: correspondence.correspondenceNumber,\r\n        title: currentRevision.subject,\r\n        status: 'CANCELLED',\r\n        projectId: correspondence.projectId,\r\n        createdAt: correspondence.createdAt,\r\n      });\r\n\r\n      // Notify originator's doc-control user about cancellation (fire-and-forget)\r\n      if (correspondence.originatorId) {\r\n        void this.userService\r\n          .findDocControlIdByOrg(correspondence.originatorId)\r\n          .then((targetUserId) => {\r\n            if (targetUserId) {\r\n              void this.notificationService.send({\r\n                userId: targetUserId,\r\n                title: 'Correspondence Cancelled',\r\n                message: `${correspondence.correspondenceNumber} — ${currentRevision.subject} has been cancelled. Reason: ${reason}`,\r\n                type: 'EMAIL',\r\n                entityType: 'correspondence',\r\n                entityId: correspondence.id,\r\n                link: `/correspondences/${correspondence.publicId}`,\r\n              });\r\n            }\r\n          })\r\n          .catch((err: Error) =>\r\n            this.logger.warn(`Cancel notification failed: ${err.message}`)\r\n          );\r\n      }\r\n\r\n      return {\r\n        success: true,\r\n        message: warningMessage || 'Correspondence cancelled successfully',\r\n        activeCirculationsCount: activeCirculations.length,\r\n      };\r\n    } catch (error) {\r\n      await queryRunner.rollbackTransaction();\r\n      this.logger.error(\r\n        `Failed to cancel correspondence: ${(error as Error).message}`\r\n      );\r\n      throw error;\r\n    } finally {\r\n      await queryRunner.release();\r\n    }\r\n  }\r\n\r\n  async bulkCancel(\r\n    publicIds: string[],\r\n    reason: string,\r\n    user: User\r\n  ): Promise<{ succeeded: string[]; failed: string[] }> {\r\n    const succeeded: string[] = [];\r\n    const failed: string[] = [];\r\n\r\n    for (const publicId of publicIds) {\r\n      try {\r\n        await this.cancel(publicId, reason, user);\r\n        succeeded.push(publicId);\r\n      } catch {\r\n        failed.push(publicId);\r\n      }\r\n    }\r\n\r\n    return { succeeded, failed };\r\n  }\r\n\r\n  async exportCsv(searchDto: SearchCorrespondenceDto): Promise<string> {\r\n    const { data } = await this.findAll(searchDto);\r\n\r\n    const header = [\r\n      'Document No.',\r\n      'Rev',\r\n      'Subject',\r\n      'Type',\r\n      'Status',\r\n      'Project',\r\n      'From',\r\n      'Due Date',\r\n      'Created At',\r\n    ];\r\n    const rows = data.map((rev) => {\r\n      const corr = rev.correspondence ?? (rev as unknown as Correspondence);\r\n      return [\r\n        this.escapeCsv(corr.correspondenceNumber ?? ''),\r\n        this.escapeCsv(rev.revisionLabel ?? String(rev.revisionNumber ?? 0)),\r\n        this.escapeCsv(rev.subject ?? ''),\r\n        this.escapeCsv(corr.type?.typeCode ?? ''),\r\n        this.escapeCsv(rev.status?.statusCode ?? ''),\r\n        this.escapeCsv(corr.project?.projectCode ?? ''),\r\n        this.escapeCsv(corr.originator?.organizationCode ?? ''),\r\n        rev.dueDate ? new Date(rev.dueDate).toISOString().split('T')[0] : '',\r\n        new Date(rev.createdAt).toISOString().split('T')[0],\r\n      ].join(',');\r\n    });\r\n\r\n    return [header.join(','), ...rows].join('\\n');\r\n  }\r\n\r\n  private escapeCsv(value: string): string {\r\n    if (value.includes(',') || value.includes('\"') || value.includes('\\n')) {\r\n      return `\"${value.replace(/\"/g, '\"\"')}\"`;\r\n    }\r\n    return value;\r\n  }\r\n}\r\n"],"version":3} \ No newline at end of file diff --git a/backend/src/.jest-cache/jest-transform-cache-60cab15b743c6776f41d29bcac696b99-12533232bd0f05f65688e7a7764bf3fb/d8/correspondenceservice_d8463801745469340085197633f7ae6b.map b/backend/src/.jest-cache/jest-transform-cache-60cab15b743c6776f41d29bcac696b99-12533232bd0f05f65688e7a7764bf3fb/d8/correspondenceservice_d8463801745469340085197633f7ae6b.map new file mode 100644 index 0000000..1de2baa --- /dev/null +++ b/backend/src/.jest-cache/jest-transform-cache-60cab15b743c6776f41d29bcac696b99-12533232bd0f05f65688e7a7764bf3fb/d8/correspondenceservice_d8463801745469340085197633f7ae6b.map @@ -0,0 +1 @@ +{"file":"E:\\np-dms\\lcbp3\\backend\\src\\modules\\correspondence\\correspondence.service.ts","mappings":";AAAA,6DAA6D;;;;;;;;;;;;;;;;;AAE7D,2CAOwB;AACxB,6CAAmD;AACnD,qCAAiD;AAEjD,WAAW;AACX,4EAAkE;AAClE,8FAAmF;AACnF,sFAA2E;AAC3E,0FAA+E;AAC/E,gGAAqF;AACrF,gGAAqF;AACrF,oFAAyE;AACzE,8DAAoD;AAEpD,sFAA4E;AAQ5E,WAAW;AACX,0GAAqG;AACrG,4EAAuE;AACvE,wFAAmF;AACnF,uDAAmD;AACnD,6DAAyD;AACzD,yFAAoF;AACpF,uFAAkF;AAClF,+EAA2E;AAUpE,IAAM,qBAAqB,6BAA3B,MAAM,qBAAqB;IAGxB,KAAK,CAAC,4BAA4B,CAAC,MAAc;QACvD,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAC;QACtE,OAAO,WAAW,CAAC,QAAQ,CAAC,mBAAmB,CAAC,CAAC;IACnD,CAAC;IAED;;;;OAIG;IACK,uBAAuB,CAAC,QAAgB;QAC9C,MAAM,aAAa,GAAG,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;QACrC,IAAI,aAAa,CAAC,QAAQ,CAAC,QAAQ,CAAC,WAAW,EAAE,CAAC,EAAE,CAAC;YACnD,OAAO,GAAG,CAAC,CAAC,wBAAwB;QACtC,CAAC;QACD,OAAO,IAAI,CAAC,CAAC,gCAAgC;IAC/C,CAAC;IAED,YAEE,kBAAsD,EAEtD,YAAwD,EAExD,QAAgD,EAEhD,UAAoD,EAEpD,aAA0D,EAE1D,OAA8C,EACtC,gBAA0C,EAC1C,iBAAoC,EACpC,cAAqC,EACrC,WAAwB,EACxB,UAAsB,EACtB,aAA4B,EAC5B,kBAAsC,EACtC,YAAiC,EACjC,mBAAwC;QAnBxC,uBAAkB,GAAlB,kBAAkB,CAA4B;QAE9C,iBAAY,GAAZ,YAAY,CAAoC;QAEhD,aAAQ,GAAR,QAAQ,CAAgC;QAExC,eAAU,GAAV,UAAU,CAAkC;QAE5C,kBAAa,GAAb,aAAa,CAAqC;QAElD,YAAO,GAAP,OAAO,CAA+B;QACtC,qBAAgB,GAAhB,gBAAgB,CAA0B;QAC1C,sBAAiB,GAAjB,iBAAiB,CAAmB;QACpC,mBAAc,GAAd,cAAc,CAAuB;QACrC,gBAAW,GAAX,WAAW,CAAa;QACxB,eAAU,GAAV,UAAU,CAAY;QACtB,kBAAa,GAAb,aAAa,CAAe;QAC5B,uBAAkB,GAAlB,kBAAkB,CAAoB;QACtC,iBAAY,GAAZ,YAAY,CAAqB;QACjC,wBAAmB,GAAnB,mBAAmB,CAAqB;QAzCjC,WAAM,GAAG,IAAI,eAAM,CAAC,uBAAqB,CAAC,IAAI,CAAC,CAAC;IA0C9D,CAAC;IAEJ;;;OAGG;IACK,KAAK,CAAC,gCAAgC,CAC5C,SAAkC,EAClC,IAAU;QAEV,0BAA0B;QAC1B,IAAI,SAAS,GAAG,IAAI,CAAC,qBAAqB,CAAC;QAC3C,IAAI,CAAC,SAAS,EAAE,CAAC;YACf,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YAC9D,IAAI,QAAQ,EAAE,CAAC;gBACb,SAAS,GAAG,QAAQ,CAAC,qBAAqB,CAAC;YAC7C,CAAC;QACH,CAAC;QAED,IAAI,CAAC,SAAS,EAAE,CAAC;YACf,IAAI,SAAS,CAAC,YAAY,EAAE,CAAC;gBAC3B,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,4BAA4B,CAC1D,IAAI,CAAC,OAAO,CACb,CAAC;gBACF,IAAI,YAAY,EAAE,CAAC;oBACjB,SAAS,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,qBAAqB,CACvD,SAAS,CAAC,YAAY,CACvB,CAAC;gBACJ,CAAC;YACH,CAAC;YAED,IAAI,CAAC,SAAS,EAAE,CAAC;gBACf,MAAM,IAAI,4BAAmB,CAC3B,yDAAyD,CAC1D,CAAC;YACJ,CAAC;QACH,CAAC;QAED,kDAAkD;QAClD,MAAM,eAAe,GAAG,SAAS,CAAC,YAAY;YAC5C,CAAC,CAAC,MAAM,IAAI,CAAC,YAAY,CAAC,qBAAqB,CAAC,SAAS,CAAC,YAAY,CAAC;YACvE,CAAC,CAAC,SAAS,CAAC;QAEd,uCAAuC;QACvC,IAAI,SAAS,CAAC,UAAU,EAAE,CAAC;YACzB,yDAAyD;YACzD,MAAM,IAAI,4BAAmB,CAC3B,gFAAgF,CACjF,CAAC;QACJ,CAAC;QAED,sBAAsB;QACtB,IAAI,CAAC,SAAS,CAAC,UAAU,IAAI,SAAS,CAAC,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC/D,MAAM,IAAI,4BAAmB,CAC3B,+CAA+C,CAChD,CAAC;QACJ,CAAC;QAED,MAAM,YAAY,GAAG,SAAS,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;QACzE,MAAM,YAAY,GAAG,SAAS,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;QAEzE,IAAI,YAAY,CAAC,MAAM,KAAK,CAAC,IAAI,YAAY,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC3D,MAAM,IAAI,4BAAmB,CAC3B,6CAA6C,CAC9C,CAAC;QACJ,CAAC;QAED,6CAA6C;QAC7C,KAAK,MAAM,SAAS,IAAI,SAAS,CAAC,UAAU,EAAE,CAAC;YAC7C,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,qBAAqB,CAClE,SAAS,CAAC,cAAc,CACzB,CAAC;YAEF,IAAI,cAAc,KAAK,eAAe,EAAE,CAAC;gBACvC,MAAM,IAAI,4BAAmB,CAC3B,wGAAwG,CACzG,CAAC;YACJ,CAAC;QACH,CAAC;IACH,CAAC;IAED,KAAK,CAAC,MAAM,CAAC,SAAkC,EAAE,IAAU;QACzD,iEAAiE;QACjE,MAAM,IAAI,CAAC,gCAAgC,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;QAC7D,uDAAuD;QACvD,MAAM,iBAAiB,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,gBAAgB,CAChE,SAAS,CAAC,SAAS,CACpB,CAAC;QACF,MAAM,oBAAoB,GAAG,SAAS,CAAC,YAAY;YACjD,CAAC,CAAC,MAAM,IAAI,CAAC,YAAY,CAAC,qBAAqB,CAAC,SAAS,CAAC,YAAY,CAAC;YACvE,CAAC,CAAC,SAAS,CAAC;QACd,MAAM,kBAAkB,GAAG,SAAS,CAAC,UAAU;YAC7C,CAAC,CAAC,MAAM,OAAO,CAAC,GAAG,CACf,SAAS,CAAC,UAAU,CAAC,GAAG,CACtB,KAAK,EAAE,CAAC,EAA8B,EAAE,CAAC,CAAC;gBACxC,cAAc,EAAE,MAAM,IAAI,CAAC,YAAY,CAAC,qBAAqB,CAC3D,CAAC,CAAC,cAAc,CACjB;gBACD,IAAI,EAAE,CAAC,CAAC,IAAI;aACb,CAAC,CACH,CACF;YACH,CAAC,CAAC,SAAS,CAAC;QACd,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC;YACvC,KAAK,EAAE,EAAE,EAAE,EAAE,SAAS,CAAC,MAAM,EAAE;SAChC,CAAC,CAAC;QACH,IAAI,CAAC,IAAI;YAAE,MAAM,IAAI,0BAAiB,CAAC,yBAAyB,CAAC,CAAC;QAElE,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC;YAChD,KAAK,EAAE,EAAE,UAAU,EAAE,OAAO,EAAE;SAC/B,CAAC,CAAC;QACH,IAAI,CAAC,WAAW,EAAE,CAAC;YACjB,MAAM,IAAI,qCAA4B,CACpC,uCAAuC,CACxC,CAAC;QACJ,CAAC;QAED,IAAI,SAAS,GAAG,IAAI,CAAC,qBAAqB,CAAC;QAE3C,IAAI,CAAC,SAAS,EAAE,CAAC;YACf,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YAC9D,IAAI,QAAQ,EAAE,CAAC;gBACb,SAAS,GAAG,QAAQ,CAAC,qBAAqB,CAAC;YAC7C,CAAC;QACH,CAAC;QAED,sBAAsB;QACtB,IAAI,oBAAoB,IAAI,oBAAoB,KAAK,SAAS,EAAE,CAAC;YAC/D,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,4BAA4B,CAC1D,IAAI,CAAC,OAAO,CACb,CAAC;YACF,IAAI,CAAC,YAAY,EAAE,CAAC;gBAClB,MAAM,IAAI,2BAAkB,CAC1B,kFAAkF,CACnF,CAAC;YACJ,CAAC;YACD,SAAS,GAAG,oBAAoB,CAAC;QACnC,CAAC;QAED,IAAI,CAAC,SAAS,EAAE,CAAC;YACf,MAAM,IAAI,4BAAmB,CAC3B,yDAAyD,CAC1D,CAAC;QACJ,CAAC;QAED,IAAI,SAAS,CAAC,OAAO,EAAE,CAAC;YACtB,IAAI,CAAC;gBACH,MAAM,IAAI,CAAC,iBAAiB,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,EAAE,SAAS,CAAC,OAAO,CAAC,CAAC;YAC1E,CAAC;YAAC,OAAO,KAAc,EAAE,CAAC;gBACxB,IAAI,CAAC,MAAM,CAAC,IAAI,CACd,iCAAiC,IAAI,CAAC,QAAQ,KAAM,KAAe,CAAC,OAAO,EAAE,CAC9E,CAAC;YACJ,CAAC;QACH,CAAC;QAED,MAAM,WAAW,GAAG,IAAI,CAAC,UAAU,CAAC,iBAAiB,EAAE,CAAC;QACxD,MAAM,WAAW,CAAC,OAAO,EAAE,CAAC;QAC5B,MAAM,WAAW,CAAC,gBAAgB,EAAE,CAAC;QAErC,IAAI,CAAC;YACH,wDAAwD;YACxD,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,OAAO,CACzD,kCAAY,EACZ;gBACE,KAAK,EAAE,EAAE,EAAE,EAAE,SAAS,EAAE;aACzB,CACF,CAAC;YACF,MAAM,OAAO,GAAG,aAAa,EAAE,gBAAgB,IAAI,KAAK,CAAC;YAEzD,6EAA6E;YAC7E,MAAM,WAAW,GAAG,kBAAkB,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;YACrE,MAAM,uBAAuB,GAAG,WAAW,EAAE,cAAc,CAAC;YAE5D,IAAI,aAAa,GAAG,EAAE,CAAC;YACvB,IAAI,uBAAuB,EAAE,CAAC;gBAC5B,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,OAAO,CAAC,kCAAY,EAAE;oBACjE,KAAK,EAAE,EAAE,EAAE,EAAE,uBAAuB,EAAE;iBACvC,CAAC,CAAC;gBACH,IAAI,MAAM;oBAAE,aAAa,GAAG,MAAM,CAAC,gBAAgB,CAAC;YACtD,CAAC;YAED,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,gBAAgB,CAAC,kBAAkB,CAAC;gBAC/D,SAAS,EAAE,iBAAiB;gBAC5B,wBAAwB,EAAE,SAAS;gBACnC,MAAM,EAAE,SAAS,CAAC,MAAM;gBACxB,YAAY,EAAE,SAAS,CAAC,YAAY;gBACpC,SAAS,EAAE,SAAS,CAAC,SAAS;gBAC9B,uBAAuB,EAAE,qDAAqD;gBAC9E,IAAI,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;gBAC9B,YAAY,EAAE;oBACZ,SAAS,EAAE,IAAI,CAAC,QAAQ;oBACxB,QAAQ,EAAE,OAAO;oBACjB,cAAc,EAAE,aAAa;oBAC7B,QAAQ,EAAE,aAAa;iBACxB;aACF,CAAC,CAAC;YAEH,MAAM,cAAc,GAAG,WAAW,CAAC,OAAO,CAAC,MAAM,CAAC,sCAAc,EAAE;gBAChE,oBAAoB,EAAE,SAAS,CAAC,MAAM;gBACtC,oBAAoB,EAAE,SAAS,CAAC,MAAM;gBACtC,YAAY,EAAE,SAAS,CAAC,YAAY;gBACpC,SAAS,EAAE,iBAAiB;gBAC5B,YAAY,EAAE,SAAS;gBACvB,UAAU,EAAE,SAAS,CAAC,UAAU,IAAI,KAAK;gBACzC,SAAS,EAAE,IAAI,CAAC,OAAO;aACxB,CAAC,CAAC;YACH,MAAM,SAAS,GAAG,MAAM,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;YAEjE,MAAM,QAAQ,GAAG,WAAW,CAAC,OAAO,CAAC,MAAM,CAAC,uDAAsB,EAAE;gBAClE,gBAAgB,EAAE,SAAS,CAAC,EAAE;gBAC9B,cAAc,EAAE,CAAC;gBACjB,aAAa,EAAE,IAAI,CAAC,uBAAuB,CAAC,IAAI,CAAC,QAAQ,CAAC;gBAC1D,SAAS,EAAE,IAAI;gBACf,QAAQ,EAAE,WAAW,CAAC,EAAE;gBACxB,OAAO,EAAE,SAAS,CAAC,OAAO;gBAC1B,IAAI,EAAE,SAAS,CAAC,IAAI;gBACpB,OAAO,EAAE,SAAS,CAAC,OAAO;gBAC1B,OAAO,EAAE,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS;gBACpE,YAAY,EAAE,SAAS,CAAC,YAAY;oBAClC,CAAC,CAAC,IAAI,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC;oBAClC,CAAC,CAAC,SAAS;gBACb,UAAU,EAAE,SAAS,CAAC,UAAU;oBAC9B,CAAC,CAAC,IAAI,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC;oBAChC,CAAC,CAAC,SAAS;gBACb,YAAY,EAAE,SAAS,CAAC,YAAY;oBAClC,CAAC,CAAC,IAAI,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC;oBAClC,CAAC,CAAC,SAAS;gBACb,WAAW,EAAE,SAAS,CAAC,WAAW;gBAClC,OAAO,EAAE,SAAS,CAAC,OAAO;gBAC1B,SAAS,EAAE,IAAI,CAAC,OAAO;gBACvB,aAAa,EAAE,CAAC;aACjB,CAAC,CAAC;YACH,MAAM,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YAEzC,2CAA2C;YAC3C,IAAI,kBAAkB,IAAI,kBAAkB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACxD,MAAM,UAAU,GAAG,kBAAkB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAC9C,WAAW,CAAC,OAAO,CAAC,MAAM,CAAC,yDAAuB,EAAE;oBAClD,gBAAgB,EAAE,SAAS,CAAC,EAAE;oBAC9B,uBAAuB,EAAE,CAAC,CAAC,cAAc;oBACzC,aAAa,EAAE,CAAC,CAAC,IAAI;iBACtB,CAAC,CACH,CAAC;gBACF,MAAM,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YAC7C,CAAC;YAED,+DAA+D;YAC/D,IAAI,SAAS,CAAC,iBAAiB,EAAE,MAAM,EAAE,CAAC;gBACxC,MAAM,SAAS,GAAG,SAAS,CAAC,UAAU;oBACpC,CAAC,CAAC,IAAI,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC;oBAChC,CAAC,CAAC,SAAS,CAAC,YAAY;wBACtB,CAAC,CAAC,IAAI,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC;wBAClC,CAAC,CAAC,SAAS,CAAC;gBAEhB,MAAM,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,SAAS,CAAC,iBAAiB,EAAE;oBAChE,SAAS;oBACT,YAAY,EAAE,gBAAgB;iBAC/B,CAAC,CAAC;YACL,CAAC;YAED,MAAM,WAAW,CAAC,iBAAiB,EAAE,CAAC;YAEtC,yCAAyC;YACzC,IAAI,CAAC;gBACH,MAAM,YAAY,GAAG,kBAAkB,IAAI,CAAC,QAAQ,EAAE,CAAC;gBACvD,MAAM,IAAI,CAAC,cAAc,CAAC,cAAc,CACtC,YAAY,EACZ,gBAAgB,EAChB,SAAS,CAAC,EAAE,CAAC,QAAQ,EAAE,EACvB;oBACE,SAAS,EAAE,iBAAiB;oBAC5B,YAAY,EAAE,SAAS;oBACvB,YAAY,EAAE,SAAS,CAAC,YAAY;oBACpC,WAAW,EAAE,IAAI,CAAC,OAAO;iBACC,CAC7B,CAAC;YACJ,CAAC;YAAC,OAAO,KAAc,EAAE,CAAC;gBACxB,IAAI,CAAC,MAAM,CAAC,IAAI,CACd,4BAA4B,SAAS,CAAC,MAAM,0BAA0B,IAAI,CAAC,QAAQ,MAAO,KAAe,CAAC,OAAO,EAAE,CACpH,CAAC;YACJ,CAAC;YAED,mEAAmE;YACnE,KAAK,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC;gBACpC,EAAE,EAAE,SAAS,CAAC,EAAE;gBAChB,QAAQ,EAAE,SAAS,CAAC,QAAQ;gBAC5B,IAAI,EAAE,gBAAgB;gBACtB,SAAS,EAAE,SAAS,CAAC,MAAM;gBAC3B,KAAK,EAAE,SAAS,CAAC,OAAO;gBACxB,WAAW,EAAE,SAAS,CAAC,WAAW;gBAClC,MAAM,EAAE,OAAO;gBACf,SAAS,EAAE,iBAAiB;gBAC5B,SAAS,EAAE,IAAI,IAAI,EAAE;aACtB,CAAC,CAAC;YAEH,OAAO;gBACL,GAAG,SAAS;gBACZ,eAAe,EAAE,QAAQ;aAC1B,CAAC;QACJ,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,MAAM,WAAW,CAAC,mBAAmB,EAAE,CAAC;YACxC,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,oCAAqC,GAAa,CAAC,OAAO,EAAE,CAC7D,CAAC;YACF,MAAM,GAAG,CAAC;QACZ,CAAC;gBAAS,CAAC;YACT,MAAM,WAAW,CAAC,OAAO,EAAE,CAAC;QAC9B,CAAC;IACH,CAAC;IAED,KAAK,CAAC,OAAO,CAAC,YAAqC,EAAE;QACnD,MAAM,EACJ,MAAM,EACN,MAAM,EACN,SAAS,EACT,QAAQ,EACR,MAAM,EACN,IAAI,GAAG,CAAC,EACR,KAAK,GAAG,EAAE,GACX,GAAG,SAAS,CAAC;QACd,MAAM,IAAI,GAAG,CAAC,IAAI,GAAG,CAAC,CAAC,GAAG,KAAK,CAAC;QAEhC,mCAAmC;QACnC,MAAM,KAAK,GAAG,IAAI,CAAC,YAAY;aAC5B,kBAAkB,CAAC,KAAK,CAAC;aACzB,iBAAiB,CAAC,oBAAoB,EAAE,MAAM,CAAC;aAC/C,iBAAiB,CAAC,WAAW,EAAE,MAAM,CAAC;aACtC,iBAAiB,CAAC,cAAc,EAAE,SAAS,CAAC;aAC5C,iBAAiB,CAAC,iBAAiB,EAAE,KAAK,CAAC;aAC3C,iBAAiB,CAAC,YAAY,EAAE,QAAQ,CAAC,CAAC;QAE7C,4BAA4B;QAC5B,MAAM,SAAS,GAAG,SAAS,CAAC,cAAc,IAAI,SAAS,CAAC;QAExD,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;YAC5B,KAAK,CAAC,KAAK,CAAC,4BAA4B,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QACjE,CAAC;aAAM,IAAI,SAAS,KAAK,KAAK,EAAE,CAAC;YAC/B,KAAK,CAAC,KAAK,CAAC,4BAA4B,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC;QAClE,CAAC;QACD,0CAA0C;QAE1C,IAAI,SAAS,EAAE,CAAC;YACd,KAAK,CAAC,QAAQ,CAAC,6BAA6B,EAAE,EAAE,SAAS,EAAE,CAAC,CAAC;QAC/D,CAAC;QAED,IAAI,MAAM,EAAE,CAAC;YACX,KAAK,CAAC,QAAQ,CAAC,qCAAqC,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC;QACpE,CAAC;QAED,IAAI,QAAQ,EAAE,CAAC;YACb,KAAK,CAAC,QAAQ,CAAC,0BAA0B,EAAE,EAAE,QAAQ,EAAE,CAAC,CAAC;QAC3D,CAAC;QAED,IAAI,MAAM,EAAE,CAAC;YACX,KAAK,CAAC,QAAQ,CAAC,6BAA6B,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC;QAC5D,CAAC;QAED,IAAI,MAAM,EAAE,CAAC;YACX,KAAK,CAAC,QAAQ,CACZ,sEAAsE,EACtE,EAAE,MAAM,EAAE,IAAI,MAAM,GAAG,EAAE,CAC1B,CAAC;QACJ,CAAC;QAED,+BAA+B;QAC/B,KAAK,CAAC,OAAO,CAAC,eAAe,EAAE,MAAM,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAE9D,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,MAAM,KAAK,CAAC,eAAe,EAAE,CAAC;QAErD,OAAO;YACL,IAAI,EAAE,KAAK;YACX,IAAI,EAAE;gBACJ,KAAK;gBACL,IAAI;gBACJ,KAAK;gBACL,UAAU,EAAE,IAAI,CAAC,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;aACrC;SACF,CAAC;IACJ,CAAC;IAED,KAAK,CAAC,OAAO,CAAC,EAAU;QACtB,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC;YAC3D,KAAK,EAAE,EAAE,EAAE,EAAE;YACb,SAAS,EAAE;gBACT,WAAW;gBACX,kBAAkB;gBAClB,MAAM;gBACN,SAAS;gBACT,YAAY;gBACZ,YAAY;gBACZ,kCAAkC,EAAE,+BAA+B;aACpE;SACF,CAAC,CAAC;QAEH,IAAI,CAAC,cAAc,EAAE,CAAC;YACpB,MAAM,IAAI,0BAAiB,CAAC,0BAA0B,EAAE,YAAY,CAAC,CAAC;QACxE,CAAC;QACD,OAAO,cAAc,CAAC;IACxB,CAAC;IAED,KAAK,CAAC,aAAa,CAAC,QAAgB;QAClC,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC;YAC3D,KAAK,EAAE,EAAE,QAAQ,EAAE;YACnB,SAAS,EAAE;gBACT,WAAW;gBACX,kBAAkB;gBAClB,MAAM;gBACN,SAAS;gBACT,YAAY;gBACZ,YAAY;gBACZ,kCAAkC;aACnC;SACF,CAAC,CAAC;QAEH,IAAI,CAAC,cAAc,EAAE,CAAC;YACpB,MAAM,IAAI,0BAAiB,CACzB,4BAA4B,QAAQ,YAAY,CACjD,CAAC;QACJ,CAAC;QACD,OAAO,cAAc,CAAC;IACxB,CAAC;IAED,KAAK,CAAC,YAAY,CAAC,EAAU,EAAE,GAAoB;QACjD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;QACxE,qDAAqD;QACrD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC;YACnD,KAAK,EAAE,EAAE,QAAQ,EAAE,GAAG,CAAC,UAAU,EAAE;SACpC,CAAC,CAAC;QAEH,IAAI,CAAC,MAAM,IAAI,CAAC,MAAM,EAAE,CAAC;YACvB,MAAM,IAAI,0BAAiB,CAAC,2CAA2C,CAAC,CAAC;QAC3E,CAAC;QAED,IAAI,MAAM,CAAC,EAAE,KAAK,MAAM,CAAC,EAAE,EAAE,CAAC;YAC5B,MAAM,IAAI,4BAAmB,CAAC,uBAAuB,CAAC,CAAC;QACzD,CAAC;QAED,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC;YAC9C,KAAK,EAAE;gBACL,QAAQ,EAAE,EAAE;gBACZ,QAAQ,EAAE,MAAM,CAAC,EAAE;aACpB;SACF,CAAC,CAAC;QAEH,IAAI,MAAM,EAAE,CAAC;YACX,OAAO,MAAM,CAAC;QAChB,CAAC;QAED,MAAM,GAAG,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC;YACpC,QAAQ,EAAE,EAAE;YACZ,QAAQ,EAAE,MAAM,CAAC,EAAE;SACpB,CAAC,CAAC;QAEH,OAAO,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACtC,CAAC;IAED,KAAK,CAAC,eAAe,CAAC,EAAU,EAAE,QAAgB;QAChD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC;YAC7C,QAAQ,EAAE,EAAE;YACZ,QAAQ,EAAE,QAAQ;SACnB,CAAC,CAAC;QAEH,IAAI,MAAM,CAAC,QAAQ,KAAK,CAAC,EAAE,CAAC;YAC1B,MAAM,IAAI,0BAAiB,CAAC,qBAAqB,CAAC,CAAC;QACrD,CAAC;IACH,CAAC;IAED,KAAK,CAAC,OAAO,CAAC,EAAU;QACtB,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC;YACnC,KAAK,EAAE,EAAE,gBAAgB,EAAE,EAAE,EAAE;YAC/B,SAAS,EAAE,CAAC,KAAK,CAAC;SACnB,CAAC,CAAC;QACH,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IAChD,CAAC;IAED,KAAK,CAAC,MAAM,CAAC,EAAU,EAAE,KAAa;QACpC,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC;YAC3D,KAAK,EAAE,EAAE,EAAE,EAAE;SACd,CAAC,CAAC;QACH,IAAI,CAAC,cAAc,EAAE,CAAC;YACpB,MAAM,IAAI,0BAAiB,CAAC,kBAAkB,EAAE,YAAY,CAAC,CAAC;QAChE,CAAC;QAED,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,OAAO,CAAC,gBAAG,EAAE;YACrD,KAAK,EAAE,EAAE,EAAE,EAAE,KAAK,EAAE;SACrB,CAAC,CAAC;QACH,IAAI,CAAC,GAAG,EAAE,CAAC;YACT,MAAM,IAAI,0BAAiB,CAAC,OAAO,KAAK,YAAY,CAAC,CAAC;QACxD,CAAC;QAED,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC;YACxC,KAAK,EAAE,EAAE,gBAAgB,EAAE,EAAE,EAAE,KAAK,EAAE;SACvC,CAAC,CAAC;QACH,IAAI,MAAM;YAAE,OAAO,MAAM,CAAC;QAE1B,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,gBAAgB,EAAE,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;QACjE,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAChC,CAAC;IAED,KAAK,CAAC,SAAS,CAAC,EAAU,EAAE,KAAa;QACvC,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,gBAAgB,EAAE,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;QAC1E,IAAI,MAAM,CAAC,QAAQ,KAAK,CAAC,EAAE,CAAC;YAC1B,MAAM,IAAI,0BAAiB,CAAC,0BAA0B,CAAC,CAAC;QAC1D,CAAC;IACH,CAAC;IAED,KAAK,CAAC,aAAa,CAAC,EAAU;QAC5B,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC;YAC7C,KAAK,EAAE,EAAE,QAAQ,EAAE,EAAE,EAAE;YACvB,SAAS,EAAE,CAAC,QAAQ,EAAE,aAAa,CAAC;SACrC,CAAC,CAAC;QAEH,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC;YAC7C,KAAK,EAAE,EAAE,QAAQ,EAAE,EAAE,EAAE;YACvB,SAAS,EAAE,CAAC,QAAQ,EAAE,aAAa,CAAC;SACrC,CAAC,CAAC;QAEH,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC;IAChC,CAAC;IAED,KAAK,CAAC,MAAM,CAAC,EAAU,EAAE,SAAkC,EAAE,IAAU;QACrE,2BAA2B;QAC3B,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC;YAC/C,KAAK,EAAE;gBACL,gBAAgB,EAAE,EAAE;gBACpB,SAAS,EAAE,IAAI;aAChB;YACD,SAAS,EAAE,CAAC,gBAAgB,CAAC;SAC9B,CAAC,CAAC;QAEH,IAAI,CAAC,QAAQ,EAAE,CAAC;YACd,MAAM,IAAI,0BAAiB,CACzB,uCAAuC,EAAE,YAAY,CACtD,CAAC;QACJ,CAAC;QAED,sBAAsB;QACtB,IAAI,QAAQ,CAAC,QAAQ,EAAE,CAAC;YACtB,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC;gBAC3C,KAAK,EAAE,EAAE,EAAE,EAAE,QAAQ,CAAC,QAAQ,EAAE;aACjC,CAAC,CAAC;YACH,IAAI,MAAM,IAAI,MAAM,CAAC,UAAU,KAAK,OAAO,EAAE,CAAC;gBAC5C,MAAM,IAAI,4BAAmB,CAAC,qCAAqC,CAAC,CAAC;YACvE,CAAC;QACH,CAAC;QAED,iDAAiD;QACjD,MAAM,oBAAoB,GAAG,SAAS,CAAC,SAAS;YAC9C,CAAC,CAAC,MAAM,IAAI,CAAC,YAAY,CAAC,gBAAgB,CAAC,SAAS,CAAC,SAAS,CAAC;YAC/D,CAAC,CAAC,SAAS,CAAC;QACd,MAAM,uBAAuB,GAAG,SAAS,CAAC,YAAY;YACpD,CAAC,CAAC,MAAM,IAAI,CAAC,YAAY,CAAC,qBAAqB,CAAC,SAAS,CAAC,YAAY,CAAC;YACvE,CAAC,CAAC,SAAS,CAAC;QACd,MAAM,qBAAqB,GAAG,SAAS,CAAC,UAAU;YAChD,CAAC,CAAC,MAAM,OAAO,CAAC,GAAG,CACf,SAAS,CAAC,UAAU,CAAC,GAAG,CACtB,KAAK,EAAE,CAAC,EAA8B,EAAE,CAAC,CAAC;gBACxC,cAAc,EAAE,MAAM,IAAI,CAAC,YAAY,CAAC,qBAAqB,CAC3D,CAAC,CAAC,cAAc,CACjB;gBACD,IAAI,EAAE,CAAC,CAAC,IAAI;aACb,CAAC,CACH,CACF;YACH,CAAC,CAAC,SAAS,CAAC;QAEd,4CAA4C;QAC5C,MAAM,oBAAoB,GAA4B,EAAE,CAAC;QACzD,IAAI,SAAS,CAAC,YAAY;YACxB,oBAAoB,CAAC,YAAY,GAAG,SAAS,CAAC,YAAY,CAAC;QAC7D,IAAI,oBAAoB;YACtB,oBAAoB,CAAC,SAAS,GAAG,oBAAoB,CAAC;QACxD,IAAI,uBAAuB;YACzB,oBAAoB,CAAC,YAAY,GAAG,uBAAuB,CAAC;QAE9D,IAAI,MAAM,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACjD,MAAM,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,EAAE,EAAE,oBAAoB,CAAC,CAAC;QACjE,CAAC;QAED,4BAA4B;QAC5B,MAAM,cAAc,GAA4B,EAAE,CAAC;QACnD,IAAI,SAAS,CAAC,OAAO;YAAE,cAAc,CAAC,OAAO,GAAG,SAAS,CAAC,OAAO,CAAC;QAClE,IAAI,SAAS,CAAC,IAAI;YAAE,cAAc,CAAC,IAAI,GAAG,SAAS,CAAC,IAAI,CAAC;QACzD,IAAI,SAAS,CAAC,OAAO;YAAE,cAAc,CAAC,OAAO,GAAG,SAAS,CAAC,OAAO,CAAC;QAClE,kCAAkC;QAClC,IAAI,SAAS,CAAC,OAAO;YAAE,cAAc,CAAC,OAAO,GAAG,IAAI,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;QAC5E,IAAI,SAAS,CAAC,YAAY;YACxB,cAAc,CAAC,YAAY,GAAG,IAAI,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC;QACjE,IAAI,SAAS,CAAC,UAAU;YACtB,cAAc,CAAC,UAAU,GAAG,IAAI,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;QAC7D,IAAI,SAAS,CAAC,YAAY;YACxB,cAAc,CAAC,YAAY,GAAG,IAAI,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC;QACjE,IAAI,SAAS,CAAC,WAAW;YACvB,cAAc,CAAC,WAAW,GAAG,SAAS,CAAC,WAAW,CAAC;QACrD,IAAI,SAAS,CAAC,OAAO;YAAE,cAAc,CAAC,OAAO,GAAG,SAAS,CAAC,OAAO,CAAC;QAElE,IAAI,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC3C,MAAM,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,EAAE,cAAc,CAAC,CAAC;QAC9D,CAAC;QAED,uEAAuE;QACvE,IAAI,SAAS,CAAC,iBAAiB,EAAE,MAAM,EAAE,CAAC;YACxC,MAAM,SAAS,GAAG,SAAS,CAAC,UAAU;gBACpC,CAAC,CAAC,IAAI,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC;gBAChC,CAAC,CAAC,SAAS,CAAC,YAAY;oBACtB,CAAC,CAAC,IAAI,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC;oBAClC,CAAC,CAAC,QAAQ,CAAC,UAAU,IAAI,QAAQ,CAAC,YAAY,IAAI,SAAS,CAAC;YAEhE,MAAM,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,SAAS,CAAC,iBAAiB,EAAE;gBAChE,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS;gBACtD,YAAY,EAAE,gBAAgB;aAC/B,CAAC,CAAC;QACL,CAAC;QAED,mCAAmC;QACnC,IAAI,qBAAqB,EAAE,CAAC;YAC1B,MAAM,aAAa,GAAG,IAAI,CAAC,UAAU,CAAC,aAAa,CACjD,yDAAuB,CACxB,CAAC;YACF,MAAM,aAAa,CAAC,MAAM,CAAC,EAAE,gBAAgB,EAAE,EAAE,EAAE,CAAC,CAAC;YAErD,MAAM,aAAa,GAAG,qBAAqB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CACpD,aAAa,CAAC,MAAM,CAAC;gBACnB,gBAAgB,EAAE,EAAE;gBACpB,uBAAuB,EAAE,CAAC,CAAC,cAAc;gBACzC,aAAa,EAAE,CAAC,CAAC,IAAI;aACtB,CAAC,CACH,CAAC;YACF,MAAM,aAAa,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QAC1C,CAAC;QAED,oGAAoG;QACpG,qBAAqB;QAErB,8CAA8C;QAC9C,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC;YACxD,KAAK,EAAE,EAAE,EAAE,EAAE;YACb,SAAS,EAAE,CAAC,MAAM,EAAE,YAAY,EAAE,kCAAkC,CAAC;SACtE,CAAC,CAAC;QAEH,IAAI,WAAW,EAAE,CAAC;YAChB,MAAM,kBAAkB,GAAG,WAAW,CAAC,UAAU,EAAE,IAAI,CACrD,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,aAAa,KAAK,IAAI,CAChC,CAAC;YACF,MAAM,kBAAkB,GAAG,kBAAkB,EAAE,uBAAuB,CAAC;YAEvE,iCAAiC;YACjC,MAAM,gBAAgB,GACpB,oBAAoB,KAAK,SAAS;gBAClC,oBAAoB,KAAK,WAAW,CAAC,SAAS,CAAC;YACjD,MAAM,mBAAmB,GACvB,uBAAuB,KAAK,SAAS;gBACrC,uBAAuB,KAAK,WAAW,CAAC,YAAY,CAAC;YACvD,MAAM,mBAAmB,GACvB,SAAS,CAAC,YAAY,KAAK,SAAS;gBACpC,SAAS,CAAC,YAAY,KAAK,WAAW,CAAC,YAAY,CAAC;YACtD,MAAM,aAAa,GACjB,SAAS,CAAC,MAAM,KAAK,SAAS;gBAC9B,SAAS,CAAC,MAAM,KAAK,WAAW,CAAC,oBAAoB,CAAC;YAExD,IAAI,kBAAkB,GAAG,KAAK,CAAC;YAC/B,IAAI,cAAkC,CAAC;YAEvC,IAAI,qBAAqB,EAAE,CAAC;gBAC1B,MAAM,cAAc,GAAG,qBAAqB,CAAC,IAAI,CAC/C,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CACvB,CAAC;gBACF,cAAc,GAAG,cAAc,EAAE,cAAc,CAAC;gBAEhD,IAAI,cAAc,KAAK,kBAAkB,EAAE,CAAC;oBAC1C,kBAAkB,GAAG,IAAI,CAAC;gBAC5B,CAAC;YACH,CAAC;YAED,IACE,gBAAgB;gBAChB,mBAAmB;gBACnB,aAAa;gBACb,kBAAkB;gBAClB,mBAAmB,EACnB,CAAC;gBACD,MAAM,iBAAiB,GAAG,kBAAkB;oBAC1C,CAAC,CAAC,cAAc;oBAChB,CAAC,CAAC,kBAAkB,CAAC;gBAEvB,6CAA6C;gBAC7C,IAAI,aAAa,GAAG,EAAE,CAAC;gBACvB,IAAI,iBAAiB,EAAE,CAAC;oBACtB,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,OAAO,CAAC,kCAAY,EAAE;wBACjE,KAAK,EAAE,EAAE,EAAE,EAAE,iBAAiB,EAAE;qBACjC,CAAC,CAAC;oBACH,IAAI,MAAM;wBAAE,aAAa,GAAG,MAAM,CAAC,gBAAgB,CAAC;gBACtD,CAAC;gBAED,4DAA4D;gBAC5D,MAAM,sBAAsB,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,OAAO,CAClE,kCAAY,EACZ;oBACE,KAAK,EAAE;wBACL,EAAE,EAAE,uBAAuB,IAAI,WAAW,CAAC,YAAY,IAAI,CAAC;qBAC7D;iBACF,CACF,CAAC;gBACF,MAAM,OAAO,GAAG,sBAAsB,EAAE,gBAAgB,IAAI,KAAK,CAAC;gBAElE,mBAAmB;gBACnB,MAAM,MAAM,GAAG;oBACb,SAAS,EAAE,WAAW,CAAC,SAAS;oBAChC,wBAAwB,EAAE,WAAW,CAAC,YAAY,IAAI,CAAC;oBACvD,MAAM,EAAE,WAAW,CAAC,oBAAoB;oBACxC,YAAY,EAAE,WAAW,CAAC,YAAY;oBACtC,uBAAuB,EAAE,kBAAkB;oBAC3C,IAAI,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;iBAC/B,CAAC;gBAEF,MAAM,MAAM,GAAG;oBACb,SAAS,EAAE,oBAAoB,IAAI,WAAW,CAAC,SAAS;oBACxD,wBAAwB,EACtB,uBAAuB,IAAI,WAAW,CAAC,YAAY,IAAI,CAAC;oBAC1D,MAAM,EAAE,SAAS,CAAC,MAAM,IAAI,WAAW,CAAC,oBAAoB;oBAC5D,YAAY,EAAE,SAAS,CAAC,YAAY,IAAI,WAAW,CAAC,YAAY;oBAChE,uBAAuB,EAAE,iBAAiB;oBAC1C,IAAI,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;oBAC9B,MAAM,EAAE,IAAI,CAAC,OAAO,EAAE,yBAAyB;oBAC/C,YAAY,EAAE;wBACZ,SAAS,EAAE,WAAW,CAAC,IAAI,EAAE,QAAQ,IAAI,EAAE;wBAC3C,QAAQ,EAAE,OAAO;wBACjB,cAAc,EAAE,aAAa;wBAC7B,QAAQ,EAAE,aAAa;qBACxB;iBACF,CAAC;gBAEF,sCAAsC;gBACtC,IAAI,aAAa,EAAE,CAAC;oBAClB,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC;wBAC1C,KAAK,EAAE,EAAE,EAAE,EAAE,MAAM,CAAC,MAAM,EAAE;qBAC7B,CAAC,CAAC;oBACH,IAAI,OAAO;wBAAE,MAAM,CAAC,YAAY,CAAC,SAAS,GAAG,OAAO,CAAC,QAAQ,CAAC;gBAChE,CAAC;gBAED,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,gBAAgB,CAAC,oBAAoB,CACnE,WAAW,CAAC,oBAAoB,EAChC,MAAM,EACN,MAAM,CACP,CAAC;gBAEF,MAAM,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,EAAE,EAAE;oBACvC,oBAAoB,EAAE,YAAY;iBACnC,CAAC,CAAC;YACL,CAAC;QACH,CAAC;QAED,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;QAEvC,+DAA+D;QAC/D,KAAK,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC;YACpC,EAAE,EAAE,OAAO,CAAC,EAAE;YACd,QAAQ,EAAE,OAAO,CAAC,QAAQ;YAC1B,IAAI,EAAE,gBAAgB;YACtB,SAAS,EAAE,OAAO,CAAC,oBAAoB;YACvC,KAAK,EAAE,SAAS,CAAC,OAAO,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,OAAO;YAC3D,WAAW,EAAE,SAAS,CAAC,WAAW,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,WAAW;YACzE,MAAM,EAAE,OAAO;YACf,SAAS,EAAE,OAAO,CAAC,SAAS;YAC5B,SAAS,EAAE,OAAO,CAAC,SAAS;SAC7B,CAAC,CAAC;QAEH,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,KAAK,CAAC,qBAAqB,CAAC,SAAkC,EAAE,IAAU;QACxE,mCAAmC;QACnC,MAAM,gBAAgB,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,gBAAgB,CAC/D,SAAS,CAAC,SAAS,CACpB,CAAC;QACF,MAAM,mBAAmB,GAAG,SAAS,CAAC,YAAY;YAChD,CAAC,CAAC,MAAM,IAAI,CAAC,YAAY,CAAC,qBAAqB,CAAC,SAAS,CAAC,YAAY,CAAC;YACvE,CAAC,CAAC,SAAS,CAAC;QACd,MAAM,iBAAiB,GAAG,SAAS,CAAC,UAAU;YAC5C,CAAC,CAAC,MAAM,OAAO,CAAC,GAAG,CACf,SAAS,CAAC,UAAU,CAAC,GAAG,CACtB,KAAK,EAAE,CAAC,EAA8B,EAAE,CAAC,CAAC;gBACxC,cAAc,EAAE,MAAM,IAAI,CAAC,YAAY,CAAC,qBAAqB,CAC3D,CAAC,CAAC,cAAc,CACjB;gBACD,IAAI,EAAE,CAAC,CAAC,IAAI;aACb,CAAC,CACH,CACF;YACH,CAAC,CAAC,SAAS,CAAC;QAEd,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC;YACvC,KAAK,EAAE,EAAE,EAAE,EAAE,SAAS,CAAC,MAAM,EAAE;SAChC,CAAC,CAAC;QACH,IAAI,CAAC,IAAI;YAAE,MAAM,IAAI,0BAAiB,CAAC,yBAAyB,CAAC,CAAC;QAElE,IAAI,SAAS,GAAG,IAAI,CAAC,qBAAqB,CAAC;QAC3C,IAAI,CAAC,SAAS,EAAE,CAAC;YACf,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YAC9D,IAAI,QAAQ;gBAAE,SAAS,GAAG,QAAQ,CAAC,qBAAqB,CAAC;QAC3D,CAAC;QAED,IAAI,mBAAmB,IAAI,mBAAmB,KAAK,SAAS,EAAE,CAAC;YAC7D,kCAAkC;YAClC,SAAS,GAAG,mBAAmB,CAAC;QAClC,CAAC;QAED,0CAA0C;QAC1C,MAAM,WAAW,GAAG,iBAAiB,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;QACpE,MAAM,uBAAuB,GAAG,WAAW,EAAE,cAAc,CAAC;QAE5D,IAAI,aAAa,GAAG,EAAE,CAAC;QACvB,IAAI,uBAAuB,EAAE,CAAC;YAC5B,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,OAAO,CAAC,kCAAY,EAAE;gBACjE,KAAK,EAAE,EAAE,EAAE,EAAE,uBAAuB,EAAE;aACvC,CAAC,CAAC;YACH,IAAI,MAAM;gBAAE,aAAa,GAAG,MAAM,CAAC,gBAAgB,CAAC;QACtD,CAAC;QAED,OAAO,IAAI,CAAC,gBAAgB,CAAC,aAAa,CAAC;YACzC,SAAS,EAAE,gBAAgB;YAC3B,wBAAwB,EAAE,SAAU;YACpC,MAAM,EAAE,SAAS,CAAC,MAAM;YACxB,YAAY,EAAE,SAAS,CAAC,YAAY;YACpC,SAAS,EAAE,SAAS,CAAC,SAAS;YAC9B,uBAAuB;YACvB,IAAI,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YAC9B,YAAY,EAAE;gBACZ,SAAS,EAAE,IAAI,CAAC,QAAQ;gBACxB,cAAc,EAAE,aAAa;gBAC7B,QAAQ,EAAE,aAAa;aACxB;SACF,CAAC,CAAC;IACL,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,MAAM,CAAC,QAAgB,EAAE,MAAc,EAAE,IAAU;QACvD,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;QAE1D,wEAAwE;QACxE,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,kBAAkB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC5E,MAAM,SAAS,GACb,WAAW,CAAC,QAAQ,CAAC,uBAAuB,CAAC;YAC7C,WAAW,CAAC,QAAQ,CAAC,mBAAmB,CAAC,CAAC;QAE5C,IAAI,CAAC,SAAS,EAAE,CAAC;YACf,MAAM,IAAI,2BAAkB,CAC1B,gDAAgD,CACjD,CAAC;QACJ,CAAC;QAED,6CAA6C;QAC7C,MAAM,eAAe,GAAG,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,aAAa,CAAC,CAAC;QACrE,MAAM,kBAAkB,GAAG,MAAM,eAAe,CAAC,IAAI,CAAC;YACpD,KAAK,EAAE;gBACL,gBAAgB,EAAE,cAAc,CAAC,EAAE;gBACnC,MAAM,EAAE,MAAM;aACf;SACF,CAAC,CAAC;QAEH,MAAM,cAAc,GAClB,kBAAkB,CAAC,MAAM,GAAG,CAAC;YAC3B,CAAC,CAAC,aAAa,kBAAkB,CAAC,MAAM,sGAAsG;YAC9I,CAAC,CAAC,EAAE,CAAC;QAET,4CAA4C;QAC5C,MAAM,eAAe,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC;YACtD,KAAK,EAAE;gBACL,gBAAgB,EAAE,cAAc,CAAC,EAAE;gBACnC,SAAS,EAAE,IAAI;aAChB;SACF,CAAC,CAAC;QAEH,IAAI,CAAC,eAAe,EAAE,CAAC;YACrB,MAAM,IAAI,0BAAiB,CAAC,4BAA4B,CAAC,CAAC;QAC5D,CAAC;QAED,uBAAuB;QACvB,MAAM,eAAe,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC;YACpD,KAAK,EAAE,EAAE,UAAU,EAAE,WAAW,EAAE;SACnC,CAAC,CAAC;QAEH,IAAI,CAAC,eAAe,EAAE,CAAC;YACrB,MAAM,IAAI,qCAA4B,CAAC,4BAA4B,CAAC,CAAC;QACvE,CAAC;QAED,MAAM,WAAW,GAAG,IAAI,CAAC,UAAU,CAAC,iBAAiB,EAAE,CAAC;QACxD,MAAM,WAAW,CAAC,OAAO,EAAE,CAAC;QAC5B,MAAM,WAAW,CAAC,gBAAgB,EAAE,CAAC;QAErC,IAAI,CAAC;YACH,qDAAqD;YACrD,MAAM,WAAW,CAAC,OAAO,CAAC,MAAM,CAC9B,uDAAsB,EACtB,eAAe,CAAC,EAAE,EAClB;gBACE,QAAQ,EAAE,eAAe,CAAC,EAAE;gBAC5B,OAAO,EAAE,cAAc,MAAM,EAAE;aAChC,CACF,CAAC;YAEF,sCAAsC;YACtC,IAAI,kBAAkB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBAClC,MAAM,WAAW,CAAC,OAAO,CAAC,MAAM,CAC9B,aAAa,EACb;oBACE,gBAAgB,EAAE,cAAc,CAAC,EAAE;oBACnC,MAAM,EAAE,MAAM;iBACf,EACD;oBACE,MAAM,EAAE,cAAc;oBACtB,QAAQ,EAAE,IAAI,IAAI,EAAE;oBACpB,QAAQ,EAAE,IAAI,CAAC,OAAO;oBACtB,WAAW,EAAE,6BAA6B,MAAM,EAAE;iBACnD,CACF,CAAC;YACJ,CAAC;YAED,MAAM,WAAW,CAAC,iBAAiB,EAAE,CAAC;YAEtC,+DAA+D;YAC/D,KAAK,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC;gBACpC,EAAE,EAAE,cAAc,CAAC,EAAE;gBACrB,QAAQ,EAAE,cAAc,CAAC,QAAQ;gBACjC,IAAI,EAAE,gBAAgB;gBACtB,SAAS,EAAE,cAAc,CAAC,oBAAoB;gBAC9C,KAAK,EAAE,eAAe,CAAC,OAAO;gBAC9B,MAAM,EAAE,WAAW;gBACnB,SAAS,EAAE,cAAc,CAAC,SAAS;gBACnC,SAAS,EAAE,cAAc,CAAC,SAAS;aACpC,CAAC,CAAC;YAEH,4EAA4E;YAC5E,IAAI,cAAc,CAAC,YAAY,EAAE,CAAC;gBAChC,KAAK,IAAI,CAAC,WAAW;qBAClB,qBAAqB,CAAC,cAAc,CAAC,YAAY,CAAC;qBAClD,IAAI,CAAC,CAAC,YAAY,EAAE,EAAE;oBACrB,IAAI,YAAY,EAAE,CAAC;wBACjB,KAAK,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC;4BACjC,MAAM,EAAE,YAAY;4BACpB,KAAK,EAAE,0BAA0B;4BACjC,OAAO,EAAE,GAAG,cAAc,CAAC,oBAAoB,MAAM,eAAe,CAAC,OAAO,gCAAgC,MAAM,EAAE;4BACpH,IAAI,EAAE,OAAO;4BACb,UAAU,EAAE,gBAAgB;4BAC5B,QAAQ,EAAE,cAAc,CAAC,EAAE;4BAC3B,IAAI,EAAE,oBAAoB,cAAc,CAAC,QAAQ,EAAE;yBACpD,CAAC,CAAC;oBACL,CAAC;gBACH,CAAC,CAAC;qBACD,KAAK,CAAC,CAAC,GAAU,EAAE,EAAE,CACpB,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,+BAA+B,GAAG,CAAC,OAAO,EAAE,CAAC,CAC/D,CAAC;YACN,CAAC;YAED,OAAO;gBACL,OAAO,EAAE,IAAI;gBACb,OAAO,EAAE,cAAc,IAAI,uCAAuC;gBAClE,uBAAuB,EAAE,kBAAkB,CAAC,MAAM;aACnD,CAAC;QACJ,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,WAAW,CAAC,mBAAmB,EAAE,CAAC;YACxC,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,oCAAqC,KAAe,CAAC,OAAO,EAAE,CAC/D,CAAC;YACF,MAAM,KAAK,CAAC;QACd,CAAC;gBAAS,CAAC;YACT,MAAM,WAAW,CAAC,OAAO,EAAE,CAAC;QAC9B,CAAC;IACH,CAAC;IAED,KAAK,CAAC,UAAU,CACd,SAAmB,EACnB,MAAc,EACd,IAAU;QAEV,MAAM,SAAS,GAAa,EAAE,CAAC;QAC/B,MAAM,MAAM,GAAa,EAAE,CAAC;QAE5B,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE,CAAC;YACjC,IAAI,CAAC;gBACH,MAAM,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC;gBAC1C,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YAC3B,CAAC;YAAC,MAAM,CAAC;gBACP,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YACxB,CAAC;QACH,CAAC;QAED,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,CAAC;IAC/B,CAAC;IAED,KAAK,CAAC,SAAS,CAAC,SAAkC;QAChD,MAAM,EAAE,IAAI,EAAE,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;QAE/C,MAAM,MAAM,GAAG;YACb,cAAc;YACd,KAAK;YACL,SAAS;YACT,MAAM;YACN,QAAQ;YACR,SAAS;YACT,MAAM;YACN,UAAU;YACV,YAAY;SACb,CAAC;QACF,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE;YAC5B,MAAM,IAAI,GAAG,GAAG,CAAC,cAAc,IAAK,GAAiC,CAAC;YACtE,OAAO;gBACL,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,oBAAoB,IAAI,EAAE,CAAC;gBAC/C,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,aAAa,IAAI,MAAM,CAAC,GAAG,CAAC,cAAc,IAAI,CAAC,CAAC,CAAC;gBACpE,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,OAAO,IAAI,EAAE,CAAC;gBACjC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,QAAQ,IAAI,EAAE,CAAC;gBACzC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,MAAM,EAAE,UAAU,IAAI,EAAE,CAAC;gBAC5C,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,EAAE,WAAW,IAAI,EAAE,CAAC;gBAC/C,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,UAAU,EAAE,gBAAgB,IAAI,EAAE,CAAC;gBACvD,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE;gBACpE,IAAI,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;aACpD,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACd,CAAC,CAAC,CAAC;QAEH,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAChD,CAAC;IAEO,SAAS,CAAC,KAAa;QAC7B,IAAI,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;YACvE,OAAO,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,GAAG,CAAC;QAC1C,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;CACF,CAAA;AAljCY,sDAAqB;gCAArB,qBAAqB;IADjC,IAAA,mBAAU,GAAE;IAuBR,WAAA,IAAA,0BAAgB,EAAC,sCAAc,CAAC,CAAA;IAEhC,WAAA,IAAA,0BAAgB,EAAC,uDAAsB,CAAC,CAAA;IAExC,WAAA,IAAA,0BAAgB,EAAC,+CAAkB,CAAC,CAAA;IAEpC,WAAA,IAAA,0BAAgB,EAAC,mDAAoB,CAAC,CAAA;IAEtC,WAAA,IAAA,0BAAgB,EAAC,yDAAuB,CAAC,CAAA;IAEzC,WAAA,IAAA,0BAAgB,EAAC,6CAAiB,CAAC,CAAA;yDATR,oBAAU,oBAAV,oBAAU,oDAEhB,oBAAU,oBAAV,oBAAU,oDAEd,oBAAU,oBAAV,oBAAU,oDAER,oBAAU,oBAAV,oBAAU,oDAEP,oBAAU,oBAAV,oBAAU,oDAEhB,oBAAU,oBAAV,oBAAU,oDACD,qDAAwB,oBAAxB,qDAAwB,oDACvB,uCAAiB,oBAAjB,uCAAiB,oDACpB,+CAAqB,oBAArB,+CAAqB,oDACxB,0BAAW,oBAAX,0BAAW,oDACZ,oBAAU,oBAAV,oBAAU,oDACP,8BAAa,oBAAb,8BAAa,oDACR,yCAAkB,oBAAlB,yCAAkB,oDACxB,2CAAmB,oBAAnB,2CAAmB,oDACZ,0CAAmB,oBAAnB,0CAAmB;GA1CvC,qBAAqB,CAkjCjC","names":[],"sources":["E:\\np-dms\\lcbp3\\backend\\src\\modules\\correspondence\\correspondence.service.ts"],"sourcesContent":["// File: src/modules/correspondence/correspondence.service.ts\r\n\r\nimport {\r\n Injectable,\r\n NotFoundException,\r\n BadRequestException,\r\n InternalServerErrorException,\r\n ForbiddenException,\r\n Logger,\r\n} from '@nestjs/common';\r\nimport { InjectRepository } from '@nestjs/typeorm';\r\nimport { Repository, DataSource } from 'typeorm';\r\n\r\n// Entities\r\nimport { Correspondence } from './entities/correspondence.entity';\r\nimport { CorrespondenceRevision } from './entities/correspondence-revision.entity';\r\nimport { CorrespondenceType } from './entities/correspondence-type.entity';\r\nimport { CorrespondenceStatus } from './entities/correspondence-status.entity';\r\nimport { CorrespondenceReference } from './entities/correspondence-reference.entity';\r\nimport { CorrespondenceRecipient } from './entities/correspondence-recipient.entity';\r\nimport { CorrespondenceTag } from './entities/correspondence-tag.entity';\r\nimport { Tag } from '../master/entities/tag.entity';\r\nimport { User } from '../user/entities/user.entity';\r\nimport { Organization } from '../organization/entities/organization.entity';\r\n\r\n// DTOs\r\nimport { CreateCorrespondenceDto } from './dto/create-correspondence.dto';\r\nimport { UpdateCorrespondenceDto } from './dto/update-correspondence.dto';\r\nimport { AddReferenceDto } from './dto/add-reference.dto';\r\nimport { SearchCorrespondenceDto } from './dto/search-correspondence.dto';\r\n\r\n// Services\r\nimport { DocumentNumberingService } from '../document-numbering/services/document-numbering.service';\r\nimport { JsonSchemaService } from '../json-schema/json-schema.service';\r\nimport { WorkflowEngineService } from '../workflow-engine/workflow-engine.service';\r\nimport { UserService } from '../user/user.service';\r\nimport { SearchService } from '../search/search.service';\r\nimport { FileStorageService } from '../../common/file-storage/file-storage.service';\r\nimport { UuidResolverService } from '../../common/services/uuid-resolver.service';\r\nimport { NotificationService } from '../notification/notification.service';\r\n\r\n/**\r\n * CorrespondenceService - Document management (CRUD)\r\n */\r\ninterface ResolvedRecipient {\r\n organizationId: number;\r\n type: 'TO' | 'CC';\r\n}\r\n@Injectable()\r\nexport class CorrespondenceService {\r\n private readonly logger = new Logger(CorrespondenceService.name);\r\n\r\n private async hasSystemManageAllPermission(userId: number): Promise {\r\n const permissions = await this.userService.getUserPermissions(userId);\r\n return permissions.includes('system.manage_all');\r\n }\r\n\r\n /**\r\n * Business Rule: Revision Label Strategy\r\n * - RFA, RFI: Use alphabet starting with 'A' (A, B, C...)\r\n * - Other types (LETTER, MEMO, etc.): Use numeric (null for first, then 1, 2, 3...)\r\n */\r\n private getInitialRevisionLabel(typeCode: string): string | null {\r\n const alphabetTypes = ['RFA', 'RFI'];\r\n if (alphabetTypes.includes(typeCode.toUpperCase())) {\r\n return 'A'; // Alphabet for RFA, RFI\r\n }\r\n return null; // Numeric (null for revision 0)\r\n }\r\n\r\n constructor(\r\n @InjectRepository(Correspondence)\r\n private correspondenceRepo: Repository,\r\n @InjectRepository(CorrespondenceRevision)\r\n private revisionRepo: Repository,\r\n @InjectRepository(CorrespondenceType)\r\n private typeRepo: Repository,\r\n @InjectRepository(CorrespondenceStatus)\r\n private statusRepo: Repository,\r\n @InjectRepository(CorrespondenceReference)\r\n private referenceRepo: Repository,\r\n @InjectRepository(CorrespondenceTag)\r\n private tagRepo: Repository,\r\n private numberingService: DocumentNumberingService,\r\n private jsonSchemaService: JsonSchemaService,\r\n private workflowEngine: WorkflowEngineService,\r\n private userService: UserService,\r\n private dataSource: DataSource,\r\n private searchService: SearchService,\r\n private fileStorageService: FileStorageService,\r\n private uuidResolver: UuidResolverService,\r\n private notificationService: NotificationService\r\n ) {}\r\n\r\n /**\r\n * Business Rule Validation: EC-CORR-003 - Correspondence to Self\r\n * Prevent external correspondence to same organization\r\n */\r\n private async validateCorrespondenceRecipients(\r\n createDto: CreateCorrespondenceDto,\r\n user: User\r\n ): Promise {\r\n // Get user's organization\r\n let userOrgId = user.primaryOrganizationId;\r\n if (!userOrgId) {\r\n const fullUser = await this.userService.findOne(user.user_id);\r\n if (fullUser) {\r\n userOrgId = fullUser.primaryOrganizationId;\r\n }\r\n }\r\n\r\n if (!userOrgId) {\r\n if (createDto.originatorId) {\r\n const canManageAll = await this.hasSystemManageAllPermission(\r\n user.user_id\r\n );\r\n if (canManageAll) {\r\n userOrgId = await this.uuidResolver.resolveOrganizationId(\r\n createDto.originatorId\r\n );\r\n }\r\n }\r\n\r\n if (!userOrgId) {\r\n throw new BadRequestException(\r\n 'User must belong to an organization to create documents'\r\n );\r\n }\r\n }\r\n\r\n // For impersonation, use the specified originator\r\n const originatorOrgId = createDto.originatorId\r\n ? await this.uuidResolver.resolveOrganizationId(createDto.originatorId)\r\n : userOrgId;\r\n\r\n // Check if it's internal communication\r\n if (createDto.isInternal) {\r\n // Internal communications should use Circulation instead\r\n throw new BadRequestException(\r\n 'Internal communications should use Circulation Sheet instead of Correspondence'\r\n );\r\n }\r\n\r\n // Validate recipients\r\n if (!createDto.recipients || createDto.recipients.length === 0) {\r\n throw new BadRequestException(\r\n 'At least one recipient (TO or CC) is required'\r\n );\r\n }\r\n\r\n const toRecipients = createDto.recipients.filter((r) => r.type === 'TO');\r\n const ccRecipients = createDto.recipients.filter((r) => r.type === 'CC');\r\n\r\n if (toRecipients.length === 0 && ccRecipients.length === 0) {\r\n throw new BadRequestException(\r\n 'At least one TO or CC recipient is required'\r\n );\r\n }\r\n\r\n // Check for same organization correspondence\r\n for (const recipient of createDto.recipients) {\r\n const recipientOrgId = await this.uuidResolver.resolveOrganizationId(\r\n recipient.organizationId\r\n );\r\n\r\n if (recipientOrgId === originatorOrgId) {\r\n throw new BadRequestException(\r\n 'Cannot send correspondence to your own organization. Use Circulation Sheet for internal communication.'\r\n );\r\n }\r\n }\r\n }\r\n\r\n async create(createDto: CreateCorrespondenceDto, user: User) {\r\n // Business Rule Validation: EC-CORR-003 - Correspondence to Self\r\n await this.validateCorrespondenceRecipients(createDto, user);\r\n // ADR-019: Resolve UUID references to internal INT IDs\r\n const resolvedProjectId = await this.uuidResolver.resolveProjectId(\r\n createDto.projectId\r\n );\r\n const resolvedOriginatorId = createDto.originatorId\r\n ? await this.uuidResolver.resolveOrganizationId(createDto.originatorId)\r\n : undefined;\r\n const resolvedRecipients = createDto.recipients\r\n ? await Promise.all(\r\n createDto.recipients.map(\r\n async (r): Promise => ({\r\n organizationId: await this.uuidResolver.resolveOrganizationId(\r\n r.organizationId\r\n ),\r\n type: r.type,\r\n })\r\n )\r\n )\r\n : undefined;\r\n const type = await this.typeRepo.findOne({\r\n where: { id: createDto.typeId },\r\n });\r\n if (!type) throw new NotFoundException('Document Type not found');\r\n\r\n const statusDraft = await this.statusRepo.findOne({\r\n where: { statusCode: 'DRAFT' },\r\n });\r\n if (!statusDraft) {\r\n throw new InternalServerErrorException(\r\n 'Status DRAFT not found in Master Data'\r\n );\r\n }\r\n\r\n let userOrgId = user.primaryOrganizationId;\r\n\r\n if (!userOrgId) {\r\n const fullUser = await this.userService.findOne(user.user_id);\r\n if (fullUser) {\r\n userOrgId = fullUser.primaryOrganizationId;\r\n }\r\n }\r\n\r\n // Impersonation Logic\r\n if (resolvedOriginatorId && resolvedOriginatorId !== userOrgId) {\r\n const canManageAll = await this.hasSystemManageAllPermission(\r\n user.user_id\r\n );\r\n if (!canManageAll) {\r\n throw new ForbiddenException(\r\n 'You do not have permission to create documents on behalf of other organizations.'\r\n );\r\n }\r\n userOrgId = resolvedOriginatorId;\r\n }\r\n\r\n if (!userOrgId) {\r\n throw new BadRequestException(\r\n 'User must belong to an organization to create documents'\r\n );\r\n }\r\n\r\n if (createDto.details) {\r\n try {\r\n await this.jsonSchemaService.validate(type.typeCode, createDto.details);\r\n } catch (error: unknown) {\r\n this.logger.warn(\r\n `Schema validation warning for ${type.typeCode}: ${(error as Error).message}`\r\n );\r\n }\r\n }\r\n\r\n const queryRunner = this.dataSource.createQueryRunner();\r\n await queryRunner.connect();\r\n await queryRunner.startTransaction();\r\n\r\n try {\r\n // [Fix #6] Fetch real ORG Code from Organization entity\r\n const originatorOrg = await this.dataSource.manager.findOne(\r\n Organization,\r\n {\r\n where: { id: userOrgId },\r\n }\r\n );\r\n const orgCode = originatorOrg?.organizationCode ?? 'UNK';\r\n\r\n // [v1.5.1] Extract recipient organization from recipients array (Primary TO)\r\n const toRecipient = resolvedRecipients?.find((r) => r.type === 'TO');\r\n const recipientOrganizationId = toRecipient?.organizationId;\r\n\r\n let recipientCode = '';\r\n if (recipientOrganizationId) {\r\n const recOrg = await this.dataSource.manager.findOne(Organization, {\r\n where: { id: recipientOrganizationId },\r\n });\r\n if (recOrg) recipientCode = recOrg.organizationCode;\r\n }\r\n\r\n const docNumber = await this.numberingService.generateNextNumber({\r\n projectId: resolvedProjectId,\r\n originatorOrganizationId: userOrgId,\r\n typeId: createDto.typeId,\r\n disciplineId: createDto.disciplineId,\r\n subTypeId: createDto.subTypeId,\r\n recipientOrganizationId, // [v1.5.1] Pass recipient for document number format\r\n year: new Date().getFullYear(),\r\n customTokens: {\r\n TYPE_CODE: type.typeCode,\r\n ORG_CODE: orgCode,\r\n RECIPIENT_CODE: recipientCode,\r\n REC_CODE: recipientCode,\r\n },\r\n });\r\n\r\n const correspondence = queryRunner.manager.create(Correspondence, {\r\n correspondenceNumber: docNumber.number,\r\n correspondenceTypeId: createDto.typeId,\r\n disciplineId: createDto.disciplineId,\r\n projectId: resolvedProjectId,\r\n originatorId: userOrgId,\r\n isInternal: createDto.isInternal || false,\r\n createdBy: user.user_id,\r\n });\r\n const savedCorr = await queryRunner.manager.save(correspondence);\r\n\r\n const revision = queryRunner.manager.create(CorrespondenceRevision, {\r\n correspondenceId: savedCorr.id,\r\n revisionNumber: 0,\r\n revisionLabel: this.getInitialRevisionLabel(type.typeCode),\r\n isCurrent: true,\r\n statusId: statusDraft.id,\r\n subject: createDto.subject,\r\n body: createDto.body,\r\n remarks: createDto.remarks,\r\n dueDate: createDto.dueDate ? new Date(createDto.dueDate) : undefined,\r\n documentDate: createDto.documentDate\r\n ? new Date(createDto.documentDate)\r\n : undefined,\r\n issuedDate: createDto.issuedDate\r\n ? new Date(createDto.issuedDate)\r\n : undefined,\r\n receivedDate: createDto.receivedDate\r\n ? new Date(createDto.receivedDate)\r\n : undefined,\r\n description: createDto.description,\r\n details: createDto.details,\r\n createdBy: user.user_id,\r\n schemaVersion: 1,\r\n });\r\n await queryRunner.manager.save(revision);\r\n\r\n // Save Recipients (using resolved INT IDs)\r\n if (resolvedRecipients && resolvedRecipients.length > 0) {\r\n const recipients = resolvedRecipients.map((r) =>\r\n queryRunner.manager.create(CorrespondenceRecipient, {\r\n correspondenceId: savedCorr.id,\r\n recipientOrganizationId: r.organizationId,\r\n recipientType: r.type,\r\n })\r\n );\r\n await queryRunner.manager.save(recipients);\r\n }\r\n\r\n // Commit attachments from Temp → Permanent (Two-Phase Storage)\r\n if (createDto.attachmentTempIds?.length) {\r\n const issueDate = createDto.issuedDate\r\n ? new Date(createDto.issuedDate)\r\n : createDto.documentDate\r\n ? new Date(createDto.documentDate)\r\n : undefined;\r\n\r\n await this.fileStorageService.commit(createDto.attachmentTempIds, {\r\n issueDate,\r\n documentType: 'Correspondence',\r\n });\r\n }\r\n\r\n await queryRunner.commitTransaction();\r\n\r\n // Start Workflow Instance (non-blocking)\r\n try {\r\n const workflowCode = `CORRESPONDENCE_${type.typeCode}`;\r\n await this.workflowEngine.createInstance(\r\n workflowCode,\r\n 'correspondence',\r\n savedCorr.id.toString(),\r\n {\r\n projectId: resolvedProjectId,\r\n originatorId: userOrgId,\r\n disciplineId: createDto.disciplineId,\r\n initiatorId: user.user_id,\r\n } as Record\r\n );\r\n } catch (error: unknown) {\r\n this.logger.warn(\r\n `Workflow not started for ${docNumber.number} (Code: CORRESPONDENCE_${type.typeCode}): ${(error as Error).message}`\r\n );\r\n }\r\n\r\n // Fire-and-forget search indexing (non-blocking, void intentional)\r\n void this.searchService.indexDocument({\r\n id: savedCorr.id,\r\n publicId: savedCorr.publicId,\r\n type: 'correspondence',\r\n docNumber: docNumber.number,\r\n title: createDto.subject,\r\n description: createDto.description,\r\n status: 'DRAFT',\r\n projectId: resolvedProjectId,\r\n createdAt: new Date(),\r\n });\r\n\r\n return {\r\n ...savedCorr,\r\n currentRevision: revision,\r\n };\r\n } catch (err) {\r\n await queryRunner.rollbackTransaction();\r\n this.logger.error(\r\n `Failed to create correspondence: ${(err as Error).message}`\r\n );\r\n throw err;\r\n } finally {\r\n await queryRunner.release();\r\n }\r\n }\r\n\r\n async findAll(searchDto: SearchCorrespondenceDto = {}) {\r\n const {\r\n search,\r\n typeId,\r\n projectId,\r\n statusId,\r\n status,\r\n page = 1,\r\n limit = 10,\r\n } = searchDto;\r\n const skip = (page - 1) * limit;\r\n\r\n // Change: Query from Revision Repo\r\n const query = this.revisionRepo\r\n .createQueryBuilder('rev')\r\n .leftJoinAndSelect('rev.correspondence', 'corr')\r\n .leftJoinAndSelect('corr.type', 'type')\r\n .leftJoinAndSelect('corr.project', 'project')\r\n .leftJoinAndSelect('corr.originator', 'org')\r\n .leftJoinAndSelect('rev.status', 'status');\r\n\r\n // Filter by Revision Status\r\n const revStatus = searchDto.revisionStatus || 'CURRENT';\r\n\r\n if (revStatus === 'CURRENT') {\r\n query.where('rev.isCurrent = :isCurrent', { isCurrent: true });\r\n } else if (revStatus === 'OLD') {\r\n query.where('rev.isCurrent = :isCurrent', { isCurrent: false });\r\n }\r\n // If 'ALL', no filter needed on isCurrent\r\n\r\n if (projectId) {\r\n query.andWhere('corr.projectId = :projectId', { projectId });\r\n }\r\n\r\n if (typeId) {\r\n query.andWhere('corr.correspondenceTypeId = :typeId', { typeId });\r\n }\r\n\r\n if (statusId) {\r\n query.andWhere('rev.statusId = :statusId', { statusId });\r\n }\r\n\r\n if (status) {\r\n query.andWhere('status.statusCode = :status', { status });\r\n }\r\n\r\n if (search) {\r\n query.andWhere(\r\n '(corr.correspondenceNumber LIKE :search OR rev.subject LIKE :search)',\r\n { search: `%${search}%` }\r\n );\r\n }\r\n\r\n // Default Sort: Latest Created\r\n query.orderBy('rev.createdAt', 'DESC').skip(skip).take(limit);\r\n\r\n const [items, total] = await query.getManyAndCount();\r\n\r\n return {\r\n data: items,\r\n meta: {\r\n total,\r\n page,\r\n limit,\r\n totalPages: Math.ceil(total / limit),\r\n },\r\n };\r\n }\r\n\r\n async findOne(id: number) {\r\n const correspondence = await this.correspondenceRepo.findOne({\r\n where: { id },\r\n relations: [\r\n 'revisions',\r\n 'revisions.status',\r\n 'type',\r\n 'project',\r\n 'originator',\r\n 'recipients',\r\n 'recipients.recipientOrganization', // [v1.5.1] Fixed relation name\r\n ],\r\n });\r\n\r\n if (!correspondence) {\r\n throw new NotFoundException(`Correspondence with ID ${id} not found`);\r\n }\r\n return correspondence;\r\n }\r\n\r\n async findOneByUuid(publicId: string) {\r\n const correspondence = await this.correspondenceRepo.findOne({\r\n where: { publicId },\r\n relations: [\r\n 'revisions',\r\n 'revisions.status',\r\n 'type',\r\n 'project',\r\n 'originator',\r\n 'recipients',\r\n 'recipients.recipientOrganization',\r\n ],\r\n });\r\n\r\n if (!correspondence) {\r\n throw new NotFoundException(\r\n `Correspondence with UUID ${publicId} not found`\r\n );\r\n }\r\n return correspondence;\r\n }\r\n\r\n async addReference(id: number, dto: AddReferenceDto) {\r\n const source = await this.correspondenceRepo.findOne({ where: { id } });\r\n // ADR-019: Resolve target publicId → internal INT id\r\n const target = await this.correspondenceRepo.findOne({\r\n where: { publicId: dto.targetUuid },\r\n });\r\n\r\n if (!source || !target) {\r\n throw new NotFoundException('Source or Target correspondence not found');\r\n }\r\n\r\n if (source.id === target.id) {\r\n throw new BadRequestException('Cannot reference self');\r\n }\r\n\r\n const exists = await this.referenceRepo.findOne({\r\n where: {\r\n sourceId: id,\r\n targetId: target.id,\r\n },\r\n });\r\n\r\n if (exists) {\r\n return exists;\r\n }\r\n\r\n const ref = this.referenceRepo.create({\r\n sourceId: id,\r\n targetId: target.id,\r\n });\r\n\r\n return this.referenceRepo.save(ref);\r\n }\r\n\r\n async removeReference(id: number, targetId: number) {\r\n const result = await this.referenceRepo.delete({\r\n sourceId: id,\r\n targetId: targetId,\r\n });\r\n\r\n if (result.affected === 0) {\r\n throw new NotFoundException('Reference not found');\r\n }\r\n }\r\n\r\n async getTags(id: number) {\r\n const rows = await this.tagRepo.find({\r\n where: { correspondenceId: id },\r\n relations: ['tag'],\r\n });\r\n return rows.map((r) => r.tag).filter(Boolean);\r\n }\r\n\r\n async addTag(id: number, tagId: number) {\r\n const correspondence = await this.correspondenceRepo.findOne({\r\n where: { id },\r\n });\r\n if (!correspondence) {\r\n throw new NotFoundException(`Correspondence ${id} not found`);\r\n }\r\n\r\n const tag = await this.dataSource.manager.findOne(Tag, {\r\n where: { id: tagId },\r\n });\r\n if (!tag) {\r\n throw new NotFoundException(`Tag ${tagId} not found`);\r\n }\r\n\r\n const exists = await this.tagRepo.findOne({\r\n where: { correspondenceId: id, tagId },\r\n });\r\n if (exists) return exists;\r\n\r\n const row = this.tagRepo.create({ correspondenceId: id, tagId });\r\n return this.tagRepo.save(row);\r\n }\r\n\r\n async removeTag(id: number, tagId: number) {\r\n const result = await this.tagRepo.delete({ correspondenceId: id, tagId });\r\n if (result.affected === 0) {\r\n throw new NotFoundException('Tag assignment not found');\r\n }\r\n }\r\n\r\n async getReferences(id: number) {\r\n const outgoing = await this.referenceRepo.find({\r\n where: { sourceId: id },\r\n relations: ['target', 'target.type'],\r\n });\r\n\r\n const incoming = await this.referenceRepo.find({\r\n where: { targetId: id },\r\n relations: ['source', 'source.type'],\r\n });\r\n\r\n return { outgoing, incoming };\r\n }\r\n\r\n async update(id: number, updateDto: UpdateCorrespondenceDto, user: User) {\r\n // 1. Find Current Revision\r\n const revision = await this.revisionRepo.findOne({\r\n where: {\r\n correspondenceId: id,\r\n isCurrent: true,\r\n },\r\n relations: ['correspondence'],\r\n });\r\n\r\n if (!revision) {\r\n throw new NotFoundException(\r\n `Current revision for correspondence ${id} not found`\r\n );\r\n }\r\n\r\n // 2. Check Permission\r\n if (revision.statusId) {\r\n const status = await this.statusRepo.findOne({\r\n where: { id: revision.statusId },\r\n });\r\n if (status && status.statusCode !== 'DRAFT') {\r\n throw new BadRequestException('Only DRAFT documents can be updated');\r\n }\r\n }\r\n\r\n // ADR-019: Resolve UUID references in update DTO\r\n const updResolvedProjectId = updateDto.projectId\r\n ? await this.uuidResolver.resolveProjectId(updateDto.projectId)\r\n : undefined;\r\n const updResolvedOriginatorId = updateDto.originatorId\r\n ? await this.uuidResolver.resolveOrganizationId(updateDto.originatorId)\r\n : undefined;\r\n const updResolvedRecipients = updateDto.recipients\r\n ? await Promise.all(\r\n updateDto.recipients.map(\r\n async (r): Promise => ({\r\n organizationId: await this.uuidResolver.resolveOrganizationId(\r\n r.organizationId\r\n ),\r\n type: r.type,\r\n })\r\n )\r\n )\r\n : undefined;\r\n\r\n // 3. Update Correspondence Entity if needed\r\n const correspondenceUpdate: Record = {};\r\n if (updateDto.disciplineId)\r\n correspondenceUpdate.disciplineId = updateDto.disciplineId;\r\n if (updResolvedProjectId)\r\n correspondenceUpdate.projectId = updResolvedProjectId;\r\n if (updResolvedOriginatorId)\r\n correspondenceUpdate.originatorId = updResolvedOriginatorId;\r\n\r\n if (Object.keys(correspondenceUpdate).length > 0) {\r\n await this.correspondenceRepo.update(id, correspondenceUpdate);\r\n }\r\n\r\n // 4. Update Revision Entity\r\n const revisionUpdate: Record = {};\r\n if (updateDto.subject) revisionUpdate.subject = updateDto.subject;\r\n if (updateDto.body) revisionUpdate.body = updateDto.body;\r\n if (updateDto.remarks) revisionUpdate.remarks = updateDto.remarks;\r\n // Format Date correctly if string\r\n if (updateDto.dueDate) revisionUpdate.dueDate = new Date(updateDto.dueDate);\r\n if (updateDto.documentDate)\r\n revisionUpdate.documentDate = new Date(updateDto.documentDate);\r\n if (updateDto.issuedDate)\r\n revisionUpdate.issuedDate = new Date(updateDto.issuedDate);\r\n if (updateDto.receivedDate)\r\n revisionUpdate.receivedDate = new Date(updateDto.receivedDate);\r\n if (updateDto.description)\r\n revisionUpdate.description = updateDto.description;\r\n if (updateDto.details) revisionUpdate.details = updateDto.details;\r\n\r\n if (Object.keys(revisionUpdate).length > 0) {\r\n await this.revisionRepo.update(revision.id, revisionUpdate);\r\n }\r\n\r\n // 4.5 Commit new attachments from Temp → Permanent (Two-Phase Storage)\r\n if (updateDto.attachmentTempIds?.length) {\r\n const issueDate = updateDto.issuedDate\r\n ? new Date(updateDto.issuedDate)\r\n : updateDto.documentDate\r\n ? new Date(updateDto.documentDate)\r\n : revision.issuedDate || revision.documentDate || undefined;\r\n\r\n await this.fileStorageService.commit(updateDto.attachmentTempIds, {\r\n issueDate: issueDate ? new Date(issueDate) : undefined,\r\n documentType: 'Correspondence',\r\n });\r\n }\r\n\r\n // 5. Update Recipients if provided\r\n if (updResolvedRecipients) {\r\n const recipientRepo = this.dataSource.getRepository(\r\n CorrespondenceRecipient\r\n );\r\n await recipientRepo.delete({ correspondenceId: id });\r\n\r\n const newRecipients = updResolvedRecipients.map((r) =>\r\n recipientRepo.create({\r\n correspondenceId: id,\r\n recipientOrganizationId: r.organizationId,\r\n recipientType: r.type,\r\n })\r\n );\r\n await recipientRepo.save(newRecipients);\r\n }\r\n\r\n // 6. Regenerate Document Number if structural fields changed (Recipient, Discipline, Type, Project)\r\n // AND it is a DRAFT.\r\n\r\n // Fetch fresh data for context and comparison\r\n const currentCorr = await this.correspondenceRepo.findOne({\r\n where: { id },\r\n relations: ['type', 'recipients', 'recipients.recipientOrganization'],\r\n });\r\n\r\n if (currentCorr) {\r\n const currentToRecipient = currentCorr.recipients?.find(\r\n (r) => r.recipientType === 'TO'\r\n );\r\n const currentRecipientId = currentToRecipient?.recipientOrganizationId;\r\n\r\n // Check for ACTUAL value changes\r\n const isProjectChanged =\r\n updResolvedProjectId !== undefined &&\r\n updResolvedProjectId !== currentCorr.projectId;\r\n const isOriginatorChanged =\r\n updResolvedOriginatorId !== undefined &&\r\n updResolvedOriginatorId !== currentCorr.originatorId;\r\n const isDisciplineChanged =\r\n updateDto.disciplineId !== undefined &&\r\n updateDto.disciplineId !== currentCorr.disciplineId;\r\n const isTypeChanged =\r\n updateDto.typeId !== undefined &&\r\n updateDto.typeId !== currentCorr.correspondenceTypeId;\r\n\r\n let isRecipientChanged = false;\r\n let newRecipientId: number | undefined;\r\n\r\n if (updResolvedRecipients) {\r\n const newToRecipient = updResolvedRecipients.find(\r\n (r) => r.type === 'TO'\r\n );\r\n newRecipientId = newToRecipient?.organizationId;\r\n\r\n if (newRecipientId !== currentRecipientId) {\r\n isRecipientChanged = true;\r\n }\r\n }\r\n\r\n if (\r\n isProjectChanged ||\r\n isDisciplineChanged ||\r\n isTypeChanged ||\r\n isRecipientChanged ||\r\n isOriginatorChanged\r\n ) {\r\n const targetRecipientId = isRecipientChanged\r\n ? newRecipientId\r\n : currentRecipientId;\r\n\r\n // Resolve Recipient Code for the NEW context\r\n let recipientCode = '';\r\n if (targetRecipientId) {\r\n const recOrg = await this.dataSource.manager.findOne(Organization, {\r\n where: { id: targetRecipientId },\r\n });\r\n if (recOrg) recipientCode = recOrg.organizationCode;\r\n }\r\n\r\n // [Fix #6] Fetch real ORG Code from originator organization\r\n const originatorOrgForUpdate = await this.dataSource.manager.findOne(\r\n Organization,\r\n {\r\n where: {\r\n id: updResolvedOriginatorId ?? currentCorr.originatorId ?? 0,\r\n },\r\n }\r\n );\r\n const orgCode = originatorOrgForUpdate?.organizationCode ?? 'UNK';\r\n\r\n // Prepare Contexts\r\n const oldCtx = {\r\n projectId: currentCorr.projectId,\r\n originatorOrganizationId: currentCorr.originatorId ?? 0,\r\n typeId: currentCorr.correspondenceTypeId,\r\n disciplineId: currentCorr.disciplineId,\r\n recipientOrganizationId: currentRecipientId,\r\n year: new Date().getFullYear(),\r\n };\r\n\r\n const newCtx = {\r\n projectId: updResolvedProjectId ?? currentCorr.projectId,\r\n originatorOrganizationId:\r\n updResolvedOriginatorId ?? currentCorr.originatorId ?? 0,\r\n typeId: updateDto.typeId ?? currentCorr.correspondenceTypeId,\r\n disciplineId: updateDto.disciplineId ?? currentCorr.disciplineId,\r\n recipientOrganizationId: targetRecipientId,\r\n year: new Date().getFullYear(),\r\n userId: user.user_id, // Pass User ID for Audit\r\n customTokens: {\r\n TYPE_CODE: currentCorr.type?.typeCode || '',\r\n ORG_CODE: orgCode,\r\n RECIPIENT_CODE: recipientCode,\r\n REC_CODE: recipientCode,\r\n },\r\n };\r\n\r\n // If Type Changed, need NEW Type Code\r\n if (isTypeChanged) {\r\n const newType = await this.typeRepo.findOne({\r\n where: { id: newCtx.typeId },\r\n });\r\n if (newType) newCtx.customTokens.TYPE_CODE = newType.typeCode;\r\n }\r\n\r\n const newDocNumber = await this.numberingService.updateNumberForDraft(\r\n currentCorr.correspondenceNumber,\r\n oldCtx,\r\n newCtx\r\n );\r\n\r\n await this.correspondenceRepo.update(id, {\r\n correspondenceNumber: newDocNumber,\r\n });\r\n }\r\n }\r\n\r\n const updated = await this.findOne(id);\r\n\r\n // Re-index updated document in Elasticsearch (fire-and-forget)\r\n void this.searchService.indexDocument({\r\n id: updated.id,\r\n publicId: updated.publicId,\r\n type: 'correspondence',\r\n docNumber: updated.correspondenceNumber,\r\n title: updateDto.subject ?? updated.revisions?.[0]?.subject,\r\n description: updateDto.description ?? updated.revisions?.[0]?.description,\r\n status: 'DRAFT',\r\n projectId: updated.projectId,\r\n createdAt: updated.createdAt,\r\n });\r\n\r\n return updated;\r\n }\r\n\r\n async previewDocumentNumber(createDto: CreateCorrespondenceDto, user: User) {\r\n // ADR-019: Resolve UUID references\r\n const previewProjectId = await this.uuidResolver.resolveProjectId(\r\n createDto.projectId\r\n );\r\n const previewOriginatorId = createDto.originatorId\r\n ? await this.uuidResolver.resolveOrganizationId(createDto.originatorId)\r\n : undefined;\r\n const previewRecipients = createDto.recipients\r\n ? await Promise.all(\r\n createDto.recipients.map(\r\n async (r): Promise => ({\r\n organizationId: await this.uuidResolver.resolveOrganizationId(\r\n r.organizationId\r\n ),\r\n type: r.type,\r\n })\r\n )\r\n )\r\n : undefined;\r\n\r\n const type = await this.typeRepo.findOne({\r\n where: { id: createDto.typeId },\r\n });\r\n if (!type) throw new NotFoundException('Document Type not found');\r\n\r\n let userOrgId = user.primaryOrganizationId;\r\n if (!userOrgId) {\r\n const fullUser = await this.userService.findOne(user.user_id);\r\n if (fullUser) userOrgId = fullUser.primaryOrganizationId;\r\n }\r\n\r\n if (previewOriginatorId && previewOriginatorId !== userOrgId) {\r\n // Allow impersonation for preview\r\n userOrgId = previewOriginatorId;\r\n }\r\n\r\n // Extract recipient from recipients array\r\n const toRecipient = previewRecipients?.find((r) => r.type === 'TO');\r\n const recipientOrganizationId = toRecipient?.organizationId;\r\n\r\n let recipientCode = '';\r\n if (recipientOrganizationId) {\r\n const recOrg = await this.dataSource.manager.findOne(Organization, {\r\n where: { id: recipientOrganizationId },\r\n });\r\n if (recOrg) recipientCode = recOrg.organizationCode;\r\n }\r\n\r\n return this.numberingService.previewNumber({\r\n projectId: previewProjectId,\r\n originatorOrganizationId: userOrgId!,\r\n typeId: createDto.typeId,\r\n disciplineId: createDto.disciplineId,\r\n subTypeId: createDto.subTypeId,\r\n recipientOrganizationId,\r\n year: new Date().getFullYear(),\r\n customTokens: {\r\n TYPE_CODE: type.typeCode,\r\n RECIPIENT_CODE: recipientCode,\r\n REC_CODE: recipientCode,\r\n },\r\n });\r\n }\r\n\r\n /**\r\n * Business Rule Implementation: EC-CORR-001 - Cancel Correspondence with Downstream Circulation\r\n * Cancel correspondence and handle related circulations\r\n */\r\n async cancel(publicId: string, reason: string, user: User) {\r\n const correspondence = await this.findOneByUuid(publicId);\r\n\r\n // Check if user has permission to cancel (Org Admin or Superadmin only)\r\n const permissions = await this.userService.getUserPermissions(user.user_id);\r\n const canCancel =\r\n permissions.includes('correspondence.cancel') ||\r\n permissions.includes('system.manage_all');\r\n\r\n if (!canCancel) {\r\n throw new ForbiddenException(\r\n 'Only administrators can cancel correspondences'\r\n );\r\n }\r\n\r\n // Check if there are any active circulations\r\n const circulationRepo = this.dataSource.getRepository('Circulation');\r\n const activeCirculations = await circulationRepo.find({\r\n where: {\r\n correspondenceId: correspondence.id,\r\n status: 'OPEN',\r\n },\r\n });\r\n\r\n const warningMessage =\r\n activeCirculations.length > 0\r\n ? `There are ${activeCirculations.length} active circulation(s) for this correspondence. Canceling will force close all related circulations.`\r\n : '';\r\n\r\n // Get the current revision to update status\r\n const currentRevision = await this.revisionRepo.findOne({\r\n where: {\r\n correspondenceId: correspondence.id,\r\n isCurrent: true,\r\n },\r\n });\r\n\r\n if (!currentRevision) {\r\n throw new NotFoundException('Current revision not found');\r\n }\r\n\r\n // Get cancelled status\r\n const cancelledStatus = await this.statusRepo.findOne({\r\n where: { statusCode: 'CANCELLED' },\r\n });\r\n\r\n if (!cancelledStatus) {\r\n throw new InternalServerErrorException('CANCELLED status not found');\r\n }\r\n\r\n const queryRunner = this.dataSource.createQueryRunner();\r\n await queryRunner.connect();\r\n await queryRunner.startTransaction();\r\n\r\n try {\r\n // Update correspondence revision status to CANCELLED\r\n await queryRunner.manager.update(\r\n CorrespondenceRevision,\r\n currentRevision.id,\r\n {\r\n statusId: cancelledStatus.id,\r\n remarks: `Cancelled: ${reason}`,\r\n }\r\n );\r\n\r\n // Force close all active circulations\r\n if (activeCirculations.length > 0) {\r\n await queryRunner.manager.update(\r\n 'Circulation',\r\n {\r\n correspondenceId: correspondence.id,\r\n status: 'OPEN',\r\n },\r\n {\r\n status: 'FORCE_CLOSED',\r\n closedAt: new Date(),\r\n closedBy: user.user_id,\r\n closeReason: `Correspondence cancelled: ${reason}`,\r\n }\r\n );\r\n }\r\n\r\n await queryRunner.commitTransaction();\r\n\r\n // Re-index cancelled status in Elasticsearch (fire-and-forget)\r\n void this.searchService.indexDocument({\r\n id: correspondence.id,\r\n publicId: correspondence.publicId,\r\n type: 'correspondence',\r\n docNumber: correspondence.correspondenceNumber,\r\n title: currentRevision.subject,\r\n status: 'CANCELLED',\r\n projectId: correspondence.projectId,\r\n createdAt: correspondence.createdAt,\r\n });\r\n\r\n // Notify originator's doc-control user about cancellation (fire-and-forget)\r\n if (correspondence.originatorId) {\r\n void this.userService\r\n .findDocControlIdByOrg(correspondence.originatorId)\r\n .then((targetUserId) => {\r\n if (targetUserId) {\r\n void this.notificationService.send({\r\n userId: targetUserId,\r\n title: 'Correspondence Cancelled',\r\n message: `${correspondence.correspondenceNumber} — ${currentRevision.subject} has been cancelled. Reason: ${reason}`,\r\n type: 'EMAIL',\r\n entityType: 'correspondence',\r\n entityId: correspondence.id,\r\n link: `/correspondences/${correspondence.publicId}`,\r\n });\r\n }\r\n })\r\n .catch((err: Error) =>\r\n this.logger.warn(`Cancel notification failed: ${err.message}`)\r\n );\r\n }\r\n\r\n return {\r\n success: true,\r\n message: warningMessage || 'Correspondence cancelled successfully',\r\n activeCirculationsCount: activeCirculations.length,\r\n };\r\n } catch (error) {\r\n await queryRunner.rollbackTransaction();\r\n this.logger.error(\r\n `Failed to cancel correspondence: ${(error as Error).message}`\r\n );\r\n throw error;\r\n } finally {\r\n await queryRunner.release();\r\n }\r\n }\r\n\r\n async bulkCancel(\r\n publicIds: string[],\r\n reason: string,\r\n user: User\r\n ): Promise<{ succeeded: string[]; failed: string[] }> {\r\n const succeeded: string[] = [];\r\n const failed: string[] = [];\r\n\r\n for (const publicId of publicIds) {\r\n try {\r\n await this.cancel(publicId, reason, user);\r\n succeeded.push(publicId);\r\n } catch {\r\n failed.push(publicId);\r\n }\r\n }\r\n\r\n return { succeeded, failed };\r\n }\r\n\r\n async exportCsv(searchDto: SearchCorrespondenceDto): Promise {\r\n const { data } = await this.findAll(searchDto);\r\n\r\n const header = [\r\n 'Document No.',\r\n 'Rev',\r\n 'Subject',\r\n 'Type',\r\n 'Status',\r\n 'Project',\r\n 'From',\r\n 'Due Date',\r\n 'Created At',\r\n ];\r\n const rows = data.map((rev) => {\r\n const corr = rev.correspondence ?? (rev as unknown as Correspondence);\r\n return [\r\n this.escapeCsv(corr.correspondenceNumber ?? ''),\r\n this.escapeCsv(rev.revisionLabel ?? String(rev.revisionNumber ?? 0)),\r\n this.escapeCsv(rev.subject ?? ''),\r\n this.escapeCsv(corr.type?.typeCode ?? ''),\r\n this.escapeCsv(rev.status?.statusCode ?? ''),\r\n this.escapeCsv(corr.project?.projectCode ?? ''),\r\n this.escapeCsv(corr.originator?.organizationCode ?? ''),\r\n rev.dueDate ? new Date(rev.dueDate).toISOString().split('T')[0] : '',\r\n new Date(rev.createdAt).toISOString().split('T')[0],\r\n ].join(',');\r\n });\r\n\r\n return [header.join(','), ...rows].join('\\n');\r\n }\r\n\r\n private escapeCsv(value: string): string {\r\n if (value.includes(',') || value.includes('\"') || value.includes('\\n')) {\r\n return `\"${value.replace(/\"/g, '\"\"')}\"`;\r\n }\r\n return value;\r\n }\r\n}\r\n"],"version":3} \ No newline at end of file diff --git a/backend/src/.jest-cache/perf-cache-60cab15b743c6776f41d29bcac696b99-da39a3ee5e6b4b0d3255bfef95601890 b/backend/src/.jest-cache/perf-cache-60cab15b743c6776f41d29bcac696b99-da39a3ee5e6b4b0d3255bfef95601890 index 7284c83..1b31b15 100644 --- a/backend/src/.jest-cache/perf-cache-60cab15b743c6776f41d29bcac696b99-da39a3ee5e6b4b0d3255bfef95601890 +++ b/backend/src/.jest-cache/perf-cache-60cab15b743c6776f41d29bcac696b99-da39a3ee5e6b4b0d3255bfef95601890 @@ -1 +1 @@ -{"E:\\np-dms\\lcbp3\\backend\\src\\modules\\correspondence\\due-date-reminder.service.spec.ts":[1,1723],"E:\\np-dms\\lcbp3\\backend\\src\\modules\\correspondence\\correspondence.service.spec.ts":[1,7901],"E:\\np-dms\\lcbp3\\backend\\src\\common\\auth\\auth.service.spec.ts":[1,1538],"E:\\np-dms\\lcbp3\\backend\\src\\modules\\document-numbering\\document-numbering.service.spec.ts":[1,2037],"E:\\np-dms\\lcbp3\\backend\\src\\common\\auth\\casl\\ability.factory.spec.ts":[1,1294],"E:\\np-dms\\lcbp3\\backend\\src\\common\\services\\uuid-resolver.service.spec.ts":[1,5491],"E:\\np-dms\\lcbp3\\backend\\src\\modules\\workflow-engine\\workflow-engine.service.spec.ts":[1,5639],"E:\\np-dms\\lcbp3\\backend\\src\\modules\\workflow-engine\\dsl\\parser.service.spec.ts":[1,5818],"E:\\np-dms\\lcbp3\\backend\\src\\common\\pipes\\parse-uuid.pipe.spec.ts":[1,355],"E:\\np-dms\\lcbp3\\backend\\src\\modules\\user\\user.service.spec.ts":[1,1270],"E:\\np-dms\\lcbp3\\backend\\src\\common\\file-storage\\file-storage.service.spec.ts":[1,1187],"E:\\np-dms\\lcbp3\\backend\\src\\modules\\correspondence\\correspondence.controller.spec.ts":[1,8495],"E:\\np-dms\\lcbp3\\backend\\src\\modules\\migration\\migration.service.spec.ts":[1,1296],"E:\\np-dms\\lcbp3\\backend\\src\\common\\entities\\uuid-base.entity.spec.ts":[1,430],"E:\\np-dms\\lcbp3\\backend\\src\\modules\\project\\project.service.spec.ts":[1,1109],"E:\\np-dms\\lcbp3\\backend\\src\\common\\auth\\auth.controller.spec.ts":[1,2191],"E:\\np-dms\\lcbp3\\backend\\src\\modules\\document-numbering\\services\\manual-override.service.spec.ts":[1,5256],"E:\\np-dms\\lcbp3\\backend\\src\\modules\\project\\project.controller.spec.ts":[1,1827],"E:\\np-dms\\lcbp3\\backend\\src\\modules\\migration\\migration.controller.spec.ts":[1,6380],"E:\\np-dms\\lcbp3\\backend\\src\\common\\file-storage\\file-storage.controller.spec.ts":[1,1482],"E:\\np-dms\\lcbp3\\backend\\src\\app.controller.spec.ts":[1,587],"E:\\np-dms\\lcbp3\\backend\\src\\modules\\json-schema\\json-schema.controller.spec.ts":[1,5062]} \ No newline at end of file +{"E:\\np-dms\\lcbp3\\backend\\src\\modules\\correspondence\\due-date-reminder.service.spec.ts":[1,1723],"E:\\np-dms\\lcbp3\\backend\\src\\modules\\correspondence\\correspondence.service.spec.ts":[1,10118],"E:\\np-dms\\lcbp3\\backend\\src\\common\\auth\\auth.service.spec.ts":[1,1538],"E:\\np-dms\\lcbp3\\backend\\src\\modules\\document-numbering\\document-numbering.service.spec.ts":[1,2037],"E:\\np-dms\\lcbp3\\backend\\src\\common\\auth\\casl\\ability.factory.spec.ts":[1,1294],"E:\\np-dms\\lcbp3\\backend\\src\\common\\services\\uuid-resolver.service.spec.ts":[1,5491],"E:\\np-dms\\lcbp3\\backend\\src\\modules\\workflow-engine\\workflow-engine.service.spec.ts":[1,5639],"E:\\np-dms\\lcbp3\\backend\\src\\modules\\workflow-engine\\dsl\\parser.service.spec.ts":[1,5818],"E:\\np-dms\\lcbp3\\backend\\src\\common\\pipes\\parse-uuid.pipe.spec.ts":[1,355],"E:\\np-dms\\lcbp3\\backend\\src\\modules\\user\\user.service.spec.ts":[1,1270],"E:\\np-dms\\lcbp3\\backend\\src\\common\\file-storage\\file-storage.service.spec.ts":[1,1187],"E:\\np-dms\\lcbp3\\backend\\src\\modules\\correspondence\\correspondence.controller.spec.ts":[1,10937],"E:\\np-dms\\lcbp3\\backend\\src\\modules\\migration\\migration.service.spec.ts":[1,1296],"E:\\np-dms\\lcbp3\\backend\\src\\common\\entities\\uuid-base.entity.spec.ts":[1,430],"E:\\np-dms\\lcbp3\\backend\\src\\modules\\project\\project.service.spec.ts":[1,1109],"E:\\np-dms\\lcbp3\\backend\\src\\common\\auth\\auth.controller.spec.ts":[1,2191],"E:\\np-dms\\lcbp3\\backend\\src\\modules\\document-numbering\\services\\manual-override.service.spec.ts":[1,5256],"E:\\np-dms\\lcbp3\\backend\\src\\modules\\project\\project.controller.spec.ts":[1,1827],"E:\\np-dms\\lcbp3\\backend\\src\\modules\\migration\\migration.controller.spec.ts":[1,6380],"E:\\np-dms\\lcbp3\\backend\\src\\common\\file-storage\\file-storage.controller.spec.ts":[1,1482],"E:\\np-dms\\lcbp3\\backend\\src\\app.controller.spec.ts":[1,587],"E:\\np-dms\\lcbp3\\backend\\src\\modules\\json-schema\\json-schema.controller.spec.ts":[1,5062]} \ No newline at end of file diff --git a/backend/src/modules/correspondence/correspondence.service.spec.ts b/backend/src/modules/correspondence/correspondence.service.spec.ts index 2f3d9b7..72ab08e 100644 --- a/backend/src/modules/correspondence/correspondence.service.spec.ts +++ b/backend/src/modules/correspondence/correspondence.service.spec.ts @@ -427,5 +427,297 @@ describe('CorrespondenceService', () => { expect.objectContaining({ originatorId: 10 }) ); }); + + it('should set revisionLabel to "A" for RFA type', async () => { + const mockUser = { + user_id: 1, + primaryOrganizationId: 10, + } as unknown as User; + + const createDto: CreateCorrespondenceDto = { + projectId: 'project-uuid', + typeId: 1, + subject: 'Test Subject', + recipients: [{ organizationId: 'recipient-uuid', type: 'TO' }], + }; + + const typeRepo = testingModule.get>( + getRepositoryToken(CorrespondenceType) + ); + const statusRepo = testingModule.get>( + getRepositoryToken(CorrespondenceStatus) + ); + const uuidResolver = + testingModule.get(UuidResolverService); + + (uuidResolver.resolveProjectId as jest.Mock).mockResolvedValue(100); + (uuidResolver.resolveOrganizationId as jest.Mock).mockResolvedValue(20); + + (typeRepo.findOne as jest.Mock).mockResolvedValue({ + id: 1, + typeCode: 'RFA', + }); + (statusRepo.findOne as jest.Mock).mockResolvedValue({ + id: 1, + statusCode: 'DRAFT', + }); + + (numberingService.generateNextNumber as jest.Mock).mockResolvedValue({ + number: 'DOC-001', + }); + + mockDataSource.manager.findOne + .mockResolvedValueOnce({ id: 10, organizationCode: 'ORG' }) + .mockResolvedValueOnce({ id: 20, organizationCode: 'REC' }); + + const queryRunner = { + connect: jest.fn(), + startTransaction: jest.fn(), + commitTransaction: jest.fn(), + rollbackTransaction: jest.fn(), + release: jest.fn(), + manager: { + create: jest.fn( + (_entity: unknown, payload: Record) => payload + ), + save: jest + .fn() + .mockResolvedValueOnce({ id: 999, publicId: 'corr-uuid' }) + .mockResolvedValueOnce({ id: 1000 }) + .mockResolvedValueOnce([]), + findOne: jest.fn(), + }, + }; + + (mockDataSource.createQueryRunner as jest.Mock).mockReturnValue( + queryRunner + ); + + await service.create(createDto, mockUser); + + expect(queryRunner.manager.create).toHaveBeenCalledWith( + CorrespondenceRevision, + expect.objectContaining({ revisionLabel: 'A' }) + ); + }); + + it('should set revisionLabel to "A" for RFI type', async () => { + const mockUser = { + user_id: 1, + primaryOrganizationId: 10, + } as unknown as User; + + const createDto: CreateCorrespondenceDto = { + projectId: 'project-uuid', + typeId: 1, + subject: 'Test Subject', + recipients: [{ organizationId: 'recipient-uuid', type: 'TO' }], + }; + + const typeRepo = testingModule.get>( + getRepositoryToken(CorrespondenceType) + ); + const statusRepo = testingModule.get>( + getRepositoryToken(CorrespondenceStatus) + ); + const uuidResolver = + testingModule.get(UuidResolverService); + + (uuidResolver.resolveProjectId as jest.Mock).mockResolvedValue(100); + (uuidResolver.resolveOrganizationId as jest.Mock).mockResolvedValue(20); + + (typeRepo.findOne as jest.Mock).mockResolvedValue({ + id: 1, + typeCode: 'RFI', + }); + (statusRepo.findOne as jest.Mock).mockResolvedValue({ + id: 1, + statusCode: 'DRAFT', + }); + + (numberingService.generateNextNumber as jest.Mock).mockResolvedValue({ + number: 'DOC-001', + }); + + mockDataSource.manager.findOne + .mockResolvedValueOnce({ id: 10, organizationCode: 'ORG' }) + .mockResolvedValueOnce({ id: 20, organizationCode: 'REC' }); + + const queryRunner = { + connect: jest.fn(), + startTransaction: jest.fn(), + commitTransaction: jest.fn(), + rollbackTransaction: jest.fn(), + release: jest.fn(), + manager: { + create: jest.fn( + (_entity: unknown, payload: Record) => payload + ), + save: jest + .fn() + .mockResolvedValueOnce({ id: 999, publicId: 'corr-uuid' }) + .mockResolvedValueOnce({ id: 1000 }) + .mockResolvedValueOnce([]), + findOne: jest.fn(), + }, + }; + + (mockDataSource.createQueryRunner as jest.Mock).mockReturnValue( + queryRunner + ); + + await service.create(createDto, mockUser); + + expect(queryRunner.manager.create).toHaveBeenCalledWith( + CorrespondenceRevision, + expect.objectContaining({ revisionLabel: 'A' }) + ); + }); + + it('should set revisionLabel to null for LETTER type', async () => { + const mockUser = { + user_id: 1, + primaryOrganizationId: 10, + } as unknown as User; + + const createDto: CreateCorrespondenceDto = { + projectId: 'project-uuid', + typeId: 1, + subject: 'Test Subject', + recipients: [{ organizationId: 'recipient-uuid', type: 'TO' }], + }; + + const typeRepo = testingModule.get>( + getRepositoryToken(CorrespondenceType) + ); + const statusRepo = testingModule.get>( + getRepositoryToken(CorrespondenceStatus) + ); + const uuidResolver = + testingModule.get(UuidResolverService); + + (uuidResolver.resolveProjectId as jest.Mock).mockResolvedValue(100); + (uuidResolver.resolveOrganizationId as jest.Mock).mockResolvedValue(20); + + (typeRepo.findOne as jest.Mock).mockResolvedValue({ + id: 1, + typeCode: 'LETTER', + }); + (statusRepo.findOne as jest.Mock).mockResolvedValue({ + id: 1, + statusCode: 'DRAFT', + }); + + (numberingService.generateNextNumber as jest.Mock).mockResolvedValue({ + number: 'DOC-001', + }); + + mockDataSource.manager.findOne + .mockResolvedValueOnce({ id: 10, organizationCode: 'ORG' }) + .mockResolvedValueOnce({ id: 20, organizationCode: 'REC' }); + + const queryRunner = { + connect: jest.fn(), + startTransaction: jest.fn(), + commitTransaction: jest.fn(), + rollbackTransaction: jest.fn(), + release: jest.fn(), + manager: { + create: jest.fn( + (_entity: unknown, payload: Record) => payload + ), + save: jest + .fn() + .mockResolvedValueOnce({ id: 999, publicId: 'corr-uuid' }) + .mockResolvedValueOnce({ id: 1000 }) + .mockResolvedValueOnce([]), + findOne: jest.fn(), + }, + }; + + (mockDataSource.createQueryRunner as jest.Mock).mockReturnValue( + queryRunner + ); + + await service.create(createDto, mockUser); + + expect(queryRunner.manager.create).toHaveBeenCalledWith( + CorrespondenceRevision, + expect.objectContaining({ revisionLabel: null }) + ); + }); + + it('should set revisionLabel to null for MEMO type', async () => { + const mockUser = { + user_id: 1, + primaryOrganizationId: 10, + } as unknown as User; + + const createDto: CreateCorrespondenceDto = { + projectId: 'project-uuid', + typeId: 1, + subject: 'Test Subject', + recipients: [{ organizationId: 'recipient-uuid', type: 'TO' }], + }; + + const typeRepo = testingModule.get>( + getRepositoryToken(CorrespondenceType) + ); + const statusRepo = testingModule.get>( + getRepositoryToken(CorrespondenceStatus) + ); + const uuidResolver = + testingModule.get(UuidResolverService); + + (uuidResolver.resolveProjectId as jest.Mock).mockResolvedValue(100); + (uuidResolver.resolveOrganizationId as jest.Mock).mockResolvedValue(20); + + (typeRepo.findOne as jest.Mock).mockResolvedValue({ + id: 1, + typeCode: 'MEMO', + }); + (statusRepo.findOne as jest.Mock).mockResolvedValue({ + id: 1, + statusCode: 'DRAFT', + }); + + (numberingService.generateNextNumber as jest.Mock).mockResolvedValue({ + number: 'DOC-001', + }); + + mockDataSource.manager.findOne + .mockResolvedValueOnce({ id: 10, organizationCode: 'ORG' }) + .mockResolvedValueOnce({ id: 20, organizationCode: 'REC' }); + + const queryRunner = { + connect: jest.fn(), + startTransaction: jest.fn(), + commitTransaction: jest.fn(), + rollbackTransaction: jest.fn(), + release: jest.fn(), + manager: { + create: jest.fn( + (_entity: unknown, payload: Record) => payload + ), + save: jest + .fn() + .mockResolvedValueOnce({ id: 999, publicId: 'corr-uuid' }) + .mockResolvedValueOnce({ id: 1000 }) + .mockResolvedValueOnce([]), + findOne: jest.fn(), + }, + }; + + (mockDataSource.createQueryRunner as jest.Mock).mockReturnValue( + queryRunner + ); + + await service.create(createDto, mockUser); + + expect(queryRunner.manager.create).toHaveBeenCalledWith( + CorrespondenceRevision, + expect.objectContaining({ revisionLabel: null }) + ); + }); }); }); diff --git a/backend/src/modules/correspondence/correspondence.service.ts b/backend/src/modules/correspondence/correspondence.service.ts index 7955c25..83384d5 100644 --- a/backend/src/modules/correspondence/correspondence.service.ts +++ b/backend/src/modules/correspondence/correspondence.service.ts @@ -55,6 +55,19 @@ export class CorrespondenceService { return permissions.includes('system.manage_all'); } + /** + * Business Rule: Revision Label Strategy + * - RFA, RFI: Use alphabet starting with 'A' (A, B, C...) + * - Other types (LETTER, MEMO, etc.): Use numeric (null for first, then 1, 2, 3...) + */ + private getInitialRevisionLabel(typeCode: string): string | null { + const alphabetTypes = ['RFA', 'RFI']; + if (alphabetTypes.includes(typeCode.toUpperCase())) { + return 'A'; // Alphabet for RFA, RFI + } + return null; // Numeric (null for revision 0) + } + constructor( @InjectRepository(Correspondence) private correspondenceRepo: Repository, @@ -288,7 +301,7 @@ export class CorrespondenceService { const revision = queryRunner.manager.create(CorrespondenceRevision, { correspondenceId: savedCorr.id, revisionNumber: 0, - revisionLabel: 'A', + revisionLabel: this.getInitialRevisionLabel(type.typeCode), isCurrent: true, statusId: statusDraft.id, subject: createDto.subject, diff --git a/specs/01-requirements/01-03-modules/01-03-02-correspondence.md b/specs/01-requirements/01-03-modules/01-03-02-correspondence.md index b333aa5..1293cbf 100644 --- a/specs/01-requirements/01-03-modules/01-03-02-correspondence.md +++ b/specs/01-requirements/01-03-modules/01-03-02-correspondence.md @@ -146,8 +146,14 @@ related: - 1 Correspondence Master → หลาย Revision (1:N) - `is_current = TRUE` มีได้เพียง 1 แถวต่อ correspondence (UNIQUE constraint) -- `revision_label`: A, B, C, ... (หรือ 1.1, 1.2 แล้วแต่ type) - `revision_number`: 0-based integer สำหรับ sorting +- `revision_label`: กำหนดตามประเภทเอกสารดังนี้: + | Type | Initial Label | ลำดับถัดไป | Format | + |------|--------------|------------|--------| + | **RFA, RFI** | `A` | B, C, D... | Alphabet | + | **LETTER, MEMO, TRANSMITTAL, EMAIL, INSTRUCTION, NOTICE, MOM, OTHER** | `null` | 1, 2, 3... | Numeric | + +**หมายเหตุ:** Shop Drawing และ As-Built Drawing ใช้ revision label แยกตามกฎของ Drawing Module (numeric '0', '1', '2'... หรือ user กำหนดเอง) ---