effective_resources 2.1.3 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 91015a3de5ffe3fd8727b1076558a95eedd3601ce768cf7c24befa42635c6a1b
-  data.tar.gz: 655794c38fa9b32c7fd40692469fe255152820e497d727a69336429d8f7e3acc
+  metadata.gz: 570e952fca070a0e231d90c8f959a80055d6a32e0b1ec51e93ae9c88d90fd44a
+  data.tar.gz: c7b247bfb4f12f6368405ac21f0a8591dc5e000d3f4a02c2daf728489d171128
 SHA512:
-  metadata.gz: 427908e33318358ca2a00ea9d578585cd18ae62dd952016e129878ebc778303084c8af06ba5dbb2d919440f9d5a0733788895cd8d77a38224915e84381d6755b
-  data.tar.gz: 53fa67e820609b4349e1623975aee917954d865cf85dba56e27b70000a953b1394d17ab098f684a900cf60274ea25ec71e56c952f5f146822fe04c9bc39299ad
+  metadata.gz: eb7ee9c3d1be22a10ad2b2d2b24e21a4af3bb084f8bdf07b484f67922ea68553bb31410562029e6b762076eec1bd6bf9eb510734c3c2c35f4c31d768479443a9
+  data.tar.gz: 1e905d78f87ddac0bfb423ad153c1066f9925739bf7f454296b9554c6c4ef6ff4a147b125f98b1a0cddeab61bfaa7e2f710d0121e7376ca7f03b62e2e7b9a09c

data/app/models/concerns/acts_as_purchasable_wizard.rb

@@ -68,6 +68,7 @@ module ActsAsPurchasableWizard
     order.billing_address = owner.billing_address if owner.try(:billing_address).present?
 
     # Important to add/remove anything
+    # This will update the prices, but the purchasables must be persisted
     order.save!
 
     order

data/app/models/concerns/acts_as_slugged.rb

@@ -40,7 +40,13 @@ module ActsAsSlugged
       return super unless args.length == 1
       return super if block_given?
 
-      where(slug: args.first).first || raise(::ActiveRecord::RecordNotFound.new("Couldn't find #{name} with 'slug'=#{args.first}"))
+      reloading = instance_variable_get(:@_effective_reloading)
+      reloading ||= self.class.instance_variable_get(:@_effective_reloading)
+      reloading ||= klass.instance_variable_get(:@_effective_reloading) if respond_to?(:klass)
+
+      return find_by_id(args.first) if reloading
+
+      find_by_slug(args.first) || raise(::ActiveRecord::RecordNotFound.new("Couldn't find #{name} with 'slug'=#{args.first}"))
     end
 
     def find_by_slug_or_id(*args)
@@ -68,4 +74,16 @@ module ActsAsSlugged
     slug_was || slug
   end
 
+  def to_global_id(**params)
+    params[:tenant] = Tenant.current if defined?(Tenant)
+    GlobalID.new(URI::GID.build(app: Rails.application.config.global_id.app, model_name: model_name, model_id: to_param, params: params))
+  end
+
+  def reload(options = nil)
+    self.class.instance_variable_set(:@_effective_reloading, true)
+    retval = super
+    self.class.instance_variable_set(:@_effective_reloading, nil)
+    retval
+  end
+
 end

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

@@ -73,13 +73,13 @@ module Effective
           { as: :string }
         else
           if res.klass.unscoped.respond_to?(:datatables_scope)
-            { collection: res.klass.datatables_scope.map { |obj| [obj.to_s, obj.to_param] } }
+            { collection: res.klass.datatables_scope.map { |obj| [obj.to_s, obj.id] } }
           elsif res.klass.unscoped.respond_to?(:datatables_filter)
-            { collection: res.klass.datatables_filter.map { |obj| [obj.to_s, obj.to_param] } }
+            { collection: res.klass.datatables_filter.map { |obj| [obj.to_s, obj.id] } }
           elsif res.klass.unscoped.respond_to?(:sorted)
-            { collection: res.klass.sorted.map { |obj| [obj.to_s, obj.to_param] } }
+            { collection: res.klass.sorted.map { |obj| [obj.to_s, obj.id] } }
           else
