solidus_product_bundle 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9a9bb87d164bab435ae5b5dae93c8f25003fbacf
+  data.tar.gz: 364c684f10939d8d693b326ebe6f6e006b69f88e
+SHA512:
+  metadata.gz: a0dd50bd5b5ead6023050936ac7847512b8a32980d1cbc23071bdf07a7e5f266a77fabdc245956ed506c469fed3591ec9687d15f94a4d7d9de3b21eb7399c9d6
+  data.tar.gz: d7c521af96a68c35f539ea7c7fe1250ab6274929c5ec09742d5592ea40f23e4ff80c1cdb1bfe018c70286626a6496dadcfa5a42034401ff9cb2d8a74ba9005fb

data/.gitignore

@@ -0,0 +1,5 @@
+spec/dummy
+Gemfile.lock
+coverage
+.ruby-gemset
+.ruby-version

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--format
+progress

data/.travis.yml

@@ -0,0 +1,11 @@
+language: ruby
+before_script:
+  - sh -e /etc/init.d/xvfb start
+  - export DISPLAY=:99.0
+  - bundle exec rake test_app
+script:
+  - bundle exec rspec spec
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0

data/Gemfile

@@ -0,0 +1,9 @@
+source "https://rubygems.org"
+
+branch = '2-4-stable'
+gem "solidus", github: 'solidusio/solidus', branch: 'master'
+# gem 'spree_wombat', github: 'spree/spree_wombat', branch: branch
+
+gem 'pry-rails'
+
+gemspec

data/LICENSE.md

@@ -0,0 +1,13 @@
+Spree Product Assembly License
+==============================
+
+Copyright © 2007-2014, Spree Commerce Inc. and other contributors.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+* Neither the name of Spree Commerce Inc. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+_This software is provided by the copyright holders and contributors "as is" and any express or implied warranties, including, but not limited to, the implied warranties of merchantability and fitness for a particular purpose are disclaimed. In no event shall the copyright owner of contributors be liable for any direct, indirect, incidental, special, exemplary, or consequential damages (including, but not limited to, procurement of substitute goods or services; loss of use, data, or profits; or business interruption) however caused and on any theory of liability, whether in contract, strict liability, or tort (including negligence or otherwise) arising in any way out of the use of this software, even if advised of the possibility of such damage._

data/README.markdown

