apigratis-sdk-ruby 0.0.1

data/lib/api_brasil/services/data/proxies.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require_relative "../base_service"
+require_relative "../device_proxy_service"
+
+module ApiBrasil
+  module Services
+    module Data
+      # Geolocalizacao (device-based): `/geolocation/{action}`.
+      class GeolocationService < DeviceProxyService
+        def initialize(http)
+          super(http, "geolocation")
+        end
+
+        # Converte endereco em coordenadas: `POST /geolocation/geocode`.
+        #
+        # @return [Object]
+        def geocode(body, options = {})
+          request("geocode", body, options)
+        end
+
+        # Geocoding direto: `POST /geolocation/forward-geocoding`.
+        #
+        # @return [Object]
+        def forward_geocoding(body, options = {})
+          request("forward-geocoding", body, options)
+        end
+      end
+
+      # Matriz de distancias (device-based): `/geomatrix/{action}`.
+      class GeomatrixService < DeviceProxyService
+        def initialize(http)
+          super(http, "geomatrix")
+        end
+
+        # Distancia entre pontos: `POST /geomatrix/distance`.
+        #
+        # @return [Object]
+        def distance(body, options = {})
+          request("distance", body, options)
+        end
+      end
+
+      # OCR / Google Vision (device-based): `/recognize/{action}`.
+      class RecognizeService < DeviceProxyService
+        def initialize(http)
+          super(http, "recognize")
+        end
+
+        # Reconhece uma imagem em base64: `POST /recognize/base64`.
+        #
+        # @return [Object]
+        def base64(body, options = {})
+          request("base64", body, options)
+        end
+
+        # Reconhece uma imagem por URL: `POST /recognize/uri`.
+        #
+        # @return [Object]
+        def uri(body, options = {})
+          request("uri", body, options)
+        end
+      end
+
+      # DDD (device-based): `/ddd/{action}`.
+      class DddService < DeviceProxyService
+        def initialize(http)
+          super(http, "ddd")
+        end
+      end
+
+      # Feriados (device-based): `/holidays/{action}`.
+      class HolidaysService < DeviceProxyService
+        def initialize(http)
+          super(http, "holidays")
+        end
+
+        # Lista os feriados: `POST /holidays/feriados`.
+        #
+        # @return [Object]
+        def feriados(body, options = {})
+          request("feriados", body, options)
+        end
+      end
+
+      # Traducao (device-based): `/translate/{action}`.
+      class TranslateService < DeviceProxyService
+        def initialize(http)
+          super(http, "translate")
+        end
+
+        # Identifica o idioma de um texto: `POST /translate/identify`.
+        #
+        # @return [Object]
+        def identify(body, options = {})
+          request("identify", body, options)
+        end
+
+        # Lista os modelos de traducao: `POST /translate/models`.
+        #
+        # @return [Object]
+        def models(body = nil, options = {})
+          request("models", body, options)
+        end
+      end
+
+      # Clima (device-based): `/weather/{action}`.
+      class WeatherService < DeviceProxyService
+        def initialize(http)
+          super(http, "weather")
+        end
+
+        # Clima por cidade: `POST /weather/city`.
+        #
+        # @return [Object]
+        def city(body, options = {})
+          request("city", body, options)
+        end
+
+        # Clima por coordenadas: `POST /weather/coordenates`.
+        #
+        # @return [Object]
+        def coordenates(body, options = {})
+          request("coordenates", body, options)
+        end
+      end
+
+      # Loterias (device-based): `/loterias/{sorteio}/*`.
+      class LoteriasService < BaseService
+        # Resultado de um concurso: `POST /loterias/{sorteio}/{concurso}`.
+        #
+        # @return [Object]
+        def resultado(sorteio, concurso, body = nil, options = {})
+          post("/loterias/#{sorteio}/#{concurso}", body, options)
+        end
+
+        # Ultimo resultado: `POST /loterias/{sorteio}/latest`.
+        #
+        # @return [Object]
+        def latest(sorteio, body = nil, options = {})
+          post("/loterias/#{sorteio}/latest", body, options)
+        end
+      end
+    end
+  end
+end

data/lib/api_brasil/services/data/ura_service.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "../base_service"
+
+module ApiBrasil
+  module Services
+    module Data
+      # URA reversa / ligacoes: `/ura/call/*`.
+      class UraService < BaseService
+        # Disca uma ligacao: `POST /ura/call/dialler`.
+        #
+        # @return [Object]
+        def dialler(body, options = {})
+          post("/ura/call/dialler", body, options)
+        end
+
+        # Consulta status da ligacao: `POST /ura/call/status`.
+        #
+        # @return [Object]
+        def status(body, options = {})
+          post("/ura/call/status", body, options)
+        end
+      end
+    end
+  end
+end

