moloni_api 0.1.0

data/lib/moloni_api/api.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require_relative 'api_exceptions'
+require_relative 'configuration'
+require_relative 'constants'
+require_relative 'http_status_codes'
+require 'json'
+
+module MoloniApi
+  # Core class responsible for api interface operations
+  class API
+    include ApiExceptions
+    include Constants
+    include HttpStatusCodes
+
+    attr_reader(*MoloniApi.configuration.property_names, :token, :endpoint)
+
+    attr_accessor :current_options
+
+    # Callback to update current configuration options
+    class_eval do
+      MoloniApi.configuration.property_names.each do |key|
+        define_method "#{key}=" do |arg|
+          instance_variable_set("@#{key}", arg)
+          current_options.merge!({ "#{key}": arg })
+        end
+      end
+    end
+
+    API_ENDPOINT = 'https://api.moloni.pt/sandbox/'
+    HTTP_STATUS_MAPPING = {
+      HTTP_BAD_REQUEST_CODE => BadRequestError,
+      HTTP_UNAUTHORIZED_CODE => UnauthorizedError,
+      HTTP_FORBIDDEN_CODE => ForbiddenError,
+      HTTP_NOT_FOUND_CODE => NotFoundError,
+      HTTP_UNPROCESSABLE_ENTITY_CODE => UnprocessableEntityError,
+      'default' => ApiError
+    }.freeze
+
+    # Create new API
+    #
+    # @api public
+    def initialize(options = {}, &block)
+      opts = MoloniApi.configuration.fetch.merge(options)
+      @current_options = opts
+
+      MoloniApi.configuration.property_names.each do |key|
+        send("#{key}=", opts[key])
+      end
+      @api_access_token = opts[:access_token] # If not provided will need to ask for credentials
+      @api_client_id = opts[:client_id] || ENV['MOLONI_API_CLIENT_ID']
+      @api_client_secret = opts[:client_secret] || ENV['MOLONI_API_CLIENT_SECRET']
+      @api_endpoint = opts[:endpoint] || ENV['MOLONI_API_ENDPOINT'] || API_ENDPOINT
+
+      yield_or_eval(&block) if block_given?
+    end
+
+    # Call block with argument
+    #
+    # @api private
+    def yield_or_eval(&block)
+      return unless block
+
+      block.arity.positive? ? yield(self) : instance_eval(&block)
+    end
+
+    private
+
+    def client
+      # provide your own logger
+      logger = Logger.new $stderr
+      logger.level = Logger::DEBUG
+      @client ||= Faraday.new(@api_endpoint) do |client|
+        client.request :url_encoded
+        #client.request :json
+        #client.response :json
+        client.adapter Faraday.default_adapter
+        client.response :logger, logger
+      end
+    end
+
+    def request(http_method:, endpoint:, params: {}, query_params: {}, add_access_token: true)
+      if add_access_token
+        query_params[:access_token] = @api_access_token
+        query_params[:json] = true
+      end
+      response = client.public_send(http_method, endpoint) do |req|
+        req.headers['Content-Type'] = 'application/json'
+        req.params = query_params
+        req.body = params.to_json if params.size
+      end
+      logger = Logger.new $stderr
+      logger.debug('Response: ' + response.body)
+
+      if response_successful?(response)
+        parsed_response = Oj.load(response.body)
+        return parsed_response
+      end
+
+      raise error_class(response), "Code: #{response.status}, response: #{response.body}"
+    end
+
+    def error_class(response)
+      if HTTP_STATUS_MAPPING.include?(response.status)
+        HTTP_STATUS_MAPPING[response.status]
+      else
+        HTTP_STATUS_MAPPING['default']
+      end
+    end
+
+    def response_successful?(response)
+      response.status == HTTP_OK_CODE
+    end
+
+    # Responds to attribute query or attribute clear
+    #
+    # @api private
+    def method_missing(method_name, *args, &block)
+      # :nodoc:
+      case method_name.to_s
+      when /^(.*)\?$/
+        !!send(Regexp.last_match(1).to_s)
+      when /^clear_(.*)$/
+        send("#{Regexp.last_match(1)}=", nil)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      method_name.to_s.start_with?('clear_') || super
+    end
+  end
+end
+# mapi = MoloniApi.new(token: )

