Humanizador

En este tutorial crearemos un microservicio de cliente y usaremos la biblioteca Humanizer para registrar la fecha de registro y también definiremos un campo de cadena con la fecha en formato ordinal.

Importante

En el siguiente ejemplo se utiliza la biblioteca Humanizer, pero puedes utilizar cualquier biblioteca que desees, el enfoque en este punto está en comprender cómo Devprime permite el uso de extensiones y cómo integrarlas en tu proyecto sin dañar los principios de arquitectura establecidos, asegurando la separación de responsabilidades y el desacoplamiento.

Creación de un microservicio para usar en el ejemplo

Utilizaremos un microservicio basado en la plataforma Devprime

Escriba el siguiente comando en un directorio de su elección y, a continuación, abra el proyecto en Visual Studio, VSCODE o el IDE que prefiera:
dp new customer --stream rabbitmq --state mongodb

Vaya a la carpeta raíz del proyecto: .\customer\

Implementaciones de dominio

Necesitamos incluir un aggregate root para componer las características comerciales de nuestro contexto, así que escriba el siguiente comando en su terminal:
dp add aggregate Customer

La CLI debe crear la clase Customer.cs donde incluiremos nuestras primeras reglas de negocio. Abra la ruta: code .\src\core\domain\aggregates\customer\Customer.cs e incluya las propiedades como se muestra en el ejemplo siguiente:

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

namespace Domain.Aggregates.Customer;
public class Customer : AggRoot
{
    public string FullName { get; private set; }
    public string CustomerTaxID { get; private set; }
    public string Address { get; private set; }
    public string Phone { get; private set; }
    public string Email { get; private set; }
    public DateTime CreationDate { get; private set; }
    public string OrdinalCreationDate { get; private set; }

    public void SetOrdinalDate(string ordinalCreationDate)
    {
        OrdinalCreationDate = ordinalCreationDate;
    }
}

Aceleración de las implementaciones con la CLI

El siguiente paso será usar la CLI para acelerar la mayoría de las implementaciones necesarias y para eso escriba el siguiente comando en su terminal:

dp init

La CLI solicita autorización para cambiar los archivos necesarios de la solución, en este caso escribiremos A para autorizar todos los archivos.

Vuelva a acceder a aggregate root en la ruta: code .\src\core\domain\aggregates\customer\Customer.cs y cambie el método Add() como en el siguiente ejemplo:

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

public virtual void Add()
{
    Dp.Pipeline(Execute: () =>
    {
        ID = Guid.NewGuid();
        IsNew = true;
        CreationDate = DateTime.UtcNow;

        ValidFields();
        Dp.ProcessEvent(new CustomerCreated());
    });
}

Todavía en aggregate root, cambie el método ValidFields() eliminando la validación del campo OrdinalCreationDate como se muestra en el siguiente ejemplo:

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

private void ValidFields()
{
    if (String.IsNullOrWhiteSpace(FullName))
        Dp.Notifications.Add("FullName is required");
    if (String.IsNullOrWhiteSpace(CustomerTaxID))
        Dp.Notifications.Add("CustomerTaxID is required");
    if (String.IsNullOrWhiteSpace(Address))
        Dp.Notifications.Add("Address is required");
    if (String.IsNullOrWhiteSpace(Phone))
        Dp.Notifications.Add("Phone is required");
    if (String.IsNullOrWhiteSpace(Email))
        Dp.Notifications.Add("Email is required");
    if (CreationDate == DateTime.MinValue)
        Dp.Notifications.Add("CreationDate is required");

    Dp.Notifications.ValidateAndThrow();
}

Agregar una extensión

Ahora incluiremos la clase HumanService que será nuestra extensión, a través del siguiente comando de la CLI de Devprime.

dp add extensions HumanService

La CLI solicita autorización para cambiar los archivos necesarios de la solución, presione A para autorizar todos los archivos.

En la siguiente imagen se muestra la clase HumanService y su Interfaz IHumanService, que se encargará de implementar las integraciones con la librería Humanizer.

También muestra la clase Extensions y la interfaz IExtensions cuyo propósito es ser un proxy que permita al contexto de ejecución de Devprime Pipeline acceder a todas las extensiones disponibles en la aplicación a través de la inyección de dependencias.