-            { collection: res.klass.all.map { |obj| [obj.to_s, obj.to_param] }.sort { |x, y| x[0] <=> y[0] } }
+            { collection: res.klass.all.map { |obj| [obj.to_s, obj.id] }.sort { |x, y| x[0] <=> y[0] } }
           end
         end
       end

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

@@ -65,125 +65,274 @@ module Effective
         end
       end
 
-      def search(name, value, as: nil, fuzzy: true, sql_column: nil)
+      def search(name, value, as: nil, column: nil, operation: nil)
         raise 'expected relation to be present' unless relation
 
-        sql_column ||= sql_column(name)
-        sql_type = (as || sql_type(name))
-        fuzzy = true unless fuzzy == false
+        sql_as = (as || sql_type(name))
+        sql_column = (column || sql_column(name))
+        sql_operation = (operation || sql_operation(name, as: sql_as)).to_sym
 
         if ['SUM(', 'COUNT(', 'MAX(', 'MIN(', 'AVG('].any? { |str| sql_column.to_s.include?(str) }
           return relation.having("#{sql_column} = ?", value)
         end
 
-        association = associated(name)
-
-        term = Effective::Attribute.new(sql_type, klass: (association.try(:klass) rescue nil) || klass).parse(value, name: name)
-
-        # term == 'nil' rescue false is a Rails 4.1 fix, where you can't compare a TimeWithZone to 'nil'
-        if (term == 'nil' rescue false) && ![:has_and_belongs_to_many, :has_many, :has_one, :belongs_to, :belongs_to_polymorphic, :effective_roles].include?(sql_type)
-          return relation.where(is_null(sql_column))
+        case sql_as
+        when :belongs_to, :belongs_to_polymorphic, :has_and_belongs_to_many, :has_many, :has_one
+          search_associated(name, value, as: sql_as, operation: sql_operation)
+        else
+          return relation.where(is_null(sql_column)) if value.to_s == 'nil'
+          search_attribute(name, value, as: sql_as, operation: sql_operation)
         end
+      end
 
-        case sql_type
-        when :belongs_to
-          if term == 'nil'
-            relation.where(is_null(association.foreign_key))
-          else
-            relation.where(search_by_associated_conditions(association, term, fuzzy: fuzzy))
-          end
-        when :belongs_to_polymorphic
-          (type, id) = term.split('_')
-
-          if term == 'nil'
-            relation.where(is_null("#{sql_column}_id")).where(is_null("#{sql_column}_type"))
-          elsif type.present? && id.present? # This was from a polymorphic select
-            relation.where("#{sql_column}_id = ?", id).where("#{sql_column}_type = ?", type)
+      def search_associated(name, value, as:, operation:)
+        reflection = associated(name)
+        raise("expected to find #{relation.klass.name} #{name} reflection") unless reflection
+        raise("expected association operation") unless [:eq, :matches, :does_not_match, :sql].include?(operation)
+
+        # Parse values
+        value_ids = value.kind_of?(Array) ? value : (value.to_s.split(/,|\s|\|/) - [nil, '', ' '])
+        value_sql = Arel.sql(value) if value.kind_of?(String)
+
+        # Foreign id and type
+        foreign_id = reflection.foreign_key
+        foreign_type = reflection.foreign_key.to_s.chomp('_id') + '_type'
+
+        # belongs_to polymorphic
+        retval = if as == :belongs_to_polymorphic
+          (type, id) = value.to_s.split('_')
+
+          if type.present? && id.present?  # This was from a polymorphic select
+            case operation
+            when :eq
+              relation.where(foreign_type => type, foreign_id => id)
+            when :matches
+              relation.where(foreign_type => type, foreign_id => id)
+            when :does_not_match
+              relation.where.not(foreign_type => type, foreign_id => id)
+            when :sql
+              if (relation.where(value_sql).present? rescue :invalid) != :invalid
+                relation.where(value_sql)
+              else
+                relation
+              end
+            end
           else # Maybe from a string field
-            collection = relation.none
+            associated = relation.none
 
