elmas 0.1.0

data/lib/elmas/exception.rb

@@ -0,0 +1,19 @@
+module Elmas
+  class BadRequestException < Exception
+    def initialize(object)
+      super(message)
+      @object = object
+    end
+
+    def message
+      case @object
+      when 500
+        "Server error"
+      else
+        "Something went wrong"
+      end
+    end
+  end
+
+  class UnauthorizedException < Exception; end
+end

data/lib/elmas/log.rb

@@ -0,0 +1,17 @@
+require "logger"
+
+module Elmas
+  module Log
+    def logger
+      Logger.new("./tmp/errors.log", "daily")
+    end
+
+    def info(msg)
+      logger.info(msg)
+    end
+
+    def error(msg)
+      logger.error(msg)
+    end
+  end
+end

data/lib/elmas/oauth.rb

@@ -0,0 +1,109 @@
+require "mechanize"
+require "uri"
+
+require File.expand_path("../utils", __FILE__)
+require File.expand_path("../response", __FILE__)
+
+# from https://developers.exactonline.com/#Example retrieve access token.html
+module Elmas
+  module OAuth
+    def authorize(user_name, password, options = {})
+      agent = Mechanize.new
+
+      login(agent, user_name, password, options)
+      allow_access(agent)
+
+      code = URI.unescape(agent.page.uri.query.split("=").last)
+      OauthResponse.new(get_access_token(code))
+    end
+
+    def authorized?
+      response = get("/Current/Me", no_division: true)
+      !response.unauthorized?
+      # Do a test call, return false if 401 or any error code
+    end
+
+    def authorize_division
+      get("/Current/Me", no_division: true).first.current_division
+    end
+
+    # Return URL for OAuth authorization
+    def authorize_url(options = {})
+      options[:response_type] ||= "code"
+      options[:redirect_uri] ||= redirect_uri
+      params = authorization_params.merge(options)
+      uri = URI("https://start.exactonline.nl/api/oauth2/auth/")
+      uri.query = URI.encode_www_form(params)
+      uri.to_s
+    end
+
+    # Return an access token from authorization
+    def get_access_token(code, _options = {})
+      conn = Faraday.new(url: "https://start.exactonline.nl") do |faraday|
+        faraday.request :url_encoded
+        faraday.adapter Faraday.default_adapter
+      end
+      params = access_token_params(code)
+      conn.post do |req|
+        req.url "/api/oauth2/token"
+        req.body = params
+        req.headers["Accept"] = "application/json"
+      end
+    end
+
+    private
+
+    def login(agent, user_name, password, options)
+      # Login
+      agent.get(authorize_url(options)) do |page|
+        form = page.forms.first
+        form["UserNameField"] = user_name
+        form["PasswordField"] = password
+        form.click_button
+      end
+    end
+
+    def allow_access(agent)
+      return if agent.page.uri.to_s.include?("getpostman")
+      form = agent.page.form_with(id: "PublicOAuth2Form")
+      button = form.button_with(id: "AllowButton")
+      agent.submit(form, button)
+    end
+
+    def authorization_params
+      {
+        client_id: client_id
+      }
+    end
+
+    def access_token_params(code)
+      {
+        client_id: client_id,
+        client_secret: client_secret,
+        grant_type: "authorization_code",
+        code: code,
+        redirect_uri: redirect_uri
+      }
+    end
+  end
+end
+
+module Elmas
+  class OauthResponse < Response
+    def body
+      JSON.parse(@response.body)
+    end
+
+    def access_token
+      body["access_token"]
+    end
+
+    def division
+      body["division"]
+    end
+
+    def refresh_token
+      body["refresh_token"]
+    end
+  end
+end

data/lib/elmas/parser.rb

@@ -0,0 +1,15 @@
+module Elmas
+  class Parser
+    def initialize(json)
+      @object = JSON.parse(json)
+    end
+
+    def results
+      @object["d"]["results"]
+    end
+
+    def first_result
+      results[0]
+    end
+  end
+end

data/lib/elmas/request.rb

