evolution_api 1.0.0

data/lib/evolution_api/errors.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module EvolutionApi
+  # Classe base para todos os erros da Evolution API
+  class Error < StandardError
+    attr_reader :response, :status_code, :error_code
+
+    def initialize(message = nil, response = nil, status_code = nil, error_code = nil)
+      super(message)
+      @response = response
+      @status_code = status_code
+      @error_code = error_code
+    end
+  end
+
+  # Erro de autenticação
+  class AuthenticationError < Error
+    def initialize(message = 'Erro de autenticação', response = nil)
+      super(message, response, 401)
+    end
+  end
+
+  # Erro de autorização
+  class AuthorizationError < Error
+    def initialize(message = 'Acesso negado', response = nil)
+      super(message, response, 403)
+    end
+  end
+
+  # Erro de recurso não encontrado
+  class NotFoundError < Error
+    def initialize(message = 'Recurso não encontrado', response = nil)
+      super(message, response, 404)
+    end
+  end
+
+  # Erro de validação
+  class ValidationError < Error
+    attr_reader :errors
+
+    def initialize(message = 'Erro de validação', response = nil, errors = {})
+      super(message, response, 422)
+      @errors = errors
+    end
+  end
+
+  # Erro de rate limit
+  class RateLimitError < Error
+    def initialize(message = 'Limite de requisições excedido', response = nil)
+      super(message, response, 429)
+    end
+  end
+
+  # Erro de servidor
+  class ServerError < Error
+    def initialize(message = 'Erro interno do servidor', response = nil)
+      super(message, response, 500)
+    end
+  end
+
+  # Erro de timeout
+  class TimeoutError < Error
+    def initialize(message = 'Timeout na requisição', response = nil)
+      super(message, response, nil)
+    end
+  end
+
+  # Erro de conexão
+  class ConnectionError < Error
+    def initialize(message = 'Erro de conexão', response = nil)
+      super(message, response, nil)
+    end
+  end
+
+  # Erro de instância não conectada
+  class InstanceNotConnectedError < Error
+    def initialize(instance_name)
+      super("Instância '#{instance_name}' não está conectada", nil, nil, 'INSTANCE_NOT_CONNECTED')
+    end
+  end
+
+  # Erro de QR Code expirado
+  class QRCodeExpiredError < Error
+    def initialize
+      super('QR Code expirado', nil, nil, 'QR_CODE_EXPIRED')
+    end
+  end
+
+  # Erro de número inválido
+  class InvalidNumberError < Error
+    def initialize(number)
+      super("Número '#{number}' é inválido", nil, nil, 'INVALID_NUMBER')
+    end
+  end
+end

