xendify 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 94231b8a9cae2090e114b0d2867af3c6900d28c5b9b9b81883e00a9d68ce474b
+  data.tar.gz: 41f98577d7a2999e8ade5dda54c7f664a2b098139d299ce230e68161031bec81
+SHA512:
+  metadata.gz: 3e9de0b6116060686415868a3420bef6ab768af64c5823ce51e09f8863160ad6a0b4b167fdeed0d19574b10a1e4cc6e9378a1e70a031463f661f554538ab9d23
+  data.tar.gz: 5ecee006018315e549ead2827ca5bf75ac00ebfde64905a124b382e4d6b274b3ff0d9f90e23a1b1df865bae2b0fb914493c6d50a486afca6dc145ba34a0ef937

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'pry'
+gem "rake", ">= 13.0"
+

data/Gemfile.lock

@@ -0,0 +1,54 @@
+PATH
+  remote: .
+  specs:
+    xend_it (0.1.0)
+      faraday (~> 1.0)
+      faraday_middleware (~> 1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    coderay (1.1.3)
+    faraday (1.10.2)
+      faraday-em_http (~> 1.0)
+      faraday-em_synchrony (~> 1.0)
+      faraday-excon (~> 1.1)
+      faraday-httpclient (~> 1.0)
+      faraday-multipart (~> 1.0)
+      faraday-net_http (~> 1.0)
+      faraday-net_http_persistent (~> 1.0)
+      faraday-patron (~> 1.0)
+      faraday-rack (~> 1.0)
+      faraday-retry (~> 1.0)
+      ruby2_keywords (>= 0.0.4)
+    faraday-em_http (1.0.0)
+    faraday-em_synchrony (1.0.0)
+    faraday-excon (1.1.0)
+    faraday-httpclient (1.0.1)
+    faraday-multipart (1.0.4)
+      multipart-post (~> 2)
+    faraday-net_http (1.0.1)
+    faraday-net_http_persistent (1.2.0)
+    faraday-patron (1.0.0)
+    faraday-rack (1.0.0)
+    faraday-retry (1.0.3)
+    faraday_middleware (1.2.0)
+      faraday (~> 1.0)
+    method_source (1.0.0)
+    multipart-post (2.2.3)
+    pry (0.14.1)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    rake (13.0.6)
+    ruby2_keywords (0.0.5)
+
+PLATFORMS
+  x86_64-darwin-21
+
+DEPENDENCIES
+  pry
+  rake (>= 13.0)
+  xend_it!
+
+BUNDLED WITH
+   2.3.21

data/lib/xendify/api_resource.rb

@@ -0,0 +1,25 @@
+module Xendify
+  class APIResource
+    def initialize(attributes = {})
+      assign_attributes(attributes) if attributes
+    end
+
+    private
+
+    def assign_attributes(new_attributes)
+      error_message = "When assigning attributes, you must pass a hash as an argument, #{new_attributes.class} passed."
+      raise ArgumentError, error_message unless new_attributes.respond_to?(:each_pair)
+      return if new_attributes.empty?
+
+      new_attributes.each do |key, value|
+        assign_attribute(key, value)
+      end
+    end
+
+    # Private: Set attribute with only defined resource attribute
+    def assign_attribute(key, value)
+      setter = :"#{key}="
+      public_send(setter, value) if respond_to?(setter)
+    end
+  end
+end

data/lib/xendify/base.rb

@@ -0,0 +1,29 @@
+module Xendify
+  class Base
+    attr_reader :client
+
+    class << self
+      def model_name
+        name.sub('Api', 'Model')
+      end
+
+      def model_class
+        Object.const_get(model_name)
+      end
+
+      def allowed_methods
+        @allowed_methods ||= []
+      end
+
+      private
+
+      def allow_method(*methods)
+        @allowed_methods = methods
+      end
+    end
+
+    def initialize(client)
+      @client = client
+    end
+  end
+end

data/lib/xendify/client.rb

@@ -0,0 +1,47 @@
+require 'faraday_middleware'
+require 'xendify/middleware'
+require 'xendify/resources/invoice'
+
+module Xendify
+  BASE_URL = 'https://api.xendit.co'.freeze
+
+  class Client
+    def initialize(authorization = nil, options = {})
+      @connection = Faraday.new(url: BASE_URL) do |connection|
+        connection.request :basic_auth, authorization, ''
+        connection.request :json
+        connection.response :json
+
+        # logger = find_logger(options[:logger])
+        # if logger
+          # connection.response :logger, logger, { headers: false, bodies: true } do |log|
+            # filtered_logs = options[:filtered_logs]
+            # if filtered_logs.respond_to?(:each)
+              # filtered_logs.each do |filter|
+                # log.filter(%r{(#{filter}=)([\w+-.?@:/]+)}, '\1[FILTERED]')
+                # log.filter(%r{(#{filter}":")([\w+-.?@:/]+)}, '\1[FILTERED]')
+                # log.filter(%r{(#{filter}":)([\w+-.?@:/]+)}, '\1[FILTERED]')
+              # end
+            # end
+          # end
+        # end
+        connection.use Xendify::Middleware::HandleResponseException
+        connection.adapter Faraday.default_adapter
+      end
+    end
+
+    def get(url, params = nil)
+      response = @connection.get(url, params)
+      response.body
+    end
+
+    def post(url, params)
+      response = @connection.post(url, params)
+      response.body
+    end
+
+    def invoice
+      @invoice ||= Xendify::Invoice.new(self)
+    end
+  end
+end

data/lib/xendify/errors/credit_card.rb

@@ -0,0 +1,46 @@
+module Xendify
+  module Errors
+    module CreditCard
+      class ResponseError < Xendify::Errors::ResponseError; end
+
+      class ChargeError < ResponseError; end
+
+      class CardDeclined < ResponseError
+        def message
+          'The card you are trying to capture has been declined by the issuing bank.'
+        end
+      end
+
+      class ExpiredCard < ResponseError
+        def message
+          'The card you are trying to capture is expired.'
+        end
+      end
+
+      class InsufficientBalance < ResponseError
+        def message
+          'The card you are trying to capture does not have enough balance to complete the capture.'
+        end
+      end
+
+      class StolenCard < ResponseError
+        def message
+          'The card you are trying to capture has been marked as stolen.'
+        end
+      end
+
+      class InactiveCard < ResponseError
+        def message
+          'The card you are trying to capture is inactive.'
+        end
+      end
+
+      class InvalidCvn < ResponseError
+        def message
+          'Invalid CVN number'
+        end
+      end
+    end
+  end
+end
+

data/lib/xendify/errors/disbursement.rb

@@ -0,0 +1,15 @@
+module Xendify
+  module Errors
+    module Disbursement
+      class Error < Xendify::Errors::ResponseError; end
+      class DescriptionNotFound < Error; end
+      class NotEnoughBalance < Error; end
+      class DuplicateTransactionError < Error; end
+      class RecipientAccountNumberError < Error; end
+      class RecipientAmountError < Error; end
+      class MaximumTransferLimitError < Error; end
+      class BankCodeNotSupported < Error; end
+      class DirectDisbursementNotFound < Error; end
+    end
+  end
+end

data/lib/xendify/errors/invoice.rb

@@ -0,0 +1,8 @@
+module Xendify
+  module Errors
+    module Invoice
+      class ResponseError < Xendify::Errors::ResponseError; end
+    end
+  end
+end
+

data/lib/xendify/errors/virtual_account.rb

@@ -0,0 +1,40 @@
+module Xendify
+  module Errors
+    module VirtualAccount
+      class ResponseError < Xendify::Errors::ResponseError; end
+
+      class CallbackNotFound < ResponseError; end
+
+      class BankNotSupported < ResponseError; end
+
+      class ApiValidation < ResponseError; end
+
+      class InvalidJsonFormat < ResponseError; end
+
+      class VirtualAccountNumberOutsideRange < ResponseError; end
+
+      class ExpirationDateNotSupported < ResponseError; end
+
+      class ExpirationInvalid < ResponseError; end
+
+      class SuggestedAmountNotSupported < ResponseError; end
+
+      class ExpectedAmountRequired < ResponseError; end
+
+      class MinimumExpectedAmount < ResponseError; end
+
+      class MaximumExpectedAmount < ResponseError; end
+
+      class CallbackVirtualAccountNameNotAllowed < ResponseError; end
+
+      class DescriptionNotSupported < ResponseError; end
+
+      class RequestForbidden < ResponseError; end
+
+      class ClosedVaNotSupported < ResponseError; end
+
+      class DuplicateCallbackVirtualAccount < ResponseError; end
+    end
+  end
+end
+

data/lib/xendify/errors.rb

@@ -0,0 +1,20 @@
+module Xendify
+  module Errors
+    class ResponseError < StandardError
+      attr_reader :payload
+
+      def initialize(message = nil, payload = nil)
+        @message = message
+        @payload = payload
+        super(@message) unless @message.nil?
+      end
+    end
+
+    class ApiValidation < ResponseError; end
+    class UnknownError < ResponseError; end
+    class ServerError < ResponseError; end
+    class DuplicateError < ResponseError; end
+    class DataNotFound < ResponseError; end
+  end
+end
+

data/lib/xendify/middleware.rb

@@ -0,0 +1,112 @@
+module Xendify
+  module Middleware
+    class HandleResponseException < Faraday::Middleware
+      def call(env)
+        @app.call(env).on_complete do |response|
+          raise Xendify::Errors::ServerError, 'An unexpected error occurred, our team has been notified and will troubleshoot the issue.' if response.status.to_s.start_with?('5')
+
+          validate_response(response.body)
+        end
+      end
+
+      private
+
+      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/AbcSize, Metrics/MethodLength
+      def validate_response(response)
+        return true if response.nil?
+
+        json_response = JSON.parse(response)
+        json_response = json_response.first if json_response.is_a? Array
+
+        return true if json_response.nil?
+        return true if json_response['error_code'].nil?
+
+        error_message = json_response['message']
+
+        case json_response['error_code']
+        when 'USER_DID_NOT_AUTHORIZE_THE_PAYMENT'
+          raise Xendify::Errors::OVO::PaymentTimeout.new(error_message, json_response)
+        when 'DUPLICATE_PAYMENT'
+          raise Xendify::Errors::OVO::DuplicatePayment.new(error_message, json_response)
+        when 'SENDING_TRANSACTION_ERROR'
+          raise Xendify::Errors::OVO::SendingRequest.new(error_message, json_response)
+        when 'USER_DECLINED_THE_TRANSACTION'
+          raise Xendify::Errors::OVO::TransactionDeclined.new(error_message, json_response)
+        when 'PHONE_NUMBER_NOT_REGISTERED'
+          raise Xendify::Errors::OVO::PhoneNumberNotRegistered.new(error_message, json_response)
+        when 'EWALLET_APP_UNREACHABLE'
+          raise Xendify::Errors::OVO::EwalletAppUnreacable.new(error_message, json_response)
+        when 'EXTERNAL_ERROR'
+          raise Xendify::Errors::OVO::ExternalError.new(error_message, json_response)
+        when 'PAYMENT_NOT_FOUND_ERROR'
+          raise Xendify::Errors::OVO::PaymentNotFound.new(error_message, json_response)
+        when 'CHANNEL_NOT_ACTIVATED'
+          raise Xendify::Errors::V1::Ewallet::ChannelNotActivated.new(error_message, json_response)
+        when 'DUPLICATE_ERROR'
+          raise Xendify::Errors::DuplicateError.new(error_message, json_response)
+        when 'DATA_NOT_FOUND'
+          raise Xendify::Errors::DataNotFound.new(error_message, json_response)
+        when 'API_VALIDATION_ERROR'
+          # In this exception with custom the title since, the message from
+          # could returns arrays (see the payload for the full messages)
+          raise Xendify::Errors::ApiValidation.new('Validation error', json_response)
+        when 'CALLBACK_VIRTUAL_ACCOUNT_NOT_FOUND_ERROR'
+          raise Xendify::Errors::VirtualAccount::CallbackNotFound.new(error_message, json_response)
+        when 'BANK_NOT_SUPPORTED_ERROR'
+          raise Xendify::Errors::VirtualAccount::BankNotSupported.new(error_message, json_response)
+        when 'INVALID_JSON_FORMAT'
+          raise Xendify::Errors::VirtualAccount::InvalidJsonFormat.new(error_message, json_response)
+        when 'VIRTUAL_ACCOUNT_NUMBER_OUTSIDE_RANGE'
+          raise Xendify::Errors::VirtualAccount::VirtualAccountNumberOutsideRange.new(error_message, json_response)
+        when 'EXPIRATION_DATE_NOT_SUPPORTED_ERROR'
+          raise Xendify::Errors::VirtualAccount::ExpirationDateNotSupported.new(error_message, json_response)
+        when 'EXPIRATION_DATE_INVALID_ERROR'
+          raise Xendify::Errors::VirtualAccount::ExpirationInvalid.new(error_message, json_response)
+        when 'SUGGESTED_AMOUNT_NOT_SUPPORTED_ERROR'
+          raise Xendify::Errors::VirtualAccount::SuggestedAmountNotSupported.new(error_message, json_response)
+        when 'EXPECTED_AMOUNT_REQUIRED_ERROR'
+          raise Xendify::Errors::VirtualAccount::ExpectedAmountRequired.new(error_message, json_response)
+        when 'CLOSED_VA_NOT_SUPPORTED_ERROR'
+          raise Xendify::Errors::VirtualAccount::ClosedVaNotSupported.new(error_message, json_response)
+        when 'DUPLICATE_CALLBACK_VIRTUAL_ACCOUNT_ERROR'
+          raise Xendify::Errors::VirtualAccount::DuplicateCallbackVirtualAccount.new(error_message, json_response)
+        when 'MAXIMUM_EXPECTED_AMOUNT_ERROR'
+          raise Xendify::Errors::VirtualAccount::MaximumExpectedAmount.new(error_message, json_response)
+        when 'CALLBACK_VIRTUAL_ACCOUNT_NAME_NOT_ALLOWED_ERROR'
+          raise Xendify::Errors::VirtualAccount::CallbackVirtualAccountNameNotAllowed.new(error_message, json_response)
+        when 'DESCRIPTION_NOT_SUPPORTED_ERROR'
+          raise Xendify::Errors::VirtualAccount::DescriptionNotSupported.new(error_message, json_response)
+        when 'MINIMUM_EXPECTED_AMOUNT_ERROR'
+          raise Xendify::Errors::VirtualAccount::MinimumExpectedAmount.new(error_message, json_response)
+        when 'REQUEST_FORBIDDEN_ERROR'
+          raise Xendify::Errors::VirtualAccount::RequestForbidden.new(error_message, json_response)
+        # credit cards
+        when 'INVALID_TOKEN_ID_ERROR'
+          raise Xendify::Errors::CreditCard::ChargeError.new(error_message, json_response)
+        # disbursements
+        when 'DISBURSEMENT_DESCRIPTION_NOT_FOUND_ERROR'
+          raise Xendify::Errors::Disbursement::DescriptionNotFound.new(error_message, json_response)
+        when 'DIRECT_DISBURSEMENT_BALANCE_INSUFFICIENT_ERROR'
+          raise Xendify::Errors::Disbursement::NotEnoughBalance.new(error_message, json_response)
+        when 'DIRECT_DISBURSEMENT_NOT_FOUND_ERROR'
+          raise Xendify::Errors::Disbursement::DirectDisbursementNotFound.new(error_message, json_response)
+        when 'DUPLICATE_TRANSACTION_ERROR'
+          raise Xendify::Errors::Disbursement::DuplicateTransactionError.new(error_message, json_response)
+        when 'RECIPIENT_ACCOUNT_NUMBER_ERROR'
+          raise Xendify::Errors::Disbursement::RecipientAccountNumberError.new(error_message, json_response)
+        when 'RECIPIENT_AMOUNT_ERROR'
+          raise Xendify::Errors::Disbursement::RecipientAmountError.new(error_message, json_response)
+        when 'MAXIMUM_TRANSFER_LIMIT_ERROR'
+          raise Xendify::Errors::Disbursement::MaximumTransferLimitError.new(error_message, json_response)
+        when 'BANK_CODE_NOT_SUPPORTED_ERROR'
+          raise Xendify::Errors::Disbursement::BankCodeNotSupported.new(error_message, json_response)
+        when 'SERVER_ERROR'
+          raise Xendify::Errors::ServerError.new(error_message, json_response)
+        else
+          raise Xendify::Errors::UnknownError.new(error_message, json_response)
+        end
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/AbcSize, Metrics/MethodLength
+    end
+  end
+end

data/lib/xendify/resources/invoice.rb

@@ -0,0 +1,47 @@
+require 'xendify/base'
+require 'xendify/api_resource'
+require 'xendify/resources/invoice'
+require 'pry'
+
+module Xendify
+  POST_PATH = '/v2/invoices'.freeze
+  GET_PATH = '/v2/invoices'.freeze
+
+  class InvoiceModel < APIResource
+    attr_accessor :id,
+                  :user_id,
+                  :external_id,
+                  :status,
+                  :merchant_name,
+                  :merchant_profile_picture_url,
+                  :amount,
+                  :payer_email,
+                  :description,
+                  :invoice_url,
+                  :expiry_date,
+                  :available_banks,
+                  :available_retail_outlets,
+                  :should_exclude_credit_card,
+                  :should_send_email,
+                  :created,
+                  :updated,
+                  :mid_label,
+                  :currency,
+                  :fixed_va,
+                  :items,
+                  :fees
+
+  end
+
+  class Invoice < Base
+    def get(id:)
+      response = client.get("#{GET_PATH}/#{id}")
+      Xendify::InvoiceModel.new(response)
+    end
+
+    def post(params:)
+      response = client.post(POST_PATH, params)
+      Xendify::InvoiceModel.new(response)
+    end
+  end
+end

data/lib/xendify/version.rb

@@ -0,0 +1,3 @@
+module Xendify
+  VERSION = '0.1.0'
+end

data/lib/xendify.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative 'xendify/version'
+require 'xendify/client'
+
+# require errors
+require 'xendify/errors'
+require 'xendify/errors/disbursement'
+require 'xendify/errors/credit_card'
+require 'xendify/errors/virtual_account'
+
+module Xendify
+  class << self
+    attr_accessor :configuration
+  end
+
+  def self.configure
+    self.configuration ||= Configuration.new
+    yield(configuration)
+  end
+
+  class Configuration
+    attr_accessor :logger
+  end
+end

data/xendify.gemspec

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(::File.join(::File.dirname(__FILE__), "lib"))
+
+require "xendify/version"
+
+Gem::Specification.new do |s|
+  s.name        = "xendify"
+  s.version     = Xendify::VERSION
+  s.required_ruby_version = ">= 2.3.0"
+  s.summary     = "Xen wrapper"
+  s.description = "Handle xen API with ease."
+  s.authors     = ["calmhacker"]
+  s.email       = "be@calmhacker.com"
+  ignored = Regexp.union(
+    /\A\.editorconfig/,
+    /\A\.git/,
+    /\A\.rubocop/,
+    /\A\.travis.yml/,
+    /\A\.vscode/,
+    /\Atest/
+  )
+
+  s.files = `git ls-files`.split("\n").reject { |f| ignored.match(f) }
+  s.executables   = `git ls-files -- bin/*`.split("\n")
+                                         .map { |f| ::File.basename(f) }
+  s.require_paths = ["lib"]
+  
+  s.homepage    = "https://rubygems.org/gems/xendit"
+  s.license       = "MIT"
+
+  s.add_dependency 'faraday', '~> 1.0'
+  s.add_dependency 'faraday_middleware', '~> 1.0'
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: xendify
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- calmhacker
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-12-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: faraday_middleware
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Handle xen API with ease.
+email: be@calmhacker.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- lib/xendify.rb
+- lib/xendify/api_resource.rb
+- lib/xendify/base.rb
+- lib/xendify/client.rb
+- lib/xendify/errors.rb
+- lib/xendify/errors/credit_card.rb
+- lib/xendify/errors/disbursement.rb
+- lib/xendify/errors/invoice.rb
+- lib/xendify/errors/virtual_account.rb
+- lib/xendify/middleware.rb
+- lib/xendify/resources/invoice.rb
+- lib/xendify/version.rb
+- xendify.gemspec
+homepage: https://rubygems.org/gems/xendit
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
+summary: Xen wrapper
+test_files: []