---
# System prepended metadata

title: Esquema interfaces

---

# 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
            - ...
    
    





