openpix-ruby_sdk 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: acb4367e543636c06a58f9b1e54a7461f050f655ee7a1049d658ba49e45307a3
+  data.tar.gz: 2030d59afb88e01194765d2d2ad4283e46d8bbc7a80bb9ce6c3351b2cb11906f
+SHA512:
+  metadata.gz: aeda3c9f14a2fe7261ea5e10cf9d69ab519a422176d4d0b45694fedd3760bbaae4769386f2ee2278a1091aac6a4f491fb0cc141dbbc9f1039e5447fb00b1bf1e
+  data.tar.gz: 7db2b6adb11cf5b3cf00c0f652751b2b6dbaf91b57f027b75e91a76c477430519a5c04078407d1308e2f9098242fd608950c33d0b7976cbc113627e797fbb8bb

data/CHANGELOG.md

@@ -0,0 +1,12 @@
+## [Unreleased]
+
+## 1.0.0 (2023-06-13)
+
+
+### Features
+
+* Trigger CI ([54531e8](https://github.com/Open-Pix/ruby-sdk/commit/54531e83fb3ebf520df077897de0f99488ded6db))
+
+## [0.1.0] - 2023-05-09
+
+- Initial release

data/README.md

@@ -0,0 +1,146 @@
+# OpenPix/Woovi Ruby SDK
+Welcome to the Woovi Ruby SDK! This SDK provides convenient access to the Woovi REST API, allowing you to easily integrate Woovi's REST API into your Ruby applications.
+
+## Documentation
+Documentation for Woovi REST API can be found [here](https://developers.woovi.com/api).
+RDoc documentation for classes included in the gem can be found [here]().
+
+## Installation
+To install this gem using Bundler, add this following line to your `Gemfile`.
+```shell
+gem 'openpix-ruby_sdk', '~> 0.1.0'
+```
+
+To manually install `openpix-ruby_sdk` via Rubygems simply:
+```shell
+gem install openpix-ruby_sdk -v 0.1.0
+```
+
+## Usage
+Main class `openpix/rubysdk/client` is your entrypoint to the endpoints.
+### Authenticating client
+```ruby
+require 'openpix/rubysdk'
+
+# Your AppID from https://app.woovi.com/home/applications/tab/list
+app_id = 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
+
+client = Openpix::RubySdk::Client.new(app_id)
+```
+### Using resources
+`Openpix::RubySdk::Client` has access to all resources available through a accessor method with resource name in plural form   
+E.g: Charge -> client.charges (returns the charge resource class with all available methods)
+```ruby
+# Creating a Charge
+client.charges.init_body(
+  params: {
+    correlation_id: 'my-correlation-id',
+    value: 50000
+  }
+)
+response = client.charges.save
+response.success? # should yield true
+response.resource_response # API response for this resource, example bellow \/
+# {
+#   "status" => "ACTIVE",
+#   "value" => 100,
+#   "comment" => "good",
+#   "correlationID" => "9134e286-6f71-427a-bf00-241681624586",
+#   ... and so on
+# }
+
+# Listing Charges
+# Default skip is 0 and limit is 100
+response = client.charges.fetch(skip: 0, limit: 100) # skip and limit are pagination params, https://developers.woovi.com/api#tag/charge/paths/~1api~1v1~1charge/get
+response.pagination_meta # holds information about pagination, like total, hasNextPage and so on
+response.resource_response # API response for this resource, should be an array
+
+# If next or previous pages available, there is a convenience method to fetch next or previous pages
+# In order to call those methods, you need first to call #fetch or #fetch! to set the pagination params
+# Those methods will preserve any :params sent to #fetch or #fetch! method
+# BE CAREFUL, those methods only have bang! versions because they have a strong dependency on #fetch, handle properly their errors
+client.charges.fetch_next_page!
+client.charges.fetch_previous_page!
+
+# Finding Charge
+response = client.charges.find(id: 'my-charge-id')
+# response has same attributes from save, since it is a single resource response
+
+# Destroying Charge
+response = client.charges.destroy(id: 'my-charge-id')
+response.success? # this operations just returns success
+```
+### Available resources
+The available resources are:
+- Charge (charges)
+- Customer (customers)
+- Payment (payments)
+- Refund (refunds)
+- Subscription (subscriptions)
+- Webhook (webhooks)
+### Handling errors
+All available resource methods have their bang! version, which raises an error whenever something goes wrong so you can properly handle those cases   
+All errors have some helpful message, showing response status and error response from API
+
+Error classes are:   
+**save!** -> `Openpix::RubySdk::Resources::RequestError`   
+**fetch!** -> `Openpix::RubySdk::Resources::RequestError`   
+**fetch_next_page!** -> `Openpix::RubySdk::Resources::RequestError`, `Openpix::RubySdk::Resources::NotFetchedError`, `Openpix::RubySdk::Resources::PageNotDefinedError`   
+**fetch_previous_page!** -> `Openpix::RubySdk::Resources::RequestError`, `Openpix::RubySdk::Resources::NotFetchedError`, `Openpix::RubySdk::Resources::PageNotDefinedError`   
+**find!** -> `Openpix::RubySdk::Resources::RequestError`   
+**destroy!** -> `Openpix::RubySdk::Resources::RequestError`   
+
+For the safe version (without bang!) there will be an `error_response` attribute setted in the API response whenever `success?` is false.
+```ruby
+response = client.customers.save
+
+unless response.success?
+  response.error_response # error response from API
+end
+```
+
+## Contributing
+We welcome contributions to the Woovi Ruby SDK! If you would like to contribute, please follow these steps:
+
+- Fork the repository
+- Create a new branch for your feature or bug fix
+- Write your code and tests
+- Commit your changes and push your branch to GitHub
+- Submit a pull request
+
+Please make sure to adhere to the [code of conduct](#code-of-conduct).
+
+## Code of Conduct
+Our Pledge
+We pledge to make participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+Our Standards
+Examples of behavior that contributes to creating a positive environment include:
+
+Using welcoming and inclusive language
+Being respectful of differing viewpoints and experiences
+Gracefully accepting constructive criticism
+Focusing on what is best for the community
+Showing empathy towards other community members
+Examples of unacceptable behavior by participants include:
+
+The use of sexualized language or imagery and unwelcome sexual attention or advances
+Trolling, insulting/derogatory comments, and personal or political attacks
+Public or private harassment
+Publishing others' private information, such as a physical or electronic address, without explicit permission
+Other conduct which could reasonably be considered inappropriate in a professional setting
+Our Responsibilities
+As project maintainers, we are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
+
+As contributors, you have the responsibility to adhere to these standards and report any instances of unacceptable behavior.
+
+Enforcement
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported to the project team at <developers@woovi.com>. The project team will review and investigate all complaints and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the code of conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
+
+Attribution
+This Code of Conduct is adapted from the Contributor Covenant, version 1.4, available at http://contributor-covenant.org/version/1/4.
+
+## License
+MIT License.

data/lib/openpix/ruby_sdk/api_body_formatter.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'active_support'
+require 'active_support/core_ext/string/inflections'
+
+module Openpix
+  module RubySdk
+    # Helper class to format body params before request
+    class ApiBodyFormatter
+      class << self
+        def format_entity_param(entity)
+          formatted_entity = {}
+
+          entity.each do |attr, value|
+            formatted_entity[transform_id_pattern(attr)] = value
+          end
+
+          remove_empty_values(formatted_entity)
+        end
+
+        def remove_empty_values(entity)
+          entity.compact.reject do |_key, value|
+            value.empty? if value.respond_to?(:empty?)
+          end
+        end
+
+        def transform_id_pattern(attr_key)
+          attr_key.camelize(:lower).gsub('Id', 'ID')
+        end
+      end
+    end
+  end
+end

data/lib/openpix/ruby_sdk/api_response.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Openpix
+  module RubySdk
+    # An Object representing the response from a call to Woovi API
+    class ApiResponse
+      attr_reader :success, :resource_response, :pagination_meta, :error_response, :status
+
+      def initialize(status:, resource_response: nil, error_response: nil, pagination_meta: {})
+        @success = status == 200
+        @status = status
+        @resource_response = resource_response
+        @pagination_meta = pagination_meta
+        @error_response = error_response
+      end
+
+      def success?
+        success
+      end
+    end
+  end
+end

data/lib/openpix/ruby_sdk/client.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'active_support'
+require 'active_support/core_ext/string/inflections'
+
+require 'openpix/ruby_sdk/http_client'
+require 'openpix/ruby_sdk/resources'
+
+module Openpix
+  module RubySdk
+    # Entrypoint class, expect to access resources and other classes just from this class
+    class Client
+      RESOURCES = %w[
+        Charge
+        Customer
+        Payment
+        Refund
+        Subscription
+        Webhook
+      ].freeze
+
+      def initialize(auth_token)
+        @auth_token = auth_token
+
+        init_http_client
+      end
+
+      RESOURCES.each do |resource|
+        pluralized_resource_name = resource.downcase.pluralize
+        define_method pluralized_resource_name do
+          return instance_variable_get("@#{pluralized_resource_name}") if instance_variable_get("@#{pluralized_resource_name}")
+
+          instance_variable_set(
+            "@#{pluralized_resource_name}",
+            "Openpix::RubySdk::Resources::#{resource}".constantize.new(@http_client)
+          )
+        end
+      end
+
+      private
+
+      def init_http_client
+        @http_client = Openpix::RubySdk::HttpClient.instance
+
+        @http_client.initialize_http_client(@auth_token)
+      end
+    end
+  end
+end

data/lib/openpix/ruby_sdk/http_client.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'faraday/httpclient'
+
+module Openpix
+  module RubySdk
+    # Application HTTP Client to make requests, it uses Faraday as the wrapper and defaults to STD Lib client (Net::HTTP)
+    class HttpClient
+      BASE_URL = 'https://api.woovi.com/api'
+      API_VERSION = '/v1'
+
+      @instance = new
+
+      private_class_method :new
+
+      class << self
+        attr_reader :instance
+      end
+
+      def initialize_http_client(auth_token)
+        @http_client = Faraday.new(
+          url: "#{BASE_URL}#{API_VERSION}",
+          headers: {
+            'Authorization' => auth_token
+          }
+        ) do |f|
+          f.request :json
+          f.response :json
+          f.adapter :httpclient
+        end
+      end
+
+      def post(resource, body:, headers: {}, params: {})
+        @http_client.post(resource) do |request|
+          request.params = params
+          request.headers = request.headers.merge(headers)
+          request.body = body
+        end
+      end
+
+      def get(resource, params: {}, headers: {})
+        @http_client.get(resource) do |request|
+          request.params = params
+          request.headers = request.headers.merge(headers)
+        end
+      end
+
+      def delete(resource, headers: {})
+        @http_client.delete(resource) do |request|
+          request.headers = request.headers.merge(headers)
+        end
+      end
+    end
+  end
+end

data/lib/openpix/ruby_sdk/resources/charge.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'openpix/ruby_sdk/resources/resource'
+require 'openpix/ruby_sdk/api_body_formatter'
+
+module Openpix
+  module RubySdk
+    module Resources
+      # Make API operations on Charge resource
+      class Charge < Resource
+        ATTRS = %w[
+          correlation_id
+          value
+          type
+          comment
+          identifier
+          expires_in
+          customer
+          days_for_due_date
+          days_after_due_date
+          interests
+          fines
+          additional_info
+        ].freeze
+
+        attr_accessor(*ATTRS)
+
+        # @param params [Hash] the attributes for creating a Charge
+        # @param rest [Hash] more attributes to be merged at the body, use this only for unsupported fields
+        def init_body(params: {}, rest: {})
+          super(base_attrs: ATTRS, params: params, rest: rest)
+        end
+
+        # attributes used on POST create method
+        def create_attributes
+          ATTRS
+        end
+
+        # URL for this resource
+        def to_url
+          'charge'
+        end
+
+        # Converts its attributes into a hash
+        def to_body
+          body = super
+
+          return body if body['customer'].nil? || body['customer'].empty?
+
+          body['customer'] = Openpix::RubySdk::ApiBodyFormatter.format_entity_param(body['customer'])
+
+          return body if body['customer']['address'].nil? || body['customer']['address'].empty?
+
+          customer_address_parsed = Openpix::RubySdk::ApiBodyFormatter.format_entity_param(body['customer']['address'])
+          body['customer'] = body['customer'].merge({ 'address' => customer_address_parsed })
+
+          body
+        end
+
+        # add a new additional_info
+        # @param key [String] the key
+        # @param value [String] the value
+        def add_additional_info(key, value)
+          @additional_info = [] if @additional_info.nil?
+
+          @additional_info << { 'key' => key, 'value' => value }
+        end
+
+        # set interests configuration for creating this resource
+        # @param value [Number] value in basis points of interests to be applied daily after the charge hits the deadline
+        def set_interests(value)
+          @interests = { 'value' => value }
+        end
+
+        # set fines configuration for creating this resource
+        # @param value [Number] value in basis points of fines to be applied when the charge hits the deadline
+        def set_fines(value)
+          @fines = { 'value' => value }
+        end
+      end
+    end
+  end
+end

data/lib/openpix/ruby_sdk/resources/customer.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'openpix/ruby_sdk/resources/resource'
+require 'openpix/ruby_sdk/api_body_formatter'
+
+module Openpix
+  module RubySdk
+    module Resources
+      # Make API operations on Customer resource
+      class Customer < Resource
+        ATTRS = %w[
+          name
+          email
+          phone
+          tax_id
+          correlation_id
+          address
+        ].freeze
+
+        attr_accessor(*ATTRS)
+
+        # @param params [Hash{String => String, Number, Hash{String, Number}, Array<Hash{String, String}>}] the attributes for creating a Charge
+        # @param rest [Hash] more attributes to be merged at the body, use this only for unsupported fields
+        def init_body(params: {}, rest: {})
+          super(base_attrs: ATTRS, params: params, rest: rest)
+        end
+
+        def create_attributes
+          ATTRS
+        end
+
+        def to_url
+          'customer'
+        end
+
+        def to_body
+          body = super
+
+          return body if body['address'].nil? || body['address'].empty?
+
+          body['address'] = Openpix::RubySdk::ApiBodyFormatter.format_entity_param(body['address'])
+
+          body
+        end
+
+        # rubocop:disable Lint/UnusedMethodArgument
+        def destroy(id:)
+          raise(
+            ActionNotImplementedError,
+            'customer does not implement DELETE action'
+          )
+        end
+
+        def destroy!(id:)
+          raise(
+            ActionNotImplementedError,
+            'customer does not implement DELETE action'
+          )
+        end
+        # rubocop:enable Lint/UnusedMethodArgument
+      end
+    end
+  end
+end

data/lib/openpix/ruby_sdk/resources/payment.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'active_support'
+require 'active_support/core_ext/hash/except'
+
+require 'openpix/ruby_sdk/resources/resource'
+
+module Openpix
+  module RubySdk
+    module Resources
+      # Make API operations on Payment resource
+      class Payment < Resource
+        ATTRS = %w[
+          value
+          destination_alias
+          correlation_id
+          comment
+          source_account_id
+        ].freeze
+
+        attr_accessor(*ATTRS)
+
+        # @param params [Hash{String => String, Number, Hash{String, Number}, Array<Hash{String, String}>}] the attributes for creating a Charge
+        # @param rest [Hash] more attributes to be merged at the body, use this only for unsupported fields
+        def init_body(params: {}, rest: {})
+          super(base_attrs: ATTRS, params: params, rest: rest)
+        end
+
+        def create_attributes
+          ATTRS
+        end
+
+        def to_url
+          'payment'
+        end
+
+        def to_body
+          body = super
+
+          return body unless body['sourceAccountID']
+
+          body['sourceAccountId'] = body['sourceAccountID']
+
+          body.except('sourceAccountID')
+        end
+
+        # rubocop:disable Lint/UnusedMethodArgument
+        def destroy(id:)
+          raise(
+            ActionNotImplementedError,
+            'payment does not implement DELETE action'
+          )
+        end
+
+        def destroy!(id:)
+          raise(
+            ActionNotImplementedError,
+            'payment does not implement DELETE action'
+          )
+        end
+        # rubocop:enable Lint/UnusedMethodArgument
+      end
+    end
+  end
+end

data/lib/openpix/ruby_sdk/resources/refund.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'active_support'
+require 'active_support/core_ext/hash/except'
+
+require 'openpix/ruby_sdk/resources/resource'
+
+module Openpix
+  module RubySdk
+    module Resources
+      # Make API operations on Refund resource
+      class Refund < Resource
+        ATTRS = %w[
+          value
+          transaction_end_to_end_id
+          correlation_id
+          comment
+        ].freeze
+
+        attr_accessor(*ATTRS)
+
+        # @param params [Hash{String => String, Number, Hash{String, Number}, Array<Hash{String, String}>}] the attributes for creating a Charge
+        # @param rest [Hash] more attributes to be merged at the body, use this only for unsupported fields
+        def init_body(params: {}, rest: {})
+          super(base_attrs: ATTRS, params: params, rest: rest)
+        end
+
+        def create_attributes
+          ATTRS
+        end
+
+        def to_url
+          'refund'
+        end
+
+        def to_body
+          body = super
+
+          return body unless body['transactionEndToEndID']
+
+          body['transactionEndToEndId'] = body['transactionEndToEndID']
+
+          body.except('transactionEndToEndID')
+        end
+
+        # rubocop:disable Lint/UnusedMethodArgument
+        def destroy(id:)
+          raise(
+            ActionNotImplementedError,
+            'refund does not implement DELETE action'
+          )
+        end
+
+        def destroy!(id:)
+          raise(
+            ActionNotImplementedError,
+            'refund does not implement DELETE action'
+          )
+        end
+        # rubocop:enable Lint/UnusedMethodArgument
+      end
+    end
+  end
+end

data/lib/openpix/ruby_sdk/resources/resource.rb

@@ -0,0 +1,303 @@
+# frozen_string_literal: true
+
+require 'active_support'
+require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/hash/indifferent_access'
+
+require 'openpix/ruby_sdk/api_response'
+require 'openpix/ruby_sdk/api_body_formatter'
+
+module Openpix
+  module RubySdk
+    module Resources
+      # Error returned when the required method is not implemented in the class child class
+      class NotImplementedError < StandardError
+        def initialize(msg: nil, method: 'nil')
+          super(msg) if msg.present?
+
+          super("#{method} not implemented")
+        end
+      end
+
+      # Error raised when there is a status != from 200 from the API response
+      # This is just raised in methods that calls the bang (with exclamation mark "!") version
+      class RequestError < StandardError
+      end
+
+      # Error raised when client is trying to fetch next/previous page without fetching without pagination first
+      class NotFetchedError < StandardError
+      end
+
+      # Error raised when client is trying to fetch next/previous page and page does not exists
+      class PageNotDefinedError < StandardError
+      end
+
+      # Error raised when client is trying to use a Restful action that is not implemented in the current resource
+      class ActionNotImplementedError < StandardError
+      end
+
+      # Base class for resources from the API
+      class Resource
+        def initialize(http_client)
+          @http_client = http_client
+        end
+
+        def init_body(base_attrs: [], params: {}, rest: {})
+          params = params.with_indifferent_access
+          base_attrs.each { |attr| instance_variable_set("@#{attr}", params[attr]) }
+          @rest = rest
+
+          self
+        end
+
+        def to_url
+          raise NotImplementedError.new(method: __method__)
+        end
+
+        def to_single_resource
+          to_url
+        end
+
+        def create_attributes
+          raise NotImplementedError.new(method: __method__)
+        end
+
+        def to_body
+          body = {}
+
+          create_attributes.each do |attr|
+            body[Openpix::RubySdk::ApiBodyFormatter.transform_id_pattern(attr)] = send(attr)
+          end
+
+          compacted_body = Openpix::RubySdk::ApiBodyFormatter.remove_empty_values(body)
+
+          return compacted_body unless @rest
+
+          compacted_body.merge(@rest)
+        end
+
+        def save(extra_headers: {}, return_existing: false)
+          response = post_request(extra_headers, return_existing)
+
+          Openpix::RubySdk::ApiResponse.new(
+            status: response.status,
+            resource_response: response.body[to_single_resource],
+            error_response: response.body['error']
+          )
+        end
+
+        def save!(extra_headers: {}, return_existing: false)
+          response = post_request(extra_headers, return_existing)
+
+          if response.status != 200
+            raise(
+              RequestError,
+              "Error while saving, API response: #{response.body['error']}, status: #{response.status}"
+            )
+          end
+
+          Openpix::RubySdk::ApiResponse.new(
+            status: response.status,
+            resource_response: response.body[to_single_resource]
+          )
+        end
+
+        def fetch(skip: nil, limit: nil, extra_headers: {}, params: {})
+          set_pagination(skip, limit)
+
+          response = get_request(extra_headers: extra_headers, params: @pagination_params.merge(params))
+
+          @fetched = response.status == 200
+
+          set_pagination_meta(response.body['pageInfo']) if @fetched
+          @last_fetched_params = params if @fetched && !params.empty?
+
+          Openpix::RubySdk::ApiResponse.new(
+            status: response.status,
+            resource_response: response.body[to_url.pluralize],
+            pagination_meta: response.body['pageInfo'],
+            error_response: response.body['error']
+          )
+        end
+
+        def fetch!(skip: nil, limit: nil, extra_headers: {}, params: {})
+          set_pagination(skip, limit)
+
+          response = get_request(extra_headers: extra_headers, params: @pagination_params.merge(params))
+
+          if response.status != 200
+            raise(
+              RequestError,
+              "Error while fetching, API response: #{response.body['error']}, status: #{response.status}"
+            )
+          end
+
+          @fetched = true
+          @last_fetched_params = params unless params.empty?
+          set_pagination_meta(response.body['pageInfo'])
+
+          Openpix::RubySdk::ApiResponse.new(
+            status: response.status,
+            pagination_meta: response.body['pageInfo'],
+            resource_response: response.body[to_url.pluralize]
+          )
+        end
+
+        def fetch_next_page!(extra_headers: {})
+          fetch_page!(:next, extra_headers)
+        end
+
+        def fetch_previous_page!(extra_headers: {})
+          fetch_page!(:previous, extra_headers)
+        end
+
+        def find(id:, extra_headers: {})
+          response = get_request(url: encoded_url(id), extra_headers: extra_headers)
+
+          Openpix::RubySdk::ApiResponse.new(
+            status: response.status,
+            resource_response: response.body[to_single_resource],
+            error_response: response.body['error']
+          )
+        end
+
+        def find!(id:, extra_headers: {})
+          response = get_request(url: encoded_url(id), extra_headers: extra_headers)
+
+          if response.status != 200
+            raise(
+              RequestError,
+              "Error while getting #{to_single_resource} of id = #{id}, API response: #{response.body['error']}, status: #{response.status}"
+            )
+          end
+
+          Openpix::RubySdk::ApiResponse.new(
+            status: response.status,
+            resource_response: response.body[to_single_resource]
+          )
+        end
+
+        def destroy(id:, extra_headers: {})
+          response = delete_request(url: encoded_url(id), extra_headers: extra_headers)
+
+          Openpix::RubySdk::ApiResponse.new(
+            status: response.status,
+            error_response: response.body['error']
+          )
+        end
+
+        def destroy!(id:, extra_headers: {})
+          response = delete_request(url: encoded_url(id), extra_headers: extra_headers)
+
+          if response.status != 200
+            raise(
+              RequestError,
+              "Error while deleting #{to_url} of id = #{id}, API response: #{response.body['error']}, status: #{response.status}"
+            )
+          end
+
+          Openpix::RubySdk::ApiResponse.new(
+            status: response.status
+          )
+        end
+
+        private
+
+        def post_request(extra_headers, return_existing)
+          @http_client.post(
+            to_url,
+            body: to_body,
+            headers: extra_headers,
+            params: { return_existing: return_existing }
+          )
+        end
+
+        def get_request(url: to_url, extra_headers: {}, params: {})
+          @http_client.get(
+            url,
+            headers: extra_headers,
+            params: params
+          )
+        end
+
+        def delete_request(url: to_url, extra_headers: {})
+          @http_client.delete(
+            url,
+            headers: extra_headers
+          )
+        end
+
+        def set_pagination(skip, limit)
+          @pagination_params = { skip: 0, limit: 100 } if @pagination_params.nil?
+          @pagination_params[:skip] = 0 if @pagination_params[:skip].nil?
+          @pagination_params[:limit] = 100 if @pagination_params[:limit].nil?
+
+          @pagination_params[:skip] = skip if skip
+
+          return unless limit
+
+          @pagination_params[:limit] = limit
+        end
+
+        def set_pagination_meta(pagination_meta)
+          @pagination_meta = {
+            total_count: pagination_meta['totalCount'],
+            has_previous_page: pagination_meta['hasPreviousPage'],
+            has_next_page: pagination_meta['hasNextPage']
+          }
+        end
+
+        def calculate_pagination_params(page_orientation)
+          if page_orientation == :next
+            @pagination_params[:skip] += @pagination_params[:limit]
+          elsif page_orientation == :previous
+            @pagination_params[:skip] -= @pagination_params[:limit]
+          end
+        end
+
+        def fetch_page!(page_orientation, extra_headers = {})
+          unless @fetched
+            raise(
+              NotFetchedError,
+              "#fetch needs to be called before trying to fetch #{page_orientation} page"
+            )
+          end
+
+          unless @pagination_meta["has_#{page_orientation}_page".to_sym]
+            raise(
+              PageNotDefinedError,
+              "There is no #{page_orientation} page defined for the skip: #{@pagination_params[:skip]} and " \
+              "limit: #{@pagination_params[:limit]} params requested"
+            )
+          end
+
+          calculate_pagination_params(page_orientation)
+          request_params = if @last_fetched_params.nil?
+                             @pagination_params
+                           else
+                             @pagination_params.merge(@last_fetched_params)
+                           end
+          response = get_request(extra_headers: extra_headers, params: request_params)
+
+          if response.status != 200
+            raise(
+              RequestError,
+              "Error while fetching #{page_orientation} page, API response: #{response.body['error']}, status: #{response.status}"
+            )
+          end
+
+          set_pagination_meta(response.body['pageInfo'])
+          Openpix::RubySdk::ApiResponse.new(
+            status: response.status,
+            pagination_meta: response.body['pageInfo'],
+            resource_response: response.body[to_url.pluralize]
+          )
+        end
+
+        def encoded_url(id)
+          "#{to_url}/#{URI.encode_www_form_component(id)}"
+        end
+      end
+    end
+  end
+end

data/lib/openpix/ruby_sdk/resources/subscription.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'openpix/ruby_sdk/resources/resource'
+require 'openpix/ruby_sdk/api_body_formatter'
+
+module Openpix
+  module RubySdk
+    module Resources
+      # Make API operations on Subscription resource
+      class Subscription < Resource
+        ATTRS = %w[
+          value
+          day_generate_charge
+          customer
+        ].freeze
+
+        attr_accessor(*ATTRS)
+
+        # @param params [Hash{String => String, Number, Hash{String, Number}, Array<Hash{String, String}>}] the attributes for creating a Charge
+        # @param rest [Hash] more attributes to be merged at the body, use this only for unsupported fields
+        def init_body(params: {}, rest: {})
+          super(base_attrs: ATTRS, params: params, rest: rest)
+        end
+
+        def create_attributes
+          ATTRS
+        end
+
+        def to_url
+          'subscriptions'
+        end
+
+        def to_single_resource
+          'subscription'
+        end
+
+        def to_body
+          body = super
+
+          return body if body['customer'].nil? || body['customer'].empty?
+
+          body['customer'] = Openpix::RubySdk::ApiBodyFormatter.format_entity_param(body['customer'])
+
+          body
+        end
+
+        # rubocop:disable Lint/UnusedMethodArgument
+        def fetch(skip: nil, limit: nil, extra_headers: {})
+          raise(
+            ActionNotImplementedError,
+            'subscription does not implement GET index action'
+          )
+        end
+
+        def fetch!(skip: nil, limit: nil, extra_headers: {})
+          raise(
+            ActionNotImplementedError,
+            'subscription does not implement GET index action'
+          )
+        end
+
+        def fetch_next_page!(extra_headers: {})
+          raise(
+            ActionNotImplementedError,
+            'subscription does not implement GET index action'
+          )
+        end
+
+        def fetch_previous_page!(extra_headers: {})
+          raise(
+            ActionNotImplementedError,
+            'subscription does not implement GET index action'
+          )
+        end
+
+        def destroy(id:)
+          raise(
+            ActionNotImplementedError,
+            'subscription does not implement DELETE action'
+          )
+        end
+
+        def destroy!(id:)
+          raise(
+            ActionNotImplementedError,
+            'subscription does not implement DELETE action'
+          )
+        end
+        # rubocop:enable Lint/UnusedMethodArgument
+      end
+    end
+  end
+end

data/lib/openpix/ruby_sdk/resources/webhook.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'openpix/ruby_sdk/resources/resource'
+
+module Openpix
+  module RubySdk
+    module Resources
+      # Make API operations on Webhook resource
+      class Webhook < Resource
+        ATTRS = %w[
+          name
+          event
+          url
+          authorization
+          is_active
+        ].freeze
+
+        attr_accessor(*ATTRS)
+
+        # @param params [Hash{String => String, Number, Hash{String, Number}, Array<Hash{String, String}>}] the attributes for creating a Charge
+        # @param rest [Hash] more attributes to be merged at the body, use this only for unsupported fields
+        def init_body(params: {}, rest: {})
+          super(base_attrs: ATTRS, params: params, rest: rest)
+        end
+
+        def create_attributes
+          ATTRS
+        end
+
+        def to_url
+          'webhook'
+        end
+
+        def to_body
+          body = super
+
+          { webhook: body }
+        end
+
+        # rubocop:disable Lint/UnusedMethodArgument
+        def find(id:, extra_headers: {})
+          raise(
+            ActionNotImplementedError,
+            'webhook does not implement GET show action'
+          )
+        end
+
+        def find!(id:, extra_headers: {})
+          raise(
+            ActionNotImplementedError,
+            'webhook does not implement GET show action'
+          )
+        end
+        # rubocop:enable Lint/UnusedMethodArgument
+      end
+    end
+  end
+end

data/lib/openpix/ruby_sdk/resources.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'openpix/ruby_sdk/resources/charge'
+require 'openpix/ruby_sdk/resources/customer'
+require 'openpix/ruby_sdk/resources/payment'
+require 'openpix/ruby_sdk/resources/refund'
+require 'openpix/ruby_sdk/resources/subscription'
+require 'openpix/ruby_sdk/resources/webhook'

data/lib/openpix/ruby_sdk/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Openpix
+  module RubySdk
+    VERSION = '1.0.0'
+  end
+end

data/lib/openpix/ruby_sdk.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'openpix/ruby_sdk/version'
+require 'openpix/ruby_sdk/client'
+
+module Openpix
+  # Main module
+  module RubySdk
+  end
+end

metadata

@@ -0,0 +1,215 @@
+--- !ruby/object:Gem::Specification
+name: openpix-ruby_sdk
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Erick Takeshi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2023-06-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.1'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.7.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.7.4
+- !ruby/object:Gem::Dependency
+  name: faraday-httpclient
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.1
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.50'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.50'
+- !ruby/object:Gem::Dependency
+  name: webrick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.34
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.34
+description: Ruby SDK for OpenPix/Woovi API
+email:
+- erick.tmr@outlook.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- CHANGELOG.md
+files:
+- CHANGELOG.md
+- README.md
+- lib/openpix/ruby_sdk.rb
+- lib/openpix/ruby_sdk/api_body_formatter.rb
+- lib/openpix/ruby_sdk/api_response.rb
+- lib/openpix/ruby_sdk/client.rb
+- lib/openpix/ruby_sdk/http_client.rb
+- lib/openpix/ruby_sdk/resources.rb
+- lib/openpix/ruby_sdk/resources/charge.rb
+- lib/openpix/ruby_sdk/resources/customer.rb
+- lib/openpix/ruby_sdk/resources/payment.rb
+- lib/openpix/ruby_sdk/resources/refund.rb
+- lib/openpix/ruby_sdk/resources/resource.rb
+- lib/openpix/ruby_sdk/resources/subscription.rb
+- lib/openpix/ruby_sdk/resources/webhook.rb
+- lib/openpix/ruby_sdk/version.rb
+homepage: https://github.com/Open-Pix/ruby-sdk
+licenses: []
+metadata:
+  homepage_uri: https://github.com/Open-Pix/ruby-sdk
+  source_code_uri: https://github.com/Open-Pix/ruby-sdk
+  changelog_uri: https://github.com/Open-Pix/ruby-sdk/blob/main/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key: 
+specification_version: 4
+summary: Ruby SDK for OpenPix/Woovi API
+test_files: []