-            relation.unscoped.distinct("#{name}_type").pluck("#{name}_type").each do |klass_name|
+            relation.unscoped.distinct(foreign_type).pluck(foreign_type).each do |klass_name|
               next if klass_name.nil?
 
               resource = Effective::Resource.new(klass_name)
               next unless resource.klass.present?
 
-              collection = collection.or(relation.where("#{name}_id": resource.search_any(term, fuzzy: fuzzy), "#{name}_type": klass_name))
+              associated = associated.or(relation.where(foreign_id => resource.search_any(value), foreign_type => klass_name))
             end
 
-            collection
-          end
-        when :has_and_belongs_to_many, :has_many, :has_one
-          relation.where(search_by_associated_conditions(association, term, fuzzy: fuzzy))
-        when :effective_addresses
-          relation.where(id: Effective::Resource.new(association).search_any(value, fuzzy: fuzzy).pluck(:addressable_id))
-        when :effective_obfuscation
-          # If value == term, it's an invalid deobfuscated id
-          relation.where("#{sql_column} = ?", (value == term ? 0 : term))
-        when :effective_roles
-          relation.with_role(term)
-        when :active_storage
-          relation.send("with_attached_#{name}").references("#{name}_attachment")
-            .where(ActiveStorage::Blob.arel_table[:filename].matches("%#{term}%"))
-        when :boolean
-          relation.where("#{sql_column} = ?", term)
-        when :datetime, :date
-          end_at = (
-            case (value.to_s.scan(/(\d+)/).flatten).length
-            when 1 ; term.end_of_year     # Year
-            when 2 ; term.end_of_month    # Year-Month
-            when 3 ; term.end_of_day      # Year-Month-Day
-            when 4 ; term.end_of_hour     # Year-Month-Day Hour
-            when 5 ; term.end_of_minute   # Year-Month-Day Hour-Minute
-            when 6 ; term + 1.second      # Year-Month-Day Hour-Minute-Second
-            else term
+            case operation
+            when :eq
+              relation.where(id: associated.select(:id))
+            when :matches
+              relation.where(id: associated.select(:id))
+            when :does_not_match
+              relation.where.not(id: associated.select(:id))
+            when :sql
+              if (relation.where(value_sql).present? rescue :invalid) != :invalid
+                relation.where(value_sql)
+              else
+                relation
+              end
             end
-          )
-          relation.where("#{sql_column} >= ? AND #{sql_column} <= ?", term, end_at)
-        when :time
-          timed = relation.where("EXTRACT(hour from #{sql_column}) = ?", term.utc.hour)
-          timed = timed.where("EXTRACT(minute from #{sql_column}) = ?", term.utc.min) if term.min > 0
-          timed
-        when :decimal, :currency
-          if fuzzy && (term.round(0) == term) && value.to_s.include?('.') == false
-            if term < 0
-              relation.where("#{sql_column} <= ? AND #{sql_column} > ?", term, term-1.0)
+          end
+
+        # belongs_to non-polymorphic
+        elsif as == :belongs_to
+          foreign_collection = reflection.klass.all
+          foreign_collection = reflection.klass.where(foreign_type => relation.klass.name) if reflection.klass.new.respond_to?(foreign_type)
+
+          case operation
+          when :eq
+            associated = foreign_collection.where(id: value_ids)
+            relation.where(foreign_id => associated.select(:id))
+          when :matches
+            associated = Resource.new(foreign_collection).search_any(value)
+            relation.where(foreign_id => associated.select(:id))
+          when :does_not_match
+            associated = Resource.new(foreign_collection).search_any(value)
+            relation.where.not(foreign_id => associated.select(:id))
+          when :sql
+            if (foreign_collection.where(value_sql).present? rescue :invalid) != :invalid
+              associated = foreign_collection.where(value_sql)
+              relation.where(foreign_id => associated.select(:id))
             else
-              relation.where("#{sql_column} >= ? AND #{sql_column} < ?", term, term+1.0)
+              relation
             end
-          else
-            relation.where("#{sql_column} = ?", term)
           end
