starkbank 0.0.1

data/lib/utils/cache.rb

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

data/lib/utils/case.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module StarkBank
+  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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require('starkbank-ecdsa')
+require('date')
+require_relative('../user/user')
+require_relative('environment')
+
+module StarkBank
+  module Utils
+    class Checks
+      def self.check_user(user)
+        return user if user.is_a?(StarkBank::User)
+
+        user = user.nil? ? StarkBank.user : user
+        raise(ArgumentError, 'A user is required to access our API. Check our README: https://github.com/starkbank/sdk-ruby/') if user.nil?
+
+        user
+      end
+
+      def self.check_environment(environment)
+        environments = StarkBank::Utils::Environment.constants(false).map { |c| StarkBank::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_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)
+
+        check_datetime_string(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 = check_datetime_string(data)
+
+        Date.new(data.year, data.month, data.day)
+      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')
+          rescue ArgumentError
+          end
+
+          begin
+            return DateTime.strptime(data, '%Y-%m-%dT%H:%M:%S+00:00')
+          rescue ArgumentError
+          end
+
+          begin
+            return DateTime.strptime(data, '%Y-%m-%d')
+          rescue ArgumentError
+            raise(ArgumentError, 'invalid datetime string ' + data)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/utils/environment.rb

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

data/lib/utils/request.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require('json')
+require('starkbank-ecdsa')
+require('net/http')
+require_relative('url')
+require_relative('checks')
+require_relative('../error')
+
+module StarkBank
+  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)
+
+        base_url = {
+          Environment::PRODUCTION => 'https://api.starkbank.com/',
+          Environment::SANDBOX => 'https://sandbox.api.starkbank.com/'
+        }[user.environment] + 'v2'
+
+        url = "#{base_url}/#{path}#{StarkBank::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-0.0.1"
+
+        request = Net::HTTP.start(uri.hostname, use_ssl: true) { |http| http.request(req) }
+
+        response = Response.new(Integer(request.code, 10), request.body)
+
+        raise(StarkBank::Error::InternalServerError) if response.status == 500
+        raise(StarkBank::Error::InputErrors, response.json['errors']) if response.status == 400
+        raise(StarkBank::Error::UnknownError, response.content) unless response.status == 200
+
+        response
+      end
+    end
+  end
+end

data/lib/utils/resource.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module StarkBank
+  module Utils
+    class Resource
+      attr_reader :id
+      def initialize(id = nil)
+        @id = id
+      end
+
+      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/rest.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require_relative('request')
+require_relative('api')
+
+module StarkBank
+  module Utils
+    module Rest
+      def self.get_list(resource_name:, resource_maker:, user: nil, **query)
+        limit = query[:limit]
+        query[:limit] = limit.nil? ? limit : [limit, 100].min
+
+        Enumerator.new do |enum|
+          loop do
+            json = StarkBank::Utils::Request.fetch(
+              method: 'GET',
+              path: StarkBank::Utils::API.endpoint(resource_name),
+              query: query,
+              user: user
+            ).json
+            entities = json[StarkBank::Utils::API.last_name_plural(resource_name)]
+
+            entities.each do |entity|
+              enum << StarkBank::Utils::API.from_api_json(resource_maker, entity)
+            end
+
+            unless limit.nil?
+              limit -= 100
+              query[:limit] = [limit, 100].min
+            end
+
+            cursor = json['cursor']
+            query['cursor'] = cursor
+
+            break if cursor.nil? || (!limit.nil? && limit <= 0)
+          end
+        end
+      end
+
+      def self.get_id(resource_name:, resource_maker:, id:, user: nil)
+        json = StarkBank::Utils::Request.fetch(
+          method: 'GET',
+          path: "#{StarkBank::Utils::API.endpoint(resource_name)}/#{id}",
+          user: user
+        ).json
+        entity = json[StarkBank::Utils::API.last_name(resource_name)]
+        StarkBank::Utils::API.from_api_json(resource_maker, entity)
+      end
+
+      def self.get_pdf(resource_name:, resource_maker:, id:, user: nil)
+        StarkBank::Utils::Request.fetch(
+          method: 'GET',
+          path: "#{StarkBank::Utils::API.endpoint(resource_name)}/#{id}/pdf",
+          user: user
+        ).content
+      end
+
+      def self.post(resource_name:, resource_maker:, entities:, user: nil)
+        jsons = []
+        entities.each do |entity|
+          jsons << StarkBank::Utils::API.api_json(entity)
+        end
+        payload = { StarkBank::Utils::API.last_name_plural(resource_name) => jsons }
+        json = StarkBank::Utils::Request.fetch(
+          method: 'POST',
+          path: StarkBank::Utils::API.endpoint(resource_name),
+          payload: payload,
+          user: user
+        ).json
+        returned_jsons = json[StarkBank::Utils::API.last_name_plural(resource_name)]
+        entities = []
+        returned_jsons.each do |returned_json|
+          entities << StarkBank::Utils::API.from_api_json(resource_maker, returned_json)
+        end
+        entities
+      end
+
+      def self.post_single(resource_name:, resource_maker:, entity:, user: nil)
+        json = StarkBank::Utils::Request.fetch(
+          method: 'POST',
+          path: StarkBank::Utils::API.endpoint(resource_name),
+          payload: StarkBank::Utils::API.api_json(entity),
+          user: user
+        ).json
+        entity_json = json[StarkBank::Utils::API.last_name(resource_name)]
+        StarkBank::Utils::API.from_api_json(resource_maker, entity_json)
+      end
+
+      def self.delete_id(resource_name:, resource_maker:, id:, user: nil)
+        json = StarkBank::Utils::Request.fetch(
+          method: 'DELETE',
+          path: "#{StarkBank::Utils::API.endpoint(resource_name)}/#{id}",
+          user: user
+        ).json
+        entity = json[StarkBank::Utils::API.last_name(resource_name)]
+        StarkBank::Utils::API.from_api_json(resource_maker, entity)
+      end
+
+      def self.patch_id(resource_name:, resource_maker:, id:, user: nil, **payload)
+        json = StarkBank::Utils::Request.fetch(
+          method: 'PATCH',
+          path: "#{StarkBank::Utils::API.endpoint(resource_name)}/#{id}",
+          user: user,
+          payload: StarkBank::Utils::API.cast_json_to_api_format(payload)
+        ).json
+        entity = json[StarkBank::Utils::API.last_name(resource_name)]
+        StarkBank::Utils::API.from_api_json(resource_maker, entity)
+      end
+    end
+  end
+end

data/lib/utils/url.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module StarkBank
+  module Utils
+    module URL
+      # generates query string from hash
+      def self.urlencode(params)
+        return '' if params.nil?
+
+        params = StarkBank::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}=#{value}"
+        end
+        '?' + query_list.join('&')
+      end
+    end
+  end
+end