data/lib/api_brasil/services/data/vehicles_service.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "uri"
+
+require_relative "../device_proxy_service"
+
+module ApiBrasil
+  module Services
+    module Data
+      # Veiculos por placa (device-based): `/vehicles/{action}`.
+      class VehiclesService < DeviceProxyService
+        def initialize(http)
+          super(http, "vehicles")
+        end
+
+        # Dados do veiculo pela placa: `POST /vehicles/dados` body `{"placa" => ...}`.
+        #
+        # @return [Object]
+        def dados(body, options = {})
+          request("dados", body, options)
+        end
+
+        # FIPE pela placa: `POST /vehicles/fipe` body `{"placa" => ...}`.
+        #
+        # @return [Object]
+        def fipe(body, options = {})
+          request("fipe", body, options)
+        end
+
+        # Consulta FIPE: `POST /vehicles/consultafipe/{placa}`.
+        #
+        # @return [Object]
+        def consulta_fipe(placa, options = {})
+          request("consultafipe/#{Core::HttpClient.escape_path_segment(placa)}", nil, options)
+        end
+
+        # Base dedicada: `POST /vehicles/base/000/{base}` (`dados` ou `fipe`).
+        #
+        # @return [Object]
+        def base(dataset, body, options = {})
+          post("/vehicles/base/000/#{dataset}", body, options)
+        end
+      end
+    end
+  end
+end

data/lib/api_brasil/services/device_proxy_service.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "base_service"
+
+module ApiBrasil
+  module Services
+    # Base dos servicos "device-based" do gateway (`/api/v2/{servico}/{action}`).
+    # Exigem `Authorization: Bearer` + header `DeviceToken`.
+    #
+    # Todos expoem `request(action, body)` como porta de saida generica - as
+    # actions sao dinamicas por provedor, consulte a documentacao em
+    # https://doc.apibrasil.io
+    #
+    # A resposta segue o envelope device-based
+    # (`{"error" => ..., "message" => ..., "response" => ...}`).
+    class DeviceProxyService < BaseService
+      # @return [String] nome do servico no gateway (primeiro segmento da rota)
+      attr_reader :service
+
+      # @param http [ApiBrasil::Core::HttpClient]
+      # @param service [String]
+      def initialize(http, service)
+        super(http)
+        @service = service
+      end
+
+      # Executa uma action do servico: `POST /{servico}/{action}`.
+      #
+      # @param action [String]
+      # @param body [Hash, nil]
+      # @param options [Hash]
+      # @return [Object]
+      def request(action, body = nil, options = {})
+        post("/#{service}/#{action.to_s.gsub(%r{\A/+|/+\z}, "")}", body, options)
+      end
+
+      # Executa a mesma action de forma assincrona via fila:
+      # `POST /{servico}/{action}/queue`.
+      #
+      # @return [Object]
+      def queue(action, body = nil, options = {})
+        post("/#{service}/#{action.to_s.gsub(%r{\A/+|/+\z}, "")}/queue", body, options)
+      end
+    end
+  end
+end

data/lib/api_brasil/services/messaging/evolution_service.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "../base_service"
+
+module ApiBrasil
+  module Services
+    module Messaging
+      # Evolution API (device-based): `POST /evolution/{controller}/{action}`.
+      # Exige `Authorization: Bearer` + `DeviceToken`.
+      #
+      # Exemplos de controller/action: `instance/create`, `message/sendText`.
+      # Os caminhos documentados estao em
+      # `ApiBrasil::Generated::Catalog::EVOLUTION_PATHS`.
+      class EvolutionService < BaseService
+        # Executa `POST /evolution/{controller}/{action}`.
+        #
+        # @return [Object]
+        def request(controller, action, body = nil, options = {})
+          post("/evolution/#{controller}/#{action}", body, options)
+        end
+
+        # Executa um caminho completo do catalogo: `POST /evolution/{path}`.
+        #
+        # @return [Object]
+        def call(path, body = nil, options = {})
+          post("/evolution/#{path.to_s.sub(%r{\A/+}, "")}", body, options)
+        end
+
+        # Executa a mesma chamada de forma assincrona via fila.
+        #
+        # @return [Object]
+        def queue(controller, action, body = nil, options = {})
+          post("/evolution/#{controller}/#{action}/queue", body, options)
+        end
+      end
+    end
+  end
+end

