Introdução
Criar um sistema de gerenciamento de contratações pode ser uma tarefa complexa, porém, com o Symfony, é possível criar um gerenciador de vagas e candidaturas de processo seletivo em um único lugar.
Criando o banco de dados
Antes de começar a criar o gerenciador, será necessário criar o banco de dados para armazenar as informações das vagas e candidaturas. Para isso, utilize o Doctrine, que é um ORM (Mapeamento Objeto-Relacional) que acompanha o Symfony e permite criar e gerenciar o banco de dados com facilidade.
Criando as entidades
As entidades são classes que representam as tabelas do banco de dados. No caso do gerenciador de vagas e candidaturas, serão necessárias duas entidades: Vaga e Candidato. A entidade Vaga terá atributos como título, descrição, requisitos e data de expiração. Já a entidade Candidato terá atributos como nome, email, telefone e currículo.
namespace AppEntity;
use DoctrineORMMapping as ORM;
/**
* @ORMEntity(repositoryClass="AppRepositoryVagaRepository")
*/
class Vaga
{
/**
* @ORMId()
* @ORMGeneratedValue()
* @ORMColumn(type="integer")
*/
private $id;
/**
* @ORMColumn(type="string", length=255)
*/
private $titulo;
/**
* @ORMColumn(type="text")
*/
private $descricao;
/**
* @ORMColumn(type="text")
*/
private $requisitos;
/**
* @ORMColumn(type="datetime")
*/
private $dataExpiracao;
//getters e setters
}
namespace AppEntity;
use DoctrineORMMapping as ORM;
/**
* @ORMEntity(repositoryClass="AppRepositoryCandidatoRepository")
*/
class Candidato
{
/**
* @ORMId()
* @ORMGeneratedValue()
* @ORMColumn(type="integer")
*/
private $id;
/**
* @ORMColumn(type="string", length=255)
*/
private $nome;
/**
* @ORMColumn(type="string", length=255)
*/
private $email;
/**
* @ORMColumn(type="string", length=255)
*/
private $telefone;
/**
* @ORMColumn(type="text")
*/
private $curriculo;
//getters e setters
}
Criando os formulários
Os formulários são as interfaces que permitem o usuário criar uma vaga ou candidatura. Para criá-los, será necessário utilizar o componente Form do Symfony.
namespace AppForm;
use AppEntityVaga;
use SymfonyComponentFormAbstractType;
use SymfonyComponentFormFormBuilderInterface;
use SymfonyComponentOptionsResolverOptionsResolver;
class VagaType extends AbstractType
{
public function buildForm(FormBuilderInterface $builder, array $options)
{
$builder
->add('titulo')
->add('descricao')
->add('requisitos')
->add('dataExpiracao')
;
}
public function configureOptions(OptionsResolver $resolver)
{
$resolver->setDefaults([
'data_class' => Vaga::class,
]);
}
}
namespace AppForm;
use AppEntityCandidato;
use SymfonyComponentFormAbstractType;
use SymfonyComponentFormFormBuilderInterface;
use SymfonyComponentOptionsResolverOptionsResolver;
class CandidatoType extends AbstractType
{
public function buildForm(FormBuilderInterface $builder, array $options)
{
$builder
->add('nome')
->add('email')
->add('telefone')
->add('curriculo')
;
}
public function configureOptions(OptionsResolver $resolver)
{
$resolver->setDefaults([
'data_class' => Candidato::class,
]);
}
}
Criando os controladores
Os controladores são as classes responsáveis por gerenciar as requisições feitas pelo usuário. No Symfony, utiliza-se o padrão MVC (Model-View-Controller), onde o controlador fica responsável por receber a requisição, manipular os dados e devolver a resposta.
namespace AppController;
use AppEntityVaga;
use AppFormVagaType;
use AppRepositoryVagaRepository;
use SymfonyBundleFrameworkBundleControllerAbstractController;
use SymfonyComponentHttpFoundationRequest;
use SymfonyComponentHttpFoundationResponse;
use SymfonyComponentRoutingAnnotationRoute;
/**
* @Route("/vaga")
*/
class VagaController extends AbstractController
{
/**
* @Route("/", name="vaga_index", methods={"GET"})
*/
public function index(VagaRepository $vagaRepository): Response
{
$vagas = $vagaRepository->findAll();
return $this->render('vaga/index.html.twig', [
'vagas' => $vagas,
]);
}
/**
* @Route("/new", name="vaga_new", methods={"GET","POST"})
*/
public function new(Request $request): Response
{
$vaga = new Vaga();
$form = $this->createForm(VagaType::class, $vaga);
$form->handleRequest($request);
if ($form->isSubmitted() && $form->isValid()) {
$entityManager = $this->getDoctrine()->getManager();
$entityManager->persist($vaga);
$entityManager->flush();
return $this->redirectToRoute('vaga_index');
}
return $this->render('vaga/new.html.twig', [
'vaga' => $vaga,
'form' => $form->createView(),
]);
}
}
namespace AppController;
use AppEntityCandidato;
use AppFormCandidatoType;
use AppRepositoryCandidatoRepository;
use SymfonyBundleFrameworkBundleControllerAbstractController;
use SymfonyComponentHttpFoundationRequest;
use SymfonyComponentHttpFoundationResponse;
use SymfonyComponentRoutingAnnotationRoute;
/**
* @Route("/candidato")
*/
class CandidatoController extends AbstractController
{
/**
* @Route("/", name="candidato_index", methods={"GET"})
*/
public function index(CandidatoRepository $candidatoRepository): Response
{
$candidatos = $candidatoRepository->findAll();
return $this->render('candidato/index.html.twig', [
'candidatos' => $candidatos,
]);
}
/**
* @Route("/new", name="candidato_new", methods={"GET","POST"})
*/
public function new(Request $request): Response
{
$candidato = new Candidato();
$form = $this->createForm(CandidatoType::class, $candidato);
$form->handleRequest($request);
if ($form->isSubmitted() && $form->isValid()) {
$entityManager = $this->getDoctrine()->getManager();
$entityManager->persist($candidato);
$entityManager->flush();
return $this->redirectToRoute('candidato_index');
}
return $this->render('candidato/new.html.twig', [
'candidato' => $candidato,
'form' => $form->createView(),
]);
}
}
Criando as visualizações
As visualizações são as páginas que o usuário irá interagir. Utilizando o Symfony, é possível criar templates reutilizáveis para evitar a repetição de código no design.
Conclusão
Com o Symfony, é possível criar um poderoso sistema de gerenciamento de contratações, gerenciando vagas e candidaturas de processo seletivo em um único lugar. Utilizando o Doctrine, o componente Form e o padrão MVC, é possível criar uma aplicação escalável e de fácil manutenção.