# Esquema interfaces
## Vista general de entre Interfaces y Race
```mermaid
sequenceDiagram
Interfaces->>Race: Envío de json encargo
Race->>Interfaces: Id de seguimiento
Race->>DB: Creación de registro Enc_EncargosInterfaces
Race->>Cola: Creación de trabajo de cola
Cola->>Race: Creación de encargo en race
Race->>Interfaces: Webhook creación expediente
````
```mermaid
sequenceDiagram
Race->>ColaWebhook: Cuando algo pasa en race
ColaWebhook->>Listener: Recibe el webhook
Listener->>Race: Llamada a race para enviar el webhook
Race->>Entidad: Webhook
````
## Entrada de una interface
Cuando entra una interface se comprueba el formato y se crea un registro en la tabla encargos_interfaces y al mismo tiempo se encola un trabajo.
```mermaid
classDiagram
EncargosInterfaceController ..> EncargosInterfaceService
EncargosInterfaceService ..> QueueService
EncargosInterfaceController : +ProcesarInterfaceRSI()
EncargosInterfaceController : +ProcesarInterfaceBBVA()
EncargosInterfaceController : +ProcesarDesdeETL()
EncargosInterfaceService : ProcesarEncargoInterface(EncargoInterfaceRequestBase)
QueueService : +EncolarEncargoInterface(EncargoInterfaceRequestBase)
````
## Desencolado de trabajo
Cuando se desencola un trabajo llama a QueueController para intentar procesar el encargo.
En ese momento se valida que la procedencia exista, si no existe se vuelve a encolar 5 min mas tarde, si se sobrepasa un número de intentos se desvía a GES.
Si la procedencia existe se determina que tipo de intefaz es y se usa la que corresponda para crear un encargo.
En el caso de ETL se llama también a noramlización de encargo el cual se encarga de unificar trabajos y bienes por dirección.
```mermaid
classDiagram
QueueController ..> EncargosInterfaceService
QueueController : + EncargoInterfaceBBVA()
QueueController : + EncargoInterfaceRsi()
QueueController : + EncargoInterfaceEtl()
EncargosInterfaceService : ProcesarEncargoInterfaceFromQueue(EncargoInterfaceRequestBase)
EncargosInterfaceService ..> EncargosInterfaceBBVAService
EncargosInterfaceService ..> EncargosInterfaceRSIService
EncargosInterfaceService ..> EncargosInterfaceETLService
EncargosInterfaceETLService ..> InterfaceSivasaService
EncargosInterfaceETLService ..> InterfaceSinfoniaService
EncargosInterfaceETLService ..> EncargoInterfaceNormalizarService
EncargosInterfaceBBVAService : + ProcesarAsync()
EncargosInterfaceRSIService : + ProcesarAsync()
EncargosInterfaceETLService : + ProcesarAsync()
InterfaceSivasaService : AplicarMapeos()
InterfaceSivasaService : AplicarPreMapeos()
InterfaceSinfoniaService : AplicarMapeos()
EncargoInterfaceNormalizarService : Normalizar()
```
## Creación del encargo
Al procesar el encargo y validar la procedencia se determina la interfaz que es la que crea el encargo.
Cuando el service de interfaz correspondiente termina de crear un encargo, se llama a PostEncargocompleto de EncargosService.
```mermaid
classDiagram
EncargosInterfaceService ..> EncargosService
EncargosInterfaceService : ProcesarEncargoInterfaceFromQueue(EncargoInterfaceRequestBase)
```
## Proceso de creación de encargo
```mermaid
graph TD
ProcesarEncargo --> validacion
validacion --> existe{Existen<br>Anteriores<br>Pendientes}
existe -- si --> rep2[/Reprogramado<br>5 min/]
existe -- no --> comprobacion
rep2-->validacion
comprobacion(Comprobación procedencia)
comprobacion -- no --> rep2
comprobacion -- si --> interface{Determinación interface}
interface --> ETL(Sivasa / Sinfonia)
interface --> BBVA
interface --> RSI
```
### Proceso de creación de encargo específico Sivasa/Sinfonia
```mermaid
graph TD
ETL(Sivasa/Sinfonia) --> premapeos(Aplicar premapeos)
premapeos --> prescriptor(Obtener prescriptor)
prescriptor --> anulacion{Comprobar existencia}
anulacion -- existe --> interfaceTipo{Tipo de interfaz}
interfaceTipo -- Sinfonia --> anulableSinfonia
interfaceTipo -- Sivasa --> anulableSivasa
subgraph SinfoniaSinfonia
%% ---- Sinfonia -----
anulableSinfonia --> sinfoniaEncargoAnulable{Encargo anulable?}
sinfoniaEncargoAnulable -- anulable --> anulacionSinfonia(Anulación)
anulacionSinfonia --> creacion(Creación de encargo)
sinfoniaEncargoAnulable -- no anulable --> sinfoniaActualizacion(Marcado como actualización)
end
sinfoniaActualizacion --> normalizacion(Creación encargo)
%% ---- Sivasa -----
subgraph SinfoniaSivasa
anulableSivasa --> anulableSivasaTraspasado{Traspasado?}
anulableSivasaTraspasado -- traspasado --> DesvioGes
anulableSivasaTraspasado -- no traspaasdo --> anulacionSivasa
end
anulacionSivasa --> normalizacion
%% ---- Sinfonia / Sivasa - Creación -----
normalizacion --> creacionSS
creacionSS -- Sinfonia --> sinfoniaEnviarEmail
sinfoniaEnviarEmail --> comprobarGESAnterior(Comprobar encargo anterior en ges)
creacionSS --> comprobarGESAnterior
comprobarGESAnterior --> getEncargo[/Salida encargo/]
```
### Proceso de creación de encargo (resto Interfaces)
```mermaid
graph TD
Interface --> ini[Inicializacion<br>Base]
ini --> compE{Existe<br>anterior?}
compE -- no existe --> creacion
compE -- existe --> baseTraspasado{Traspasado?}
baseTraspasado -- traspasado --> DesvioGes
baseTraspasado -- no traspasado --> baseAnulable{Anulable?}
baseAnulable -- no --> baseActualizacion(Marcado actualizacion)
baseAnulable -- si --> baseAnulacion(Anulación)
baseAnulacion --> creacion
creacion --> comprobarGESAnterior
comprobarGESAnterior --> getEncargo[/Salida encargo/]
```
## Creación de una interfaz nueva
- Primer paso sería tener un json válido generado por interfaces
- Crear un modelo request que represente ese json en Models/Encargos/Commands/EncargosInterface : EncargoInterfaceRequestBase
- Este modelo debe heredar de EncargoInterfaceRequestBase
- Crear un service para crear un encargo
- Crear service en Services/EncargosInterfaces/Interfaces
- La interfaz de este service tiene que heredar de IEncargosInterfaceServiceBase
- Completar los métodos abstractos
- ProcesarAsync estrucutra de procesamiento de encargo
- CompletarEncargo : Completado de todas las secciones del encargo.
- Prescriptor
- Solicintante/Cliente
- Trabajo/Bienes
- Documetacion
- Referencias
- ...