Download juvet - download do código-fonte juvet

juvet

Código-Fonte de IA

1.0.0

Baixar

A estrutura MVC para aplicativos de bate-papo construída em uma plataforma projetada para sistemas de comunicação.

ESTE É UM TRABALHO EM ANDAMENTO E AINDA NÃO ESTÁ PRONTO PARA NADA REAL

DESCRIÇÃO

Crie aplicativos de chat bot para as principais plataformas de aplicativos de chat bot usando padrões familiares de arquitetura model-view-controller que os desenvolvedores usam há décadas.

Juvet é uma estrutura de aplicativo que inclui tudo que você precisa para construir um aplicativo de bate-papo para todas as principais plataformas de mensagens, incluindo:

Folga RTM
API de eventos do Slack
Webhook de entrada do Slack (em breve)
AmazonAlexa
Facebook Mensageiro
SMS de Twillio
Personalizado...

Juvet oferece todos os recursos que você precisa para construir um aplicativo de bate-papo escalável e de fácil manutenção, incluindo

Wrappers de API
Enfileiramento de mensagens
Middleware e plug-ins
Suporte de conversação
Suporte PNL
mais por vir...

O ROADMAP descreve os principais recursos futuros de cada versão.

ESTE QUADRO ESTÁ DISPONÍVEL PARA PATROCÍNIO?

Este repositório está disponível para patrocínio via GitHub Sponsors em https://github.com/sponsors/jwright.

Se você ou sua empresa se beneficiarão de uma estrutura de aplicativo de bate-papo bem mantida e fácil de usar, considere um patrocínio. Seu patrocínio ajudará nesse desenvolvimento.

Obrigado pelo apoio! ?

INSTALAÇÃO

Adicione as dependências Juvet ao seu arquivo mix.exs

# mix.exs

def deps do
  [{:juvet, "~> 0.0.1"}]
end

Instale as dependências

mix deps.get

Certifique-se de que o Juvet seja iniciado antes de sua aplicação

# mix.exs

def application do
  [extra_applications: [:juvet]]
end

USO

Processos Iniciais

Quando o Juvet for iniciado, a aparência da árvore de processos deve ser a seguinte.

                                            +------------------+ +-------------------+|                  |-----| VerEstadoRegistro |
                                         +--| ViewStateManager |     +-------------------+
                                         |  |                  |     +---------------------+
                                         |  +------------------+-----| ViewStateSupervisor |
  +---------------+ +--------------+--+ +------------- ---+ +---------------------+
  |               |    |              |     |                |
  |     Juveta |----|  BotFactory |-----| Superintendente |
  | (aplicativo) |    |              |     |                |
  |               |    +--------------+--+ +----------------+
  +---------------+ |  +-------------------+
                                         |  |                   |
                                         +--| Supervisor de Fábrica |
                                            |                   |
                                            +-------------------+
                                             |                 |
                                             |                 |
                                      +---------------+ +---------------+
                                      |               | |               |
                                      | Supervisor de bots | | Supervisor de bots |
                                      |               | |               |
                                      +---------------+ +---------------+
                                               |                |
                                               |                |
                                            +-----+ +-----+
                                            | Robô |          | Robô |
                                            +-----+ +-----+

Juvet - Aplicativo que inicia o supervisor Juvet.BotFactory
BotFactory – Supervisor que inicia os processos Juvet.Superintendent e Juvet.ViewStateManager .
ViewStateManager - Supervisor que pode gerenciar o armazenamento de qualquer dado arbitrário para um determinado conjunto de chaves. Inicia o Juvet.ViewStateRegistry e um supervisor dinâmico para processos Juvet.ViewState .
ViewStateRegistry - Servidor para atuar como um serviço de registro para converter chaves (como Tuplas) em pids para identificar processos Juvet.ViewState .
Superintendente – O cérebro da operação. O processo verifica a validade da configuração e se estiver configurada corretamente, inicia o processo Juvet.Endpoint e o Juvet.FactorySupervisor
FactorySupervisor - Supervisor de todos os processos Juvet.BotSupervisor .
BotSupervisor - Supervisor de um processo Juvet.Bot bem como de quaisquer processos de suporte adicionais (como Juvet.Receivers.SlackRTMReceiver )
Bot - Recebe mensagens dos provedores de chat. É responsável por processar mensagens e gerar respostas

