workarea-core 3.4.44 → 3.5.0.beta.1

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

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

@@ -1,34 +1,23 @@
+# This fixes Release::Changes == Mongoid::AuditLog::Changes in development
+require_dependency 'workarea/release/changes'
+
 module Workarea
   class Release
     class Changeset
       include ApplicationDocument
 
       field :changeset, type: Hash, default: {}
-      field :undo, type: Hash, default: {}
+      field :original, type: Hash, default: {}
+      field :undo, type: Hash, default: {} # TODO deprecated, remove in v3.6
 
       embeds_many :document_path, class_name: 'Mongoid::DocumentPath::Node'
 
       belongs_to :release, class_name: 'Workarea::Release', index: true
       belongs_to :releasable, polymorphic: true, index: true, optional: true
 
-      index(
-        { 'document_path.type' => 1, 'document_path.document_id' => 1 },
-        { name: 'document_path' }
-      )
-
-      # Whether these value changes to this field should be included when
-      # saving a changeset. Used in building changeset hashes.
-      #
-      # @param attribute [String]
-      # @param old_value [Object]
-      # @param new_value [Object]
-      #
-      # @return [Boolean]
-      #
-      def self.track_change?(attribute, old_value, new_value)
-        !attribute.in?(Workarea.config.untracked_release_changes_fields) &&
-          (old_value.present? || new_value.present?)
-      end
+      index({ 'document_path.type' => 1, 'document_path.document_id' => 1 })
+      index('changeset.product_ids' => 1)
+      index('original.product_ids' => 1)
 
       # Finds changeset by whether the passed document is in the document
       # path of the changeset. Useful for showing embedded changes in the
@@ -61,6 +50,10 @@ module Workarea
         changeset.keys
       end
 
+      def includes_change?(key, new_value)
+        changed_fields.include?(key) && changeset[key] == new_value
+      end
+
       # Apply (but do not save) the changes represented by this changeset to
       # the model passed in.
       #
@@ -73,45 +66,44 @@ module Workarea
       # Make the changes represented by this changeset live. Used when
       # publishing a release.
       #
-      # Builds and saves the undo in case that's desired later.
-      #
       # @return [Boolean]
       #
       def publish!
         return false if releasable_from_document_path.blank?
 
-        build_undo
         apply_to(releasable_from_document_path)
 
         releasable_from_document_path.skip_changeset do
           releasable_from_document_path.save!
         end
 
-        save! # saves undo
+        save!
       end
 
-      # Apply the changes in the undo hash on this changeset and save to make
-      # them live. Used when undoing a release.
-      #
-      # @return [Boolean]
-      #
-      def undo!
-        apply_changeset(releasable_from_document_path, undo)
-
-        releasable_from_document_path.skip_changeset do
-          releasable_from_document_path.save!
+      def build_undo(attributes = {})
+        # Ensure the appropriate Release.current for building the undo
+        # This can be nil, which is essential if there is some other arbitrary
+        # release as Release.current.
+        Release.with_current(release.previous) do
+          releasable_from_document_path.reload
+
+          Changeset.new(
+            attributes.reverse_merge(
+              releasable: releasable,
+              document_path: document_path,
+              changeset: changeset.keys.inject({}) do |memo, key|
+                old_value = releasable_from_document_path.attributes[key]
+                new_value = changeset[key]
+
+                memo[key] = old_value if Changes.tracked_change?(key, old_value, new_value)
+                memo
+              end
+            )
+          )
         end
-      end
 
-      def releasable_from_document_path
-        return @releasable_from_document_path if defined?(@releasable_from_document_path)
-
-        @releasable_from_document_path =
-          begin
-            Mongoid::DocumentPath.find(document_path)
-          rescue Mongoid::Errors::DocumentNotFound
-            nil
-          end
+      ensure
+        releasable_from_document_path.reload
       end
 
       private
@@ -123,17 +115,15 @@ module Workarea
         end
       end
 
-      def build_undo(model = releasable_from_document_path)
-        self.undo = changeset.keys.inject({}) do |memo, key|
-          old_value = model.attributes[key]
-          new_value = changeset[key]
+      def releasable_from_document_path
+        return @releasable_from_document_path if defined?(@releasable_from_document_path)
 
-          if self.class.track_change?(key, old_value, new_value)
-            memo[key] = old_value
+        @releasable_from_document_path =
+          begin
+            Mongoid::DocumentPath.find(document_path)
+          rescue Mongoid::Errors::DocumentNotFound
+            nil
           end
-
-          memo
-        end
       end
     end
   end

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

@@ -0,0 +1,28 @@
+module Workarea
+  class Release
+    class Preview
+      attr_reader :release
+
+      def initialize(release)
+        @release = release
+      end
+
+      def releases
+        @releases ||= release.scheduled_before + [release]
+      end
+
+      def changesets
+        @changesets ||= releases.flat_map(&:changesets)
+      end
+
+      def changesets_for(model)
+        changesets.select do |changeset|
+          # Check this way because loading the releasable will cause `load_release_changes`
+          # to run this, resulting in a stack overflow.
+          changeset.releasable_type == model.class.name &&
+            changeset.releasable_id.to_s == model.id.to_s
+        end
+      end
+    end
+  end
+end

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

@@ -5,9 +5,7 @@ module Workarea
         include StatusCalculator::Status
 
         def in_status?
-          model.publish_at.blank? &&
-          model.published_at.blank? &&
-          model.undo_at.blank?
+          model.publish_at.blank? && model.published_at.blank?
         end
       end
 
