colppy 0.1.0

data/lib/colppy/core/services.rb

@@ -0,0 +1,72 @@
+module Colppy
+  module Core
+    SERVICES = {
+      company: {
+        list: {
+          provision: "Empresa",
+          operacion: "listar_empresa"
+        },
+        read: {
+          provision: "Empresa",
+          operacion: "leer_empresa"
+        }
+      },
+      customer: {
+        list: {
+          provision: "Cliente",
+          operacion: "listar_cliente"
+        },
+        read: {
+          provision: "Cliente",
+          operacion: "leer_cliente"
+        },
+        create: {
+          provision: "Cliente",
+          operacion: "alta_cliente"
+        },
+        update: {
+          provision: "Cliente",
+          operacion: "editar_cliente"
+        }
+      },
+      product: {
+        list: {
+          provision: "Inventario",
+          operacion: "listar_itemsinventario"
+        },
+        create: {
+          provision: "Inventario",
+          operacion: "alta_iteminventario"
+        },
+        update: {
+          provision: "Inventario",
+          operacion: "editar_iteminventario"
+        }
+      },
+      sell_invoice: {
+        list: {
+          provision: "FacturaVenta",
+          operacion: "listar_facturasventa"
+        },
+        read: {
+          provision: "FacturaVenta",
+          operacion: "leer_facturaventa"
+        },
+        create: {
+          provision: "FacturaVenta",
+          operacion: "alta_facturaventa"
+        }
+      },
+      user: {
+        sign_in: {
+          provision: "Usuario",
+          operacion: "iniciar_sesion"
+        },
+        sign_out: {
+          provision: "Usuario",
+          operacion: "cerrar_sesion"
+        }
+      }
+    }.freeze
+  end
+end

data/lib/colppy/core/support/hash.rb

@@ -0,0 +1,49 @@
+# # Taken from https://github.com/futurechimp/plissken because that gem
+# # has a dependency on symbolize -> Active**
+
+module Colppy
+  module Core
+    # Colppy::Core::Hash.snakecase_keys(value)
+    module Hash
+      extend self
+      # Recursively converts CamelCase and camelBack JSON-style hash keys to
+      # Rubyish snake_case, suitable for use during instantiation of Ruby
+      # model attributes.
+      #
+      def snakecase_keys(value)
+        case value
+        when(Array)
+          value.map { |v| snakecase_keys(v) }
+        when(::Hash)
+          snake_hash(value)
+        else
+          value
+        end
+      end
+
+      private
+
+      def snake_hash(value)
+        ::Hash[value.map { |k, v| [snake_key(k).to_sym, snakecase_keys(v)] }]
+      end
+
+      def snake_key(k)
+        if k.is_a? Symbol
+          snakecase(k.to_s).to_sym
+        elsif k.is_a? String
+          snakecase(k)
+        else
+          k # Can't snakify anything except strings and symbols
+        end
+      end
+
+      def snakecase(string)
+        string.gsub(/::/, '/')
+          .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+          .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+          .tr('-', '_')
+          .downcase
+      end
+    end
+  end
+end

data/lib/colppy/digest.rb

@@ -0,0 +1,16 @@
+module Colppy
+  module Digest
+    module_function
+
+    MD5_DIGEST = OpenSSL::Digest.new("md5").freeze
+
+    def md5(string)
+      return string if valid_md5?(string)
+      MD5_DIGEST.hexdigest(string)
+    end
+
+    def valid_md5?(string)
+      !!(%r{^[a-f0-9]{32}$}i =~ string)
+    end
+  end
+end

data/lib/colppy/errors.rb

@@ -0,0 +1,7 @@
+module Colppy
+  class Error < StandardError; end
+  class ClientError < Error; end
+  class DataError < Error; end
+  class ResourceError < Error; end
+  class ServiceError < Error; end
+end

data/lib/colppy/resource.rb