data/lib/moloni_api/api_exceptions.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module MoloniApi
+  module ApiExceptions
+    APIExceptionError = Class.new(StandardError)
+    BadRequestError = Class.new(APIExceptionError)
+    UnauthorizedError = Class.new(APIExceptionError)
+    ForbiddenError = Class.new(APIExceptionError)
+    ApiRequestsQuotaReachedError = Class.new(APIExceptionError)
+    NotFoundError = Class.new(APIExceptionError)
+    UnprocessableEntityError = Class.new(APIExceptionError)
+    ApiError = Class.new(APIExceptionError)
+  end
+end

data/lib/moloni_api/client.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'logger'
+require_relative 'api'
+require_relative 'models/product'
+
+module MoloniApi
+  # Main client class that implements communication with the API
+  # other_params - view documentation for additional options:
+  # https://www.moloni.pt/dev/endpoints/
+  # - qty
+  # - offset
+  # global:
+  # - access_token
+  # - json
+  # - human_errors
+  class Client < API
+
+    attr_accessor :api_access_token, :api_refresh_token
+
+    def authenticate(user_username, user_password)
+      response = request(
+        http_method: :get,
+        endpoint: 'grant/',
+        query_params: {
+          grant_type: 'password',
+          client_id: @api_client_id,
+          client_secret: @api_client_secret,
+          username: user_username,
+          password: user_password
+        },
+        add_access_token: false
+      )
+      res = process_response(response)
+      self.api_access_token = res[:access_token]
+      self.api_refresh_token = res[:refresh_token]
+      return res
+    end
+
+    def renew_token(refresh_token = nil)
+      response = request(
+        http_method: :get,
+        endpoint: 'grant/',
+        query_params: {
+          grant_type: 'refresh_token',
+          client_id: @api_client_id,
+          client_secret: @api_client_secret,
+          refresh_token: refresh_token || @api_refresh_token
+        },
+        add_access_token: false
+      )
+      res = process_response(response)
+      @api_access_token = res[:access_token]
+      return res
+    end
+
+    def companies(other_params: {})
+      response = request(
+        http_method: :get,
+        endpoint: 'companies/getAll/',
+        query_params: other_params
+      )
+      process_response(response)
+    end
+
+    # MoloniApi::Client.new.calendar(38859, '2022-01-01', '2022-07-31')
+    def documents_getAll(company_id, customer_id: nil, your_reference: nil, our_reference: nil, other_params: {})
+      response = request(
+        http_method: :post,
+        endpoint: 'documents/getAll/',
+        params: {
+          company_id: company_id,
+          customer_id: customer_id,
+          your_reference: your_reference,
+          our_reference: our_reference,
+        }.merge(other_params)
+      )
+      process_response(response)
+    end
+
+    def simplifiedInvoices_getAll(company_id, customer_id: nil, your_reference: nil, our_reference: nil, other_params: {})
+      response = request(
+        http_method: :post,
+        endpoint: 'simplifiedInvoices/getAll/',
+        params: {
+          company_id: company_id,
+          customer_id: customer_id,
+          your_reference: your_reference,
+          our_reference: our_reference,
+        }.merge(other_params)
+      )
+      process_response(response)
+    end
+
+    def invoiceReceipts_getAll(company_id, customer_id: nil, your_reference: nil, our_reference: nil, other_params: {})
+      response = request(
+        http_method: :post,
+        endpoint: 'invoiceReceipts/getAll/',
+        params: {
+          company_id: company_id,
+          customer_id: customer_id,
+          your_reference: your_reference,
+          our_reference: our_reference,
+        }.merge(other_params)
+      )
+      process_response(response)
+    end
+
+    # documentSets/getAll
+    def documentSets_getAll(company_id)
+      response = request(
+        http_method: :post,
+        endpoint: 'documentSets/getAll/',
+        params: {
+          company_id: company_id
+        }
+      )
+      process_response(response)
+    end
+
+    # paymentMethods/getAll/
+    def paymentMethods_getAll(company_id)
+      response = request(
+        http_method: :post,
+        endpoint: 'paymentMethods/getAll/',
+        params: {
+          company_id: company_id
+        }
+      )
+      process_response(response)
+    end
+
+    # customers/getAll/
+    def customers_getAll(company_id)
+      response = request(
+        http_method: :post,
+        endpoint: 'customers/getAll/',
+        params: {
+          company_id: company_id
+        }
+      )
+      process_response(response)
+    end
+
+    # customers/insert/
+    def customers_insert(company_id, customer_data: {})
+      # mandatory customer params:
+      # vat, number, name, language_id, address, city, country_id, maturity_date_id, payment_method_id
+      # optional params:
+      # email, zip_code, phone
+      response = request(
+        http_method: :post,
+        endpoint: 'customers/insert/',
+        params: { company_id: company_id }.merge(customer_data)
+      )
+      process_response(response)
+    end
+
+    def invoices_insert(company_id, invoice_params: {}, products: [])
+      # mandatory invoice params:
+      # date, expiration_date, document_set_id, customer_id, products
+      # optional params:
+      # our_reference, your_reference
+      response = request(
+        http_method: :post,
+        endpoint: 'invoices/insert/',
+        params: { company_id: company_id, products: products }.merge(invoice_params)
+      )
+      process_response(response)
+    end
+
+    def simplifiedInvoices_insert(company_id, invoice_params: {}, products: [], payments: [])
+      # mandatory invoice params:
+      # date, expiration_date, document_set_id, customer_id, products, payments
+      # optional params:
+      # our_reference, your_reference...
+      response = request(
+        http_method: :post,
+        endpoint: 'simplifiedInvoices/insert/',
+        params: {
+          company_id: company_id,
+          products: products,
+          payments: payments
+        }.merge(invoice_params)
+      )
+      process_response(response)
+    end
+
+    # invoiceReceipts/insert/
+    def invoiceReceipts_insert(company_id, invoice_params: {}, products: [], payments: [])
+      # mandatory invoice params:
+      # date, expiration_date, document_set_id, customer_id, products, payments
+      # optional params:
+      # our_reference, your_reference...
+      response = request(
+        http_method: :post,
+        endpoint: 'invoiceReceipts/insert/',
+        params: {
+          company_id: company_id,
+          products: products,
+          payments: payments
+        }.merge(invoice_params)
+      )
+      process_response(response)
+    end
+
+    def products_getBySearch(company_id, search_str, other_params: {})
+      response = request(
+        http_method: :post,
+        endpoint: 'products/getBySearch/',
+        params: {
+          company_id: company_id,
+          search: search_str,
+        }.merge(other_params)
+      )
+      process_response(response)
+    end
+
+    def products_getByReference(company_id, reference, other_params: {})
+      response = request(
+        http_method: :post,
+        endpoint: 'products/getByReference/',
+        params: {
+          company_id: company_id,
+          reference: reference,
+        }.merge(other_params)
+      )
+      process_response(response)
+    end
+
+    protected
+
+    def process_response(response)
+      result = response
+      case result
+      when Hash
+        result.transform_keys!(&:to_sym)
+        result.values.each do |r|
+          process_response(r)
+        end
+      when Array
+        result.each do |r|
+          process_response(r)
+        end
+      end
+      result
+    end
+  end
+end

