naranya_ecm-sdk 0.0.14 → 0.0.15

data/lib/naranya_ecm/rest/model.rb

@@ -0,0 +1,215 @@
+require 'httparty'
+require 'active_model'
+
+module NaranyaEcm::Rest
+  module Model
+
+    # Constant proc that validates if a given value is a boolean:
+    BOOLEAN = Proc.new { |value| !!value == value }
+
+    class LocalizedAttribute < HashWithIndifferentAccess
+
+      alias_method :locales, :keys
+      alias_method :available_locales, :locales
+
+      def initialize(*args)
+        super()
+        given_attrs = args.shift
+        given_attrs.each { |k,v| self[k] = v } unless given_attrs.nil?
+      end
+
+      def lookup
+        locale = ::I18n.locale
+        if ::I18n.respond_to?(:fallbacks)
+          lookup_result = self[::I18n.fallbacks[locale].map(&:to_s).find{ |loc| self.has_key?(loc) }]
+        else
+          lookup_result = self[locale.to_s]
+        end
+        lookup_result || self.present? ? self.first[1] : nil
+      end
+
+      def method_missing(method_name, *args, &block)
+        if method_name == self.class.aliased_lookup_name
+          # El nombre del método debe ser un alias de lookup.
+          # Agregar el alias:
+          self.class.send :alias_method, self.class.aliased_lookup_name, :lookup
+          # llamar el método de lookup. La siguiente ocación no caerá aqui:
+          lookup
+        else
+          super # You *must* call super if you don't handle the
+          # method, otherwise you'll mess up Ruby's method
+          # lookup.
+        end
+      end
+
+      class << self
+        def aliased_lookup_name
+          @lookup_alias ||= self.name.demodulize[0..-("Translations".length+1)].underscore.to_sym
+        end
+      end
+    end
+
+    extend ActiveSupport::Concern
+    
+    included do
+
+      include ActiveModel::Model
+      extend  ActiveModel::Callbacks
+
+      include ActiveModel::Dirty
+      primary_key :id, type: String
+
+      # Ignore the server resource's url attribute:
+      attr_accessor :url
+
+      include HTTParty
+      base_uri NaranyaEcm.options[:site]
+      #debug_output $stderr
+
+      include NaranyaEcm::Rest::Associations
+      include NaranyaEcm::Rest::Persistence
+
+      extend NaranyaEcm::Rest::FinderMethods
+      
+      alias_method_chain :initialize, :defaults
+
+      if NaranyaEcm.options[:extra_attributes] && (extra_fields = NaranyaEcm.options[:extra_attributes][self.name.demodulize.underscore])
+        extra_fields.each do |name, type|
+          
+          field_options = {}
+          
+          field_options[:type] = case type
+          when 'boolean'
+            NaranyaEcm::Rest::Model::BOOLEAN
+          else
+            type.classify.constantize
+          end
+
+          field(name.to_sym, field_options)
+        end
+      end
+
+    end
+
+    def initialize_with_defaults(*args)
+      initialize_without_defaults(*args)
+      # inicializar con los valores default los campos que esten nulos y tengan un default definido:
+      self.class.fields.values
+        .select { |f| instance_variable_get("@#{f[:name]}".to_sym).nil? && f[:default] }
+        .each { |f| instance_variable_set("@#{f[:name]}".to_sym, f[:default].call) }
+      
+    end
+
+    def method_missing(method, *args, &block)
+      if method =~ /^(\w+)=$/i
+        self.class.send :field, $1.to_sym, type: args.first.class
+        self.send method, *args
+      else
+        super # You *must* call super if you don't handle the
+              # method, otherwise you'll mess up Ruby's method
+              # lookup.
+      end
+    end
+
+    def attributes
+      HashWithIndifferentAccess[
+        self.class.fields.values
+          .map { |attr_data| [attr_data[:name], self.send(attr_data[:name].to_sym)] }
+      ]
+    end
+
+    def associations
+      self.instance_variables
+        .map { |instance_variable| instance_variable[1..-1].to_sym }
+        .select { |accessor_name| self.is_association?(accessor_name) }
+        .inject({}.with_indifferent_access) { |hash, accessor_name| hash[accessor_name] = self.send accessor_name; hash }
+    end
+
+    def load(params={})
+      params.each do |attr, value|
+        self.public_send("#{attr}=", value)
+      end if params
+    end
+
+    def path
+      "#{self.class.path}/#{self.id}"
+    end
+
+    protected
+
+      def off_band_changes
+        @off_band_changes ||= {}.with_indifferent_access
+      end
+
+
+    module ClassMethods
+
+      def fields
+        @_fields ||= {}.with_indifferent_access
+      end
+
+      def load(*args)
+        loaded = self.new
+        loaded.load(*args)
+        loaded.changed_attributes.clear
+        loaded
+      end
+
+      def primary_key(name, options = {})
+        attr_accessor name
+        define_attribute_method name
+      end
+
+      def field(name, options = {})
+        
+        if options[:localize]
+          lookup_alias_name = name
+          name = "#{name}_translations".to_sym
+        end
+
+        fields[name] = {name: name}.merge(options).with_indifferent_access
+        
+        attr_accessor name
+        define_attribute_method name
+
+        if options[:localize]
+          # Define localized setter with dirty notification:
+          define_method("#{name}=".to_sym) do |value|
+            value = LocalizedAttribute.new value if value.is_a?(Hash) && !value.is_a?(LocalizedAttribute)
+            raise "Type Mismatch..." unless value.is_a?(LocalizedAttribute)
+
+            variable_name = "@#{name}".to_sym
+            self.send "#{name}_will_change!".to_sym unless value == instance_variable_get(variable_name)
+            instance_variable_set variable_name, value
+          end
+
+          # Define lookup alias:
+          define_method lookup_alias_name do
+            self.send(name).lookup
+          end
+
+        else
+          # Define normal setter with dirty notification:
+          define_method("#{name}=".to_sym) do |value|
+            variable_name = "@#{name}".to_sym
+            self.send "#{name}_will_change!".to_sym unless value == instance_variable_get(variable_name)
+            instance_variable_set variable_name, value
+          end
+        end
+      end
+
+      def path
+        @path ||= "/#{self.name.demodulize.tableize}"
+      end
+
+      def where(given_conditions={})
+        Relation.new self, given_conditions.with_indifferent_access 
+      end
+
+      def all
+        where()
+      end
+      
+    end
+  end
+end

data/lib/naranya_ecm/rest/persistence.rb

@@ -0,0 +1,122 @@
+module NaranyaEcm::Rest
+
+  module Persistence
+
+    extend ActiveSupport::Concern
+
+    included do
+      define_model_callbacks :create, :update, :save
+    end
+
+    def save
+      run_callbacks :save do
+        @previously_changed = changes
+        result = self.new_resource? ? self.create : self.update
+        @changed_attributes.clear
+        result
+      end
+    end
+
+    def new_resource?; self.id.nil?; end
+    alias_method :new?, :new_resource?
+
+    def persisted?; !new_resource? || !self.changed?; end
+
+    protected
+
+      def load_server_errors(server_error_hash)
+        server_error_hash = server_error_hash.with_indifferent_access
+        if server_error_hash.present? && server_error_hash.has_key?(:errors) && server_error_hash[:errors].present?
+          server_error_hash[:errors].each do |field_name, error_list|
+            error_list.each do |message|
+              self.errors.add field_name.to_sym, message
+            end
+          end
+        else
+          self.errors.add :base, 'is invalid in server'
+        end
+      end
+
+      def reload
+        format = NaranyaEcm.options[:format] || 'json'
+        get_path = "#{path}.#{format}"
+        response = self.class.get get_path
+        case response.code
+        when 200
+          load(response.to_hash)
+          true
+        else
+          false
+        end
+      end
+
+      def reload!; raise "Ja!" unless reload; end
+
+      def persist_request_options(data)
+        {
+          body: ActiveSupport::JSON.encode({ self.class.name.demodulize.underscore => data }),
+          headers: { 'Content-Type' => 'application/json'}
+        }
+      end
+
+      def create
+        run_callbacks :create do
+
+          format = NaranyaEcm.options[:format] || 'json'
+          create_path = "#{self.class.path}.#{format}"
+
+          response = self.class.post create_path, persist_request_options(self.attributes)
+          
+          case response.code
+          when 201
+            self.load(response.to_hash)
+            true
+          when 422 # Unprocessable Entity
+            self.load_server_errors(response.to_hash)
+            false
+          end
+        end
+      end
+
+      def update
+        run_callbacks :update do
+          attributes_to_save = self.changes.dup
+          attributes_to_save.each do |key, val|
+            attributes_to_save[key] = val.last
+          end
+
+          attributes_to_save.merge! off_band_changes
+
+          format = NaranyaEcm.options[:format] || 'json'
+          update_path = "#{self.path}.#{format}"
+
+          response = self.class.put update_path, persist_request_options(attributes_to_save)
+          case response.code
+          when 204
+            self.reload!
+            true
+          when 422 # Unprocessable Entity
+            self.load_server_errors(response.to_hash)
+            false
+          end
+        end
+      end
+
+
+    module ClassMethods
+
+      def create(attributes={})
+        object_to_create = self.new attributes
+        object_to_create.save
+        object_to_create
+      end
+      def create!(attributes={})
+        created_object = create(attributes)
+        raise "ValidationError" unless created_object.persisted?
+        created_object
+      end
+    end
+
+  end
+
+end

data/lib/naranya_ecm/rest/relation.rb

@@ -0,0 +1,54 @@
+module NaranyaEcm::Rest
+  class Relation
+    include Enumerable
+    delegate :to_yaml, :all?, :each, :first, :last, to: :to_a
+
+    attr_reader :klass, :conditions, :elements
+    
+    def initialize(given_klass, given_conditions = {})
+      @klass, @conditions = given_klass, given_conditions.with_indifferent_access
+    end
+
+    def where(given_conditions = {})
+      spawn_chain(given_conditions)
+    end
+
+    def limit(given_limit)
+      spawn_chain(limit: given_limit.to_i)
+    end
+
+    def to_a
+      materialize! unless @elements
+      elements
+    end
+
+    def fetch_from_server
+      format = NaranyaEcm.options[:format] || 'json'
+      response = klass.get("#{klass.path}.#{format}", query: conditions)
+      case response.code
+      when 404
+        raise ResourceNotFound
+      when 200
+        response.to_a
+      end
+    end
+
+    def load(given_list)
+      # Revisar que todos los elementos sean Hash o la clase asociada:
+      raise "Type Mismatch: some elements are not a hash nor associated_class" unless given_list
+        .map { |e| e.is_a?(Hash) || e.is_a?(@klass) }
+        .reduce { |res, e| res && e }
+      @elements = given_list.map { |e| e.is_a?(Hash) ? @klass.load(e) : e }
+    end
+
+    private
+      def spawn_chain(given_conditions = {})
+        self.class.new klass, conditions.merge(given_conditions)
+      end
+
+      def materialize!
+        @elements = fetch_from_server.map { |s| klass.load s }
+      end
+
+  end
+end

data/lib/naranya_ecm/search/hit.rb

@@ -1,17 +1,22 @@
-module NaranyaEcm
-  module Search
-    class Hit
-      attr_reader :id, :type, :updated_at, :order, :score
-      attr_accessor :cache_key
-      def initialize(attributes={})
-        @id         = attributes.delete :_id
-        @type       = attributes.delete :_type
-        @score      = attributes.delete :_score
+module NaranyaEcm::Search
+  class Hit
+    attr_reader :id, :type, :updated_at, :order, :score
+    def initialize(attributes={})
+      @id         = attributes.delete :_id
+      @type       = attributes.delete :_type
+      @score      = attributes.delete :_score
 
-        source      = attributes.delete :_source
-        @updated_at = source.has_key?(:updated_at) ? source.delete(:updated_at).to_datetime : nil
-        @order      = attributes.delete :order
-      end
+      source      = attributes.delete :_source
+      @updated_at = source.has_key?(:updated_at) ? source.delete(:updated_at).to_datetime : nil
+      @order      = attributes.delete :order
+    end
+
+    def klass
+      @klass ||= "NaranyaEcm::#{type.classify}".constantize
+    end
+
+    def cache_key
+      @cache_key ||= NaranyaEcm::Cache::Key.new klass, id, updated_at
     end
   end
-end
+end

data/lib/naranya_ecm/search/methods.rb

@@ -1,26 +1,24 @@
 require 'active_support/concern'
-module NaranyaEcm
-  module Search
-    module Methods
-      extend ActiveSupport::Concern
+module NaranyaEcm::Search
+  module Methods
+    extend ActiveSupport::Concern
 
-      included do
-        attr_reader :search_score, :search_order
-      end
-      
-      def merge_search_hit_data(hit)
-        @search_score, @search_order = hit.score, hit.order
-      end
+    included do
+      attr_reader :search_score, :search_order
+    end
+    
+    def merge_search_hit_data(hit)
+      @search_score, @search_order = hit.score, hit.order
+    end
 
-      module ClassMethods
-        def search(*args)
-          Results.new(*args, self)
-        end
-        def kick_search(terms, options={})
-          search(Query.build_searchkick_like(terms, options))
-        end
+    module ClassMethods
+      def search(*args)
+        Results.new(self, *args)
+      end
+      def kick_search(terms, options={})
+        search(Query.build_searchkick_like(terms, options))
       end
-
     end
+
   end
-end
+end