@@ -0,0 +1,58 @@
+module Elmas
+  # Defines HTTP request methods
+  module Request
+    # Perform an HTTP GET request
+    def get(path, options = {})
+      request(:get, path, options)
+    end
+
+    # Perform an HTTP POST request
+    def post(path, options = {})
+      request(:post, path, options)
+    end
+
+    # Perform an HTTP PUT request
+    def put(path, options = {})
+      request(:put, path, options)
+    end
+
+    # Perform an HTTP DELETE request
+    def delete(path, options = {})
+      request(:delete, path, options)
+    end
+
+    private
+
+    def build_path(path, options)
+      path = "#{division}/#{path}" unless options[:no_division]
+      path = "#{endpoint}/#{path}" unless options[:no_endpoint]
+      path = "#{options[:url] || base_url}/#{path}"
+      path
+    end
+
+    def add_headers
+      headers = {}
+      headers["Content-Type"] = "application/#{response_format}"
+      headers["Accept"] = "application/#{response_format}"
+      headers["Authorization"] = "Bearer #{access_token}" if access_token
+      headers
+    end
+
+    # Perform an HTTP request
+    def request(method, path, options = {})
+      path = build_path(path, options)
+
+      response = connection.send(method) do |request|
+        case method
+        when :post, :put
+          request.url path
+          request.body = options[:params].to_json
+        when :get, :delete
+          request.url path
+        end
+        request.headers = add_headers
+      end
+      Response.new(response)
+    end
+  end
+end

data/lib/elmas/resource.rb

@@ -0,0 +1,112 @@
+require File.expand_path("../utils", __FILE__)
+require File.expand_path("../exception", __FILE__)
+require File.expand_path("../uri", __FILE__)
+
+module Elmas
+  module Resource
+    include UriMethods
+
+    STANDARD_FILTERS = [:id].freeze
+
+    attr_accessor :attributes, :url
+    attr_reader :response
+
+    def initialize(attributes = {})
+      @attributes = Utils.normalize_hash(attributes)
+      @filters = STANDARD_FILTERS
+      @query = []
+    end
+
+    def find_all(options = {})
+      @order_by = options[:order_by]
+      @select = options[:select]
+      get(uri([:order, :select]))
+    end
+
+    # Pass filters in an array, for example 'filters: [:id, :name]'
+    def find_by(options = {})
+      @filters = options[:filters]
+      @order_by = options[:order_by]
+      @select = options[:select]
+      get(uri([:order, :select, :filters]))
+    end
+
+    def find
+      return nil unless id?
+      get(uri([:filters]))
+    end
+
+    # Normally use the url method (which applies the filters) but sometimes you only want to use the base path or other paths
+    def get(uri = self.uri)
+      @response = Elmas.get(URI.unescape(uri.to_s))
+    end
+
+    def valid?
+      valid = true
+      mandatory_attributes.each do |attribute|
+        valid = @attributes.key? attribute
+      end
+      valid
+    end
+
+    def id?
+      !@attributes[:id].nil?
+    end
+
+    def save
+      attributes_to_submit = sanitize
+      if valid?
+        if id?
+          return @response = Elmas.put(basic_identifier_uri, params: attributes_to_submit)
+        else
+          return @response = Elmas.post(base_path, params: attributes_to_submit)
+        end
+      else
+        Elmas.error("Invalid Resource #{self.class.name}, attributes: #{@attributes.inspect}")
+        Elmas::Response.new(Faraday::Response.new(status: 400, body: "Invalid Request"))
+      end
+    end
+
+    def delete
+      return nil unless id?
+      Elmas.delete(basic_identifier_uri)
+    end
+
+    # Parse the attributes for to post to the API
+    def sanitize
+      to_submit = {}
+      @attributes.each do |key, value|
+        next if key == :id || !valid_attribute?(key)
+        key = Utils.parse_key(key)
+        value.is_a?(Elmas::Resource) ? submit_value = value.id : submit_value = value # Turn relation into ID
+        to_submit[key] = submit_value
+      end
+      to_submit
+    end
+
+    # Getter/Setter for resource
+    def method_missing(method, *args, &block)
+      yield if block
+      if /^(\w+)=$/ =~ method
+        set_attribute($1, args[0])
+      else
+        nil unless @attributes[method.to_sym]
+      end
+      @attributes[method.to_sym]
+    end
+
+    private
+
+    def set_attribute(attribute, value)
+      @attributes[attribute.to_sym] = value if valid_attribute?(attribute)
+    end
+
+    def valid_attribute?(attribute)
+      valid_attributes.include?(attribute.to_sym)
+    end
+
+    def valid_attributes
+      @valid_attributes ||= mandatory_attributes.inject(other_attributes, :<<)
+    end
+  end
+end

