lims-core 3.2.3

data/lib/lims-core/persistence/resource_state.rb

@@ -0,0 +1,157 @@
+# vi: ts=2:sts=2:et:sw=2 spell:spelllang=en
+require 'virtus'
+
+require 'lims-core/resource'
+require 'lims-core/persistence/persistor'
+
+module Lims::Core
+  module Persistence
+    # Hold different information relateed particular resource
+    # within a {Session}/{Persistor}.
+    # This could be the database id, the current saving state etc ...
+    class ResourceState
+      include Virtus
+      attribute :id, Object
+      attribute :uuid_resource, Object
+      attribute :resource, Object, :writer => :private, :required => true
+      attribute :persistor, Persistor, :writer => :private, :required => true
+      attribute :to_delete, Object, :writer => :private
+
+      def children_saved?
+        @children_saved
+      end
+
+      def body_saved?
+        @body_saved
+      end
+
+      def initialize(resource, persistor, id=nil)
+        @resource=resource
+        @persistor=persistor
+        self.id=id if id
+        @to_delete = false
+        update_dirty_key
+        reset
+
+      end
+
+      def to_delete
+        @to_delete
+      end
+
+
+      def id
+        @id
+      end
+
+      def resource
+        @resource
+      end
+
+      def persistor
+        @persistor
+      end
+
+      def dirty_key
+        @persistor.dirty_key_for(resource)
+      end
+
+      def update_dirty_key
+        @last_dirty_key = resource ?  @persistor.dirty_key_for(resource) : nil
+      end
+
+      def new?
+        @id == nil
+      end
+
+      def to_load?
+        @id != nil && @resource == nil
+      end
+
+
+      def dirty?
+       !@body_saved && dirty_key != @last_dirty_key
+      end
+
+      def id=(new_id)
+        return  if new_id == @id
+        raise RuntimeError, "modifing existing id not allowed. #{self}"   if @id
+        @id = new_id
+        # link the new id in th id_to_state map
+        @persistor.bind_state_to_id(self)
+        id
+      end
+
+      def resource=(new_resource)
+        # Hack
+        # for some emtpy resources , resource == nil returns true
+        # but nil == resource returns false
+        # which is why we test both.
+        return if resource == new_resource && new_resource == resource
+        raise RuntimeError, "modifing existing resource not allowed. #{self}"   if @resource
+        @resource = new_resource
+        # link the new resource in th resource_to_state map
+        @persistor.bind_state_to_resource(self)
+        update_dirty_key
+        resource
+      end
+
+      def mark_for_deletion
+        @to_delete = true
+      end
+
+      # @todo use state machine ?
+      def save_action
+        case
+        when @body_saved then nil
+        when to_delete && !new? then :delete
+        when new? then :insert
+        when dirty? then :update
+        end
+      end
+
+      def inserted(new_id=nil)
+        self.id = new_id
+        update_dirty_key
+      end
+
+      def updated
+        update_dirty_key
+      end
+
+      def parents_saved!
+        @parents_saved = true
+      end
+      def parents
+        !@parents_saved && @persistor.parents_for(resource)
+      end
+      def parents!
+        parents.tap { parents_saved! }
+      end
+      def children_saved!
+        @children_saved = true
+      end
+
+      def parents_saved?
+        @parents_saved
+      end
+      def children
+        return [] if to_delete
+        !@children_saved && @persistor.children_for(resource)
+      end
+      def children!
+        children.tap { children_saved! }
+      end
+      def body_saved!
+        @body_saved = true
+      end
+
+        def reset
+          @parents_saved = nil
+          @children_saved = nil
+          @body_saved= nil
+        end
+      end
+    end
+  end
+

data/lib/lims-core/persistence/search.rb

@@ -0,0 +1,3 @@
+#vi: ts=2 sw=2 et
+# Convenience file.
+require 'lims-core/persistence/search/search_persistor'

data/lib/lims-core/persistence/search/all.rb

@@ -0,0 +1,3 @@
+require('lims-core/persistence/search/create_search')
+require('lims-core/persistence/search/search_persistor')
+require('lims-core/persistence/search/search_sequel_persistor')

data/lib/lims-core/persistence/search/create_search.rb