-        when :duration
-          if fuzzy && (term % 60 == 0) && value.to_s.include?('m') == false
-            if term < 0
-              relation.where("#{sql_column} <= ? AND #{sql_column} > ?", term, term-60)
+
+        # has_and_belongs_to_many
+        elsif as == :has_and_belongs_to_many
+          foreign_collection = reflection.source_reflection.klass.all
+
+          habtm = foreign_collection.klass.reflect_on_all_associations.find { |ass| ass.macro == :has_and_belongs_to_many && ass.join_table == reflection.join_table }
+          raise("expected a matching HABTM reflection") unless habtm
+
+          case operation
+          when :eq
+            associated = foreign_collection.where(id: value_ids)
+            relation.where(id: associated.joins(habtm.name).select(foreign_id))
+          when :matches
+            associated = Resource.new(foreign_collection).search_any(value)
+            relation.where(id: associated.joins(habtm.name).select(foreign_id))
+          when :does_not_match
+            associated = Resource.new(foreign_collection).search_any(value)
+            relation.where.not(id: associated.joins(habtm.name).select(foreign_id))
+          when :sql
+            if (foreign_collection.where(value_sql).present? rescue :invalid) != :invalid
+              associated = foreign_collection.where(value_sql)
+              relation.where(id: associated.joins(habtm.name).select(foreign_id))
             else
-              relation.where("#{sql_column} >= ? AND #{sql_column} < ?", term, term+60)
+              relation
             end
+          end
+
+        # has_many through
+        elsif reflection.options[:through].present?
+          reflected_klass = if reflection.source_reflection.options[:polymorphic]
+            reflection.klass
           else
-            relation.where("#{sql_column} = ?", term)
+            reflection.source_reflection.klass
           end
-        when :integer
-          relation.where("#{sql_column} = ?", term)
-        when :percent
-          relation.where("#{sql_column} = ?", term)
-        when :price
-          relation.where("#{sql_column} = ?", term)
-        when :string, :text, :email
-          if fuzzy
-            relation.where("#{sql_column} #{ilike} ?", "%#{term}%")
+
+          reflected_id = if reflection.source_reflection.macro == :belongs_to
+            reflection.source_reflection.foreign_key # to do check this
           else
-            relation.where("#{sql_column} = ?", term)
+            reflection.source_reflection.klass.primary_key # group_id
           end
-        when :uuid
-          if fuzzy
-            relation.where("#{sql_column}::text #{ilike} ?", "%#{term}%")
+
+          foreign_id = if reflection.through_reflection.macro == :belongs_to
+            reflection.through_reflection.klass.primary_key # to do check this
           else
-            relation.where("#{sql_column}::text = ?", term)
+            reflection.through_reflection.foreign_key # user_id
+          end
+
+          # Build the through collection
+          through = reflection.through_reflection.klass.all  # group mates
+
+          if reflection.source_reflection.options[:polymorphic]
+            through = through.where(reflection.source_reflection.foreign_type => reflected_klass.name)
+          end
+
+          # Search the associated class
+          case operation
+          when :eq
+            associated = through.where(reflected_id => value_ids)
+            relation.where(id: associated.select(foreign_id))
+          when :matches
+            reflected = Resource.new(reflected_klass).search_any(value)
+            associated = through.where(reflected_id => reflected)
+            relation.where(id: associated.select(foreign_id))
+          when :does_not_match
+            reflected = Resource.new(reflected_klass).search_any(value)
+            associated = through.where(reflected_id => reflected)
+            relation.where.not(id: associated.select(foreign_id))
+          when :sql
+            if (reflected_klass.where(value_sql).present? rescue :invalid) != :invalid
+              reflected = reflected_klass.where(value_sql)
+              associated = through.where(reflected_id => reflected)
+              relation.where(id: associated.select(foreign_id))
+            else
+              relation
+            end
+          end
+
+        # has_many and has_one
+        elsif (as == :has_many || as == :has_one)
+          foreign_collection = reflection.klass.all
+          foreign_collection = reflection.klass.where(foreign_type => relation.klass.name) if reflection.klass.new.respond_to?(foreign_type)
+
+          case operation
+          when :eq
+            associated = foreign_collection.where(id: value_ids)
+            relation.where(id: associated.select(foreign_id))
+          when :matches
+            associated = Resource.new(foreign_collection).search_any(value)
+            relation.where(id: associated.select(foreign_id))
+          when :does_not_match
+            associated = Resource.new(foreign_collection).search_any(value)
+            relation.where.not(id: associated.select(foreign_id))
+          when :sql
+            if (foreign_collection.where(value_sql).present? rescue :invalid) != :invalid
+              associated = foreign_collection.where(value_sql)
+              relation.where(id: associated.select(foreign_id))
+            else
+              relation
+            end
           end