Configuração

Você precisa informar ao Juvet qual módulo bot deve ser criado quando uma nova conexão for feita. Você pode fazer isso com a seguinte configuração.

# config/config.exs

config :juvet,
  bot: MyBot,
  slack: [
    actions_endpoint: "/slack/actions",
    commands_endpoint: "/slack/commands",
    events_endpoint: "/slack/events",
    options_load_endpoint: "/slack/options"
  ]

Montar roteador

O aplicativo cliente que usa o Juvet pode usar o roteador do seu aplicativo cliente. Você só precisa montar o Juvet.Plug .

Montagem em Fênix

O roteador pode ser montado dentro do endpoint Phoenix apenas adicionando:

# lib/my_phoenix_app_web/endpoint.ex

defmodule MyPhoenixAppWeb.Endpoint do
  use Phoenix.Endpoint, otp_app: :my_phoenix_app

  # ...

  plug Juvet.Plug
end

Folga

Autorizando com seu aplicativo Slack

Atualmente o Juvet não executa nenhuma funcionalidade oauth. Isso acontecerá em breve, então cabe ao seu aplicativo conectá-lo ao Slack via OAuth. Se você estiver usando o ueberauth, o ueberauth_slack é uma boa opção para autorizar seus usuários no Slack.

Depois de obter o token de acesso do bot para sua equipe, você estará pronto para começar.

Conectando-se ao seu aplicativo Slack

Depois de ter um token de acesso de bot para sua equipe, você poderá se conectar ao Slack por meio de:

{:ok, bot} = Juvet.create_bot("MyBot")

Tratamento de eventos do Slack

Você pode lidar com mensagens do Slack substituindo a função handle_event/3 em seu bot. Esta função pode usar correspondência de padrões para lidar com vários eventos do Slack.

defmodule MyBot do
  use Juvet.Bot

  def handle_event(platform, %{type: "message"} = message, state) do
    # Add your logic here on how to handle a message event

    {:ok, state}
  end

  def handle_event(platform, %{type: "file_created"} = message, state) do
    # Add your logic here on how to handle a file_created event

    {:ok, state}
  end
end

Enviando mensagens para o Slack

Você pode enviar mensagens de volta para o Slack a partir do seu bot, substituindo a função send_message/3 no seu bot. O segundo argumento ( state ) deve conter uma chave ( id ) que será usada para enviar a mensagem para a equipe correta.

defmodule MyBot do
  use Juvet.Bot

  def handle_event(platform, %{type: "message", text: "Hello"} = message, %{id: id, channel: channel} = state) do
    send_message(platform, state, %{type: "message", channel: channel, message: "Right back at cha!"})

    {:ok, state}
  end
end

DOCUMENTAÇÃO

Conectando-se a uma plataforma

Recebendo mensagens

Respondendo a mensagens

TESTE

Você pode executar as tarefas com o comando mix padrão:

mix test

Regravando respostas

Você pode regravar as respostas do Slack com o seguinte comando mix:

MIX_ENV=test mix record token:<slack token here> channel:<slack channel id here> text:"<Welcome from Juvet!>" ts:<valid message timestamp here> user:<slack user id here> users:<slack user id here>,<another slack user id here>

Você pode gravar os cassetes para apenas um método adicionando um parâmetro method acima (ou seja, method:chat.update ) e ele apenas regravará esse método.

Você pode criar um token do Slack para qualquer uma de suas equipes visitando a área OAuth & Permissions em seus aplicativos de API do Slack.