Consumir API usando http

Este contexto se desarrollará utilizando un microservicio llamado “ms-order” y otro llamado “ms-delivery”. El primero expondrá las API’s y el segundo microservicios realizará las peticiones vía HTTP para obtener los detalles de una petición en el “ms-order”.

Preparar el entorno inicial con docker

En este ejemplo se usará MongoDB como base de datos y RabbitMQ como cola en el entorno local de docker. Asegúrese de tener docker en gira con contenedores MongoDB y RabbitMQ activos. Únase al tema RabbitMQ para aprender a crear el intercambio “Devprime” y las colas orderevents y deliveryevents.

Creación de los microservicios “ms-order”

En este microservicio usaremos un ejemplo de un negocio de marketplace ‘order’. A continuación, ejecute la Devprime CLI.

dp new ms-order --state mongodb --stream rabbitmq --marketplace order --init

Al final del primer microservicio, estará listo para producción y con las API construidas por el acelerador Devprime CLI. Ejecución de los microservicios “ms-order”
.\run.ps1 ou ./run.sh (Linux, macOS)

Abra el microservicio del explorador “ms-order” en la dirección URL “https://localhost:5001 o http://localhost:5000” y publíquelo en la API para crear una solicitud.

Creación de los microservicios “ms-delivery”

Ahora crearemos ms-delivery y, a continuación, agregaremos una raíz agregada llamada “Delivery”.
dp new ms-delivery --state mongodb --stream rabbitmq

Vaya a la carpeta ms-delivery y agregue una raíz agregada
dp add aggregate Delivery

Después de ejecutar los comandos, abra el archivo “Delivery.cs” en la carpeta ms-delivery/src/Core/Domain/Aggregates/Delivery y agregue el código a continuación en la raíz agregada “Delivery” para complementar la funcionalidad que necesita nuestra implementación.
code src/Core/Domain/Aggregates/Delivery/Delivery.cs

1
2
3
4
5
6
7
8

namespace Domain.Aggregates.Delivery;
    public class Delivery : AggRoot
    {
       public DateTime Started { get; private set;}
       public DateTime Finished { get; private set;}
       public Guid OrderID { get; private set;}
       public double Total { get; private set;}      
    }

Después de agregar el código, ejecute el acelerador Devprime CLI para compilar las implementaciones básicas del microservicio “ms-delivery”
dp init

Al final, tendrá el microservicio “ms-delivery” listo para que lo usemos. Para cumplir con nuestro escenario, haremos algunas personalizaciones. Al principio, es importante recordar cambiar los puertos del adaptador web en el archivo de configuración ms-delivery/src/App/appsettings.json a 5002 y 5003 para evitar conflictos con el “ms-order” cuando esté de excursión.
code src/App/appsettings.json

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

"Devprime_Web": {
    "url": "https://localhost:5003;http://localhost:5002",
    "enable": "true",
    "enableswagger": "true",
    "PostSuccess": "201",
    "PostFailure": "500",
    "GetSuccess": "200",
    "GetFailure": "500",
    "PatchSuccess": "200",
    "PatchFailure": "500",
    "PutSuccess": "200",
    "PutFailure": "500",
    "DeleteSuccess": "200",
    "DeleteFailure": "500"
},

Después del cambio, puede ejecutar el proyecto y confirmar el cambio del portal desde el registro de Devprime. Es importante exigir la presencia del registro automático proporcionado por el adaptador de observabilidad. Finalice el proyecto y siga los siguientes pasos.

Creación de un DomainEvent y un DTO

Ahora crearemos un evento de dominio ‘DeliveryGetOrder’ y un controlador para implementar la llamada de acceso externo mediante http. La Devprime CLI proporciona un acelerador para agregar eventos de dominio.

Necesitaremos un objeto de transferencia de datos (DTO) para convertir el resultado de la API “ms-order”. El primer paso será crear la carpeta src/Core/Application/EventHandlers/Delivery/Model si no existe y agregar un nuevo archivo “OrderCreated.cs” con el texto a continuación.

Abra el archivo desde Visual Studio Code (vscode).
code src/Core/Application/EventHandlers/Delivery/Model/OrderCreated.cs

Añade el código y guárdalo.

1
2
3
4
5

namespace Application.EventHandlers.Delivery.Model;
    public class OrderCreated: ServicesResult
    {
        public double Total { get; set; }
    }

Ahora que tiene un objeto de transferencia de datos (DTO), vamos a agregar un evento de dominio. Y para facilitar el proceso, usaremos un acelerador Devprime CLI.
dp add domainevent DeliveryGetOrder -agg Delivery

Después de confirmar, abra el archivo “DeliveryGetOrderEventHandler.cs” en la carpeta /src/Core/Application/EventHandlers/Delivery y consulte el servicio externo mediante Adapter Services mediante el comando “Dp.Services.HTTP.DpGet”.

