starkinfra 0.4.0 → 0.5.0

data/lib/utils/api.rb

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-require_relative('case')
-
-module StarkInfra
-  module Utils
-    module API
-      def self.build_entity_hash(entity)
-        if entity.is_a?(Hash)
-          entity_hash = entity
-        else
-          entity_hash = {}
-          entity.instance_variables.each do |key|
-            variable = entity.instance_variable_get(key)
-            entity_hash[key[1..-1]] = variable.is_a?(StarkInfra::Utils::Resource) ? build_entity_hash(variable) : entity.instance_variable_get(key)
-          end
-        end
-        entity_hash
-      end
-
-      def self.api_json(entity)
-        built_hash = build_entity_hash(entity)
-        cast_json_to_api_format(built_hash)
-      end
-
-      def self.cast_json_to_api_format(hash)
-        entity_hash = {}
-        hash.each do |key, value|
-          next if value.nil?
-
-          entity_hash[StarkInfra::Utils::Case.snake_to_camel(key)] = parse_value(value)
-        end
-        entity_hash
-      end
-
-      def self.parse_value(value)
-        return api_json(value) if value.is_a?(SubResource)
-        return value.strftime('%Y-%m-%d') if value.is_a?(Date)
-        return value.strftime('%Y-%m-%dT%H:%M:%S+00:00') if value.is_a?(DateTime) || value.is_a?(Time)
-        return cast_json_to_api_format(value) if value.is_a?(Hash)
-        return value unless value.is_a?(Array)
-
-        list = []
-        value.each do |v|
-          if v.is_a?(Hash)
-            list << cast_json_to_api_format(v)
-            next
-          end
-          if v.is_a?(SubResource)
-            list << api_json(v)
-            next
-          end
-          list << v
-        end
-        list
-      end
-
-      def self.from_api_json(resource_maker, json)
-        snakes = {}
-        json.each do |key, value|
-          snakes[StarkInfra::Utils::Case.camel_to_snake(key)] = value
-        end
-
-        resource_maker.call(snakes)
-      end
-
-      def self.endpoint(resource_name)
-        kebab = StarkInfra::Utils::Case.camel_to_kebab(resource_name)
-        kebab.sub!('-log', '/log')
-        kebab.sub!('-attempt', '/attempt')
-        kebab
-      end
-
-      def self.last_name_plural(resource_name)
-        base = last_name(resource_name)
-
-        return base if base[-1].eql?('s')
-        return "#{base}s" if base[-2..-1].eql?('ey')
-        return "#{base[0...-1]}ies" if base[-1].eql?('y')
-
-        "#{base}s"
-      end
-
-      def self.last_name(resource_name)
-        StarkInfra::Utils::Case.camel_to_kebab(resource_name).split('-').last
-      end
-    end
-  end
-end

data/lib/utils/bacenid.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: false
-
-require('date')
-
-module StarkInfra
-  module Utils
-    module BacenId
-      def self._create(bank_code)
-        random_source = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890'.split('')
-        random_string = ''
-
-        11.times do
-          random_string << random_source[rand(random_source.length)]
-        end
-        bank_code + DateTime.now.strftime('%Y%m%d%H%M').to_s << random_string
-      end
-    end
-  end
-end

data/lib/utils/cache.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module StarkInfra
-  module Utils
-    module Cache
-      @starkinfra_public_key = nil
-      class << self; attr_accessor :starkinfra_public_key; end
-    end
-  end
-end

data/lib/utils/case.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module StarkInfra
-  module Utils
-    module Case
-      def self.camel_to_snake(camel)
-        camel.to_s.gsub(/([a-z])([A-Z\d])/, '\1_\2').downcase
-      end
-
-      def self.snake_to_camel(snake)
-        camel = snake.to_s.split('_').map(&:capitalize).join
-        camel[0] = camel[0].downcase
-        camel
-      end
-
-      def self.camel_to_kebab(camel)
-        camel_to_snake(camel).tr('_', '-')
-      end
-    end
-  end
-end