data/lib/evolution_api/instance.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module EvolutionApi
+  # Classe para gerenciar instâncias do WhatsApp
+  class Instance
+    attr_reader :name, :client
+
+    def initialize(name, client)
+      @name = name
+      @client = client
+    end
+
+    # Obtém informações da instância
+    def info
+      client.get_instance(name)
+    end
+
+    # Conecta a instância
+    def connect
+      client.connect_instance(name)
+    end
+
+    # Desconecta a instância
+    def disconnect
+      client.disconnect_instance(name)
+    end
+
+    # Remove a instância
+    def delete
+      client.delete_instance(name)
+    end
+
+    # Obtém QR Code para conexão
+    def qr_code
+      client.get_qr_code(name)
+    end
+
+    # Verifica se a instância está conectada
+    def connected?
+      info = self.info
+      info['status'] == 'open'
+    rescue StandardError
+      false
+    end
+
+    # Envia uma mensagem de texto
+    def send_text(number, text, options = {})
+      client.send_text_message(name, number, text, options)
+    end
+
+    # Envia uma mensagem de imagem
+    def send_image(number, image_url, caption = nil, options = {})
+      client.send_image_message(name, number, image_url, caption, options)
+    end
+
+    # Envia uma mensagem de áudio
+    def send_audio(number, audio_url, options = {})
+      client.send_audio_message(name, number, audio_url, options)
+    end
+
+    # Envia uma mensagem de vídeo
+    def send_video(number, video_url, caption = nil, options = {})
+      client.send_video_message(name, number, video_url, caption, options)
+    end
+
+    # Envia um documento
+    def send_document(number, document_url, caption = nil, options = {})
+      client.send_document_message(name, number, document_url, caption, options)
+    end
+
+    # Envia uma localização
+    def send_location(number, latitude, longitude, description = nil)
+      client.send_location_message(name, number, latitude, longitude, description)
+    end
+
+    # Envia um contato
+    def send_contact(number, contact_number, contact_name)
+      client.send_contact_message(name, number, contact_number, contact_name)
+    end
+
+    # Envia uma mensagem com botões
+    def send_button(number, title, description, buttons)
+      client.send_button_message(name, number, title, description, buttons)
+    end
+
+    # Envia uma lista de opções
+    def send_list(number, title, description, sections)
+      client.send_list_message(name, number, title, description, sections)
+    end
+
+    # Obtém chats da instância
+    def chats
+      client.get_chats(name)
+    end
+
+    # Obtém mensagens de um chat
+    def messages(number, options = {})
+      client.get_messages(name, number, options)
+    end
+
+    # Marca mensagens como lidas
+    def mark_as_read(number)
+      client.mark_messages_as_read(name, number)
+    end
+
+    # Arquivar chat
+    def archive_chat(number)
+      client.archive_chat(name, number)
+    end
+
+    # Desarquivar chat
+    def unarchive_chat(number)
+      client.unarchive_chat(name, number)
+    end
+
+    # Deletar chat
+    def delete_chat(number)
+      client.delete_chat(name, number)
+    end
+
+    # Obtém contatos da instância
+    def contacts
+      client.get_contacts(name)
+    end
+
+    # Obtém informações de um contato
+    def contact(number)
+      client.get_contact(name, number)
+    end
+
+    # Verifica se um número existe no WhatsApp
+    def check_number(number)
+      client.check_number(name, number)
+    end
+
+    # Bloqueia um contato
+    def block_contact(number)
+      client.block_contact(name, number)
+    end
+
+    # Desbloqueia um contato
+    def unblock_contact(number)
+      client.unblock_contact(name, number)
+    end
+
+    # Configura webhook
+    def set_webhook(webhook_url, events = nil)
+      client.set_webhook(name, webhook_url, events)
+    end
+
+    # Obtém configuração de webhook
+    def webhook
+      client.get_webhook(name)
+    end
+
+    # Remove webhook
+    def delete_webhook
+      client.delete_webhook(name)
+    end
+  end
+end

