workarea-core 3.4.12

data/app/services/workarea/packaging.rb

@@ -0,0 +1,103 @@
+# Out of the box, the system assumes one package per order. This is a very naive
+# implementation, but the complexities required to handle all the possibilities
+# is beyond the scope of this system.
+#
+# If using a shipping gateway that relies on packaging, it is recommended you
+# decorate this class and implement the logic the retailer prefers to use.
+#
+module Workarea
+  class Packaging
+    class Package < Struct.new(:weight, :dimensions, :value); end
+
+    # Passing in the {Shipping} is optional, done in {ShippingOptions} to allow
+    # easier customization for order with multiple {Shipping}.
+    #
+    def initialize(order, shipping = nil)
+      @order = order
+      @shipping = shipping
+    end
+
+    # Returns an Array out-of-the-box to allow easier multi-package
+    # customization. Out-of-the-box will only ever return one package.
+    #
+    # @return Array<ActiveShipping::Package>
+    #
+    def packages
+      [
+        ActiveShipping::Package.new(
+          total_weight,
+          total_dimensions,
+          Workarea.config.shipping_options.merge(value: total_value)
+        )
+      ]
+    end
+
+    def total_weight
+      individual_packages.sum(&:weight)
+    end
+
+    def total_dimensions
+      if individual_dimensions?
+        stacked_dimensions
+      else
+        Workarea.config.shipping_dimensions
+      end
+    end
+
+    def total_value
+      individual_packages.sum(&:value)
+    end
+
+    def individual_dimensions?
+      individual_packages.all? { |p| p.dimensions.present? }
+    end
+
+    private
+
+    def find_shipping_sku(sku)
+      shipping_skus.detect { |s| s.id == sku } || Shipping::Sku.new(id: sku)
+    end
+
+    def find_item_quantity(item)
+      return item.quantity unless @shipping.present? && @shipping.partial?
+
+      @shipping.quantities.detect do |item_id, quantity|
+        item_id.to_s == item.id.to_s
+      end.try(:last) || 0
+    end
+
+    def shipping_skus
+      @shipping_skus ||= Shipping::Sku
+                          .any_in(id: shippable_items.map(&:sku))
+                          .to_a
+    end
+
+    def individual_packages
+      shippable_items.reduce([]) do |memo, item|
+        quantity = find_item_quantity(item)
+        next memo unless quantity.positive?
+
+        sku = find_shipping_sku(item.sku)
+        unit_value = item.total_value / item.quantity
+
+        quantity.times do
+          memo << Package.new(sku.weight, sku.dimensions, unit_value)
+        end
+
+        memo
+      end
+    end
+
+    def shippable_items
+      @order.items.reject(&:digital?)
+    end
+
+    def stacked_dimensions
+      total_height = individual_packages.map { |p| p.dimensions.first }.sum
+      largest_width = individual_packages.map { |p| p.dimensions.second }.max
+      largest_length = individual_packages.map { |p| p.dimensions.third }.max
+
+      [largest_length, largest_width, total_height]
+    end
+  end
+end

data/app/services/workarea/save_publishing.rb

@@ -0,0 +1,34 @@
+module Workarea
+  class SavePublishing
+    delegate :errors, to: :release, allow_nil: true
+
+    def initialize(releasable, params)
+      @releasable = releasable
+      @params = params
+    end
+
+    def perform
+      return false if release.present? && !release.valid?
+      return true if @releasable.blank?
+
+      Release.with_current(release.try(:id)) do
+        @releasable.update_attributes!(active: activate?)
+      end
+    end
+
+    def release
+      return if @params[:activate].in?(%w(now never))
+
+      @release ||=
+        if @params[:activate] == 'new_release'
+          Release.create(@params[:release])
+        else
+          Release.find(@params[:activate])
+        end
+    end
+
+    def activate?
+      @params[:activate] != 'never'
+    end
+  end
+end

data/app/services/workarea/save_taxonomy.rb

@@ -0,0 +1,39 @@
+module Workarea
+  class SaveTaxonomy
+    def self.build(navigable)
+      navigable.taxon || navigable.build_taxon(
+        name: navigable.name,
+
+        # These two fields necessary because Mongoid isn't setting them
+        # automatically :(
+        navigable_type: navigable.class.name,
+        navigable_id: navigable.id
+      )
+    end
+
+    def initialize(taxon, params)
+      @taxon = taxon
+      @params = params
+    end
+
+    def perform
+      @taxon.update_attributes!(parent_id: @params[:parent_id])
+      @taxon.move_to_position(@params[:position]) if @params[:position].present?
+
+      set_taxonomy_slug
+    end
+
+    def set_taxonomy_slug
+      Release.with_current(nil) do
+        Sidekiq::Callbacks.disable(RedirectNavigableSlugs) do
+          slug = FindTaxonomySlug.new(@taxon.navigable, @taxon).slug
+          @taxon.navigable.update_attributes!(slug: slug) if slug.present?
+        end
+      end
+    end
+
+    def top_level?
+      @taxon.parent == Navigation::Taxon.root
+    end
+  end
+end

