workarea-wish_lists 3.0.4

data/app/controllers/workarea/storefront/wish_lists_controller.rb

@@ -0,0 +1,22 @@
+module Workarea
+  module Storefront
+    class WishListsController < Storefront::ApplicationController
+      def index
+        if params[:wish_list_query].present?
+          @wish_lists = WishList
+                        .search(params[:wish_list_query], params[:location])
+                        .page(params[:page] || 1)
+        end
+      end
+
+      def show
+        wish_list = WishList.find_by_token(params[:id])
+        WishList::Pricing.perform(wish_list)
+        @wish_list = WishListViewModel.new(
+          wish_list,
+          view_model_options
+        )
+      end
+    end
+  end
+end

data/app/models/workarea/wish_list.rb

@@ -0,0 +1,212 @@
+module Workarea
+  class WishList
+    include Mongoid::Document
+    include Mongoid::Timestamps
+    include UrlToken
+
+    class InvalidToken < StandardError; end
+
+    field :user_id, type: String
+    field :email, type: String
+    field :first_name, type: String
+    field :last_name, type: String
+    field :name, type: String
+    field :location, type: String
+    field :privacy, type: String, default: 'public'
+
+    index({ user_id: 1 }, { unique: true })
+    index(first_name: 1)
+    index(last_name: 1)
+    index(name: 1)
+    index(email: 1)
+
+    index(token: 1, privacy: 1)
+
+    embeds_many :items, class_name: 'Workarea::WishList::Item'
+
+    validates :privacy,
+              presence: true,
+              inclusion: { in: %w(public shared private) }
+
+    scope :named, -> { where(:name.exists => true, :name.ne => '') }
+
+    before_create :set_user_details
+
+    # Gets a wish list for a user.
+    #
+    # @param [String] user_id
+    #
+    # @return [WishList]
+    #
+    def self.for_user(user_id)
+      existing = Workarea::WishList.where(user_id: user_id).first
+      existing || Workarea::WishList.create!(user_id: user_id)
+    end
+
+    # Find wish lists for public viewing.
+    # Only returns wish lists with public privacy setting.
+    #
+    # @param [String] query
+    #   name or email
+    # @param [String] location
+    #   city, state, postal code
+    #
+    # @return [Array]
+    #
+    def self.search(query, location = '')
+      Workarea::WishList::PublicSearch.new(
+        query,
+        location
+      ).results
+    end
+
+    # Find a wish list by the share token
+    #
+    # @param [String] token
+    #
+    # @return [WishList]
+    #
+    def self.find_by_token(token)
+      raise(InvalidToken, token) if token.blank?
+
+      Workarea::WishList.where(
+        token: token,
+        :privacy.ne => 'private'
+      ).first || raise(InvalidToken, token)
+    end
+
+    # Find a list of product ids in a user's wish list
+    #
+    # @param [String, BSON::ObjectId] user_id
+    #
+    # @return [Array]
+    #
+    def self.find_products(user_id)
+      wish_list = Workarea::WishList.where(user_id: user_id).first
+      wish_list ? wish_list.items.map(&:product_id) : []
+    end
+
+    %w(public shared private).each do |privacy_level|
+      define_method "#{privacy_level}?" do
+        privacy == privacy_level
+      end
+    end
+
+    # How many valid units are in the wish list
+    #
+    # @return [Integer]
+    #
+    def quantity
+      items.select(&:valid?).sum(&:quantity)
+    end
+
+    # Get unpurchased items
+    #
+    # @return [Array]
+    #
+    def unpurchased_items
+      items.reject(&:purchased?)
+    end
+
+    # Get items from this list that have been purchased
+    #
+    # @return [Array]
+    #
+    def purchased_items
+      items.select(&:purchased?)
+    end
+
+    # Add a wish list item
+    #
+    # @param [String] product_id
+    # @param [String] sku
+    # @param [Integer] quantity
+    #
+    # @return [Boolean]
+    #   whether the item was saved
+    #
+    def add_item(product_id, sku, quantity = 1, details = {}, customizations = {})
+      if existing_item = items.where(sku: sku, customizations: customizations).first
+        change_quantity(sku, existing_item.quantity + quantity)
+      else
+        items.build(
+          product_id:     product_id,
+          sku:            sku,
+          quantity:       quantity,
+          details:        details,
+          customizations: customizations
+        )
+      end
+
+      save
+    end
+
+    # Update a wish list item's quantity
+    #
+    # @param [String] item_id
+    # @param [Integer] quantity
+    #
+    # @return [Boolean]
+    #   whether the item was saved
+    #
+
+    def update_item_quantity(item_id, quantity)
+      item = items.where(id: item_id).first
+      return false if item.nil?
+      item.update_attributes(quantity: quantity)
+    end
+
+    # Mark the items as being purchased
+    #
+    # @param [Array] skus
+    #
+    # @return [self]
+    #
+    def mark_item_purchased(sku, quantity)
+      item = items.detect { |i| i.sku == sku }
+      if item
+        item.received = item.received + quantity
+        item.purchased = true
+      end
+      save!
+    end
+
+    # Remove a SKU from the wish list
+    #
+    # @param [String] sku
+    #
+    # @return [self]
+    #
+    def remove_item(sku)
+      items.where(sku: sku).first.delete
+      save
+    end
+
+    def price_adjustments
+      PriceAdjustmentSet.new(
+        (items.map(&:price_adjustments).flatten || [])
+      )
+    end
+
+    def reset_pricing!
+      items.each(&:reset_pricing!)
+      self
+    end
+
+    def segment_ids
+      []
+    end
+
+    private
+
+    def change_quantity(sku, quantity)
+      item = items.where(sku: sku).first
+      item.quantity = quantity
+    end
+
+    def set_user_details
+      return unless user_id.present?
+      SetWishListDetails.new(self).perform
+    end
+  end
+end

