workarea-core 3.4.45 → 3.5.0.beta.1

data/app/models/workarea/pricing/discount/application_group.rb

@@ -6,7 +6,8 @@ module Workarea
 
         class << self
           def calculate(discounts, order, shippings)
-            groups = Rails.cache.fetch('discount_application_groups', expires_in: Workarea.config.cache_expirations.discount_application_groups, race_condition_ttl: 10) do
+            expiration = Workarea.config.cache_expirations.discount_application_groups
+            groups = Rails.cache.fetch(current_cache_key, expires_in: expiration, race_condition_ttl: 10) do
               # Ensure an undirected graph of compatibility on discounts
               discounts.each do |discount|
                 discount.compatible_discount_ids.each do |id|
@@ -30,8 +31,12 @@ module Workarea
             groups.map { |set| new(set.to_a, order, shippings) }
           end
 
-          def expire_cache
-            Rails.cache.delete('discount_application_groups')
+          def current_cache_key
+            [
+              'discount_application_groups',
+              Release.current&.id,
+              *Segment.current.map(&:id).sort
+            ].compact.join('/')
           end
 
           private

data/app/models/workarea/pricing/discount/free_gift.rb

@@ -125,8 +125,9 @@ module Workarea
 
         def free_product_attributes(sku)
           ttl = Workarea.config.cache_expirations.free_gift_attributes
+          key = ['workarea/free_gift', sku, Release.current&.id].compact.join('/')
 
-          Rails.cache.fetch("workarea/free_gift/#{sku}", expires_in: ttl) do
+          Rails.cache.fetch(key, expires_in: ttl) do
             Workarea::OrderItemDetails.find(sku).try(:to_h) || {}
           end
         end

data/app/models/workarea/pricing/discount/redemption.rb

@@ -18,8 +18,8 @@ module Workarea
         belongs_to :discount,
           class_name: 'Workarea::Pricing::Discount'
 
+        scope :recent, -> { desc(:created_at) }
         index({ discount_id: 1, email: 1 })
-        index({ discount_id: 1, created_at: -1 }, { background: true })
 
         before_validation :downcase_email
 

data/app/models/workarea/pricing/discount.rb

@@ -91,8 +91,7 @@ module Workarea
       has_many :redemptions,
         class_name: 'Workarea::Pricing::Discount::Redemption'
 
-      index(active: 1)
-      index(updated_at: 1)
+      index(created_at: 1) # for DeactivateStaleDiscounts
 
       validates :name, presence: true
 
@@ -243,7 +242,7 @@ module Workarea
       # @return [Time]
       #
       def auto_deactivates_at
-        start = last_redemption.try(:created_at) || updated_at
+        start = last_redemption.try(:created_at) || created_at
         start + Workarea.config.discount_staleness_ttl
       end
 

data/app/models/workarea/pricing/item_tax_applier.rb

@@ -0,0 +1,41 @@
+module Workarea
+  module Pricing
+    class ItemTaxApplier
+      include TaxApplication
+
+      def initialize(address, adjustments_to_tax)
+        @address = address
+        @adjustments_to_tax = adjustments_to_tax
+        @adjustments_by_parent = adjustments_to_tax.grouped_by_parent
+      end
+
+      def apply
+        @adjustments_to_tax.each { |adjustment| assign_item_tax(adjustment) }
+      end
+
+      private
+
+      def assign_item_tax(adjustment)
+        order_item = adjustment._parent
+        taxable_amount = @adjustments_by_parent[order_item].taxable_share_for(adjustment)
+        return if taxable_amount.zero?
+
+        rate = Tax.find_rate(adjustment.data['tax_code'], taxable_amount, @address)
+        tax_amounts = calculate_tax_amounts(taxable_amount, rate)
+        return if tax_amounts.values.sum.zero?
+
+        order_item.adjust_pricing(
+          price: 'tax',
+          calculator: self.class.name,
+          description: 'Item Tax',
+          amount: tax_amounts.values.sum,
+          data: tax_amounts.merge(
+            'adjustment' => adjustment.id,
+            'order_item_id' => adjustment._parent.id,
+            'tax_code' => adjustment.data['tax_code']
+          )
+        )
+      end
+    end
+  end
+end