@@ -0,0 +1,83 @@
+module Colppy
+  class Resource
+    VALID_INVOICE_TYPES = %w(A B C E Z I M X)
+
+    class << self
+      protected
+
+      def parse_list_response(results, total, call_parameters)
+        per_page = call_parameters[:limit] || 50
+        offset = call_parameters[:start] || 0
+        page, total_pages = pages_calculation(offset, per_page, total)
+        {
+          offset: offset,
+          total: total,
+          page: page,
+          per_page: per_page,
+          total_pages: total_pages,
+          results: results
+        }
+      end
+
+      private
+
+      def pages_calculation(offset, per_page, total)
+        total_pages = ( total.to_f / per_page.to_f ).ceil
+        remaining_pages = ((total - offset).to_f / per_page.to_f).floor
+        [(total_pages - remaining_pages), total_pages]
+      end
+    end
+
+    def inspect
+      formatted_attrs = attr_inspect.map do |attr|
+        "#{attr}: #{send(attr).inspect}"
+      end
+      "#<#{self.class.name} #{formatted_attrs.join(", ")}>"
+    end
+
+    private
+
+    def attr_inspect
+    end
+
+    def valid_date(date_string)
+      return today_date_string if date_string.nil? || date_string.empty?
+
+      parsed_date = Date.parse(date_string)
+      if parsed_date <= Date.today
+        date_string
+      else
+        today_date_string
+      end
+    end
+
+    def today_date_string
+      Date.today.strftime("%d-%m-%Y")
+    end
+
+    def ensure_client_valid!
+      unless @client && @client.is_a?(Colppy::Client)
+        raise ResourceError.new(
+          "You should provide a client, and it should be a Colppy::Client instance"
+        )
+      end
+    end
+
+    def ensure_company_valid!
+      unless @company && @company.is_a?(Colppy::Company)
+        raise ResourceError.new(
+          "You should provide a company, and it should be a Colppy::Company instance"
+        )
+      end
+    end
+
+    def ensure_customer_valid!
+      unless @customer && @customer.is_a?(Colppy::Customer)
+        raise ResourceError.new(
+          "You should provide a customer, and it should be a Colppy::Customer instance"
+        )
+      end
+    end
+
+  end
+end

data/lib/colppy/resources/company.rb

@@ -0,0 +1,123 @@
+module Colppy
+  module CompanyActions
+    extend self
+
+    def companies
+      @companies ||= Company.all(self)
+    end
+
+  end
+
+  class Company < Resource
+    attr_reader :id, :name
+
+    class << self
+      def all(client)
+        list(client)
+      end
+
+      def list(client, parameters = {})
+        response = client.call(
+          :company,
+          :list,
+          parameters.merge(client.session_params)
+        )
+        if response[:success]
+          results = response[:data].map do |params|
+            new(params.merge(client: client))
+          end
+          parse_list_response(results, response[:total].to_i, parameters)
+        else
+          response
+        end
+      end
+    end
+
+    def initialize(client: nil, **params)
+      @client = client if client && client.is_a?(Colppy::Client)
+      @id = params.delete(:IdEmpresa)
+      @name = params.delete(:razonSocial)
+      @extras = params
+    end
+
+    def customers(params = {})
+      ensure_client_valid!
+
+      if params.empty?
+        Customer.all(@client, self)
+      else
+        Customer.list(@client, self, params)
+      end
+    end
+
+    def customer_by_id(id)
+      ensure_client_valid!
+
+      Customer.get(@client, self, id)
+    end
+
+    def products(params = {})
+      ensure_client_valid!
+
+      if params.empty?
+        Product.all(@client, self)
+      else
+        Product.list(@client, self, params)
+      end
+    end
+    alias :customer :customer_by_id
+
+    def product_by_sku(sku)
+      ensure_client_valid!
+
+      params = {
+        filter: [
+          { field: "codigo", op: "=", value: sku }
+        ]
+      }
+      response = Product.list(@client, self, params)
+      response[:results].last
+    end
+
+    def product_by_id(id)
+      ensure_client_valid!
+
+      params = {
+        filter: [
+          { field: "idItem", op: "=", value: id }
+        ]
+      }
+      response = Product.list(@client, self, params)
+      response[:results].last
+    end
+    alias :product :product_by_id
+
+    def sell_invoices(params = {})
+      ensure_client_valid!
+
+      if params.empty?
+        SellInvoice.all(@client, self)
+      else
+        SellInvoice.list(@client, self, params)
+      end
+    end
+
+    def sell_invoice_by_id(id)
+      ensure_client_valid!
+
+      SellInvoice.get(@client, self, id)
+    end
+    alias :sell_invoice :sell_invoice_by_id
+
+    def params
+      { idEmpresa: @id }
+    end
+
+    private
+
+    def attr_inspect
+      [:id, :name]
+    end
+
+  end
+end

data/lib/colppy/resources/customer.rb

