@muni-sanfer/types-gestor-documental 0.0.1-beta.0 → 0.0.1-beta.10

package/src/contracts/signatureBatch.contract.ts

@@ -0,0 +1,96 @@
+import { type DocumentAccessLevel } from '../base/entities';
+import {
+  type SignatureBatchCreateResponseEntity,
+  type SignatureBatchGetAllResponseEntity,
+  type SignatureBatchGetByIdResponseEntity,
+  type SignatureBatchRejectResponseEntity,
+  type SignatureBatchSignResponseEntity,
+  type SignatureBatchTab,
+  type SignatureBatchVisaResponseEntity,
+} from '../entities';
+import { type RpcPage } from './contract';
+import { type DocumentActor } from './document.contract';
+
+/** Patrones NATS de `signatureBatch` (lotes de firma): `<servicio>.<recurso>.<acción>`. */
+export const SignatureBatchPatterns = {
+  getAll: 'gestorDocumental.signatureBatch.getAll',
+  getById: 'gestorDocumental.signatureBatch.getById',
+  create: 'gestorDocumental.signatureBatch.create',
+  visa: 'gestorDocumental.signatureBatch.visa',
+  sign: 'gestorDocumental.signatureBatch.sign',
+  reject: 'gestorDocumental.signatureBatch.reject',
+} as const;
+
+/** Datos de quien firma, para el sello de la firma (los resuelve el gateway desde la sesión). */
+export interface SignatureBatchSigner {
+  rut: string;
+  fullName: string;
+  role: string;
+  areaName: string;
+}
+
+export interface SignatureBatchContract {
+  [SignatureBatchPatterns.getAll]: {
+    payload: {
+      pagination?: { page?: number; limit?: number };
+      filters?: { search?: string; tab?: SignatureBatchTab };
+      actor: DocumentActor;
+    };
+    response: RpcPage<SignatureBatchGetAllResponseEntity[]>;
+  };
+  /** Lo ven su redactor y quienes visan o firman sus documentos; con `viewAll`, quien lleva el registro. */
+  [SignatureBatchPatterns.getById]: {
+    payload: { id: string; actor: DocumentActor; viewAll?: boolean };
+    response: SignatureBatchGetByIdResponseEntity;
+  };
+  /**
+   * Crea el lote y lo envía a tramitación: un documento por cada PDF, todos del mismo tipo y con el mismo flujo.
+   * Cada documento recibe su código de verificación y, con su primera firma, su número (si el tipo lo lleva).
+   */
+  [SignatureBatchPatterns.create]: {
+    payload: {
+      name: string;
+      documentTypeId: string;
+      keywords: string[];
+      accessLevel?: DocumentAccessLevel;
+      hasSensitiveData?: boolean;
+      directorateCodeReference?: number | null;
+      departmentId?: string | null;
+      visaEmployeeIds?: string[];
+      // Etapa de cada visador: los de una misma etapa visan a la vez.
+      visaStages?: number[] | null;
+      signatureEmployeeIds: string[];
+      signatureSheet?: boolean;
+      documents: { subject: string; file: { fileId: string; name: string } }[];
+      actor: DocumentActor;
+    };
+    response: SignatureBatchCreateResponseEntity;
+  };
+  /** Visa de una vez los documentos del lote que el funcionario tiene en su turno de visación. */
+  [SignatureBatchPatterns.visa]: {
+    payload: { id: string; observation?: string | null; actor: DocumentActor };
+    response: SignatureBatchVisaResponseEntity;
+  };
+  /**
+   * Firma con un solo OTP los documentos del lote que el funcionario tiene en su turno de firma. FirmaGob admite 5 MB
+   * por solicitud: los que no caben quedan en `remaining`, para firmarlos con un OTP nuevo.
+   */
+  [SignatureBatchPatterns.sign]: {
+    payload: {
+      id: string;
+      observation?: string | null;
+      signer: SignatureBatchSigner;
+      otp?: string;
+      actor: DocumentActor;
+    };
+    response: SignatureBatchSignResponseEntity;
+  };
+  /**
+   * Devuelve a su redactor los documentos del lote que el funcionario tiene en su turno: todos, o los indicados en
+   * `documentIds`. Los demás siguen su curso.
+   */
+  [SignatureBatchPatterns.reject]: {
+    payload: { id: string; observation: string; documentIds?: string[]; actor: DocumentActor };
+    response: SignatureBatchRejectResponseEntity;
+  };
+}

package/src/contracts/workFolder.contract.ts

@@ -0,0 +1,75 @@
+import {
+  type WorkFolderConvertInput,
+  type WorkFolderConvertResponseEntity,
+  type WorkFolderGetAllResponseEntity,
+  type WorkFolderGetByIdResponseEntity,
+  type WorkFolderWriteResponseEntity,
+} from '../entities';
+import { type RpcPage } from './contract';
+import { type DocumentActor } from './document.contract';
+
+/** Patrones NATS de `workFolder` (carpetas de trabajo): `<servicio>.<recurso>.<acción>`. */
+export const WorkFolderPatterns = {
+  getAll: 'gestorDocumental.workFolder.getAll',
+  getById: 'gestorDocumental.workFolder.getById',
+  create: 'gestorDocumental.workFolder.create',
+  update: 'gestorDocumental.workFolder.update',
+  share: 'gestorDocumental.workFolder.share',
+  unshare: 'gestorDocumental.workFolder.unshare',
+  addItem: 'gestorDocumental.workFolder.addItem',
+  removeItem: 'gestorDocumental.workFolder.removeItem',
+  remove: 'gestorDocumental.workFolder.remove',
+  convert: 'gestorDocumental.workFolder.convert',
+} as const;
+
+/** Lo que se agrega a una carpeta: un documento finalizado del gestor o un archivo ya subido. */
+export type WorkFolderItemInput =
+  { kind: 'Document'; documentId: string } | { kind: 'File'; fileId: string; fileName: string; title: string };
+
+type TActor = { actor: DocumentActor };
+
+/**
+ * Carpetas de trabajo: agrupan y comparten documentos y archivos sin procedimiento asociado. Las ven su responsable y
+ * aquellos con quienes la compartió.
+ */
+export interface WorkFolderContract {
+  [WorkFolderPatterns.getAll]: {
+    payload: { pagination?: { page?: number; limit?: number }; filters?: { search?: string } } & TActor;
+    response: RpcPage<WorkFolderGetAllResponseEntity[]>;
+  };
+  [WorkFolderPatterns.getById]: { payload: { id: string } & TActor; response: WorkFolderGetByIdResponseEntity };
+  [WorkFolderPatterns.create]: {
+    payload: { name: string; description?: string | null } & TActor;
+    response: WorkFolderWriteResponseEntity;
+  };
+  [WorkFolderPatterns.update]: {
+    payload: { id: string; name: string; description?: string | null } & TActor;
+    response: WorkFolderWriteResponseEntity;
+  };
+  [WorkFolderPatterns.share]: {
+    payload: { id: string; employeeIds: string[] } & TActor;
+    response: WorkFolderWriteResponseEntity;
+  };
+  [WorkFolderPatterns.unshare]: {
+    payload: { id: string; participantId: string } & TActor;
+    response: WorkFolderWriteResponseEntity;
+  };
+  [WorkFolderPatterns.addItem]: {
+    payload: { id: string; item: WorkFolderItemInput } & TActor;
+    response: WorkFolderWriteResponseEntity;
+  };
+  [WorkFolderPatterns.removeItem]: {
+    payload: { id: string; itemId: string } & TActor;
+    response: WorkFolderWriteResponseEntity;
+  };
+  /** La carpeta deja de verse. Lo que contiene no se toca: los documentos siguen en el gestor. */
+  [WorkFolderPatterns.remove]: { payload: { id: string } & TActor; response: WorkFolderWriteResponseEntity };
+  /**
+   * La convierte en expediente: lo crea con estos metadatos, lo comparte con los mismos funcionarios e incorpora sus
+   * ítems al índice en el orden en que se agregaron. Desde ahí la carpeta queda solo de consulta.
+   */
+  [WorkFolderPatterns.convert]: {
+    payload: { id: string } & WorkFolderConvertInput & TActor;
+    response: WorkFolderConvertResponseEntity;
+  };
+}

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

@@ -0,0 +1,204 @@
+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;
+}
+
+/** Lote incorporado: cuántos documentos entraron y cuántos se omitieron (ya estaban, o no finalizados). */
+export interface CaseFileAddBatchResponseEntity {
+  id: CaseFileEntity['id'];
+  added: number;
+  skipped: number;
+  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';