effective_resources 2.5.4 → 2.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b61642f0df33f0c4ae152ce94fe4e8b455c05ef012d156bcfd3cfa49b6f99f2c
-  data.tar.gz: 1c2333209641f7c555322808ed7f5980cd02620d206cd6538072a863494f11de
+  metadata.gz: '00988bb634b26b3acd5d90cf94a2cffbb55dc5d4c73db5afe6668d06860a3091'
+  data.tar.gz: d55a09844c23668b754c9ac1d43a6f087330620b32d642b7ceca1990f00a3134
 SHA512:
-  metadata.gz: 0baedf6b1cfe7d25ad4f551cfc710b64b5253154dfed6a7b17d2d745cded561e2d1f516f973bbd9c165ace4747a7c48806e7e70dbfd4b13d7ede919155655500
-  data.tar.gz: 97b02b7a8da7a7f9e81758cdffb3cc2f42d84a99aeb2840e69d05c8e80973b4d5170edabcb85b21a902c1be8a07464c65aca463304746884461e61fec6c9e980
+  metadata.gz: 452023c6b1e60a9317914409b9da54887ec6f686f49c762c7ea87c574ed77172e92519edc685800d297d87976eb936ace8ee3978f0be7f20602c201c0148d366
+  data.tar.gz: 65021dd0297c40f44d1aef163c8dcfbfa4c94aea720ec42290f164ae3f00950fcd79a1df3167eaac86ca1916c9a10f86ed8655d5e5c2788d1a3a0f8973a4bfa2

data/app/models/concerns/acts_as_statused.rb

@@ -24,67 +24,6 @@ module ActsAsStatused
     end
   end
 
-  module CanCan
-    # The idea here is you can go forward but you can't go back.
-    def acts_as_statused(klass, only: nil, except: nil)
-      raise "klass does not implement acts_as_statused" unless klass.acts_as_statused?
-
-      statuses = klass.const_get(:STATUSES)
-      instance = klass.new
-
-      only = Array(only).compact
-      except = Array(except).compact
-
-      statuses.each_with_index do |status, index|
-        action = status_active_verb(status, instance)
-
-        next if action.blank?
-        next if only.present? && !only.include?(action)
-        next if except.present? && except.include?(action)
-
-        if index == 0
-          can(action, klass) and next
-        end
-
-        if status == :approved && statuses.include?(:declined)
-          if (position = statuses.index { |status| (status == :approved || status == :declined) }) > 0
-            can(action, klass) { |obj| obj.public_send("#{statuses[position-1]}?") || obj.declined? }
-            next
-          end
-        end
-
-        if status == :declined && statuses.include?(:approved)
-          if (position = statuses.index { |status| (status == :approved || status == :declined) }) > 0
-            can(action, klass) { |obj| obj.public_send("#{statuses[position-1]}?") }
-            next
-          end
-        end
-
-        can(action, klass) { |obj| obj.public_send("#{statuses[index-1]}?") }
-      end
-    end
-
-    private
-
-    # requested -> request, approved -> approve, declined -> decline, pending -> pending
-    def status_active_verb(status, instance)
-      status = status.to_s.strip
-
-      if status.end_with?('ied')
-        action = status[0...-3] + 'y'
-        return action.to_sym if instance.respond_to?(action + '!')
-      end
-
-      # ed, e, ing
-      [-1, -2, -3].each do |index|
-        action = status[0...index]
-        return action.to_sym if instance.respond_to?(action + '!')
-      end
-
-      nil
-    end
-  end
-
   included do
     acts_as_statused_options = @acts_as_statused_options
 
@@ -103,38 +42,85 @@ module ActsAsStatused
       self.status ||= self.class.const_get(:STATUSES).first
 
       # Set an existing belongs_to automatically
-      if respond_to?("#{status}_by=") && respond_to?("#{status}_by") && send("#{status}_by").blank?
+      if respond_to?("#{status}_by") && send("#{status}_by").blank?
         self.send("#{status}_by=", current_user)
       end
 
       # Set an existing timestamp automatically
-      if respond_to?("#{status}_at=") && respond_to?("#{status}_at") && send("#{status}_at").blank?
+      if respond_to?("#{status}_at") && send("#{status}_at").blank?
         self.send("#{status}_at=", Time.zone.now)
       end
 
+      if current_user.present?
+        self.status_steps["#{status}_by_id".to_sym] ||= current_user.id
+        self.status_steps["#{status}_by_type".to_sym] ||= current_user.class.name
+      end
+
       self.status_steps["#{status}_at".to_sym] ||= Time.zone.now
-      self.status_steps["#{status}_by".to_sym] ||= current_user.try(:id)
     end
 
     validates :status, presence: true, inclusion: { in: const_get(:STATUSES).map(&:to_s) }
 
     # Create an received scope and approved? method for each status
     acts_as_statused_options[:statuses].each do |sym|
+      sym_at = "#{sym}_at".to_sym
+      sym_by = "#{sym}_by".to_sym
+      sym_by_id = "#{sym}_by_id".to_sym
+      sym_by_type = "#{sym}_by_type".to_sym
+
       scope(sym, -> { where(status: sym.to_s) })
 
+      # approved?
       define_method("#{sym}?") { status == sym.to_s }
-      define_method("was_#{sym}?") { send("#{sym}_at").present? }
 