data/lib/moloni_api/configuration.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'api/config'
+require_relative 'version'
+
+module MoloniApi
+  # Stores the configuration
+  class Configuration < API::Config
+    property :follow_redirects, default: true
+
+    # The api endpoint used to connect to MoloniApi if none is set
+    # prd: https://api.moloni.pt/v1/
+    # sandbox: https://api.moloni.pt/sandbox/
+    property  :endpoint, default: 'https://api.moloni.pt/sandbox/'
+
+    # The value sent in the http header for 'User-Agent' if none is set
+    property  :user_agent, default: "MoloniApi API Ruby Gem #{MoloniApi::VERSION}"
+
+    # By default uses the Faraday connection options if none is set
+    property  :connection_options, default: {}
+
+    # By default display 30 resources
+    property :per_page, default: 20
+
+    # Add Faraday::RackBuilder to overwrite middleware
+    property :stack
+  end
+end

data/lib/moloni_api/constants.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module MoloniApi
+  # Constants
+  module Constants
+    # Response headers
+    RATELIMIT_REMAINING = 'X-RateLimit-Remaining'
+
+    RATELIMIT_LIMIT = 'X-RateLimit-Limit'
+
+    RATELIMIT_RESET = 'X-RateLimit-Reset'
+
+    CONTENT_TYPE = 'Content-Type'
+
+    CONTENT_LENGTH = 'content-length'
+
+    CACHE_CONTROL = 'cache-control'
+
+    ETAG = 'ETag'
+
+    SERVER = 'Server'
+
+    DATE = 'Date'
+
+    LOCATION = 'Location'
+
+    USER_AGENT = 'User-Agent'
+
+    ACCEPT = 'Accept'
+
+    ACCEPT_CHARSET = 'Accept-Charset'
+
+    OAUTH_SCOPES = 'X-OAuth-Scopes'
+
+    ACCEPTED_OAUTH_SCOPES = 'X-Accepted-Oauth-Scopes'
+
+    # Link headers
+    HEADER_LINK = 'Link'
+
+    HEADER_NEXT = 'X-Next'
+
+    HEADER_LAST = 'X-Last'
+
+    META_REL = 'rel'
+
+    META_LAST = 'last'
+
+    META_NEXT = 'next'
+
+    META_FIRST = 'first'
+
+    META_PREV = 'prev'
+
+    PARAM_PAGE = 'page'
+
+    PARAM_PER_PAGE = 'per_page'
+
+    PARAM_START_PAGE = 'start_page'
+
+    PARAM_INCLUDE_RELATED = 'include_related_objects'
+  end
+end