data/app/services/workarea/set_navigable.rb

@@ -0,0 +1,71 @@
+module Workarea
+  class SetNavigable
+    class MissingSlugMapEntry < RuntimeError; end
+
+    cattr_accessor :slug_map
+    self.slug_map ||= {
+      'page' => Content::Page,
+      'category' => Catalog::Category,
+      'product' => Catalog::Product
+    }
+
+    def initialize(taxon, params)
+      @taxon = taxon
+      @params = params
+    end
+
+    def new_navigable?
+      @params[:new_navigable_type].present? &&
+        @params[:new_navigable_name].present?
+    end
+
+    def existing_navigable?
+      @params[:navigable_type].present? && @params[:navigable_id].present?
+    end
+
+    def navigable?
+      new_navigable? || existing_navigable?
+    end
+
+    def slug
+      if new_navigable?
+        @params[:new_navigable_type]
+      elsif existing_navigable?
+        @params[:navigable_type]
+      end
+    end
+
+    def navigable_class
+      slug_map[slug] if slug.present?
+    end
+
+    def navigable
+      assert_navigable_class if navigable?
+
+      if new_navigable?
+        navigable_class.create!(name: @params[:new_navigable_name])
+      elsif existing_navigable?
+        navigable_class.find(@params[:navigable_id])
+      end
+    end
+
+    def set
+      @taxon.navigable = navigable
+    end
+
+    private
+
+    def assert_navigable_class
+      if navigable_class.nil?
+        raise(
+          MissingSlugMapEntry,
+          <<-message
+            There is no entry in the slug map for '#{slug}'.
+            You must add a map from slug to class in Workarea::SetNavigable:
+            Workarea::SetNavigable.slug_map['#{slug}'] = #{slug.to_s.classify}
+          message
+        )
+      end
+    end
+  end
+end

data/app/services/workarea/sort_navigation_menus_by_orders.rb

@@ -0,0 +1,32 @@
+module Workarea
+  class SortNavigationMenusByOrders
+    def self.perform
+      new.perform
+    end
+
+    def perform
+      sorted_menus.each_with_index { |m, i| m.set(position: i) }
+    end
+
+    def menus
+      @menus ||= Navigation::Menu.all.to_a
+    end
+
+    def sorted_menus
+      @sorted_menus ||= menus.sort_by { |m| scores[m] || 999 }.reverse
+    end
+
+    private
+
+    def scores
+      menus.reduce({}) do |memo, menu|
+        memo.merge(
+          menu => Metrics::MenuByDay
+            .by_menu(menu.id)
+            .since(Workarea.config.sorting_score_ttl.ago)
+            .score(:orders)
+        )
+      end
+    end
+  end
+end

data/app/services/workarea/tag_update.rb

@@ -0,0 +1,15 @@
+module Workarea
+  class TagUpdate
+    attr_accessor :removes, :adds
+
+    def initialize(adds: [], removes: [])
+      @adds = adds
+      @removes = removes
+    end
+
+    def apply(tags)
+      tags.reject! { |tag| removes.include?(tag) }
+      tags.concat(adds).uniq!
+    end
+  end
+end

data/app/view_models/workarea/application_view_model.rb

@@ -0,0 +1,72 @@
+module Workarea
+  class ApplicationViewModel
+    attr_reader :model, :options
+
+    def self.wrap(input, options = {})
+      if input.is_a?(Enumerable)
+        input.map { |i| new(i, options) }
+      else
+        new(input, options)
+      end
+    end
+
+    def initialize(model = nil, options = {})
+      @model = model
+      @options = if options.respond_to?(:to_unsafe_h)
+                   options.to_unsafe_h.with_indifferent_access
+                 else
+                   options.to_h.with_indifferent_access
+                 end
+    end
+
+    def method_missing(method, *args, &block)
+      if model && model.respond_to?(method)
+        # Define a method so the next call is faster
+        self.class.send(:define_method, method) do |*args, &blok|
+          model.send(method, *args, &blok)
+        end
+
+        send(method, *args, &block)
+      else
+        super
+      end
+
+    rescue NoMethodError => no_method_error
+      super if no_method_error.name == method
+      raise no_method_error
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      super || (model && model.respond_to?(method_name))
+    end
+
+    def to_param
+      model.to_param
+    end
+
+    def to_model
+      model
+    end
+
+    def present?
+      model.present?
+    end
+
+    def blank?
+      model.blank?
+    end
+
+    def nil?
+      model.nil?
+    end
+
+    def ==(other)
+      (other.class == self.class && other.id == id) || other == model
+    end
+
+    def translate(key, options = {})
+      I18n.translate(key, options)
+    end
+    alias :t :translate
+  end
+end

