Categorias
Tecnologia

Usando grunt-ng-constant para mudar o endereço da API no build de um app AngularJS

Desenvolvendo pela primeira vez um webapp que consome uma API com AngularJS (e usando o Yeoman e o Grunt para fazer build e para autorefresh durante o desenvolvimento) me deparei com uma questão: Como faria o build dos arquivos para diferentes ambientes? Atualmente este projeto possui os ambientes local (dev), homologação e produção, cada um com seu respectivo endereço de API.

Para atingir esse objetivo, e como essa era minha primeira vez com Angular e com Grunt, pesquisei muito e achei uma solução que funcionou bem.

Usango o pacote grunt-ng-constant eu consigo manter uma constante com a URL de cada ambiente separadamente. Dependendo do comando de build que eu executar no Grunt, terei um resultado diferente nessa constante.

O primeiro passo é instalar o pacote citado. Lembrando que estou utilizando o NPM como gerenciador de pacotes.

npm install grunt-ng-constant --save-dev

Depois temos que configurá-lo no nosso arquivo Gruntfile.js. Aqui segue um exemplo comentado:

[gist id=”3fc6625cd09f3a4c280cf7cb7c662f45″ file=”Gruntfile.js”]

Com o Grunt configurado, podemos passar para nosso AngularJS agora.

Dentro do arquivo app.js injetamos o parâmetro ENV no método run e passamos a constante apiBaseURL para o $rootScope, fazendo com que ela fique disponível por todo o app.

[gist id=”3fc6625cd09f3a4c280cf7cb7c662f45″ file=”app.js”]

Agora você pode usar um service que faça as chamadas de API concatenando seu apiBaseUrl em todos os requests. Como no exemplo abaixo.

[gist id=”3fc6625cd09f3a4c280cf7cb7c662f45″ file=”api.js”]

Para finalizar, fazemos o build com o seguinte comando:

grunt build:homolog

Podendo subistituir o homolog por develop ou prod (ou deixar sem nenhum, que pegará o padrão prod que definimos no Grunfile.js) e testar seus arquivos no diretório dist. Lembrando que o arquivo config.js será gerado automaticamente durante o build.

Tive uma boa batalha com o Grunt no começo, mas depois que aprendemos como funciona ele se torna um aliado incrível para o desenvolvimento.

Espero que tenha gostado dessa postagem, se tiver alguma dúvida ou comentário deixe abaixo.

Categorias
Tecnologia

Achando coordenadas de um endereço em Python

Precisei criar um script que encontra as coordenadas de acordo com um dado endereço. Eles vieram de um arquivo Excel com diversos locais registrados.

Para atingir esse objetivo me baseei em um projeto antigo do meu colega Fernando Freitas Alves. Ele já vinha pronto para ler planilhas Excel e buscar coordenadas para cada endereço, o que facilitou muito meu trabalho.

Precisei alterar diversos comportamentos do script e também atualizei a maneira como ele fazia requests, dado que na época em que ele criou o script não se utilizava o requests do python, ele utilizava urllib e simplejson para parsear os resultados dos requests.

Mandei um pull request apenas com a parte de atualização de urllib + simplejson para o requests no projeto dele. 😉

Abaixo segue um Gist com o código parecido com o que tenho utilizado, comentado em cada parte, para melhor compreensão. Utilizando Python 2.7:

[gist id=”d815e7cc6119bbe11f045b4ea26a90e3″ file=”coords.py”]

Meu script trabalha para tentar encontrar as coordenadas de milhares endereços. Como a API do Google Maps tem um limite diário, estou utilizando mais de uma API Key.

Com esses dados eu faço um request no minha API e adiciono no banco de dados. Mas você pode fazer o que quiser com eles agora. =)

Categorias
Tecnologia

Calculando a distância entre dois pontos e ordenando os resultados com GeoDjango

Atualmente tenho trabalhado com Django em um projeto de API que aproveita a geolocalização do usuário para ordenar os dados e mostrar os resultados mais próximos.

