QNE 0.1.0

data/lib/connection.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require_relative 'agents'
+require_relative 'customers'
+require_relative 'customer_categories'
+require_relative 'default_tax_code'
+require_relative 'sales_invoices'
+require_relative 'sales_orders'
+require_relative 'stocks'
+require_relative 'stock_locations'
+require_relative 'system_version'
+require_relative 'terms'
+require_relative 'uoms'
+require_relative 'tax_codes'
+require_relative 'users'
+
+module QNE
+  class Connection
+    BASE_URI = 'https://dev-api.qne.cloud'.freeze
+
+    # You can provide your own block before executing retry function
+    def initialize(options = {}, &retry_block)
+      @db_code = options.fetch(:db_code, nil) || ENV['QNE_DB_CODE']
+      @api_token = options.fetch(:api_token, nil)
+      @retry_block = retry_block
+    end
+
+    def system_version
+      @system_version ||= QNE::SystemVersion.new(connection).call
+    end
+
+    def agents
+      @agents ||= QNE::Agents.new(connection)
+    end
+
+    def customers
+      @customers ||= QNE::Customers.new(connection)
+    end
+
+    def customer_categories
+      @customer_categories ||= QNE::CustomerCategories.new(connection)
+    end
+
+    def default_tax_code
+      @default_tax_code ||= QNE::DefaultTaxCode.new(connection).call
+    end
+
+    def sales_invoices
+      @sales_invoices ||= QNE::SalesInvoices.new(connection)
+    end
+
+    def sales_orders
+      @sales_orders ||= QNE::SalesOrders.new(connection)
+    end
+
+    def stocks
+      @stocks ||= QNE::Stocks.new(connection)
+    end
+
+    def terms
+      @terms ||= QNE::Terms.new(connection)
+    end
+
+    def stock_locations
+      @stock_locations ||= QNE::StockLocations.new(connection)
+    end
+
+    def uoms
+      @uoms ||= QNE::UOMs.new(connection)
+    end
+
+    def tax_codes
+      @tax_codes ||= QNE::TaxCodes.new(connection)
+    end
+
+    def users
+      @users ||= QNE::Users.new(Faraday.new(url: BASE_URI))
+    end
+
+    def connected?
+      QNE::SystemVersion.new(connection).call
+    rescue Faraday::TimeoutError
+      false
+    end
+
+    def authenticated?
+      qne = QNE::SystemVersion.new(connection)
+      qne.call
+      qne.success?
+    end
+
+    def connection
+      @connection ||= Faraday.new(faraday_params) do |conn|
+        conn.request :retry, retry_options
+        conn.adapter Faraday.default_adapter
+      end
+    end
+
+    private
+
+    def faraday_params
+      @faraday_params ||= {
+        url: BASE_URI,
+        headers: auth_method,
+        request: request_options
+      }
+    end
+
+    def retry_options
+      @retry_options ||= {
+        retry_statuses: [401, 409, 500],
+        max: ENV.fetch('MAX_REQUEST_RETRY', '3').to_i, # total request will be made is 4
+        interval: ENV.fetch('INTERVAL_RETRY_NUMBER', '10').to_i, # interval each retry request
+        backoff_factor: 0,
+        exceptions: [Faraday::ResourceNotFound, Faraday::UnauthorizedError, Faraday::TimeoutError, Faraday::ConnectionFailed],
+        retry_block: @retry_block
+      }
+    end
+
+    def auth_method
+      @api_token ? bearer_auth : dbcode_auth
+    end
+
+    def dbcode_auth
+      { 'DbCode' => @db_code }
+    end
+
+    def bearer_auth
+      { 'Authorization' => "Bearer #{@api_token}" }
+    end
+
+    def request_options
+      {
+        read_timeout: ENV.fetch('FARADAY_READ_TIMEOUT', '60').to_i,
+        timeout: ENV.fetch('FARADAY_TIMEOUT', '60').to_i
+      }
+    end
+  end
+end

data/lib/customer_categories.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'QNE/customer_category/all'
+
+module QNE
+  class CustomerCategories < Base
+    include ::QNE::QueryBuilder
+
+    def all(params = {})
+      @response = QNE::CustomerCategory::All.new(
+        conn, params: uri_query(params)
+      ).call
+
+      parse_to_json(@response.body)
+    end
+  end
+end

