workarea-core 3.4.44 → 3.5.0.beta.1

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.rb

@@ -8,27 +8,25 @@ module Workarea
     field :publish_at, type: Time
     field :published_at, type: Time
     field :publish_job_id, type: String
-    field :undo_at, type: Time
-    field :undone_at, type: Time
-    field :undo_job_id, type: String
+    field :undo_at, type: Time # TODO deprecated, remove in v3.6
+    field :undone_at, type: Time # TODO deprecated, remove in v3.6
+    field :undo_job_id, type: String # TODO deprecated, remove in v3.6
 
     has_many :changesets, class_name: 'Workarea::Release::Changeset'
+    has_one :undo, class_name: 'Workarea::Release', inverse_of: :undoes
+    belongs_to :undoes, class_name: 'Workarea::Release', inverse_of: :undo, optional: true
 
     index({ publish_at: 1 })
     index({ published_at: 1 })
-    index({ undo_at: 1 })
-    index({ undone_at: 1 })
 
     validates :name, presence: true
     validate :publish_at_status
-    validate :undoable_release, if: :undo_at?
 
+    after_find :reset_preview
     before_save :remove_publish_job, if: Proc.new { |r| r.publish_at.blank? }
-    before_save :remove_undo_job, if: Proc.new { |r| r.undo_at.blank? }
     before_save :schedule_publish
-    before_save :schedule_undo
+    after_save :reset_preview
     before_destroy :remove_publish_job
-    before_destroy :remove_undo_job
 
     scope :not_published, (lambda do
       any_of({ :published_at.exists => false }, { published_at: nil })
@@ -36,11 +34,21 @@ module Workarea
     scope :published, (lambda do
       where(:published_at.exists => true)
     end)
+    scope :published_between, ->(starts_at: nil, ends_at: nil) do
+      where(
+        :published_at.gte => starts_at,
+        :published_at.lte => ends_at
+      )
+    end
     scope :not_scheduled, (lambda do
       any_of({ :publish_at.exists => false }, { publish_at: nil })
     end)
-    scope :scheduled, -> { where(:publish_at.gt => Time.current) }
-    scope :to_undo, -> { where(:undo_at.gt => Time.current) }
+    scope :scheduled, ->(before: nil, after: nil) do
+      criteria = where(:publish_at.gt => Time.current)
+      criteria = criteria.where(:publish_at.lte => before) if before.present?
+      criteria = criteria.where(:publish_at.gte => after) if after.present?
+      criteria
+    end
     scope :soonest, -> { scheduled.asc(:publish_at) }
     scope :tomorrow, -> do
       where(
@@ -57,15 +65,28 @@ module Workarea
       Thread.current[:current_release] = release
     end
 
-    def self.with_current(release_id, &block)
+    def self.with_current(release)
       previous = current
-      self.current = release_id.blank? ? nil : find(release_id) rescue nil
 
-      return_value = block.call
+      new_current = if release.is_a?(Release)
+        release
+      elsif release.present?
+        find(release) rescue nil
+      end
+
+      self.current = new_current
+      current&.reset_preview
+      yield
 
     ensure
       self.current = previous
-      return_value
+
+      current&.reset_preview
+      previous&.reset_preview
+    end
+
+    def self.without_current(&block)
+      with_current(nil, &block)
     end
 
     # Gets a list of unscheduled releases
@@ -104,29 +125,12 @@ module Workarea
       results.uniq.sort_by { |r| [r.publish_at || 0, r.published_at || 0] }
     end
 
-    # Get a list of releases undone or to be undone
-    # within a given range
-    #
-    # @ return [Array<Release>]
-    #
-    def self.undone_within(start_date, end_date)
-      results = where(
-        :undo_at.gte => start_date.to_time,
-        :undo_at.lte => end_date.to_time
-      )
-
-      results += where(
-        :undone_at.gte => start_date.to_time,
-        :undone_at.lte => end_date.to_time
-      )
-
-      results.uniq.sort_by { |r| [r.undo_at || 0, r.undone_at || 0] }
+    def self.sort_by_publish
+      scoped.sort_by { |r| [r.publish_at, r.created_at] }
     end
 
     def as_current
-      self.class.with_current(id) do
-        yield
-      end
+      self.class.with_current(self) { yield }
     end
 
     def scheduled?
@@ -141,31 +145,48 @@ module Workarea
       scheduled? || (!scheduled? && !published?)
     end
 
-    def undone?
-      !!undone_at
-    end
-
     def has_changes?
       changesets.present?
     end
 
-    def publish!
-      self.published_at = Time.current
-      self.undone_at = nil
-      self.publish_at = nil
-      save!
+    def preview
+      @preview ||= Preview.new(self)
+    end
+
+    def reset_preview
+      @preview = nil
+    end
+
+    def scheduled_before
+      return [] unless scheduled?
+      self.class.scheduled(before: publish_at).ne(id: id).sort_by_publish
+    end
 
-      ordered_changesets.each(&:publish!)
-      touch_releasables
+    def scheduled_after
+      return [] unless scheduled?
+      self.class.scheduled(after: publish_at).ne(id: id).sort_by_publish
     end
 
-    def undo!
-      self.undo_at = nil if undo_at.present? && undo_at >= Time.current
-      self.undone_at = Time.current
+    def previous
+      scheduled_before.last
+    end
+
+    def build_undo(attributes = {})
+      result = undo || Release.new(attributes)
+
+      result.name ||= I18n.t('workarea.release.undo', name: name)
+      result.tags = %w(undo) if result.tags.blank?
+      self.undo = result
+
+      result
+    end
+
+    def publish!
+      self.published_at = Time.current
+      self.publish_at = nil
       save!
 
-      ordered_changesets.each(&:undo!)
-      touch_releasables
+      changesets.each(&:publish!)
     end
 
     def set_publish_job
@@ -177,15 +198,6 @@ module Workarea
       )
     end
 
-    def set_undo_job
-      self.undo_job_id = Scheduler.schedule(
-        worker: UndoRelease,
-        at: undo_at,
-        args: [id.to_s],
-        job_id: undo_job_id
-      )
-    end
-
     # Get all statuses of this release.
     #
     # @return [Array<Symbol>]
@@ -195,18 +207,6 @@ module Workarea
       StatusCalculator.new(calculators, self).results
     end
 
-    # Get changesets ordered based on publish priority set by configuration.
-    #
-    # @return [Array<Workarea::Release::Changeset>]
-    #
-    def ordered_changesets
-      ordering = Workarea.config.release_changeset_ordering
-
-      changesets.sort_by do |changeset|
-        ordering[changeset.releasable_type].presence || 999
-      end
-    end
-
     private
 
     def publish_at_status
@@ -219,38 +219,11 @@ module Workarea
       set_publish_job if publish_at_changed? && publish_at.present?
     end
 
-    def schedule_undo
-      set_undo_job if undo_at_changed? && undo_at.present?
-    end
-
     def remove_publish_job
       return if publish_job_id.blank?
 
       Scheduler.delete(publish_job_id)
       self.publish_job_id = nil
     end
-
-    def remove_undo_job
-      return if undo_job_id.blank?
-
-      Scheduler.delete(undo_job_id)
-      self.undo_job_id = nil
-    end
-
-    def undoable_release
-      unless publish_at.present? || published_at.present?
-        errors.add(:undo_at, I18n.t('workarea.errors.messages.undo_unpublished_release'))
-      end
-    end
-
-    def touch_releasables
-      Sidekiq::Callbacks.disable do
-        changesets
-          .map(&:releasable_from_document_path)
-          .compact
-          .uniq
-          .each(&:touch)
-      end
-    end
   end
 end