logical_model 0.4.10 → 0.5.0

data/lib/logical_model/api_key.rb

@@ -0,0 +1,41 @@
+class LogicalModel
+  module ApiKey
+    def self.included(base)
+      base.send(:extend, ClassMethods)
+    end
+
+    module ClassMethods
+      attr_accessor :api_key, :api_key_name, :use_api_key
+
+      # Set api_key
+      # @param name [Symbol] name for api_key. Eg: app_key, token, etc.
+      # @param value [String] value of key. Eg: 1o2u3hqkfd, secret, etc.
+      #
+      # @example
+      #   class Client < LogicalModel
+      #     set_api_key(:token, 'asdfasdf')
+      #     ...
+      #   end
+      def set_api_key(name,value)
+        @use_api_key = true
+        @api_key_name = name
+        @api_key = value
+      end
+
+      def use_api_key
+        @use_api_key ||= false
+      end
+
+      # if needed will merge api_key into given hash
+      # returns merged hash
+      def merge_key(params = {})
+        if self.use_api_key
+          params.merge({self.api_key_name => self.api_key})
+        else
+          params
+        end
+      end
+
+    end
+  end
+end

data/lib/logical_model/attributes.rb

@@ -0,0 +1,57 @@
+class LogicalModel
+  module Attributes
+    # TODO replace this module with ActvieAttr ?
+    def self.included(base)
+      base.send(:include, InstanceMethods)
+      base.send(:extend, ClassMethods)
+    end
+
+    module InstanceMethods
+
+      def attributes=(attrs)
+        sanitize_for_mass_assignment(attrs).each{|k,v| send("#{k}=",v) if respond_to?("#{k}=")}
+      end
+
+      def attributes
+        attrs = self.class.attribute_keys.inject(ActiveSupport::HashWithIndifferentAccess.new) do |result,key|
+          result[key] = read_attribute_for_validation(key)
+          result
+        end
+
+        unless self.class.has_many_keys.blank?
+          self.class.has_many_keys.inject(attrs) do |result,key|
+            result["#{key}_attributes"] = send(key).map {|a| a.attributes}
+            result
+          end
+        end
+        attrs.reject {|key, value| key == "_id" && value.blank?}
+      end
+    end
+
+    module ClassMethods
+
+      # declares an attribute.
+      # @param name [Symbol]
+      # @example
+      #     class Client < LogicalModel
+      #       attribute :att_name
+      #     end
+      def attribute(name)
+        @attribute_keys = [] if @attribute_keys.nil?
+        @attribute_keys << name
+        attr_accessor name
+      end
+
+      # overrides attributes with given keys.
+      # @param keys [Array<Symbol>]
+      def attribute_keys=(keys)
+        @attribute_keys = keys
+        attr_accessor *keys
+      end
+
+      def attribute_keys
+        @attribute_keys
+      end
+    end
+  end
+end

data/lib/logical_model/has_many_keys.rb

@@ -1,69 +1,75 @@
 class LogicalModel
   module HasManyKeys
 
-    def has_many_keys=(keys)
-      @has_many_keys = keys
-      attr_accessor *keys
+    def self.included(base)
+      base.send(:extend, ClassMethods)
+    end
 
-      keys.each do |association|
+    module ClassMethods
 
-        # return empty array or @association variable for each association
-        define_method association do
-          if instance_variable_get("@#{association}").blank?
-            instance_variable_set("@#{association}", [])
-          end
+      def has_many_keys=(keys)
+        @has_many_keys = keys
+        attr_accessor *keys
 
-          instance_variable_get("@#{association}")
-        end
+        keys.each do |association|
 
-        # this method loads the contact attributes recieved by logical model from the service
-        define_method "#{association}=" do |params|
-          collection = []
-          params.each do |attr_params|
-            if attr_params["_type"].present?
-              attr_class = attr_params.delete("_type").to_s.constantize
-            else
-              attr_class = association.to_s.singularize.camelize.constantize
+          # return empty array or @association variable for each association
+          define_method association do
+            if instance_variable_get("@#{association}").blank?
+              instance_variable_set("@#{association}", [])
             end
-            collection << attr_class.new(attr_params)
-          end
-          instance_variable_set("@#{association}", collection)
-        end
 
-        define_method "new_#{association.to_s.singularize}" do |attr_params|
-          if attr_params["_type"].present?
-            clazz = attr_params.delete(:_type).constantize
-          else
-            clazz = association.to_s.singularize.camelize.constantize
+            instance_variable_get("@#{association}")
           end
 
-          return unless clazz
-
-          temp_object = clazz.new(attr_params.merge({"#{self.json_root}_id" => self.id}))
-          eval(association.to_s) << temp_object
-          temp_object
-        end
+          # this method loads the contact attributes recieved by logical model from the service
+          define_method "#{association}=" do |params|
+            collection = []
+            params.each do |attr_params|
+              if attr_params["_type"].present?
+                attr_class = attr_params.delete("_type").to_s.constantize
+              else
+                attr_class = association.to_s.singularize.camelize.constantize
+              end
+              collection << attr_class.new(attr_params)
+            end
+            instance_variable_set("@#{association}", collection)
+          end
 
-        # this method loads the contact attributes from the html form (using nested resources conventions)
-        define_method "#{association}_attributes=" do |key_attributes|
-          array = []
-          key_attributes.each do |attr_params|
-            attr_params.to_hash.symbolize_keys!
+          define_method "new_#{association.to_s.singularize}" do |attr_params|
             if attr_params["_type"].present?
-              attr_class = attr_params.delete("_type").to_s.constantize
+              clazz = attr_params.delete(:_type).constantize
             else
-              attr_class = association.to_s.singularize.camelize.constantize
+              clazz = association.to_s.singularize.camelize.constantize
             end
-            array << attr_class.new(attr_params)
+
+            return unless clazz
+
+            temp_object = clazz.new(attr_params.merge({"#{self.json_root}_id" => self.id}))
+            eval(association.to_s) << temp_object
+            temp_object
+          end
+
+          # this method loads the contact attributes from the html form (using nested resources conventions)
+          define_method "#{association}_attributes=" do |key_attributes|
+            array = []
+            key_attributes.each do |attr_params|
+              attr_params.to_hash.symbolize_keys!
+              if attr_params["_type"].present?
+                attr_class = attr_params.delete("_type").to_s.constantize
+              else
+                attr_class = association.to_s.singularize.camelize.constantize
+              end
+              array << attr_class.new(attr_params)
+            end
+            instance_variable_set("@#{association}", array)
           end
-          instance_variable_set("@#{association}", array)
         end
       end
-    end
 
-    def has_many_keys
-      @has_many_keys
+      def has_many_keys
+        @has_many_keys
+      end
     end
-
   end
 end

data/lib/logical_model/rest_actions.rb

