mycrm 0.0.41

data/lib/mycrm/core_ext/string.rb

@@ -0,0 +1,24 @@
+require 'mycrm/core_ext/address'
+
+module Mycrm
+  module CoreExt
+    module String
+      def to_underscore
+        self.to_s.gsub(/::/, '/')
+          .gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+          .gsub(/([a-z\d])([A-Z])/,'\1_\2')
+          .tr("-", "_")
+          .downcase
+      end
+
+      def to_camelized
+        return self if self.to_s !~ /_/ && self.to_s =~ /[A-Z]+.*/
+        self.to_s.split('_').collect(&:capitalize).join
+      end
+
+      def to_address
+        Mycrm::CoreExt::Address.new(self)
+      end
+    end
+  end
+end

data/lib/mycrm/domains.rb

@@ -0,0 +1,57 @@
+module Mycrm
+  # facades
+  module Domains
+    module Rescuer
+      def [](label)
+        name = label.downcase.gsub(/\W/, '_')
+        raise NameError, "#{label} is not a valid domain" unless constant?(name)
+        create_constant(name)
+      end
+      alias find []
+
+      private
+
+      def method_missing(name, *args, &block)
+        return super unless constant?(name)
+        create_constant(name)
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        constant?(name) || super
+      end
+
+      def const_missing(name)
+        return super unless constant?(name)
+        create_constant(name)
+      end
+
+      def create_constant(name)
+        configured_domain[name.to_underscore].tap do |val|
+          self.const_set(name.to_camelized, val) unless self.const_defined?(name.to_camelized)
+        end
+      end
+
+      def constant?(name)
+        configured_domain && !configured_domain[name.to_underscore].nil?
+      end
+
+      def configured_domain
+        Mycrm.configuration.domains[self.name.split('::').last.to_underscore]
+      end
+    end
+
+    # Uncomment this line to create categories as constants on load.
+    #
+    # Mycrm.configuration.domains.each { |key, items| create_constant(key) }
+
+    def self.const_missing(name)
+      return super unless Mycrm.configuration.domains.key?(name.to_underscore)
+      create_constant(name)
+    end
+
+    def self.create_constant(name)
+      domain = Mycrm::Domains.const_set(name.to_camelized, Module.new)
+      domain.extend Mycrm::Domains::Rescuer
+    end
+  end
+end

data/lib/mycrm/facade.rb

@@ -0,0 +1,98 @@
+module Mycrm
+  # facades
+  module Facade
+    def self.included(descendant)
+      descendant.send(:include, InstanceMethods)
+      descendant.send(:extend, ClassMethods)
+    end
+
+    module InstanceMethods
+      def self.included(descendant)
+        descendant.class_eval do
+          attr_accessor :delegates
+        end
+      end
+
+      def initialize(attributes = {})
+        self.delegates = {}
+        self.class.delegate_classes.each do |name, delegate|
+          delegates[name] = delegate[:class].new attributes[name]
+        end
+      end
+
+      def to_json
+        delegates.each_with_object({}) { |(name, instance), r| r[name] = instance.to_json }
+      end
+
+      def run
+        {}.tap do |response|
+          Mycrm::Connectable.session do
+            delegates.each do |name, instance|
+              refresh_relation(name)
+              response[name] = yield(instance)
+            end
+          end
+        end
+      end
+
+      def refresh_relation(name)
+        self.class.relations(name).to_a.each do |pair|
+          delegates[name].send("#{pair.first}=", relative_value(*pair.last.split('.'))) rescue nil
+        end
+      end
+
+      def relative_value(delegate_name, field)
+        delegates[delegate_name.to_sym].send(field)
+      end
+
+      def method_missing(name, *args, &block)
+        return delegates[name] if delegates.key?(name)
+        delegate = delegates.values.detect { |d| d.respond_to?(name) }
+        delegate ? delegate.send(name, *args) : super
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        delegates[name] || delegates.detect { |d| d.respond_to?(name) } || super
+      end
+    end
+
+    module ClassMethods
+      def self.extended(descendant)
+        descendant.singleton_class.class_eval do
+          attr_accessor :delegate_classes
+        end
+      end
+
+      def delegate(name, clazz, relations = {})
+        self.delegate_classes ||= {}
+        delegate_classes[name] = { class: clazz, relations: relations }
+      end
+
+      def relations(delegate)
+        delegate_classes[delegate][:relations]
+      end
+
+      [:find, :list].each do |method|
+        define_method method do |*args|
+          run method, *args
+        end
+      end
+
+      def run(method = :find, *args)
+        attributes = {}.tap do |response|
+          Mycrm::Connectable.session do
+            self.delegate_classes.each do |name, delegate|
+              res = if block_given?
+                yield(name, delegate, response)
+              elsif delegate[:class].respond_to? :find
+                delegate[:class].send(method, *args)
+              end
+              response[name] = res.is_a?(Array) ? res.map(&:to_json) : res.to_json
+            end
+          end
+        end
+        new(attributes)
+      end
+    end
+  end
+end