data/lib/api_brasil/services/messaging/sms_service.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "../device_proxy_service"
+
+module ApiBrasil
+  module Services
+    module Messaging
+      # API de SMS (device-based): `POST /sms/{action}`.
+      # Exige `Authorization: Bearer` + `DeviceToken`.
+      class SmsService < DeviceProxyService
+        def initialize(http)
+          super(http, "sms")
+        end
+
+        # Envia um SMS pelo device: `POST /sms/send`.
+        #
+        # Campos: `number`, `message`, `operator`, `user_reply`, `webhook_url`.
+        #
+        # @return [Object]
+        def send_message(body, options = {})
+          request("send", body, options)
+        end
+
+        # `send` mantem a paridade com as demais SDKs (`api.sms.send(...)`).
+        # `send_message` e o alias idiomatico em Ruby, ja que `Object#send`
+        # tem outro significado na linguagem - `public_send` e `__send__`
+        # continuam disponiveis normalmente.
+        alias send send_message
+
+        # Envia um SMS debitando creditos da conta (sem DeviceToken):
+        # `POST /sms/send/credits`.
+        #
+        # @return [Object]
+        def send_with_credits(body, options = {})
+          post("/sms/send/credits", body, options)
+        end
+      end
+    end
+  end
+end

data/lib/api_brasil/services/messaging/whats_meow_service.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "../base_service"
+
+module ApiBrasil
+  module Services
+    module Messaging
+      # WhatsMeow API (device-based): `POST /whatsmeow/{action}`.
+      # Exige `Authorization: Bearer` + `DeviceToken`.
+      #
+      # As actions documentadas estao em
+      # `ApiBrasil::Generated::Catalog::WHATSMEOW_ACTIONS`.
+      class WhatsMeowService < BaseService
+        # Executa `POST /whatsmeow/{action}`.
+        #
+        # @return [Object]
+        def request(action, body = nil, options = {})
+          post("/whatsmeow/#{action.to_s.sub(%r{\A/+}, "")}", body, options)
+        end
+
+        # Executa a mesma chamada de forma assincrona via fila.
+        #
+        # @return [Object]
+        def queue(action, body = nil, options = {})
+          post("/whatsmeow/#{action.to_s.sub(%r{\A/+}, "")}/queue", body, options)
+        end
+      end
+    end
+  end
+end

data/lib/api_brasil/services/messaging/whatsapp_service.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require_relative "../device_proxy_service"
+
+module ApiBrasil
+  module Services
+    module Messaging
+      # API de WhatsApp (device-based): `POST /whatsapp/{action}`.
+      # Exige `Authorization: Bearer` + `DeviceToken`.
+      #
+      # Alem dos metodos nomeados, `request(action, body)` aceita qualquer
+      # action do catalogo (`ApiBrasil::Generated::Catalog::WHATSAPP_ACTIONS`).
+      class WhatsAppService < DeviceProxyService
+        def initialize(http)
+          super(http, "whatsapp")
+        end
+
+        # Inicia a sessao do device (aceita webhooks opcionais):
+        # `webhook_wh_status`, `webhook_wh_message`, `webhook_wh_connect`,
+        # `webhook_wh_qrcode`.
+        #
+        # @return [Object]
+        def start(body = nil, options = {})
+          request("start", body, options)
+        end
+
+        # Retorna o QR Code de pareamento (`response.qrcode` em base64).
+        #
+        # @return [Object]
+        def qrcode(body = nil, options = {})
+          request("qrcode", body, options)
+        end
+
+        # Encerra a sessao.
+        #
+        # @return [Object]
+        def logout(body = nil, options = {})
+          request("logout", body, options)
+        end
+
+        # Fecha o navegador/sessao no servidor.
+        #
+        # @return [Object]
+        def close(body = nil, options = {})
+          request("close", body, options)
+        end
+
+        # Apaga a sessao no servidor.
+        #
+        # @return [Object]
+        def delete_session(body = nil, options = {})
+          request("deleteSession", body, options)
+        end
+
+        # Status da conexao: `POST /whatsapp/getConnectionStatus`.
+        #
+        # @return [Object]
+        def connection_status(body = nil, options = {})
+          request("getConnectionStatus", body, options)
+        end
+
+        # Envia mensagem de texto: `{"number" => "5511999999999", "text" => "Ola!"}`.
+        #
+        # @return [Object]
+        def send_text(body, options = {})
+          request("sendText", body, options)
+        end
+
+        # Envia arquivo a partir de uma URL: `{"number" => ..., "path" => ...}`.
+        #
+        # @return [Object]
+        def send_file(body, options = {})
+          request("sendFile", body, options)
+        end
+
+        # Envia arquivo em base64.
+        #
+        # @return [Object]
+        def send_file64(body, options = {})
+          request("sendFile64", body, options)
+        end
+
+        # Envia audio (URL; convertido para mp3 pelo gateway, max. 6 min).
+        #
+        # @return [Object]
+        def send_audio(body, options = {})
+          request("sendAudio", body, options)
+        end
+
+        # Envia video a partir de uma URL.
+        #
+        # @return [Object]
+        def send_video(body, options = {})
+          request("sendVideo", body, options)
+        end
+
+        # Envia um link com preview.
+        #
+        # @return [Object]
+        def send_link(body, options = {})
+          request("sendLink", body, options)
+        end
+
+        # Envia uma localizacao: `{"number" => ..., "lat" => ..., "lng" => ...}`.
+        #
+        # @return [Object]
+        def send_location(body, options = {})
+          request("sendLocation", body, options)
+        end
+
+        # Envia um contato.
+        #
+        # @return [Object]
+        def send_contact(body, options = {})
+          request("sendContact", body, options)
+        end
+      end
+    end
+  end
+end

