workarea-registries 1.0.0

data/app/controllers/workarea/storefront/users/registry_items_controller.rb

@@ -0,0 +1,67 @@
+module Workarea
+  module Storefront
+    class Users::RegistryItemsController < ApplicationController
+      before_action :require_login
+      before_action :find_registry, except: [:new]
+      before_action :find_item, except: [:new, :create, :update]
+
+      def new
+        @registries = RegistryViewModel.wrap(
+          Registry.for_user(current_user.id),
+          view_model_options
+        )
+
+        @product = ProductViewModel.wrap(
+          Catalog::Product.find(params[:product_id]),
+          view_model_options
+        )
+      end
+
+      def create
+        if @registry.add_item(item_params)
+          flash[:success] = t('workarea.storefront.flash_messages.registry_item_created')
+        else
+          flash[:error] = t('workarea.storefront.flash_messages.registry_item_not_created')
+        end
+
+        redirect_to users_registry_path(@registry)
+      end
+
+      def update
+        if @registry.update_item(params[:id], item_params)
+          flash[:success] = t('workarea.storefront.flash_messages.registry_item_updated')
+        else
+          flash[:error] = t('workarea.storefront.flash_messages.registry_item_not_updated')
+        end
+
+        redirect_to users_registry_path(@registry)
+      end
+
+      def destroy
+        if @item.unpurchased?
+         @registry.remove_item(params[:id])
+          flash[:success] = t('workarea.storefront.flash_messages.registry_item_destroyed')
+        else
+          flash[:error] = t('workarea.storefront.flash_messages.registry_item_not_destroyed')
+        end
+
+        redirect_to users_registry_path(@registry)
+      end
+
+      private
+
+      def item_params
+        params.permit(:product_id, :sku, :quantity, :purchased_by)
+      end
+
+      def find_registry
+        @registry =
+          Registry.for_user(current_user.id).find(params[:registry_id])
+      end
+
+      def find_item
+        @item = @registry.items.find(params[:id])
+      end
+    end
+  end
+end

data/app/controllers/workarea/storefront/users/registry_shares_controller.rb

@@ -0,0 +1,43 @@
+module Workarea
+  module Storefront
+    class Users::RegistrySharesController < Storefront::ApplicationController
+      before_action :find_registry_share
+
+      def new
+      end
+
+      def create
+        if @registry_share.save
+          flash[:success] = t(
+            'workarea.storefront.flash_messages.registry_share_message_sent',
+            recipient: @registry_share.friendly_to
+          )
+          RegistriesMailer.share(@registry_share.id.to_s).deliver_later
+          redirect_to users_registry_path(@registry_share.registry_id)
+        else
+          render :new
+        end
+      end
+
+      private
+
+      def find_registry_share
+        model = Registry::Share.new(share_params)
+        @registry_share = RegistryShareViewModel.wrap(model, view_model_options)
+      end
+
+      def share_params
+        params.permit(
+          :url,
+          :registry_id,
+          :registry_name,
+          :to_email,
+          :to_name,
+          :from_email,
+          :from_name,
+          :message
+        )
+      end
+    end
+  end
+end

data/app/controllers/workarea/storefront/users/registry_thanks_controller.rb

@@ -0,0 +1,41 @@
+module Workarea
+  module Storefront
+    class Users::RegistryThanksController < Storefront::ApplicationController
+      before_action :find_registry_thank
+
+      def new
+      end
+
+      def create
+        if @registry_thank.save
+          flash[:success] = t(
+            'workarea.storefront.flash_messages.registry_thank_message_sent',
+            recipient: @registry_thank.friendly_to
+          )
+          RegistriesMailer.thank(@registry_thank.id.to_s).deliver_later
+          redirect_to users_registry_path(@registry_thank.registry_id, state: 'unpurchased')
+        else
+          render :new
+        end
+      end
+
+      private
+
+      def find_registry_thank
+        model = Registry::Thank.new(thank_params)
+        @registry_thank = RegistryThankViewModel.wrap(model, view_model_options)
+      end
+
+      def thank_params
+        params.permit(
+          :registry_id,
+          :to_email,
+          :to_name,
+          :from_email,
+          :from_name,
+          :message
+        )
+      end
+    end
+  end
+end

data/app/helpers/workarea/registries_helper.rb

@@ -0,0 +1,41 @@
+module Workarea
+  module RegistriesHelper
+    def minimum_quantity(received)
+      received.positive? ? received : 1
+    end
+
+    def share_registry_url(registry, options = {})
+      registry_url(registry, options.merge(host: Workarea.config.host))
+    end
+
+    def facebook_query_string(url)
+      hash_without_blanks_to_query(u: url)
+    end
+
+    def twitter_query_string(url, message = nil)
+      hash_without_blanks_to_query(url: url, text: message)
+    end
+
+    def share_query_string(url, message = nil, image = nil)
+      hash_without_blanks_to_query(
+        url: url,
+        description: message,
+        media: image
+      )
+    end
+
+    def share_analytics_data(type, url)
+      {
+        event: 'share',
+        domEvent: 'click',
+        payload: { type: type, url: url }
+      }
+    end
+
+    private
+
+    def hash_without_blanks_to_query(hash)
+      hash.delete_if { |_k, v| v.blank? }.to_query
+    end
+  end
+end

data/app/mailers/workarea/storefront/registries_mailer.rb

@@ -0,0 +1,52 @@
+module Workarea
+  module Storefront
+    class RegistriesMailer < ApplicationMailer
+      def creation(id)
+        @registry = RegistryViewModel.wrap(Registry.find(id))
+        @content = Content::Email.find_content('registry_creation')
+
+        mail(
+          to: @registry.email,
+          from: Workarea.config.email_from,
+          subject: t('workarea.storefront.email.registries.creation.subject')
+        )
+      end
+
+      def share(id)
+        @share = RegistryShareViewModel.wrap(Registry::Share.find(id))
+        @content = Content::Email.find_content('registry_share')
+
+        mail(
+          to: @share.friendly_to,
+          from: Workarea.config.email_from,
+          reply_to: @share.from,
+          subject: t('workarea.storefront.email.registries.share.subject', from: @share.friendly_from)
+        )
+      end
+
+      def thank(id)
+        @thank = RegistryThankViewModel.wrap(Registry::Thank.find(id))
+        @content = Content::Email.find_content('registry_thank')
+
+        mail(
+          to: @thank.friendly_to,
+          from: Workarea.config.email_from,
+          reply_to: @thank.from,
+          subject: t('workarea.storefront.email.registries.thank.subject', from: @thank.friendly_from)
+        )
+      end
+
+      def gift_receipt(order_id)
+        order = Order.find(order_id)
+        @order = Storefront::OrderViewModel.wrap(order)
+        @content = Content::Email.find_content('registry_gift_receipt')
+
+        mail(
+          to: @order.registry_email,
+          from: Workarea.config.email_from,
+          subject: t('workarea.storefront.email.registries.gift_receipt.subject')
+        )
+      end
+    end
+  end
+end

data/app/models/workarea/checkout/steps/addresses.decorator

@@ -0,0 +1,28 @@
+module Workarea
+  decorate Checkout::Steps::Addresses, with: :registries do
+
+    def update(params = {})
+      set_ship_to_registrant(params)
+      super
+    end
+
+    private
+
+    def set_shipping_address(params)
+      if params[:ship_to_registrant].present? && params[:ship_to_registrant] == 'true'
+        if order.requires_shipping? && params[:registry_shipping_address].present?
+          shipping.set_address(params[:registry_shipping_address])
+          set_default_shipping_option
+        end
+      else
+        super
+      end
+    end
+
+    def set_ship_to_registrant(params)
+      if params[:ship_to_registrant].present?
+        order.ship_to_registrant = params[:ship_to_registrant]
+      end
+    end
+  end
+end

data/app/models/workarea/order.decorator

@@ -0,0 +1,7 @@
+module Workarea
+  decorate Order, with: :registries do
+    decorated do
+      field :ship_to_registrant, type: Boolean, default: false
+    end
+  end
+end

data/app/models/workarea/order/item.decorator

@@ -0,0 +1,11 @@
+module Workarea
+  decorate Order::Item, with: :registries do
+    decorated do
+      field :registry_id, type: String
+    end
+
+    def registry_item?
+      registry_id.present?
+    end
+  end
+end

data/app/models/workarea/registry.rb