data/lib/mycrm/facades.rb

@@ -0,0 +1,3 @@
+require_relative 'facades/lead'
+require_relative 'facades/lead_application'
+require_relative 'facades/organization'

data/lib/mycrm/facades/lead.rb

@@ -0,0 +1,24 @@
+require_relative '../facade'
+require_relative '../models/client'
+require_relative '../models/note'
+require_relative '../models/adviser_note'
+
+module Mycrm
+  module Facades
+    class Lead
+      include Facade
+
+      delegate :client, Mycrm::Models::Client
+      delegate :note, Mycrm::Models::Note, family_id: 'client.family_id'
+      delegate :adviser_note, Mycrm::Models::AdviserNote, family_id: 'client.family_id'
+
+      def create
+        run { |instance| instance.create }.values.all?
+      end
+
+      def create!
+        run { |instance| instance.create! }
+      end
+    end
+  end
+end

data/lib/mycrm/facades/lead_application.rb

@@ -0,0 +1,28 @@
+require_relative '../facade'
+require_relative '../models/client'
+require_relative '../models/note'
+require_relative '../models/adviser_note'
+require_relative '../models/application'
+require_relative '../models/structure'
+
+module Mycrm
+  module Facades
+    class LeadApplication
+      include Facade
+
+      delegate :client, Mycrm::Models::Client
+      delegate :note, Mycrm::Models::Note, family_id: 'client.family_id'
+      delegate :adviser_note, Mycrm::Models::AdviserNote, family_id: 'client.family_id'
+      delegate :application, Mycrm::Models::Application, client_id: 'client.id'
+      delegate :structure, Mycrm::Models::Structure, application_id: 'application.id'
+
+      def create
+        run { |instance| instance.create }.values.all?
+      end
+
+      def create!
+        run { |instance| instance.create! }
+      end
+    end
+  end
+end

data/lib/mycrm/facades/organization.rb

@@ -0,0 +1,14 @@
+require_relative '../facade'
+require_relative '../models/office'
+require_relative '../models/office_address'
+
+module Mycrm
+  module Facades
+    class Organization
+      include Facade
+
+      delegate :office, Mycrm::Models::Office
+      delegate :address, Mycrm::Models::OfficeAddress
+    end
+  end
+end

data/lib/mycrm/model.rb