data/app/models/workarea/wish_list/item.rb

@@ -0,0 +1,76 @@
+module Workarea
+  class WishList::Item
+    include Mongoid::Document
+    include Mongoid::Timestamps
+
+    field :product_id, type: String
+    field :quantity, type: Integer, default: 1
+    field :received, type: Integer, default: 0
+    field :sku, type: String
+    field :product_details, type: Hash, default: {}
+    field :sku_details, type: Hash, default: {}
+    field :customizations, type: Hash, default: {}
+    field :purchased, type: Boolean, default: false
+    field :discountable, type: Boolean, default: true
+    field :contributes_to_shipping, type: Boolean, default: true
+    field :product_attributes, type: Hash, default: {}
+    field :total_price, type: Money, default: 0
+
+    embedded_in :wish_list, inverse_of: :items
+
+    embeds_many :price_adjustments,
+                class_name: 'Workarea::PriceAdjustment',
+                extend: Workarea::PriceAdjustmentExtension
+
+    validates :product_id, presence: true
+    validates :sku, presence: true
+    validates :quantity, presence: true,
+                         numericality: {
+                           greater_than_or_equal_to: 1,
+                           only_integer: true
+                         }
+
+    def details=(details)
+      write_attributes(
+        details.slice(
+          :product_details,
+          :sku_details,
+          :product_attributes
+        )
+      )
+
+      self
+    end
+
+    # Adds a price adjustment to the item. Does not persist.
+    #
+    # @return [self]
+    #
+    def adjust_pricing(options = {})
+      price_adjustments.build(options)
+    end
+
+    # Clears out all pricing for this item.
+    #
+    def reset_pricing!
+      price_adjustments.delete_all
+    end
+
+    # The base price per-unit for this item.
+    #
+    # @return [Money]
+    #
+    def unit_price
+      price_adjustments.first.unit.to_m
+    end
+
+    # Whether this item is on sale (as of the last time the
+    # order was priced).
+    #
+    # @return [Boolean]
+    #
+    def on_sale?
+      !!price_adjustments.first.data['on_sale']
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module Workarea
+  module WishList::Pricing
+    # Build price adjustments and set order total prices.
+    #
+    # @param [Workarea::WishList] wish_list
+    # @return [self]
+    #
+    def self.perform(wish_list)
+      wish_list.reset_pricing!
+      WishList::Request.new(wish_list).run
+      self
+    end
+  end
+end

data/app/models/workarea/wish_list/pricing/calculators/totals_calculator.rb

@@ -0,0 +1,26 @@
+module Workarea
+  class WishList::Pricing::Calculators::TotalsCalculator
+    attr_reader :wish_list, :request
+
+    def initialize(wish_list, request = nil)
+      @wish_list = wish_list
+      @request = request
+    end
+
+    def adjust
+      set_item_totals
+    end
+
+    private
+
+    def price_adjustments
+      @price_adjustments ||= @wish_list.price_adjustments # Memoize for perf
+    end
+
+    def set_item_totals
+      @wish_list.items.each do |item|
+        item.total_price = item.price_adjustments.adjusting('item').sum
+      end
+    end
+  end
+end

data/app/models/workarea/wish_list/public_search.rb

@@ -0,0 +1,34 @@
+module Workarea
+  class WishList::PublicSearch
+    attr_reader :query, :location
+
+    def initialize(query, location = '')
+      @query    = query
+      @location = location
+    end
+
+    def results
+      regex = /^#{Regexp.quote(query)}/i
+      criteria = [
+        { name: regex },
+        { first_name: regex },
+        { last_name: regex },
+        { email: query } # we don't want partial matching on email
+      ]
+
+      if location.present?
+        loc_regex = /.*#{Regexp.quote(location)}.*/i
+        Workarea::WishList.where(
+          privacy: 'public',
+          location: loc_regex,
+          '$or' => criteria
+        )
+      else
+        Workarea::WishList.where(
+          privacy: 'public',
+          '$or' => criteria
+        )
+      end.named
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module Workarea
+  module Pricing
+    class WishList::Request
+      delegate :items, to: :order
+
+      def initialize(wish_list)
+        @wish_list = wish_list
+      end
+
+      def pricing
+        @pricing ||= Pricing::Collection.new(all_skus)
+      end
+
+      def order
+        @wish_list
+      end
+
+      def run
+        Workarea.config.wish_list_pricing_calculators.each do |klass|
+          klass.constantize.new(self).adjust
+        end
+      end
+
+      private
+
+      def all_skus
+        skus = [
+          @wish_list.items.map(&:sku),
+          @wish_list.items.map { |i| i.customizations['pricing_sku'] }
+        ]
+
+        skus.flatten.reject(&:blank?).uniq
+      end
+    end
+  end
+end

data/app/seeds/workarea/wish_list_seeds.rb

@@ -0,0 +1,24 @@
+module Workarea
+  class WishListSeeds
+    def perform
+      puts 'Adding wish lists...'
+
+      5.times do
+        user = Workarea::User.sample
+        wish_list = Workarea::WishList.for_user(user.id)
+        Workarea::Catalog::Product.limit(5).each do |product|
+          sku = product.skus.sample
+          quantity = rand(3) + 1
+
+          next unless sku
+          wish_list.add_item(product.id, sku, quantity)
+
+          if rand(2).zero?
+            purchased_quantity = rand(quantity) + 1
+            wish_list.mark_item_purchased(sku, purchased_quantity)
+          end
+        end
+      end
+    end
+  end
+end