data/app/models/workarea/pricing/price.rb

@@ -3,6 +3,7 @@ module Workarea
     class Price
       include ApplicationDocument
       include Releasable
+      include UnsupportedSegmentation
 
       field :min_quantity, type: Integer, default: 1
       field :regular, type: Money, default: 0

data/app/models/workarea/pricing/request.rb

@@ -4,6 +4,7 @@ module Workarea
       def initialize(order, shippings)
         @persisted_order = order
         @persisted_shippings = Array(shippings)
+        @persisted_payment = Workarea::Payment.find(order.id) rescue nil
       end
 
       # Builds a duplicate, non-persisted version of the {Workarea::Order}
@@ -44,6 +45,15 @@ module Workarea
         end
       end
 
+      def payment
+        return unless @persisted_payment.present?
+
+        @payment ||=
+          Workarea::Payment.instantiate(@persisted_payment.as_document).tap do |payment|
+            payment.new_record = true # Ensure this isn't persisted by raising duplicate key if saved
+          end
+      end
+
       # An enumerable of discounts, which allows single a single db query for discounts
       # to fix N+1 discount queries.
       #
@@ -99,6 +109,7 @@ module Workarea
         @cache_key ||= CacheKey.new(
           @persisted_order,
           @persisted_shippings,
+          @persisted_payment,
           self
         )
       end

data/app/models/workarea/pricing/sku.rb

@@ -5,6 +5,7 @@ module Workarea
 
       include ApplicationDocument
       include Releasable
+      include UnsupportedSegmentation
 
       field :_id, type: String
       field :on_sale, type: Boolean, default: false

data/app/models/workarea/pricing/tax_application.rb

@@ -0,0 +1,21 @@
+module Workarea
+  module Pricing
+    module TaxApplication
+      extend ActiveSupport::Concern
+      include GuardNegativePrice
+
+      def calculate_tax_amounts(taxable_amount, rate)
+        {
+          'country_amount' => calculate_tax_amount(taxable_amount, rate.country_percentage),
+          'region_amount' => calculate_tax_amount(taxable_amount, rate.region_percentage),
+          'postal_code_amount' => calculate_tax_amount(taxable_amount, rate.postal_code_percentage)
+        }
+      end
+
+      def calculate_tax_amount(amount, percentage)
+        return 0.to_m unless percentage.present?
+        guard_negative_price { amount * percentage }
+      end
+    end
+  end
+end

data/app/models/workarea/pricing/tax_applier.rb

@@ -1,7 +1,7 @@
 module Workarea
   module Pricing
     class TaxApplier
-      include GuardNegativePrice
+      include TaxApplication
 
       def initialize(shipping, adjustments_to_tax)
         @shipping = shipping
@@ -30,22 +30,19 @@ module Workarea
           @shipping.address
         )
 
-        tax_amount = guard_negative_price do
-          taxable_amount * rate.percentage
-        end
-
-        return if tax_amount.zero?
+        tax_amounts = calculate_tax_amounts(taxable_amount, rate)
+        return if tax_amounts.values.sum.zero?
 
         @shipping.adjust_pricing(
           price: 'tax',
           calculator: self.class.name,
           description: 'Item Tax',
-          amount: tax_amount,
-          data: {
+          amount: tax_amounts.values.sum,
+          data: tax_amounts.merge(
             'adjustment' => adjustment.id,
             'order_item_id' => adjustment._parent.id,
             'tax_code' => adjustment.data['tax_code']
-          }
+          )
         )
       end
 
@@ -60,7 +57,7 @@ module Workarea
       end
 
       def assign_shipping_tax
