Introdução
Symfony é um dos frameworks PHP mais utilizados no desenvolvimento de aplicações web robustas e escaláveis. Ele fornece um conjunto robusto de ferramentas e recursos para criar aplicativos complexos, como plataformas de gerenciamento de contratos. Neste artigo, aprenderemos a criar um sistema de gerenciamento de contratos com Symfony, permitindo que gerenciemos contratos e suas condições em um só lugar.
Criando a estrutura básica do projeto
Primeiro, precisamos criar a estrutura básica do projeto Symfony. Podemos fazer isso usando o Composer, o gerenciador de dependências do PHP. No terminal, execute o seguinte comando:
composer create-project symfony/skeleton nome-do-projeto
Isso irá criar uma nova instalação do Symfony na pasta “nome-do-projeto”. Em seguida, podemos navegar para a pasta do nosso projeto e executar o seguinte comando para iniciar um servidor Symfony local:
cd nome-do-projeto
symfony server:start
Isso nos permitirá visualizar o projeto em nosso navegador visitando “http://localhost:8000”.
Criando o banco de dados
Para gerenciar os contratos e suas condições, precisamos criar um banco de dados para armazená-los. Podemos fazer isso usando o ORM (Object-Relational Mapping) do Symfony, o Doctrine. Primeiro, precisamos instalar o pacote Doctrine com o Composer usando o seguinte comando:
composer require symfony/orm-pack
Em seguida, precisamos configurar o banco de dados em nossa aplicação Symfony. Podemos fazer isso editando o arquivo “.env” em nossa pasta de projeto e fornecendo as credenciais de login do banco de dados. Por exemplo:
DATABASE_URL=mysql://user:password@localhost/nome-do-banco
Depois de configurar o banco de dados, podemos criar nosso esquema de banco de dados executando o seguinte comando no terminal:
php bin/console doctrine:schema:create
Isso irá criar todas as tabelas necessárias em nosso banco de dados.
Criando a entidade Contract
Para gerenciar nossos contratos e suas condições em um só lugar, precisamos criar uma entidade Contract que representará um contrato em nosso aplicativo. Para fazer isso, podemos criar um novo arquivo de classe PHP chamado “Contract” dentro da pasta “src/Entity”. Aqui está um exemplo de uma entidade Contract básica:
namespace AppEntity;
use DoctrineORMMapping as ORM;
/**
* @ORMEntity(repositoryClass="AppRepositoryContractRepository")
*/
class Contract
{
/**
* @ORMId()
* @ORMGeneratedValue()
* @ORMColumn(type="integer")
*/
private $id;
/**
* @ORMColumn(type="string", length=255)
*/
private $name;
/**
* @ORMColumn(type="text")
*/
private $description;
/**
* @ORMColumn(type="datetime")
*/
private $startDate;
/**
* @ORMColumn(type="datetime")
*/
private $endDate;
// getters and setters
}
Aqui, estamos simplesmente definindo as propriedades que nosso contrato terá, como nome, descrição, data de início e data de término. Também estamos usando as anotações ORM do Symfony para indicar que essa classe é uma entidade e quais são suas propriedades e tipos. Essas anotações ORM permitirão que o Doctrine mapeie essa entidade para o banco de dados e execute consultas SQL para nós.
Criando a entidade Condition
Além dos contratos, também precisamos gerenciar as condições associadas a cada contrato. Podemos criar uma entidade Condition semelhante para representar cada condição. Aqui está um exemplo de uma entidade Condition básica:
namespace AppEntity;
use DoctrineORMMapping as ORM;
/**
* @ORMEntity(repositoryClass="AppRepositoryConditionRepository")
*/
class Condition
{
/**
* @ORMId()
* @ORMGeneratedValue()
* @ORMColumn(type="integer")
*/
private $id;
/**
* @ORMColumn(type="string", length=255)
*/
private $name;
/**
* @ORMColumn(type="text")
*/
private $description;
/**
* @ORMManyToOne(targetEntity="AppEntityContract", inversedBy="conditions")
* @ORMJoinColumn(nullable=false)
*/
private $contract;
// getters and setters
}
Aqui, estamos definindo as propriedades básicas de uma condição, como nome e descrição. Também estamos usando as anotações ORM para indicar que essa entidade faz parte de um relacionamento de muitos para um com a classe Contract e que cada condição pertence a um contrato específico. Também definimos a propriedade “contract” para ser uma “implementação inversa”, o que significa que essa propriedade é a ponta “inversa” do relacionamento. Isso permitirá que o Doctrine automaticamente relacione as condições com seus contratos correspondentes.
Conclusão
Criar um sistema de gerenciamento de contratos com Symfony é fácil quando usamos o Doctrine para mapear nossas entidades do PHP para tabelas de banco de dados e permitir que o Symfony lide com as camadas controladoras e de visão da aplicação. Com as entidades Contract e Condition que criamos neste exemplo, agora podemos gerenciar facilmente nossos contratos e condições em um só lugar e executar consultas avançadas de banco de dados conforme necessário.