@@ -0,0 +1,410 @@
+class LogicalModel
+  module RESTActions
+
+    def self.included(base)
+      base.send(:include, InstanceMethods)
+      base.send(:extend, ClassMethods)
+    end
+
+    module InstanceMethods
+
+      def create(params={})
+        run_callbacks :save do
+          run_callbacks :create do
+            _create(params)
+          end
+        end
+      end
+
+      def save
+        run_callbacks :save do
+          run_callbacks new_record?? :create : :update do
+            _save
+          end
+        end
+      end
+
+      def destroy(params={})
+        run_callbacks :destroy do
+          _destroy(params)
+        end
+      end
+
+      # @param params [Hash] parameters to be sent to service
+      def update(params)
+        run_callbacks :save do
+          run_callbacks :update do
+            _update(params)
+          end
+        end
+
+      end
+
+      #
+      # creates model.
+      #
+      # returns:
+      # @return false if model invalid
+      # @return nil if there was a connection problem
+      # @return created model ID if successfull
+      #
+      # @example Usage:
+      #   @person = Person.new(params[:person])
+      #   @person.create( non_attribute_param: "value" )
+      def _create(params = {})
+        return false unless valid?
+
+        params = { self.json_root => self.attributes }.merge(params)
+        params = self.class.merge_key(params)
+
+        response = nil
+        Timeout::timeout(self.class.timeout/1000) do
+          response = Typhoeus::Request.post( self.class.resource_uri, :body => params, :timeout => self.class.timeout )
+        end
+        self.last_response_code = response.code
+        if response.code == 201 || response.code == 202
+          log_ok(response)
+          if self.respond_to?('id=')
+            self.id = ActiveSupport::JSON.decode(response.body)["id"]
+          else
+            true
+          end
+        elsif response.code == 400
+          log_failed(response)
+          ws_errors = ActiveSupport::JSON.decode(response.body)["errors"]
+          ws_errors.each_key do |k|
+            self.errors.add k, ws_errors[k]
+          end
+          return false
+        else
+          log_failed(response)
+          return nil
+        end
+      rescue Timeout::Error
+        self.class.logger.warn "timeout"
+        return nil
+      end
+
+      # Updates Objects attributes, this will only send attributes passed as arguments
+      #
+      #
+      # Returns false if Object#valid? is false.
+      # Returns updated object if successfull.
+      # Returns nil if update failed
+      #
+      # Usage:
+      #   @person.update(params[:person])
+      def _update(params)
+
+        self.attributes = params[self.json_root]
+
+        return false unless valid?
+
+        params = self.class.merge_key(params)
+
+        response = nil
+        Timeout::timeout(self.class.timeout/1000) do
+          response = Typhoeus::Request.put( self.class.resource_uri(id),
+                                            :params => params,
+                                            :timeout => self.class.timeout )
+        end
+
+        if response.code == 200
+          log_ok(response)
+          return self
+        else
+          log_failed(response)
+          return nil
+        end
+
+      rescue Timeout::Error
+        self.class.logger.warn("request timed out")
+        return nil
+      end
+
+      # Saves Objects attributes
+      #
+      #
+      # Returns false if Object#valid? is false.
+      # Returns updated object if successfull.
+      # Returns nil if update failed
+      #
+      # Usage:
+      #   @person.save
+      def _save
+        self.attributes = attributes
+
+        return false unless valid?
+
+        sending_params = self.attributes
+        sending_params.delete(:id)
+
+        params = { self.json_root => sending_params }
+        params = self.class.merge_key(params)
+        response = nil
+        Timeout::timeout(self.class.timeout/1000) do
+          response = Typhoeus::Request.put( self.class.resource_uri(id), :params => params, :timeout => self.class.timeout )
+        end
+        if response.code == 200
+          log_ok(response)
+          return self
+        else
+          log_failed(response)
+          return nil
+        end
+      rescue Timeout::Error
+        self.class.logger.warn "timeout"
+        return nil
+      end
+
+      # Destroy object
+      #
+      # Usage:
+      #   @person.destroy
+      def _destroy(params={})
+        self.class.delete(self.id,params)
+      end
+
+    end
+
+    module ClassMethods
+
+      attr_accessor :enable_delete_multiple
+
+      #  ============================================================================================================
+      #  Following methods are API specific.
+      #  They assume we are using a RESTfull API.
+      #  for get, put, delete :id is expected
+      #  for post, put attributes are excepted under class_name directly. eg. put( {:id => 1, :class_name => {:attr => "new value for attr"}} )
+      #
+      #  On error (400) a "errors" is expected.
+      #  ============================================================================================================
+
+      # Asynchronic Pagination
+      #  This pagination won't block excecution waiting for result, pagination will be enqueued in Objectr#hydra.
+      #
+      # Parameters:
+      #   @param options [Hash].
+      #   Valid options are:
+      #   * :page - indicated what page to return. Defaults to 1.
+      #   * :per_page - indicates how many records to be returned per page. Defauls to 20
+      #   * all other options will be sent in :params to WebService
+      #
+      # Usage:
+      #   Person.async_paginate(:page => params[:page]){|i| result = i}
+      def async_paginate(options={})
+        options[:page] ||= 1
+        options[:per_page] ||= 20
+
+        options = self.merge_key(options)
+
+        request = Typhoeus::Request.new(resource_uri, :params => options)
+        request.on_complete do |response|
+          if response.code >= 200 && response.code < 400
+            log_ok(response)
+
+            result_set = self.from_json(response.body)
+
+            # this paginate is will_paginate's Array pagination
+            collection = Kaminari.paginate_array(
+                result_set[:collection],
+                {
+                    :total_count=>result_set[:total],
+                    :limit => options[:per_page],
+                    :offset => options[:per_page] * ([options[:page], 1].max - 1)
+                }
+            )
+
+            yield collection
+          else
+            log_failed(response)
+          end
+        end
+        self.hydra.queue(request)
+      end
+
+      #synchronic pagination
+      def paginate(options={})
+        result = nil
+        self.retries.times do
+          begin
+            async_paginate(options){|i| result = i}
+            Timeout::timeout(self.timeout/1000) do
+              self.hydra.run
+            end
+            break unless result.nil?
+          rescue Timeout::Error
+            self.logger.warn("timeout")
+            result = nil
+          end
+        end
+        result
+      end
+
+      # Asynchronic Count
+      #  This count won't block excecution waiting for result, count will be enqueued in Objectr#hydra.
+      #
+      # Parameters:
+      #   @param options [Hash].
+      #   Valid options are:
+      #   @option options [Integer] :page - indicated what page to return. Defaults to 1.
+      #   @option options [Integer] :per_page - indicates how many records to be returned per page. Defauls to 20
+      #   @option options [Hash] all other options will be forwarded in :params to WebService
+      #
+      # @example 'Count bobs'
+      #   Person.async_count(:when => {:name => 'bob'}}){|i| result = i}
+      def async_count(options={})
+        options[:page] = 1
+        options[:per_page] = 1
+
+        options = self.merge_key(options)
+
+        request = Typhoeus::Request.new(resource_uri, :params => options)
+        request.on_complete do |response|
+          if response.code >= 200 && response.code < 400
+            log_ok(response)
+
+            result_set = self.from_json(response.body)
+
+            yield result_set[:total]
+          else
+            log_failed(response)
+          end
+        end
+        self.hydra.queue(request)
+      end
+
+      # synchronic count
+      def count(options={})
+        result = nil
+        async_count(options){|i| result = i}
+        Timeout::timeout(self.timeout/1000) do
+          self.hydra.run
+        end
+        result
+      rescue Timeout::Error
+        self.logger.warn("timeout")
+        return nil
+      end
+
+      # Asynchronic Find
+      #  This find won't block excecution waiting for result, excecution will be enqueued in Objectr#hydra.
+      #
+      # Parameters:
+      #   - id, id of object to find
+      # @param [String/Integer] id
+      # @param [Hash] params
+      #
+      # Usage:
+      #   Person.async_find(params[:id])
+      def async_find(id, params = {})
+        params = self.merge_key(params)
+        request = Typhoeus::Request.new( resource_uri(id), :params => params )
+
+        request.on_complete do |response|
+          if response.code >= 200 && response.code < 400
+            log_ok(response)
+            yield self.new.from_json(response.body) # this from_json is defined in ActiveModel::Serializers::JSON
+          else
+            log_failed(response)
+          end
+        end
+
+        self.hydra.queue(request)
+      end
+
+      # synchronic find
+      def find(id, params = {})
+        result = nil
+        async_find(id, params){|i| result = i}
+        Timeout::timeout(self.timeout/1000) do
+          self.hydra.run
+        end
+        result
+      rescue Timeout::Error
+        self.logger.warn("timeout")
+        return nil
+      end
+
+      # Deletes Object#id
+      #
+      # Returns nil if delete failed
+      #
+      # @param [String] id - id of contact to be deleted
+      # @param [Hash] params - other params to be sent to WS on request
+      #
+      # Usage:
+      #   Person.delete(params[:id])
+      def delete(id, params={})
+
+        params = self.merge_key(params)
+
+        response = nil
+        Timeout::timeout(self.timeout/1000) do
+          response = Typhoeus::Request.delete( self.resource_uri(id),
+                                               :params => params,
+                                               :timeout => self.timeout
+          )
+        end
+        if response.code == 200
+          log_ok(response)
+          return self
+        else
+          log_failed(response)
+          return nil
+        end
+      rescue Timeout::Error
+        self.logger.warn "timeout"
+        return nil
+      end
+
+      # Deletes all Objects matching given ids
+      #
+      # This method will make a DELETE request to resource_uri/destroy_multiple
+      #
+      # Returns nil if delete failed
+      #
+      # @param [Array] ids - ids of contacts to be deleted
+      # @param [Hash] params - other params to be sent to WS on request
+      #
+      # Usage:
+      #   Person.delete_multiple([1,2,4,5,6])
+      def delete_multiple(ids, params={})
+        raise "not-enabled" unless self.delete_multiple_enabled?
+
+        params = self.merge_key(params)
+        params = params.merge({:ids => ids})
+
+        response = nil
+        Timeout::timeout(self.timeout/1000) do
+          response = Typhoeus::Request.delete( self.resource_uri+"/destroy_multiple",
+                                               :params => params,
+                                               :timeout => self.timeout
+          )
+        end
+        if response.code == 200
+          log_ok(response)
+          return self
+        else
+          log_failed(response)
+          return nil
+        end
+      rescue Timeout::Error
+        self.logger.warn "timeout"
+        return nil
+      end
+    end
+  end
+
+  ##
+  # Will parse JSON string and initialize classes for all hashes in json_string[collection].
+  #
+  # @param json_string [JSON String] This JSON should have format: {collection: [...], total: X}
+  #
+  def self.from_json(json_string)
+    parsed = ActiveSupport::JSON.decode(json_string)
+    collection = parsed["collection"].map{|i|self.new(i)}
+    return { :collection => collection, :total => parsed["total"].to_i }
+  end
+
+end