cryptopay-ruby 0.1.0

data/lib/cryptopay/models/rates_result.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+# Auto-generated file
+# DO NOT EDIT
+
+module Cryptopay
+  class RatesResult
+    ENCODER = Encoder.new(
+      name: 'Cryptopay::RatesResult',
+      attribute_map: {
+        'data': :data
+      },
+      types: {
+        'data': :'Hash<String, Rate>'
+      },
+      nullables: []
+    )
+    private_constant :ENCODER
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      @attributes = ENCODER.sanitize(attributes)
+    end
+
+    def data
+      @attributes[:data]
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def invalid_properties
+      properties = []
+
+      properties.push('invalid value for "data", data cannot be nil.') if data.nil?
+
+      properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      invalid_properties.empty?
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Cryptopay::RatesResult] Returns the model itself
+    def self.build_from_hash(data)
+      attributes = ENCODER.build_from_hash(data)
+      new(attributes)
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      ENCODER.to_hash(@attributes)
+    end
+
+    def inspect
+      "#<#{self.class}:0x#{object_id.to_s(16)}> JSON: " + JSON.pretty_generate(to_hash)
+    end
+  end
+end

data/lib/cryptopay/models/risk.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+# Auto-generated file
+# DO NOT EDIT
+
+module Cryptopay
+  # Transaction risk level details
+  class Risk
+    ENCODER = Encoder.new(
+      name: 'Cryptopay::Risk',
+      attribute_map: {
+        'score': :score,
+        'level': :level,
+        'resource_name': :resource_name,
+        'resource_category': :resource_category
+      },
+      types: {
+        'score': :Float,
+        'level': :RiskLevel,
+        'resource_name': :String,
+        'resource_category': :String
+      },
+      nullables: []
+    )
+    private_constant :ENCODER
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      @attributes = ENCODER.sanitize(attributes)
+    end
+
+    # Transaction risk score
+    def score
+      @attributes[:score]
+    end
+
+    def level
+      @attributes[:level]
+    end
+
+    # A resource name the transaction has been received from
+    def resource_name
+      @attributes[:resource_name]
+    end
+
+    # A resource category the transaction has been received from
+    def resource_category
+      @attributes[:resource_category]
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def invalid_properties
+      properties = []
+
+      properties.push('invalid value for "score", score cannot be nil.') if score.nil?
+
+      properties.push('invalid value for "level", level cannot be nil.') if level.nil?
+
+      if !level.nil? && !%w[low medium high].include?(level)
+        properties.push('invalid value for level, must be one of "low", "medium", "high"')
+      end
+
+      properties.push('invalid value for "resource_name", resource_name cannot be nil.') if resource_name.nil?
+
+      if resource_category.nil?
+        properties.push('invalid value for "resource_category", resource_category cannot be nil.')
+      end
+
+      properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      invalid_properties.empty?
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Cryptopay::Risk] Returns the model itself
+    def self.build_from_hash(data)
+      attributes = ENCODER.build_from_hash(data)
+      new(attributes)
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      ENCODER.to_hash(@attributes)
+    end
+
+    def inspect
+      "#<#{self.class}:0x#{object_id.to_s(16)}> JSON: " + JSON.pretty_generate(to_hash)
+    end
+  end
+end

data/lib/cryptopay/models/risk_level.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# Auto-generated file
+# DO NOT EDIT
+
+module Cryptopay
+  module RiskLevel
+    LOW = 'low'
+    MEDIUM = 'medium'
+    HIGH = 'high'
+
+    # Builds the enum from string
+    # @param [String] The enum value in the form of the string
+    # @return [String] The enum value
+    def self.build_from_hash(value)
+      value
+    end
+  end
+end

data/lib/cryptopay/models/risk_params.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+# Auto-generated file
+# DO NOT EDIT
+
+module Cryptopay
+  class RiskParams
+    ENCODER = Encoder.new(
+      name: 'Cryptopay::RiskParams',
+      attribute_map: {
+        'address': :address,
+        'currency': :currency,
+        'type': :type
+      },
+      types: {
+        'address': :String,
+        'currency': :String,
+        'type': :String
+      },
+      nullables: []
+    )
+    private_constant :ENCODER
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      @attributes = ENCODER.sanitize(attributes)
+    end
+
+    # Cryptocurrency address
+    def address
+      @attributes[:address]
+    end
+
+    # Cryptocurrency symbol
+    def currency
+      @attributes[:currency]
+    end
+
+    def type
+      @attributes[:type]
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def invalid_properties
+      properties = []
+
+      properties.push('invalid value for "address", address cannot be nil.') if address.nil?
+
+      properties.push('invalid value for "currency", currency cannot be nil.') if currency.nil?
+
+      properties.push('invalid value for "type", type cannot be nil.') if type.nil?
+
+      if !type.nil? && !%w[source_of_funds destination_of_funds].include?(type)
+        properties.push('invalid value for type, must be one of "source_of_funds", "destination_of_funds"')
+      end
+
+      properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      invalid_properties.empty?
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Cryptopay::RiskParams] Returns the model itself
+    def self.build_from_hash(data)
+      attributes = ENCODER.build_from_hash(data)
+      new(attributes)
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      ENCODER.to_hash(@attributes)
+    end
+
+    def inspect
+      "#<#{self.class}:0x#{object_id.to_s(16)}> JSON: " + JSON.pretty_generate(to_hash)
+    end
+  end
+end