data/lib/utils/checks.rb

@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-require('date')
-require('starkbank-ecdsa')
-require_relative('environment')
-
-module StarkInfra
-  module Utils
-    class Checks
-      def self.check_user(user)
-        return user if user.is_a?(StarkInfra::User)
-
-        user = user.nil? ? StarkInfra.user : user
-        raise(ArgumentError, 'A user is required to access our API. Check our README: https://github.com/starkinfra/sdk-ruby/') if user.nil?
-
-        user
-      end
-
-      def self.check_language
-        language = StarkInfra.language
-        accepted_languages = %w[en-US pt-BR]
-        raise(ArgumentError, "Select a valid language: #{accepted_languages.join(', ')}") unless accepted_languages.include?(language)
-
-        language
-      end
-
-      def self.check_environment(environment)
-        environments = StarkInfra::Utils::Environment.constants(false).map { |c| StarkInfra::Utils::Environment.const_get(c) }
-        raise(ArgumentError, "Select a valid environment: #{environments.join(', ')}") unless environments.include?(environment)
-
-        environment
-      end
-
-      def self.check_private_key(pem)
-        EllipticCurve::PrivateKey.fromPem(pem)
-        pem
-      rescue
-        raise(ArgumentError, 'Private-key must be a valid secp256k1 ECDSA string in pem format')
-      end
-
-      def self.check_date_or_datetime(data)
-        return if data.nil?
-
-        return data if data.is_a?(Time) || data.is_a?(DateTime)
-
-        return data if data.is_a?(Date)
-
-        data, type = check_datetime_string(data)
-        type == 'date' ? Date.new(data.year, data.month, data.day) : data
-      end
-
-      def self.check_datetime(data)
-        return if data.nil?
-
-        return data if data.is_a?(Time) || data.is_a?(DateTime)
-
-        return Time.new(data.year, data.month, data.day) if data.is_a?(Date)
-
-        data, _type = check_datetime_string(data)
-        data
-      end
-
-      def self.check_date(data)
-        return if data.nil?
-
-        return Date.new(data.year, data.month, data.day) if data.is_a?(Time) || data.is_a?(DateTime)
-
-        return data if data.is_a?(Date)
-
-        data, type = check_datetime_string(data)
-
-        type == 'date' ? Date.new(data.year, data.month, data.day) : data
-      end
-
-      class << self
-        private
-
-        def check_datetime_string(data)
-          data = data.to_s
-
-          begin
-            return [DateTime.strptime(data, '%Y-%m-%dT%H:%M:%S.%L+00:00'), 'datetime']
-          rescue ArgumentError
-          end
-
-          begin
-            return [DateTime.strptime(data, '%Y-%m-%dT%H:%M:%S+00:00'), 'datetime']
-          rescue ArgumentError
-          end
-
-          begin
-            [DateTime.strptime(data, '%Y-%m-%d'), 'date']
-          rescue ArgumentError
-            raise(ArgumentError, 'invalid datetime string ' + data)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/utils/endtoendid.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: false
-
-require_relative('bacenid')
-
-module StarkInfra
-  module EndToEndId
-    def self.create(bank_code)
-      'E' << StarkInfra::Utils::BacenId._create(bank_code)
-    end
-  end
-end

data/lib/utils/environment.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module StarkInfra
-  module Utils
-    class Environment
-      PRODUCTION = 'production'
-      public_constant :PRODUCTION
-
-      SANDBOX = 'sandbox'
-      public_constant :SANDBOX
-
-    end
-  end
-end