data/lib/webhook/event.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require('json')
+require('starkbank-ecdsa')
+require_relative('../utils/resource')
+require_relative('../utils/rest')
+require_relative('../utils/checks')
+require_relative('../utils/cache')
+require_relative('../error')
+require_relative('../boleto/log')
+require_relative('../transfer/log')
+require_relative('../payment/boleto/log')
+require_relative('../payment/utility/log')
+
+module StarkBank
+  # # Webhook Event object
+  #
+  # An Event is the notification received from the subscription to the Webhook.
+  # Events cannot be created, but may be retrieved from the Stark Bank API to
+  # list all generated updates on entities.
+  #
+  # ## Attributes:
+  # - id [string]: unique id returned when the log is created. ex: "5656565656565656"
+  # - log [Log]: a Log object from one the subscription services (TransferLog, BoletoLog, BoletoPaymentlog or UtilityPaymentLog)
+  # - created [DateTime]: creation datetime for the notification event. ex: DateTime.new(2020, 3, 10, 10, 30, 0, 0)
+  # - is_delivered [bool]: true if the event has been successfully delivered to the user url. ex: False
+  # - subscription [string]: service that triggered this event. ex: "transfer", "utility-payment"
+  class Event < StarkBank::Utils::Resource
+    attr_reader :id, :log, :created, :is_delivered, :subscription
+    def initialize(id:, log:, created:, is_delivered:, subscription:)
+      super(id)
+      @created = StarkBank::Utils::Checks.check_datetime(created)
+      @is_delivered = is_delivered
+      @subscription = subscription
+
+      maker = {
+        'transfer': StarkBank::Transfer::Log.resource,
+        'boleto': StarkBank::Boleto::Log.resource,
+        'boleto-payment': StarkBank::BoletoPayment::Log.resource,
+        'utility-payment': StarkBank::UtilityPayment::Log.resource
+      }[subscription.to_sym][:resource_maker]
+
+      @log = StarkBank::Utils::API.from_api_json(maker, log)
+    end
+
+    # # Retrieve a specific notification Event
+    #
+    # Receive a single notification Event object previously created in the Stark Bank API by passing its id
+    #
+    # ## Parameters (required):
+    # - id [string]: object unique id. ex: "5656565656565656"
+    #
+    # ## Parameters (optional):
+    # - user [Project object]: Project object. Not necessary if StarkBank.user was set before function call
+    #
+    # ## Return:
+    # - Event object with updated attributes
+    def self.get(id:, user: nil)
+      StarkBank::Utils::Rest.get_id(id: id, user: user, **resource)
+    end
+
+    # # Retrieve notification Events
+    #
+    # Receive a generator of notification Event 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
+    # - is_delivered [bool, default nil]: bool to filter successfully delivered events. ex: True or False
+    # - after [Date, default nil]: date filter for objects created only after specified date. ex: Date.new(2020, 3, 10)
+    # - before [Date, default nil]: date filter for objects only before specified date. ex: Date.new(2020, 3, 10)
+    # - user [Project object, default nil]: Project object. Not necessary if StarkBank.user was set before function call
+    #
+    # ## Return:
+    # - generator of Event objects with updated attributes
+    def self.query(limit: nil, is_delivered: nil, after: nil, before: nil, user: nil)
+      after = StarkBank::Utils::Checks.check_date(after)
+      before = StarkBank::Utils::Checks.check_date(before)
+      StarkBank::Utils::Rest.get_list(user: user, limit: limit, is_delivered: is_delivered, after: after, before: before, **resource)
+    end
+
+    # # Delete a notification Event
+    #
+    # Delete a of notification Event entity previously created in the Stark Bank API by its ID
+    #
+    # ## Parameters (required):
+    # - id [string]: Event unique id. ex: "5656565656565656"
+    #
+    # ## Parameters (optional):
+    # - user [Project object]: Project object. Not necessary if StarkBank.user was set before function call
+    #
+    # ## Return:
+    # - deleted Event with updated attributes
+    def self.delete(id:, user: nil)
+      StarkBank::Utils::Rest.delete_id(id: id, user: user, **resource)
+    end
+
+    # # Update notification Event entity
+    #
+    # Update notification Event by passing id.
+    # If is_delivered is True, the event will no longer be returned on queries with is_delivered=False.
+    #
+    # ## Parameters (required):
+    # - id [list of strings]: Event unique ids. ex: "5656565656565656"
+    # - is_delivered [bool]: If True and event hasn't been delivered already, event will be set as delivered. ex: True
+    #
+    # ## Parameters (optional):
+    # - user [Project object]: Project object. Not necessary if StarkBank.user was set before function call
+    #
+    # ## Return:
+    # - target Event with updated attributes
+    def self.update(id:, is_delivered:, user: nil)
+      StarkBank::Utils::Rest.patch_id(id: id, user: user, is_delivered: is_delivered, **resource)
+    end
+
+    # # Create single notification Event from a content string
+    #
+    # Create a single Event object received from event listening at subscribed user endpoint.
+    # If the provided digital signature does not check out with the StarkBank public key, a
+    # starkbank.exception.InvalidSignatureException will be raised.
+    #
+    # ## 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 [Project object]: Project object. Not necessary if StarkBank.user was set before function call
+    #
+    # ## Return:
+    # - Parsed Event object
+    def self.parse(content:, signature:, user: nil)
+      event = StarkBank::Utils::API.from_api_json(resource[:resource_maker], JSON.parse(content)['event'])
+
+      return event if verify_signature(content: content, signature: signature, user: user)
+
+      return event if verify_signature(content: content, signature: signature, user: user, refresh: true)
+
+      raise(StarkBank::Error::InvalidSignatureError, 'The provided signature and content do not match the Stark Bank public key')
+    end
+
+    class << self
+      private
+
+      def verify_signature(content:, signature:, user:, refresh: false)
+        signature = EllipticCurve::Signature.fromBase64(signature)
+        public_key = StarkBank::Utils::Cache.starkbank_public_key
+        if public_key.nil? || refresh
+          pem = get_public_key_pem(user)
+          public_key = EllipticCurve::PublicKey.fromPem(pem)
+          StarkBank::Utils::Cache.starkbank_public_key = public_key
+        end
+        EllipticCurve::Ecdsa.verify(content, signature, public_key)
+      end
+
+      def get_public_key_pem(user)
+        StarkBank::Utils::Request.fetch(method: 'GET', path: 'public-key', query: {limit: 1}, user: user).json['publicKeys'][0]['content']
+      end
+
+      def resource
+        {
+          resource_name: 'Event',
+          resource_maker: proc { |json|
+            Event.new(
+              id: json['id'],
+              log: json['log'],
+              created: json['created'],
+              is_delivered: json['is_delivered'],
+              subscription: json['subscription']
+            )
+          }
+        }
+      end
+    end
+  end
+end

data/lib/webhook/webhook.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require_relative('../utils/resource')
+require_relative('../utils/rest')
+require_relative('../utils/checks')
+
+module StarkBank
+  # # Webhook subscription object
+  #
+  # A Webhook is used to subscribe to notification events on a user-selected endpoint.
+  # Currently available services for subscription are transfer, boleto, boleto-payment,
+  # and utility-payment
+  #
+  # ## Parameters (required):
+  # - url [string]: Url that will be notified when an event occurs.
+  # - subscriptions [list of strings]: list of any non-empty combination of the available services. ex: ["transfer", "boleto-payment"]
+  #
+  # ## Attributes:
+  # - id [string, default nil]: unique id returned when the log is created. ex: "5656565656565656"
+  class Webhook < StarkBank::Utils::Resource
+    attr_reader :url, :subscriptions, :id
+    def initialize(url:, subscriptions:, id: nil)
+      super(id)
+      @url = url
+      @subscriptions = subscriptions
+    end
+
+    # # Create Webhook subscription
+    #
+    # Send a single Webhook subscription for creation in the Stark Bank API
+    #
+    # ## Parameters (required):
+    # - url [string]: url to which notification events will be sent to. ex: "https://webhook.site/60e9c18e-4b5c-4369-bda1-ab5fcd8e1b29"
+    # - subscriptions [list of strings]: list of any non-empty combination of the available services. ex: ["transfer", "boleto-payment"]
+    #
+    # ## Parameters (optional):
+    # - user [Project object]: Project object. Not necessary if StarkBank.user was set before function call
+    #
+    # ## Return:
+    # - Webhook object with updated attributes
+    def self.create(url:, subscriptions:, id: nil, user: nil)
+      StarkBank::Utils::Rest.post_single(entity: Webhook.new(url: url, subscriptions: subscriptions), user: user, **resource)
+    end
+
+    # # Retrieve a specific Webhook subscription
+    #
+    # Receive a single Webhook subscription object previously created in the Stark Bank API by passing its id
+    #
+    # ## Parameters (required):
+    # - id [string]: object unique id. ex: "5656565656565656"
+    #
+    # ## Parameters (optional):
+    # - user [Project object]: Project object. Not necessary if StarkBank.user was set before function call
+    #
+    # ## Return:
+    # - Webhook object with updated attributes
+    def self.get(id:, user: nil)
+      StarkBank::Utils::Rest.get_id(id: id, user: user, **resource)
+    end
+
+    # # Retrieve Webhook subcriptions
+    #
+    # Receive a generator of Webhook subcription 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
+    # - user [Project object, default nil]: Project object. Not necessary if StarkBank.user was set before function call
+    #
+    # ## Return:
+    # - generator of Webhook objects with updated attributes
+    def self.query(limit: nil, user: nil)
+      StarkBank::Utils::Rest.get_list(user: user, limit: limit, **resource)
+    end
+
+    # # Delete a Webhook entity
+    #
+    # Delete a Webhook entity previously created in the Stark Bank API
+    #
+    # ## Parameters (required):
+    # - id [string]: Webhook unique id. ex: "5656565656565656"
+    #
+    # ## Parameters (optional):
+    # - user [Project object]: Project object. Not necessary if StarkBank.user was set before function call
+    #
+    # ## Return:
+    # - deleted Webhook with updated attributes
+    def self.delete(id:, user: nil)
+      StarkBank::Utils::Rest.delete_id(id: id, user: user, **resource)
+    end
+
+    def self.resource
+      {
+        resource_name: 'Webhook',
+        resource_maker: proc { |json|
+          Webhook.new(
+            id: json['id'],
+            url: json['url'],
+            subscriptions: json['subscriptions']
+          )
+        }
+      }
+    end
+  end
+end