Clave de extensiones de Devprime `

Adicionando a referência para a biblioteca Humanizer

Nós vamos incluir a biblioteca Humanizer em nosso projeto, lembre-se de definir o destino de instalação para o projeto “Devprime.Extensions”. code .\src\adapters\extensions\Devprime.Extensions.csproj

Via dotnet CLI

dotnet add .\src\adapters\extensions\Devprime.Extensions.csproj package Humanizer

Rode também o dotnet build no projeto. (Lembre-se de estar na pasta raíz do projeto .\customer\):

dotnet build

Implementando a integração com a biblioteca Humanizer

Nós vamos alterar a interface “IHumanService” existente no caminho code .\src\core\application\interfaces\adapters\extensions\IHumanService.cs, incluindo a assinatura de método a seguir:

1

string ToOrdinalWords(DateTime date);

Nós também precisamos implementar o método na classe “HumanService” code .\src\adapters\extensions\humanservice\HumanService.cs, deixando-a conforme segue:

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

using Humanizer;
using System;
namespace Devprime.Extensions.HumanService;
public class HumanService : DevprimeExtensions, IHumanService
{
    public HumanService(IDpExtensions dp) : base(dp)
    {
    }

    public string ToOrdinalWords(DateTime date)
    {
        return Dp.Pipeline(ExecuteResult: () =>
        {
            var result = date.ToOrdinalWords();
            return result;
        });
    }
}

Implementado a chamada ao adapter de extension

O nosso cenário envolve um evento de domínio chamado “CustomerCreated” e associado a ele temos um EventHandler chamado “CustomerCreatedEventHandler”, que possui uma chamada ao Devprime State Adapter para persistência dos dados (linha 11) e emite um evento externo à aplicação (linha 26).
Caminho: code .\src\Core\Application\EventHandlers\Customer\CustomerCreatedEventHandler.cs

 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
31

namespace Application.EventHandlers.Customer;
public class CustomerCreatedEventHandler : EventHandler<CustomerCreated, ICustomerState>
{
    public CustomerCreatedEventHandler(ICustomerState state, IDp dp) : base(state, dp){}

    public override dynamic Handle(CustomerCreated customerCreated)
    {
        var success = false;
        var customer = customerCreated.Get<Domain.Aggregates.Customer.Customer>();
        
        Dp.State.Customer.Add(customer);

        var destination = Dp.Settings.Default("stream.customerevents");
        var eventName = "CustomerCreated";
        var eventData = new CustomerCreatedEventDTO()
        {
            ID = customer.ID,
            FullName = customer.FullName,
            CustomerTaxID = customer.CustomerTaxID,
            Address = customer.Address,
            Phone = customer.Phone,
            Email = customer.Email,
            CreationDate = customer.CreationDate,
            OrdinalCreationDate = customer.OrdinalCreationDate
        };
        Dp.Stream.Send(destination, eventName, eventData);

        success = true;
        return success;
    }
}

Altere o código do nosso EventHandler conforme modelo abaixo (vide linhas destacadas):

 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
31
32
33
34
35

namespace Application.EventHandlers.Customer;
public class CustomerCreatedEventHandler : EventHandlerWithStateAndExtensions<CustomerCreated, ICustomerState, IExtensions>
{
    public CustomerCreatedEventHandler(ICustomerState state, IExtensions extension, IDp dp) : base(state, extension, dp) { }

    public override dynamic Handle(CustomerCreated customerCreated)
    {
        var success = false;
        var customer = customerCreated.Get<Domain.Aggregates.Customer.Customer>();

        var ordinalCreationDate = Dp.Extensions.HumanService.ToOrdinalWords(customer.CreationDate);
        customer.SetOrdinalDate(ordinalCreationDate);

        Dp.State.Customer.Add(customer);

        var destination = Dp.Settings.Default("stream.customerevents");
        var eventName = "CustomerCreated";
        var eventData = new CustomerCreatedEventDTO()
        {
            ID = customer.ID,
            FullName = customer.FullName,
            CustomerTaxID = customer.CustomerTaxID,
            Address = customer.Address,
            Phone = customer.Phone,
            Email = customer.Email,
            CreationDate = customer.CreationDate,
            OrdinalCreationDate = customer.OrdinalCreationDate
        };

        Dp.Stream.Send(destination, eventName, eventData);

        success = true;
        return success;
    }
}

Testando a aplicação

Agora que temos as implementações necessárias, vamos rodar o microsserviço através do comando abaixo:

Windows

.\run.ps1

Linux / Mac

.\run.sh

No browser, acesse o link: https://localhost:5001/swagger, nós vamos utilizar o método POST para criar um novo customer:

Devprime How To Extensions Key`

Utilice el cuerpo de la solicitud a continuación:

1
2
3
4
5
6
7

{
  "fullName": "Bot One",
  "customerTaxID": "37429734",
  "address": "Av. Paulista, 1811",
  "phone": "11999999999",
  "email": "botone@bot.com"
}

Todavía en la API use el punto de conexión GET para obtener los clientes registrados (no es necesario pasar ningún parámetro), el resultado de Response Body debe ser similar al siguiente:

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

{
  "response": [
    {
      "id": "997809ad-e48f-4eb4-9145-4b569adba492",
      "fullName": "Bot One",
      "customerTaxID": "37429734",
      "address": "Av. Paulista, 1811",
      "phone": "11999999999",
      "email": "botone@bot.com",
      "creationDate": "2022-04-05T03:28:47.16Z",
      "ordinalCreationDate": "April 5th, 2022" //Humanized by our extension
    }
  ],
  "total": 1,
  "pageTotal": 1,
  "hasNext": false,
  "hasPrevious": false,
  "success": true
}

Más artículos sobre extensiones

SendGrid

Última modificación April 16, 2024 (2b35fcc8)