@@ -0,0 +1,129 @@
+module Workarea
+  class Registry
+    include ApplicationDocument
+
+    field :user_id, type: String
+    field :email, type: String
+    field :name, type: String
+    field :description, type: String
+    field :privacy, type: String, default: 'public'
+    field :event_date, type: Date
+
+    embeds_many :items,
+      class_name: 'Workarea::Registry::Item',
+      cascade_callbacks: true,
+      inverse_of: :registry
+
+    embeds_one :address,
+      class_name: 'Workarea::Address',
+      as: :addressable
+
+    validates :name, presence: true
+    validates :user_id, presence: true
+    validates :email, presence: true
+    validates :privacy, presence: true,
+      inclusion: { in: %w(public shared private) }
+
+    scope :for_user, ->(user_id) { where(user_id: user_id.to_s) }
+    scope :by_activity, -> { order(updated_at: :desc) }
+
+    index({ user_id: 1 })
+    index('items.product_id' => 1)
+    index(name: 1)
+    index(email: 1)
+    index(id: 1)
+
+    def self.search(query)
+      Workarea::Registry::PublicSearch.new(
+        query
+      ).results
+    end
+
+    %w(public shared private).each do |privacy_level|
+      define_method "#{privacy_level}?" do
+        privacy == privacy_level
+      end
+    end
+
+    def default_privacy?
+      public? || privacy.blank?
+    end
+
+    def purchased_items
+      items.select(&:purchased_by?)
+    end
+
+    def unpurchased_items
+      items.reject(&:purchased_by?)
+    end
+
+    def available_items
+      items.reject(&:purchased_by?).select(&:available?)
+    end
+
+    def add_item(params)
+      quantity = params.fetch(:quantity, 1).to_i
+      existing_item = find_existing_item(sku: params[:sku])
+
+      if existing_item.present?
+        update_item(
+          existing_item.id,
+          quantity: existing_item.quantity + quantity
+        )
+      else
+        items.build(params)
+      end
+
+      save
+    end
+
+    def add_purchased_item(params)
+      existing_purchased_item = find_existing_purchased_item(params)
+
+      if existing_purchased_item
+        quantity = existing_purchased_item.quantity + params[:quantity]
+        existing_purchased_item.update(quantity: quantity)
+      else
+        items.build(params)
+      end
+
+      save
+    end
+
+    def update_item(id, params)
+      sku = params[:sku]
+      existing_item = find_existing_item(sku: sku) if sku.present?
+
+      if existing_item.present? && existing_item.id.to_s != id.to_s
+        item = items.find(id)
+        quantity = existing_item.quantity + (params[:quantity] || item.quantity)
+
+        existing_item.update(quantity: quantity) && item.delete
+      else
+        items.find(id).update(params)
+      end
+    end
+
+    def remove_item(id)
+      item = items.detect { |item| item.id.to_s == id.to_s }
+      item.nil? || item.destroy!
+    end
+
+    def mark_item_received(item)
+      existing_item = find_existing_item(sku: item.sku)
+
+      if existing_item
+        received = existing_item.received + item.quantity
+        existing_item.update(received: received)
+      end
+    end
+
+    def find_existing_item(params = {})
+      unpurchased_items.detect { |item| item.sku == params[:sku] }
+    end
+
+    def find_existing_purchased_item(params = {})
+      items.detect { |item| item.sku == params[:sku] && item.purchased_by == params[:purchased_by] }
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+module Workarea
+  class Registry
+    class Item
+      include ApplicationDocument
+
+      field :product_id, type: String
+      field :sku, type: String
+      field :quantity, type: Integer, default: 1
+      field :received, type: Integer, default: 0
+      field :purchased_by, type: String
+
+      embedded_in :registry,
+        class_name: 'Workarea::Registry',
+        touch: true
+
+      validates :product_id, presence: true
+      validates :sku, presence: true
+      validates :quantity, presence: true, numericality: { greater_than: 0 }
+
+      index(product_id: 1)
+
+      def available?
+        quantity > received
+      end
+
+      def received?
+        received.positive?
+      end
+
+      def purchased?
+        purchased_by.present?
+      end
+
+      def unpurchased?
+        !purchased? && !received?
+      end
+    end
+  end
+end