starkbank 2.8.0 → 2.10.0

data/lib/corporate_purchase/corporatepurchase.rb

@@ -0,0 +1,265 @@
+# frozen_string_literal: true
+
+require('starkcore')
+require_relative('../utils/rest')
+
+module StarkBank
+  # # CorporatePurchase object
+  #
+  # Displays the CorporatePurchase objects created in your Workspace.
+  #
+  # ## Attributes (return-only):
+  # - id [string]: unique id returned when CorporatePurchase is created. ex: "5656565656565656"
+  # - holder_id [string]: card holder unique id. ex: "5656565656565656"
+  # - holder_name [string]: card holder name. ex: "Tony Stark"
+  # - center_id [string]: target cost center ID. ex: "5656565656565656"
+  # - card_id [string]: unique id returned when CorporateCard is created. ex: "5656565656565656"
+  # - card_ending [string]: last 4 digits of the card number. ex: "1234"
+  # - description [string]: purchase descriptions. ex: "my_description"
+  # - amount [integer]: CorporatePurchase value in cents. Minimum = 0. ex: 1234 (= R$ 12.34)
+  # - tax [integer]: IOF amount taxed for international purchases. ex: 1234 (= R$ 12.34)
+  # - corporate_amount [integer]: corporate amount. ex: 1234 (= R$ 12.34)
+  # - corporate_currency_code [string]: corporate currency code. ex: "USD"
+  # - corporate_currency_symbol [string]: corporate currency symbol. ex: "$"
+  # - merchant_amount [integer]: merchant amount. ex: 1234 (= R$ 12.34)
+  # - merchant_currency_code [string]: merchant currency code. ex: "USD"
+  # - merchant_currency_symbol [string]: merchant currency symbol. ex: "$"
+  # - merchant_category_code [string]: merchant category code. ex: "fastFoodRestaurants"
+  # - merchant_category_type [string]: merchant category type. ex: "health"
+  # - merchant_country_code [string]: merchant country code. ex: "USA"
+  # - merchant_name [string]: merchant name. ex: "Google Cloud Platform"
+  # - merchant_display_name [string]: merchant name. ex: "Google Cloud Platform"
+  # - merchant_display_url [string]: public merchant icon (png image). ex: "https://sandbox.api.starkbank.com/v2/corporate-icon/merchant/ifood.png"
+  # - merchant_fee [integer]: fee charged by the merchant to cover specific costs, such as ATM withdrawal logistics, etc. ex: 200 (= R$ 2.00)
+  # - method_code [string]: method code. Options: "chip", "token", "server", "manual", "magstripe" or "contactless"
+  # - tags [list of strings]: list of strings for tagging returned by the sub-issuer during the authorization. ex: ["travel", "food"]
+  # - corporate_transaction_ids [list of strings]: ledger transaction ids linked to this Purchase
+  # - status [string]: current CorporateCard status. Options: "approved", "canceled", "denied", "confirmed", "voided"
+  # - updated [DateTime]: latest update datetime for the CorporatePurchase. ex: DateTime(2020, 3, 10, 10, 30, 0, 0)
+  # - created [DateTime]: creation datetime for the CorporatePurchase. ex: DateTime(2020, 3, 10, 10, 30, 0, 0)
+  class CorporatePurchase < StarkCore::Utils::Resource
+    attr_reader :id, :holder_id, :holder_name, :center_id, :card_id, :card_ending, :description, :amount, :tax, :corporate_amount,
+                :corporate_currency_code, :corporate_currency_symbol, :merchant_amount, :merchant_currency_code, :merchant_currency_symbol,
+                :merchant_category_code, :merchant_category_type, :merchant_country_code, :merchant_name, :merchant_display_name,
+                :merchant_display_url, :merchant_fee, :method_code, :tags, :corporate_transaction_ids, :status, :updated, :created
+    def initialize(
+      id: nil, holder_id: nil, holder_name: nil, center_id: nil, card_id: nil, card_ending: nil, description: nil, amount: nil, tax: nil, corporate_amount: nil,
+      corporate_currency_code: nil, corporate_currency_symbol: nil, merchant_amount: nil, merchant_currency_code: nil, merchant_currency_symbol: nil,
+      merchant_category_code: nil, merchant_category_type: nil, merchant_country_code: nil, merchant_name: nil, merchant_display_name: nil,
+      merchant_display_url: nil, merchant_fee: nil, method_code: nil, tags: nil, corporate_transaction_ids: nil, status: nil, updated: nil, created: nil
+    )
+      super(id)
+      @holder_id = holder_id
+      @holder_name = holder_name
+      @center_id = center_id
+      @card_id = card_id
+      @card_ending = card_ending
+      @description = description
+      @amount = amount
+      @tax = tax
+      @corporate_amount = corporate_amount
+      @corporate_currency_code = corporate_currency_code
+      @corporate_currency_symbol = corporate_currency_symbol
+      @merchant_amount = merchant_amount
+      @merchant_currency_code = merchant_currency_code
+      @merchant_currency_symbol = merchant_currency_symbol
+      @merchant_category_code = merchant_category_code
+      @merchant_category_type = merchant_category_type
+      @merchant_country_code = merchant_country_code
+      @merchant_name = merchant_name
+      @merchant_display_name = merchant_display_name
+      @merchant_display_url = merchant_display_url
+      @merchant_fee = merchant_fee
+      @method_code = method_code
+      @tags = tags
+      @corporate_transaction_ids = corporate_transaction_ids
+      @status = status
+      @updated = updated
+      @created = created
+
+    end
+
+    # # Retrieve a specific CorporatePurchase
+    #
+    # Receive a single CorporatePurchase object previously created in the Stark Bank API by its id
+    #
+    # ## Parameters (required):
+    # - id [string]: object unique id. ex: '5656565656565656'
+    #
+    # ## Parameters (optional):
+    # - user [Organization/Project object, default nil]: Organization or Project object. Not necessary if StarkBank.user was set before function call
+    #
+    # ## Return:
+    # - CorporatePurchase object with updated attributes
+    def self.get(id, user: nil)
+      StarkBank::Utils::Rest.get_id(id: id, user: user, **resource)
+    end
+
+    # # Retrieve CorporatePurchases
+    #
+    # Receive a generator of CorporatePurchases objects previously created in the Stark Bank API
+    #
+    # ## Parameters (optional):
+    # - limit [integer, default nil]: maximum number of objects to be retrieved. Unlimited if nil. ex: 35
+    # - after [Date or string, default nil]: date filter for objects created only after specified date. ex: Date.new(2020, 3, 09)
+    # - before [Date or string, default nil]: date filter for objects created only before specified date. ex: Date.new(2020, 3, 10)
+    # - merchant_category_types [list of strings, default nil]: merchant category type. ex: "health"
+    # - holder_ids [list of strings, default nil]: card holder IDs. ex: ["5656565656565656", "4545454545454545"]
+    # - card_ids [list of strings, default nil]: card  IDs. ex: ["5656565656565656", "4545454545454545"]
+    # - status [list of strings, default nil]: filter for status of retrieved objects. ex: ['approved', 'canceled', 'denied', 'confirmed', 'voided']
+    # - ids [list of strings, default nil]: purchase IDs. ex: ['5656565656565656', '4545454545454545']
+    # - user [Organization/Project object, default nil]: Organization or Project object. Not necessary if starkbank.user was set before function call
+    #
+    # ## Return:
+    # - generator of CorporatePurchases objects with updated attributes
+    def self.query(ids: nil, limit: nil, after: nil, before: nil, merchant_category_types: nil, holder_ids: nil, card_ids: nil,
+                   status: nil, user: nil)
+      after = StarkCore::Utils::Checks.check_date(after)
+      before = StarkCore::Utils::Checks.check_date(before)
+      StarkBank::Utils::Rest.get_stream(
+        ids: ids,
+        limit: limit,
+        after: after,
+        before: before,
+        merchant_category_types: merchant_category_types,
+        holder_ids: holder_ids,
+        card_ids: card_ids,
+        status: status,
+        user: user,
+        **resource
+      )
+    end
+
+    # # Retrieve paged CorporatePurchases
+    #
+    # Receive a list of up to 100 CorporatePurchases objects previously created in the Stark Bank API and the cursor
+    # to the next page. Use this function instead of query if you want to manually page your invoices.
+    #
+    # ## Parameters (optional):
+    # - cursor [string, default nil]: cursor returned on the previous page function call.
+    # - limit [integer, default 100]: maximum number of objects to be retrieved. Max = 100. ex: 35
+    # - after [Date or string, default nil]: date filter for objects created only after specified date. ex: Date.new(2020, 3, 10)
+    # - before [Date or string, default nil]: date filter for objects created only before specified date. ex: Date.new(2020, 3, 10)
+    # - merchant_category_types [list of strings, default nil]: merchant category type. ex: "health"
+    # - holder_ids [list of strings, default nil]: card holder IDs. ex: ["5656565656565656", "4545454545454545"]
+    # - card_ids [list of strings, default nil]: card  IDs. ex: ["5656565656565656", "4545454545454545"]
+    # - status [list of strings, default nil]: filter for status of retrieved objects. ex: ['approved', 'canceled', 'denied', 'confirmed', 'voided']
+    # - ids [list of strings, default nil]: purchase IDs. ex: ['5656565656565656', '4545454545454545']
+    # - user [Organization/Project object, default nil]: Organization or Project object. Not necessary if starkbank.user was set before function call
+    #
+    # ## Return:
+    # - list of CorporatePurchases objects with updated attributes
+    # - cursor to retrieve the next page of CorporatePurchases objects
+    def self.page(cursor: nil, ids: nil, limit: nil, after: nil, before: nil, merchant_category_types: nil, holder_ids: nil,
+                  card_ids: nil, status: nil, user: nil)
+      after = StarkCore::Utils::Checks.check_date(after)
+      before = StarkCore::Utils::Checks.check_date(before)
+      StarkBank::Utils::Rest.get_page(
+        cursor: cursor,
+        ids: ids,
+        limit: limit,
+        after: after,
+        before: before,
+        merchant_category_types: merchant_category_types,
+        holder_ids: holder_ids,
+        card_ids: card_ids,
+        status: status,
+        user: user,
+        **resource
+      )
+    end
+
+    # # Create a single verified CorporatePurchase authorization request from a content string
+    #
+    # Use this method to parse and verify the authenticity of the authorization request received at the informed endpoint.
+    # Authorization requests are posted to your registered endpoint whenever CorporatePurchases are received.
+    # They present CorporatePurchase data that must be analyzed and answered with approval or declination.
+    # If the provided digital signature does not check out with the StarkBank public key, a stark.exception.InvalidSignatureException will be raised.
+    # If the authorization request is not answered within 2 seconds or is not answered with an HTTP status code 200 the
+    # CorporatePurchase will go through the pre-configured stand-in validation.
+    #
+    # ## Parameters (required):
+    # - content [string]: response content from request received at user endpoint (not parsed)
+    # - signature [string]: base-64 digital signature received at response header 'Digital-Signature'
+    #
+    # # ## Parameters (optional):
+    # - user [Organization/Project object, default nil]: Organization or Project object. Not necessary if starkbank.user was set before function call
+    #
+    # ## Return:
+    # - Parsed CorporatePurchase object
+    def self.parse(content:, signature:, user: nil)
+      StarkBank::Utils::Parse.parse_and_verify(
+        content: content,
+        signature: signature,
+        user: user,
+        key: nil,
+        resource: resource
+      )
+    end
+
+    # # Helps you respond CorporatePurchase requests
+    #
+    # ## Parameters (required):
+    # - status [string]: sub-issuer response to the authorization. ex: 'approved' or 'denied'
+    #
+    # ## Parameters (conditionally required):
+    # - reason [string]: denial reason. Options: 'other', 'blocked', 'lostCard', 'stolenCard', 'invalidPin', 'invalidCard', 'cardExpired', 'corporateError', 'concurrency', 'standInDenial', 'subIssuerError', 'invalidPurpose', 'invalidZipCode', 'invalidWalletId', 'inconsistentCard', 'settlementFailed', 'cardRuleMismatch', 'invalidExpiration', 'prepaidInstallment', 'holderRuleMismatch', 'insufficientBalance', 'tooManyTransactions', 'invalidSecurityCode', 'invalidPaymentMethod', 'confirmationDeadline', 'withdrawalAmountLimit', 'insufficientCardLimit', 'insufficientHolderLimit'
+    #
+    # # ## Parameters (optional):
+    # - amount [integer, default nil]: amount in cents that was authorized. ex: 1234 (= R$ 12.34)
+    # - tags [list of strings, default nil]: tags to filter retrieved object. ex: ['tony', 'stark']
+    #
+    # ## Return:
+    # - Dumped JSON string that must be returned to us on the CorporatePurchase request
+    def self.response(
+      status:, reason: nil, amount: nil, tags: nil
+    )
+      params = {
+        'status': status,
+        'reason': reason,
+        'amount': amount,
+        'tags': tags
+      }
+
+      params.to_json
+    end
+
+    def self.resource
+      {
+        resource_name: 'CorporatePurchase',
+        resource_maker: proc { |json|
+          CorporatePurchase.new(
+            id: json['id'],
+            holder_id: json['holder_id'],
+            holder_name: json['holder_name'],
+            center_id: json['center_id'],
+            card_id: json['card_id'],
+            card_ending: json['card_ending'],
+            description: json['description'],
+            amount: json['amount'],
+            tax: json['tax'],
+            corporate_amount: json['corporate_amount'],
+            corporate_currency_code: json['corporate_currency_code'],
+            corporate_currency_symbol: json['corporate_currency_symbol'],
+            merchant_amount: json['merchant_amount'],
+            merchant_currency_code: json['merchant_currency_code'],
+            merchant_currency_symbol: json['merchant_currency_symbol'],
+            merchant_category_code: json['merchant_category_code'],
+            merchant_category_type: json['merchant_category_type'],
+            merchant_country_code: json['merchant_country_code'],
+            merchant_name: json['merchant_name'],
+            merchant_display_name: json['merchant_display_name'],
+            merchant_display_url: json['merchant_display_url'],
+            merchant_fee: json['merchant_fee'],
+            method_code: json['method_code'],
+            tags: json['tags'],
+            corporate_transaction_ids: json['corporate_transaction_ids'],
+            status: json['status'],
+            updated: json['updated'],
+            created: json['created'],
+          )
+        }
+      }
+    end
+  end
+end