data/lib/cryptopay/models/risk_result.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+# Auto-generated file
+# DO NOT EDIT
+
+module Cryptopay
+  class RiskResult
+    ENCODER = Encoder.new(
+      name: 'Cryptopay::RiskResult',
+      attribute_map: {
+        'data': :data
+      },
+      types: {
+        'data': :Risk
+      },
+      nullables: []
+    )
+    private_constant :ENCODER
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      @attributes = ENCODER.sanitize(attributes)
+    end
+
+    def data
+      @attributes[:data]
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def invalid_properties
+      properties = []
+
+      properties.push('invalid value for "data", data cannot be nil.') if data.nil?
+
+      data&.invalid_properties&.each do |prop|
+        properties.push("invalid value for \"data\": #{prop}")
+      end
+
+      properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      invalid_properties.empty?
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Cryptopay::RiskResult] Returns the model itself
+    def self.build_from_hash(data)
+      attributes = ENCODER.build_from_hash(data)
+      new(attributes)
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      ENCODER.to_hash(@attributes)
+    end
+
+    def inspect
+      "#<#{self.class}:0x#{object_id.to_s(16)}> JSON: " + JSON.pretty_generate(to_hash)
+    end
+  end
+end

data/lib/cryptopay/models/transaction.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+# Auto-generated file
+# DO NOT EDIT
+
+module Cryptopay
+  class Transaction
+    ENCODER = Encoder.new(
+      name: 'Cryptopay::Transaction',
+      attribute_map: {
+        'id': :id,
+        'custom_id': :custom_id,
+        'customer_id': :customer_id,
+        'amount': :amount,
+        'currency': :currency,
+        'balance': :balance,
+        'fee': :fee,
+        'fee_currency': :fee_currency,
+        'reference_id': :reference_id,
+        'reference_type': :reference_type,
+        'description': :description,
+        'status': :status,
+        'status_context': :status_context,
+        'risk': :risk,
+        'created_at': :created_at
+      },
+      types: {
+        'id': :String,
+        'custom_id': :String,
+        'customer_id': :String,
+        'amount': :Decimal,
+        'currency': :String,
+        'balance': :Decimal,
+        'fee': :Decimal,
+        'fee_currency': :String,
+        'reference_id': :String,
+        'reference_type': :TransactionReferenceType,
+        'description': :String,
+        'status': :String,
+        'status_context': :String,
+        'risk': :Risk,
+        'created_at': :Time
+      },
+      nullables: %i[
+        custom_id
+        customer_id
+        description
+        status
+        status_context
+      ]
+    )
+    private_constant :ENCODER
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      @attributes = ENCODER.sanitize(attributes)
+    end
+
+    def id
+      @attributes[:id]
+    end
+
+    def custom_id
+      @attributes[:custom_id]
+    end
+
+    def customer_id
+      @attributes[:customer_id]
+    end
+
+    def amount
+      @attributes[:amount]
+    end
+
+    def currency
+      @attributes[:currency]
+    end
+
+    def balance
+      @attributes[:balance]
+    end
+
+    def fee
+      @attributes[:fee]
+    end
+
+    def fee_currency
+      @attributes[:fee_currency]
+    end
+
+    def reference_id
+      @attributes[:reference_id]
+    end
+
+    def reference_type
+      @attributes[:reference_type]
+    end
+
+    def description
+      @attributes[:description]
+    end
+
+    def status
+      @attributes[:status]
+    end
+
+    def status_context
+      @attributes[:status_context]
+    end
+
+    def risk
+      @attributes[:risk]
+    end
+
+    def created_at
+      @attributes[:created_at]
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def invalid_properties
+      properties = []
+
+      properties.push('invalid value for "id", id cannot be nil.') if id.nil?
+
+      properties.push('invalid value for "amount", amount cannot be nil.') if amount.nil?
+
+      properties.push('invalid value for "currency", currency cannot be nil.') if currency.nil?
+
+      properties.push('invalid value for "balance", balance cannot be nil.') if balance.nil?
+
+      properties.push('invalid value for "reference_id", reference_id cannot be nil.') if reference_id.nil?
+
+      properties.push('invalid value for "reference_type", reference_type cannot be nil.') if reference_type.nil?
+
+      if !reference_type.nil? && !%w[BankDeposit BankWithdrawal ChannelPayment CoinDeposit CoinWithdrawal ExchangeTransfer Invoice InvoiceRefund ManualBalanceTransaction].include?(reference_type)
+        properties.push('invalid value for reference_type, must be one of "BankDeposit", "BankWithdrawal", "ChannelPayment", "CoinDeposit", "CoinWithdrawal", "ExchangeTransfer", "Invoice", "InvoiceRefund", "ManualBalanceTransaction"')
+      end
+
+      risk&.invalid_properties&.each do |prop|
+        properties.push("invalid value for \"risk\": #{prop}")
+      end
+
+      properties.push('invalid value for "created_at", created_at cannot be nil.') if created_at.nil?
+
+      properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      invalid_properties.empty?
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Cryptopay::Transaction] Returns the model itself
+    def self.build_from_hash(data)
+      attributes = ENCODER.build_from_hash(data)
+      new(attributes)
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      ENCODER.to_hash(@attributes)
+    end
+
+    def inspect
+      "#<#{self.class}:0x#{object_id.to_s(16)}> JSON: " + JSON.pretty_generate(to_hash)
+    end
+  end
+end