data/lib/customers.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative 'QNE/customer/all'
+require_relative 'QNE/customer/create'
+require_relative 'QNE/customer/find_by'
+require_relative 'QNE/customer/show'
+require_relative 'QNE/customer/update'
+require_relative 'QNE/customer/find'
+
+module QNE
+  class Customers < Base
+    attr_accessor :id, :customer
+
+    include ::QNE::QueryBuilder
+
+    def find(id)
+      @id = id
+      finder = QNE::Customer::Find.new(conn, id: id).call
+
+      return unless finder.success?
+
+      define_singleton_method 'show' do
+        parse_to_json(finder.body)
+      end
+
+      self
+    end
+
+    def all(params = {})
+      @response = QNE::Customer::All.new(
+        conn, params: uri_query(params)
+      ).call
+
+      parse_to_json(@response.body)
+    end
+
+    def find_by(params)
+      @response = QNE::Customer::FindBy.new(
+        conn, params: eq_query(params)
+      ).call
+
+      body = parse_to_json(@response.body)
+
+      @response.success? ? body.first : body
+    end
+
+    def create(request_body)
+      @response = QNE::Customer::Create.new(
+        conn, request_body: request_body
+      ).call
+
+      parse_to_json(@response.body)
+    end
+
+    def show(id)
+      @response = QNE::Customer::Show.new(
+        conn, id: id
+      ).call
+
+      parse_to_json(@response.body)
+    end
+
+    def update(request_body)
+      @response = QNE::Customer::Update.new(
+        conn, request_body: request_body
+      ).call
+
+      parse_to_json(@response.body)
+    end
+  end
+end

data/lib/default_tax_code.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module QNE
+  class DefaultTaxCode < Base
+    include ::QNE::QueryBuilder
+
+    PATH = '/api/DefaultTaxCodes/OutputTaxCode'.freeze
+
+    def call
+      @response = conn.get(PATH)
+
+      parse_to_json(@response.body)
+    end
+  end
+end

data/lib/query_builder.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module QNE
+  module QueryBuilder
+    OPERATORS = {
+      eq: {
+        string: "COLUMN OPERATOR 'VALUE'",
+        default: "COLUMN OPERATOR VALUE",
+      },
+      in: {
+        default: "COLUMN OPERATOR (VALUE)"
+      }
+    }.freeze
+
+    def eq_query(queries)
+      filters = queries.map { |column, value| "#{column} eq '#{value}'" }
+      filters.join(' and ')
+    end
+
+    def multi_query(queries)
+      filters = queries.map do |column, operators|
+        operators.map do |operator, value|
+          parse_query_by_operator(column, operator, value)
+        end
+      end
+
+      filters.join(' and ')
+    end
+
+    def uri_query(queries)
+      return filterables if queries.empty?
+
+      filters = queries.map do |filter, value|
+        { "$#{filter}" => value }
+      end
+
+      filterables.merge(filters.reduce(&:merge))
+    end
+
+    def where(params)
+      filterables['$filter'] = multi_query(params)
+
+      self
+    end
+
+    private
+
+    def parse_query_by_operator(col, operator, val)
+      string = OPERATORS[operator.to_sym]
+      datatype = val.class.name.downcase.to_sym
+
+      return "#{col} #{operator} #{val}" unless string
+
+      query = String.new(string[datatype] || string[:default])
+
+      query.gsub!(/COLUMN/, col.to_s)
+      query.gsub!(/OPERATOR/, operator.to_s)
+      query.gsub!(/VALUE/, val)
+    end
+
+    def filterables
+      @filterables ||= {}
+    end
+  end
+end

data/lib/sales_invoices.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative 'QNE/sales_invoice/find_by'
+require_relative 'QNE/sales_invoice/all'
+require_relative 'QNE/sales_invoice/show'
+require_relative 'QNE/sales_invoice/create'
+require_relative 'QNE/sales_invoice/update'
+require_relative 'QNE/sales_invoice/download'
+
+module QNE
+  class SalesInvoices < Base
+    include ::QNE::QueryBuilder
+
+    def find_by(params)
+      @response = QNE::SalesInvoice::FindBy.new(
+        conn, params: eq_query(params)
+      ).call
+
+      body = parse_to_json(@response.body)
+
+      @response.success? ? body.first : body
+    end
+
+    def all(params = {})
+      @response = QNE::SalesInvoice::All.new(
+        conn, params: uri_query(params)
+      ).call
+
+      parse_to_json(@response.body)
+    end
+
+    def show(id)
+      @response = QNE::SalesInvoice::Show.new(
+        conn, id: id
+      ).call
+
+      parse_to_json(@response.body)
+    end
+
+    def create(request_body)
+      @response = QNE::SalesInvoice::Create.new(
+        conn, request_body: request_body
+      ).call
+
+      parse_to_json(@response.body)
+    end
+
+    def update(request_body)
+      @response = QNE::SalesInvoice::Update.new(
+        conn, request_body: request_body
+      ).call
+
+      parse_to_json(@response.body)
+    end
+
+    def download(id, type = :sales_invoice)
+      @response = QNE::SalesInvoice::Download.new(
+        conn, id: id, type: type
+      ).call
+
+      parse_to_json(@response.body)
+    end
+  end
+end

