<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Gabriel Gularte on Medium]]></title>
        <description><![CDATA[Stories by Gabriel Gularte on Medium]]></description>
        <link>https://medium.com/@gabrielfgularte?source=rss-2416e20eb08e------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*stUDNF_X4ym1rgabdF7rkQ.jpeg</url>
            <title>Stories by Gabriel Gularte on Medium</title>
            <link>https://medium.com/@gabrielfgularte?source=rss-2416e20eb08e------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 13:48:24 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@gabrielfgularte/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Meu Django starter kit]]></title>
            <link>https://medium.com/@gabrielfgularte/meu-django-starter-kit-a8dc48086d96?source=rss-2416e20eb08e------2</link>
            <guid isPermaLink="false">https://medium.com/p/a8dc48086d96</guid>
            <category><![CDATA[docker-compose]]></category>
            <category><![CDATA[lets-encrypt]]></category>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[ssl]]></category>
            <category><![CDATA[django]]></category>
            <dc:creator><![CDATA[Gabriel Gularte]]></dc:creator>
            <pubDate>Thu, 11 Jan 2018 17:13:11 GMT</pubDate>
            <atom:updated>2018-01-11T17:33:35.181Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jC9OoCbea2kmRPbeEtJlFA.png" /></figure><h4>Iniciando um novo projeto com Django e Docker</h4><p>Ultimamente tenho desenvolvido todos os meus projetos usando Django, e como a cada dia acordo com uma nova super empolgante ideia, criar um projeto do zero não era uma tarefa trivial: levantar uma VM instalar todas as dependências, configurar o projeto, etc etc.</p><p>Eu consegui facilitar e agilizar todo esse processo com o Docker (que é uma ferramenta de aprendizagem diária — ainda falta muito pra estudar e usar). Nesse post vou dar uma ideia de como eu consegui otimizar a criação e inicialização dos meus projetos com o meu starter. Como não é um post exclusivo sobre as ferramentas que eu usei, vou tentar ser o mais genérico e breve possível.</p><p>O repositório tá aqui: <a href="https://github.com/gabrielfgularte/django-starter">https://github.com/gabrielfgularte/django-starter</a> e eu super aceito contribuições, dicas, críticas, sugestões e qualquer outro tipo de contribuição.</p><h3>Docker &amp; Docker Compose</h3><p>O <strong>Docker</strong> é uma ferramenta sensacional. Basicamente, ela roda containers de aplicação numa camada de alto nível, permitindo que ela seja agnóstica a ambientes. Essa premissa é o que difere o Docker de uma VM comum, que virtualiza todo um OS cada vez que você levanta ela. Se quiser saber mais sobre Docker, recomendo esse site: <a href="https://docker-curriculum.com/">https://docker-curriculum.com/</a>.</p><p>Quando comecei a usar o Docker, pensei que seria ótimo &quot;dockerizar&quot; minhas aplicações pré-existentes. O problema é que um container, por padrão e por conceito, deve rodar somente um serviço, uma aplicação, um comando. Então eu teria que ter um container rodando pro Django, um pro meu banco de dados, um pro meu webserver e um pra cada comando agendado (CRONs). E ainda teria que conectar todos esses serviços usando técnicas de networking entre containers e etc.</p><p>Foi aí que o <strong>Docker Compose</strong> me salvou. Com ele, pude criar uma &quot;rede de serviços&quot; que se comunicam uns com os outros, dentre outras coisas. Vamos ver um exemplo do meu docker-compose.yml, arquivo padrão para configurar os serviços do Docker Compose:</p><pre>version: ‘3.3’</pre><pre>services:</pre><pre>database:<br> container_name: database<br> image: postgres<br> volumes:<br> — ./database:/var/lib/postgresql/data</pre><pre>django:<br> build: .<br> container_name: django<br> environment:<br> — PYTHONUNBUFFERED=1<br> volumes:<br> — ./application:/root<br> links:<br> — database<br> restart: unless-stopped</pre><pre>webserver:<br> image: nginx<br> links:<br> — django<br> volumes:<br> — ./nginx.conf:/etc/nginx/conf.d/default.conf<br> restart: unless-stopped</pre><p>Quando usamos link, dizemos ao Docker que um serviço estará ligado ao outro. Ou seja, dentro do container django nós temos acesso ao container database . Dessa forma podemos acessar o IP desse container usando a string &#39;database&#39;.</p><h3>Django feat PostgreSQL</h3><p>Eu sempre tenho usado Postgre como banco de dados, mas trocar pra outro banco não é difícil. É só você mudar o serviço do PostgreSQL para utilizar outra imagem. Por exemplo, supondo que você prefira utilizar MySQL, o serviço de database ficaria assim:</p><pre>database:<br> container_name: database<br> image: mysql<br> volumes:<br> — ./database:/var/lib/mysql</pre><h3>Nginx feat Let&#39;s Encrypt SSL (HTTPS)</h3><p>Toda aplicação que utiliza senha, compra, e/ou quaisquer outros dados sensíveis do usuário deve ser HTTPS. <a href="https://security.googleblog.com/2016/09/moving-towards-more-secure-web.html">O próprio Google disse que vai começar a avisar aos usuários de forma mais incisiva sobre o site que ele está visitando se o site não for seguro.</a> Como a grande maioria das minhas aplicações possuem dados sensíveis dos usuários, eu optei por colocar HTTPS no meu starter. E mesmo que eu não vá desenvolver uma aplicação com dados sensíveis, a <a href="https://letsencrypt.org/">Let&#39;s Encrypt</a> emite certificados SSL de graça e não custa nada a gente aparecer verdinho com cadeado ali na barra de endereço. ;)</p><p>Pra isso, foi preciso ralar um pouco, e pra ser sincero, não sei e não pesquisei como isso ficaria se eu tivesse que usar Apache ou Lighthttpd. Como em todos os meus projetos, sou eu quem define as tecnologias a serem usadas e desde que migrei pro Python (usava PHP feat Apache) passei a usar Nginx, segui com ele. <strong>SUPER ACEITO CONTRIBUIÇÕES</strong> para colocar esse starter rodando com Apache e outros webservers também.</p><p>Outra coisa interessante e que deixa os seus serviços mais agnósticos a ambientes ainda, é que o Docker Compose aceita que você crie um arquivo chamado docker-compose.override.yml para substituir as configurações utilizadas no docker-compose.yml original. Aí fica fácil da gente escrever configurações de webserver diferentes pros ambientes que a gente precisa, seja local, homologação ou produção.<em> Aqui vai uma dica: eu escrevo arquivos com os nomes dos ambientes, por exemplo, para produção, meu arquivo é </em><em>docker-compose.prod.yml. Daí, na hora do deploy, eu subo o arquivo relativo ao ambiente e renomeio ele pra </em><em>docker-compose.override.yml.</em></p><blockquote><em>Lembrando que eu uso a versão 3.3 do Docker Compose File, e é provável que não funcione bem versões mais antigas.</em></blockquote><h3>Baixando, instalando e usando</h3><p>Pra usar o django-starter, o que você precisa fazer é clonar, forkar ou baixar o repositório que tá no github no link ali em cima. Depois vá para pasta onde baixou e remova a pasta .git do projeto. Daí, basta renomear a pasta pro nome do seu projeto e rodar o arquivo install.sh.</p><p>Pra rodar a aplicação, é só rodar o comando updo Docker Compose ( docker-compose-up ).</p><p>Sempre que quiser parar, reiniciar ou rodar um dos serviços standalone, é só rodar o comando que deseja seguido do serviço definido no Docker Compose File, por exemplo, docker-compose stop django .</p><p>Seu novo projeto estará rodando em qualquer ambiente, usando sempre as ferramentas que você escolheu! Obrigado pela leitura, e até a próxima!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a8dc48086d96" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Custom User Model no Django]]></title>
            <link>https://medium.com/@gabrielfgularte/custom-user-model-no-django-d9bdf2838bd8?source=rss-2416e20eb08e------2</link>
            <guid isPermaLink="false">https://medium.com/p/d9bdf2838bd8</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[tutorial]]></category>
            <category><![CDATA[django]]></category>
            <dc:creator><![CDATA[Gabriel Gularte]]></dc:creator>
            <pubDate>Mon, 20 Jul 2015 06:06:43 GMT</pubDate>
            <atom:updated>2015-07-20T23:39:26.811Z</atom:updated>
            <cc:license>https://creativecommons.org/licenses/by-sa/4.0/</cc:license>
            <content:encoded><![CDATA[<h4>Eu me enrolei, e sei que muita gente também se enrola quando se trata de User Authentication do framework. Mas agora seus problemas acabaram! ;)</h4><h3>Qual o problema com o User Model default do Django?</h3><p>A princípio, nenhum. Se você está começando no Django, só brincando, fazendo testes e experimentando não há nada de errado em usá-lo. O problema é quando você precisa desenvolver um grande projeto, sério, cisudo e pomposo e vai colocá-lo em produção.</p><p>O <em>User </em>default atende muito bem quase todas expectativas de um projeto do mundo real. Mas ele acaba atrapalhando, e até desencorajando os novos <em>djanglers</em> na hora da customização. Isso porque esse model não permite muita customização, e a recomendação na documentação do próprio Django é que você extenda esse model ou crie o seu próprio. É nessa hora que a coisa começa a ficar complicada…</p><h3>Extendendo o User Model</h3><p>A maneira mais simples de adicionar alguma customização pra esse model, é criando um outro model com um relacionamento <em>OneToOne</em> pra ele. Para exemplificar, imagine que você planejou que seus usuários tenham perfis, e seus perfis têm dados como: idade e gênero. Extendendo o <em>User </em>default com um relacionamento <em>OneToOne</em>, seu código ficaria mais ou menos assim:</p><pre>from django.contrib.auth.models import User<br>from django.db import models</pre><pre>class Profile(models.Model):<br>    user = models.OneToOneField(User, related_name=&#39;profile&#39;)<br>    age = models.IntegerField()<br>    gender = models.BooleanField()</pre><blockquote>Ps: Todos os blocos de código desse post vão estar meio sem identação. Eu não consegui fazer a identação direitinho neles… Se alguém souber como, ajuda bastante! ;)</blockquote><p>Dessa forma você extendeu o <em>User </em>default do Django e criou uma nova entidade para comportar os campos que ele não oferece nativamente.</p><h3>Substituindo o User Model</h3><p>Uma vez que você não precisa alterar o comportamento nativo do <em>User </em>default, a solução anterior se aplica perfeitamente a você. Mas e se, por exemplo, o usuário do nosso site precisa <strong>se logar com o email ao invés de username</strong>? Ou se a <strong>senha do usuário necessita ter um limite de 8 caracteres</strong>? Aqui está a triste verdade: <strong>não existe uma maneira fácil e/ou <em>painless</em> de alterar esses comportamentos</strong>. Você precisa meter a mão na massa e ralar um pouquinho…</p><p>Mas como eu já ralei bastante, vou tentar diminuir seu sofrimento, ok? Vamos lá, como eu disse, você precisa que o seu usuário se logue no nosso site com o email, e não com o seu username. Além disso, você quer uma informação importante sobre o usuário, quer saber se ele confirmou seu email, ou seja, se ele realmente existe e é confiável. Para isso nós vamos substituir o User Model default do Django e usar nosso próprio model.</p><blockquote><strong>É muito importante ressaltar aqui que você inicie um novo projeto para esse método. Se você tentar substituir o User Model com uma aplicação viva ou um projeto que já tenha qualquer tipo de estrutura, pode dar merda, e você pode acabar num beco sem saída, ok?</strong></blockquote><p>Pra começar, vamos criar um novo app chamado <em>account</em>:</p><pre>python manage.py startapp account</pre><p>Agora a brincadeira começa. Vamos deixar claro que a repetição vai existir aonde você não quer alterar, ou seja, nós vamos repetir aqui o comportamento de alguns campos, portanto, se você só precisa alterar um comportamento, tenha certeza de ser extremamente necessário, ok? Vamos começar a escrever nosso próprio User model:</p><pre># Arquivo models.py do app account</pre><pre>from django.contrib.auth.models import AbstractBaseUser, PermissionsMixin, BaseUserManager<br>from django.core import validators<br>from django.utils.translation import ugettext_lazy as _<br>import re<br></pre><pre>class User(AbstractBaseUser, PermissionsMixin):<br>    <br>    username = models.CharField(_(&#39;username&#39;), max_length=15, unique=True, help_text=_(&#39;Required. 15 characters or fewer. Letters, numbers and @/./+/-/_ characters&#39;), validators=[ validators.RegexValidator(re.compile(&#39;^[\w.@+-]+$&#39;), _(&#39;Enter a valid username.&#39;), _(&#39;invalid&#39;))])</pre><pre>    first_name = models.CharField(_(&#39;first name&#39;), max_length=30)</pre><pre>    last_name = models.CharField(_(&#39;last name&#39;), max_length=30)</pre><pre>    email = models.EmailField(_(&#39;email address&#39;), max_length=255, unique=True)</pre><pre>    is_staff = models.BooleanField(_(&#39;staff status&#39;), default=False, help_text=_(&#39;Designates whether the user can log into this admin site.&#39;))</pre><pre>    is_active = models.BooleanField(_(&#39;active&#39;), default=True, help_text=_(&#39;Designates whether this user should be treated as active. Unselect this instead of deleting accounts.&#39;))<br>    <br>    date_joined = models.DateTimeField(_(&#39;date joined&#39;), default=timezone.now)</pre><p>Até aí, estamos bem perto do model default, agora vamos adicionar um campo a mais nesse model:</p><pre>is_trusty = models.BooleanField(_(&#39;trusty&#39;), default=False, help_text=_(&#39;Designates whether this user has confirmed his account.&#39;))</pre><p>Esse bloco de código acrescenta o campo <em>is_trusty</em>, que nos dirá se o usuário confirmou o email, ou seja, se é um usuário confiável. A estrutura do nosso model está basicamente pronta, vamos agora trocar a forma de login do usuário, que será via email. Vamos também adicionar os campos obrigatórios e uns métodos de apoio. Ainda na nossa classe User:</p><pre>USERNAME_FIELD = &#39;email&#39;<br>REQUIRED_FIELDS = [&#39;username&#39;, &#39;first_name&#39;, &#39;last_name&#39;]</pre><pre>class Meta:<br>    verbose_name = _(&#39;user&#39;)<br>    verbose_name_plural = _(&#39;users&#39;)</pre><pre>def get_full_name(self):<br>    full_name = &#39;%s %s&#39; % (self.first_name, self.last_name)<br>    return full_name.strip()</pre><pre>def get_short_name(self):<br>    return self.first_name</pre><pre>def email_user(self, subject, message, from_email=None):<br>    send_mail(subject, message, from_email, [self.email])</pre><p>Agora sim nós temos nosso model (quase) completo. Ainda vai ficar faltando uma linhazinha, mas a gente já fala dela. Vamos analisar o código acima:</p><ul><li>USERNAME_FIELD: essa variável recebe o campo do model que será utilizado pelo Django para autenticação. É aqui que ao invés de <em>username</em> do model default, eu coloco <em>email</em> para fazer o login pelo email do usuário.</li><li>REQUIRED_FIELDS: os campos que são obrigatórios desse model. Nenhuma dúvida quanto isso, certo?</li><li>class Meta, verbose_name e verbose_plural: aqui a gente define a taxonomia que nosso model terá para o Django no singular e no plural.</li><li>get_full_name, get_short_name e email_user: são métodos de apoio que facilitam nossa vida. Se eu não me engano, elas são obrigatórias para o sistema do Django.</li></ul><p>Agora nós precisamos criar um manager pro nosso model. O manager é a classe que disponibiliza funções para criação e administração do usuário e <em>superuser</em>. Vamos escrever nosso manager, no mesmo arquivo, porém em outra classe e acima da nossa classe User (já explico o motivo):</p><pre>class UserManager(BaseUserManager):</pre><pre>    def _create_user(self, username, email, password, is_staff, is_superuser, **extra_fields):<br>        now = timezone.now()<br>        if not username:<br>            raise ValueError(_(‘The given username must be set’))<br>        email = self.normalize_email(email)<br>        user = self.model(username=username, email=email, is_staff=is_staff, is_active=True, is_superuser=is_superuser, last_login=now, date_joined=now, **extra_fields)<br>        user.set_password(password)<br>        user.save(using=self._db)<br>        return user</pre><pre>    def create_user(self, username, email=None, password=None, **extra_fields):<br>        return self._create_user(username, email, password, False, False, **extra_fields)</pre><pre>    def create_superuser(self, username, email, password, **extra_fields):<br>        user=self._create_user(username, email, password, True, True, **extra_fields)<br>        user.is_active=True<br>        user.save(using=self._db)<br>        return user</pre><p>Depois de criarmos o <em>User Manager</em>, voltamos ao <em>User </em>para inserir o <em>Manager</em>. E é aqui que entendemos o motivo de inserir a classe UserManager acima da <em>User</em>. A classe <em>User </em>faz referência a <em>UserManager</em>, ou seja, se colocarmos a <em>UserManager </em>depois vamos causar um erro, pois a aplicação não vai econtrar <em>UserManager </em>quando for parsear essa linha.</p><pre>...<br>USERNAME_FIELD = &#39;email&#39;<br>REQUIRED_FIELDS = [&#39;username&#39;, &#39;first_name&#39;, &#39;last_name&#39;]</pre><pre>objects = UserManager()</pre><pre>class Meta:<br>...</pre><p>O arquivo final, deve se parecer com o código abaixo, devidamente identado, claro…</p><pre>import re</pre><pre>from django.db import models<br>from django.core import validators<br>from django.utils import timezone<br>from django.core.mail import send_mail<br>from django.utils.http import urlquote<br>from django.utils.translation import ugettext_lazy as _<br>from django.contrib.auth.models import AbstractBaseUser, PermissionsMixin, BaseUserManager<br>from django.conf import settings</pre><pre>class UserManager(BaseUserManager):</pre><pre>def _create_user(self, username, email, password, is_staff, is_superuser, **extra_fields):<br> now = timezone.now()<br> if not username:<br> raise ValueError(_(‘The given username must be set’))<br> email = self.normalize_email(email)<br> user = self.model(username=username, email=email,<br> is_staff=is_staff, is_active=True,<br> is_superuser=is_superuser, last_login=now,<br> date_joined=now, **extra_fields)<br> user.set_password(password)<br> user.save(using=self._db)<br> return user</pre><pre>def create_user(self, username, email=None, password=None, **extra_fields):<br> return self._create_user(username, email, password, False, False,<br> **extra_fields)</pre><pre>def create_superuser(self, username, email, password, **extra_fields):<br> user=self._create_user(username, email, password, True, True,<br> **extra_fields)<br> user.is_active=True<br> user.save(using=self._db)<br> return user</pre><pre>class User(AbstractBaseUser, PermissionsMixin):</pre><pre>username = models.CharField(_(‘username’), max_length=15, unique=True,<br> help_text=_(‘Required. 15 characters or fewer. Letters, \<br> numbers and @/./+/-/_ characters’),<br> validators=[<br> validators.RegexValidator(<br> re.compile(‘^[\w.@+-]+$’),<br> _(‘Enter a valid username.’),<br> _(‘invalid’))])<br> first_name = models.CharField(_(‘first name’), max_length=30)<br> last_name = models.CharField(_(‘last name’), max_length=30)<br> email = models.EmailField(_(‘email address’), max_length=255, unique=True)<br> is_staff = models.BooleanField(_(‘staff status’), default=False,<br> help_text=_(‘Designates whether the user can log into this admin site.’))<br> is_active = models.BooleanField(_(‘active’), default=True,<br> help_text=_(‘Designates whether this user should be treated as active. \<br> Unselect this instead of deleting accounts.’))<br> date_joined = models.DateTimeField(_(‘date joined’), default=timezone.now)<br> is_trusty = models.BooleanField(_(‘trusty’), default=False,<br> help_text=_(‘Designates whether this user has confirmed his account.’))</pre><pre>USERNAME_FIELD = ‘email’<br> REQUIRED_FIELDS = [‘username’, ‘first_name’, ‘last_name’]</pre><pre>objects = UserManager()</pre><pre>class Meta:<br> verbose_name = _(‘user’)<br> verbose_name_plural = _(‘users’)</pre><pre>def get_full_name(self):<br> full_name = ‘%s %s’ % (self.first_name, self.last_name)<br> return full_name.strip()</pre><pre>def get_short_name(self):<br> return self.first_name</pre><pre>def email_user(self, subject, message, from_email=None):<br> send_mail(subject, message, from_email, [self.email])</pre><p>Feito isso, agora precisamos dizer ao Django que queremos usar o nosso model ao invés do default dele. Pra isso, vamos adicionar uma linha ao arquivo <em>settings.py</em>:</p><pre>...<br>ALLOWED_HOSTS = []</pre><pre># Eu coloquei aqui entre o ALLOWED_HOSTS e o LOGIN_URL, mas você<br># pode colocar aonde quiser, desde que faça algum sentido.<br>AUTH_USER_MODEL = ‘account.User’</pre><pre>LOGIN_URL = ‘/’<br>...</pre><blockquote><strong>Não se esqueça de adicionar o app “account” no INSTALLED_APPS!</strong></blockquote><p>Agora basta rodar um <em>makemigrations </em>e <em>migrate </em>da <em>account, </em>criar um <em>superuser </em>e voilà!</p><pre>python manage.py makemigrations account<br>python manage.py migrate account<br># Eu gosto de rodar um migrate puro por segurança...<br>python manage.py migrate</pre><pre>python manage.py createsuperuser</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9TONeUOghrbUhcMLp_tRLw.jpeg" /><figcaption>Login no admin do Django com email ao invés de username (sim, estou num Windows… Não me julgue! Rsrs)</figcaption></figure><p>Espero que não tenha sido muito maçante ler esse artigo imenso! Haha. <a href="https://github.com/gabrielfgularte/django-custom-user"><strong>O código desse artigo está no Github</strong></a>, e já vem até com uma <em>Vagrant </em>se você quiser levantar uma VM de brinks pra testar. É isso galera, aquele abraço!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d9bdf2838bd8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Caracteres especiais e full-text search no Postgre]]></title>
            <link>https://medium.com/@gabrielfgularte/caracteres-especiais-e-full-text-search-no-postgre-c345b1da5b7b?source=rss-2416e20eb08e------2</link>
            <guid isPermaLink="false">https://medium.com/p/c345b1da5b7b</guid>
            <category><![CDATA[search]]></category>
            <category><![CDATA[full-text]]></category>
            <category><![CDATA[postgres]]></category>
            <dc:creator><![CDATA[Gabriel Gularte]]></dc:creator>
            <pubDate>Thu, 16 Jul 2015 06:07:17 GMT</pubDate>
            <atom:updated>2018-04-11T20:36:11.534Z</atom:updated>
            <cc:license>https://creativecommons.org/licenses/by-sa/4.0/</cc:license>
            <content:encoded><![CDATA[<h4>Full-text search é uma feature irada no Postgre. O problema é quando você precisa lidar com caracteres especiais.</h4><h3>Breve introdução ao cenário…</h3><p>Aqui na <strong>Mentis </strong>estamos migrando o banco de dados do <a href="http://www.amoremcristo.com/">Amor Em Cristo</a> de SQLServer para Postgre. Para começar não foi fácil arrumar uma ferramenta que transportasse os dados de uma tecnologia para outra, principalmente quando falamos de um banco mais fechado, com uma comunidade de difícil acesso e produtos nada open-source como o SQLServer. Pesquisa dali, testa daqui, gasta uma grana forte com um driver de lá, e encontramos uma maneira de realizar o <a href="https://en.wikipedia.org/wiki/Data_Transformation_Services">DTS</a> e transferir os dados entre as tecnologias.</p><p>Passamos um bom tempo transcrevendo as Stored Procedures do SQLServer para as Functions do Postgre. Isso sem falar nas diferenças de tipos, de conceitos e <em>Built-in Functions… </em>Muitos fios de cabelo branco depois chegamos a um ponto delicado do processo: <strong>Full-text Search</strong>. E por que é um ponto delicado? Bom, o Amor Em Cristo é um <strong>site de relacionamento</strong> para cristãos, o que o torna 90% dependente de uma área específica, a <strong>busca</strong>, tendo seus outros 10% no chat e algoritmos de <em>match</em>. Resumindo, se os usuários não conseguem encontrar alguém que eles querem, o site não serve de muita coisa pra eles…</p><h3>O real problema</h3><p>Quando o usuário pesquisa por “José”, ele QUER encontrar pessoas que se chamam José. De fato, não custa e não há problema em mostrar pra ele pessoas que se chamam Joses também. Mas principalmente ele quer ver pessoas que se chamam José, e se possível, no topo do resultado de busca. Isso seria muito simples de implementar, o Postgre possui um sistema de full-text search genial. Basta você criar um INDEX do tipo <em>gin</em> para a coluna desejada utilizando a função <em>ts_vector </em>e quando for realizar a busca, colocar o <em>ts_query</em>:</p><pre>-- Adiciona o INDEX na coluna nome:<br>CREATE INDEX usuarios_nome_search ON usuarios using gin(to_tsvector(&#39;portuguese&#39;, nome));</pre><pre>-- Na query da busca:<br>SELECT * FROM usuarios WHERE to_tsvector(&#39;portuguese&#39;, usuarios.nome) @@ to_tsquery(&#39;portuguese&#39;, &#39;jose&#39;);</pre><pre>-- Resultado:<br>id | nome<br>------------<br>1  | José<br>2  | Joses</pre><p>O resultado mostra que o full-text do Postgre já consegue fazer a indexação de plural, acentos e ainda é <a href="https://en.wikipedia.org/wiki/Case_sensitivity">case-insensitive</a>. Genial! Até aí está muito bom. Mas e se ao invés de nome, estivermos procurando por apelidos? Imagine que o apelido do José é<em> jose/maria!</em>. Só nesse apelido já temos uma barra e um ponto de exclamação. Vamos tentar encontrar o José pelo seu apelido?</p><pre>-- Adiciona o INDEX na coluna apelido:<br>CREATE INDEX usuarios_apelido_search ON usuarios using gin(to_tsvector(&#39;portuguese&#39;, apelido));</pre><pre>-- Na query da busca:<br>SELECT * FROM usuarios WHERE to_tsvector(&#39;portuguese&#39;, usuarios.apelido) @@ to_tsquery(&#39;portuguese&#39;, &#39;jose/maria!&#39;);</pre><pre>-- Resultado:<br>ERROR:  syntax error in tsquery: &quot;jose&quot;</pre><p>E agora José? Calma, eu já sofri resolvendo e espero que você sofra menos… rsrs.</p><h3>A causa e a solução</h3><p>O que aconteceu ali em cima, rapaz? Eu te explico… A função <em>ts_query </em>do Postgre aceita operações lógicas, ou seja, dentro da string do termo a ser comparado(o segundo parâmetro da função) você pode fazer operações como <em>&amp; (AND)</em>,<em> | (OR)</em>, <em>!(NOT)</em>, etc… Por isso ele detecta um erro de sintaxe e não vamos poder usar essa função para nossa busca. Olhando com mais cuidado a documentação do Postgre, encontramos a seguinte frase:</p><blockquote>PostgreSQL provides the functions to_tsquery and plainto_tsquery for converting a query to the tsquery data type. to_tsquery offers access to more features than plainto_tsquery, but is less forgiving about its input.</blockquote><p>Ou seja, além da <em>to_tsquery </em>existe a <em>plainto_tsquery</em>, que oferece menos funcionalidades, mas funciona melhor se eu optar pela simplicidade na string que eu to passando, o que é justamente o que eu quero aqui. Então agora, vamos novamente pro nosso SELECT:</p><pre>-- Na query da busca:<br>SELECT * FROM usuarios WHERE to_tsvector(&#39;portuguese&#39;, usuarios.apelido) @@ plainto_tsquery(&#39;portuguese&#39;, &#39;jose/maria!&#39;);</pre><pre>-- Resultado:<br>id | nome  | apelido<br>--------------------<br>1  | José  | jose/maria!</pre><p><strong>YOU WIN! FATALITY! </strong>Aparentemente, tudo está perfeito, certo? Mas vamos complicar ainda mais… Vamos agora buscar pelo usuário Joses, e queremos encontrá-lo pelo seu apelido, que é <em>josesboladão</em>, mas eu não quero acentuar apelidos na busca, ou seja, vamos buscar por <em>josesboladao</em>. Vamos refazer o SELECT e ver o que acontece:</p><pre>-- Na query da busca:<br>SELECT * FROM usuarios WHERE to_tsvector(&#39;portuguese&#39;, usuarios.apelido) @@ plainto_tsquery(&#39;portuguese&#39;, &#39;josesboladao&#39;);</pre><pre>-- Resultado:<br>id | nome  | apelido<br>--------------------</pre><p>Oops! Acho que não deu muito certo… =/</p><p>O problema aqui é justamente o <em>plainto_tsquery</em>, que por ser muito simples, não faz o <em>parsing</em> da acentuação como o <em>to_tsquery</em> faz. E agora? Aqui está um belo <em>pulo-do-gato</em>. Pesquisando nós encontramos uma extensão do Postgre chamada <em>unaccent</em>, e o que ela faz está implícito no seu próprio nome: ela remove os acentos de uma string. Para ligar uma extensão no Postgre utilizamos o comando CREATE EXTENSION, e é requerido que você tenha instalado o pacote de extensões do Postgre. <a href="http://www.postgresql.org/docs/9.1/static/sql-createextension.html">Clique aqui para ir até a documentação</a>. Agora vamos aplicar ela na nossa query, mas acho que você já adivinhou como vai ficar, não é?</p><pre>-- Liga extensão unaccent:<br>CREATE EXTENSION unaccent;</pre><pre>-- Na query da busca:<br>SELECT * FROM usuarios WHERE to_tsvector(&#39;portuguese&#39;, usuarios.apelido) @@ plainto_tsquery(&#39;portuguese&#39;, unaccent(&#39;josesboladao&#39;));</pre><pre>-- Resultado:<br>id | nome  | apelido<br>--------------------<br>2  | Joses | josesboladão</pre><p><strong>EDIT</strong>: O <a href="https://medium.com/u/9bce8e1ef986">Emerson Santos</a> apontou muito bem um erro no código acima. O ideal aqui, é a gente rodar o unaccent também no to_tsvector, dessa forma a query vai comprar as duas expressões pesquisadas sem acentos. Então vamos ao código correto!</p><pre>-- Liga extensão unaccent:<br>CREATE EXTENSION unaccent;</pre><pre>-- Na query da busca:<br>SELECT * FROM usuarios WHERE to_tsvector(&#39;portuguese&#39;, unaccent(usuarios.apelido)) @@ plainto_tsquery(&#39;portuguese&#39;, unaccent(&#39;josesboladao&#39;));</pre><pre>-- Resultado:<br>id | nome  | apelido<br>--------------------<br>2  | Joses | josesboladão</pre><p><strong>YOU WIN! FLAWLESS VICTORY! FATALITY! </strong>Agora sim, nós passamos a buscar por termos com quaisquer caracteres especiais e acentuações.</p><p>Grande abraço! \o</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c345b1da5b7b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Entendendo Aplicações Web Realtime]]></title>
            <link>https://medium.com/@gabrielfgularte/understanding-realtime-web-apps-5aef47d51a45?source=rss-2416e20eb08e------2</link>
            <guid isPermaLink="false">https://medium.com/p/5aef47d51a45</guid>
            <category><![CDATA[websocket]]></category>
            <category><![CDATA[web-apps]]></category>
            <category><![CDATA[realtime]]></category>
            <dc:creator><![CDATA[Gabriel Gularte]]></dc:creator>
            <pubDate>Thu, 11 Sep 2014 20:16:54 GMT</pubDate>
            <atom:updated>2015-07-24T19:56:05.872Z</atom:updated>
            <cc:license>https://creativecommons.org/licenses/by-sa/4.0/</cc:license>
            <content:encoded><![CDATA[<h4>Sem mágicas, sem complicações: WebSockets, Polling e Long Polling</h4><blockquote>PS.: Esse artigo já existia, mas foi traduzido para o português. Sim, cansei de escrever em inglês… por enquanto.</blockquote><h3>O que é realtime?</h3><p>Bom, vamos <em>começar pelo começo</em>, certo? Quanto tempo você acha que a imagem de um belo quadro leva até chegar ao seu cérebro, para que ele possa processar a imagem e, obter a brilhante presunção, de que aquilo é um quadro? É óbvio que você não pára pra pensar nisso toda vez que enxerga alguma coisa, mas vamos tentar fazer esse exercício agora:</p><p>Feche os olhos, conte até 10 e os abra. O que você vê? Quanto tempo demorou até que você percebesse o que estava vendo? Foi <em>&quot;instantâneo&quot;</em>, não é mesmo? Foi <strong><em>verdadeiramente</em></strong> <strong><em>realtime!! </em></strong>#sóquenão :(</p><p>Nosso cérebro está atrasado em relação ao verdadeiro realtime em 80 milissegundos, ou ms (que é como vou chamar os milissegundos daqui por diante no post). Já parou pra pensar nisso? Tudo o que vemos, já aconteceu e nós estamos sempre presenciando o passado.</p><h3>Realtime é fake! :O</h3><p>Nada vivo, morto ou construído (nesse planeta, pelo menos) executa uma ação ou reação absolutamente instantânea. Tudo tem um tempo para acontecer, mesmo que isso dure milimicronano segundos (obviamente inventei essa medida… xD).</p><p>O toque, a visão, a audição, etc. Tudo leva um tempo para acontecer e raramente notamos isso. As vezes lembramos disso com fogos de artifício, trovões, etc. Aí você se pergunta:</p><blockquote>Mas cara, se você tá me dizendo que não existe realtime, o que é esse realtime que a galera tanto fala?</blockquote><h3>O que é realtime, afinal?</h3><p>O realtime de que tanto falam é apenas uma sensação. Temos a (errônea) impressão de que foi instantâneo, mas nem foi cara… Só pareceu que foi, é sério. =/ Mas isso não é tão ruim quanto parece, pois, ao invés de trabalhar para fazer as coisas serem instantâneas, nós temos agora que trabalhar duro para fazer as coisas <em>parecerem</em> instantâneas. Temos que dar a melhor sensação de realtime para quem estiver no fim da linha do nosso trabalho.</p><p>Isso é mais fácil do que você imagina, nós já fazemos isso no WhatsApp, por exemplo e até no bom e velho telefone mesmo, quando estamos tentando passar alguma informação que estamos presenciando no nosso lado da linha. Então se você estiver pensando em desenvolver uma <strong><em>aplicação realtime</em></strong>, se prepare pra entender como funciona a comunicação e como ela te ajuda a proporcionar uma experiência com a melhor sensação de realtime possível.</p><p>A leitura vai ficar um pouco mais técnica a partir daqui, ok?</p><h3>Realtime na web</h3><p>Sempre que falamos sobre desenvolver uma aplicação realtime, que pode ser um chat, notificações push ou qualquer coisa que você imagine, nós estamos falando de entregar informação da maneira mais rápida e eficiente possível para nossos clientes.</p><p>Para desenvolver tais aplicações, precisamos escolher técnicas e ferramentas, e dentre muitas opções atuais do mercado, eu escolhi falar mais especificamente sobre duas: <strong><em>WebSockets</em></strong> e <strong><em>Long Polling</em></strong>.</p><h3>Websockets</h3><p>Para entender o que é, precisamos primeiro ver (ou rever) alguns conceitos básicos da comunicação. Uma comunicação <em>duplex</em> só pode ser realizada entre um transmissor e um receptor. Além disso, eles precisam criar um protocolo para estabelecer e regularizar essa comunicação entre eles, e existem dois tipos de protocolos em um sistema <em>duplex</em>: <strong><em>Half-Duple</em></strong>x e <strong><em>Full-Duplex</em></strong>.</p><blockquote>Mas cara! Pera aí! O que é duplex???</blockquote><h4>Duplex</h4><p>Duplex é um sistema de comunicação que, para existir, precisa de pelo menos um transmissor e pelo menos um receptor. Nós usamos esse cara pra praticamente tudo relacionado a comunicação na nossa vida.</p><p>Explicado? Qualquer coisa joga no Google que você vai achar um monte de coisa mais específica, eu vou tentar pegar mais leve aqui, ok? Agora vamos aos protocolos de um sistema Duplex.</p><h4>Half-Duplex</h4><p>Também chamado de <strong><em>Semi-Duplex</em></strong>, esse protocolo permite que a informação da comunicação trafegue de forma unidirecional, ou seja, só pode existir um transmissor e um receptor por vez. Tem um velho e conhecido ditado que exemplifica isso muito bem: “Quando um burro fala, o outro abaixa a orelha”.</p><h4>Full-Duplex</h4><p>Esse protocolo fornece uma comunicação bidirecional entre o transmissor e o receptor. Isso significa que o transmissor e o receptor ficam trocando de papel um com o outro a todo momento. Imagine uma feira, o recreio de uma pré-escola e a praça de alimentação de um shopping. Todos esses lugares acontecendo junto, no mesmo tempo e ocupando o mesmo espaço. É isso.</p><p>Agora que a gente (re)lembrou os conceitos de uma comunicação, podemos definir <strong><em>WebSockets</em></strong> como uma comunicação <strong><em>Full-Duplex</em></strong>. Em outras palavras, podemos dizer que o <strong><em>WebSockets</em></strong> abre uma conexão entre o cliente e o servidor, tornando possível a troca bidirecional de informações.</p><p>O <strong><em>WebSockets</em></strong> é uma <em>API</em> do <strong><em>HTML5</em></strong> e sua especificação ainda está em desenvolvimento pelo <a href="http://www.w3.org/"><strong>W3C</strong></a>, mas a maioria dos browsers modernos já oferecem suporte e você já pode encontrar centenas de aplicações, plugins e frameworks que usam essa tecnologia.</p><p>Se sua aplicação <strong>não precisa</strong> dar suporte para navegadores antigos, o <strong><em>WebSockets</em></strong> parece ser a sua melhor opção.</p><p>Mas se você precisa dar suporte a navegadores antigos, aí os problemas começam a ficar um pouco mais cabeludos para resolver. Para isso, você vai precisar desenvolver um sistema super inteligente de fallback, ou acreditar na mágica de fallback de frameworks de terceiros.</p><blockquote>Mas cara… pera! Se eu não posso usar o <strong>WebSockets</strong> pra fazer meus apps, #comofaz?</blockquote><p>Existe uma técnica pra isso, que não é uma API, é uma técnica mesmo, uma maneira de realizar que não depende de browser modernos nem nada disso. Você só vai precisar escolher ferramentas que possam ser utilizadas no servidor ou como um servidor que disponibilizem esse tipo de interação. Essa técnica se chama <strong><em>Polling.</em></strong></p><h3>Polling</h3><p>O conceito por trás da técnica de <strong><em>Polling</em></strong> consiste em manter o cliente atualizado por meio de requisições periódicas ao servidor. Aqui na <a href="http://www.mentisdating.com/"><strong>Mentis</strong></a>, nós tínhamos um produto que foi incialmente desenvolvido dessa maneira. Todas as notificações e chats dos usuários ficavam atualizando de x em x segundos, fazendo com que a experiência do usuário não fosse a das melhores. Mesmo se a gente fizesse com que esses x segundos se tornassem 1 segundo, ainda teríamos que somar esse segundo ao tempo de tráfego das informações na internet, condições de conexão e uma porção de outros fatores externos a nós que resultariam em um número de atraso nada interessante pro cliente final. Além do que, fazer chamadas de 1 em 1 segundo pro servidor iria onerar bastante a banda do usuário final, se ele estivesse em uam conexão 3G, poderia acabar com o tráfego dele.</p><blockquote>E agora? Quem irá nos defender?</blockquote><h3>Euuu!!!! O Long Polling (Colorado)</h3><p>Long Polling é uma extensão da técnica de Polling e ela funciona mais ou menos como pescar: você joga sua isca na água e decide ficar esperando por uns 3 minutos até puxar sua vara, venha peixe ou não. Mas se vier um peixe e morder sua isca em 3 segundos, você puxa sua vara imediatamente. No nosso caso, o peixe são as novas informações, a água é o servidor, o pescador é nossa aplicação e a vara é a requisição. Funciona <strong><em>MESMO</em></strong> dessa forma:</p><ol><li>A aplicação abre uma conexão com o servidor;</li><li>O servidor recebe e segura essa conexão e a segura por x segundos;</li><li>Passaram-se os x segundos e nada aconteceu? Devolve a conexão sem nada;</li><li>Algo aconteceu nesses x segundos? Devolve o que aconteceu pra aplicação.</li></ol><p>Simples, não é?</p><h3>Conclusão</h3><p>Acho que <strong><em>Long Polling</em></strong> é a melhor maneira de desenvolver aplicações realtime hoje. Apesar de que escolher um servidor que possa ser assíncrono e se comunicar com um banco que tenha certas inteligências possa ser uma tarefa árdua, ainda é menos penoso e fornece um aprendizado mais interessante do que simplesmente adicionar uma url de um framework de terceiros e cruzar os dedos pra ver se funciona.</p><p>Valeu, é isso aí! ;)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5aef47d51a45" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Angular.js Application Debug Level]]></title>
            <link>https://medium.com/@gabrielfgularte/angular-js-application-debug-level-6f5d421c7004?source=rss-2416e20eb08e------2</link>
            <guid isPermaLink="false">https://medium.com/p/6f5d421c7004</guid>
            <dc:creator><![CDATA[Gabriel Gularte]]></dc:creator>
            <pubDate>Wed, 30 Jul 2014 18:04:22 GMT</pubDate>
            <atom:updated>2014-09-11T15:33:57.687Z</atom:updated>
            <content:encoded><![CDATA[<p>Bringing the power of debug to the client side</p><p>At <a href="http://www.mentisdating.com/">Mentis</a>, we are full stack developers. That means work with all web technologies to bring to our clients the best experience in our apps.</p><p>While developing webapps and sites, we have to learn new engines, libraries and frameworks of all kind. For Python, (for example) we have <a href="https://www.djangoproject.com/">Django</a>, <a href="http://flask.pocoo.org/">Flask</a> and <a href="http://www.tornadoweb.org/en/stable/">Tornado</a>. So, I love frameworks and these frameworks have something in common that let me debug our applications in a soft way: the Debug Level. With it, I can set a level per application and see specific logs based on these levels and they hierarchy. And this is amazing when we have to find a single error or info.</p><p>So, you’re asking me: ABOUT WHAT ARE YOU TALKING??</p><p>I’m talking about bring the power of debug to the <a href="https://angularjs.org/">Angular Framework</a>. It wouldn’t be very nice if we could set the application level to see or inspect only the logs that we want? Thinking in that, I developed a feature for ngLog (an Angular builtin service ) that makes easy switch the application level.</p><p>So, if you want to see all logs in the application, just set the level to ‘log’. You’ll see $log.log(), $log.info(), $log.warn() and $log.error() messages. But if you’re tracking some error, and in some part of your code you have $log.error(‘some s#it happened’), you can set the level to ‘error’ and you‘ll only see these kind of messages in the console. Warns, infos and log messages will not be displayed.</p><p>This makes easier to maintain and the messages you set will really have some difference between log, info, warn and error.</p><p>Here’s the PR to the Angular repo: <a href="https://github.com/angular/angular.js/pull/8303">https://github.com/angular/angular.js/pull/8303</a></p><p>And my forked repo: <a href="https://github.com/gabrielfgularte/angular.js/tree/debugLevel">https://github.com/gabrielfgularte/angular.js/tree/debugLevel</a></p><p>If you want to contribute, you must. Cheers!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6f5d421c7004" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>