data/lib/moloni_api/http_status_codes.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module MoloniApi
+  module HttpStatusCodes
+    HTTP_OK_CODE = 200
+
+    HTTP_BAD_REQUEST_CODE = 400
+    HTTP_UNAUTHORIZED_CODE = 401
+    HTTP_FORBIDDEN_CODE = 403
+    HTTP_NOT_FOUND_CODE = 404
+    HTTP_UNPROCESSABLE_ENTITY_CODE = 429
+  end
+end

data/lib/moloni_api/models/product.rb

@@ -0,0 +1,120 @@
+module MoloniApi
+  module Models
+    class Product
+      ##
+      # company_id int
+      # Obrigatório
+      #
+      # category_id int
+      # Obrigatório
+      #
+      # type int
+      # Obrigatório
+      #
+      # name string
+      # Obrigatório
+      #
+      # summary string
+      # Facultativo
+      #
+      # reference string
+      # Obrigatório
+      #
+      # ean string
+      # Facultativo
+      #
+      # price float
+      # Obrigatório
+      #
+      # unit_id int
+      # Obrigatório
+      #
+      # has_stock int
+      # Obrigatório
+      #
+      # stock float
+      # Obrigatório
+      #
+      # minimum_stock float
+      # Facultativo
+      #
+      # pos_favorite int
+      # Facultativo
+      #
+      # at_product_category string
+      # Facultativo
+      #
+      # exemption_reason string
+      # Facultativo
+      #
+      # taxes array
+      # Facultativo
+      #
+      # tax_id int
+      # Obrigatório
+      #
+      # value float
+      # Obrigatório
+      #
+      # order int
+      # Obrigatório
+      #
+      # cumulative int
+      # Obrigatório
+      #
+      # suppliers array
+      # Facultativo
+      #
+      # supplier_id int
+      # Obrigatório
+      #
+      # cost_price float
+      # Obrigatório
+      #
+      # referenceint
+      # Facultativo
+      #
+      # properties array
+      # Facultativo
+      #
+      # property_id int
+      # Obrigatório
+      #
+      # value string
+      # Obrigatório
+      #
+      # warehouses array
+      # Facultativo
+      #
+      # warehouse_id int
+      # Obrigatório
+      #
+      # stock float
+      # Obrigatório
+      def initialize(raw_result)
+        @raw_result = raw_result
+
+        @company_id = raw_result[:company_id]
+        @product_id = raw_result[:product_id]
+        @category = raw_result[:category]
+        @type = raw_result[:type]
+        @name = raw_result[:name]
+        @summary = raw_result[:summary]
+        @reference = raw_result[:reference]
+        @ean = raw_result[:ean]
+        @price = raw_result[:price]
+        @unit_id = raw_result[:unit_id]
+        @has_stock = raw_result[:has_stock]
+        @stock = raw_result[:stock]
+        @minimum_stock = raw_result[:minimum_stock]
+        @pos_favorite = raw_result[:pos_favorite]
+        @at_product_category = raw_result[:at_product_category]
+        @exemption_reason = raw_result[:exemption_reason]
+        @taxes = raw_result[:taxes] # array
+        @suppliers = raw_result[:suppliers] # array
+        @properties = raw_result[:properties] # array
+        @warehouses = raw_result[:warehouses] # array
+      end
+    end
+  end
+end

data/lib/moloni_api/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module MoloniApi
+  VERSION = '0.1.0'
+end