-        return unless shipping_total > 0
+        return unless shipping_total.positive?
 
         tax_rate = Tax.find_rate(
           @shipping.shipping_service.tax_code,
@@ -70,18 +67,18 @@ module Workarea
 
         return unless tax_rate.charge_on_shipping?
 
-        amount = shipping_total * tax_rate.percentage
+        amounts = calculate_tax_amounts(shipping_total, tax_rate)
 
-        if amount > 0
+        if amounts.values.sum.positive?
           @shipping.adjust_pricing(
             price: 'tax',
             calculator: self.class.name,
             description: 'Shipping Tax',
-            amount: amount,
-            data: {
+            amount: amounts.values.sum,
+            data: amounts.merge(
               'shipping_service_tax' => true,
               'tax_code' => tax_rate.category.code
-            }
+            )
           )
         end
       end

data/app/models/workarea/pricing/unsupported_segmentation.rb

@@ -0,0 +1,22 @@
+module Workarea
+  module Pricing
+    module UnsupportedSegmentation
+      extend ActiveSupport::Concern
+
+      included do
+        validate :unsupported_segmentation
+      end
+
+      private
+
+      def unsupported_segmentation
+        if active_segment_ids.present?
+          errors.add(
+            :active_segment_ids,
+            I18n.t('workarea.errors.messages.unsupported_segmentation')
+          )
+        end
+      end
+    end
+  end
+end

data/app/models/workarea/product_rule.rb

@@ -1,6 +1,7 @@
 module Workarea
   class ProductRule
     include ApplicationDocument
+    include Releasable
 
     OPERATORS = %w(
       greater_than
@@ -22,6 +23,10 @@ module Workarea
     validates :name, presence: true
     validates :operator, presence: true
 
+    def self.usable
+      scoped.select(&:active?).select(&:valid?)
+    end
+
     # The identifier for which admin partials to render for this rule.
     #
     # @return [Symbol]

data/app/models/workarea/releasable.rb

@@ -2,9 +2,12 @@ module Workarea
   module Releasable
     extend ActiveSupport::Concern
     include Mongoid::DocumentPath
+    include Release::Activation
+    include Segmentable
 
     included do
       field :active, type: Boolean, default: true, localize: Workarea.config.localized_active_fields
+      attr_accessor :release_id
 
       has_many :changesets,
         class_name: 'Workarea::Release::Changeset',
@@ -12,11 +15,8 @@ module Workarea
 
       validate :slug_unchanged, on: :update
 
-      scope :active, -> { where(active: true) }
-      scope :inactive, -> { where(active: false) }
-
-      around_create :save_activate_with
-      before_update :save_release_changes
+      define_model_callbacks :save_release_changes
+      before_update :handle_release_changes
       after_find :load_release_changes
       after_destroy :destroy_embedded_changesets
 
@@ -25,8 +25,22 @@ module Workarea
       else
         index(active: 1)
       end
+    end
+
+    def changesets_with_children
+      criteria = Release::Changeset.any_of(
+        { releasable_type: self.class.name, releasable_id: id }
+      )
 
-      attr_accessor :activate_with
+      embedded_relations.each do |name, metadata|
+        Array.wrap(send(name)).each do |child|
+          if child.respond_to?(:changesets_with_children)
+            criteria.merge!(child.changesets_with_children)
+          end
+        end
+      end
+
+      criteria
     end
 
     # A hash of changes for being set on the changeset. It's just a filtered
@@ -35,17 +49,44 @@ module Workarea
     # @return [Hash]
     #
     def release_changes
-      changes.keys.inject({}) do |memo, key|
-        old_value, new_value = *changes[key]
+      ::Workarea::Release::Changes.new(self).to_h
+    end
 
-        if Release::Changeset.track_change?(key, old_value, new_value)
-          memo[key] = new_value
-        end
+    def release_originals
+      ::Workarea::Release::Changes.new(self).to_originals_h
+    end
 
-        memo
+    # Get a new instance of this model loaded with changes for the release
+    # passed in.
+    #
+    # @return [Releasable]
+    #
+    def in_release(release)
+      if release.blank? && !changed? # No extra work necessary, return a copy
+        result = dup
+        result.id = id
+        result.release_id = nil
+        result
+      elsif release.present? && !changed? # We don't have to reload from DB, just apply release changes to a copy
+        result = dup
+        result.id = id
+        result.release_id = release.id
+        release.preview.changesets_for(self).each { |cs| cs.apply_to(result) }
+        result
+      else
+        Release.with_current(release) { self.class.find(id) }
       end
     end
 
+    # Get a new instance of this model without any release changes. This a new
+    # instance without any release changes applied.
+    #
+    # @return [Releasable]
+    #
+    def without_release
+      in_release(nil)
+    end
+
     # Skip the release changeset for the duration of the block. Used when
     # publishing a changeset, i.e. don't apply/save the release changes since
     # we actually want to publish.
@@ -54,19 +95,10 @@ module Workarea
     #
     def skip_changeset
       @_skip_changeset = true
-      result = yield
-      @_skip_changeset = false
-      result
-    end
+      yield
 
-    # Whether this model becomes active with the current release. Used for some
-    # funny business when displaying content blocks in the admin. :(
-    #
-    # @return [Boolean]
-    #
-    def activates_with_current_release?
-      return false if Release.current.blank?
-      active? && active_changed? && !was_active?
+    ensure
+      @_skip_changeset = false
     end
 
     # Persist a to be recalled for publishing later. This is where changesets
@@ -76,34 +108,22 @@ module Workarea
     #
     # @param release_id [String]
     #
-    def save_changeset(release_id)
-      return unless release_id.present?
-
-      changeset = Release::Changeset.find_or_initialize_by(
-        releasable_id: id,
-        releasable_type: self.class.name,
-        release_id: release_id
-      )
-
-      if changeset.persisted? && release_changes.present?
-        # This is to avoid triggering callbacks - calling #save on a
-        # persisted Changeset is causing Mongoid to run callbacks on the
-        # parent document, which resets the changeset changes to previous
-        # values, not allowing updates to a changeset. #set merges a hash
-        # field's new value into the old, so a call to #unset is necessary
-        # to ensure any removed changes are properly deleted.
-        #
-        # TODO check in with this before v3 to see if Mongoid has fixed or
-        # open a Mongoid PR
-        #
-        changeset.unset(:changeset)
-        changeset.set(changeset: release_changes)
-      elsif release_changes.present?
-        changeset.document_path = document_path
-        changeset.changeset = release_changes
-        changeset.save!
-      elsif changeset.persisted?
-        changeset.destroy
+    def save_changeset(release)
+      return unless release.present?
+
+      changeset = release.changesets.find_or_initialize_by(releasable: self)
+
+      run_callbacks :save_release_changes do
+        if changeset.persisted? && release_changes.present?
+          changeset.update!(changeset: release_changes, original: release_originals)
+        elsif release_changes.present?
+          changeset.document_path = document_path
+          changeset.changeset = release_changes
+          changeset.original = release_originals
+          changeset.save!
+        elsif changeset.persisted?
+          changeset.destroy
+        end
       end
 
       changes.each do |field, change|
@@ -111,22 +131,25 @@ module Workarea
       end
     end
 
-    def releasable?
-      true
+    def destroy(*)
+      if embedded? && Release.current.present?
+        update!(active: false)
+      else
+        super
+      end
     end
 
     private
 
     def load_release_changes
-      # Documents found with .only cause issues
-      return if readonly? || Release.current.blank?
+      return if readonly? || Release.current.blank? # Documents found with .only cause issues
 
-      changeset = changesets.find_by(release_id: Release.current.id) rescue nil
-      changeset.apply_to(self) if changeset.present?
+      Release.current.preview.changesets_for(self).each { |c| c.apply_to(self) }
+      self.release_id = Release.current.id
     end
 
-    def save_release_changes
-      save_changeset(Release.current.try(:id)) unless @_skip_changeset
+    def handle_release_changes
+      save_changeset(Release.current) unless @_skip_changeset
     end
 
     def destroy_embedded_changesets
@@ -138,34 +161,5 @@ module Workarea
         errors.add(:slug, 'cannot be changed for releases')
       end
     end
-
-    def save_activate_with
-      self.active = false if activate_with?
-      yield
-      create_activation_changeset(activate_with) if activate_with?
-    end
-
-    def activate_with?
-      activate_with.present? && BSON::ObjectId.legal?(activate_with)
-    end
-
-    def create_activation_changeset(release_id)
-      set = changesets.find_or_initialize_by(release_id: release_id)
-      set.document_path = document_path
-
-      active_changeset = if Workarea.config.localized_active_fields
-        { 'active' => { I18n.locale => true } }
-      else
-        { 'active' => true }
-      end
-
-      set.changeset = active_changeset
-      set.save!
-    end
-
-    def was_active?
-      (Workarea.config.localized_active_fields && active_was[I18n.locale]) ||
-        (!Workarea.config.localized_active_fields && active_was)
-    end
   end
 end

data/app/models/workarea/release/activation.rb

@@ -0,0 +1,45 @@
+module Workarea
+  class Release
+    module Activation
+      extend ActiveSupport::Concern
+
+      included do
+        around_create :save_activate_with
+        attr_accessor :activate_with
+      end
+
+      def save_activate_with
+        self.active = false if activate_with?
+        yield
+        create_activation_changeset(activate_with) if activate_with?
+      end
+
+      def activate_with?
+        activate_with.present? && BSON::ObjectId.legal?(activate_with)
+      end
+
+      def create_activation_changeset(release_id)
+        set = changesets.find_or_initialize_by(release_id: release_id)
+        set.document_path = document_path
+
+        set.changeset = if Workarea.config.localized_active_fields
+          { 'active' => { I18n.locale.to_s => true } }
+        else
+          { 'active' => true }
+        end
+        set.original = if Workarea.config.localized_active_fields
+          { 'active' => { I18n.locale.to_s => false } }
+        else
+          { 'active' => false }
+        end
+
+        set.save!
+      end
+
+      def was_active?
+        (Workarea.config.localized_active_fields && active_was[I18n.locale.to_s]) ||
+          (!Workarea.config.localized_active_fields && active_was)
+      end
+    end
+  end
+end

data/app/models/workarea/release/changes.rb

@@ -0,0 +1,45 @@
+module Workarea
+  class Release
+    class Changes
+      attr_reader :releasable
+
+      def self.tracked_change?(key, old_value, new_value)
+        !key.in?(Workarea.config.untracked_release_changes_fields) &&
+          (old_value.present? || new_value.present?)
+      end
+
+      def initialize(releasable)
+        @releasable = releasable
+      end
+
+      def to_h
+        releasable.changes.keys.inject({}) do |memo, key|
+          old_value, new_value = *releasable.changes[key]
+
+          memo[key] = new_value if track_change?(key, old_value, new_value)
+          memo
+        end
+      end
+
+      def to_originals_h
+        releasable.changes.keys.inject({}) do |memo, key|
+          old_value, new_value = *releasable.changes[key]
+
+          memo[key] = old_value if track_change?(key, old_value, new_value)
+          memo
+        end
+      end
+
+      def track_change?(key, old_value, new_value)
+        self.class.tracked_change?(key, old_value, new_value) &&
+          !change_appears_in_earlier_release?(key, new_value)
+      end
+
+      def change_appears_in_earlier_release?(key, new_value)
+        Release.current.scheduled_before.flat_map(&:changesets).any? do |changeset|
+          changeset.releasable == releasable && changeset.includes_change?(key, new_value)
+        end
+      end
+    end
+  end
+end