-        else
-          raise "unsupported sql type #{sql_type}"
+        end
+
+        retval || raise("unable to search associated #{as} #{operation} #{name} for #{value}")
+      end
+
+      def search_attribute(name, value, as:, operation:)
+        raise 'expected relation to be present' unless relation
+
+        attribute = relation.arel_table[name]
+
+        # 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
+
+        searched = case as
+          when :date, :datetime
+            if value.kind_of?(String)
+              end_at = (
+                case (value.to_s.scan(/(\d+)/).flatten).length
+                when 1 ; term.end_of_year     # Year
+                when 2 ; term.end_of_month    # Year-Month
+                when 3 ; term.end_of_day      # Year-Month-Day
+                when 4 ; term.end_of_hour     # Year-Month-Day Hour
+                when 5 ; term.end_of_minute   # Year-Month-Day Hour-Minute
+                when 6 ; term + 1.second      # Year-Month-Day Hour-Minute-Second
+                else term
+                end
+              )
+
+              relation.where(attribute.gteq(term)).where(attribute.lteq(end_at))
+            end
+
+          when :effective_obfuscation
+            term = Attribute.new(as, klass: (associated(name).try(:klass) || klass)).parse(value, name: name)
+            relation.where(attribute.eq((value == term ? 0 : term)))
+
+          when :effective_addresses
+            association = associated(name)
+            associated = Resource.new(association).search_any(value)
+            relation.where(id: associated.where(addressable_type: klass.name).select(:addressable_id))
+
+          when :effective_roles
+            relation.with_role(term)
+
+          when :time
+            timed = relation.where("EXTRACT(hour from #{sql_column}) = ?", term.utc.hour)
+            timed = timed.where("EXTRACT(minute from #{sql_column}) = ?", term.utc.min) if term.min > 0
+            timed
+        end
+
+        return searched if searched
+
+        # Simple operation search
+        case operation
+          when :eq then relation.where(attribute.eq(term))
+          when :not_eq then relation.where(attribute.not_eq(term))
+          when :matches then relation.where(attribute.matches("%#{term}%"))
+          when :does_not_match then relation.where(attribute.does_not_match("%#{term}%"))
+          when :starts_with then relation.where(attribute.matches("#{term}%"))
+          when :ends_with then relation.where(attribute.matches("%#{term}"))
+          when :gt then relation.where(attribute.gt(term))
+          when :gteq then relation.where(attribute.gteq(term))
+          when :lt then relation.where(attribute.lt(term))
+          when :lteq then relation.where(attribute.lteq(term))
+          else raise("Unexpected operation: #{operation}")
         end
       end
 
@@ -195,11 +344,6 @@ module Effective
           return relation.where(klass.primary_key => value)
         end
 
-        # If the value is 3-something-like-this
-        if (values = value.to_s.split('-')).length > 0 && (maybe_id = values.first).present?
-          return relation.where(klass.primary_key => maybe_id) if (maybe_id.to_i.to_s == maybe_id)
-        end
-
         # If the user specifies columns. Filter out invalid ones for this klass
         if columns.present?
           columns = Array(columns).map(&:to_s) - [nil, '']
@@ -238,81 +382,6 @@ module Effective
 
       private
 