data/lib/corporate_purchase/log.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require('starkcore')
+require_relative('corporatepurchase')
+require_relative('../utils/rest')
+
+module StarkBank
+  class CorporatePurchase
+    # # CorporatePurchase::Log object
+    #
+    # Every time a CorporatePurchase entity is updated, a corresponding CorporatePurchase::Log is generated for the entity.
+    # This Log is never generated by the user, but it can be retrieved to check additional information on the CorporatePurchase.
+    #
+    # ## Attributes (return-only):
+    # - id [string]: unique id returned when the log is created. ex: '5656565656565656'
+    # - purchase [CorporatePurchase]: CorporatePurchase entity to which the log refers to.
+    # - description [string]: purchase descriptions. ex: 'my_description'
+    # - corporate_transaction_id [string]: transaction ID related to the CorporateCard.
+    # - errors [list of strings]: list of errors linked to this CorporatePurchase event
+    # - type [string]: type of the CorporatePurchase event which triggered the log creation. ex: 'approved', 'canceled', 'confirmed', 'denied', 'reversed', 'voided'.
+    # - created [DateTime]: creation datetime for the log. ex: DateTime.new(2020, 3, 10, 10, 30, 0, 0)
+    class Log < StarkCore::Utils::Resource
+      attr_reader :id, :purchase, :description, :corporate_transaction_id, :errors, :type, :created
+      def initialize(id: nil, purchase: nil, description: nil, corporate_transaction_id: nil, errors: nil, type: nil, created: nil)
+        super(id)
+        @purchase = purchase
+        @description = description
+        @corporate_transaction_id = corporate_transaction_id
+        @errors = errors
+        @type = type
+        @created = StarkCore::Utils::Checks.check_datetime(created)
+      end
+
+      # # Retrieve a specific CorporatePurchase::Log
+      #
+      # Receive a single CorporatePurchase::Log object previously created by the Stark Bank API by passing its id
+      #
+      # ## Parameters (required):
+      # - id [string]: object unique id. ex: '5656565656565656'
+      #
+      # ## Parameters (optional):
+      # - user [Organization/Project object, default nil]: Organization or Project object. Not necessary if StarkBank.user was set before function call
+      #
+      # ## Return:
+      # - CorporatePurchase::Log object with updated attributes
+      def self.get(id, user: nil)
+        StarkBank::Utils::Rest.get_id(id: id, user: user, **resource)
+      end
+
+      # # Retrieve CorporatePurchase::Logs
+      #
+      # Receive a generator of CorporatePurchase::Log objects previously created in the Stark Bank API
+      #
+      # ## Parameters (optional):
+      # - limit [integer, default nil]: maximum number of objects to be retrieved. Unlimited if nil. ex: 35
+      # - after [Date or string, default nil]: date filter for objects created only after specified date. ex: Date.new(2020, 3, 10)
+      # - before [Date or string, default nil]: date filter for objects created only before specified date. ex: Date.new(2020, 3, 10)
+      # - types [list of strings, default nil]: filter for log event types. ex: ['approved', 'canceled', 'confirmed', 'denied', 'reversed', 'voided']
+      # - purchase_ids [list of strings, default nil]: list of Purchase ids to filter logs. ex: ['5656565656565656', '4545454545454545']
+      # - ids [list of strings, default nil]: list of CorporatePurchase ids to filter logs. ex: ['5656565656565656', '4545454545454545']
+      # - user [Organization/Project object, default nil]: Organization or Project object. Not necessary if starkbank.user was set before function call
+      #
+      # ## Return:
+      # - generator of CorporatePurchase::Log objects with updated attributes
+      def self.query(ids: nil, limit: nil, after: nil, before: nil, types: nil, purchase_ids: nil, user: nil)
+        after = StarkCore::Utils::Checks.check_date(after)
+        before = StarkCore::Utils::Checks.check_date(before)
+        StarkBank::Utils::Rest.get_stream(
+          ids: ids,
+          limit: limit,
+          after: after,
+          before: before,
+          types: types,
+          purchase_ids: purchase_ids,
+          user: user,
+          **resource
+        )
+      end
+
+      # # Retrieve paged CorporatePurchase::Logs
+      #
+      # Receive a list of up to 100 Log objects previously created in the Stark Bank API and the cursor to the next page.
+      # Use this function instead of query if you want to manually page your purchases.
+      #
+      # ## Parameters (optional):
+      # - cursor [string, default nil]: cursor returned on the previous page function call
+      # - limit [integer, default 100]: maximum number of objects to be retrieved. Max = 100. ex: 35
+      # - after [Date or string, default nil]: date filter for objects created only after specified date. ex: Date.new(2020, 3, 10)
+      # - before [Date or string, default nil]: date filter for objects created only before specified date. ex: Date.new(2020, 3, 10)
+      # - types [list of strings, default nil]: filter for log event types. ex: ['approved', 'canceled', 'confirmed', 'denied', 'reversed', 'voided']
+      # - purchase_ids [list of strings, default nil]: list of Purchase ids to filter logs. ex: ['5656565656565656', '4545454545454545']
+      # - ids [list of strings, default nil]: list of CorporatePurchase ids to filter logs. ex: ['5656565656565656', '4545454545454545']
+      # - user [Organization/Project object, default nil]: Organization or Project object. Not necessary if starkbank.user was set before function call
+      #
+      # ## Return:
+      # - list of CorporatePurchase::Log objects with updated attributes
+      # - cursor to retrieve the next page of Log objects
+      def self.page(cursor: nil, ids: nil, limit: nil, after: nil, before: nil, types: nil, purchase_ids: nil, user: nil)
+        after = StarkCore::Utils::Checks.check_date(after)
+        before = StarkCore::Utils::Checks.check_date(before)
+        StarkBank::Utils::Rest.get_page(
+          cursor: cursor,
+          ids: ids,
+          limit: limit,
+          after: after,
+          before: before,
+          types: types,
+          purchase_ids: purchase_ids,
+          user: user,
+          **resource
+        )
+      end
+
+      def self.resource
+        request_maker = StarkBank::CorporatePurchase.resource[:resource_maker]
+        {
+          resource_name: 'CorporatePurchaseLog',
+          resource_maker: proc { |json|
+            Log.new(
+              id: json['id'],
+              purchase: StarkCore::Utils::API.from_api_json(request_maker, json['purchase']),
+              description: json['description'],
+              corporate_transaction_id: json['corporate_transaction_id'],
+              errors: json['errors'],
+              type: json['type'],
+              created: json['created']
+            )
+          }
+        }
+      end
+    end
+  end
+end