@@ -0,0 +1,203 @@
+require 'virtus'
+require 'virtus_convert'
+require_relative 'connectable'
+
+module Mycrm
+  # models
+  module Model
+    def self.included(descendant)
+      descendant.send(:include, Virtus.model)
+      descendant.send(:include, InstanceMethods)
+      descendant.send(:extend, Connectable)
+      descendant.send(:extend, ClassMethods)
+
+      descendant.class_eval do
+        attr_accessor :error
+      end
+    end
+
+    # provides methods for the instance
+    module InstanceMethods
+      def initialize(attributes = nil)
+        partitions = (attributes || []).partition{ |field, _| attribute_set[field].nil? }
+        super(partitions.last.to_h)
+        partitions.first.each { |field, value| send("#{field}=", value) rescue nil }
+      end
+
+      def create!
+        mass_assign(self.class.execute(:post, nil, to_json))
+      end
+
+      def update!
+        mass_assign(self.class.execute(:put, id, to_json))
+      end
+
+      def delete!
+        self.class.execute(:delete, id, nil)
+      end
+
+      def to_json
+        VirtusConvert.new(self).to_hash.delete_if(&method(:swoop))
+      end
+
+      def swoop(_, v)
+        (v.is_a?(Hash) ? v.delete_if(&method(:swoop)) : v.to_s).empty?
+      end
+
+      def mass_assign(json)
+        attribute_set.set(self, json)
+      end
+
+      # safe methods for the principal crud methods
+      %w(create update delete).each do |method|
+        define_method method do
+          begin
+            send("#{method}!")
+            true
+          rescue => e
+            self.error = e.message
+            false
+          end
+        end
+      end
+    end
+
+    # provides method at class level
+    module ClassMethods
+      def self.extended(descendant)
+        descendant.singleton_class.class_eval do
+          attr_accessor :class_endpoint, :alowed_methods, :attribute_to
+        end
+      end
+
+      def list(id = nil)
+        to_list(execute(:get, id))
+      end
+
+      def list_by(key, value, use_key_as_path = false)
+        path = use_key_as_path ? key : nil
+        to_list(execute(:get, path, {}, key => value))
+      end
+
+      def find(id)
+        new(execute(:get, id))
+      end
+
+      def find_by(key, value, use_key_as_path = false)
+        path = use_key_as_path ? key : nil
+        new(execute(:get, path, {}, key => value))
+      end
+
+      def execute(action, path, body = {}, query = {})
+        raise ApiError, 'Method not allowed' if !alowed_methods.nil? && !alowed_methods.include?(action)
+        Mycrm.log(:info, %{
+--------- #{self.name} ---------
+method:   #{action}
+path:     #{uri(path, body)}
+body:     #{body}
+query:    #{query}
+-------------------------------})
+        send(action, uri(path, body), body, query).tap { |response|  Mycrm.log(:info, "response: #{response}") }
+      end
+
+      def uri(relative = nil, parameters = {})
+        format([class_endpoint, relative.to_s].compact.join('/').chomp('/'), parameters)
+      rescue KeyError => e
+        raise ApiError, e
+      end
+
+      def to_list(res)
+        raise ApiError, 'The output is not compatible.' unless res.is_a?(Array)
+        res.each_with_object([]) { |j, list| list << new(j) }
+      end
+
+      # macro method to setup the endpoint that will be used to connect the API
+      def endpoint(endpoint)
+        self.class_endpoint = endpoint
+      end
+
+      # macro method to limit the method type
+      def only(*methods)
+        self.alowed_methods = methods.collect(&:to_sym)
+      end
+
+      def to(mode)
+        raise ApiError, "The conversion type '#{mode}' is not compatible." unless [:underscore, :camelized].include?(mode)
+        self.attribute_to = mode
+      end
+
+      # macro method to create a new attribute of type Object
+      # and relative accessors
+      def attribute(name, klazz, options = {})
+        if options[:embedded]
+          options.merge!(default: {})
+          define_embedded_methods(name, klazz)
+        end
+
+        define_formatted_methods name
+
+        super
+
+        alias_method(options[:as], name) if options[:as]
+      end
+
+      # Defines accessors for embetted attributes
+      #
+      # class Phone
+      #   attribute :home
+      #   attribute :work
+      #   attribute :mobile
+      # end
+      #
+      # class Contact
+      #  attribute :phone, embedded:true
+      # end
+      #
+      # contact = Contact.new
+      # contact.phone_home = 'xxx'
+      # contact.home_phone = 'xxx'
+      #
+      # private
+      def define_embedded_methods(field, klazz)
+        klazz.allowed_writer_methods.each do |att|
+          ['%{field}_%{attribute}', '%{attribute}_%{field}'].each do |template|
+            define_embedded_method template, field, att.to_s.chomp('=')
+          end
+        end
+      end
+
+      def define_embedded_method(template, field, attribute)
+        accessor = format(template, field: field.to_s, attribute: attribute)
+
+        define_method "#{accessor}=" do |val|
+          instance_variable_get("@#{field}").send("#{attribute}=", val)
+        end
+
+        define_method accessor do
+          instance_variable_get("@#{field}").send(attribute)
+        end
+      end
+
+      def define_formatted_methods(field)
+        return unless attribute_to
+        alias_name = field.send("to_#{attribute_to}")
+
+        define_method "#{alias_name}=" do |val|
+          send("#{field}=", val)
+        end
+
+        define_method alias_name do
+          send(field)
+        end
+      end
+
+      def method_missing(name, *args, &block)
+        name =~ /^(find|list)_by_(.*)$/ ? send("#{Regexp.last_match[1]}_by", Regexp.last_match[2], *args) : super
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        name !~ /^(find|list)_by_(.*)$/ ? super : true
+      end
+    end
+  end
+end