@muni-sanfer/types-gestor-documental 0.0.1-beta.2 → 0.0.1-beta.4

package/src/base/entities.ts

@@ -59,7 +59,8 @@ export type DocumentTrackingAction =
   | 'NumberAnnulled'
   | 'Annulled'
   | 'Delivered'
-  | 'Derived';
+  | 'Derived'
+  | 'Reassigned';
 
 export const DocumentTrackingAction = {
   Created: 'Created',
@@ -75,8 +76,16 @@ export const DocumentTrackingAction = {
   Annulled: 'Annulled',
   Delivered: 'Delivered',
   Derived: 'Derived',
+  Reassigned: 'Reassigned',
 } satisfies Record<string, DocumentTrackingAction>;
 
+export type DocumentFlowStepType = 'Employee' | 'DirectorateHead';
+
+export const DocumentFlowStepType = {
+  Employee: 'Employee',
+  DirectorateHead: 'DirectorateHead',
+} satisfies Record<string, DocumentFlowStepType>;
+
 export type DocumentAttachmentType = 'File' | 'Link';
 
 export const DocumentAttachmentType = {
@@ -108,6 +117,101 @@ export const DocumentInstruction = {
   Archive: 'Archive',
 } satisfies Record<string, DocumentInstruction>;
 
+export type CaseFileStatus = 'Open' | 'Closed';
+
+export const CaseFileStatus = {
+  Open: 'Open',
+  Closed: 'Closed',
+} satisfies Record<string, CaseFileStatus>;
+
+export type CaseFileIncorporationMechanism =
+  'Manual' | 'WebService' | 'Mixed' | 'CitizenRepository' | 'Interoperability';
+
+export const CaseFileIncorporationMechanism = {
+  Manual: 'Manual',
+  WebService: 'WebService',
+  Mixed: 'Mixed',
+  CitizenRepository: 'CitizenRepository',
+  Interoperability: 'Interoperability',
+} satisfies Record<string, CaseFileIncorporationMechanism>;
+
+export type CaseFileActuationType =
+  | 'AdministrativeAct'
+  | 'Notification'
+  | 'OfficialCommunication'
+  | 'Interoperability'
+  | 'RequestReception'
+  | 'Subfolder'
+  | 'PowerRegistration';
+
+export const CaseFileActuationType = {
+  AdministrativeAct: 'AdministrativeAct',
+  Notification: 'Notification',
+  OfficialCommunication: 'OfficialCommunication',
+  Interoperability: 'Interoperability',
+  RequestReception: 'RequestReception',
+  Subfolder: 'Subfolder',
+  PowerRegistration: 'PowerRegistration',
+} satisfies Record<string, CaseFileActuationType>;
+
+export type CaseFileEntryKind = 'Document' | 'File' | 'CaseFile';
+
+export const CaseFileEntryKind = {
+  Document: 'Document',
+  File: 'File',
+  CaseFile: 'CaseFile',
+} satisfies Record<string, CaseFileEntryKind>;
+
+export type CaseFileActorRelation =
+  'Responsible' | 'Interested' | 'Author' | 'Referred' | 'Recipient' | 'MinisterOfFaith';
+
+export const CaseFileActorRelation = {
+  Responsible: 'Responsible',
+  Interested: 'Interested',
+  Author: 'Author',
+  Referred: 'Referred',
+  Recipient: 'Recipient',
+  MinisterOfFaith: 'MinisterOfFaith',
+} satisfies Record<string, CaseFileActorRelation>;
+
+export type CaseFileActorType = 'Citizen' | 'Foreigner' | 'PrivateInstitution' | 'Official';
+
+export const CaseFileActorType = {
+  Citizen: 'Citizen',
+  Foreigner: 'Foreigner',
+  PrivateInstitution: 'PrivateInstitution',
+  Official: 'Official',
+} satisfies Record<string, CaseFileActorType>;
+
+export type CaseFileTrackingAction =
+  | 'Created'
+  | 'Updated'
+  | 'EntryAdded'
+  | 'EntryVoided'
+  | 'ParticipantAdded'
+  | 'ParticipantRemoved'
+  | 'Closed'
+  | 'Exported';
+
+export const CaseFileTrackingAction = {
+  Created: 'Created',
+  Updated: 'Updated',
+  EntryAdded: 'EntryAdded',
+  EntryVoided: 'EntryVoided',
+  ParticipantAdded: 'ParticipantAdded',
+  ParticipantRemoved: 'ParticipantRemoved',
+  Closed: 'Closed',
+  Exported: 'Exported',
+} satisfies Record<string, CaseFileTrackingAction>;
+
+export type CaseFileAccessAction = 'Viewed' | 'FileDownloaded' | 'Exported';
+
+export const CaseFileAccessAction = {
+  Viewed: 'Viewed',
+  FileDownloaded: 'FileDownloaded',
+  Exported: 'Exported',
+} satisfies Record<string, CaseFileAccessAction>;
+
 export interface DocumentTypeEntity {
   id: string;
   name: string;
@@ -121,6 +225,7 @@ export interface DocumentTypeEntity {
   enabled: boolean;
   documents?: DocumentEntity[];
   annulledNumbers?: DocumentAnnulledNumberEntity[];
+  flowSteps?: DocumentTypeFlowStepEntity[];
   deleted: boolean;
   createdAt: string;
   updatedAt: string;
@@ -162,6 +267,7 @@ export interface DocumentEntity {
   annulledNumbers?: DocumentAnnulledNumberEntity[];
   recipients?: DocumentRecipientEntity[];
   deliveries?: DocumentDeliveryEntity[];
+  caseFileEntries?: CaseFileEntryEntity[];
   deleted: boolean;
   createdAt: string;
   updatedAt: string;
@@ -254,3 +360,157 @@ export interface DocumentDeliveryEntity {
   documentId: string;
   createdAt: string;
 }
+
+export interface DocumentTypeFlowStepEntity {
+  id: string;
+  role: DocumentParticipantRole;
+  order: number;
+  type: DocumentFlowStepType;
+  employeeId?: string | null;
+  directorateCodeReference?: number | null;
+  name: string;
+  position?: string | null;
+  documentType?: DocumentTypeEntity;
+  documentTypeId: string;
+  createdAt: string;
+}
+
+export interface ProcedureEntity {
+  id: string;
+  name: string;
+  cpatId?: string | null;
+  cpatCode?: string | null;
+  description?: string | null;
+  enabled: boolean;
+  caseFiles?: CaseFileEntity[];
+  deleted: boolean;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface CaseFileSequenceEntity {
+  year: number;
+  next: number;
+}
+
+export interface CaseFileEntity {
+  id: string;
+  code: string;
+  year: number;
+  number: number;
+  title: string;
+  subject: string;
+  summary?: string | null;
+  status: CaseFileStatus;
+  accessLevel: DocumentAccessLevel;
+  hasSensitiveData: boolean;
+  incorporationMechanism: CaseFileIncorporationMechanism;
+  schemaVersion: string;
+  procedure?: ProcedureEntity;
+  procedureId: string;
+  responsibleEmployeeId: string;
+  responsibleFullName: string;
+  responsiblePosition?: string | null;
+  closedAt?: string | null;
+  closedByEmployeeId?: string | null;
+  closedByFullName?: string | null;
+  closingNote?: string | null;
+  participants?: CaseFileParticipantEntity[];
+  actors?: CaseFileActorEntity[];
+  entries?: CaseFileEntryEntity[];
+  linkedFrom?: CaseFileEntryEntity[];
+  trackings?: CaseFileTrackingEntity[];
+  metadataChanges?: CaseFileMetadataChangeEntity[];
+  accesses?: CaseFileAccessEntity[];
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface CaseFileParticipantEntity {
+  id: string;
+  employeeId: string;
+  fullName: string;
+  position?: string | null;
+  addedByEmployeeId: string;
+  addedByFullName: string;
+  caseFile?: CaseFileEntity;
+  caseFileId: string;
+  createdAt: string;
+}
+
+export interface CaseFileActorEntity {
+  id: string;
+  relation: CaseFileActorRelation;
+  actorType: CaseFileActorType;
+  identifier?: string | null;
+  name: string;
+  caseFile?: CaseFileEntity;
+  caseFileId: string;
+  createdAt: string;
+}
+
+export interface CaseFileEntryEntity {
+  id: string;
+  sequence: number;
+  kind: CaseFileEntryKind;
+  actuationType: CaseFileActuationType;
+  title: string;
+  document?: DocumentEntity | null;
+  documentId?: string | null;
+  fileId?: string | null;
+  fileName?: string | null;
+  documentTypeName?: string | null;
+  originDate?: string | null;
+  author?: string | null;
+  keywords: string[];
+  accessLevel?: DocumentAccessLevel | null;
+  hasSensitiveData?: boolean | null;
+  linkedCaseFile?: CaseFileEntity | null;
+  linkedCaseFileId?: string | null;
+  sha256?: string | null;
+  size?: number | null;
+  hasAdvancedSignature: boolean;
+  incorporatedByEmployeeId: string;
+  incorporatedByFullName: string;
+  voidedAt?: string | null;
+  voidedByEmployeeId?: string | null;
+  voidedByFullName?: string | null;
+  voidReason?: string | null;
+  caseFile?: CaseFileEntity;
+  caseFileId: string;
+  createdAt: string;
+}
+
+export interface CaseFileTrackingEntity {
+  id: string;
+  action: CaseFileTrackingAction;
+  observation?: string | null;
+  employeeId?: string | null;
+  employeeFullName?: string | null;
+  caseFile?: CaseFileEntity;
+  caseFileId: string;
+  createdAt: string;
+}
+
+export interface CaseFileMetadataChangeEntity {
+  id: string;
+  field: string;
+  previousValue?: string | null;
+  newValue?: string | null;
+  employeeId: string;
+  employeeFullName: string;
+  caseFile?: CaseFileEntity;
+  caseFileId: string;
+  createdAt: string;
+}
+
+export interface CaseFileAccessEntity {
+  id: string;
+  action: CaseFileAccessAction;
+  entryId?: string | null;
+  employeeId: string;
+  employeeFullName: string;
+  caseFile?: CaseFileEntity;
+  caseFileId: string;
+  createdAt: string;
+}

package/src/contracts/caseFile.contract.ts

@@ -0,0 +1,134 @@
+import {
+  type CaseFileActorRelation,
+  type CaseFileActorType,
+  type CaseFileActuationType,
+  type CaseFileEntity,
+  type CaseFileStatus,
+  type DocumentAccessLevel,
+} from '../base/entities';
+import {
+  type CaseFileAddEntryResponseEntity,
+  type CaseFileCreateResponseEntity,
+  type CaseFileEntryFileResponseEntity,
+  type CaseFileExportResponseEntity,
+  type CaseFileGetAllResponseEntity,
+  type CaseFileGetByIdResponseEntity,
+  type CaseFileUpdateResponseEntity,
+} from '../entities';
+import { type RpcPage } from './contract';
+import { type DocumentActor } from './document.contract';
+
+/** Patrones NATS de `caseFile`: `<servicio>.<recurso>.<acción>`. */
+export const CaseFilePatterns = {
+  getAll: 'gestorDocumental.caseFile.getAll',
+  getById: 'gestorDocumental.caseFile.getById',
+  create: 'gestorDocumental.caseFile.create',
+  update: 'gestorDocumental.caseFile.update',
+  addEntry: 'gestorDocumental.caseFile.addEntry',
+  voidEntry: 'gestorDocumental.caseFile.voidEntry',
+  share: 'gestorDocumental.caseFile.share',
+  unshare: 'gestorDocumental.caseFile.unshare',
+  close: 'gestorDocumental.caseFile.close',
+  getEntryFile: 'gestorDocumental.caseFile.getEntryFile',
+  getExport: 'gestorDocumental.caseFile.getExport',
+} as const;
+
+/** Persona u organización relacionada con el expediente (MGDEE54). */
+export interface CaseFileActorInput {
+  relation: CaseFileActorRelation;
+  actorType: CaseFileActorType;
+  identifier?: string | null;
+  name: string;
+}
+
+/** Metadatos del expediente que se ingresan a mano. */
+export interface CaseFileWritePayload {
+  title: string;
+  subject: string;
+  summary?: string | null;
+  procedureId: string;
+  accessLevel: DocumentAccessLevel;
+  hasSensitiveData: boolean;
+  actors?: CaseFileActorInput[];
+}
+
+/** Actuación que se incorpora al índice: un documento del gestor, un archivo subido u otro expediente. */
+export type CaseFileEntryInput =
+  | { kind: 'Document'; actuationType: CaseFileActuationType; documentId: string }
+  | {
+      kind: 'File';
+      actuationType: CaseFileActuationType;
+      fileId: string;
+      fileName: string;
+      title: string;
+      documentTypeName?: string | null;
+      originDate?: string | null;
+      author?: string | null;
+      keywords: string[];
+      accessLevel: DocumentAccessLevel;
+      hasSensitiveData: boolean;
+    }
+  | { kind: 'CaseFile'; actuationType: CaseFileActuationType; linkedCaseFileId: string };
+
+/** Quién hace la operación (de la sesión) y si puede ver todos los expedientes. */
+interface CaseFileActorPayload {
+  actor: DocumentActor;
+  viewAll?: boolean;
+}
+
+/** Ámbito del listado: los expedientes del funcionario (responsable o compartidos con él) o todos. */
+export type CaseFileScope = 'mine' | 'all';
+
+export interface CaseFileContract {
+  [CaseFilePatterns.getAll]: {
+    payload: {
+      pagination?: { page?: number; limit?: number };
+      filters?: { search?: string; status?: CaseFileStatus; procedureId?: string; scope?: CaseFileScope };
+    } & CaseFileActorPayload;
+    response: RpcPage<CaseFileGetAllResponseEntity[]>;
+  };
+  /** Por id o por su identificador (`EXP-2026-00001`), que es el del enlace persistente. Queda en el registro de accesos. */
+  [CaseFilePatterns.getById]: {
+    payload: { id: string } & CaseFileActorPayload;
+    response: CaseFileGetByIdResponseEntity;
+  };
+  [CaseFilePatterns.create]: {
+    payload: CaseFileWritePayload & { actor: DocumentActor };
+    response: CaseFileCreateResponseEntity;
+  };
+  [CaseFilePatterns.update]: {
+    payload: CaseFileWritePayload & Pick<CaseFileEntity, 'id'> & { actor: DocumentActor };
+    response: CaseFileUpdateResponseEntity;
+  };
+  [CaseFilePatterns.addEntry]: {
+    payload: Pick<CaseFileEntity, 'id'> & { entry: CaseFileEntryInput } & CaseFileActorPayload;
+    response: CaseFileAddEntryResponseEntity;
+  };
+  /** Deja una actuación sin efecto, con su motivo. No se elimina del índice. */
+  [CaseFilePatterns.voidEntry]: {
+    payload: Pick<CaseFileEntity, 'id'> & { entryId: string; reason: string; actor: DocumentActor };
+    response: CaseFileUpdateResponseEntity;
+  };
+  [CaseFilePatterns.share]: {
+    payload: Pick<CaseFileEntity, 'id'> & { employeeIds: string[]; actor: DocumentActor };
+    response: CaseFileUpdateResponseEntity;
+  };
+  [CaseFilePatterns.unshare]: {
+    payload: Pick<CaseFileEntity, 'id'> & { participantId: string; actor: DocumentActor };
+    response: CaseFileUpdateResponseEntity;
+  };
+  [CaseFilePatterns.close]: {
+    payload: Pick<CaseFileEntity, 'id'> & { note?: string | null; actor: DocumentActor };
+    response: CaseFileUpdateResponseEntity;
+  };
+  /** Archivo de una actuación del índice. Queda en el registro de accesos. */
+  [CaseFilePatterns.getEntryFile]: {
+    payload: Pick<CaseFileEntity, 'id'> & { entryId: string } & CaseFileActorPayload;
+    response: CaseFileEntryFileResponseEntity;
+  };
+  /** Metadatos y archivos para exportar el expediente completo. Queda en la trazabilidad y en el registro de accesos. */
+  [CaseFilePatterns.getExport]: {
+    payload: Pick<CaseFileEntity, 'id'> & CaseFileActorPayload;
+    response: CaseFileExportResponseEntity;
+  };
+}

package/src/contracts/document.contract.ts

@@ -4,6 +4,7 @@ import {
   type DocumentDeliveryEntity,
   type DocumentEntity,
   type DocumentInstruction,
+  type DocumentParticipantEntity,
   type DocumentStatus,
 } from '../base/entities';
 import {
@@ -17,6 +18,7 @@ import {
   type DocumentGetSummaryResponseEntity,
   type DocumentInboxItemEntity,
   type DocumentPublicFileResponseEntity,
+  type DocumentReassignResponseEntity,
   type DocumentReviewResponseEntity,
   type DocumentUpdateResponseEntity,
   type DocumentVerifyResponseEntity,
@@ -32,6 +34,7 @@ export const DocumentPatterns = {
   create: 'gestorDocumental.document.create',
   update: 'gestorDocumental.document.update',
   review: 'gestorDocumental.document.review',
+  reassign: 'gestorDocumental.document.reassign',
   discard: 'gestorDocumental.document.discard',
   annul: 'gestorDocumental.document.annul',
   derive: 'gestorDocumental.document.derive',
@@ -165,6 +168,21 @@ export interface DocumentContract {
     };
     response: DocumentReviewResponseEntity;
   };
+  /**
+   * Pasa un turno pendiente (de visación o de firma) a otro funcionario, por ausencia o por error, y lo deja en la
+   * trazabilidad con su motivo. Puede hacerlo quien redactó el documento; con `anyDocument`, quien lleva el registro.
+   */
+  [DocumentPatterns.reassign]: {
+    payload: Pick<DocumentEntity, 'id'> & {
+      participantId: DocumentParticipantEntity['id'];
+      // Funcionario que toma el turno.
+      employeeId: string;
+      reason: string;
+      actor: DocumentActor;
+      anyDocument?: boolean;
+    };
+    response: DocumentReassignResponseEntity;
+  };
   [DocumentPatterns.discard]: {
     payload: Pick<DocumentEntity, 'id'> & { actor: DocumentActor };
     response: DocumentDiscardResponseEntity;

package/src/contracts/documentType.contract.ts

@@ -1,4 +1,4 @@
-import { type DocumentCategory, type DocumentTypeEntity } from '../base/entities';
+import { type DocumentCategory, type DocumentParticipantRole, type DocumentTypeEntity } from '../base/entities';
 import {
   type DocumentTypeCreateResponseEntity,
   type DocumentTypeGetAllResponseEntity,
@@ -16,6 +16,15 @@ export const DocumentTypePatterns = {
   setEnabled: 'gestorDocumental.documentType.setEnabled',
 } as const;
 
+/**
+ * Paso del flujo sugerido de un tipo documental: un funcionario en particular, o quien dirija una dirección al
+ * momento de redactar (su jefatura o, con subrogancia activa, el subrogante). El nombre de la dirección lo resuelve
+ * el gateway; el navegador solo indica cuál es.
+ */
+export type DocumentFlowStepInput =
+  | { role: DocumentParticipantRole; type: 'Employee'; employeeId: string }
+  | { role: DocumentParticipantRole; type: 'DirectorateHead'; directorateCodeReference: number; name: string };
+
 /** Datos de un tipo documental al crearlo o editarlo. */
 export interface DocumentTypeWritePayload {
   name: string;
@@ -27,6 +36,8 @@ export interface DocumentTypeWritePayload {
   resetsYearly?: boolean;
   directorateCodeReference?: number | null;
   enabled?: boolean;
+  // Flujo sugerido, en el orden en que les toca dentro de cada rol. Al editar, si no viene, el flujo no cambia.
+  flowSteps?: DocumentFlowStepInput[];
 }
 
 /**

package/src/contracts/index.ts

@@ -1,15 +1,21 @@
+import { CaseFilePatterns, type CaseFileContract } from './caseFile.contract';
 import { DocumentPatterns, type DocumentContract } from './document.contract';
 import { DocumentTypePatterns, type DocumentTypeContract } from './documentType.contract';
+import { ProcedurePatterns, type ProcedureContract } from './procedure.contract';
 
 export * from './contract';
 export * from './document.contract';
 export * from './documentType.contract';
+export * from './procedure.contract';
+export * from './caseFile.contract';
 
 /** Patrones NATS de gestor-documental-ms, por recurso: `gestorDocumental.<recurso>.<acción>`. */
 export const GestorDocumentalPatterns = {
   documentType: DocumentTypePatterns,
   document: DocumentPatterns,
+  procedure: ProcedurePatterns,
+  caseFile: CaseFilePatterns,
 } as const;
 
 /** Contrato completo de gestor-documental-ms: la unión de los contratos de sus recursos. */
-export type GestorDocumentalContract = DocumentTypeContract & DocumentContract;
+export type GestorDocumentalContract = DocumentTypeContract & DocumentContract & ProcedureContract & CaseFileContract;

package/src/contracts/procedure.contract.ts

@@ -0,0 +1,53 @@
+import { type ProcedureEntity } from '../base/entities';
+import {
+  type ProcedureCreateResponseEntity,
+  type ProcedureGetAllResponseEntity,
+  type ProcedureGetByIdResponseEntity,
+  type ProcedureUpdateResponseEntity,
+} from '../entities';
+import { type RpcPage } from './contract';
+
+/** Patrones NATS de `procedure`: `<servicio>.<recurso>.<acción>`. */
+export const ProcedurePatterns = {
+  getAll: 'gestorDocumental.procedure.getAll',
+  getById: 'gestorDocumental.procedure.getById',
+  create: 'gestorDocumental.procedure.create',
+  update: 'gestorDocumental.procedure.update',
+  setEnabled: 'gestorDocumental.procedure.setEnabled',
+} as const;
+
+/** Datos de un procedimiento administrativo al crearlo o editarlo. */
+export interface ProcedureWritePayload {
+  name: string;
+  cpatId?: string | null;
+  cpatCode?: string | null;
+  description?: string | null;
+  enabled?: boolean;
+}
+
+export interface ProcedureContract {
+  [ProcedurePatterns.getAll]: {
+    // sin `page` y `limit` responde todos en una sola página
+    payload: {
+      pagination?: { page?: number; limit?: number };
+      filters?: { search?: string; enabled?: boolean };
+    };
+    response: RpcPage<ProcedureGetAllResponseEntity[]>;
+  };
+  [ProcedurePatterns.getById]: {
+    payload: Pick<ProcedureEntity, 'id'>;
+    response: ProcedureGetByIdResponseEntity;
+  };
+  [ProcedurePatterns.create]: {
+    payload: ProcedureWritePayload;
+    response: ProcedureCreateResponseEntity;
+  };
+  [ProcedurePatterns.update]: {
+    payload: ProcedureWritePayload & Pick<ProcedureEntity, 'id'>;
+    response: ProcedureUpdateResponseEntity;
+  };
+  [ProcedurePatterns.setEnabled]: {
+    payload: Pick<ProcedureEntity, 'id' | 'enabled'>;
+    response: ProcedureUpdateResponseEntity;
+  };
+}