Para fazer isso é preciso utilizar um conjunto de ferramentas específicas para geolocalização que o Django possui, que são conhecidos como GeoDjango.

Nesse texto não irei cobrir as instalações e configurações específicas do banco de dados. Mas elas podem ser vistas aqui.

[gist id=”fde02ecf744cfeb8e5db” file=”settings.py”]

Começamos adicionando django.contrib.gis no nosso arquivo settings.py e partimos para os nossos models.

[gist id=”fde02ecf744cfeb8e5db” file=”models-1.py”]

Ao invés de importar os models comuns do Django, importamos os models do django.contrib.gis.db. Nesse caso eu criei um abstract model que vai ser utilizado em todos os outros que necessitarem de endereço e localização.

O campo location vem com um tipo especial, o PointField, que irá guardar os dados de geolocalização do endereço.

No model que extende nosso AddressBaseModel utilizamos o GeoManager para substituir o manager dos models comuns do Django.

[gist id=”fde02ecf744cfeb8e5db” file=”models-2.py”]

Agora podemos ordenar o resultado pela distância de um ponto específico.

Na view vamos utilizar o método distance do queryset para “criar” um campo com o mesmo nome e utilizar o order para ordenar por esse novo campo distance.

Para o método distance, precisamos passar uma origem. Origem será o local que o usuário está nesse caso. Para transformar as strings com a latitude e longitude em um ponto de geolocalização, utilizamos a classe Point do django.contrib.gis.geos.

[gist id=”fde02ecf744cfeb8e5db” file=”views.py”]

Para formatar o resultado eu criei um método get_distance no StuffSerializer. O objetivo dele é mostrar a distância em metros ou quilômetros.

[gist id=”fde02ecf744cfeb8e5db” file=”serializers.py”]

O resultado será algo como o exemplo abaixo.

[gist id=”fde02ecf744cfeb8e5db” file=”result.json”]

Este é um exemplo de como podemos utilizar o GeoDjango para calcular a distância e ordenar os resultados através dela, mas existem diversas outras formas de fazer isso também.

Deixe seu comentário ou dúvida abaixo.

Categorias
Crônicas Tecnologia

Sobre a Python Brasil 2015

Apesar de tantos anos trabalhando com desenvolvimento web e tecnologia eu nunca havia participado de uma conferência de qualquer tecnologia na minha vida. Como no último ano tenho mergulhado 100% no desenvolvimento com a linguagem Python, poucos dias atrás me inscrevi em cima da hora para a PythonBrasil[11].

Tudo começou com os tutoriais gratuitos que aconteceram na FATEC de São José dos Campos, cidade escolhida para a edição 2015 do evento. Diversos tutoriais e workshops sobre os mais diversos usos da linguagem Python e tudo de graça. O único problema era escolher qual eu deveria participar naquele horário, pois muitos aconteciam ao mesmo tempo em salas diferentes.

Na segunda-feira começou a conferência em si, no Novotel de SJC, com Keynotes,Lightning Talks (palestras de 5 minutos de pessoas que se inscrevem na hora para falar sobre algo) e palestras simultâneas divididas em quatro diferentes trilhas: pydata, web, carreira e iniciantes. No caso das trilhas, mais uma vez o “problema” de escolher a qual comparecer em determinado horário.

Neste mesmo dia a noite tivemos um #horaextra em um kart muito próximo do local do evento onde todo mundo se divertiu e teve mais oportunidade para conhecer pessoas incríveis. Jantei na mesma mesa que o David Beazley, que veio de Chicago para dar uma palestra incrível na terça-feira. E o cara é muito gente boa!

Na terça tivemos mais palestras, keynotes e lightning talks. E foi tudo muito legal e construtivo.

A comunidade Python é bastante aberta para novos membros e o pessoal da organização foi extremamente atencioso, apesar da correria que é organizar um evento desse porte.