data/lib/evolution_api/message.rb

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+module EvolutionApi
+  # Classe para representar mensagens do WhatsApp
+  class Message
+    attr_reader :id, :key, :message, :message_timestamp, :status, :participant, :instance_name
+
+    def initialize(data, instance_name = nil)
+      @id = data['id']
+      @key = data['key']
+      @message = data['message']
+      @message_timestamp = data['messageTimestamp']
+      @status = data['status']
+      @participant = data['participant']
+      @instance_name = instance_name
+    end
+
+    # Verifica se é uma mensagem de texto
+    def text?
+      message&.key?('conversation') || message&.key?('extendedTextMessage')
+    end
+
+    # Obtém o texto da mensagem
+    def text
+      return message['conversation'] if message&.key?('conversation')
+      return message['extendedTextMessage']['text'] if message&.key?('extendedTextMessage')
+
+      nil
+    end
+
+    # Verifica se é uma mensagem de imagem
+    def image?
+      message&.key?('imageMessage')
+    end
+
+    # Obtém informações da imagem
+    def image
+      return nil unless image?
+
+      message['imageMessage']
+    end
+
+    # Verifica se é uma mensagem de áudio
+    def audio?
+      message&.key?('audioMessage')
+    end
+
+    # Obtém informações do áudio
+    def audio
+      return nil unless audio?
+
+      message['audioMessage']
+    end
+
+    # Verifica se é uma mensagem de vídeo
+    def video?
+      message&.key?('videoMessage')
+    end
+
+    # Obtém informações do vídeo
+    def video
+      return nil unless video?
+
+      message['videoMessage']
+    end
+
+    # Verifica se é um documento
+    def document?
+      message&.key?('documentMessage')
+    end
+
+    # Obtém informações do documento
+    def document
+      return nil unless document?
+
+      message['documentMessage']
+    end
+
+    # Verifica se é uma localização
+    def location?
+      message&.key?('locationMessage')
+    end
+
+    # Obtém informações da localização
+    def location
+      return nil unless location?
+
+      message['locationMessage']
+    end
+
+    # Verifica se é um contato
+    def contact?
+      message&.key?('contactMessage')
+    end
+
+    # Obtém informações do contato
+    def contact
+      return nil unless contact?
+
+      message['contactMessage']
+    end
+
+    # Verifica se é uma mensagem de botão
+    def button?
+      message&.key?('buttonsResponseMessage') || message&.key?('buttonMessage')
+    end
+
+    # Obtém informações do botão
+    def button
+      return message['buttonsResponseMessage'] if message&.key?('buttonsResponseMessage')
+      return message['buttonMessage'] if message&.key?('buttonMessage')
+
+      nil
+    end
+
+    # Verifica se é uma lista
+    def list?
+      message&.key?('listResponseMessage') || message&.key?('listMessage')
+    end
+
+    # Obtém informações da lista
+    def list
+      return message['listResponseMessage'] if message&.key?('listResponseMessage')
+      return message['listMessage'] if message&.key?('listMessage')
+
+      nil
+    end
+
+    # Verifica se é uma mensagem de reação
+    def reaction?
+      message&.key?('reactionMessage')
+    end
+
+    # Obtém informações da reação
+    def reaction
+      return nil unless reaction?
+
+      message['reactionMessage']
+    end
+
+    # Verifica se é uma mensagem de sticker
+    def sticker?
+      message&.key?('stickerMessage')
+    end
+
+    # Obtém informações do sticker
+    def sticker
+      return nil unless sticker?
+
+      message['stickerMessage']
+    end
+
+    # Obtém o número do remetente
+    def from
+      key['remoteJid']&.split('@')&.first
+    end
+
+    # Obtém o ID da mensagem
+    def message_id
+      key['id']
+    end
+
+    # Verifica se é uma mensagem de grupo
+    def group?
+      key['remoteJid']&.include?('@g.us')
+    end
+
+    # Verifica se é uma mensagem de broadcast
+    def broadcast?
+      key['remoteJid']&.include?('@broadcast')
+    end
+
+    # Verifica se é uma mensagem privada
+    def private?
+      !group? && !broadcast?
+    end
+
+    # Verifica se a mensagem foi enviada pelo próprio usuário
+    def from_me?
+      key['fromMe'] == true
+    end
+
+    # Obtém o timestamp da mensagem
+    def timestamp
+      Time.at(message_timestamp) if message_timestamp
+    end
+
+    # Verifica se a mensagem foi lida
+    def read?
+      status == 'read'
+    end
+
+    # Verifica se a mensagem foi entregue
+    def delivered?
+      status == 'delivered'
+    end
+
+    # Verifica se a mensagem foi enviada
+    def sent?
+      status == 'sent'
+    end
+
+    # Verifica se a mensagem falhou
+    def failed?
+      status == 'failed'
+    end
+
+    # Obtém o tipo da mensagem
+    def type
+      return 'text' if text?
+      return 'image' if image?
+      return 'audio' if audio?
+      return 'video' if video?
+      return 'document' if document?
+      return 'location' if location?
+      return 'contact' if contact?
+      return 'button' if button?
+      return 'list' if list?
+      return 'reaction' if reaction?
+      return 'sticker' if sticker?
+
+      'unknown'
+    end
+
+    # Converte para hash
+    def to_h
+      {
+        id: id,
+        key: key,
+        message: message,
+        message_timestamp: message_timestamp,
+        status: status,
+        participant: participant,
+        instance_name: instance_name,
+        type: type,
+        from: from,
+        from_me: from_me?,
+        group: group?,
+        timestamp: timestamp,
+        text: text
+      }
+    end
+
+    # Converte para JSON
+    def to_json(*args)
+      to_h.to_json(*args)
+    end
+  end
+end