data/lib/corporate_rule/corporaterule.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require_relative('../utils/rest')
+
+module StarkBank
+  # # CorporateRule object
+  #
+  # The CorporateRule object displays the spending rules of CorporateCards and CorporateHolders created in your Workspace.
+  #
+  # ## Parameters (required):
+  # - name [string]: rule name. ex: 'Travel' or 'Food'
+  # - amount [integer]: maximum amount that can be spent in the informed interval. ex: 200000 (= R$ 2000.00)
+  #
+  # ## Parameters (optional):
+  # - interval [string, default 'lifetime']: interval after which the rule amount counter will be reset to 0. ex: 'instant', 'day', 'week', 'month', 'year' or 'lifetime'
+  # - schedule [string, default nil]: schedule time for user to spend. ex: "every monday, wednesday from 00:00 to 23:59 in America/Sao_Paulo"
+  # - purposes [list of string, default []]: list of strings representing the allowed purposes for card purchases, you can use this to restrict ATM withdrawals. ex: ["purchase", "withdrawal"]
+  # - currency_code [string, default 'BRL']: code of the currency that the rule amount refers to. ex: 'BRL' or 'USD'
+  # - categories [list of MerchantCategories, default nil]: merchant categories accepted by the rule. ex: [MerchantCategory(code='fastFoodRestaurants')]
+  # - countries [list of MerchantCountries, default nil]: countries accepted by the rule. ex: [MerchantCountry(code='BRA')]
+  # - methods [list of CardMethods, default nil]: card purchase methods accepted by the rule. ex: [CardMethod(code='magstripe')]
+  #
+  # ## Attributes (expanded return-only):
+  # - id [string]: unique id returned when a CorporateRule is created, used to update a specific CorporateRule. ex: '5656565656565656'
+  # - counter_amount [integer]: current rule spent amount. ex: 1000
+  # - currency_symbol [string]: currency symbol. ex: 'R$'
+  # - currency_name [string]: currency name. ex: 'Brazilian Real'
+  class CorporateRule < StarkCore::Utils::Resource
+    attr_reader :name, :interval, :amount, :currency_code, :counter_amount, :schedule, :purposes, :currency_name, :currency_symbol,
+                :categories, :countries, :methods
+    def initialize(
+      name:, amount:, id: nil, interval: nil, schedule: nil, purposes: nil, currency_code: nil, categories: nil, countries: nil, methods: nil,
+      counter_amount: nil, currency_symbol: nil, currency_name: nil
+    )
+      super(id)
+      @name = name
+      @amount = amount
+      @interval = interval
+      @schedule = schedule
+      @purposes = purposes
+      @currency_code = currency_code
+      @categories = CorporateRule.parse_categories(categories)
+      @countries = CorporateRule.parse_categories(countries)
+      @methods = CorporateRule.parse_categories(methods)
+      @counter_amount = counter_amount
+      @currency_symbol = currency_symbol
+      @currency_name = currency_name
+    end
+
+    def self.parse_categories(categories)
+      resource_maker = StarkBank::MerchantCategory.resource[:resource_maker]
+      return categories if categories.nil?
+
+      parsed_categories = []
+      categories.each do |category|
+        unless category.is_a? MerchantCategory
+          category = StarkCore::Utils::API.from_api_json(resource_maker, category)
+        end
+        parsed_categories << category
+      end
+      parsed_categories
+    end
+
+    def self.parse_countries(countries)
+      resource_maker = StarkBank::MerchantCountry.resource[:resource_maker]
+      return countries if countries.nil?
+
+      parsed_countries = []
+      countries.each do |country|
+        unless country.is_a? MerchantCountry
+          country = StarkCore::Utils::API.from_api_json(resource_maker, country)
+        end
+        parsed_countries << country
+      end
+      parsed_countries
+    end
+
+    def self.parse_methods(methods)
+      resource_maker = StarkBank::CardMethod.resource[:resource_maker]
+      return methods if methods.nil?
+
+      parsed_methods = []
+      methods.each do |method|
+        unless method.is_a? CardMethod
+          method = StarkCore::Utils::API.from_api_json(resource_maker, method)
+        end
+        parsed_methods << method
+      end
+      parsed_methods
+    end
+
+    def self.parse_rules(rules)
+      rule_maker = StarkBank::CorporateRule.resource[:resource_maker]
+      return rules if rules.nil?
+
+      parsed_rules = []
+      rules.each do |rule|
+        unless rule.is_a? CorporateRule
+          rule = StarkCore::Utils::API.from_api_json(rule_maker, rule)
+        end
+        parsed_rules << rule
+      end
+      parsed_rules
+    end
+
+    def self.resource
+      {
+        resource_name: 'CorporateRule',
+        resource_maker: proc { |json|
+          CorporateRule.new(
+            name: json['name'],
+            amount: json['amount'],
+            interval: json['interval'],
+            schedule: json['schedule'],
+            purposes: json['purposes'],
+            currency_code: json['currency_code'],
+            categories: json['categories'],
+            countries: json['countries'],
+            methods: json['methods'],
+            counter_amount: json['counter_amount'],
+            currency_symbol: json['currency_symbol'],
+            currency_name: json['currency_name']
+          )
+        }
+      }
+    end
+  end
+end
+