@@ -0,0 +1,55 @@
+# vi: ts=2:sts=2:et:sw=2  spell:spelllang=en  
+require 'lims-core/actions/action'
+
+require 'lims-core/persistence/search/search_persistor'
+require 'lims-core/persistence/multi_criteria_filter'
+require 'lims-core/persistence/comparison_filter'
+
+module Lims::Core
+  module Persistence
+    class Search
+      class CreateSearch
+        include Actions::Action
+
+        attribute :description, String, :required => true
+        attribute :model, String, :required => true
+        attribute :criteria, Hash, :required => true
+
+        def _call_in_session(session)
+          # Use the appropriate filter if needed.
+          filter = nil
+          keys = criteria.keys
+          keys.delete("comparison") if criteria.keys.size > 1
+          if keys.size == 1
+            keys.first.andtap do |model|
+              filter_class_name = "#{model.capitalize.gsub(/_[^_]*/) { |b| b[1..b.size].capitalize }}Filter"
+              if Persistence::const_defined? filter_class_name
+                filter = Persistence::const_get(filter_class_name).new(:criteria => criteria)
+              end
+            end
+          end
+          filter ||= Persistence::MultiCriteriaFilter.new(:criteria => criteria)
+          search = Persistence::Search.new(:description => description, 
+                                           :model => session.send(model).model, 
+                                           :filter => filter)
+          if search.valid?   
+            stored_search = session.search[search.attributes, false].first
+            if stored_search.nil?
+              session << search
+            else 
+              search = stored_search
+            end
+            { :search => search, :uuid => session.uuid_for!(search) }
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+  module Persistence
+    class Search
+      Create = CreateSearch
+    end
+  end
+end

data/lib/lims-core/persistence/search/search_persistor.rb

@@ -0,0 +1,45 @@
+#vi: ts=2 sw=2 et
+require 'common'
+
+require 'lims-core/resource'
+require 'lims-core/persistence/persistor'
+require 'lims-core/persistence/filter'
+
+# We need to load all the possible filter to be able load them by name.
+require_all('*filter')
+
+module Lims::Core
+  module Persistence
+    # base class handling searches. A Search represent a set of parameters 
+    # which when executed returns a set of similar object (.i.e the same class).
+    # A search is savable.
+    class Search
+      include Resource
+      attribute :description, String, :required => true, :initializable => true, :write => :private
+      attribute :model, Class, :required => true, :initializable => true, :writer => :private
+      attribute :filter, Filter, :required => true, :initializable => true, :writer => :private
+
+      # Main method. Take an session an return an filtered persistor.
+      # @param [Session]
+      # @return [Persistor]
+      def call(session)
+        filter.call(session.persistor_for(@model))
+      end
+
+      # Base persistor for Search object.
+      # It should be called Persistence::Search but, this is 
+      # already taken by the main Search class.
+      class SearchPersistor < Persistence::Persistor
+        Model = Persistence::Search
+        # Override default one, because filter are serialized
+        # and even though they are a Resource they are not counted as parents
+        def parents(resource)
+          []
+        end
+      end
+
+
+    end
+  end
+end
+

data/lib/lims-core/persistence/search/search_sequel_persistor.rb

@@ -0,0 +1,40 @@
+# vi: ts=2:sts=2:et:sw=2 spell:spelllang=en
+
+require 'lims-core/persistence/search/search_persistor'
+require 'lims-core/persistence/sequel/persistor'
+
+
+module Lims::Core
+  module Persistence
+    # Not a search but a search persistor.
+    class Search
+      class SearchSequelPersistor < Search::SearchPersistor
+        include Persistence::Sequel::Persistor
+
+        def self.table_name
+          :searches
+        end
+
+        def filter_attributes_on_load(attributes)
+          filter_parameters = @session.unserialize(attributes[:filter_parameters])
+          # The first key should be a symbol, @see persistence/comparison_filter.rb for example
+          filter_parameters.rekey! { |k| k.to_sym }
+          {
+            :description => attributes[:description],
+            :model => constant(attributes[:model]),
+            :filter => Persistence.const_get(attributes[:filter_type]).new(filter_parameters)
+          }
+        end
+        def filter_attributes_on_save(attributes, *args)
+          filter = attributes[:filter]
+          {
+            :description => attributes[:description],
+            :model => attributes[:model].name,
+            :filter_type => filter.class.name.split('::').last,
+            :filter_parameters => @session.serialize(filter.attributes)
+          }
+        end
+      end
+    end
+  end
+end

data/lib/lims-core/persistence/sequel.rb

@@ -0,0 +1,14 @@
+# vi: ts=2:sts=2:et:sw=2 spell:spelllang=en
+# please keep 2 empty lines to avoid to comment to be
+# seen as Persistence doc.
+require 'common'
+
+module Lims::Core::Persistence
+  # Persistence module using the {http://sequel.rubyforge.org/ sequel} gem.
+  # It implements abstract/base classes : {Store}, {Session} etc.
+  module Sequel
+  end
+end
+
+# require everything
+require 'lims-core/persistence/sequel/store'