data/app/view_models/workarea/shipping_carrier_view_model.rb

@@ -0,0 +1,24 @@
+module Workarea
+  module ShippingCarrierViewModel
+    def carrier
+      carrier_info.first if model.present?
+    end
+
+    def tracking_link
+      "#{carrier_info.last}#{model.tracking_number}" if model.present?
+    end
+
+    private
+
+    def carrier_info
+      return [] unless model.tracking_number.present?
+
+      tuple = tracking_links.detect { |r, _| r.match(model.tracking_number) }
+      tuple ? tuple.last : []
+    end
+
+    def tracking_links
+      Workarea.config.shipping_service_tracking_links
+    end
+  end
+end

data/app/workers/sidekiq/callbacks.rb

@@ -0,0 +1,242 @@
+module Sidekiq
+  # A plugin for +Sidekiq+ that enables automatic job enqueuing via
+  # Rails callback methods. Mix +Sidekiq::Callbacks+ into your model to
+  # enable this feature on any class that defines +run_callbacks+.
+  module Callbacks
+    extend ActiveSupport::Concern
+    class InvalidConfiguration < RuntimeError; end
+
+    class << self
+      # Permanently or temporarily enable callback workers. If
+      # no workers are given, it will enable all callback
+      # workers during the execution of the block or globally if no
+      # block is given. If a block and workers are given, workers
+      # provided will only be enable during the execution of the
+      # block. Callback workers already enabled will continue to be
+      # enabled during block execution.
+      #
+      # @example permanently enable all workers
+      #   Sidekiq::Callbacks.enable
+      #
+      # @example temporarily enable all workers
+      #   Sidekiq::Callbacks.enable do
+      #     Content.create!(name: 'Foo')
+      #   end
+      #
+      # @example permanently enable specific workers
+      #   Sidekiq::Callbacks.enable(IndexProductBrowse, IndexContent)
+      #
+      # @example temporarily enable specific workers
+      #   Sidekiq::Callbacks.enable(IndexContent) do
+      #     Content.create!(name: 'Foo')
+      #   end
+      #
+      # @overload enable(worker, ...)
+      #   @param [Object] worker  A worker to enable
+      #   @param [Object] ...     Any number of workers to enable
+      #
+      # @yield code to be executed during temporarily enabling of workers
+      # @return nil or result of block if provided
+      #
+      def enable(*workers, &block)
+        set_workers(workers, :enable, &block)
+      end
+
+      # Permanently or temporarily disable callback workers. If
+      # no workers are given, it will disable all callback
+      # workers during the execution of the block or globally if no
+      # block is given. If a block and workers are given, workers
+      # provided will only be disabled during the execution of the block.
+      #
+      # @example permanently disable all workers
+      #   Sidekiq::Callbacks.disable
+      #
+      # @example temporarily disable all workers
+      #   Sidekiq::Callbacks.disable do
+      #     Content.create!(name: 'Foo')
+      #   end
+      #
+      # @example permanently disable specific workers
+      #   Sidekiq::Callbacks.disable(IndexProductBrowse, IndexContent)
+      #
+      # @example temporarily disable specific workers
+      #   Sidekiq::Callbacks.disable(IndexContent) do
+      #     Content.create!(name: 'Foo')
+      #   end
+      #
+      # @overload disable(worker, ...)
+      #   @param [Object] worker  A worker to disable
+      #   @param [Object] ...     Any number of workers to disable
+      #
+      # @yield code to be executed during temporarily disabling of workers
+      # @return nil or result of block if provided
+      #
+      def disable(*workers, &block)
+        set_workers(workers, :disable, &block)
+      end
+
+      # Permanently or temporarily inline callback workers. If
+      # no workers are given, it will inline all callback
+      # workers during the execution of the block or globally if no
+      # block is given. If a block and workers are given, workers
+      # provided will only be inline during the execution of the
+      # block. Callback workers already inlined will continue to be
+      # inlined during block execution.
+      #
+      # @example permanently inline all workers
+      #   Sidekiq::Callbacks.inline
+      #
+      # @example temporarily inline all workers
+      #   Sidekiq::Callbacks.inline do
+      #     Content.create!(name: 'Foo')
+      #   end
+      #
+      # @example permanently inline specific workers
+      #   Sidekiq::Callbacks.inline(IndexProductBrowse, IndexContent)
+      #
+      # @example temporarily inline specific workers
+      #   Sidekiq::Callbacks.inline(IndexContent) do
+      #     Content.create!(name: 'Foo')
+      #   end
+      #
+      # @overload inline(worker, ...)
+      #   @param [Object] worker  A worker to inline
+      #   @param [Object] ...     Any number of workers to inline
+      #
+      # @yield code to be executed during temporarily enabling of workers
+      # @return nil or result of block if provided
+      #
+      def inline(*workers, &block)
+        set_workers(workers, :inline, &block)
+      end
+
+      # Permanently or temporarily inline callback workers. If
+      # no workers are given, it will inline all callback
+      # workers during the execution of the block or globally if no
+      # block is given. If a block and workers are given, workers
+      # provided will only be async during the execution of the block.
+      #
+      # @example permanently inline all workers
+      #   Sidekiq::Callbacks.inline
+      #
+      # @example temporarily async all workers
+      #   Sidekiq::Callbacks.async do
+      #     Content.create!(name: 'Foo')
+      #   end
+      #
+      # @example permanently async specific workers
+      #   Sidekiq::Callbacks.async(IndexProductBrowse, IndexContent)
+      #
+      # @example temporarily async specific workers
+      #   Sidekiq::Callbacks.async(IndexContent) do
+      #     Content.create!(name: 'Foo')
+      #   end
+      #
+      # @overload async(worker, ...)
+      #   @param [Object] worker  A worker to set async
+      #   @param [Object] ...     Any number of workers to set async
+      #
+      # @yield code to be executed during temporarily asyncing of workers
+      # @return nil or result of block if provided
+      #
+      def async(*workers, &block)
+        set_workers(workers, :async, &block)
+      end
+
+      # This method is run on boot to ensure a valid configuration of callback
+      # workers. It will raise a Sidekiq::Callbacks::InvalidConfiguration if it
+      # finds a problem.
+      #
+      def assert_valid_config!
+        Sidekiq::CallbacksWorker.workers.each do |worker|
+          if (worker.enqueue_on.values.flatten & [:find, 'find']).any?
+            raise(
+              InvalidConfiguration,
+              "For performance reasons, Sidekiq::Callbacks do not support the `find` callback."
+            )
+          end
+        end
+      end
+
+      private
+
+      def set_workers(workers, action)
+        workers = Sidekiq::CallbacksWorker.workers if workers.blank?
+
+        if !block_given?
+          workers.each(&action)
+        else
+          worker_state = workers.reduce({}) do |memo, worker|
+            memo[worker] = [worker.enabled?, worker.inlined?]
+            memo
+          end
+
+          workers.each(&action)
+
+          begin
+            result = yield
+
+          ensure
+            workers.each do |worker|
+              worker.enabled = worker_state[worker].first
+              worker.inlined = worker_state[worker].second
+            end
+          end
+
+          result
+        end
+      end
+    end
+
+    def run_callbacks(kind, *)
+      result = super
+      _enqueue_callback_workers(kind) if result != false && kind != :find
+      result
+    end
+
+    private
+
+    def _enqueue_callback_workers(kind)
+      Sidekiq::CallbacksWorker.workers.select(&:enabled?).each do |worker|
+        worker.callbacks.each do |klass, callbacks|
+          if _perform_callback_worker?(klass, callbacks, kind, worker)
+            args = worker.find_callback_args(self)
+
+            if worker.inlined?
+              worker.new.perform(*args)
+            else
+              worker.perform_async(*args)
+            end
+          end
+        end
+      end
+    end
+
+    def _perform_callback_worker?(model_class, callbacks, kind, worker_class)
+      _is_a_callback_type_match?(model_class) &&
+        Array(callbacks).include?(kind) &&
+        worker_class.perform_callback?(self)
+    end
+
+    def _is_a_callback_type_match?(model_class)
+      return is_a?(model_class) if ::Rails.application.config.cache_classes
+
+      # This is a funny way of doing the same check as `is_a?`.
+      #
+      # Consider this example from a Sidekiq::CallbacksWorker:
+      #   `enqueue_on: { Catalog::Product => :create }`
+      #
+      # On app boot, we get a reference to the Catalog::Product constant. If in
+      # development reloading mode, something causes that constant to get reloaded
+      # we end up with the same constant with a different `object_id`. This
+      # happens because Rails undefines the constant and creates it again.
+      # Because these `object_id`s are different, the `is_a?` check will fail in
+      # subsequent checks to see if this worker should fire.
+      #
+      # This hack uses string comparison to alleviate.
+      #
+      @_callbacks_ancestors_cache ||= self.class.ancestors.map(&:name)
+      @_callbacks_ancestors_cache.include?(model_class.name)
+    end
+  end
+end