data/lib/corporate_transaction/corporatetransaction.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require('starkcore')
+require_relative('../utils/rest')
+
+module StarkBank
+  # # CorporateTransaction object
+  #
+  # The CorporateTransaction objects created in your Workspace to represent each balance shift.
+  #
+  # ## Attributes (return-only):
+  # - id [string]: unique id returned when CorporateTransaction is created. ex: '5656565656565656'
+  # - amount [integer]: CorporateTransaction value in cents. ex: 1234 (= R$ 12.34)
+  # - balance [integer]: balance amount of the Workspace at the instant of the Transaction in cents. ex: 200 (= R$ 2.00)
+  # - description [string]: CorporateTransaction description. ex: 'Buying food'
+  # - source [string]: source of the transaction. ex: 'corporate-purchase/5656565656565656'
+  # - tags [string]: list of strings inherited from the source resource. ex: ['tony', 'stark']
+  # - created [DateTime]: creation datetime for the CorporateTransaction. ex: DateTime.new(2020, 3, 10, 10, 30, 0, 0)
+  class CorporateTransaction < StarkCore::Utils::Resource
+    attr_reader :id, :amount, :balance, :description, :source, :tags, :created
+
+    def initialize(id: nil, amount: nil, balance: nil, description: nil, source: nil, tags: nil, created: nil)
+      super(id)
+      @amount = amount
+      @balance = balance
+      @description = description
+      @source = source
+      @tags = tags
+      @created = StarkCore::Utils::Checks.check_datetime(created)
+    end
+
+    # # Retrieve a specific CorporateTransaction
+    #
+    # Receive a single CorporateTransaction object previously created in the Stark Bank API by its id
+    #
+    # ## Parameters (required):
+    # - id [string]: object unique id. ex: '5656565656565656'
+    #
+    # ## Parameters (optional):
+    # - user [Organization/Project object, default nil]: Organization or Project object. Not necessary if StarkBank.user was set before function call
+    #
+    # ## Return:
+    # - CorporateTransaction object with updated attributes
+    def self.get(id, user: nil)
+      StarkBank::Utils::Rest.get_id(id: id, user: user, **resource)
+    end
+
+    # # Retrieve CorporateTransactions
+    #
+    # Receive a generator of CorporateTransaction objects previously created in the Stark Bank API
+    #
+    # ## Parameters (optional):
+    # - tags [list of strings, default nil]: tags to filter retrieved objects. ex: ['tony', 'stark']
+    # - external_ids [list of strings, default nil]: external IDs. ex: ['5656565656565656', '4545454545454545']
+    # - after [Date or string, default nil]: date filter for objects created only after specified date. ex: Date.new(2020, 3, 10)
+    # - before [Date or string, default nil]: date filter for objects created only before specified date. ex: Date.new(2020, 3, 10)
+    # - status [string, default nil]: filter for status of retrieved objects. ex: 'approved', 'canceled', 'denied', 'confirmed' or 'voided'
+    # - ids [list of strings, default nil]: purchase IDs
+    # - limit [integer, default nil]: maximum number of objects to be retrieved. Unlimited if nil. ex: 35
+    # - user [Organization/Project object, default nil]: Organization or Project object. Not necessary if starkbank.user was set before function call
+    #
+    # ## Return:
+    # - generator of CorporateTransaction objects with updated attributes
+    def self.query(tags: nil, external_ids: nil, after: nil, before: nil, status: nil, ids: nil, limit: nil, user: nil)
+      after = StarkCore::Utils::Checks.check_date(after)
+      before = StarkCore::Utils::Checks.check_date(before)
+      StarkBank::Utils::Rest.get_stream(
+        tags: tags,
+        external_ids: external_ids,
+        after: after,
+        before: before,
+        status: status,
+        ids: ids,
+        limit: limit,
+        user: user,
+        **resource
+      )
+    end
+
+    # # Retrieve paged CorporateTransactions
+    #
+    # Receive a list of up to 100 CorporateTransaction objects previously created in the Stark Bank API and the cursor to the next page.
+    # Use this function instead of query if you want to manually page your requests.
+    #
+    # ## Parameters (optional):
+    # - cursor [string, default nil]: cursor returned on the previous page function call.
+    # - limit [integer, default 100]: maximum number of objects to be retrieved. Max = 100. ex: 35
+    # - after [Date or string, default nil]: date filter for objects created only after specified date. ex: Date.new(2020, 3, 10)
+    # - before [Date or string, default nil]: date filter for objects created only before specified date. ex: Date.new(2020, 3, 10)
+    # - tags [list of strings, default nil]: tags to filter retrieved objects. ex: ['tony', 'stark']
+    # - external_ids [list of strings, default nil]: external IDs. ex: ['5656565656565656', '4545454545454545']
+    # - status [string, default nil]: filter for status of retrieved objects. ex: 'approved', 'canceled', 'denied', 'confirmed' or 'voided'
+    # - ids [list of strings, default nil]: purchase IDs
+    # - user [Organization/Project object, default nil]: Organization or Project object. Not necessary if starkbank.user was set before function call
+    #
+    # ## Return:
+    # - list of CorporateTransactions objects with updated attributes
+    # - cursor to retrieve the next page of CorporateTransactions objects
+    def self.page(cursor: nil, tags: nil, external_ids: nil, after: nil, before: nil, status: nil, ids: nil, limit: nil,
+                  user: nil)
+      after = StarkCore::Utils::Checks.check_date(after)
+      before = StarkCore::Utils::Checks.check_date(before)
+      StarkBank::Utils::Rest.get_page(
+        cursor: cursor,
+        tags: tags,
+        external_ids: external_ids,
+        after: after,
+        before: before,
+        status: status,
+        ids: ids,
+        limit: limit,
+        user: user,
+        **resource
+      )
+    end
+
+    def self.resource
+      {
+        resource_name: 'CorporateTransaction',
+        resource_maker: proc { |json|
+          CorporateTransaction.new(
+            id: json['id'],
+            amount: json['amount'],
+            balance: json['balance'],
+            description: json['description'],
+            source: json['source'],
+            tags: json['tags'],
+            created: json['created']
+          )
+        }
+      }
+    end
+  end
+end