data/lib/lims-core/persistence/sequel/filters.rb

@@ -0,0 +1,106 @@
+require 'lims-core/persistence/sequel'
+require 'active_support/inflector'
+
+module Lims::Core
+  module Persistence
+    # Implementes filter methods needed by persitors.
+    module Sequel::Filters
+
+      LIKE_OPERATOR = 'LIKE'
+      COMPARISON_OPERATORS = ["<", "<=", "=", ">=", ">", LIKE_OPERATOR]
+
+      # Implement a multicriteria filter for a Sequel::Persistor.
+      # Value can be either a String, an Array  or a Hash.
+      # Strings and Arrays are normal filters, whereas Hashes
+      # correspond to a joined search. The criteria will apply to the 
+      # joined object corresponding to the key.
+      # @param [Hash<String, Object > criteria
+      # @return [Persistor]
+      def multi_criteria_filter(criteria)
+        # We need to create the adequat dataset.
+        dataset = __multi_criteria_filter(criteria).dataset
+        # As the dataset can include join, we need to select only the columns
+        # corresponding to the persistor
+        self.class.new(self, dataset.qualify(table_name).distinct())
+      end
+
+      # Implement a comparison filter for a Sequel::Persistor.
+      # Key being the name of the resource's field and the value is a Hash.
+      # The key of the hash is a comparison operator
+      # and the value is the given value the filter do the comparison against.
+      # @param [Hash<String, Object>] criteria
+      # @return [Persistor]
+      def comparison_filter(criteria)
+        clause = ""
+        criteria.each do |field, comparison_expression|
+          comparison_expression.each do |operator, value|
+            if operator.upcase == LIKE_OPERATOR
+              operator = operator.upcase
+              value = "%#{value}%" if operator == LIKE_OPERATOR
+            end
+
+            raise ArgumentError, "Not supported comparison operator has been given: '#{operator}'" unless COMPARISON_OPERATORS.include?(operator) 
+
+            clause = clause + ') & (' unless clause == ""
+            clause = clause + " #{field} " + operator + "'#{value}'"
+          end
+        end
+
+        self.class.new(self, dataset.where(clause).qualify)
+      end
+
+      # Joins the comparison filter to the existing persistor.
+      # @param [Dataset] dataset
+      # @param [Hash<String, Object>] criteria for the comparison
+      # @return [Persistor]
+      def add_comparison_filter(dataset, comparison_criteria)
+        comparison_persistor = comparison_filter(comparison_criteria)
+        self.class.new(self, dataset.join(comparison_persistor.dataset, :id => :key).qualify)
+      end
+
+      protected
+      # @param Hash criteria
+      # @return Persistor
+      def __multi_criteria_filter(criteria)
+        # Extract critera recursively and apply subhashes to
+        # joined table
+        # Hash value are criteria for the corresponding joined tabled
+        # We need to extract them and do the obvious join
+        # Values are passed to filter_attributes_on save to get
+        # the right format if needed.
+        joined = criteria.reduce(self) do |persistor, (key, value)|
+          case value
+          when Hash
+            criteria_persistor = persistor.send(key)
+            filtered_value = criteria_persistor.filter_attributes_on_save(value.rekey {|k| k.to_sym})
+            joined_persistor = criteria_persistor.__multi_criteria_filter(filtered_value)
+            __join(joined_persistor)
+          else persistor
+          end
+        end
+
+        # We need to passes to filter are applied on the joined persistor.
+        # This is needed because the __join function expected bare persistor 
+        # and will loose any filter applied on the original persistor
+        criteria.reduce(joined) do |persistor, (key, value)|
+          case value
+          when Hash
+            persistor
+          else
+            self.class.new(persistor, persistor.dataset.filter(::Sequel.qualify(table_name, key) => value))
+          end
+        end
+      end
+
+      # Assume that the original persistor his *blank* ie 
+      # it doesn't contain any SQL modifier
+      # @param [Persistor] persistor
+      # @return [Persistor]
+      def __join(persistor)
+        self.class.new(self, persistor.dataset.join(table_name, primary_key => :"#{table_name.to_s.singularize}_#{persistor.primary_key}"))
+      end
+
+    end
+  end
+end
+

data/lib/lims-core/persistence/sequel/migrations.rb

@@ -0,0 +1,14 @@
+require 'common'
+
+# A namespace containing migrations mixin
+module Lims
+  module Core
+    module Persistence
+      module Sequel
+        module Migrations
+        end
+      end
+    end
+  end
+end
+require_all('migrations/*')