data/lib/api_brasil/services/platform/account_service.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require_relative "../base_service"
+
+module ApiBrasil
+  module Services
+    module Platform
+      # Conta, saldo, faturas, notificacoes e tickets.
+      class AccountService < BaseService
+        # Saldo/creditos da conta: `GET /balance`.
+        #
+        # @return [Object]
+        def balance(options = {})
+          get("/balance", options)
+        end
+
+        # Plano atual: `GET /plan`.
+        #
+        # @return [Object]
+        def plan(options = {})
+          get("/plan", options)
+        end
+
+        # Faturas: `GET /invoices`.
+        #
+        # @return [Object]
+        def invoices(options = {})
+          get("/invoices", options)
+        end
+
+        # Notas fiscais das faturas: `GET /invoices/notes`.
+        #
+        # @return [Object]
+        def invoice_notes(options = {})
+          get("/invoices/notes", options)
+        end
+
+        # Paga uma fatura: `POST /invoices/pay`.
+        #
+        # @return [Object]
+        def pay_invoice(body, options = {})
+          post("/invoices/pay", body, options)
+        end
+
+        # Historico de requisicoes da conta: `POST /requests`.
+        #
+        # @return [Object]
+        def requests(body = nil, options = {})
+          post("/requests", body, options)
+        end
+
+        # Historico de requisicoes por API: `POST /api/requests`.
+        #
+        # @return [Object]
+        def api_requests(body = nil, options = {})
+          post("/api/requests", body, options)
+        end
+
+        # Jobs em fila do usuario: `GET /jobs`.
+        #
+        # @return [Object]
+        def jobs(options = {})
+          get("/jobs", options)
+        end
+
+        # Credenciais do usuario: `GET /credentials`.
+        #
+        # @return [Object]
+        def credentials(options = {})
+          get("/credentials", options)
+        end
+
+        # Indicacoes do usuario: `GET /indications`.
+        #
+        # @return [Object]
+        def indications(options = {})
+          get("/indications", options)
+        end
+
+        # Notificacoes: `GET /notifications`.
+        #
+        # @return [Object]
+        def notifications(options = {})
+          get("/notifications", options)
+        end
+
+        # Marca uma notificacao como lida: `PATCH /notifications/{id}/read`.
+        #
+        # @return [Object]
+        def mark_notification_read(id, options = {})
+          patch("/notifications/#{id}/read", nil, options)
+        end
+
+        # Marca todas as notificacoes como lidas: `POST /notifications/mark-all-read`.
+        #
+        # @return [Object]
+        def mark_all_notifications_read(options = {})
+          post("/notifications/mark-all-read", nil, options)
+        end
+
+        # Tickets de suporte: `GET /tickets`.
+        #
+        # @return [Object]
+        def tickets(options = {})
+          get("/tickets", options)
+        end
+
+        # Abre um ticket: `POST /ticket`.
+        #
+        # @return [Object]
+        def create_ticket(body, options = {})
+          post("/ticket", body, options)
+        end
+
+        # Atualiza um ticket: `PUT /ticket/{id}`.
+        #
+        # @return [Object]
+        def update_ticket(id, body, options = {})
+          put("/ticket/#{id}", body, options)
+        end
+
+        # Mensagens de um ticket: `GET /ticket/{id}/messages`.
+        #
+        # @return [Object]
+        def ticket_messages(id, options = {})
+          get("/ticket/#{id}/messages", options)
+        end
+
+        # Responde um ticket: `POST /ticket/{id}/messages`.
+        #
+        # @return [Object]
+        def add_ticket_message(id, body, options = {})
+          post("/ticket/#{id}/messages", body, options)
+        end
+      end
+    end
+  end
+end