Abra el archivo desde Visual Studio Code (vscode).
code src/Core/Application/EventHandlers/Delivery/DeliveryGetOrderEventHandler.cs

Cambie el código para que evaluemos el retorno “resultado”. En caso de éxito con el código “200” te devolveremos el importe del pedido.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

using Application.EventHandlers.Delivery.Model;
namespace Application.EventHandlers.Delivery;


public class DeliveryGetOrderEventHandler : EventHandler<DeliveryGetOrder,
 IDeliveryState>
{
    public DeliveryGetOrderEventHandler(IDeliveryState state,
     IDp dp) : base(state, dp)
    {
    }

    public override dynamic Handle(DeliveryGetOrder domainEvent)
    {
        // Aggregate Root
        var delivery = domainEvent.Get<Domain.Aggregates.Delivery.Delivery>();

        // External http request using Services Adapter
        var url = $"https://localhost:5001/v1/order/{delivery.OrderID}";

        // Executando o request externo usando http 
        var result = Dp.Services.HTTP.DpGet<OrderCreated>(url);

        // Analisando o resultado da consulta externa
        if (result.Dp.Status.Equals(200)|| result.Dp.Status.Equals(201))
            return result.Total;
        else
            return null;
    }
}

En este ejemplo, el adaptador de servicios accederá a una API basada en DevPrime a través de HTTP y mediante el comando “DpGet” específico de las API basadas en Devprime. Al usar DpGet, ya identifica el resultado y lo convierte al formato “OrderCreated”, lo que simplifica automáticamente el proceso.

Agregar un DomainEvent en Aggretate

El último paso es modificar el método “Add()” presente en la raíz de Aggretate “Delivery”. Agregue la implementación para emitir el evento “DeliveryGetOrder()” que será interceptado por el controlador “DeliveryGetOrderEventHandler” implementado anteriormente.
code src/Core/Domain/Aggregates/Delivery/Delivery.cs

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

public virtual void Add()
{
          Dp.Pipeline(Execute: () =>
          {
            ValidFields();
              ID = Guid.NewGuid();

              var ordertotal = Dp.ProcessEvent(new DeliveryGetOrder());
              if (ordertotal > 0)
              {

                  Total = ordertotal;
                  Dp.ProcessEvent(new DeliveryCreated());
              }
              else
              {
                  throw new PublicException("Can not confirm order");
              }            
          });
}

Si podemos obtener el valor del pedido, actualizaremos el agregado y emitiremos el evento “DeliveryCreated”, propagando el hecho empresarial. Si no es así, emitiremos una PublicException
que devolverá al autor de la llamada de esa API una información de error de proceso.

Demostración del escenario de entrega

Para iniciar la demostración del escenario, debe ejecutar los microservicios “ms-order” y “ms-delivery” al mismo tiempo. Al estar en puertas diferentes, podremos demostrar el escenario con tranquilidad.

microservicios: Pedido

1. Abra el navegador en la API de microservicios “ms-order” en [http://localhost:5000 o https://localhost:5001]
2. Publique en la API ‘/v1/order’ completando el nombre del cliente y el total.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

{
  "customerName": "Bill",
  "customerTaxID": "string",
  "itens": [
    {
      "description": "string",
      "amount": 0,
      "sku": "string",
      "price": 0
    }
  ],
  "total": 1000
}

3. Realice un get en la API ‘/v1/order’ y localice el código de pedido ‘id’

Microservicios: Entrega

1. Abra el navegador en la API de microservicios “ms-order” en [http://localhost:5002 o https://localhost:5003]
2. Publique en la API ‘/v1/delivery’ ingresando el ID del pedido en ‘orderID’.

1
2
3
4
5
6

{
  "started": "2022-03-07T17:54:41.920Z",
  "finished": "2022-03-07T17:54:41.920Z",
  "orderID": "",
  "total": 0
}

3. Los microservicios “ms-delivery” consultarán la API de pedidos mediante servicios de adaptador y devolverán el valor total de la solicitud. El siguiente paso es crear un registro en el microservicio de entrega y emitir un evento en Stream

1
2
3

{
  "success": true
}

También puede realizar un seguimiento de la solicitud “GET” desde el lado del microservicio Order

4. En este nuevo escenario, genere un GUID con un ID de pedido inexistente y publique en la API ‘/v1/delivery’.

1
2
3
4
5
6

{
  "started": "2022-03-07T17:54:41.920Z",
  "finished": "2022-03-07T17:54:41.920Z",
  "orderID": "a316f224-c8fd-4d4d-8495-600f9fea7aaa",
  "total": 0
}

5. Al consultar el microservicio “Pedido” sobre un pedido inexistente, la API de entrega devuelve un error.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

{
  "success": false,
  "error": {
    "type": "Public",
    "trace": "05d359f0-f99a-4f63-8f89-0ac87ac36edd",
    "exceptions": [
      "Can not confirm order"
    ]
  }
}

Enhorabuena 🚀🚀🚀.