data/lib/cryptopay/models/transaction_list_result.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+# Auto-generated file
+# DO NOT EDIT
+
+module Cryptopay
+  class TransactionListResult
+    ENCODER = Encoder.new(
+      name: 'Cryptopay::TransactionListResult',
+      attribute_map: {
+        'data': :data,
+        'meta': :meta
+      },
+      types: {
+        'data': :'Array<Transaction>',
+        'meta': :Pagination
+      },
+      nullables: []
+    )
+    private_constant :ENCODER
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      @attributes = ENCODER.sanitize(attributes)
+    end
+
+    def data
+      @attributes[:data]
+    end
+
+    def meta
+      @attributes[:meta]
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def invalid_properties
+      properties = []
+
+      properties.push('invalid value for "data", data cannot be nil.') if data.nil?
+
+      data&.each_with_index do |item, index|
+        item.invalid_properties.each do |prop|
+          properties.push("invalid value for \"data.#{index}\": #{prop}")
+        end
+      end
+
+      properties.push('invalid value for "meta", meta cannot be nil.') if meta.nil?
+
+      meta&.invalid_properties&.each do |prop|
+        properties.push("invalid value for \"meta\": #{prop}")
+      end
+
+      properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      invalid_properties.empty?
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Cryptopay::TransactionListResult] Returns the model itself
+    def self.build_from_hash(data)
+      attributes = ENCODER.build_from_hash(data)
+      new(attributes)
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      ENCODER.to_hash(@attributes)
+    end
+
+    def inspect
+      "#<#{self.class}:0x#{object_id.to_s(16)}> JSON: " + JSON.pretty_generate(to_hash)
+    end
+  end
+end

data/lib/cryptopay/models/transaction_reference_type.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# Auto-generated file
+# DO NOT EDIT
+
+module Cryptopay
+  module TransactionReferenceType
+    BANK_DEPOSIT = 'BankDeposit'
+    BANK_WITHDRAWAL = 'BankWithdrawal'
+    CHANNEL_PAYMENT = 'ChannelPayment'
+    COIN_DEPOSIT = 'CoinDeposit'
+    COIN_WITHDRAWAL = 'CoinWithdrawal'
+    EXCHANGE_TRANSFER = 'ExchangeTransfer'
+    INVOICE = 'Invoice'
+    INVOICE_REFUND = 'InvoiceRefund'
+    MANUAL_BALANCE_TRANSACTION = 'ManualBalanceTransaction'
+
+    # Builds the enum from string
+    # @param [String] The enum value in the form of the string
+    # @return [String] The enum value
+    def self.build_from_hash(value)
+      value
+    end
+  end
+end

data/lib/cryptopay/request.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Cryptopay
+  class Request
+    attr_reader :method, :path, :body, :date, :headers, :content_type
+
+    DEFAULT_HEADERS = {
+      'Accept' => 'application/json',
+      'User-Agent' => "Cryptopay Ruby v#{VERSION}"
+    }.freeze
+
+    CONTENT_TYPE = 'application/json'
+
+    def initialize(method:, path:, query_params: {}, body_params: {})
+      @method = method
+      @path = prepare_query(path, query_params)
+      @body = prepare_body(body_params.to_hash)
+      @date = Time.now.httpdate
+      @content_type = CONTENT_TYPE
+      @headers = DEFAULT_HEADERS.merge(Date: date, 'Content-Type': @content_type)
+    end
+
+    def add_header(key, value)
+      @headers = headers.merge(key => value)
+    end
+
+    private
+
+    def prepare_query(path, params)
+      return path if params.empty?
+
+      query = encode_query(params)
+      [path, query].join('?')
+    end
+
+    def prepare_body(params)
+      return if params.empty?
+
+      params.to_json
+    end
+
+    def encode_query(params)
+      Faraday::NestedParamsEncoder.encode(params)
+    end
+  end
+end