Devprime | Documentação – Extensões

Examples: Humanizer

Mon, 01 Jan 0001 00:00:00 +0000

Importante

O exemplo a seguir utiliza a biblioteca Humanizer, mas você pode utilizar a biblioteca que desejar, o foco neste momento é o entendimento de como o Devprime habilita o uso de extensões e como integrá-las em seu projeto sem ferir os princípios de arquitetura estabelecidos, garantindo separação de responsabilidades e desacoplamento.

Criando um microserviço para utilizar no exemplo

Nós utilizaremos um microsserviço baseado na plataforma Devprime

Utilize uma conta ativa no Devprime e ative o Devprime CLI.
Inicie os containers pelo Docker (MongoDB e RabbitMQ)
Crie a fila customerevents no RabbitMQ.

Digite o comando abaixo em um diretório de sua preferência e em seguida abra o projeto no Visual Studio, VSCODE ou sua IDE de preferência:
dp new customer --stream rabbitmq --state mongodb

Acesse a pasta raiz do projeto: .\customer\

Implementações de domínio

Nós precisamos incluir um aggregate root para compor as funcionalidades de negócio do nosso contexto, sendo assim, digite o seguinte comando em seu terminal:
dp add aggregate Customer

O CLI deverá criar a classe Customer.cs onde iremos incluir nossas primeiras regras de negócio. Abra o caminho: code .\src\core\domain\aggregates\customer\Customer.cs e inclua as propriedades conforme exemplo abaixo:

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;
    }
}

Acelerando implementações com o CLI

O próximo passo será utilizar o CLI para acelerar as grande parte das implementações necessárias e para isso digite o comando abaixo em seu terminal:

dp init

O CLI solicita autorização para alterar os arquivos necessários da solution, neste caso vamos digitar A para autorizar todos os arquivos.

Acesse novamente o aggregate root no caminho: code .\src\core\domain\aggregates\customer\Customer.cs e altere o método Add() conforme o exemplo a seguir:

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

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

Ainda no aggregate root altere o método ValidFields() removendo a validação referente ao campo OrdinalCreationDate como mostra o exemplo a seguir:

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();
}

Adicionando uma extension

Nós vamos incluir agora a classe HumanService que será a nossa extension, através do seguinte comando do Devprime CLI.

dp add extensions HumanService

O CLI solicita autorização para alterar os arquivos necessários da solution, tecle A para autorizar todos os arquivos.

A imagem a seguir mostra a classe HumanService e sua Interface IHumanService, cuja responsabilidade será implementar as integrações com a biblioteca Humanizer.

Ela mostra também a classe Extensions e a interface IExtensions cuja finalidade é ser um proxy que permite ao contexto de execução do Devprime Pipeline, acessar todas as extensions disponíveis na aplicação via injeção de dependência.

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:

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

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):

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:

Utilize o Request Body abaixo:

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

Ainda na API utilize o endpoint de GET para obter os customers cadastrados (não necessita passar nenhum parâmetro), o resultado do Response Body deve ser similar ao seguinte:

{
  "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
}

Mais artigos sobre extensions

SendGrid

Examples: SendGrid

Mon, 01 Jan 0001 00:00:00 +0000

Importante

O exemplo a seguir utiliza o SendGrid, mas você pode utilizar a biblioteca que desejar, o foco neste momento é o entendimento de como o Devprime habilita o uso de extensões e como integrá-las em seu projeto sem ferir os princípios de arquitetura estabelecidos, garantindo separação de responsabilidades e desacoplamento.

Criando um microserviço para utilizar no exemplo

Nós utilizaremos um microsserviço baseado na plataforma Devprime

Utilize uma conta ativa no Devprime e ative o Devprime CLI.
Inicie os containers pelo Docker (MongoDB e RabbitMQ)
Crie a fila orderevents no RabbitMQ.

Digite o comando abaixo em um diretório de sua preferência e em seguida abra o projeto no Visual Studio, VSCODE ou sua IDE de preferência:

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

Acesse a pasta raiz do projeto: .\order\

Implementações de domínio

Nós vamos incluir um campo de Email em nosso aggregate root na camada de domínio. Abra a classe Order.cs existente no caminho code .\src\core\domain\aggregates\order\Order.cs, inclua a propriedade como segue destacado abaixo (linha 6) e salve as alterações:

namespace Domain.Aggregates.Order;
public class Order : AggRoot
{
    public string CustomerName { get; private set; }
    public string CustomerTaxID { get; private set; }
    public string Email { get; private set; }
    public IList<Item> Itens { get; private set; }
    public double Total { get; private set; }
    public void AddItem(Item item)
    {
        if (item != null && Itens != null)
        {
            var myItens = Itens.Where(p => p.SKU == item.SKU).FirstOrDefault();
            if (myItens != null)
                myItens.Sum(item.Amount);
            else
                Itens.Add(item);
        }
    }
}

Acelerando implementações com o CLI

O próximo passo será utilizar o CLI para acelerar grande parte das implementações necessárias e para isso digite o comando abaixo em seu terminal:

dp init

O CLI solicita autorização para alterar os arquivos necessários da solution, neste caso vamos digitar A para autorizar todos os arquivos.

Iniciando a configuração do SendGrid

Altere a configuração da chave “Devprime_Custom” conforme exemplo abaixo:
code .\src\app\appsettings.json

"Devprime_Custom": {
    "sendgrid.ssettings.apikey": "API_KEY_SENDGRID",
    "sendgrid.from.email": "YOUR_EMAIL_REGISTERED_AT_SENDGRID",
    "sendgrid.from.name": "YOUR_NAME",
    "stream.orderevents": "orderevents"
}

Adicionando uma extension

Nós vamos incluir agora a classe “MailService” que será a nossa extension, através do seguinte comando do Devprime CLI.

`1`	`dp add extensions MailService`

O CLI solicita outra autorização para alterar os arquivos necessários da solution, tecle A para autorizar todos os arquivos.

A imagem a seguir mostra a classe MailService e sua Interface IMailService, cuja responsabilidade será implementar as integrações com a API do SendGrid.

Ela mostra também a classe Extensions e a interface IExtensions cuja finalidade é ser um proxy que permite ao contexto de execução do Devprime Pipeline, acessar todas as extensions disponíveis na aplicação via injeção de dependência.

Ao rodar o comando para inclusão da extension, note que o CLI gerou também sua injeção na classe “Extensions”: code .\src\adapters\extensions\Extensions.cs

public class Extensions : IExtensions
{
    public Extensions(IMailService mailService)
    {
        MailService = mailService;
    }

    public IMailService MailService { get; }
}

Adicionando a referência para a biblioteca SendGrid

Nós vamos incluir a biblioteca SendGrid 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 SendGrid

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

dotnet build

Implementando a integração com SendGrid

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

1
2
3

bool SendMail(string subject,
              string plainText,
              string htmlMessage);

Nós também precisamos implementar o método na classe “MailService”
code .\src\adapters\extensions\mailservice\MailService.cs, conforme o modelo a seguir:

using SendGrid;
using SendGrid.Helpers.Mail;
using System.Net;

namespace Devprime.Extensions.MailService;
public class MailService : DevprimeExtensions, IMailService
{
    private string ApiKey { get; set; }
    private string FromEmail { get; set; }
    private string FromName { get; set; }

    public MailService(IDpExtensions dp) : base(dp)
    {
        ApiKey = Dp.Settings.Default("sendgrid.ssettings.apikey");
        FromEmail = Dp.Settings.Default("sendgrid.from.email");
        FromName = Dp.Settings.Default("sendgrid.from.name");
    }

    public bool SendMail(string email, string name, string plainText)
    {
        var Client = new SendGridClient(ApiKey);
        var From = new EmailAddress(FromEmail, FromName);
        var Subject = "Thank you to shopping at DpCommerce";
        var To = new EmailAddress(email, name);
        var PlainTextContent = plainText;

        var msg = MailHelper.CreateSingleEmail(From, To,
         Subject, PlainTextContent, null);
        var response = Client.SendEmailAsync(msg).Result;
        if (!response.StatusCode.Equals(HttpStatusCode.OK) &&
         !response.StatusCode.Equals(HttpStatusCode.Accepted))
        {
            Dp.Observability.Log($"[Not possible to send message.
             Details: {response.StatusCode} - 
             {response.Body.ReadAsStringAsync().Result}
             - {response.Headers}]");

            return false;
        }

        return true;
    }
}

Vamos entender melhor alguns recursos existentes no código acima:

Code	Description
Dp.Settings.Default("…")	Obtem chave no AppSettings.json da aplicação
Dp.Observability.Log("…")	Imprime log persoanlizado

Implementado a chamada ao adapter de extension

O nosso cenário envolve um evento de domínio chamado “OrderCreated” e associado a ele temos um EventHandler chamado “OrderCreatedEventHandler”, que possui uma chamada ao Devprime State Adapter para persistência dos dados (linha 11) e emite um evento externo à aplicação (linha 23).
Caminho: code .\src\core\application\eventhandlers\order\OrderCreatedEventHandler.cs

namespace Application.EventHandlers.Order;
public class OrderCreatedEventHandler :
EventHandler<OrderCreated, IOrderState>
{
    public OrderCreatedEventHandler(IOrderState state, IDp dp) :
     base(state, dp) { }

    public override dynamic Handle(OrderCreated orderCreated)
    {
        var success = false;
        var order = orderCreated.Get<Domain.Aggregates.Order.Order>();

        Dp.State.Order.Add(order);

        var destination = Dp.Settings.Default("stream.orderevents");
        var eventName = "OrderCreated";
        var eventData = new OrderCreatedEventDTO()
        {
            ID = order.ID,
            CustomerName = order.CustomerName,
            CustomerTaxID = order.CustomerTaxID,
            Total = order.Total
        };

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

        success = true;
        return success;
    }
}

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