-      def search_by_associated_conditions(association, value, fuzzy: nil)
-        resource = Effective::Resource.new(association)
-
-        # Search the target model for its matching records / keys
-        relation = resource.search_any(value, fuzzy: fuzzy)
-
-        if association.options[:as] # polymorphic
-          relation = relation.where(association.type => klass.name)
-        end
-
-        # key: the id, or associated_id on my table
-        # keys: the ids themselves as per the target table
-        if association.macro == :belongs_to && association.options[:polymorphic]
-          key = sql_column(association.foreign_key)
-          keys = relation.pluck((relation.klass.primary_key rescue nil))
-        elsif association.macro == :belongs_to
-          key = sql_column(association.foreign_key)
-          keys = relation.pluck(association.klass.primary_key)
-        elsif association.macro == :has_and_belongs_to_many
-          key = sql_column(klass.primary_key)
-          values = relation.pluck(association.source_reflection.klass.primary_key).uniq.compact
-
-          keys = if value == 'nil'
-            klass.where.not(klass.primary_key => klass.joins(association.name)).pluck(klass.primary_key)
-          else
-            klass.joins(association.name)
-              .where(association.name => { association.source_reflection.klass.primary_key => values })
-              .pluck(klass.primary_key)
-          end
-        elsif association.options[:through].present?
-          scope = association.through_reflection.klass.all
-
-          if association.source_reflection.options[:polymorphic]
-            reflected_klass = association.klass
-            scope = scope.where(association.source_reflection.foreign_type => reflected_klass.name)
-          else
-            reflected_klass = association.source_reflection.klass
-          end
-
-          if association.through_reflection.macro == :belongs_to
-            key = association.through_reflection.foreign_key
-            pluck_key = association.through_reflection.klass.primary_key
-          else
-            key = sql_column(klass.primary_key)
-            pluck_key = association.through_reflection.foreign_key
-          end
-
-          if value == 'nil'
-            keys = klass.where.not(klass.primary_key => scope.pluck(pluck_key)).pluck(klass.primary_key)
-          else
-            keys = scope.where(association.source_reflection.foreign_key => relation).pluck(pluck_key)
-          end
-
-        elsif association.macro == :has_many
-          key = sql_column(klass.primary_key)
-
-          keys = if value == 'nil'
-            klass.where.not(klass.primary_key => resource.klass.pluck(association.foreign_key)).pluck(klass.primary_key)
-          else
-            relation.pluck(association.foreign_key)
-          end
-
-        elsif association.macro == :has_one
-          key = sql_column(klass.primary_key)
-
-          keys = if value == 'nil'
-            klass.where.not(klass.primary_key => resource.klass.pluck(association.foreign_key)).pluck(klass.primary_key)
-          else
-            relation.pluck(association.foreign_key)
-          end
-        end
-
-        "#{key} IN (#{(keys.uniq.compact.presence || [0]).join(',')})"
-      end
-
       def order_by_associated_conditions(association, sort: nil, direction: :asc, limit: nil)
         resource = Effective::Resource.new(association)
 

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

@@ -38,6 +38,15 @@ module Effective
         name.to_s.downcase == 'desc' ? 'DESC' : 'ASC'
       end
 
+      def sql_operation(name, as: nil)
+        sql_type = (as || sql_type(name))
+
+        case sql_type
+        when :boolean, :decimal, :integer, :price, :date, :datetime, :percent then :eq
+        else :matches
+        end
+      end
+
       # This is for EffectiveDatatables (col as:)
       # Might be :name, or 'users.name'
       def sql_type(name)

data/lib/effective_resources/version.rb

@@ -1,3 +1,3 @@
 module EffectiveResources
-  VERSION = '2.1.3'.freeze
+  VERSION = '2.2.0'.freeze
 end

data/lib/effective_resources.rb

@@ -172,4 +172,10 @@ module EffectiveResources
 
   end
 
+  def self.replace_nested_attributes(attributes)
+    attributes.reject { |k, values| truthy?(values[:_destroy]) }.inject({}) do |h, (key, values)|
+      h[key] = values.reject { |k, v| k == 'id' || k == '_destroy' }; h
+    end
+  end
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: effective_resources
 version: !ruby/object:Gem::Version
-  version: 2.1.3
+  version: 2.2.0
 platform: ruby
 authors:
 - Code and Effect
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-11-28 00:00:00.000000000 Z
+date: 2023-01-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails