Microblog com minhas imagens e fotos preferidas
7 |
16 | | ID | 18 |Title | 19 |Actions | 20 |
|---|---|---|
| ID | 25 |Title | 26 |Actions | 27 |
| {{ post.id }} | 33 |34 | 35 | {{ post.title }} 36 | 37 | | 38 |39 | Delete 40 | | 41 |
10 | {% endblock %}
--------------------------------------------------------------------------------
/templates/registration/index.html.twig:
--------------------------------------------------------------------------------
1 | {% extends 'base.html.twig' %}
2 |
3 | {% block title %} Register {% endblock %}
4 |
5 | {% block body %}
6 | {{ form(form) }}
7 | {% endblock %}
--------------------------------------------------------------------------------
/templates/security/login.html.twig:
--------------------------------------------------------------------------------
1 | {% extends 'base.html.twig' %}
2 |
3 | {% block title %}Log in!{% endblock %}
4 |
5 | {% block body %}
6 |
52 | {% endblock %}
53 |
--------------------------------------------------------------------------------
/tutorial/ARQUIVOS.md:
--------------------------------------------------------------------------------
1 | ### Upload de Arquivos
2 | Agora que temos nossa entidade que consegue armazenar o caminho das imagens precisamos fazer o upload de arquivos em si. Para isso precisamos adicionar um input file no nosso formulário de novo post. Vamos mudar o $builder para:
3 | ```php
4 | $builder
5 | ->add('title', null, [
6 | 'attr' => [
7 | 'class' => 'input'
8 | ],
9 | 'row_attr' => [
10 | 'class' => 'field'
11 | ],
12 | 'label_attr' => [
13 | 'class' => 'label'
14 | ]
15 | ]) ->add('image', FileType::class, [
16 | 'mapped' => false,
17 | 'row_attr' => [
18 | 'class' => 'field'
19 | ],
20 | 'label_attr' => [
21 | 'class' => 'label'
22 | ]
23 | ]) ->add('save', SubmitType::class, [
24 | 'attr' => [
25 | 'class' => 'button is-primary'
26 | ]
27 | ]);
28 | ```
29 | Note que adicionamos 'mapped' como falso, isso siginifica que esse campo não será automaticamente persistido e terá que ser tratado no controller, a documentação do symfony diz que isso é necessário caso quisermos salvar o arquivo em alguma pasta que não a temporária.
30 |
31 | Atualmente nossa tela de novo post deve estar assim:
32 | 
33 |
34 | Ok, como disse antes, agora teremos que tratar o arquivo no controller. Para isso teremos que alterar a função create em PostController
35 | ```php
36 | /**
37 | * @Route("/post/create", name="post.create")
38 | * @param Request $request
39 | * @return Response
40 | */
41 | public function create(Request $request)
42 | {
43 | // cria um novo post com titulo
44 | $post = new Post();
45 |
46 | // cria um novo formulário usando PostType de modelo que após preenchido
47 | // passa as informações para o objeto $post
48 | $form = $this->createForm(PostType::class, $post);
49 |
50 | $form->handleRequest($request);
51 |
52 | if($form->isSubmitted() && $form->isValid()) {
53 | $file = $request->files->get('post')['image'];
54 | // entity manager
55 | $em = $this->getDoctrine()->getManager();
56 | $em->persist($post);
57 | if ($file) {
58 | // cria um nome único para cada imagem
59 | // isso evita conflitos caso 2 tenham mesmo nome
60 | $filename = md5(uniqid()) . '.' . $file->guessClientExtension();
61 |
62 | // move as imagens, pega o valor de uploads_dir em services.yaml
63 | // e renomeia o arquivo com o valor em $filename
64 | $file->move($this->getParameter('uploads_dir'), $filename);
65 |
66 | // adiciona o caminho ao post para que seja persistido
67 | $post->setImage($filename);
68 | }
69 | $em->flush();
70 |
71 | $this->addFlash('success', 'O post ' . $post->getTitle() . ' foi criado.' );
72 |
73 | return $this->redirect($this->generateUrl('post'));
74 | }
75 |
76 | // return a response
77 | return $this->render('post/create.html.twig', [
78 | 'form' => $form->createView()
79 | ]);
80 | }
81 | ```
82 | Agora precisamos alterar config/services.yaml para que tenhamos a chave que pegamos com getParameter(), para isso vamos adicionar um valor em parameters apontando o local da pasta em que vamos salvar os arquivos.
83 | ```yaml
84 | parameters:
85 | uploads_dir: '%kernel.project_dir%/public/uploads/'
86 | ```
87 | Agora precisamos migrar nossos novos campos para o BD para que possa recebe-los:
88 | ``` php bin/console doctrine:schema:update --force```
89 | Após migrarmos os dados podemos enviar nosso arquivo que será salvo dentro de public/uploads/ e persistido.
90 | 
91 | Estamos quase prontos, para finalizarmos o upload de arquivos devemos também exibir a imagem salva quando acessarmos um de nossos posts. Para isso temos que ir no nosso template /post/show.html.twig e adicionar a imagem:
92 | ```twig
93 | {% extends 'base.html.twig' %}
94 |
95 | {% block title %} {{ post.title }}{% endblock %}
96 |
97 | {% block body %}
98 |
100 | {% endblock %}
101 | ```
102 | **Obs:** O caminho '/sftutorial/public/uploads/' é para quem está usando apache sem virtualhost, para quem está usando htacess, emdded server do php ou symfony ou com o virtualhost configurado o caminho é '/uploads/' apenas.
103 |
104 | Se tudo deu certo você deve estar vendo seus novos posts com imagens, parabéns!
105 | 
106 |
--------------------------------------------------------------------------------
/tutorial/COMPLETO.md:
--------------------------------------------------------------------------------
1 | # Symfony
2 | 
3 |
4 | ### O que é o Framework Symfony?
5 | Symfony é um framework - conjunto de bibliotecas e ferramentas - em PHP para a criação de aplicações de alta performance e de fácil manutenção. É altamente inspirado pelo projeto Spring da comunidade Java e nasceu inicialmente direcionado à produzir sistemas de qualidade para o mundo enterprise em PHP oferecendo soluções modulares com o máximo de reaproveitamento de código.
6 |
7 | ### Popularidade e Uso
8 |
9 | O Symfony é um framework modular, voltado ao público enterprise e muito eficiente para a criação de microserviços. Todas essas partes de sua natureza combianda torna muito dificil estimar de forma quantitativa quantas empresas usam Symfony, uma vez em que muitos projetos utilizam apenas algumas partes ou serviços e as companhias do ramo de software enterprise não costumam divulgar o que usam para construir seus produtos.
10 |
11 | Porém é facil de dizer que Symfony é um dos frameworks php mais populares devido ao fato da W3CTech medir o Symfony como o terceiro framework mais usado na internet, além disso foi o framework que [mais recebeu contribuições em 2019](https://symfony.com/blog/symfony-was-the-backend-framework-with-the-most-contributors-in-2019).
12 |
13 | ### Empresas que usam Symfony
14 |
15 | #### Spotify
16 | Segundo o site [EtonDigital](https://www.etondigital.com/popular-symfony-projects/) o Spotify usa o Symfony para construir o backend do site e isso foi confirmado por o ex-engenheiro [Mathias Petter Johansen](https://www.quora.com/On-what-language-is-Spotify-built) (porém, ele deixa claro que o Symfony não é usado na aplicação principal/player que tem o backend escrito em Clojure e Java).
17 |
18 | ### Dailymotion
19 | O Dailymotion é completamente construído usando Symfony. Isso inclusive faz parte dos [estudos de caso disponíveis](https://symfony.com/blog/dailymotion-powered-by-symfony) no site do framework. Segundo o Rank Global da Alexa o site é o #207 mais visitado no mundo e o quarto maior volume de mídias da internet.
20 |
21 | ### ( ͡° ͜ʖ ͡°)
22 | Ainda segundo o site [EtonDigital](https://www.etondigital.com/popular-symfony-projects/) e confirmado no Quora e no Fórum Laracasts por funcionários da empresa o **PornHub** é construído com Symfony e o que levou a empresa a migrar o código PHP para Symfony foi justamente o grande número de requisições por dia que exigiram uma arquitetura de sistemas mais robusta para aguentar o tráfego na casa dos bilhões de requisições.
23 |
24 | ## Instalação
25 |
26 | ### Requisitos Mínimos
27 | - Ter o PHP 7.2.5 or maior instalado e as seguintes extensões instaladas e habilitadas no arquivo php.ini: [Ctype](https://www.php.net/book.ctype), [iconv](https://www.php.net/book.iconv), [JSON](https://www.php.net/book.json), [PCRE](https://www.php.net/book.pcre), [Session](https://www.php.net/book.session), [SimpleXML](https://www.php.net/book.simplexml), and [Tokenizer](https://www.php.net/book.tokenizer);
28 | - Ter o Apache e um banco de dados devidamente instalados e configurados;
29 | - Ter o [Composer](https://getcomposer.org/download/), o package manager de php instalado e configurado nas variáveis de ambiente do sistema;
30 | - Instalar a ferramenta [Symfony](https://symfony.com/download), que adiciona diversas ferramentas para desenvolvimento com Symfony.
31 |
32 | Caso o desenvolvedor tenha dúvidas se seu ambiente já atende a todos esses requisitos basta usar o seguinte comando após instalar a ferramenta [Symfony](https://symfony.com/download):
33 | ```bash
34 | $ symfony check:requirements
35 | ```
36 | ### Iniciando um novo projeto no Symfony
37 | 1. Navegue no terminal até a pasta do Apache
38 | ``` bash
39 | $ cd /etc/var/www/
40 | ```
41 | 2. Use a ferramenta de CLI do Symfony para criar um novo projeto:
42 | ```bash
43 | $ symfony new | ID | 338 |Title | 339 |
|---|---|
| ID | 344 |Title | 345 |
| {{ post.id }} | 351 |{{ post.title }} | 352 |
| ID | 423 |Title | 424 |Actions | 425 |
|---|---|---|
| ID | 426 |Title | 427 |Actions | 428 |
| {{ post.id }} | 431 |432 | {{ post.title }} 433 | Delete 434 | |
912 | {% endblock %}
913 | ```
914 | **Obs:** O caminho '/sftutorial/public/uploads/' é para quem está usando apache sem virtualhost, para quem está usando htacess, emdded server do php ou symfony ou com o virtualhost configurado o caminho é '/uploads/' apenas.
915 |
916 | Se tudo deu certo você deve estar vendo seus novos posts com imagens, parabéns!
917 | 
918 | ### Relações de tabelas usando Doctrine, parte 2
919 | Agora faremos uma relação entre duas entidades, sendo uma a categoria e outra post, sendo que uma categoria terá muitos posts enquanto um post terá uma categoria. Para isso primeiro precisamos criar uma entidade chamada de Category com apenas um atributo string name:
920 | ``` php bin/console make:entity ```
921 | Após entrarmos com esse comando o terminal irá fazer algumas perguntas sobre a entidade que vamos criar e vamos entrar com as seguintes respostas:
922 | - Class name of the entity to create or update (e.g. FierceElephant):
923 | \> **Category**
924 | - New property name (press
1008 | {% endblock %}
1009 | ```
1010 | Agora quando acessamos um post ele deve parecer-se com isso:
1011 | 
1012 |
1013 | ### Services
1014 | Esse será o último tópico desse tutorial. Basicamente um _Service_ (Serviço) é qualquer Classe do Symfony. Durante esse tutorial usamos diversos serviços e o Symfony é baseado em Serviços (o que poderiamos pensar como módulos). Todos os serviços estão dentro de algo chamado _Container_ que você pode pensar como uma caixa que contêm diversos objetos que precisamos. Para ver todos os serviços que temos em nosso projeto Symfony podemos usar:
1015 | ``` php bin/console debug:container ```
1016 | Para exemplificar melhor como criar um serviço, vamos transformar a parte de upload de imagens em um serviço que irá tornar nosso código um pouco bagunçado nessa parte em algo mais organizado e efetivo. Para melhor oganizar nossas Classes de serviço vamos criar uma pasta src/Service e dentro vamos criar um arquivo php chamado Uploader.php e dentro dessa classe vamos adicionar nossa função de upload:
1017 | ```php
1018 | class Uploader
1019 | {
1020 | /**
1021 | * @var ContainerInterface
1022 | */
1023 | private $container;
1024 |
1025 | public function __construct(ContainerInterface $container)
1026 | {
1027 | $this->container = $container;
1028 | }
1029 | public function uploadFile(UploadedFile $file)
1030 | {
1031 | // cria um nome único para cada imagem
1032 | // isso evita conflitos caso 2 tenham mesmo nome
1033 | $filename = md5(uniqid()) . '.' . $file->guessClientExtension();
1034 |
1035 | // move as imagens, pega o valor de uploads_dir em services.yaml
1036 | // e renomeia o arquivo com o valor em $filename
1037 | $file->move($this->container->getParameter('uploads_dir'), $filename);
1038 |
1039 | return $filename;
1040 | }
1041 | }
1042 | ```
1043 | e agora vamos alterar nosso método create em PostController para utilizar nosso Service:
1044 | ```php
1045 | /**
1046 | * @Route("/post/create", name="post.create")
1047 | * @param Request $request
1048 | * @return Response
1049 | */public function create(Request $request, Uploader $uploader)
1050 | {
1051 | // cria um novo post com titulo
1052 | $post = new Post();
1053 |
1054 | // cria um novo formulário usando PostType de modelo que após preenchido
1055 | // passa as informações para o objeto $post $form = $this->createForm(PostType::class, $post);
1056 |
1057 | $form->handleRequest($request);
1058 |
1059 | if($form->isSubmitted() && $form->isValid()) {
1060 | $file = $request->files->get('post')['image'];
1061 | // entity manager
1062 | $em = $this->getDoctrine()->getManager();
1063 | $em->persist($post);
1064 | if ($file) {
1065 | $filename = $uploader->uploadFile($file);
1066 |
1067 | // adiciona o caminho ao post para que seja persistido
1068 | $post->setImage($filename);
1069 | }
1070 | $em->flush();
1071 |
1072 | $this->addFlash('success', 'O post ' . $post->getTitle() . ' foi criado.' );
1073 |
1074 | return $this->redirect($this->generateUrl('post'));
1075 | }
1076 |
1077 | // return a response
1078 | return $this->render('post/create.html.twig', [
1079 | 'form' => $form->createView()
1080 | ]);
1081 | }
1082 | ```
1083 | Ótimo se testar agora verá que tudo | ID | 104 |Title | 105 |
|---|---|
| ID | 110 |Title | 111 |
| {{ post.id }} | 117 |{{ post.title }} | 118 |
| ID | 189 |Title | 190 |Actions | 191 |
|---|---|---|
| ID | 192 |Title | 193 |Actions | 194 |
| {{ post.id }} | 197 |198 | {{ post.title }} 199 | Delete 200 | |
91 | {% endblock %}
92 | ```
93 | Agora quando acessamos um post ele deve parecer-se com isso:
94 | 
95 |
--------------------------------------------------------------------------------
/tutorial/ROTAS.md:
--------------------------------------------------------------------------------
1 | ### Rotas
2 | Existem quatro formas de trabalhar com rotas no Symfony e fica à decisão do programador qual escolher:
3 | 1. **Annotations**: Similar ao Spring Boot/.NET, o roteamento é feito através de uma anotação sobre o método/classe. Como podemos ver no código gerado pelo comando make a classe já veio anotada com a rota que chama o método index() e seu nome. Anotações é o meio padrão de trabalho do Symfony, essa pode ser uma opção bem popular para desenvolvedores que venham desses frameworks, além de adaptar-se melhor ao restante do Workflow do projeto;
4 | 2. **yaml**: Arquivos YAML são arquivos chave-valor assim como o JSON, esse tipo de arquivo é muito utilizado na configuração do Symfony, umas das configurações disponíveis é o arquivo routes.yaml onde podem ser definidas todas as rotas da aplicação, por padrão, esse arquivo vem inteiramente comentado e caso deseje usar YAML para configurar as rotas é só apagar as annotations da classe gerada, descomentar o arquivo route.yaml e preencher o arquivo com o nome da rota como chave e um array - que YAML é declarado por identação - com dois elementos chave-valor o index com o caminho de valor e path que diz qual classe e método será chamado:
5 | ```yaml
6 | main:
7 | path: /main
8 | controller: App\Controller\MainController::index
9 | ```
10 | 3. **XML**: Similar à outros frameworks enterprise como JSF, para usar basta renomear o arquivo routes.yaml para routes.xml e configurar as chaves e valores com a mesma estrutura esperada no YAML, tendo path e controller dentro do nome da rota. Essa pode ser uma opção interessante ao público enterprise que está migrando de JSF/.NET ou tenham ferramentas que integram melhor com XML como o Eclipse.
11 | ```xml
12 |
13 |
14 | Microblog com minhas imagens e fotos preferidas
13 |
21 |