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

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;
+  };
+}

package/src/entities/caseFile/caseFile.entity.ts

@@ -0,0 +1,196 @@
+import {
+  CaseFileAccessEntity,
+  CaseFileActorEntity,
+  CaseFileEntity,
+  CaseFileEntryEntity,
+  CaseFileMetadataChangeEntity,
+  CaseFileParticipantEntity,
+  CaseFileTrackingEntity,
+  DocumentEntity,
+  ProcedureEntity,
+} from '../../base/entities';
+import { DocumentTypeSummaryEntity } from '../document';
+
+/** Expediente al que se hace referencia desde otro lado: cómo se cita y en qué estado está. */
+export interface CaseFileLinkEntity {
+  id: CaseFileEntity['id'];
+  code: CaseFileEntity['code'];
+  title: CaseFileEntity['title'];
+  status: CaseFileEntity['status'];
+}
+
+export interface CaseFileGetAllResponseEntity extends CaseFileLinkEntity {
+  subject: CaseFileEntity['subject'];
+  accessLevel: CaseFileEntity['accessLevel'];
+  hasSensitiveData: CaseFileEntity['hasSensitiveData'];
+  procedure: Pick<ProcedureEntity, 'id' | 'name'>;
+  responsibleEmployeeId: CaseFileEntity['responsibleEmployeeId'];
+  responsibleFullName: CaseFileEntity['responsibleFullName'];
+  /** Actuaciones vigentes del índice (las que quedaron sin efecto no cuentan). */
+  entries: number;
+  participants: number;
+  createdAt: CaseFileEntity['createdAt'];
+  closedAt: CaseFileEntity['closedAt'];
+}
+
+/** Documento del gestor incorporado al expediente. */
+export interface CaseFileEntryDocumentEntity {
+  id: DocumentEntity['id'];
+  subject: DocumentEntity['subject'];
+  status: DocumentEntity['status'];
+  correlative: DocumentEntity['correlative'];
+  correlativeYear: DocumentEntity['correlativeYear'];
+  documentType: DocumentTypeSummaryEntity;
+}
+
+/** Entrada del índice electrónico: una actuación, en su orden de incorporación. */
+export interface CaseFileEntryResponseEntity {
+  id: CaseFileEntryEntity['id'];
+  sequence: CaseFileEntryEntity['sequence'];
+  kind: CaseFileEntryEntity['kind'];
+  actuationType: CaseFileEntryEntity['actuationType'];
+  title: CaseFileEntryEntity['title'];
+  document: CaseFileEntryDocumentEntity | null;
+  fileName: CaseFileEntryEntity['fileName'];
+  documentTypeName: CaseFileEntryEntity['documentTypeName'];
+  originDate: CaseFileEntryEntity['originDate'];
+  author: CaseFileEntryEntity['author'];
+  keywords: CaseFileEntryEntity['keywords'];
+  accessLevel: CaseFileEntryEntity['accessLevel'];
+  hasSensitiveData: CaseFileEntryEntity['hasSensitiveData'];
+  linkedCaseFile: CaseFileLinkEntity | null;
+  /** `true` si la entrada tiene un archivo que se puede abrir (un documento o un archivo subido). */
+  hasFile: boolean;
+  sha256: CaseFileEntryEntity['sha256'];
+  size: CaseFileEntryEntity['size'];
+  hasAdvancedSignature: CaseFileEntryEntity['hasAdvancedSignature'];
+  incorporatedByEmployeeId: CaseFileEntryEntity['incorporatedByEmployeeId'];
+  incorporatedByFullName: CaseFileEntryEntity['incorporatedByFullName'];
+  createdAt: CaseFileEntryEntity['createdAt'];
+  voidedAt: CaseFileEntryEntity['voidedAt'];
+  voidedByFullName: CaseFileEntryEntity['voidedByFullName'];
+  voidReason: CaseFileEntryEntity['voidReason'];
+  /** `true` si quien consulta puede dejarla sin efecto: el responsable o quien la incorporó, con el expediente abierto. */
+  canVoid: boolean;
+}
+
+export interface CaseFileParticipantResponseEntity {
+  id: CaseFileParticipantEntity['id'];
+  employeeId: CaseFileParticipantEntity['employeeId'];
+  fullName: CaseFileParticipantEntity['fullName'];
+  position: CaseFileParticipantEntity['position'];
+  addedByFullName: CaseFileParticipantEntity['addedByFullName'];
+  createdAt: CaseFileParticipantEntity['createdAt'];
+}
+
+export interface CaseFileActorResponseEntity {
+  id: CaseFileActorEntity['id'];
+  relation: CaseFileActorEntity['relation'];
+  actorType: CaseFileActorEntity['actorType'];
+  identifier: CaseFileActorEntity['identifier'];
+  name: CaseFileActorEntity['name'];
+}
+
+export interface CaseFileTrackingResponseEntity {
+  id: CaseFileTrackingEntity['id'];
+  action: CaseFileTrackingEntity['action'];
+  observation: CaseFileTrackingEntity['observation'];
+  employeeFullName: CaseFileTrackingEntity['employeeFullName'];
+  createdAt: CaseFileTrackingEntity['createdAt'];
+}
+
+export interface CaseFileMetadataChangeResponseEntity {
+  id: CaseFileMetadataChangeEntity['id'];
+  /** Código oficial del metadato. Ej: `MGDEE1_5`. */
+  field: CaseFileMetadataChangeEntity['field'];
+  previousValue: CaseFileMetadataChangeEntity['previousValue'];
+  newValue: CaseFileMetadataChangeEntity['newValue'];
+  employeeFullName: CaseFileMetadataChangeEntity['employeeFullName'];
+  createdAt: CaseFileMetadataChangeEntity['createdAt'];
+}
+
+export interface CaseFileAccessResponseEntity {
+  id: CaseFileAccessEntity['id'];
+  action: CaseFileAccessEntity['action'];
+  entryId: CaseFileAccessEntity['entryId'];
+  /** Título del documento que se abrió, si el acceso fue a uno. */
+  entryTitle: string | null;
+  employeeFullName: CaseFileAccessEntity['employeeFullName'];
+  createdAt: CaseFileAccessEntity['createdAt'];
+}
+
+export interface CaseFileGetByIdResponseEntity extends CaseFileGetAllResponseEntity {
+  summary: CaseFileEntity['summary'];
+  procedure: Pick<ProcedureEntity, 'id' | 'name' | 'cpatId' | 'cpatCode'>;
+  responsiblePosition: CaseFileEntity['responsiblePosition'];
+  incorporationMechanism: CaseFileEntity['incorporationMechanism'];
+  schemaVersion: CaseFileEntity['schemaVersion'];
+  /** Enlace persistente del expediente (MGDEE4_2). `null` si el servicio no tiene configurada la dirección. */
+  uri: string | null;
+  closedByFullName: CaseFileEntity['closedByFullName'];
+  closingNote: CaseFileEntity['closingNote'];
+  index: CaseFileEntryResponseEntity[];
+  sharedWith: CaseFileParticipantResponseEntity[];
+  actors: CaseFileActorResponseEntity[];
+  trackings: CaseFileTrackingResponseEntity[];
+  metadataChanges: CaseFileMetadataChangeResponseEntity[];
+  /** Registro de accesos. Solo lo recibe el responsable y quien puede ver todos los expedientes. */
+  accesses: CaseFileAccessResponseEntity[];
+  /** Qué puede hacer con el expediente quien lo consulta. Sin `actor` en la consulta, no viene. */
+  actorCapabilities?: {
+    isResponsible: boolean;
+    /** Editar sus metadatos y cerrarlo: el responsable, mientras esté abierto. */
+    canEdit: boolean;
+    /** Incorporar actuaciones: el responsable y aquellos con quienes se compartió, mientras esté abierto. */
+    canIncorporate: boolean;
+    /** Compartirlo con otros funcionarios: el responsable, también después de cerrado. */
+    canShare: boolean;
+  };
+}
+
+export interface CaseFileCreateResponseEntity {
+  id: CaseFileEntity['id'];
+  code: CaseFileEntity['code'];
+  ok: boolean;
+}
+
+export interface CaseFileUpdateResponseEntity {
+  id: CaseFileEntity['id'];
+  ok: boolean;
+}
+
+export interface CaseFileAddEntryResponseEntity {
+  id: CaseFileEntity['id'];
+  entryId: CaseFileEntryEntity['id'];
+  sequence: CaseFileEntryEntity['sequence'];
+  ok: boolean;
+}
+
+/** Archivo de una entrada del índice, para servirlo a quien puede ver el expediente. */
+export interface CaseFileEntryFileResponseEntity {
+  fileId: string;
+  fileName: string;
+}
+
+/** Archivo que va dentro del expediente exportado, con la huella que tenía al incorporarse. */
+export interface CaseFileExportFileEntity {
+  entryId: CaseFileEntryEntity['id'];
+  sequence: CaseFileEntryEntity['sequence'];
+  /** Ruta dentro del ZIP. Ej: `documentos/001-decreto-alcaldicio-exento-590-2026.pdf`. */
+  path: string;
+  fileId: string;
+  sha256: string | null;
+}
+
+/**
+ * Expediente listo para exportar: los metadatos con sus códigos oficiales (va tal cual como `expediente.json`) y los
+ * archivos que hay que agregar. El ZIP lo arma el gateway.
+ */
+export interface CaseFileExportResponseEntity {
+  code: CaseFileEntity['code'];
+  manifest: Record<string, unknown>;
+  files: CaseFileExportFileEntity[];
+}
+
+/** Expediente en que está incorporado un documento, visto desde el documento. */
+export type DocumentCaseFileEntity = CaseFileLinkEntity;