data/lib/evolution_api/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module EvolutionApi
+  VERSION = '1.0.0'
+end

data/lib/evolution_api/webhook.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module EvolutionApi
+  # Classe para gerenciar webhooks da Evolution API
+  class Webhook
+    attr_reader :url, :events, :instance_name
+
+    def initialize(data, instance_name = nil)
+      @url = data['webhook']
+      @events = data['events'] || []
+      @instance_name = instance_name
+    end
+
+    # Verifica se o webhook está configurado
+    def configured?
+      !url.nil? && !url.empty?
+    end
+
+    # Verifica se um evento específico está habilitado
+    def event_enabled?(event)
+      events.include?(event)
+    end
+
+    # Lista todos os eventos habilitados
+    def enabled_events
+      events.dup
+    end
+
+    # Converte para hash
+    def to_h
+      {
+        url: url,
+        events: events,
+        configured: configured?,
+        instance_name: instance_name
+      }
+    end
+
+    # Converte para JSON
+    def to_json(*args)
+      to_h.to_json(*args)
+    end
+  end
+end

data/lib/evolution_api.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'httparty'
+require 'json'
+require 'dry/configurable'
+require 'dry/validation'
+
+require_relative 'evolution_api/version'
+require_relative 'evolution_api/client'
+require_relative 'evolution_api/instance'
+require_relative 'evolution_api/message'
+require_relative 'evolution_api/chat'
+require_relative 'evolution_api/contact'
+require_relative 'evolution_api/webhook'
+require_relative 'evolution_api/errors'
+
+# Evolution API Ruby Client
+#
+# Uma gem Ruby para consumir facilmente a Evolution API,
+# permitindo integração com WhatsApp através de uma API REST simples e poderosa.
+#
+# @example Configuração básica
+#   EvolutionApi.configure do |config|
+#     config.base_url = "http://localhost:8080"
+#     config.api_key = "sua_api_key_aqui"
+#   end
+#
+# @example Uso básico
+#   client = EvolutionApi::Client.new
+#   instances = client.list_instances
+#   client.send_message("instance_name", "5511999999999", "Olá!")
+#
+# @see https://doc.evolution-api.com/ Evolution API Documentation
+module EvolutionApi
+  extend Dry::Configurable
+
+  # Configurações padrão
+  setting :base_url, default: 'http://localhost:8080'
+  setting :api_key, default: nil
+  setting :timeout, default: 30
+  setting :retry_attempts, default: 3
+  setting :retry_delay, default: 1
+
+  # Configuração de webhooks
+  setting :webhook_url, default: nil
+  setting :webhook_events, default: %w[connection.update message.upsert]
+
+  # Configuração de logs
+  setting :logger, default: nil
+  setting :log_level, default: :info
+
+  # Configuração de cache
+  setting :cache_enabled, default: false
+  setting :cache_ttl, default: 300 # 5 minutos
+
+  class << self
+    # Configura a gem com as opções fornecidas
+    #
+    # @param options [Hash] Opções de configuração
+    # @yield [config] Bloco para configuração
+    # @yieldparam config [Dry::Configurable::Config] Objeto de configuração
+    #
+    # @example
+    #   EvolutionApi.configure do |config|
+    #     config.base_url = "https://api.evolution.com"
+    #     config.api_key = "sua_chave_api"
+    #     config.timeout = 60
+    #   end
+    def configure(options = {})
+      options.each { |key, value| config.public_send("#{key}=", value) }
+      yield config if block_given?
+    end
+
+    # Retorna um novo cliente configurado
+    #
+    # @return [EvolutionApi::Client] Cliente configurado
+    def client
+      @client ||= Client.new
+    end
+
+    # Reseta o cliente (útil para testes)
+    def reset_client!
+      @client = nil
+    end
+  end
+end