Como todos com quem conversei me confirmaram, a melhor parte desta comunidade não é só o conhecimento que é compartilhado, mas também as pessoas que fazem parte dela.

Participar dessa conferência foi uma experiência muito boa, então já vou me preparar para o ano que vem, não quero mais perder as próximas PythonBrasil.

Publicado originalmente no LinkedIn Pulse.

Categorias
Tecnologia

Autenticação do Mandrill Webhook com Python Flask

Mandrill é um serviço para disparo de emails transacionais, ele possui relatórios e você pode receber os eventos de cada mensagem (enviado, aberto, click em link, etc) enviada via Webhook.

Procurando uma forma de autenticar o Webhook do Mandrill com Python, o qual eu já havia feito com PHP, eu encontrei esse artigo que mostrava como fazer utilizando o framework Webapp2 e usando uma versão 2.7 do Python. Como eu utilizo Flask com Python 3.4, tive que fazer algumas modificações, mas consegui fazer funcionar.

Segue o trecho de código que estou utilizando:

def calc_mandrill_signature(raw, key):
    import hashlib
    import hmac
    import base64

    digest = hmac.new(key.encode('utf-8'), raw.encode('utf-8'), hashlib.sha1).digest()
    hashed = base64.encodestring(digest).decode("utf-8").rstrip('\n')
    return hashed

def verify_mandrill_signature(request):
    '''
    Mandrill includes an additional HTTP header with webhook POST requests,
        X-Mandrill-Signature, which will contain the signature for the request.
        To verify a webhook request, generate a signature using the same key
        that Mandrill uses and compare that to the value of the
        X-Mandrill-Signature header.
    :return: True if verified valid
    '''
    mandrill_signature = request.headers['X-Mandrill-Signature']
    mandrill_key = 'aqui vai a API key do seu webhook'
    signed_data = request.url
    sorted_key = sorted(request.form)
    for k in sorted_key:
        signed_data += k
        signed_data += request.form[k]
    expected_signature = calc_mandrill_signature(signed_data, mandrill_key)
    return expected_signature == mandrill_signature

@app.route('/webhook', methods=['POST'])
def event_webhook():
    if not verify_mandrill_signature(request):
        abort(403)

    import json
    data = json.loads(request.form['mandrill_events'])

    for e in data:
        '''
        Insira o que você quiser fazer com os resultados dos eventos...
        '''
Categorias
Tecnologia

Estruturando aplicações maiores com o microframework Flask

A principal vantagem de se utilizar um microframework para criar um sistema web é a pouca quantidade de “regras” que se precisa seguir no desenvolvimento. O que quero dizer é que se ganha liberdade para escolher o que e como utilizar as facilidades que o framework provém.

Com o advento da liberdade vem a pergunta: qual é o melhor jeito de fazer?

Como de costume, assim que comecei a utilizar o microframework Flask, escrito em Python, segui diversos tutoriais que encontrei na internet para dar os primeiros passos. Fiz alguns sistemas pequenos para aprender e logo vieram as dúvidas. Pesquisando mais e mais percebi que existem diversas maneiras de se estruturar uma aplicação com ele.

E a lição mais interessante que tirei com tudo isso é que deve-se criar seu próprio jeito de fazer as coisas. De acordo com seu background e com seu conhecimento anterior o desenvolvedor vai naturalmente criando seu “estilo” de estruturar seu código e seus sistemas como um todo.

Criando pequenos sistemas não se tem dificuldades com a estrutura, mas a partir do momento que o sistema cresce a coisa muda de figura. Quase todos os tutoriais estilo “hello world” em Flask tem o mesmo formato: um arquivo único que possui todas as chamadas e roda o sistema, como no exemplo abaixo.

from flask import Flask
app = Flask(__name__)

@app.route('/')
def hello_world():
    return 'Hello World!'

if __name__ == '__main__':
    app.run()

É claro que para criar um sistema mais complexo colocar tudo em um arquivo único é uma péssima ideia. Mas esse tipo de exemplo serve para dar a noção de como o framework é simples.

Mas como estruturar um sistema maior? Nesse caso se cria o arquivo que contém as rotas e suas funções, um arquivo que carrega o aplicativo e um arquivo com o mapeamento do banco de dados. Uma estrutura de diretórios mais ou menos como no exemplo abaixo.

/app
 __init__.py
 models.py
 views.py
/run.py

Até aí tudo bem, ainda se tem uma aplicação bem simples. Adicionamos os diretórios de templates, de arquivos estáticos e o arquivo com as configurações e teremos a estrutura padrão de um sistema simples em Flask.

/app
 /static
 /templates
 __init__.py
 models.py
 views.py
/config.py
/run.py

Ficou um pouquinho mais complexo, mas ainda segue o padrão de tutoriais básicos de utilização do Flask.

Nesse caso, todas as rotas que o sistema terá ficarão em apenas um único arquivo. Pode-se imaginar que isso não é uma boa ideia no caso de sistemas mais complexos, correto?

Basta imaginar a quantidade de linhas que o arquivo views.py pode atingir… a manutenção e o entendimento dele ficarão mais difíceis. Sabe-se que, principalmente para scripts Python, isso não é a melhor opção, pois a ideia é que o código seja simples e legível.

É aí que entram os Blueprints.

Blueprints

Existem diversas formas de utilizar Blueprints no Flask, mas eu basicamente tenho utilizado como aprendi com um vídeo de Miguel Grinberg para a PyCon 2014 (se não me engano): uma forma de separar e modularizar as rotas do aplicativo.

Funciona da seguinte maneira. Em vez de termos um arquivo para todas as rotas do sistema, modularizamos as rotas utilizando arquivos separados e registrando Blueprints para cada um deles.

Em uma tradução livre da documentação do Flask:

Um Blueprint funciona de forma parecida com o objeto de aplicação do Flask, mas não é a mesma coisa. Poderiam ser criadas várias aplicações separadas, mas elas não compartilhariam as mesmas configurações e seriam tratadas na camada WSGI e não na camada do Flask. Já os Blueprints compartilham as mesmas configurações e são uma forma de separar funções dentro da mesma aplicação.

Como eu uso os Blueprints

Para cada módulo que defino no sistema eu crio um arquivo e registro seu Blueprint, como no exemplo abaixo, que simula o arquivo meumodulo.py.

from flask import Blueprint, render_template

meumodulo = Blueprint('meumodulo', __name__, template_folder='templates')

@meumodulo.route('/')
def index(page):
    return render_template('index.html')

Dessa maneira eu crio todas as rotas desse “módulo” específico. Para registrar o Blueprint é preciso adicionar a linha abaixo no arquivo __init__.py, depois de inicializar o objeto app do Flask.

from .meumodulo import meumodulo
app.register_blueprint(meumodulo)

Se quiser que o novo módulo tenha um prefixo para todas as suas rotas, basta adicionar url_prefixao registro do Blueprint.

app.register_blueprint(meumodulo, url_prefix='/modulo')

Já começamos a deixar tudo mais organizado, pelo menos no que diz respeito às rotas. E com isso podemos ter a seguinte estrutura de diretórios.

/app
 /static
 /templates
 __init__.py
 meumodulo.py
 models.py
 outromodulo.py
/config.py
/run.py

Evitando dependências circulares

Para evitar dependências circulares, podemos criar uma função que registre os Blueprints e a chamamos ao final do arquivo __init__.py, como mostra o exemplo abaixo.

def register_blueprints(app):
    from .meumodulo import meumodulo
    from .outromodulo import outromodulo
    app.register_blueprint(meumodulo, url_prefix='/modulo')
    app.register_blueprint(outromodulo, url_prefix='/outromodulo')

register_blueprints(app)

Conclusão

Depois de tudo isso, ainda utilizo uma extensão do Flask chamada Flask-Script para criar um arquivo manager.py no lugar do arquivo run.py. Mas vou explicar melhor sobre isso em uma post futuro.

Essas são apenas algumas dicas que mostram como eu tenho utilizado o microframework Flask para alguns dos meus projetos. Sou relativamente novo com Python e com Flask e por isso tenho certeza de que no futuro terei descoberto novas formas de estruturar os sistemas maiores que farei, mas por enquanto essas são as dicas que tenho para dar para quem se encontra na mesma situação de estudante que eu. Espero poder ter ajudado.

Qualquer dúvida ou sugestão, por favor deixe seu comentário abaixo que responderei sempre que possível.

Atá a próxima.

Categorias
Tecnologia

Summernote, um editor WYSIWYG super simples para Bootstrap

O Summernote é um editor WYSIWYG muito bom, e simples, para utilizar em aplicações web. Pra quem não sabe o que significa WYSIWYG, vejamos o que nos diz a Wikipedia.

WYSIWYG é o acrônimo da expressão em inglês “What You See Is What You Get”, cuja tradução remete a algo como “O que você vê é o que você obtém” (OQVVEOQVO). Significa a capacidade de um programa de computador de permitir que um documento, enquanto manipulado na tela, tenha a mesma aparência de sua utilização (…)

No nosso caso, estamos falando de aplicações web. O Summernote é um dos editores mais simples que já encontrei e sua instalação foi tão fácil que me surpreendi. Até mesmo para personalizar o upload de imagem foi mais simples do que eu imaginava.

Outros editores WYSIWYG para web muito conhecidos, e que eu já utilizei em alguns projetos, são o CKEditor e o TinyMCE. Apesar de suas instalações não serem complicadas, ambos tem muitos arquivos e exigem um conhecimento mais específico para executar qualquer alteração, principalmente no upload de imagens.

Para utilizar o Summernote é preciso jQuery, Bootstrap e Font Awesome (para os ícones). Com as linhas abaixo você consegue essas dependências funcionando na sua aplicação.

<script src="//code.jquery.com/jquery-1.9.1.min.js"></script>
<link href="//netdna.bootstrapcdn.com/bootstrap/3.0.1/css/bootstrap.min.css" rel="stylesheet">
<script src="//netdna.bootstrapcdn.com/bootstrap/3.0.1/js/bootstrap.min.js"></script>
<link href="//netdna.bootstrapcdn.com/font-awesome/4.0.3/css/font-awesome.min.css" rel="stylesheet">

A seguir, basta inserir o CSS e o código JavaScript do Summernote.

<link href="summernote.css" rel="stylesheet">
<script src="summernote.min.js"></script>

Então basta escolher qual é o campo que você deseja transformar em um editor WYSIWYG, adicionar o código de inicialização do Summernote, como no exemplo abaixo, e voilà!

<div id="summernote">Hello Summernote</div>
<script>
$(document).ready(function() {
  $('#summernote').summernote();
});
</script>

Seu campo vai aparecer dessa maneira:

Se você quer personalizar os itens da barra do editor, o tamanho do campo, entre outras coisas, basta ver as features no site do Summernote.

Personalizando o upload de imagens

Ao inserir uma imagem, por padrão, o editor insere os dados da imagem em Base64 ao texto. Mas normalmente não é isso que queremos no nosso código, certo? Então a opção é alterar o padrão para efetuar um upload do arquivo ao ser inserido.

Não vou abordar aqui o script backend por trás do upload, porque isso não tem nada a ver com o editor em questão, vou mostrar apenas como chamamos esse código pelo Summernote.

$(document).ready(function() {
    $('#summernote').summernote({
        onImageUpload: function(files, editor, welEditable) {
            sendFile(files[0],editor,welEditable);
        }
    });
});

function sendFile(file,editor,welEditable) {
    data = new FormData();
    data.append("file", file);
    $.ajax({
        data: data,
        type: "POST",
        url: "url/para/upload/",
        cache: false,
        contentType: false,
        processData: false,
        success: function(url) {
            editor.insertImage(welEditable, url);
        }
    });
}

Primeiro configuramos o callback onImageUpload para chamar nossa função de envio de arquivo. Essa função, a sendFile, cria um novo objeto de formulário pelo javascript e insere o nosso arquivo a ele. Com o método $.ajax do jQuery chamamos nosso script de backend e, mais uma vez, voilà!

Funcionou muito bem pra mim e espero que essas dicas possam ajudar a facilitar a vida de mais pessoas por ai.

Categorias
Tecnologia

Sticky navbar com Bootstrap

Como fixar a barra de navegação do Bootstrap quando a barra de rolagem chegar nela? Essa funcionalidade é chamada de Sticky Navbar.

Utilizando esse código JavaScript abaixo a barra de navegação estática (com a classe .navbar-static-top) passa a ficar fixada no topo da página (classe .navbar-fixed-top) quando a barra de rolagem atinge certa parte da página.

      var num = $('.navbar').offset().top;

      $(window).bind('scroll', function () {
          if ($(window).scrollTop() > num) {
              $('.navbar').addClass('navbar-fixed-top');
              $('.navbar').removeClass('navbar-static-top');
          } else {
              $('.navbar').addClass('navbar-static-top');
              $('.navbar').removeClass('navbar-fixed-top');
          }
      });

A variável num contém a quantidade de pixels do topo até onde a barra de rolagem vai atuar para modificar o estilo da navbar. Neste caso estou utilizando o método offset() do jQuery para verificar a altura da barra de navegação automaticamente.

As classes de navbar descritas acima são originalmente do Bootstrap (testado com o Bootstrap 3.3.2), mas com algumas adaptações pode ser utilizado em qualquer outro CSS, basta alterar os nomes das classes no código.

Esse código foi encontrado nesse JSFiddle e apenas alterei para a utilização do método offset().

Categorias
Tecnologia

Deploy de sistema Flask no Webfaction

Depois de concluir um sistema simples (em Python Flask) para guardar informações em um banco de dados, eu o publiquei no meu servidor para disponibilizar para o usuário final (deploy).

Foi a primeira vez que fiz um deploy de um sistema desenvolvido em Flask (que é um micro framework web em Python que tenho estudado e utilizado ultimamente, como comentei neste texto).

Tenho uma conta no Webfaction e foi lá que fiz o deploy do sistema. O processo foi baseado em uma mistura de alguns tutoriais achados na internet e também de tentativa e erro. Entretanto todos eles eram baseados em Python 2.7 e o Webfaction já disponibilizou o WSGI com Python 3.4. Depois de algumas alterações para suprir isso e mais pesquisa eu consegui colocar o sistema para funcionar.

O deploy foi feito para rodar com virtualenv, como mostra essa referência que encontrei neste link. O que tive mesmo que mudar da referência foi a forma de executar o arquivo Python que ativa o ambiente virtual (activate_this.py). No Python 2.7 utilizamos execfile() para rodar o script que ativa o ambiente (como você pode ver no Step 6 do artigo que referenciei acima) e precisei substituir por exec() do Python 3.4.

Só consegui descobrir que o erro era esse acompanhando os logs do servidor a cada vez que fazia uma mudança no código e executava um restart no Apache. No caso do Webfaction os logs ficam em /home/<seuUsuario>/logs/user/error_<seuApp>.log.

Estou gostando muito de trabalhar com o Python e com o Flask. Desenvolver com este framework é muito ágil e dinâmico. O Flask tem diversas extensões que facilitam a vida do desenvolvedor e ainda assim, por não virem no código-fonte do framework, te deixam a escolha de usar ou esta ou aquela extensão. O que é muito bom, pois dependendo do escopo do projeto podemos precisar ou não de determinadas extensões.

Neste projeto, que comento neste texto, estou utilizando as extensões Flask-Login (controle de acesso), Flask-SQLAlchemy (ORM) e Flask-WTF (para formulários). Em textos futuros falarei um pouco mais sobre as extensões do Flask.

Categorias
Tecnologia

Annyang para reconhecimento de voz

Nos últimos dias do ano passado comecei um projeto de chatbot para praticar Python e Flask, chama-se Jarvis. A ideia é que sempre que eu tiver um tempo livre eu adicione algumas coisinhas a mais nele.

Desde o começo eu gostaria que o Jarvis ajudasse na prática da lingua inglesa, principalmente na conversação. Foi por isso que comecei a pesquisar meios de fazer reconhecimento de voz (speech recognition) pela web.

A opção mais comum é a Speech API do Google, entretanto ela tem algumas limitações por ter um largo uso entre os desenvolvedores. Então fui pesquisar se existia outra opção. Nessa pesquisa encontrei o Annyang, um projeto em javascript para adicionar comandos de voz ao seus aplicativos web.

Ele é muito fácil de aplicar ao site, basta adicionar o script ao html e declarar os comandos de voz que o seu site irá atender.

<script src="//cdnjs.cloudflare.com/ajax/libs/annyang/1.4.0/annyang.min.js"></script>
<script>
    if (annyang) {
        // Let's define our first command. First the text we expect, and then the function it should call
        var commands = {
            'show tps report': function() {
                $('#tpsreport').animate({bottom: '-100px'});
            }
        };

        // Add our commands to annyang
        annyang.addCommands(commands);

        // Start listening. You can call this here, or attach this call to an event, button, etc.
        annyang.start();
    }
</script>

É importante adicionar uma verificação lógica na variável annyang antes de tudo, porque se o navegador não for compatível com o reconhecimento de voz seus comandos serão ignorados e não causarão erro algum. Isso pode ser feito porque no código fonte do Annyang a variável é iniciada como false antes de fazer a verificação de suporte do navegador e caso o mesmo não tenha este suporte, ela continuará falsa.

Caso você queira adicionar um comando que possa receber qualquer palavra depois (uma variável) continua sendo muito simples: basta adicionar um asterisco antes do nome da variável e declará-la como parâmetro na função anônima do comando.

var commands = {
    'tell me *chat' : function(chat) {
        $('#question').val(chat);
        $('#the-form').submit();
    }
}

No exemplo acima mostro como estou usando no projeto Jarvis. Basta o usuário pronunciar ‘tell me‘ e a frase que gostaria de dizer em inglês, então o sistema preenche o campo do formulário com a frase e em seguida executa um submit, fazendo com que o Jarvis responda em seguida.

Caso você queira ver o que está acontecendo enquanto ele tenta reconhecer o que você está dizendo, adicione um annyang.debug(); antes do annyang.start();. Isso fará com que ele apresente no seu console Javascript o que está sendo reconhecido em tempo real. Isso é prático porque ele nem sempre consegue reconhecer e você consegue perceber o que pode estar acontecendo.

Opinião

O Annyang funciona muito bem para aquilo que se propõe, que é o reconhecimento de comandos de voz, entretanto nem sempre ele consegue reconhecer uma frase maior, diferente da Speech API do Google, talvez por problemas com a entonação ou a pronúncia. Ainda não experimentei ele com um microfone melhor, apenas com o do meu notebook, e talvez isso faça uma boa diferença na porcentagem de sucesso. Mas ele é tão fácil de implementar que vale a pena experimentar e se divertir com os comandos de voz.

No caso do Jarvis ele não fica tão prático por causa da necessidade de um comando antes de cada frase e para a prática de conversação isso é um pé no saco, mas mesmo assim vou mantê-lo no projeto por enquanto.

Observação: O Annyang não irá funcionar com arquivos locais (acessando via file:///) pois o navegador (pelo menos o Google Chrome) irá bloquear a tentativa do script de acessar o microfone. É preciso testá-lo com um servidor http.