fcoin_ruby_client 0.1.0

data/lib/fcoin/request.rb

@@ -0,0 +1,73 @@
+require_relative 'authorization'
+require_relative 'formatter'
+
+# Scope Fcoin::API
+module Fcoin
+  module Request
+    # Perform an HTTP GET request
+    def get(path, auth=true, payload={})
+      request(:get, path, auth, payload)
+    end
+
+    # Perform an HTTP POST request
+    def post(path, auth=true, payload={})
+      request(:post, path, auth, payload)
+    end
+
+    # Perform an HTTP PUT request
+    def put(path, auth=true, payload={})
+      request(:put, path, auth, payload)
+    end
+
+    # Perform an HTTP DELETE request
+    def delete(path, auth=true, payload={})
+      request(:delete, path, auth, payload)
+    end
+
+    private
+
+    # Perform an HTTP request
+    def request(http_method, path, auth, payload)
+      response = connection.send(http_method) do |request|
+        required = {
+          http_method: http_method,
+          path:        path,
+          payload:     payload,
+          endpoint:    endpoint,
+          api_key:     api_key,
+          secret_key:  secret_key
+        }
+        
+        if auth
+          auth = Fcoin::Authorization.new(required)
+          request.headers.merge!(auth.original_headers)
+        end
+
+        case http_method
+        when :get, :delete
+          request.url(path, payload)
+        when :post, :put
+          request.path = path
+          request.body = payload unless payload.empty?
+        end
+      end
+
+      return formatted(response.body)
+    end
+
+    # change the output format of the body
+    #
+    # @param body [Hash]
+    # @return [Hash or JSON]
+    def formatted(body)
+      case format_type
+      when :json
+        body.to_json
+      when :hash
+        body
+      else
+        raise "format_type is #{format_type}. format_type must be included in [:json, :hash]."
+      end
+    end
+  end
+end

data/lib/fcoin/validator/market_validator.rb

@@ -0,0 +1,60 @@
+require_relative 'validator_utility'
+
+module Fcoin
+  class MarketValidator
+    include ValidatorUtility
+
+    # @params params [Hash] Parameter you want to verify including the called method name
+    # @option params :level [String or Symbol] Level of depth chart
+    # @option params :resolution [String or Symbol] period of Candles Chart
+    # @option params :method_name [String or Symbol] invoked method name
+    def initialize(params)
+      self.level       = params[:level]
+      self.resolution  = params[:resolution]
+      self.method_name = params[:method_name]
+    end
+
+    # Validate according to method_name
+    def valid?
+      case method_name
+      when /market_depth|on_depth/
+        valid_level?
+      when /market_candles|on_candle/
+        valid_resolution?
+      end
+    end
+
+    # Error message when invalid
+    def messages
+      return {} if valid?
+      results = []
+      case method_name
+      when /market_depth|on_depth/
+        results << includes_error_message(level, :level, valid_levels) unless valid_level?
+      when /market_candles|on_candle/
+        results << includes_error_message(resolution, :resolution, valid_resolutions) unless valid_resolution?
+      end
+      results.compact&.each_with_object({}) { |message, data| data.merge!(message) }
+    end
+
+    private
+
+    attr_accessor :level, :resolution, :method_name
+
+    def valid_level?
+      level.to_s.in? valid_levels
+    end
+
+    def valid_resolution?
+      resolution.to_s.in? valid_resolutions
+    end
+
+    def valid_levels
+      ::Settings.fcoin.validation.params.level
+    end
+
+    def valid_resolutions
+      ::Settings.fcoin.validation.params.resolution
+    end
+  end
+end

data/lib/fcoin/validator/orders/base_validator.rb

@@ -0,0 +1,96 @@
+module Fcoin
+  module Orders
+    class BaseValidator
+
+      # @param params [Hash] Parameter you want to verify including the called method name
+      # @option params :symbol [String or Symbol] Transaction pair
+      # @option params :side [String or Symbol] Direction of the transaction
+      # @option params :price [Float]
+      # @option params :total [Float]
+      # @option params :amount [Float]
+      # @option params :states [String] Order state
+      def initialize(params)
+        self.symbol      = params[:symbol]
+        self.side        = params[:side]
+        self.price       = params[:price]
+        self.total       = params[:total]
+        self.amount      = params[:amount]
+        self.states      = params[:states]
+      end
+
+      # Validate according to method_name
+      # @abstract Subclass and override {#valid?} to implement
+      def valid?
+        raise 'Please be implemented in inheriting.'
+      end
+
+      # Error message when invalid
+      # @abstract Subclass and override {#messages} to implement
+      def messages
+        raise 'Please be implemented in inheriting.'
+      end
+
+      private
+
+      attr_accessor :symbol, :side, :type, :price, :total, :amount, :states
+
+      def valid_symbol?
+        symbol.present?
+      end
+
+      def valid_side?
+        side.to_s.in? valid_sides
+      end
+
+      def valid_type?
+        type.to_s.in? valid_types
+      end
+
+      def valid_states?
+        states_arr = states.to_s.gsub(' ','')&.split(',')
+        states_arr.present? && states_arr.map { |state| state.in? valid_states }.all?
+      end
+
+      def valid_price?
+        price.present? && price.between?(min(:price), max(:price))
+      end
+
+      def valid_total?
+        total.present? && total.between?(min(:total), max(:total))
+      end
+
+      def valid_amount?
+        amount.present? && amount.between?(min(:amount), max(:amount))
+      end
+
+      def min(type)
+        valid_symbol_setting_exist? ? valid_symbols[symbol][type].to_h[:min] : 0
+      end
+
+      def max(type)
+        valid_symbol_setting_exist? ? valid_symbols[symbol][type].to_h[:max] : 0
+      end
+
+      def valid_symbol_setting_exist?
+        valid_symbols[symbol].present?
+      end
+
+      def valid_sides
+        ::Settings.fcoin.validation.params.side
+      end
+
+      def valid_types
+        ::Settings.fcoin.validation.params.type
+      end
+
+      def valid_states
+        ::Settings.fcoin.validation.params.states
+      end
+
+      # @abstract Subclass and override {#valid_symbols} to implement
+      def valid_symbols
+        raise 'Please be implemented in inheriting.'
+      end
+    end
+  end
+end

data/lib/fcoin/validator/orders/create_order_limit_validator.rb

@@ -0,0 +1,54 @@
+require_relative 'base_validator'
+require_relative '../validator_utility'
+
+module Fcoin
+  module Orders
+    class CreateOrderLimitValidator < BaseValidator
+      include ValidatorUtility
+
+      # @param params [Hash] Parameter you want to verify including the called method name
+      # @option params :symbol [String or Symbol] Transaction pair
+      # @option params :side [String or Symbol] Direction of the transaction
+      # @option params :price [Float]
+      # @option params :amount [Float]
+      def initialize(params)
+        self.symbol      = params[:symbol]
+        self.side        = params[:side]
+        self.price       = params[:price]
+        self.amount      = params[:amount]
+      end
+
+      # Validate according to method_name
+      def valid?
+        if valid_symbol_setting_exist?
+          valid_price? && valid_amount?
+        else
+          valid_symbol? && valid_side?
+        end
+      end
+
+      # Error message when invalid
+      def messages
+        return {} if valid?
+        results = []
+
+        results << presence_error_message(symbol, :symbol) unless valid_symbol?
+        results << includes_error_message(side, :side, valid_sides) unless valid_side?
+        if valid_symbol_setting_exist?
+          results << between_error_message(price,  :price,  min(:price),  max(:price)) unless valid_price?
+          results << between_error_message(amount, :amount, min(:amount), max(:amount)) unless valid_amount?
+        end
+        results.compact&.each_with_object({}) { |message, data| data.merge!(message) }
+      end
+
+      private
+
+      def valid_symbols
+        return HashWithIndifferentAccess.new unless valid_side?
+        ::Settings.fcoin.validation.limit[side].to_h.values.flatten.compact.each_with_object(HashWithIndifferentAccess.new) do |setting, data|
+          data[setting.symbol] = setting
+        end
+      end
+    end
+  end
+end

data/lib/fcoin/validator/orders/create_order_market_validator.rb

@@ -0,0 +1,95 @@
+require_relative 'base_validator'
+require_relative '../validator_utility'
+
+module Fcoin
+  module Orders
+    class CreateOrderMarketValidator < BaseValidator
+      include ValidatorUtility
+
+      # @param params [Hash] Parameter you want to verify including the called method name
+      # @option params :symbol [String or Symbol] Transaction pair
+      # @option params :side [String or Symbol] Direction of the transaction
+      # @option params :total [Float]
+      # @option params :amount [Float]
+      def initialize(params)
+        self.symbol      = params[:symbol]
+        self.side        = params[:side]
+        self.total       = params[:amount] # this is not a mistake
+        self.amount      = params[:amount]
+      end
+
+      # Validate according to method_name
+      def valid?
+        case
+        when valid_symbol_setting_exist?
+          case
+          when sell?
+            valid_amount?
+          when buy?
+            valid_total?
+          end
+        when invalid_symbol_setting_exist?
+          false
+        else
+          valid_symbol? && valid_side?
+        end
+      end
+
+      # Error message when invalid
+      def messages
+        return {} if valid?
+        results = []
+        results << presence_error_message(symbol, :symbol) unless valid_symbol?
+        results << includes_error_message(side, :side, valid_sides) unless valid_side?
+
+        case
+        when valid_symbol_setting_exist?
+          case
+          when sell?
+            results << between_error_message(amount, :amount, min(:amount), max(:amount)) unless valid_amount?
+          when buy?
+            results << between_error_message(total, :total, min(:total), max(:total)) unless valid_total?
+          end
+        when invalid_symbol_setting_exist?
+          results << invalid_create_order_market_error_message(symbol, :symbol)
+        end
+        results.compact&.each_with_object({}) { |message, data| data.merge!(message) }
+      end
+
+      private
+
+      def sell?
+        side.to_s == 'sell'
+      end
+
+      def buy?
+        side.to_s == 'buy'
+      end
+
+      def invalid_create_order_market_error_message(value, type)
+        message = {}
+        adjusted_value = value.present? ? value : 'nil'
+        message[type] = "#{type} is #{adjusted_value}. This #{type} board is not adapted on-going order."
+        message
+      end
+
+      def invalid_symbol_setting_exist?
+        invalid_symbols[symbol].present?
+      end
+
+      def valid_symbols
+        return HashWithIndifferentAccess.new unless valid_side?
+        ::Settings.fcoin.validation.market.valid[side].to_h.values.flatten.compact.each_with_object(HashWithIndifferentAccess.new) do |setting, data|
+          data[setting.symbol] = setting
+        end
+      end
+
+      def invalid_symbols
+        return HashWithIndifferentAccess.new unless valid_side?
+        ::Settings.fcoin.validation.market.invalid[side].to_h.values.flatten.compact.each_with_object(HashWithIndifferentAccess.new) do |setting, data|
+          data[setting] = setting
+        end
+      end
+    end
+  end
+end

data/lib/fcoin/validator/orders/order_list_validator.rb

@@ -0,0 +1,33 @@
+require_relative 'base_validator'
+require_relative '../validator_utility'
+
+module Fcoin
+  module Orders
+    class OrderListValidator < BaseValidator
+      include ValidatorUtility
+
+      # @param params [Hash] Parameter you want to verify including the called method name
+      # @option params :symbol [String or Symbol] Transaction pair
+      # @option params :states [String] Order state
+      def initialize(params)
+        self.symbol      = params[:symbol]
+        self.states      = params[:states]
+      end
+
+      # Validate according to method_name
+      def valid?
+        valid_symbol? && valid_states?
+      end
+
+      # Error message when invalid
+      def messages
+        return {} if valid?
+        results = []
+
+        results << presence_error_message(symbol, :symbol) unless valid_symbol?
+        results << includes_error_message(states, :states, valid_states) unless valid_states?
+        results.compact&.each_with_object({}) { |message, data| data.merge!(message) }
+      end
+    end
+  end
+end

data/lib/fcoin/validator/orders_validator.rb

@@ -0,0 +1,69 @@
+require_relative 'orders/create_order_limit_validator'
+require_relative 'orders/create_order_market_validator'
+require_relative 'orders/order_list_validator'
+
+module Fcoin
+  class OrdersValidator
+
+    # @param params [Hash] Parameter you want to verify including the called method name
+    # @option params :symbol [String or Symbol] Transaction pair
+    # @option params :side [String or Symbol] Direction of the transaction
+    # @option params :type [String or Symbol] Order type
+    # @option params :price [Float]
+    # @option params :amount [Float]
+    # @option params :states [String] Order state
+    # @option params :method_name [String or Symbol] invoked method name
+    def initialize(params)
+      self.symbol      = params[:symbol]
+      self.side        = params[:side]
+      self.type        = params[:type]
+      self.price       = params[:price]
+      self.amount      = params[:amount]
+      self.total       = params[:total]
+      self.states      = params[:states]
+      self.method_name = params[:method_name]
+    end
+
+    # Validate according to method_name
+    def valid?
+      validator.present? ? validator.valid? : false
+    end
+
+    # Error message when invalid
+    def messages
+      return {} if valid?
+      results = []
+      results << (validator.present? ? validator.messages : {})
+      results.compact&.each_with_object({}) { |message, data| data.merge!(message) }
+    end
+
+    private
+
+    attr_accessor :symbol, :side, :type, :price, :total, :amount, :states, :method_name
+
+    def validator
+      case method_name.to_sym
+      when :create_order_limit
+        create_order_limit_validator
+      when :create_order_market
+        create_order_market_validator
+      when :order_list
+        order_list_validator
+      else
+        nil
+      end
+    end
+
+    def create_order_limit_validator
+      @create_order_limit_validator ||= Orders::CreateOrderLimitValidator.new(symbol: symbol, side: side, price: price, amount: amount)
+    end
+
+    def create_order_market_validator
+      @create_order_market_validator ||= Orders::CreateOrderMarketValidator.new(symbol: symbol, side: side, total: total, amount: amount)
+    end
+
+    def order_list_validator
+      @order_list_validator ||= Orders::OrderListValidator.new(symbol: symbol, states: states)
+    end
+  end
+end

data/lib/fcoin/validator/validator_utility.rb

@@ -0,0 +1,24 @@
+module Fcoin
+  module ValidatorUtility
+    def includes_error_message(target, target_type, list)
+      message = {}
+      target_value = target.present? ? target : 'nil'
+      message[target_type] = "#{target_type} is #{target_value}. #{target_type} is not included in the [#{list.join(', ')}]."
+      message
+    end
+
+    def between_error_message(target, target_type, min, max)
+      message = {}
+      target_value = target.present? ? target : 'nil'
+      message[target_type] = "#{target_type} is #{target_value}. #{target_type} is not between #{min} and #{max}."
+      message
+    end
+
+    def presence_error_message(target, target_type)
+      message = {}
+      target_value = target.present? ? target : 'nil'
+      message[target_type] = "#{target_type} is #{target_value}. #{target_type} can't be blank"
+      message
+    end
+  end
+end

data/lib/fcoin/validator.rb

@@ -0,0 +1,58 @@
+require_relative 'validator/market_validator'
+require_relative 'validator/orders_validator'
+
+# Scope Fcoin::API
+module Fcoin
+  class Validator
+    # @param params [Hash] Parameter you want to verify including the called method name
+    # @option params :level [String or Symbol] Level of depth chart
+    # @option params :resolution [String or Symbol] period of Candles Chart
+    # @option params :symbol [String or Symbol] Transaction pair
+    # @option params :side [String or Symbol] Direction of the transaction
+    # @option params :type [String or Symbol] Order type
+    # @option params :price [Float]
+    # @option params :amount [Float]
+    # @option params :states [String] Order state
+    # @option params :method_name [String or Symbol] invoked method name
+    def initialize(params)
+      self.level       = params[:level]
+      self.resolution  = params[:resolution]
+      self.symbol      = params[:symbol]
+      self.side        = params[:side]
+      self.type        = params[:type]
+      self.price       = params[:price]
+      self.amount      = params[:amount]
+      self.states      = params[:states]
+      self.method_name = params[:method_name]
+    end
+
+    # Whether the parameters are valid?
+    def valid?
+      validator.present? ? validator.valid? : true
+    end
+
+    # Error message when invalid
+    def messages
+      validator.present? ? validator.messages : {}
+    end
+
+    private
+
+    def validator
+      case method_name
+      when /market_depth|on_depth/
+        MarketValidator.new(level: level, method_name: method_name)
+      when /market_candles|on_candle/
+        MarketValidator.new(resolution: resolution, method_name: method_name)
+      when /create_order/
+        OrdersValidator.new(symbol: symbol, side: side, type: type, price: price, amount: amount, method_name: method_name)
+      when /order_list/
+        OrdersValidator.new(symbol: symbol, states: states, method_name: method_name)
+      else
+        nil
+      end
+    end
+
+    attr_accessor :level, :resolution, :symbol, :side, :type, :price, :amount, :states, :method_name
+  end
+end

data/lib/fcoin/version.rb

@@ -0,0 +1,3 @@
+module Fcoin
+  VERSION = "0.1.0"
+end

data/lib/fcoin.rb

@@ -0,0 +1,11 @@
+require_relative "fcoin/version"
+require_relative "fcoin/configuration"
+require_relative "fcoin/client"
+require_relative "fcoin/realtime/client"
+require_relative "fcoin/cli"
+require_relative "fcoin/generators/validation"
+require_relative "fcoin/generators/locale"
+
+module Fcoin
+  extend Configuration
+end