@@ -24,27 +22,7 @@ module Workarea
         include StatusCalculator::Status
 
         def in_status?
-          model.published_at.present? &&
-          model.publish_at.blank?
-        end
-      end
-
-      class Undone
-        include StatusCalculator::Status
-
-        def in_status?
-          model.published_at.present? &&
-          model.undone_at.present?
-        end
-      end
-
-      class ScheduledUndo
-        include StatusCalculator::Status
-
-        def in_status?
-          return false unless model.undo_at.present?
-          model.published_at.present? &&
-          model.undo_at >= Time.current
+          model.published_at.present? && model.publish_at.blank?
         end
       end
     end

data/app/models/workarea/release_session.rb

@@ -1,7 +1,7 @@
 module Workarea
   class ReleaseSession
-    def initialize(cookies)
-      @cookies = cookies
+    def initialize(session)
+      @session = session
     end
 
     def remind?
@@ -9,8 +9,8 @@ module Workarea
     end
 
     def expired_by_time?
-      @cookies.permanent[:release_changed_at].present? &&
-        Time.zone.parse(@cookies.permanent[:release_changed_at]) < timeout
+      @session[:release_changed_at].present? &&
+        Time.zone.parse(@session[:release_changed_at]) < timeout
     end
 
     def timeout
@@ -18,8 +18,8 @@ module Workarea
     end
 
     def expired_by_page_views?
-      @cookies.permanent[:release_page_views].present? &&
-        @cookies.permanent[:release_page_views].to_i > max_page_views
+      @session[:release_page_views].present? &&
+        @session[:release_page_views].to_i > max_page_views
     end
 
     def max_page_views
@@ -27,19 +27,19 @@ module Workarea
     end
 
     def save_page_view
-      incremented = @cookies.permanent[:release_page_views].to_i + 1
-      @cookies.permanent[:release_page_views] = incremented
+      incremented = @session[:release_page_views].to_i + 1
+      @session[:release_page_views] = incremented
     end
 
     def save_release_change
       reset!
-      @cookies.permanent[:release_changed_at] = Time.current.to_s
+      @session[:release_changed_at] = Time.current.to_s
     end
     alias_method :touch, :save_release_change
 
     def reset!
-      @cookies.permanent[:release_page_views] = nil
-      @cookies.permanent[:release_changed_at] = nil
+      @session.delete(:release_page_views)
+      @session.delete(:release_changed_at)
     end
   end
 end

data/app/models/workarea/search/admin.rb

@@ -5,49 +5,27 @@ module Workarea
 
       def self.jump_to(params, size = Workarea.config.default_admin_jump_to_result_count)
         query = {
-          aggs: {
-            grouped_by_type: {
-              filter: {
-                match_phrase_prefix: {
-                  jump_to_search_text: {
-                    query: params[:q],
-                    max_expansions: 10
-                  }
-                }
-              },
-              aggs: {
-                type: {
-                  terms: { field: 'facets.type', size: Workarea.config.jump_to_type_limit },
-                  aggs: {
-                    top: {
-                      top_hits: {
-                        size: Workarea.config.jump_to_results_per_type,
-                        sort: [
-                          { _score: { order: 'desc' } },
-                          { updated_at: { order: 'desc' } }
-                        ]
-                      }
-                    }
-                  }
-                }
+          query: {
+            match_phrase_prefix: {
+              jump_to_search_text: {
+                query: params[:q],
+                max_expansions: 10
               }
             }
-          }
+          },
+          size: size,
+          sort: [{ jump_to_position: :asc }]
         }
 
-        aggregation = search(query)['aggregations']['grouped_by_type']['type']
-        aggregation['buckets']
-          .reduce([]) { |m, b| m + b['top']['hits']['hits'] }
-          .sort_by { |r| [r['_source']['jump_to_position'] || 999, r['_score'] || 0] }
-          .map do |result|
-            {
-              label: result['_source']['jump_to_text'],
-              type: result['_source']['facets']['type'],
-              model_class: result['_source']['model_class'],
-              route_helper: result['_source']['jump_to_route_helper'],
-              to_param: result['_source']['jump_to_param']
-            }
-          end
+        search(query)['hits']['hits'].map do |result|
+          {
+            label: result['_source']['jump_to_text'],
+            type: result['_source']['facets']['type'],
+            model_class: result['_source']['model_class'],
+            route_helper: result['_source']['jump_to_route_helper'],
+            to_param: result['_source']['jump_to_param']
+          }
+        end
       end
 
       def self.for(model)

data/app/models/workarea/search/admin/catalog_product.rb

@@ -80,8 +80,7 @@ module Workarea
         end
 
         def low_inventory?
-          available = Inventory::Sku.in(id: model.skus).sum(&:available_to_sell)
-          available < Workarea.config.low_inventory_threshold
+          Inventory::Collection.new(model.skus).low_inventory?
         end
 
         def variant_missing_details?

data/app/models/workarea/search/admin/fulfillment_sku.rb

@@ -0,0 +1,27 @@
+module Workarea
+  module Search
+    class Admin
+      class FulfillmentSku < Search::Admin
+        def type
+          'fulfillment_sku'
+        end
+
+        def search_text
+          model.name
+        end
+
+        def jump_to_text
+          "#{model.id} - (#{model.policy})"
+        end
+
+        def jump_to_position
+          12
+        end
+
+        def facets
+          super.merge(policy: model.policy)
+        end
+      end
+    end
+  end
+end