@@ -0,0 +1,169 @@
+module Colppy
+  class Customer < Resource
+    attr_reader :id, :name, :data
+
+    class << self
+      def all(client, company)
+        list(client, company)
+      end
+
+      def list(client, company, parameters = {})
+        call_parameters = base_params.merge(parameters)
+        response = client.call(
+          :customer,
+          :list,
+          extended_parameters(client, company, call_parameters)
+        )
+        if response[:success]
+          results = response[:data].map do |params|
+            new(params.merge(client: client, company: company))
+          end
+          parse_list_response(results, response[:total].to_i, call_parameters)
+        else
+          response
+        end
+      end
+
+      def get(client, company, id)
+        response = client.call(
+          :customer,
+          :read,
+          extended_parameters(client, company, { idCliente: id })
+        )
+        if response[:success]
+          new(response[:data].merge(client: client, company: company))
+        else
+          response
+        end
+      end
+
+      private
+
+      def extended_parameters(client, company, parameters)
+        [ client.session_params,
+          company.params,
+          parameters
+        ].inject(&:merge)
+      end
+
+      def base_params
+        {
+          filter:[],
+          order: [{
+            field: "RazonSocial",
+            dir: "asc"
+          }]
+        }
+      end
+
+    end
+
+    def initialize(client: nil, company: nil, **params)
+      @client = client if client && client.is_a?(Colppy::Client)
+      @company = company if company && company.is_a?(Colppy::Company)
+      @id = params.delete(:idCliente)
+      @name = params.delete(:RazonSocial)
+      @data = params
+    end
+
+    def new?
+      id.nil? || id.empty?
+    end
+
+    def save
+      ensure_client_valid! && ensure_company_valid!
+
+      response = @client.call(
+        :customer,
+        operation,
+        save_parameters
+      )
+      if response[:success]
+        response_data = response[:data]
+        case operation
+        when :create
+          @id = response_data[:idCliente]
+        when :update
+          @data[:NombreFantasia] = response_data[:nombreCliente]
+        end
+        self
+      else
+        false
+      end
+    end
+
+    def name=(new_name)
+      @name = new_name
+    end
+
+    def []=(key, value)
+      key_sym = key.to_sym
+      if protected_data_keys.include?(key_sym)
+        raise ResourceError.new("You cannot change any of this values: #{protected_data_keys.join(", ")} manually")
+      end
+      @data[key_sym] = value
+    end
+
+    private
+
+    def attr_inspect
+      [:id, :name]
+    end
+
+    def protected_data_keys
+      [:idUsuario, :idCliente, :idEmpresa]
+    end
+
+    def operation
+      new? ? :create : :update
+    end
+
+    def save_parameters
+      [
+        @client.session_params,
+        info_general: general_info_params,
+        info_otra: other_info_params
+      ].inject(&:merge)
+    end
+
+    def general_info_params
+      {
+        idUsuario: @client.username,
+        idCliente: id || "",
+        idEmpresa: @company.id,
+        NombreFantasia: @data[:NombreFantasia] || "",
+        RazonSocial: name || "",
+        CUIT: @data[:CUIT] || "",
+        DirPostal: @data[:DirPostal] || "",
+        DirPostalCiudad: @data[:DirPostalCiudad] || "",
+        DirPostalCodigoPostal: @data[:DirPostalCodigoPostal] || "",
+        DirPostalProvincia: @data[:DirPostalProvincia] || "",
+        DirPostalPais: @data[:DirPostalPais] || "Argentina",
+        Telefono: @data[:Telefono] || "",
+        Email: @data[:Email] || ""
+      }
+    end
+
+    def other_info_params
+      {
+        Activo: @data[:Activo] || "1",
+        FechaAlta: @data[:FechaAlta] || "",
+        DirFiscal: @data[:DirFiscal] || "",
+        DirFiscalCiudad: @data[:DirFiscalCiudad] || "",
+        DirFiscalCodigoPostal: @data[:DirFiscalCodigoPostal] || "",
+        DirFiscalProvincia: @data[:DirFiscalProvincia] || "",
+        DirFiscalPais: @data[:DirFiscalPais] || "",
+        idCondicionPago: @data[:idCondicionPago] || "",
+        idCondicionIva: @data[:idCondicionIva] || "",
+        porcentajeIVA: @data[:porcentajeIVA] || "21",
+        idPlanCuenta: @data[:idPlanCuenta] || "",
+        CuentaCredito: @data[:CuentaCredito] || "",
+        DirEnvio: @data[:DirEnvio] || "",
+        DirEnvioCiudad: @data[:DirEnvioCiudad] || "",
+        DirEnvioCodigoPostal: @data[:DirEnvioCodigoPostal] || "",
+        DirEnvioProvincia: @data[:DirEnvioProvincia] || "",
+        DirEnvioPais: @data[:DirEnvioPais] || ""
+      }
+    end
+  end
+end