-      #unless has_attribute?("#{sym}_at")
-        define_method("#{sym}_at") { status_steps["#{sym}_at".to_sym] }
-        define_method("#{sym}_at=") { |value| status_steps["#{sym}_at".to_sym] = value }
-      #end
+      # was_approved?
+      define_method("was_#{sym}?") { send(sym_at).present? }
+
+      # approved_at
+      define_method(sym_at) { self[sym_at.to_s] || status_steps[sym_at] }
+
+      # approved_by_id
+      define_method(sym_by_id) { self[sym_by_id.to_s] || status_steps[sym_by_id] }
+
+      # approved_by_type
+      define_method(sym_by_type) { self[sym_by_type.to_s] || status_steps[sym_by_type] }
+
+      # approved_by
+      define_method(sym_by) do
+        user = (super() if attributes.key?(sym_by_id.to_s))
+
+        user ||= begin
+          id = status_steps[sym_by_id]
+          klass = status_steps[sym_by_type]
+
+          klass.constantize.find(id) if id.present? && klass.present?
+        end
+      end
+
+      # approved_at=
+      define_method("#{sym_at}=") do |value|
+        super(value) if attributes.key?(sym_at.to_s)
+        status_steps[sym_at] = value
+      end
+
+      # approved_by_id=
+      define_method("#{sym_by_id}=") do |value|
+        super(value) if attributes.key?(sym_by_id.to_s)
+        status_steps[sym_by_id] = value
+      end
+
+      # approved_by_type=
+      define_method("#{sym_by_type}=") do |value|
+        super(value) if attributes.key?(sym_by_type.to_s)
+        status_steps[sym_by_type] = value
+      end
 
-      #unless has_attribute?("#{sym}_by_id")
-        define_method("#{sym}_by") { acts_as_statused_by_user(sym) }
-        define_method("#{sym}_by_id") { status_steps["#{sym}_by".to_sym] }
-        define_method("#{sym}_by_id=") { |value| status_steps["#{sym}_by".to_sym] = value }
-      #end
+      # approved_by=
+      define_method("#{sym_by}=") do |value|
+        super(value) if attributes.key?(sym_by_id.to_s)
+        status_steps[sym_by_id] = value&.id
+        status_steps[sym_by_type] = value&.class&.name
+      end
 
       # approved!
       define_method("#{sym}!") do |atts = {}|
@@ -146,17 +132,18 @@ module ActsAsStatused
       define_method("un#{sym}!") do
         self.status = nil if (status == sym.to_s)
 
-        status_steps.delete("#{sym}_at".to_sym)
-        status_steps.delete("#{sym}_by".to_sym)
-
-        if respond_to?("#{sym}_at=") && respond_to?("#{sym}_at") && send("#{sym}_at").present?
+        if respond_to?("#{sym}_at") && send("#{sym}_at").present?
           self.send("#{sym}_at=", nil)
         end
 
-        if respond_to?("#{sym}_by=") && respond_to?("#{sym}_by") && send("#{sym}_by").present?
+        if respond_to?("#{sym}_by") && send("#{sym}_by").present?
           self.send("#{sym}_by=", nil)
         end
 
+        status_steps.delete(sym_at)
+        status_steps.delete(sym_by_id)
+        status_steps.delete(sym_by_type)
+
         true
       end
 
@@ -167,16 +154,4 @@ module ActsAsStatused
     def acts_as_statused?; true; end
   end
 
-  private
-
-  def acts_as_statused_by_user(status)
-    return nil if status_steps["#{status}_by".to_sym].blank?
-
-    @acts_as_statused_by_users ||= begin
-      User.where(id: status_steps.map { |k, v| v.presence if k.to_s.end_with?('_by') }.compact).all.inject({}) { |h, user| h[user.id] = user; h }
-    end
-
-    @acts_as_statused_by_users[status_steps["#{status}_by".to_sym]]
-  end
-
 end

data/app/models/effective/resources/relation.rb

@@ -281,7 +281,8 @@ module Effective
 
         # Normalize the term.
         # If you pass an email attribute it can return nil so we return the full value
-        term = Attribute.new(as).parse(value, name: name) || value
+        term = Attribute.new(as).parse(value, name: name)
+        term = value if term.nil?
 
         # If using the joined syntax from datatables
         joined = (sql_column.to_s.split('.').first.to_s.include?(relation.arel_table.name) == false)
@@ -305,7 +306,14 @@ module Effective
                 end
               )
 
+              if as == :date
+                term = term.to_date
+                end_at = end_at.to_date
+              end
+
               relation.where("#{sql_column} >= ? AND #{sql_column} <= ?", term, end_at)
+            elsif value.respond_to?(:strftime) && operation == :eq
+              relation.where(attribute.matches(value))
             end
 
           when :effective_obfuscation

data/lib/effective_resources/engine.rb

@@ -50,7 +50,6 @@ module EffectiveResources
           end
 
           CanCan::Ability.include(ActsAsArchived::CanCan)
-          CanCan::Ability.include(ActsAsStatused::CanCan)
         end
       end
     end

data/lib/effective_resources/version.rb

@@ -1,3 +1,3 @@
 module EffectiveResources
-  VERSION = '2.5.4'.freeze
+  VERSION = '2.6.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: effective_resources
 version: !ruby/object:Gem::Version
-  version: 2.5.4
+  version: 2.6.0
 platform: ruby
 authors:
 - Code and Effect
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-03-28 00:00:00.000000000 Z
+date: 2023-03-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails