justa-ruby 0.1.9

data/lib/justa/model.rb

@@ -0,0 +1,71 @@
+module Justa
+  class Model < JustaObject
+    def create
+      update Justa::Request.post(self.class.url, params: to_hash).call(class_name)
+      self
+    end
+
+    # def save
+    #   update Justa::Request.put(url, params: unsaved_attributes).call(class_name)
+    #   self
+    # end
+
+    def url(*params)
+      raise RequestError, "Invalid ID" unless primary_key.present?
+
+      self.class.url CGI.escape(primary_key.to_s), *params
+    end
+
+    def fetch
+      update self.class.find(primary_key, client_key: client_key)
+      self
+    end
+
+    def primary_key
+      tx_id
+    end
+
+    def class_name
+      self.class.to_s.split("::").last
+    end
+
+    class << self
+      def create(*args)
+        new(*args).create
+      end
+
+      def find_by_id(id, **options)
+        raise RequestError, "Invalid ID" unless id.present?
+
+        Justa::Request.get(url(id), options.merge({ append_document: false })).call underscored_class_name
+      end
+      alias find find_by_id
+
+      # def find_by(params = Hash.new, page = nil, count = nil)
+      #   params = extract_page_count_or_params(page, count, **params)
+      #   raise RequestError.new('Invalid page count') if params[:page] < 1 or params[:count] < 1
+
+      #   Justa::Request.get(url, params: params).call
+      # end
+      # alias :find_by_hash :find_by
+
+      # def all(*args, **params)
+      #   params = extract_page_count_or_params(*args, **params)
+      #   find_by params
+      # end
+      # alias :where :all
+
+      def url(*params)
+        ["/#{CGI.escape class_name}", *params].join "/"
+      end
+
+      def class_name
+        name.split("::").last.downcase
+      end
+
+      def underscored_class_name
+        name.split("::").last.gsub(/[a-z0-9][A-Z]/) { |s| "#{s[0]}_#{s[1]}" }.downcase
+      end
+    end
+  end
+end

data/lib/justa/object.rb

@@ -0,0 +1,143 @@
+module Justa
+  class JustaObject
+    attr_reader :attributes
+
+    RESOURCES = Dir[File.expand_path("resources/*.rb", __dir__)].map do |path|
+      File.basename(path, ".rb").to_sym
+    end.freeze
+
+    def initialize(response = {})
+      # raise MissingCredentialsError.new("Missing :client_key for extra options #{options}") if options && !options[:client_key]
+
+      @attributes = {}
+      @unsaved_attributes = Set.new
+
+      @client_key = response.dig(:client_key) || Justa.default_client_key # || :default
+      update response
+    end
+
+    def []=(key, value)
+      @attributes[key] = value
+      @unsaved_attributes.add key
+    end
+
+    def empty?
+      @attributes.empty?
+    end
+
+    def ==(other)
+      self.class == other.class && id == other.id
+    end
+
+    def unsaved_attributes
+      Hash[@unsaved_attributes.map do |key|
+        [key, to_hash_value(self[key], :unsaved_attributes)]
+      end]
+    end
+
+    def to_hash
+      Hash[@attributes.map do |key, value|
+        [key, to_hash_value(value, :to_hash)]
+      end]
+    end
+
+    def to_request_params
+      Hash[@attributes.map do |key, value|
+        [key.to_s.to_camel(:lower), to_hash_value(value, :to_hash)]
+      end]
+    end
+
+    def respond_to?(name, include_all = false)
+      return true if name.to_s.end_with? "="
+
+      @attributes.has_key?(name.to_s) || super
+    end
+
+    # def to_s
+    #   attributes_str = ''
+    #   (attributes.keys - ['id', 'object']).sort.each do |key|
+    #     attributes_str += " \033[1;33m#{key}:\033[0m#{self[key].inspect}" unless self[key].nil?
+    #   end
+    #   "\033[1;31m#<#{self.class.name}:\033[0;32m#{id}#{attributes_str}\033[0m\033[0m\033[1;31m>\033[0;32m"
+    # end
+    # # alias :inspect :to_s
+
+    protected
+
+    def update(attributes)
+      attributes = attributes.convert_from_request if attributes.respond_to? :convert_from_request
+      removed_attributes = @attributes.keys - attributes.to_hash.keys
+
+      removed_attributes.each do |key|
+        @attributes.delete key
+      end
+
+      attributes.each do |key, value|
+        key = key.to_s.to_snake
+
+        @attributes[key] = JustaObject.convert(value, Util.singularize(key), @client_key)
+        @unsaved_attributes.delete key
+      end
+    end
+
+    def to_hash_value(value, type)
+      case value
+      when JustaObject
+        value.send type
+      when Array
+        value.map do |v|
+          to_hash_value v, type
+        end
+      else
+        value
+      end
+    end
+
+    def method_missing(name, *args, &block)
+      name = name.to_s
+
+      unless block_given?
+        if name.end_with?("=") && args.size == 1
+          attribute_name = name[0...-1]
+          return self[attribute_name] = args[0]
+        end
+
+        return self[name] || self[name.to_sym] if args.size == 0
+      end
+
+      return attributes.public_send name, *args, &block if attributes.respond_to? name
+
+      super name, *args, &block
+    end
+
+    class << self
+      def convert(response, resource_name = nil, client_key = nil)
+        case response
+        when Array
+          response.map { |i| convert i, resource_name, client_key }
+        when Hash
+          resource_class_for(resource_name).new(response.merge({ client_key: client_key }))
+        else
+          response
+        end
+      end
+
+      protected
+
+      def resource_class_for(resource_name)
+        return Justa::JustaObject if resource_name.nil?
+
+        if RESOURCES.include? resource_name.to_sym
+          Object.const_get "Justa::#{capitalize_name resource_name}"
+        else
+          Justa::JustaObject
+        end
+      end
+
+      def capitalize_name(name)
+        name.split("_").collect(&:capitalize).join
+        # name.gsub(/(\A\w|\_\w)/){ |str| str.gsub('_', '').upcase }
+      end
+    end
+  end
+end

data/lib/justa/order_commom.rb

@@ -0,0 +1,15 @@
+module Justa
+  class OrderCommom < Model
+    # def self.url(*params)
+    #   ["/#{ CGI.escape underscored_class_name }", *params].join '/'
+    # end
+
+    #
+    # Defines primary key for model
+    #
+    # @return [String] Return the primary_key field value
+    def primary_key
+      tx_id
+    end
+  end
+end

data/lib/justa/request.rb

@@ -0,0 +1,114 @@
+require "uri"
+require "rest_client"
+require "multi_json"
+
+module Justa
+  class Request
+    DEFAULT_HEADERS = {
+      "Content-Type" => "application/json",
+      "Accept" => "application/json",
+      "User-Agent" => "justa-ruby/#{Justa::VERSION}"
+    }.freeze
+
+    attr_accessor :path, :method, :parameters, :headers, :query
+
+    def initialize(path, method, options = {})
+      @path             = path
+      @method           = method
+      @parameters       = options[:params]      || nil
+      @query            = options[:query]       || {}
+      @headers          = options[:headers]     || {}
+      @auth             = options[:auth]        || false
+      @append_document  = options.fetch(:append_document, true)
+      @client_key       = options[:client_key] || @parameters && (@parameters[:client_key] || @parameters["client_key"]) || Justa.default_client_key
+    end
+
+    def run
+      response = RestClient::Request.execute request_params
+      MultiJson.decode response.body
+    rescue RestClient::Exception => e
+      begin
+        parsed_error = MultiJson.decode e.http_body
+
+        if e.is_a? RestClient::ResourceNotFound
+          if parsed_error["message"]
+            raise Justa::NotFound.new(parsed_error, request_params, e)
+          else
+            raise Justa::NotFound.new(nil, request_params, e)
+          end
+        elsif parsed_error["message"]
+          raise Justa::ResponseError.new(request_params, e, parsed_error["message"])
+        else
+          raise Justa::ValidationError, parsed_error
+        end
+      rescue MultiJson::ParseError
+        raise Justa::ResponseError.new(request_params, e)
+      end
+    rescue MultiJson::ParseError
+      return {} unless response.code < 200 && response.code > 299
+
+      raise Justa::ResponseError.new(request_params, response)
+    rescue SocketError
+      raise Justa::ConnectionError, $!
+    rescue RestClient::ServerBrokeConnection
+      raise Justa::ConnectionError, $!
+    end
+
+    def call(ressource_name)
+      JustaObject.convert run, ressource_name, @client_key
+    end
+
+    def self.get(url, options = {})
+      new url, "GET", options
+    end
+
+    def self.auth(url, options = {})
+      options[:auth] = true
+      new url, "POST", options
+    end
+
+    def self.post(url, options = {})
+      new url, "POST", options
+    end
+
+    def self.put(url, options = {})
+      new url, "PUT", options
+    end
+
+    def self.patch(url, options = {})
+      new url, "PATCH", options
+    end
+
+    def self.delete(url, options = {})
+      new url, "DELETE", options
+    end
+
+    def request_params
+      aux = {
+        method: method,
+        url: full_api_url
+      }
+
+      @parameters
+
+      if !@auth && @parameters && method == "POST"
+        aux.merge!({ payload: MultiJson.encode(@parameters.to_request_params) })
+      elsif @parameters
+        aux.merge!({ payload: @parameters })
+      end
+
+      extra_headers = DEFAULT_HEADERS.merge(@headers)
+      extra_headers[:authorization] = "Bearer #{Justa::TokenManager.token_for @client_key}" unless @auth
+      extra_headers["integratorId"] = Justa.integrator_id unless @auth
+
+      aux.merge!({ headers: extra_headers })
+      aux
+    end
+
+    def must_append_document?; end
+
+    def full_api_url
+      Justa.api_endpoint + "/payment-provider/api" + @path + (!@auth && @append_document ? ("/" + TokenManager.client_for(@client_key).document.to_s) : "")
+    end
+  end
+end

data/lib/justa/resources/pix.rb

@@ -0,0 +1,30 @@
+module Justa
+  class Pix < OrderCommom
+    # def self.url(*params)
+    #   ["/#{ CGI.escape underscored_class_name }", *params].join '/'
+    # end
+
+    def primary_key
+      tx_id
+    end
+
+    #
+    # Request approve to Justa api for this pix ( Only in DEVELOPMENT)
+    #
+    # @param [Hash] params Parameters for function
+    # @option params [Numeric] :value (Required) The amount that will be approved in cents format
+    # @option params [String] :end_to_end_id (Optional) The reference for the payment transaction
+    # @return [Pix] Return model pix instance
+    # @example Pay 1.0 of pix
+    #     pix_instance.approve(value: 1.0)
+    def approve(**params)
+      raise JustaError, "Can't approve value in Production environment" if Justa.production?
+      raise ParamError.new("Missing value param", :value, :integer, url("approve")) unless params.has_key? :value
+
+      Justa::Request.post(url("approve"),
+                          { append_document: false,
+                            params: params.merge({ client_key: @client_key }) }).call underscored_class_name
+      fetch
+    end
+  end
+end

data/lib/justa/token_manager.rb

@@ -0,0 +1,135 @@
+module Justa
+  #
+  # Class to manage Tokens with singleton structure
+  #
+  class TokenManager
+    attr_reader :authenticators, :mutex
+
+    # private_class_method :new
+
+    #
+    # Initializes TokenManager
+    #
+    # This class builds authentication array with a mutex to share tokens
+    def initialize
+      tokens = nil
+      if Justa.credentials
+        case Justa.credentials
+        when Array
+          tokens = Justa.credentials
+        when Hash
+          tokens = [Justa.credentials]
+        end
+      else
+        tokens = [{
+          username: Justa.username,
+          password: Justa.password,
+          client_id: Justa.client_id,
+          client_secret: Justa.client_secret,
+          integrator_id: Justa.integrator_id,
+          document: Justa.document,
+          key: :default,
+          default: true
+        }]
+      end
+
+      @mutex = Mutex.new
+      @authenticators = nil
+      setup_autenticators tokens
+    end
+
+    #
+    # Sets authenticators based on tokens passed by constructor
+    #
+    # @param [Array] tokens Array of tokens to be registered as clients
+    #
+    # @return [Array] Authenticators array
+    #
+    def setup_autenticators(tokens)
+      return @authenticators if @authenticators
+
+      tokens = tokens.map { |t| Justa::Client.new(**t) }
+      @mutex.synchronize do
+        @authenticators = []
+        tokens.each do |client|
+          @authenticators << Authenticator.new(client)
+        end
+      end
+    end
+
+    #
+    # Find a token for a specific Client Key
+    #
+    # @param [Symbol] key Client Key to be found in Authenticators Array
+    #
+    # @return [String] Auth token
+    #
+    def self.token_for(key = Justa.default_client_key)
+      instance unless @instance
+      k = Justa::Util.to_sym(key)
+      raise MissingCredentialsError, "Missing credentials for key: '#{key}'" unless @instance.authenticators
+
+      @instance.mutex.synchronize do
+        auth = @instance.authenticators.find { |obj| obj.key == k }
+
+        raise MissingCredentialsError, "Missing credentials for key: '#{key}'" if auth.blank?
+
+        auth.token
+      end
+    end
+
+    #
+    # Registers a new client to be used
+    #
+    # @param [Justa::Client] client Client instance to be registered in TokenManager
+    #
+    # @return [Array] Authenticators array
+    # @example Ads a new client to be used in calls to Justa Api
+    #     Justa::TokenManager.add_client Client.new(client_id: <CLIENT_KEY>, key: :<CLIENT_ALIAS>)
+    def self.add_client(client)
+      instance unless @instance
+      client = (client.is_a? Justa::Client) ? client : Justa::Client.new(**client)
+
+      raise ParamError.new("Client key '#{client.key}' already exists", "Key", "") if client_for client.key
+
+      @instance.mutex.synchronize do
+        @instance.authenticators << Authenticator.new(client)
+      end
+    end
+
+    #
+    # Find a Client for a specific Key
+    #
+    # @param [Symbol] key Client Key to be found in Authenticators Array ( Defaults to Justa.default_client_key)
+    #
+    # @return [Justa::Client] Client instance registed with the key passed
+    #
+    def self.client_for(key = Justa.default_client_key)
+      k = Justa::Util.to_sym(key)
+      instance unless @instance
+      return nil unless @instance.authenticators.present?
+
+      @instance.mutex.synchronize do
+        auth = @instance.authenticators.find { |obj| obj.key == k }
+        auth&.client
+      end
+    end
+
+    #
+    # Find a Client Type for a specific Key
+    #
+    # @param [Symbol] key Client Key to be found in Authenticators Array ( Defaults to Justa.default_client_key)
+    #
+    # @return [Symbol] Return the cleint type ( :pdv or :e_commerce) ( Defaults to :pdv if not found)
+    #
+    def self.client_type_for(key = Justa.default_client_key)
+      client_for(key)&.type || :pdv
+    end
+
+    def self.instance
+      return @instance if @instance
+
+      @instance = TokenManager.new
+    end
+  end
+end

data/lib/justa/util.rb

@@ -0,0 +1,79 @@
+module Justa
+  class Util
+    class << self
+      SINGULARS = {
+        "/s$/i" => "",
+        "/(ss)$/i" => '\1',
+        "/(n)ews$/i" => '\1ews',
+        "/([ti])a$/i" => '\1um',
+        "/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)(sis|ses)$/i" => '\1sis',
+        "/(^analy)(sis|ses)$/i" => '\1sis',
+        "/([^f])ves$/i" => '\1fe',
+        "/(hive)s$/i" => '\1',
+        "/(tive)s$/i" => '\1',
+        "/([lr])ves$/i" => '\1f',
+        "/([^aeiouy]|qu)ies$/i" => '\1y',
+        "/(s)eries$/i" => '\1eries',
+        "/(m)ovies$/i" => '\1ovie',
+        "/(x|ch|ss|sh)es$/i" => '\1',
+        "/^(m|l)ice$/i" => '\1ouse', -
+        "/(bus)(es)?$/i" => '\1',
+        "/(o)es$/i" => '\1',
+        "/(shoe)s$/i" => '\1',
+        "/(cris|test)(is|es)$/i" => '\1is',
+        "/^(a)x[ie]s$/i" => '\1xis',
+        "/(octop|vir)(us|i)$/i" => '\1us',
+        "/(alias|status)(es)?$/i" => '\1',
+        "/^(ox)en/i" => '\1',
+        "/(vert|ind)ices$/i" => '\1ex',
+        "/(matr)ices$/i" => '\1ix',
+        "/(quiz)zes$/i" => '\1',
+        "/(database)s$/i" => '\1'
+      }
+
+      def singularize(resource)
+        out = ""
+        SINGULARS.keys.each do |key|
+          out = resource.to_s.gsub(/s$/, SINGULARS[key])
+          break out if out != resource
+        end
+        case resource.class
+        when Symbol
+          return out.to_sym
+        end
+        out
+      end
+
+      def to_sym(string)
+        string.to_s.strip.gsub(" -", "_").to_sym
+      end
+    end
+  end
+end
+
+class Hash
+  def except_nested(key)
+    r = Marshal.load(Marshal.dump(self))
+    r.except_nested!(key)
+  end
+
+  def except_nested!(key)
+    reject! { |k, _| k == key || k.to_s == key }
+    each do |_, v|
+      v.except_nested!(key) if v.is_a?(Hash)
+      v.map! { |obj| obj.except_nested!(key) if obj.is_a?(Hash) } if v.is_a?(Array)
+    end
+  end
+
+  def to_request_params
+    Hash[map do |k, v|
+      [k.to_s.to_camel(:lower), v]
+    end]
+  end
+
+  def convert_from_request
+    Hash[map do |k, v|
+      [k.to_s.to_snake, v]
+    end]
+  end
+end

data/lib/justa/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Justa
+  VERSION = "0.1.9"
+end

data/lib/justa.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "justa/version"
+require_relative "justa/authenticator"
+require_relative "justa/request"
+require_relative "justa/object"
+require_relative "justa/model"
+require_relative "justa/core_ext"
+require_relative "justa/errors"
+require_relative "justa/util"
+require_relative "justa/token_manager"
+require_relative "justa/order_commom"
+
+Dir[File.expand_path("justa/resources/*.rb", __dir__)].map do |path|
+  require path
+end
+
+module Justa
+  class Error < StandardError; end
+
+  class << self
+    attr_accessor :username, :password, :client_id, :client_secret, :integrator_id, :callback_url, :credentials,
+                  :default_client_key, :document
+    attr_reader :api_endpoint
+
+    def production?
+      env = nil
+      begin
+        env = ENV["RACK_ENV"] == "production" ||
+              ENV["RAILS_ENV"] == "production" ||
+              ENV["PRODUCTION"] ||
+              ENV["production"] || (Rails.env.production? if Object.const_defined?("::Rails"))
+      rescue NameError => e
+        return false
+      end
+
+      env || false
+    end
+  end
+
+  @default_client_key = :default
+
+  @api_endpoint = Justa.production? ? "https://gateway.justa.com.vc" : "https://integrador.staging.justa.com.vc"
+
+  puts "Running on production" if production?
+end

data/main.rb

@@ -0,0 +1,45 @@
+require_relative 'lib/Justa'
+
+Justa.secret_key = 'Q__g6ie850Pv4jVBQUeyAMA_mlJH3xG1Acg2FiPU_lYpVol9z69RHmOE4BZDMaHVGsMEg1s9BI5pvgKkCAWDdw'
+Justa.access_key='CyUqG2hSfQJbE8OTWfy1fQ'
+Justa.client_id='ubceuMCPeVygHW8xynrFYzbF3JKE1zlnpjNBReM6gDz0jzQ-5clVgRdtRRDJ5yWENkGMnC3VI2wQSyu_507g5c9ujS6D5eOSBVheKbMVbEW8qk8dYb41yqgl7o9xv-puarpHV7Dk3jv6n6_HZlAl4S8gHjNsayuj2RSqT8AbtY4'
+
+
+# Justa::Authenticator.instance()
+
+# Justa::Authenticator.headers
+sh = Justa::Order.new({
+	order_ref: "Justapag-001",
+	wallet: "Justa-pagador",
+	total: 0.51,
+	items: [
+		{
+			item_title: "Item 1",
+			unit_price: 0.30,
+			quantity: 1
+		},
+		{
+			item_title: "Item 2",
+			unit_price: 0.20,
+			quantity: 1
+		},
+		{
+			item_title: "Item 3",
+			unit_price: 0.01,
+			quantity: 1
+		}
+	],
+	buyer: {
+		name: "Justa PDV",
+		cpf_cnpj: "121.191.870-02",
+		email: "Justa-pagador@Justa.com.br",
+		phone: "+55 11 99999-9999"
+	}
+}).create
+
+  puts sh
+  # Justa.api_endpoint='https://postman-echo.com/get'
+
+  ord = Justa::Order.find_by_id(sh.order_id)
+
+  puts ord