data/lib/elmas/resources/account.rb

@@ -0,0 +1,40 @@
+module Elmas
+  class Account
+    # An account needs a name
+    include Elmas::Resource
+
+    def base_path
+      "crm/Accounts"
+    end
+
+    def mandatory_attributes
+      [:name]
+    end
+
+    # https://start.exactonline.nl/docs/HlpRestAPIResourcesDetails.aspx?id=9
+    def other_attributes # rubocop:disable Metrics/MethodLength
+      [
+        :accountant, :account_manager, :activity_sector,
+        :activity_sub_sector, :address_line1, :address_line2,
+        :address_line3, :blocked, :business_type, :can_drop_ship,
+        :chamber_of_commerce, :city, :code, :code_at_supplier,
+        :company_size, :consolidation_scenario, :controlled_date,
+        :cost_paid, :country, :credit_line_purchase, :credit_line_sales,
+        :discount_purchase, :discount_sales, :email, :end_date, :fax,
+        :intra_stat_area, :intra_stat_delivery_term, :intra_stat_system,
+        :intra_stat_transaction_a, :intra_stat_transaction_b,
+        :intra_stat_transport_method, :invoice_acount, :invoice_attachment_type,
+        :invoicing_method, :is_accountant, :is_agency, :is_competitor, :is_mailing,
+        :is_pilot, :is_reseller, :is_sales, :is_supplier, :language, :latitude,
+        :lead_source, :logo, :logo_file_name, :longitude, :main_contact,
+        :payment_condition_purchase, :payment_condition_sales, :phone,
+        :phone_extension, :postcode, :price_list, :purchase_currency,
+        :purchase_lead_days, :purchase_VAT_code, :recipient_of_commissions,
+        :remarks, :reseller, :sales_currency, :sales_tax_schedule, :sales_vat_code,
+        :search_code, :security_level, :seperate_inv_per_project, :seperate_inv_per_subscription,
+        :shipping_lead_days, :shipping_method, :start_date, :state, :status,
+        :VAT_liability, :VAT_number, :website
+      ]
+    end
+  end
+end

data/lib/elmas/resources/contact.rb

@@ -0,0 +1,18 @@
+module Elmas
+  class Contact
+    # A contact needs a First and Last name and a reference to an account
+    include Elmas::Resource
+
+    def base_path
+      "crm/Contacts"
+    end
+
+    def mandatory_attributes
+      [:first_name, :last_name, :account]
+    end
+
+    def other_attributes
+      []
+    end
+  end
+end

data/lib/elmas/resources/invoice.rb

@@ -0,0 +1,19 @@
+module Elmas
+  class Invoice
+    # An invoice usually has multiple invoice lines
+    # It should also have a journal id and a contact id who ordered it
+    include Elmas::Resource
+
+    def base_path
+      "salesinvoice/SalesInvoices"
+    end
+
+    def mandatory_attributes
+      [:journal, :ordered_by]
+    end
+
+    def other_attributes
+      [:sales_invoice_lines, :type]
+    end
+  end
+end

data/lib/elmas/resources/invoice_line.rb

@@ -0,0 +1,18 @@
+module Elmas
+  class InvoiceLine
+    # An invoice_line should always have a reference to an item and to an invoice.
+    include Elmas::Resource
+
+    def base_path
+      "salesinvoice/SalesInvoiceLines"
+    end
+
+    def mandatory_attributes
+      [:item]
+    end
+
+    def other_attributes
+      [:discount, :quantity, :amount_FC, :description, :vat_code]
+    end
+  end
+end

data/lib/elmas/resources/item.rb

@@ -0,0 +1,17 @@
+module Elmas
+  class Item
+    include Elmas::Resource
+
+    def base_path
+      "logistics/Items"
+    end
+
+    def other_attributes
+      []
+    end
+
+    def mandatory_attributes
+      [:code, :description]
+    end
+  end
+end