apigratis-sdk-ruby 0.0.1

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

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+require_relative "../base_service"
+
+module ApiBrasil
+  module Services
+    module Platform
+      # Autenticacao e conta (`/auth/*`, `/profile*`, `/password/*`).
+      #
+      # `login` e `verify_2fa` guardam automaticamente o Bearer Token
+      # retornado no cliente, deixando as proximas chamadas autenticadas.
+      class AuthService < BaseService
+        # Autentica com email/senha: `POST /auth/login`.
+        # Se a conta tiver 2FA, retorna `{"requires_2fa" => true, "challenge" => ...}` -
+        # use `send_2fa` + `verify_2fa` para concluir.
+        #
+        # @param body [Hash] `email`, `password`, `turnstile_token`
+        # @return [Object]
+        def login(body, options = {})
+          response = post("/auth/login", body, options)
+          store_token(response)
+          response
+        end
+
+        # Envia o codigo 2FA pelo metodo escolhido: `POST /auth/2fa/send`.
+        #
+        # @param body [Hash] `challenge`, `method` (email|sms|whatsapp|call)
+        # @return [Object]
+        def send_2fa(body, options = {})
+          post("/auth/2fa/send", body, options)
+        end
+
+        # Conclui o login com o codigo 2FA: `POST /auth/login/verify-2fa`.
+        #
+        # @param body [Hash] `challenge`, `code`
+        # @return [Object]
+        def verify_2fa(body, options = {})
+          response = post("/auth/login/verify-2fa", body, options)
+          store_token(response)
+          response
+        end
+
+        # Lista os metodos 2FA ativos da conta: `GET /auth/2fa/methods`.
+        #
+        # @return [Object]
+        def two_factor_methods(options = {})
+          get("/auth/2fa/methods", options)
+        end
+
+        # Cria uma conta: `POST /auth/register`.
+        #
+        # @param body [Hash] `first_name`, `email`, `cellphone`, `password`, `terms_accepted`
+        # @return [Object]
+        def register(body, options = {})
+          post("/auth/register", body, options)
+        end
+
+        # Cadastro simplificado: `POST /auth/register/simple`.
+        #
+        # @return [Object]
+        def register_simple(body, options = {})
+          post("/auth/register/simple", body, options)
+        end
+
+        # Dispara verificacao de email/celular: `POST /auth/verification/send`.
+        #
+        # @param body [Hash] `type` (email|cellphone)
+        # @return [Object]
+        def verification_send(body, options = {})
+          post("/auth/verification/send", body, options)
+        end
+
+        # Confirma o codigo de verificacao: `POST /auth/verification/verify`.
+        #
+        # @param body [Hash] `code`, `type`
+        # @return [Object]
+        def verification_verify(body, options = {})
+          post("/auth/verification/verify", body, options)
+        end
+
+        # Esqueci a senha: `POST /auth/password/forgot`.
+        #
+        # @param body [Hash] `identifier`, `method` (email|sms|whatsapp)
+        # @return [Object]
+        def password_forgot(body, options = {})
+          post("/auth/password/forgot", body, options)
+        end
+
+        # Valida o codigo de recuperacao: `POST /auth/password/verify-code`.
+        #
+        # @param body [Hash] `identifier`, `code`
+        # @return [Object]
+        def password_verify_code(body, options = {})
+          post("/auth/password/verify-code", body, options)
+        end
+
+        # Redefine a senha: `POST /auth/password/reset`.
+        #
+        # @param body [Hash] `reset_token`, `password`, `password_confirmation`
+        # @return [Object]
+        def password_reset(body, options = {})
+          post("/auth/password/reset", body, options)
+        end
+
+        # Reenvia o codigo de recuperacao: `POST /auth/password/resend`.
+        #
+        # @return [Object]
+        def password_resend(body, options = {})
+          post("/auth/password/resend", body, options)
+        end
+
+        # Troca a senha logado: `POST /password/change`.
+        #
+        # @param body [Hash] `current_password`, `password`, `password_confirmation`
+        # @return [Object]
+        def change_password(body, options = {})
+          post("/password/change", body, options)
+        end
+
+        # Perfil completo (com estatisticas): `POST /profile`.
+        #
+        # @return [Object]
+        def profile(options = {})
+          post("/profile", nil, options)
+        end
+
+        # Perfil atual: `GET /profile/me`.
+        #
+        # @return [Object]
+        def me(options = {})
+          get("/profile/me", options)
+        end
+
+        # Atualiza o perfil: `PUT /profile/me`.
+        #
+        # @return [Object]
+        def update_me(body, options = {})
+          put("/profile/me", body, options)
+        end
+
+        # Valida o token atual: `GET /auth/verify`.
+        #
+        # @return [Object]
+        def verify(options = {})
+          get("/auth/verify", options)
+        end
+
+        # Renova o JWT: `POST /refresh`.
+        #
+        # @return [Object]
+        def refresh(options = {})
+          response = post("/refresh", nil, options)
+
+          token = nil
+          if response.is_a?(Hash)
+            authorization = response["authorization"]
+            token = authorization["token"] if authorization.is_a?(Hash)
+            token ||= response["token"]
+          end
+
+          http.bearer_token = token if token.is_a?(String) && !token.empty?
+
+          response
+        end
+
+        # Rotaciona o token: `POST /auth/token/rotate`.
+        #
+        # @return [Object]
+        def token_rotate(options = {})
+          post("/auth/token/rotate", nil, options)
+        end
+
+        # Revoga o token atual: `POST /auth/token/revoke`.
+        #
+        # @return [Object]
+        def token_revoke(options = {})
+          post("/auth/token/revoke", nil, options)
+        end
+
+        # Encerra a sessao: `POST /auth/logout`.
+        #
+        # @return [Object]
+        def logout(options = {})
+          response = post("/auth/logout", nil, options)
+          http.bearer_token = nil
+          response
+        end
+
+        private
+
+        # Guarda o Bearer Token quando a resposta trouxer `authorization.token`.
+        def store_token(response)
+          return unless response.is_a?(Hash)
+
+          authorization = response["authorization"]
+          return unless authorization.is_a?(Hash)
+
+          token = authorization["token"]
+          http.bearer_token = token if token.is_a?(String) && !token.empty?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "../base_service"
+
+module ApiBrasil
+  module Services
+    module Platform
+      # Rate limit por Bearer Token (`/bearer-rate-limit`).
+      #
+      # `get`/`set` seguem os nomes usados nas demais SDKs; por isso as
+      # chamadas internas usam `http.*` diretamente.
+      class BearerRateLimitService < BaseService
+        # Limite atual: `GET /bearer-rate-limit`.
+        #
+        # @return [Object]
+        def get(options = {})
+          http.get("/bearer-rate-limit", options)
+        end
+
+        # Define o limite por minuto: `PUT /bearer-rate-limit`.
+        #
+        # @return [Object]
+        def set(body, options = {})
+          http.put("/bearer-rate-limit", body, options)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require "uri"
+
+require_relative "../base_service"
+
+module ApiBrasil
+  module Services
+    module Platform
+      # Catalogo publico da plataforma: APIs, planos, documentacoes e servidores.
+      # A maioria das rotas e publica (nao exige Bearer Token).
+      class CatalogService < BaseService
+        # Lista/busca APIs disponiveis: `GET /apis?search=`.
+        #
+        # @return [Object]
+        def apis(search = nil, options = {})
+          options = Core::HttpClient.normalize_keys(options)
+          query = search.nil? || search.to_s.empty? ? {} : { "search" => search }
+          options[:query] = query.merge(options[:query] || {})
+
+          get("/apis", options)
+        end
+
+        # Detalha uma API por identificador: `GET /apis/{identifier}`.
+        #
+        # @return [Object]
+        def api(identifier, options = {})
+          get("/apis/#{identifier}", options)
+        end
+
+        # Detalha uma API pelo nome: `GET /apis/name/{name}`.
+        #
+        # @return [Object]
+        def api_by_name(name, options = {})
+          get("/apis/name/#{Core::HttpClient.escape_path_segment(name)}", options)
+        end
+
+        # Categorias de APIs: `GET /apis/categories`.
+        #
+        # @return [Object]
+        def api_categories(options = {})
+          get("/apis/categories", options)
+        end
+
+        # APIs contratadas pelo usuario (autenticado): `GET /apis/list`.
+        #
+        # @return [Object]
+        def my_apis(options = {})
+          get("/apis/list", options)
+        end
+
+        # APIs vinculadas a um device: `GET /apis/device/{device_token}`.
+        #
+        # @return [Object]
+        def apis_by_device(device_token, options = {})
+          get("/apis/device/#{device_token}", options)
+        end
+
+        # Planos disponiveis: `GET /plans`.
+        #
+        # @return [Object]
+        def plans(options = {})
+          get("/plans", options)
+        end
+
+        # Documentacoes: `GET /documentations`.
+        #
+        # @return [Object]
+        def documentations(options = {})
+          get("/documentations", options)
+        end
+
+        # Documentacao por servidor: `GET /documentations/server/{server_search}`.
+        #
+        # @return [Object]
+        def documentations_by_server(server_search, options = {})
+          get("/documentations/server/#{server_search}", options)
+        end
+
+        # Servidores disponiveis: `GET /servers`.
+        #
+        # @return [Object]
+        def servers(options = {})
+          get("/servers", options)
+        end
+
+        # Resolve a URL de uma action (descoberta dinamica de endpoints):
+        # `POST /endpoint/url`.
+        #
+        # @return [Object]
+        def endpoint_url(body, options = {})
+          post("/endpoint/url", body, options)
+        end
+
+        # Body esperado por uma action: `POST /endpoint/body`.
+        #
+        # @return [Object]
+        def endpoint_body(body, options = {})
+          post("/endpoint/body", body, options)
+        end
+
+        # Status do gateway: `GET /status`.
+        #
+        # @return [Object]
+        def status(options = {})
+          get("/status", options)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require_relative "../base_service"
+
+module ApiBrasil
+  module Services
+    module Platform
+      # Gestao de devices (`/devices/*`).
+      #
+      # Devices sao a credencial de consumo dos servicos device-based:
+      # crie um device com a `SecretKey` da API desejada e use o
+      # `device_token` retornado como header `DeviceToken`.
+      class DevicesService < BaseService
+        # Lista os devices do usuario: `GET /devices`.
+        #
+        # @param query [Hash] ex: `{ paginate: true }`
+        # @return [Object]
+        def list(query = {}, options = {})
+          options = Core::HttpClient.normalize_keys(options)
+          options[:query] = query.merge(options[:query] || {})
+
+          get("/devices", options)
+        end
+
+        # Cria um device: `POST /devices/store`.
+        #
+        # A `SecretKey` da API (painel APIBrasil) vai no header - passe em
+        # `options[:secret_key]` ou configure `secret_key` no cliente.
+        #
+        # @param body [Hash] `device_name`, `type`, `device_key`, webhooks...
+        # @return [Object]
+        def store(body, options = {})
+          options = Core::HttpClient.normalize_keys(options)
+          secret = options[:secret_key] || http.secret_key
+          options[:secret_key] = secret unless secret.nil?
+
+          post("/devices/store", body, options)
+        end
+
+        # Detalha um device: `GET /devices/show?search={device_token}`.
+        #
+        # @return [Object]
+        def show(device_token = nil, options = {})
+          options = Core::HttpClient.normalize_keys(options)
+          options[:query] = { "search" => device_token || http.device_token }.merge(options[:query] || {})
+
+          get("/devices/show", options)
+        end
+
+        # Atualiza um device: `POST /devices/update` (body com `device_token` + campos).
+        #
+        # @return [Object]
+        def update(body, options = {})
+          post("/devices/update", body, options)
+        end
+
+        # Remove um device: `DELETE /devices/destroy`.
+        #
+        # @return [Object]
+        def destroy(device_token = nil, options = {})
+          delete("/devices/destroy", { "search" => device_token || http.device_token }, options)
+        end
+
+        # Historico de requisicoes do device: `POST /devices/requests`.
+        #
+        # @return [Object]
+        def requests(body = nil, options = {})
+          post("/devices/requests", body, options)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require_relative "../base_service"
+
+module ApiBrasil
+  module Services
+    module Platform
+      # IP Whitelist da conta (`/ip-whitelist/*`).
+      # Restringe de quais IPs o Bearer Token pode ser usado.
+      #
+      # `get`/`set` seguem os nomes usados nas demais SDKs; por isso as
+      # chamadas internas usam `http.*` diretamente.
+      class IpWhitelistService < BaseService
+        # Configuracao atual: `GET /ip-whitelist`.
+        #
+        # @return [Object]
+        def get(options = {})
+          http.get("/ip-whitelist", options)
+        end
+
+        # Substitui a lista inteira: `PUT /ip-whitelist`.
+        #
+        # @param ip_whitelist [String, Array<String>]
+        # @return [Object]
+        def set(ip_whitelist, options = {})
+          http.put("/ip-whitelist", { "ip_whitelist" => ip_whitelist }, options)
+        end
+
+        # Adiciona uma entrada: `POST /ip-whitelist/add`.
+        #
+        # @return [Object]
+        def add(entry, options = {})
+          http.post("/ip-whitelist/add", { "entry" => entry }, options)
+        end
+
+        # Remove uma entrada: `DELETE /ip-whitelist/remove`.
+        #
+        # @return [Object]
+        def remove(entry, options = {})
+          http.delete("/ip-whitelist/remove", { "entry" => entry }, options)
+        end
+
+        # Adiciona o IP atual: `POST /ip-whitelist/add-current`.
+        #
+        # @return [Object]
+        def add_current(options = {})
+          http.post("/ip-whitelist/add-current", nil, options)
+        end
+
+        # Libera todos os IPs (wildcard): `POST /ip-whitelist/reset`.
+        #
+        # @return [Object]
+        def reset(options = {})
+          http.post("/ip-whitelist/reset", nil, options)
+        end
+
+        # Valida uma entrada: `POST /ip-whitelist/validate`.
+        #
+        # @return [Object]
+        def validate(entry, options = {})
+          http.post("/ip-whitelist/validate", { "entry" => entry }, options)
+        end
+
+        # IP atual visto pelo gateway: `GET /ip-whitelist/current-ip`.
+        #
+        # @return [Object]
+        def current_ip(options = {})
+          http.get("/ip-whitelist/current-ip", options)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require_relative "../base_service"
+
+module ApiBrasil
+  module Services
+    module Platform
+      # Pagamentos e recargas (PIX, boleto e cartao) - `/recharge`,
+      # `/{provider}/pix/*`, `/{provider}/boleto/*`, `/mercadopago/card/*`.
+      class PaymentsService < BaseService
+        # Provedores de pagamento suportados pelo gateway.
+        PROVIDERS = %w[santander inter mercadopago sicoob].freeze
+
+        # Lista as recargas: `GET /recharges`.
+        #
+        # @return [Object]
+        def recharges(options = {})
+          get("/recharges", options)
+        end
+
+        # Cria uma recarga (pix|boleto): `POST /recharge`.
+        #
+        # @param body [Hash] `amount`, `type`
+        # @return [Object]
+        def recharge(body, options = {})
+          post("/recharge", body, options)
+        end
+
+        # Detalha uma recarga: `GET /recharge/{identifier}`.
+        #
+        # @return [Object]
+        def recharge_show(identifier, options = {})
+          get("/recharge/#{identifier}", options)
+        end
+
+        # Gera uma cobranca PIX: `POST /{provider}/pix/generate`.
+        #
+        # @param provider [String] um de `PROVIDERS`
+        # @return [Object]
+        def pix_generate(provider, body, options = {})
+          post("/#{provider}/pix/generate", body, options)
+        end
+
+        # Consulta uma cobranca PIX: `GET /{provider}/pix/{tx_id}`.
+        #
+        # @return [Object]
+        def pix_status(provider, tx_id, options = {})
+          get("/#{provider}/pix/#{tx_id}", options)
+        end
+
+        # Gera um boleto: `POST /{provider}/boleto/generate`.
+        #
+        # @return [Object]
+        def boleto_generate(provider, body, options = {})
+          post("/#{provider}/boleto/generate", body, options)
+        end
+
+        # Consulta um boleto: `GET /{provider}/boleto/{id}`.
+        #
+        # @return [Object]
+        def boleto_status(provider, id, options = {})
+          get("/#{provider}/boleto/#{id}", options)
+        end
+
+        # Baixa o PDF de um boleto: `GET /{provider}/boleto/{id}/pdf`.
+        # Devolve o conteudo binario do arquivo.
+        #
+        # @return [String]
+        def boleto_pdf(provider, id, options = {})
+          get("/#{provider}/boleto/#{id}/pdf", { response_type: "raw" }.merge(options))
+        end
+
+        # Processa pagamento com cartao (Mercado Pago): `POST /mercadopago/card/process`.
+        #
+        # @return [Object]
+        def card_process(body, options = {})
+          post("/mercadopago/card/process", body, options)
+        end
+
+        # Consulta parcelas do cartao: `POST /mercadopago/card/installments`.
+        #
+        # @return [Object]
+        def card_installments(body, options = {})
+          post("/mercadopago/card/installments", body, options)
+        end
+
+        # Consulta um pagamento de cartao: `GET /mercadopago/card/{id}`.
+        #
+        # @return [Object]
+        def card_status(id, options = {})
+          get("/mercadopago/card/#{id}", options)
+        end
+
+        # Metodos de pagamento do checkout: `GET /checkout/payment-methods`.
+        #
+        # @return [Object]
+        def checkout_payment_methods(options = {})
+          get("/checkout/payment-methods", options)
+        end
+
+        # Periodos do checkout: `GET /checkout/periods`.
+        #
+        # @return [Object]
+        def checkout_periods(options = {})
+          get("/checkout/periods", options)
+        end
+
+        # Valida um cupom: `POST /checkout/validate-coupon`.
+        #
+        # @return [Object]
+        def validate_coupon(body, options = {})
+          post("/checkout/validate-coupon", body, options)
+        end
+
+        # Finaliza o checkout: `POST /checkout/finalize`.
+        #
+        # @return [Object]
+        def checkout_finalize(body, options = {})
+          post("/checkout/finalize", body, options)
+        end
+      end
+    end
+  end
+end