Criando um sistema de suporte ao cliente com Symfony: gerenciando e triando informações de contato
Um sistema de suporte ao cliente é fundamental para qualquer negócio que queira manter um bom relacionamento com seus clientes. No entanto, gerenciar todas as informações de contato pode ser uma tarefa difícil e demorada. Neste artigo, demonstraremos como é possível criar um sistema de suporte ao cliente com Symfony, utilizando a biblioteca de gerenciamento de filas RabbitMQ para triagem de informações de contato.
O que é RabbitMQ e por que utilizá-lo?
RabbitMQ é um sistema de mensagens open source que utiliza o protocolo AMQP (Advanced Message Queuing Protocol) para troca de mensagens assíncronas entre diferentes sistemas. É uma excelente opção para situações em que múltiplas aplicações precisam se comunicar de forma eficiente e confiável.
Neste caso, utilizaremos a biblioteca `enqueue/amqp-lib` para integração com o RabbitMQ.
Criando a estrutura do projeto Symfony
Para começar, será necessário criar a estrutura do projeto Symfony. Você pode utilizar o comando composer create-project symfony/skeleton my_project_name para criar um projeto básico.
Em seguida, vamos adicionar os seguintes pacotes ao arquivo `composer.json`:
"enqueue/amqp-lib": "^0.10.13",
"enqueue/amqp-ext": "^0.10.13",
"enqueue/enqueue-bundle": "^0.9.6"
Em seguida, execute o comando `composer install` para instalar as dependências.
Configurando o RabbitMQ
Para configurar o RabbitMQ, adicione as seguintes linhas ao arquivo `.env`:
ENQUEUE_DSN=amqp://user:password@rabbitmq:5672/%2f
Altere o valor `user` e `password` para o nome de usuário e senha do RabbitMQ, respectivamente.
Em seguida, crie um novo arquivo `config/packages/enqueue.yaml` e adicione as seguintes configurações:
enqueue:
default:
transport: '%env(ENQUEUE_DSN)%'
client: ~
transport:
'%env(ENQUEUE_DSN)%': ~
Com isso, a biblioteca de gerenciamento de filas RabbitMQ estará configurada para o projeto.
Criando um serviço para gerenciamento de mensagens
Para gerenciar as mensagens, vamos criar um serviço que será responsável por ler as informações de contato e enviá-las para a fila de triagem.
Primeiramente, crie um novo arquivo `src/Service/ContactManager.php`. Neste arquivo, adicione a seguinte classe:
namespace AppService;
use EnqueueAmqpLibAmqpConnectionFactory;
use InteropAmqpAmqpMessage;
use InteropAmqpAmqpQueue;
use InteropQueueContext;
use InteropQueueMessage;
class ContactManager
{
/**
* @var Context
*/
private $context;
/**
* ContactManager constructor.
* @param string $dsn
*/
public function __construct(string $dsn)
{
$factory = new AmqpConnectionFactory($dsn);
$this->context = $factory->createContext();
}
/**
* @param string $name
* @param string $email
* @param string $message
* @return bool
*/
public function send(string $name, string $email, string $message): bool
{
$data = [
'name' => $name,
'email' => $email,
'message' => $message
];
$message = new AmqpMessage(json_encode($data));
$queue = new AmqpQueue('contact');
$this->context->declareQueue($queue);
$this->context->createProducer()->send($queue, $message);
return true;
}
}
Esta classe recebe como parâmetro a configuração do RabbitMQ e possui um método `send` que recebe as informações de contato e envia para a fila `contact`.
Em seguida, vamos criar um serviço para esta classe. Adicione a seguinte configuração ao arquivo `config/services.yaml`:
services:
AppServiceContactManager:
arguments:
$dsn: '%env(ENQUEUE_DSN)%'
Criando um Consumer para triagem de mensagens
Para a triagem das mensagens, é necessário criar um Consumer. Este Consumer irá consumir as mensagens da fila `contact` e armazenar as informações no banco de dados.
Crie um novo arquivo `src/Messenger/ContactConsumer.php` e adicione a seguinte classe:
namespace AppMessenger;
use DoctrineORMEntityManagerInterface;
use SymfonyComponentMessengerHandlerMessageHandlerInterface;
class ContactConsumer implements MessageHandlerInterface
{
/**
* @var EntityManagerInterface
*/
private $entityManager;
/**
* ContactConsumer constructor.
* @param EntityManagerInterface $entityManager
*/
public function __construct(EntityManagerInterface $entityManager)
{
$this->entityManager = $entityManager;
}
/**
* @param array $data
*/
public function __invoke(array $data)
{
// Armazenar as informações da mensagem no banco de dados
}
}
Esta classe recebe como parâmetro o EntityManager do Doctrine, que será utilizado para armazenar as informações no banco de dados.
Em seguida, vamos criar um serviço para este Consumer. Adicione a seguinte configuração ao arquivo `config/services.yaml`:
services:
AppMessengerContactConsumer:
tags:
- { name: 'messenger.message_handler' }
arguments:
$entityManager: '@doctrine.orm.default_entity_manager'
Com esta configuração, o Symfony saberá que esta classe é um Consumer e irá ler as mensagens da fila `contact`, executando o método `__invoke` para cada mensagem recebida.
Criando a rota para o formulário de contato
Por fim, vamos criar a rota para o formulário de contato, que irá utilizar o serviço `ContactManager` para enviar as informações para a fila `contact`.
Adicione a seguinte rota ao arquivo `config/routes.yaml`:
contact:
path: '/contact'
methods: [GET, POST]
controller: AppControllerContactController::index
Em seguida, crie o arquivo `src/Controller/ContactController.php` e adicione a seguinte classe:
namespace AppController;
use AppServiceContactManager;
use SymfonyBundleFrameworkBundleControllerAbstractController;
use SymfonyComponentHttpFoundationRequest;
use SymfonyComponentHttpFoundationResponse;
class ContactController extends AbstractController
{
/**
* @param Request $request
* @param ContactManager $contactManager
* @return Response
*/
public function index(Request $request, ContactManager $contactManager): Response
{
if ($request->isMethod('POST')) {
$contactManager->send(
$request->request->get('name'),
$request->request->get('email'),
$request->request->get('message')
);
}
return $this->render('contact/index.html.twig');
}
}
Este Controller recebe como parâmetro o serviço `ContactManager` e envia as informações para a fila quando o formulário for submetido.
Conclusão
Com estas configurações, será possível criar um sistema de suporte ao cliente com Symfony de forma eficiente e escalável, utilizando o RabbitMQ para gerenciar as mensagens e o Symfony Messenger para triagem e armazenamento das informações.