@@ -0,0 +1,95 @@
+# Product Assembly
+
+[![Build Status](https://secure.travis-ci.org/spree-contrib/spree-product-assembly.png)](https://travis-ci.org/spree-contrib/spree-product-assembly)
+[![Code Climate](https://codeclimate.com/github/spree-contrib/spree-product-assembly.png)](https://codeclimate.com/github/spree-contrib/spree-product-assembly)
+
+Create a product which is composed of other products.
+
+## Installation
+
+Add the following line to your `Gemfile`
+```ruby
+gem 'spree_product_assembly', github: 'spree-contrib/spree-product-assembly', branch: 'master'
+```
+
+Run bundle install as well as the extension intall command to copy and run migrations and
+append spree_product_assembly to your js manifest file
+
+    bundle install
+    rails g spree_product_assembly:install
+
+_master branch is compatible with spree edge and rails 4 only. Please use
+2-0-stable for Spree 2.0.x or 1-3-stable branch for Spree 1.3.x compatibility_
+
+_In case you're upgrading from 1-3-stable of this extension you might want to run a
+rake task which assigns a line item to your previous inventory units from bundle
+products. That is so you have a better view on the current backend UI and avoid
+exceptions. No need to run this task if you're not upgrading from product assembly
+1-3-stable_
+
+    rake spree_product_assembly:upgrade
+
+## Use
+
+To build a bundle (assembly product) you'd need to first check the "Can be part"
+flag on each product you want to be part of the bundle. Then create a product
+and add parts to it. By doing that you're making that product an assembly.
+
+The store will treat assemblies a bit different than regular products on checkout.
+Spree will create and track inventory units for its parts rather than for the product itself.
+That means you essentially have a product composed of other products. From a
+customer perspective it's like they are paying a single amount for a collection
+of products.
+
+## Using with spree_wombat
+
+If you use this with spree_wombat make sure that you add this extension after
+spree_wombat in your `Gemfile`
+
+This extension provides a specific serializer for shipments `assembly_shipment_serializer`, to use this in your Spree storefront make sure
+you configure spree_wombat like this:
+
+```ruby
+config.payload_builder = {
+  "Spree::Shipment" => {:serializer => "Spree::Wombat::AssemblyShipmentSerializer", :root => "shipments"}
+}
+```
+
+Contributing
+------------
+
+Spree is an open source project and we encourage contributions. Please see the [contributors guidelines][1] before contributing.
+
+In the spirit of [free software][2], **everyone** is encouraged to help improve this project.
+
+Here are some ways *you* can contribute:
+
+* by using prerelease versions
+* by reporting [bugs][3]
+* by suggesting new features
+* by writing translations
+* by writing or editing documentation
+* by writing specifications
+* by writing code (*no patch is too small*: fix typos, add comments, clean up inconsistent whitespace)
+* by refactoring code
+* by resolving [issues][3]
+* by reviewing patches
+
+Starting point:
+
+* Fork the repo
+* Clone your repo
+* Run `bundle install`
+* Run `bundle exec rake test_app` to create the test application in `spec/test_app`
+* Make your changes
+* Ensure specs pass by running `bundle exec rspec spec`
+* Submit your pull request
+
+Copyright (c) 2014 [Spree Commerce Inc.][4] and [contributors][5], released under the [New BSD License][6]
+
+[1]: http://guides.spreecommerce.com/developer/contributing.html
+[2]: http://www.fsf.org/licensing/essays/free-sw.html
+[3]: https://github.com/spree/spree-product-assembly/issues
+[4]: https://github.com/spree
+[5]: https://github.com/spree/spree-product-assembly/graphs/contributors
+[6]: https://github.com/spree/spree-product-assembly/blob/master/LICENSE.md

data/README.md

@@ -0,0 +1,2 @@
+# solidus_product_assembly
+Completely based on spree_product_assembly

data/Rakefile

@@ -0,0 +1,15 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+require 'spree/testing_support/common_rake'
+
+RSpec::Core::RakeTask.new
+
+task :default => [:spec]
+
+desc "Generates a dummy app for testing"
+task :test_app do
+  ENV['LIB_NAME'] = 'spree_product_assembly'
+  Rake::Task['common:test_app'].invoke
+end

data/app/assets/javascripts/spree/backend/spree_product_assembly/index.js.coffee

@@ -0,0 +1,82 @@
+#= require ./translations
+
+$(document).ready ->
+  Spree.routes.available_admin_product_parts = (productSlug) ->
+    Spree.pathFor("admin/products/" + productSlug + "/parts/available")
+
+  showErrorMessages = (xhr) ->
+    response = JSON.parse(xhr.responseText)
+    show_flash("error", response)
+
+  partsTable = $("#product_parts")
+  searchResults = $("#search_hits")
+
+  searchForParts = ->
+    productSlug = partsTable.data("product-slug")
+    searchUrl = Spree.routes.available_admin_product_parts(productSlug)
+
+    $.ajax
+     data:
+       q: $("#searchtext").val()
+     dataType: 'html'
+     success: (request) ->
+       searchResults.html(request)
+       searchResults.show()
+     type: 'POST'
+     url: searchUrl
+
+  $("#searchtext").keypress (e) ->
+    if (e.which && e.which == 13) || (e.keyCode && e.keyCode == 13)
+      searchForParts()
+      false
+    else
+      true
+
+  $("#search_parts_button").click (e) ->
+    e.preventDefault()
+    searchForParts()
+
+  makePostRequest = (link, post_params = {}) ->
+    spinner = $("img.spinner", link.parent())
+    spinner.show()
+
+    request = $.ajax
+      type: "POST"
+      url: link.attr("href")
+      data: post_params
+      dateType: "script"
+    request.fail showErrorMessages
+    request.always -> spinner.hide()
+
+    false
+
+  searchResults.on "click", "a.add_product_part_link", (event) ->
+    event.preventDefault()
+
+    part = {}
+    link = $(this)
+    row = $("#" + link.data("target"))
+    loadingIndicator = $("img.spinner", link.parent())
+    quantityField = $('input:last', row)
+
+    part.count = quantityField.val()
+
+    if row.hasClass("with-variants")
+      selectedVariantOption = $('select option:selected', row)
+      part.variant_id = selectedVariantOption.val()
+
+      if selectedVariantOption.text() == Spree.translations.user_selectable
+        part.variant_selection_deferred = "t"
+        part.variant_id = link.data("master-variant-id")
+
+    else
+      part.variant_id = $('input[name="part[id]"]', row).val()
+
+    makePostRequest(link, {assemblies_part: part})
+
+  partsTable.on "click", "a.set_count_admin_product_part_link", ->
+    params = { count: $("input", $(this).parent().parent()).val() }
+    makePostRequest($(this), params)
+
+  partsTable.on "click", "a.remove_admin_product_part_link", ->
+    makePostRequest($(this))

data/app/assets/javascripts/spree/backend/spree_product_assembly/translations.js.erb

@@ -0,0 +1,3 @@
+$(document).ready(function() {
+  Spree.translations.user_selectable = "<%= Spree.t(:user_selectable) %>";
+});

data/app/assets/javascripts/spree/frontend/spree_product_assembly.js

@@ -0,0 +1 @@
+//= require spree/frontend

data/app/assets/stylesheets/spree/backend/spree_product_assembly.css

@@ -0,0 +1,3 @@
+/*
+ *= require spree/backend
+*/

data/app/assets/stylesheets/spree/frontend/spree_product_assembly.css

@@ -0,0 +1,3 @@
+/*
+ *= require spree/frontend
+*/

data/app/controllers/spree/admin/parts_controller.rb

@@ -0,0 +1,63 @@
+class Spree::Admin::PartsController < Spree::Admin::BaseController
+  helper_method :product
+
+  def index
+    @parts = product.assemblies_parts
+  end
+
+  def remove
+    assembly_part = Spree::AssembliesPart.find(params[:id])
+    assembly_part.destroy
+    render 'spree/admin/parts/update_parts_table'
+  end
+
+  def set_count
+    save_part(existing_part_params)
+  end
+
+  def available
+    if params[:q].blank?
+      @available_products = []
+    else
+      query = "%#{params[:q]}%"
+      @available_products = Spree::Product.search_can_be_part(query)
+      @available_products.uniq!
+    end
+    respond_to do |format|
+      format.html {render :layout => false}
+      format.js {render :layout => false}
+    end
+  end
+
+  def create
+    save_part(new_part_params)
+  end
+
+  private
+
+    def save_part(part_params)
+      form = Spree::AssignPartToBundleForm.new(product, part_params)
+      if form.submit
+        render 'spree/admin/parts/update_parts_table'
+      else
+        error_message = form.errors.full_messages.to_sentence
+        render json: error_message.to_json, status: 422
+      end
+    end
+
+    def product
+      @product ||= Spree::Product.find_by(slug: params[:product_id])
+    end
+
+    def new_part_params
+      params.require(:assemblies_part).permit(
+        :count,
+        :variant_id,
+        :variant_selection_deferred
+      )
+    end
+
+    def existing_part_params
+      params.permit(:id, :count)
+    end
+end

data/app/controllers/spree/checkout_controller_decorator.rb

@@ -0,0 +1,9 @@
+module Spree
+  if defined? Spree::Frontend
+    CheckoutController.class_eval do
+      # Override because we don't want to remove unshippable items from the order
+      # A bundle itself is an unshippable item
+      def before_payment; end
+    end
+  end
+end

data/app/helpers/spree/admin/orders_helper_decorator.rb

@@ -0,0 +1,9 @@
+module Spree
+  module Admin
+    OrdersHelper.module_eval do
+      def line_item_shipment_price(line_item, quantity)
+        Spree::Money.new(line_item.price * quantity, { currency: line_item.currency })
+      end
+    end
+  end
+end

data/app/models/spree/assemblies_part.rb

@@ -0,0 +1,33 @@
+module Spree
+  class AssembliesPart < ActiveRecord::Base
+    belongs_to :assembly, class_name: "Spree::Product",
+                          foreign_key: "assembly_id",
+                          touch: true
+
+    belongs_to :part, class_name: "Spree::Variant", foreign_key: "part_id"
+
+    delegate :name, :sku, to: :part
+
+    after_create :set_master_unlimited_stock
+
+    def self.get(assembly_id, part_id)
+      find_or_initialize_by(assembly_id: assembly_id, part_id: part_id)
+    end
+
+    def options_text
+      if variant_selection_deferred?
+        Spree.t(:user_selectable)
+      else
+        part.options_text
+      end
+    end
+
+    private
+
+    def set_master_unlimited_stock
+      if part.product.variants.any?
+        part.product.master.update_attribute :track_inventory, false
+      end
+    end
+  end
+end

data/app/models/spree/assign_part_to_bundle_form.rb

@@ -0,0 +1,64 @@
+module Spree
+  class AssignPartToBundleForm
+    include ActiveModel::Validations
+
+    validates :quantity, numericality: {greater_than: 0}
+
+    attr_reader :product, :part_options
+
+    def initialize(product, part_options)
+      @product = product
+      @part_options = part_options
+    end
+
+    def submit
+      if valid?
+        assemblies_part.update_attributes(attributes)
+      end
+    end
+
+    private
+
+    def attributes
+      part_options.reject {|k, v| k.to_sym == :variant_id}
+    end
+
+    def given_id?
+      part_options[:id].present?
+    end
+
+    def product_id
+      product.id
+    end
+
+    def part_id
+      variant.id
+    end
+
+    def variant
+      Spree::Variant.find(part_options[:variant_id])
+    end
+
+    def variant_selection_deferred?
+      part_options[:variant_selection_deferred]
+    end
+
+    def quantity
+      part_options[:count].to_i
+    end
+
+    def assemblies_part
+      @assemblies_part ||= begin
+        if given_id?
+          Spree::AssembliesPart.find(part_options[:id])
+        else
+          Spree::AssembliesPart.find_or_initialize_by(
+            variant_selection_deferred: variant_selection_deferred?,
+            assembly_id: product_id,
+            part_id: part_id
+          )
+        end
+      end
+    end
+  end
+end

data/app/models/spree/inventory_unit_decorator.rb

@@ -0,0 +1,13 @@
+module Spree
+  InventoryUnit.class_eval do
+    def percentage_of_line_item
+      product = line_item.product
+      if product.assembly?
+        total_value = line_item.quantity_by_variant.map { |part, quantity| part.price * quantity }.sum
+        variant.price / total_value
+      else
+        1 / BigDecimal.new(line_item.quantity)
+      end
+    end
+  end
+end

data/app/models/spree/line_item_decorator.rb

@@ -0,0 +1,65 @@
+module Spree
+  LineItem.class_eval do
+    scope :assemblies, -> { joins(product: :parts).uniq }
+
+    has_many :part_line_items, dependent: :destroy
+
+    def any_units_shipped?
+      inventory_units.any? { |unit| unit.shipped? }
+    end
+
+    # The parts that apply to this particular LineItem. Usually `product#parts`,
+    # but provided as a hook if you want to override and customize the parts for
+    # a specific LineItem.
+    def parts
+      product.parts
+    end
+
+    # The number of the specified variant that make up this LineItem. By
+    # default, calls `product#count_of`, but provided as a hook if you want to
+    # override and customize the parts available for a specific LineItem. Note
+    # that if you only customize whether a variant is included in the LineItem,
+    # and don't customize the quantity of that part per LineItem, you shouldn't
+    # need to override this method.
+    def count_of(variant)
+      product.count_of(variant)
+    end
+
+    def quantity_by_variant
+      if product.assembly?
+        if part_line_items.any?
+          quantity_with_part_line_items(quantity)
+        else
+          quantity_without_part_line_items(quantity)
+        end
+      else
+        { variant => quantity }
+      end
+    end
+
+    private
+
+    def update_inventory
+      if (changed? || target_shipment.present?) &&
+         order.has_checkout_step?("delivery")
+        if product.assembly?
+          OrderInventoryAssembly.new(self).verify(target_shipment)
+        else
+          OrderInventory.new(order, self).verify(target_shipment)
+        end
+      end
+    end
+
+    def quantity_with_part_line_items(quantity)
+      part_line_items.each_with_object({}) do |ap, hash|
+        hash[ap.variant] = ap.quantity * quantity
+      end
+    end
+
+    def quantity_without_part_line_items(quantity)
+      product.assemblies_parts.each_with_object({}) do |ap, hash|
+        hash[ap.part] = ap.count * quantity
+      end
+    end
+  end
+end

data/app/models/spree/order_contents_decorator.rb

@@ -0,0 +1,35 @@
+module Spree
+  OrderContents.class_eval do
+    def add_to_line_item_with_parts(variant, quantity, options = {})
+      add_to_line_item_without_parts(variant, quantity, options).
+        tap do |line_item|
+        populate_part_line_items(
+          line_item,
+          variant.product.assemblies_parts,
+          options["selected_variants"]
+        )
+      end
+    end
+    alias_method_chain :add_to_line_item, :parts
+
+    private
+
+    def populate_part_line_items(line_item, parts, selected_variants)
+      parts.each do |part|
+        line_item.part_line_items.create!(
+          line_item: line_item,
+          variant_id: variant_id_for(part, selected_variants),
+          quantity: part.count
+        )
+      end
+    end
+
+    def variant_id_for(part, selected_variants)
+      if part.variant_selection_deferred?
+        selected_variants[part.id.to_s]
+      else
+        part.part.id
+      end
+    end
+  end
+end

data/app/models/spree/order_inventory_assembly.rb

@@ -0,0 +1,54 @@
+module Spree
+  # This class has basically the same functionality of Spree core OrderInventory
+  # except that it takes account of bundle parts and properly creates and
+  # removes inventory unit for each parts of a bundle
+  class OrderInventoryAssembly < OrderInventory
+    attr_reader :product
+
+    def initialize(line_item)
+      @order = line_item.order
+      @line_item = line_item
+      @product = line_item.product
+    end
+
+    def verify(shipment = nil)
+      if order.completed? || shipment.present?
+        line_item.quantity_by_variant.each do |part, total_parts|
+          existing_parts = line_item.inventory_units.where(variant: part).count
+
+          self.variant = part
+
+          verify_parts(shipment, total_parts, existing_parts)
+        end
+      end
+    end
+
+    private
+
+    def verify_parts(shipment, total_parts, existing_parts)
+      if existing_parts < total_parts
+        verifiy_add_to_shipment(shipment, total_parts, existing_parts)
+      elsif existing_parts > total_parts
+        verify_remove_from_shipment(shipment, total_parts, existing_parts)
+      end
+    end
+
+    def verifiy_add_to_shipment(shipment, total_parts, existing_parts)
+      shipment = determine_target_shipment unless shipment
+      add_to_shipment(shipment, total_parts - existing_parts)
+    end
+
+    def verify_remove_from_shipment(shipment, total_parts, existing_parts)
+      quantity = existing_parts - total_parts
+
+      if shipment.present?
+        remove_from_shipment(shipment, quantity)
+      else
+        order.shipments.each do |shpment|
+          break if quantity == 0
+          quantity -= remove_from_shipment(shpment, quantity)
+        end
+      end
+    end
+  end
+end

data/app/models/spree/part_line_item.rb

@@ -0,0 +1,6 @@
+module Spree
+  class PartLineItem < ActiveRecord::Base
+    belongs_to :line_item
+    belongs_to :variant, class_name: "Spree::Variant"
+  end
+end

data/app/models/spree/product_decorator.rb

@@ -0,0 +1,37 @@
+Spree::Product.class_eval do
+  has_and_belongs_to_many  :parts, :class_name => "Spree::Variant",
+        :join_table => "spree_assemblies_parts",
+        :foreign_key => "assembly_id", :association_foreign_key => "part_id"
+
+  has_many :assemblies_parts, :class_name => "Spree::AssembliesPart",
+    :foreign_key => "assembly_id"
+
+  scope :individual_saled, -> { where(individual_sale: true) }
+
+  scope :search_can_be_part, ->(query){ not_deleted.available.joins(:master)
+    .where(arel_table["name"].matches("%#{query}%").or(Spree::Variant.arel_table["sku"].matches("%#{query}%")))
+    .where(can_be_part: true)
+    .limit(30)
+  }
+
+  validate :assembly_cannot_be_part, :if => :assembly?
+
+  def assembly?
+    parts.present?
+  end
+
+  def count_of(variant)
+    ap = assemblies_part(variant)
+    # This checks persisted because the default count is 1
+    ap.persisted? ? ap.count : 0
+  end
+
+  def assembly_cannot_be_part
+    errors.add(:can_be_part, Spree.t(:assembly_cannot_be_part)) if can_be_part
+  end
+
+  private
+  def assemblies_part(variant)
+    Spree::AssembliesPart.get(self.id, variant.id)
+  end
+end