data/lib/sales_orders.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative 'QNE/sales_order/all'
+require_relative 'QNE/sales_order/show'
+require_relative 'QNE/sales_order/create'
+
+module QNE
+  class SalesOrders < Base
+    include ::QNE::QueryBuilder
+
+    def all(params = {})
+      @response = QNE::SalesOrder::All.new(
+        conn, params: uri_query(params)
+      ).call
+
+      parse_to_json(@response.body)
+    end
+
+    def show(id)
+      @response = QNE::SalesOrder::Show.new(
+        conn, id: id
+      ).call
+
+      parse_to_json(@response.body)
+    end
+
+    def create(request_body)
+      @response = QNE::SalesOrder::Create.new(
+        conn, request_body: request_body
+      ).call
+
+      parse_to_json(@response.body)
+    end
+  end
+end

data/lib/stock_locations.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative 'QNE/stock_location/all'
+
+module QNE
+  class StockLocations < Base
+    include ::QNE::QueryBuilder
+
+    def all
+      @response = QNE::StockLocation::All.new(conn).call
+
+      parse_to_json(@response.body)
+    end
+  end
+end

data/lib/stocks.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative 'QNE/stock/all'
+require_relative 'QNE/stock/uoms'
+require_relative 'QNE/stock/find'
+
+module QNE
+  class Stocks < Base
+    include ::QNE::QueryBuilder
+
+    attr_reader :id
+
+    def find(id)
+      finder = QNE::Stocks::Find.new(conn, id: id).call
+
+      return unless finder.success?
+
+      define_singleton_method 'uoms' do
+        find_uoms_by_id(id)
+      end
+
+      define_singleton_method 'show' do
+        @response = parse_to_json(finder.body)
+      end
+
+      self
+    end
+
+    def all(params = {})
+      @response = QNE::Stock::All.new(
+        conn, params: uri_query(params)
+      ).call
+
+      parse_to_json(@response.body)
+    end
+
+    def find_uoms_by_id(id)
+      @response = QNE::Stock::UOMs.new(
+        conn, id: id
+      ).call
+
+      parse_to_json(@response.body)
+    end
+  end
+end

data/lib/system_version.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module QNE
+  class SystemVersion < Base
+    PATH = '/api/System/Version'.freeze
+
+    def call
+      @response = conn.get(PATH)
+
+      parse_to_json(@response.body)
+    end
+  end
+end

data/lib/tax_codes.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative 'QNE/tax_code/all'
+require_relative 'QNE/tax_code/output_tax_codes'
+require_relative 'QNE/tax_code/input_tax_codes'
+
+module QNE
+  class TaxCodes < Base
+    include ::QNE::QueryBuilder
+
+    def all(params = {})
+      @response = QNE::TaxCode::All.new(
+        conn, params: uri_query(params)
+      ).call
+
+      parse_to_json(@response.body)
+    end
+
+    def output_tax_codes(params = {})
+      @response = QNE::TaxCode::OutputTaxCodes.new(
+        conn, params: uri_query(params)
+      ).call
+
+      parse_to_json(@response.body)
+    end
+
+    def input_tax_codes(params = {})
+      @response = QNE::TaxCode::InputTaxCodes.new(
+        conn, params: uri_query(params)
+      ).call
+
+      parse_to_json(@response.body)
+    end
+  end
+end

data/lib/terms.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative 'QNE/term/all'
+require_relative 'QNE/term/show'
+
+module QNE
+  class Terms < Base
+    include ::QNE::QueryBuilder
+
+    def all(params = {})
+      @response = QNE::Term::All.new(
+        conn, params: uri_query(params)
+      ).call
+
+      parse_to_json(@response.body)
+    end
+
+    def show(id)
+      @response = QNE::Term::Show.new(
+        conn, id: id
+      ).call
+
+      parse_to_json(@response.body)
+    end
+  end
+end

data/lib/uoms.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'QNE/uom/all'
+
+module QNE
+  class UOMs < Base
+    include ::QNE::QueryBuilder
+
+    def all(params = {})
+      @response = QNE::UOM::All.new(
+        conn, params: uri_query(params)
+      ).call
+
+      parse_to_json(@response.body)
+    end
+  end
+end

data/lib/users.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'QNE/user/login'
+
+module QNE
+  class Users < Base
+    def login(username:, password:, db_code:)
+      @response = QNE::User::Login.new(
+        @conn, params: {
+          dbCode: db_code,
+          userName: username,
+          password: password
+        }
+      ).call
+
+      parse_to_json(@response.body)
+    end
+  end
+end

data/sig/QNE.rbs

@@ -0,0 +1,4 @@
+module QNE
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end