namespace Application.EventHandlers.Order;
public class OrderCreatedEventHandler : 
EventHandlerWithStateAndExtensions<OrderCreated, IOrderState,
IExtensions>
{
    public OrderCreatedEventHandler(IOrderState state,
    IExtensions extension, IDp dp) : base(state, extension, dp) { }

    public override dynamic Handle(OrderCreated orderCreated)
    {
        var success = false;
        var order = orderCreated.Get<Domain.Aggregates.Order.Order>();

        Dp.State.Order.Add(order);

        var destination = Dp.Settings.Default("stream.orderevents");
        var eventName = "OrderCreated";
        var eventData = new OrderCreatedEventDTO()
        {
            ID = order.ID,
            CustomerName = order.CustomerName,
            CustomerTaxID = order.CustomerTaxID,
            Total = order.Total
        };
        Dp.Stream.Send(destination, eventName, eventData);

        success = Dp.Extensions.MailService.SendMail(order.Email,
         order.CustomerName, "Your content here");
        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 uma nova order:

Utilize o Request Body abaixo:

{
  "customerName": "YOUR_NAME",
  "customerTaxID": "12345678910",
  "email": "TYPE_YOU_EMAIL",
  "itens": [
    {
      "description": "TV",
      "amount": 1,
      "sku": "TV001",
      "price": 1000.00
    }
  ]
}

Você deverá receber o e-mail conforme configurado na aplicação.

Mais artigos sobre extensions

Humanizer

Examples: OpenAI

Mon, 01 Jan 0001 00:00:00 +0000

Introdução

A plataforma Devprime acelera a produtividade do desenvolvedor de software, oferecendo um projeto completo de arquitetura de software, componentes com comportamentos inteligentes, aceleradores para implementação de código e atualizações com novos recursos.

Neste artigo, abordaremos a utilização do Adapter de Extensions presente na arquitetura Devprime, que permite adicionar comportamentos adicionais por meio de componentes externos baseados na tecnologia do NuGet. Isso proporciona a possibilidade de expandir as funcionalidades da plataforma Devprime e aderir aos padrões de arquitetura de software, melhorando a manutenibilidade, reuso e testabilidade.

Durante esse artigo utilizaremos o componente nuget Azure.AI.OpenAI que incopora o acesso a API do Microsoft Azure OpenAI e da OpenAI diretamente e você poderá testar utilizando as credenciais de um desses serviços.

Cheklist e preperação do ambiente inicial:

Abra uma conta na plataforma Devprime e adquira uma licença (Developer/Enterprise).
Instale uma versão atualizada do .NET (Linux, macOS e Windows)
Instale e/ou atualize o Visual Studio Code e/ou o Visual Studio 2023 Community / Professional / Enterprise.
Instale e/ou atualize o Docker (Para Windows, utilize o WSL2).
Inicialize os containers do MongoDB e RabbitMQ no Docker e adicione a fila ‘orderevents’ no RabbitMQ.
Instale e ative a versão mais nova do Devprime CLI.
Crie uma pasta para os seus projetos e defina as permissões de leitura e gravação.
Consulte o artigo “Criando o primeiro microsserviço” para explorar os primeiros passos na Devprime.
Crie uma conta no Microsoft Azure OpenAI ou contrate a API da OpenAI e obenha as credenciais de acesso.

Exemplo pronto com todos os passos do artigo

Este artigo inclui um projeto completo que demonstra o recurso discutido. Você pode optar por fazer o download seguindo as etapas abaixo ou simplesmente prosseguir para os próximos itens.

Efetue um clone no repo
git clone https://github.com/devprime/examples.git
Entre na pasta
cd examples/extensions/openai/basic
Atualize a sua licença Devprime
dp stack
Atualize as configurações do MongoDB / RabbitMQ no arquivo src/App/appsettings.json
Atualize as credenciais do Azure OpenAI / OpenAI no arquivo src/App/appsettings.json

Localize em DevPrime_Custom os itens:
ai.url / ai.credential / ai.deploymentmodel /

Execute o microsserviço

Criando um microserviço para utilizar no exemplo

O primeiro passo é criar um novo microsserviço para que possamos realizar customizações no Adapter de Extensions, adicionando o componente externo NuGet e preparando-o para interagir com a API da OpenAI. O nome deste microsserviço será definido como “ms-ai”, conforme demonstrado no comando abaixo.
dp new ms-ai --state mongodb --stream rabbitmq

Após a criação do novo microsserviço entre na pasta do projeto “ms-ai” e já poderá visualizar todas as implementações pelo Visual Studio Code conforme demonstrado no artigo relacionado a criação do primeiro microsserviço.

Adicionando uma regra de negócio

As regras de negócio na arquitetura da plataforma Devprime são baseadas em Domain-Driven Design (DDD), e para avançarmos, é necessário adicionar uma classe Aggregate Root dentro do projeto Domain. Para facilitar esse procedimento, utilizaremos o comando abaixo disponível no Devprime CLI.
dp add aggregate AI

Visualize a nova classe criada pelo Visual Studio Code.
code src/Core/Domain/Aggregates/AI/AI.cs

Modifique a classe AI adicionando uma propriedade chamada “Prompt” conforme exemplo abaixo.

namespace Domain.Aggregates.AI;
public class AI : AggRoot
{
         public string Prompt { get; private set; }
}

Utilizando os aceleradores de código da plataforma Devprime

Agora que você já implementou uma regra de negócio, vamos usar o acelerador do Devprime CLI para gerar o código necessário e iniciar o microsserviço com base na regra de negócio inicial que você forneceu.

Execute o comando a seguir e digite A para avançar nas implementações:

dp init

Após a conclusão deste comando, você já terá as implementações básicas do seu microsserviço e utilizaremos como referência para avançar para o próximo passo, que envolve a incorporação do componente OpenAI no Adapter de Extension.

Adicionando a extension Intelligence

Neste ponto, iniciaremos os procedimentos para habilitar uma extensão de terceiros fornecida como um componente NuGet na plataforma Devprime, seguindo padrões de desenvolvimento que garantem a manutenibilidade e desacoplamento.

Para acelerar esse processo, usaremos o comando abaixo, que implementa a nova extensão no serviço de aplicação por meio de uma interface e injeção de dependência, e construirá a implementação inicial necessária no adaptador.

Execute o comando abaixo:
dp add extensions IntelligenceService

# created
/src/Core/Application/Interfaces/Adapters/Extensions/IIntelligenceService.cs
/src/Adapters/Extensions/IntelligenceService/IntelligenceService.cs
# modified
/src/Core/Application/Interfaces/Adapters/Extensions/IExtensions.cs 
/src/Adapters/Extensions/Extensions.cs 
/src/Adapters/Extensions/GlobalUsings.cs 
/src/App/App.cs
/src/App/GlobalUsings.cs

A classe IntelligenceService e a sua interface IIntelligenceService implementam as integrações com a biblioteca OpenAI. Por outro lado, a classe Extensions e sua interface IExtensions atuam como proxies, permitindo que o contexto de execução do Devprime Pipeline acesse todas as extensões disponíveis na aplicação por meio da injeção de dependência.

Adicionando a referência ao componente da OpenAI

Adicione a referência do componente NuGet Azure.AI.OpenAI ao arquivo de projeto do Adapter de Extensions. Certifique-se de verificar o portal NuGet em busca da versão mais atual e ajuste a versão, se necessário:

Execute o comando abaixo em uma única linha:

1
2

dotnet add src/Adapters/Extensions/DevPrime.Extensions.csproj package 
Azure.AI.OpenAI --version 1.0.0-beta.17

Agora que você acabou de adicionar um novo componente aproveite e efetue um build do microsserviço para se certificar
que está tudo funcionando corretamente com essa nova dependência.

Execute o comando:

`1`	`dotnet build`

Implementando a integração com o componente da OpenAI

Neste momento, vamos implementar a integração com o componente OpenAI dentro do Adapter de Extensions. O primeiro passo é modificar a interface para incluir um método chamado “Conversation” e, em seguida, implementar o código que realiza a chamada à API do OpenAI e retorna o resultado em um formato que pode ser transportado para o contexto de nossa aplicação.

Abra Abra a interface IIntelligenceService no Visual Studio Code.
code src/Core/Application/Interfaces/Adapters/Extensions/IIntelligenceService.cs

Substitua pelo código abaixo:

namespace Application.Interfaces.Adapters.Extensions;
public interface IIntelligenceService
{
     string Conversation(string prompt);
}

Abra Abra a classe IntelligenceService no Visual Studio Code.
code src/Adapters/Extensions/IntelligenceService/IntelligenceService.cs

Substitua pelo código abaixo:

using System.Collections.Generic;
using Azure;
using Azure.AI.OpenAI;

namespace DevPrime.Extensions.IntelligenceService
{
    // Main class implementing the IIntelligenceService interface
    public class IntelligenceService : DevPrimeExtensions, IIntelligenceService
    {
        // Private properties to store credentials and intelligence service configurations
        private string Credential { get; set; }
        private string Url { get; set; }
        private string DeploymentModel { get; set; }
        private string Platform { get; set; }


        // Constructor initializing properties based on DpExtensions settings
        public IntelligenceService(IDpExtensions dp) : base(dp)
        {
            Credential = Dp.Settings.Default("ai.credential");
            Url = Dp.Settings.Default("ai.url");
            DeploymentModel = Dp.Settings.Default("ai.deploymentmodel");
            Platform = ValidatePlatformSetting(Dp.Settings.Default("ai.platform") ?? "azure");
        }

        // Method to start a conversation with the AI service
        public string Conversation(string prompt)
        {
            // Using DpExtensions pipeline to execute conversation logic
            return Dp.Pipeline(ExecuteResult: () =>
            {
                // Log to indicate the start of interaction with OpenAI service
                Dp.Observability.Log("Starting OpenAI");

                // Settings for interacting with OpenAI service
                var chatCompletionsOptions = new ChatCompletionsOptions()
                {

                    Temperature = (float)0.7,
                    MaxTokens = 800,
                    NucleusSamplingFactor = (float)0.95,
                    FrequencyPenalty = 0,
                    PresencePenalty = 0,
                    DeploymentName = DeploymentModel
                };

                // Creating OpenAI client with provided credentials
                
                var openAiClient = Platform == "azure" ?
                new OpenAIClient(new System.Uri(Url), new AzureKeyCredential(Credential)) :
                new OpenAIClient(Credential);


                Dp.Observability.Log($"Starting OpenAI using platform {Platform}");

                // Adding user's message to the conversation
                // ChatRequestSystemMessage / ChatRequestUserMessage / ChatRequestAssistantMessage  
                chatCompletionsOptions.Messages.Add(new ChatRequestUserMessage(prompt));

                // Preparation for interaction with OpenAI service
                Response<ChatCompletions> response = openAiClient.GetChatCompletions(chatCompletionsOptions);

                // Processing OpenAI response
                var airesponse = response.GetRawResponse().Content.ToString();
                var root = System.Text.Json.JsonSerializer.Deserialize<Root>(airesponse);
                Message message = root.choices[0].message;
                var airesult = message.content;

                // Log to indicate the end of interaction with OpenAI service
                Dp.Observability.Log("Finalizing OpenAI");

                // Returning OpenAI response
                return airesult;
            });
        }

        // Definition of inner classes to structure OpenAI response
        public class ContentFilterResults
        {
            public bool filtered { get; set; }
            public string severity { get; set; }
        }

        public class PromptFilterResults
        {
            public int prompt_index { get; set; }
            public ContentFilterResults content_filter_results { get; set; }
        }

        public class Message
        {
            public string role { get; set; }
            public string content { get; set; }
            public ContentFilterResults content_filter_results { get; set; }
        }

        public class Choice
        {
            public int index { get; set; }
            public string finish_reason { get; set; }
            public Message message { get; set; }
            public ContentFilterResults content_filter_results { get; set; }
        }

        public class Usage
        {
            public int prompt_tokens { get; set; }
            public int completion_tokens { get; set; }
            public int total_tokens { get; set; }
        }

        public class Root
        {
            public string id { get; set; }
            public string _object { get; set; }
            public int created { get; set; }
            public string model { get; set; }
            public List<PromptFilterResults> prompt_filter_results { get; set; }
            public List<Choice> choices { get; set; }
            public Usage usage { get; set; }
        }

        private string ValidatePlatformSetting(string setting)
        {
            Dp.Observability.Log($"[Extensions]ValidatePlatformSetting:{setting}");
            var platform = setting.ToLower();
            if (platform != "azure" && platform != "openai")
            {
                Dp.Observability.Log($"[Extensions]ERROR: Platform must be either 'azure' or 'openai'.");
                throw new System.Exception("Platform must be either 'azure' or 'openai'.");
            }
            return platform;
        }
    }
}

Adicionando váriaveis de ambiente para uso no OpenAI

Na implementação anterior nós utilizamos o comando Dp.Settings.Default("ai.credential") para obter o parametro de uma variavel de ambiente definida no projeto local no arquivo “src/App/appsettings.json”. Abra o bloco “DevPrime_Custom” seguindo exemplo abaixo adicionando a URL do servíco de OpenAI, a credencial e o modelo de deployment e por últimos nós devemos informar no item “ai.platform” o valor openai ou azure.

Abra e edite pelo Visual Studio Code
code src/App/appsettings.json

  "DevPrime_Custom": {
    "stream.processevents": "aievents",
    "ai.url": "put azure url or openai",
    "ai.credential": "put azure key or openai",
    "ai.deploymentmodel": "put deployment name",
    "ai.platform": "change to openai or azure"
  }

Implementado a chamada ao adapter de extension

O primeiro ponto de contato com a nova funcionalidade disponibilizada pela nova Extension do OpenAI é o Handler que nesse contexto utilizaremos o CreateAIEventHandler que tem o papel de interceptar um evento de dominio e mediar a integração com os recursos tecnologicos da plataforma. Para que tenha suporte ao Extensions nós adicionamos a herança para a classe EventHandlerWithExtensions além de adicionarmos a interface IExtensions.

É importante observar que após as implementações anteriores agora nós temos a dispoção dentro da arquitetura Devprime um novo metodo Dp.Extensions.IntelligenceService.Conversation() que executa o código externo incoporado dentro do Adapter de Extensions.

Essa nova implementação executará a chamada ao OpenAI e retornará o resultado. Para avançar abra o arquivo e substitua todo o código.

Abra o Handler pelo Visual Studio Code.
code src/Core/Application/EventHandlers/AI/CreateAIEventHandler.cs

namespace Application.EventHandlers.AI;
public class CreateAIEventHandler : 
EventHandlerWithExtensions<CreateAI, IExtensions>
{
    public CreateAIEventHandler(IExtensions extensions, IDp dp) : 
    base(extensions, dp)
    {
    }
    public override dynamic Handle(CreateAI createAI)
    {
        var ai = createAI.Get<Domain.Aggregates.AI.AI>();
        var result = Dp.Extensions.IntelligenceService.Conversation(ai.Prompt);
        return result;
    }
}

Em função dessa modificação no Handler remova o arquivo de testes que não é utilizado nesse exemplo
utilizando o comando abaixo:

Removendo arquivo
rm src/Tests/Core/Application/AI/CreateAIEventHandlerTest.cs

Modificando o método ADD no Aggregate Root

Agora retornaremos à regra de negócio no Aggregate Root para realizar uma customização no método “ADD”, substituindo-o pelo código abaixo para permitir a execução do evento de domínio “CreateAI” e obter esse retorno. Esse evento será processado no Handler “CreateAIEventHandler” responsável pela interação com o Adapter de Extensions."

Abra a classe Aggregate Root no Visual Studio Code
code src/Core/domain/aggregates/AI/AI.cs

public virtual string Add()
 {
    var result = Dp.Pipeline(ExecuteResult: () =>
    {
        ValidFields();
        ID = Guid.NewGuid();
        IsNew = true;
        var processresult = Dp.ProcessEvent<string>(new CreateAI());
        return processresult;
    });
        return result;
    }

Modificando a Interface e Application Services

Devido à implementação no Adapter de Extension, é necessário obter o retorno do Aggregate Root no Application Services. O primeiro passo é modificar a interface IAIService conforme o exemplo abaixo.

Abra a Interface no Vsiual Studio Code
code src\Core\Application\Interfaces\Services\IAIService.cs

namespace Application.Interfaces.Services;
public interface IAIService
{
    string Add(Application.Services.AI.Model.AI command);
    void Update(Application.Services.AI.Model.AI command);
    void Delete(Application.Services.AI.Model.AI command);
    Application.Services.AI.Model.AI 
    Get(Application.Services.AI.Model.AI query);
    PagingResult<IList<Application.Services.AI.Model.AI>>
    GetAll(Application.Services.AI.Model.AI query);
}

Após a modificação da interface no passo anterior, é hora de refletir essa alteração no Application Services. Localize o método Add abaixo e faça a substituição para que o serviço de aplicação retorne o resultado do nosso Aggregate Root.

Abra o Application Services no Visual Studio Code.
code src\Core\Application\Services\AI\AIService.cs

    public string Add(Model.AI command)
    {
      return Dp.Pipeline(ExecuteResult: () =>
        {
            var process = command.ToDomain();
            Dp.Attach(process);
            var processresult = process.Add();
            return processresult;
        });
    }

Explorando o microsserviço integrado com o OpenAI

Ao final dessa implementação nós já podemos realizar os testes executando o microsserviço customizando com a integração do OpenAI.

Inicie o microsserviço executando um dos scripts abaixo:

`1`	`.\run.ps1 (Windows) or ./run.sh (Linux, macOS)`

Acesse o portal do swagger do microsserviço

Efetue um post na API pelo Swagger preenchendo o prompt

{
  "prompt": "Explain how the Devprime platform enhances developer productivity
   in one sentence?"
}

e confira o resultado no json abaixo:

{
  "response": "The Devprime platform streamlines development workflows
   and automates repetitive tasks,   allowing developers to focus on
   writing high-quality code and delivering projects faster.",
  "success": true
}

Acompanhe o exemplo de registro de log gerado automaticamente pelo Adapter de Observability, que detalha todo o fluxo interno, desde o recebimento do POST até a integração com o OpenAI no Adapter de Extensions.

[App]["Powered by DevPrime"][Version]["7.0.59"][License]["Developer"]
[App]["Start"]["ms-ai"][Configuration]["Appsettings"][AppVersion]["1.0.0.0"]
[App][Idempotency]["Disable"][RID 3b8cdd1a-48cc-44ea-9d4d-af36db35e4e4]
[State][Type "MongoDB"][Alias "State1"]["Database"]["Enable"]
[App][Tenancy]["Disable"]
[App][Observability]["Enable"][Log "Enable"][Export "Enable"][Type "seq"]
[Trace "Disable"][Metrics "Disable"]
[Security]["Disable"]
[Web]["https://localhost:5001"]["http://localhost:5000"][Host]["Production"]
[Parameters]["Appsettings"]
[Stream][Type "RabbitMQ"][Alias "Stream1"]["Enable"]
[Web]["HTTP"][AI][POST /v1/ai]
[Origin "https://localhost:5001/swagger/index.html"]
[Application][AIService][Add][RID aa13bca3-76f3-4b51-b35e-c05e24e0cad3]
[Domain][AI][Add]
[Domain][AI][ProcessEvent]["CreateAI"]
[Application][EventHandler]["CreateAIEventHandler"][Event]["CreateAI"]
[Extensions][IntelligenceService][Conversation]
[Custom][Starting OpenAI]
[Custom][Finalizing OpenAI]

Mais artigos sobre extesions na plataforma Devprime

Utilizando o SendGrid em microsserviços
Utilizando o Humanizer em microsserviços