data/lib/utils/request.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-require('json')
-require('starkbank-ecdsa')
-require('net/http')
-require_relative('url')
-require_relative('checks')
-require_relative('../error')
-
-module StarkInfra
-  module Utils
-    module Request
-      class Response
-        attr_reader :status, :content
-        def initialize(status, content)
-          @status = status
-          @content = content
-        end
-
-        def json
-          JSON.parse(@content)
-        end
-      end
-
-      def self.fetch(method:, path:, payload: nil, query: nil, user: nil)
-        user = Checks.check_user(user)
-        language = Checks.check_language
-
-        base_url = {
-          Environment::PRODUCTION => 'https://api.starkinfra.com/',
-          Environment::SANDBOX => 'https://sandbox.api.starkinfra.com/'
-        }[user.environment] + 'v2'
-
-        url = "#{base_url}/#{path}#{StarkInfra::Utils::URL.urlencode(query)}"
-        uri = URI(url)
-
-        access_time = Time.now.to_i
-        body = payload.nil? ? '' : payload.to_json
-        message = "#{user.access_id}:#{access_time}:#{body}"
-        signature = EllipticCurve::Ecdsa.sign(message, user.private_key).toBase64
-
-        case method
-        when 'GET'
-          req = Net::HTTP::Get.new(uri)
-        when 'DELETE'
-          req = Net::HTTP::Delete.new(uri)
-        when 'POST'
-          req = Net::HTTP::Post.new(uri)
-          req.body = body
-        when 'PATCH'
-          req = Net::HTTP::Patch.new(uri)
-          req.body = body
-        when 'PUT'
-          req = Net::HTTP::Put.new(uri)
-          req.body = body
-        else
-          raise(ArgumentError, 'unknown HTTP method ' + method)
-        end
-
-        req['Access-Id'] = user.access_id
-        req['Access-Time'] = access_time
-        req['Access-Signature'] = signature
-        req['Content-Type'] = 'application/json'
-        req['User-Agent'] = "Ruby-#{RUBY_VERSION}-SDK-Infra-0.4.0"
-        req['Accept-Language'] = language
-
-        request = Net::HTTP.start(uri.hostname, use_ssl: true) { |http| http.request(req) }
-
-        response = Response.new(Integer(request.code, 10), request.body)
-
-        raise(StarkInfra::Error::InternalServerError) if response.status == 500
-        raise(StarkInfra::Error::InputErrors, response.json['errors']) if response.status == 400
-        raise(StarkInfra::Error::UnknownError, response.content) unless response.status == 200
-
-        response
-      end
-    end
-  end
-end

data/lib/utils/resource.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-require_relative('sub_resource')
-
-module StarkInfra
-  module Utils
-    class Resource < StarkInfra::Utils::SubResource
-      attr_reader :id
-      def initialize(id = nil)
-        @id = id
-      end
-    end
-  end
-end

data/lib/utils/returnid.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: false
-
-require_relative('bacenid')
-
-module StarkInfra
-  module ReturnId
-    def self.create(bank_code)
-      'D' << StarkInfra::Utils::BacenId._create(bank_code)
-    end
-  end
-end

data/lib/utils/sub_resource.rb

@@ -1,27 +0,0 @@
-
-
-module StarkInfra
-  module Utils
-    class SubResource
-      def to_s
-        string_vars = []
-        instance_variables.each do |key|
-          value = instance_variable_get(key).to_s.lines.map(&:chomp).join("\n  ")
-          string_vars << "#{key[1..-1]}: #{value}"
-        end
-        fields = string_vars.join(",\n  ")
-        "#{class_name}(\n  #{fields}\n)"
-      end
-
-      def inspect
-        "#{class_name}[#{@id}]"
-      end
-
-      private
-
-      def class_name
-        self.class.name.split('::').last.downcase
-      end
-    end
-  end
-end

data/lib/utils/url.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-require 'erb'
-
-
-module StarkInfra
-  module Utils
-    module URL
-      # generates query string from hash
-      def self.urlencode(params)
-        return '' if params.nil?
-
-        params = StarkInfra::Utils::API.cast_json_to_api_format(params)
-        return '' if params.empty?
-
-        string_params = {}
-        params.each do |key, value|
-          string_params[key] = value.is_a?(Array) ? value.join(',') : value
-        end
-
-        query_list = []
-        string_params.each do |key, value|
-          query_list << "#{key}=#{ERB::Util.url_encode(value)}"
-        end
-        '?' + query_list.join('&')
-      end
-    end
-  end
-end