package/src/entities/caseFile/index.ts

@@ -0,0 +1 @@
+export * from './caseFile.entity';

package/src/entities/document/document.entity.ts

@@ -145,6 +145,8 @@ export interface DocumentGetByIdResponseEntity {
   // Documento al que este responde, y los que le responden (solo los ya finalizados, más los propios de quien consulta).
   replyTo: DocumentLinkEntity | null;
   replies: DocumentLinkEntity[];
+  /** Expedientes en que está incorporado y que quien consulta puede ver. */
+  caseFiles: { id: string; code: string; title: string; status: 'Open' | 'Closed' }[];
   documentType: DocumentTypeSummaryEntity;
   participants: DocumentParticipantResponseEntity[];
   attachments: {

package/src/entities/index.ts

@@ -1,2 +1,4 @@
 export * from './documentType';
 export * from './document';
+export * from './procedure';
+export * from './caseFile';

package/src/entities/procedure/index.ts

@@ -0,0 +1 @@
+export * from './procedure.entity';

package/src/entities/procedure/procedure.entity.ts

@@ -0,0 +1,24 @@
+import { ProcedureEntity } from '../../base/entities';
+
+export interface ProcedureGetAllResponseEntity {
+  id: ProcedureEntity['id'];
+  name: ProcedureEntity['name'];
+  cpatId: ProcedureEntity['cpatId'];
+  cpatCode: ProcedureEntity['cpatCode'];
+  description: ProcedureEntity['description'];
+  enabled: ProcedureEntity['enabled'];
+  /** Cuántos expedientes pertenecen a este procedimiento. */
+  caseFiles: number;
+}
+
+export type ProcedureGetByIdResponseEntity = ProcedureGetAllResponseEntity;
+
+export interface ProcedureCreateResponseEntity {
+  id: ProcedureEntity['id'];
+  ok: boolean;
+}
+
+export interface ProcedureUpdateResponseEntity {
+  id: ProcedureEntity['id'];
+  ok: boolean;
+}