rfcommerce_core 0.0.3

data/app/models/product_group.rb

@@ -0,0 +1,216 @@
+# *ProductGroups* are used for creating and managing sets of products.
+# Product group can be either anonymous(adhoc) or named.
+#
+# Anonymous Product groups are created by combining product scopes generated from url
+# in 2 formats:
+#
+#   /t/*taxons/s/name_of_scope/comma_separated_arguments/name_of_scope_that_doesn_take_any//order
+#   */s/name_of_scope/comma_separated_arguments/name_of_scope_that_doesn_take_any//order
+#
+# Named product groups can be created from anonymous ones, lub from another named scope
+# (using ProductGroup.from_url method).
+# Named product groups have pernament urls, that don't change even after changes
+# to scopes are made, and come in two types.
+#
+#   /t/*taxons/pg/named_product_group
+#   */pg/named_product_group
+#
+# first one is used for combining named scope with taxons, named product group can
+# have #in_taxon or #taxons_name_eq scope defined, result should combine both
+# and return products that exist in both taxons.
+#
+# ProductGroup#dynamic_products returns chain of named scopes generated from order and
+# product scopes. So you can do counting, calculations etc, on resulted set of products,
+# without retriving all records.
+#
+# ProductGroup operates on named scopes defined for product in Scopes::Product,
+# or generated automatically by meta_search
+#
+class ProductGroup < ActiveRecord::Base
+  validates :name, :presence => true # TODO ensure that this field is defined as not_null
+  validates_associated :product_scopes
+
+  before_save :set_permalink
+  after_save :update_memberships
+
+  has_and_belongs_to_many :cached_products, :class_name => "Product"
+  # name
+  has_many :product_scopes
+  accepts_nested_attributes_for :product_scopes
+
+  # Testing utility: creates new *ProductGroup* from search permalink url.
+  # Follows conventions for accessing PGs from URLs, as decoded in routes
+  def self.from_url(url)
+    pg = nil;
+    case url
+    when /\/t\/(.+?)\/s\/(.+)/  then taxons = $1; attrs = $2;
+    when /\/t\/(.+?)\/pg\/(.+)/ then taxons = $1; pg_name = $2;
+    when /(.*?)\/s\/(.+)/       then attrs = $2;
+    when /(.*?)\/pg\/(.+)/      then pg_name = $2;
+    else                        return(nil)
+    end
+
+    if pg_name && opg = ProductGroup.find_by_permalink(pg_name)
+      pg = new.from_product_group(opg)
+    elsif attrs
+      attrs = url.split("/")
+      pg = new.from_route(attrs)
+    end
+    taxon = taxons && taxons.split("/").last
+    pg.add_scope("in_taxon", taxon) if taxon
+
+    pg
+  end
+
+  def from_product_group(opg)
+    self.product_scopes = opg.product_scopes.map{|ps|
+      ps = ps.clone;
+      ps.product_group_id = nil;
+      ps.product_group = self;
+      ps
+    }
+    self
+  end
+
+  def from_route(attrs)
+    self.order_scope = attrs.pop if attrs.length % 2 == 1
+    attrs.each_slice(2) do |scope|
+      next unless Product.respond_to?(scope.first)
+      add_scope(scope.first, scope.last.split(","))
+    end
+    self
+  end
+
+  def from_search(search_hash)
+    search_hash.each_pair do |scope_name, scope_attribute|
+      add_scope(scope_name, scope_attribute)
+    end
+
+    self
+  end
+
+  def add_scope(scope_name, arguments=[])
+    if scope_name.to_s !~ /eval|send|system|[^a-z0-9_!?]/
+      self.product_scopes << ProductScope.new({
+          :name => scope_name.to_s,
+          :arguments => [*arguments]
+        })
+    else
+      raise ArgumentError.new("'#{scope_name}` can't be used as scope")
+    end
+    self
+  end
+
+  def apply_on(scopish, use_order = true)
+    # There's bug in AR, it doesn't merge :order, instead it takes order
+    # from first nested_scope so we have to apply ordering FIRST.
+    # see #2253 on rails LH
+    base_product_scope = scopish
+    if use_order && !self.order_scope.blank? && Product.respond_to?(self.order_scope.intern)
+      base_product_scope = base_product_scope.send(self.order_scope)
+    end
+
+    return self.product_scopes.reject {|s| s.is_ordering? }.inject(base_product_scope) do |result, scope|
+      scope.apply_on(result)
+    end
+
+  end
+
+  # returns chain of named scopes generated from order scope and product scopes.
+  def dynamic_products(use_order = true)
+    apply_on(Product.group_by_products_id, use_order)
+  end
+
+  # Does the final ordering if requested
+  # TODO: move the order stuff out of the above - is superfluous now
+  def products(use_order = true)
+    cached_group = Product.in_cached_group(self)
+    if cached_group.limit(1).blank?
+      dynamic_products(use_order)
+    elsif !use_order
+      cached_group
+    else
+      product_scopes.select {|s|
+        s.is_ordering?
+      }.inject(cached_group) {|res,order|
+        order.apply_on(res)
+      }
+    end
+  end
+
+  def include?(product)
+    res = apply_on(Product.id_equals(product.id), false)
+    res.count > 0
+  end
+
+  def scopes_to_hash
+    result = {}
+    self.product_scopes.each do |scope|
+      result[scope.name] = scope.arguments
+    end
+    result
+  end
+
+  # generates ProductGroup url
+  def to_url
+    if (new_record? || name.blank?)
+      result = ""
+      result+= self.product_scopes.map{|ps|
+        [ps.name, ps.arguments.join(",")]
+      }.flatten.join('/')
+      result+= self.order_scope if self.order_scope
+
+      result
+    else
+      name.to_url
+    end
+  end
+
+  def set_permalink
+    self.permalink = self.name.to_url
+  end
+
+  def update_memberships
+    # wipe everything directly to avoid expensive in-rails sorting
+    ActiveRecord::Base.connection.execute "DELETE FROM product_groups_products WHERE product_group_id = #{self.id}"
+
+    # and generate the new group entirely in SQL
+    ActiveRecord::Base.connection.execute "INSERT INTO product_groups_products #{dynamic_products(false).scoped(:select => "products.id, #{self.id}").to_sql}"
+  end
+
+  def generate_preview(size = Spree::Config[:admin_pgroup_preview_size])
+    count = self.class.count_by_sql ["SELECT COUNT(*) FROM product_groups_products WHERE product_groups_products.product_group_id = ?", self]
+
+    return count, products.limit(size)
+  end
+
+  def to_s
+    "<ProductGroup" + (id && "[#{id}]").to_s + ":'#{to_url}'>"
+  end
+  
+  def to_param
+    self.permalink
+  end
+
+  def order_scope
+    if scope = product_scopes.detect {|s| s.is_ordering?}
+      scope.name
+    end
+  end
+
+  def order_scope=(scope_name)
+    if scope = product_scopes.detect {|s| s.is_ordering?}
+      scope.update_attribute(:name, scope_name)
+    else
+      self.product_scopes.build(:name => scope_name, :arguments => [])
+    end
+  end
+
+  # Build a new product group with a scope to filter by specified products
+  def self.new_from_products(products, attrs = {})
+    pg = new(attrs)
+    pg.product_scopes.build(:name => 'with_ids', :arguments => [products.map(&:id).join(',')])
+    pg
+  end
+
+end

data/app/models/product_option_type.rb

@@ -0,0 +1,5 @@
+class ProductOptionType < ActiveRecord::Base
+  belongs_to :product
+  belongs_to :option_type
+  acts_as_list :scope => :product
+end

data/app/models/product_property.rb

@@ -0,0 +1,15 @@
+class ProductProperty < ActiveRecord::Base
+  belongs_to :product
+  belongs_to :property
+
+  validates :property, :presence => true
+
+  # virtual attributes for use with AJAX completion stuff
+  def property_name
+    property.name if property
+  end
+
+  def property_name=(name)
+    self.property = Property.find_by_name(name) unless name.blank?
+  end
+end

data/app/models/product_scope.rb

@@ -0,0 +1,78 @@
+# *ProductScope* is model for storing named scopes with their arguments,
+# to be used with ProductGroups.
+#
+# Each product Scope can be applied to Product (or product scope) with #apply_on method
+# which returns new combined named scope
+#
+class ProductScope < ActiveRecord::Base
+  # name
+  # arguments
+  belongs_to :product_group
+  serialize :arguments
+
+  validate :check_validity_of_scope
+
+  extend ::Scopes::Dynamic
+
+  # Get all products with this scope
+  def products
+    if Product.respond_to?(name)
+      Product.send(name, *arguments)
+    end
+  end
+
+  # Applies product scope on Product model or another named scope
+  def apply_on(another_scope)
+    array = *self.arguments
+    if Product.respond_to?(self.name.intern)
+      relation2 = if (array.blank? || array.size < 2)
+                      Product.send(self.name.intern, array.try(:first))
+                  else
+                      Product.send(self.name.intern, *array)
+                  end
+    else
+      relation2 = Product.metasearch({self.name.intern => array}).relation
+    end
+    unless another_scope.class == ActiveRecord::Relation
+      another_scope = another_scope.send(:relation)
+    end
+    another_scope.merge(relation2)
+  end
+
+  before_validation(:on => :create) {
+    # Add default empty arguments so scope validates and errors aren't caused when previewing it
+     if name && args = Scopes::Product.arguments_for_scope_name(name)
+      self.arguments ||= ['']*args.length
+    end
+  }
+
+  # checks validity of the named scope (if its safe and can be applied on Product)
+  def check_validity_of_scope
+    errors.add(:name, "is not a valid scope name") unless Product.respond_to?(self.name.intern)
+    apply_on(Product).limit(0) != nil
+  rescue Exception => e
+    unless Rails.env.production?
+
+      puts "name: #{self.name}"
+      puts "arguments: #{self.arguments.inspect}"
+      puts e.message
+      puts e.backtrace
+    end
+    errors.add(:arguments, "are incorrect")
+  end
+
+  # test ordering scope by looking for name pattern or missed arguments
+  def is_ordering?
+    name =~ /^(ascend_by|descend_by)/ || arguments.blank?
+  end
+
+  def to_sentence
+    result = I18n.t(:sentence, :scope => [:product_scopes, :scopes, self.name], :default => "")
+    result = I18n.t(:name, :scope => [:product_scopes, :scopes, self.name]) if result.blank?
+    result % [*self.arguments]
+  end
+
+  def to_s
+    to_sentence
+  end
+end

data/app/models/property.rb

@@ -0,0 +1,18 @@
+class Property < ActiveRecord::Base
+  has_and_belongs_to_many :prototypes
+
+  has_many :product_properties, :dependent => :destroy
+  has_many :products, :through => :product_properties
+
+  validates :name, :presentation, :presence => true
+
+  scope :sorted, lambda { order(:name) }
+
+  def self.find_all_by_prototype(prototype)
+    id = prototype
+    if prototype.class == Prototype
+      id = prototype.id
+    end
+    joins('left join properties_prototypes on property_id = properties.id').where('prototype_id = ?', id)
+  end
+end

data/app/models/prototype.rb

@@ -0,0 +1,5 @@
+class Prototype < ActiveRecord::Base
+  has_and_belongs_to_many :properties
+  has_and_belongs_to_many :option_types
+  validates :name, :presence => true
+end

data/app/models/return_authorization.rb

@@ -0,0 +1,79 @@
+class ReturnAuthorization < ActiveRecord::Base
+  belongs_to :order
+  has_many :inventory_units
+  before_create :generate_number
+  before_save :force_positive_amount
+
+  validates :order, :presence => true
+  validates :amount, :numericality => true
+  validate :must_have_shipped_units
+
+  state_machine :initial => 'authorized' do
+    after_transition :to => 'received', :do => :process_return
+
+    event :receive do
+      transition :to => 'received', :from => 'authorized', :if => :allow_receive?
+    end
+    event :cancel do
+      transition :to => 'canceled', :from => 'authorized'
+    end
+  end
+
+  def add_variant(variant_id, quantity)
+    order_units = self.order.inventory_units.group_by(&:variant_id)
+    returned_units = self.inventory_units.group_by(&:variant_id)
+
+    count = 0
+
+    if returned_units[variant_id].nil? || returned_units[variant_id].size < quantity
+      count = returned_units[variant_id].nil? ? 0 : returned_units[variant_id].size
+
+      order_units[variant_id].each do |inventory_unit|
+        next unless inventory_unit.return_authorization.nil? && count < quantity
+
+        inventory_unit.return_authorization = self
+        inventory_unit.save!
+
+        count += 1
+      end
+    elsif returned_units[variant_id].size > quantity
+      (returned_units[variant_id].size - quantity).times do |i|
+        returned_units[variant_id][i].return_authorization_id = nil
+        returned_units[variant_id][i].save!
+      end
+    end
+
+    self.order.authorize_return! if self.inventory_units.reload.size > 0 && !self.order.awaiting_return?
+  end
+
+  private
+  def must_have_shipped_units
+    errors.add(:order, I18n.t("has_no_shipped_units")) if order.nil? || !order.inventory_units.any?(&:shipped?)
+  end
+
+  def generate_number
+    return if self.number
+
+    record = true
+    while record
+      random = "RMA#{Array.new(9){rand(9)}.join}"
+      record = ReturnAuthorization.find(:first, :conditions => ["number = ?", random])
+    end
+    self.number = random
+  end
+
+  def process_return
+    inventory_units.each &:return!
+
+    credit = Adjustment.create(:source => self, :order_id => self.order.id, :amount => self.amount.abs * -1, :label => I18n.t("rma_credit"))
+    self.order.update!
+  end
+
+  def allow_receive?
+    !inventory_units.empty?
+  end
+
+  def force_positive_amount
+    self.amount = self.amount.abs
+  end
+end

data/app/models/role.rb

@@ -0,0 +1,3 @@
+class Role < ActiveRecord::Base
+  has_and_belongs_to_many :users
+end

data/app/models/shipment.rb

@@ -0,0 +1,157 @@
+require 'ostruct'
+class Shipment < ActiveRecord::Base
+  belongs_to :order
+  belongs_to :shipping_method
+  belongs_to :address
+  has_many :state_events, :as => :stateful
+  has_many :inventory_units
+  has_one :adjustment, :as => :source
+
+  before_create :generate_shipment_number
+  after_destroy :release_inventory_units
+  after_save :ensure_correct_adjustment, :update_order
+
+  attr_accessor :special_instructions
+  accepts_nested_attributes_for :address
+  accepts_nested_attributes_for :inventory_units
+
+  validates :inventory_units, :presence => true, :if => :require_inventory
+  validates :shipping_method, :presence => true
+
+  make_permalink :field => :number
+
+  scope :shipped, where(:state => 'shipped')
+  scope :ready, where(:state => 'ready')
+  scope :pending, where(:state => 'pending')
+
+  def to_param
+    self.number if self.number
+    generate_shipment_number unless self.number
+    self.number.parameterize.to_s.upcase
+  end
+
+  def shipped=(value)
+    return unless value == "1" && shipped_at.nil?
+    self.shipped_at = Time.now
+  end
+
+  # The adjustment amount associated with this shipment (if any.)  Returns only the first adjustment to match
+  # the shipment but there should never really be more than one.
+  def cost
+    adjustment ? adjustment.amount : 0
+  end
+
+  # shipment state machine (see http://github.com/pluginaweek/state_machine/tree/master for details)
+  state_machine :initial => 'pending', :use_transactions => false do
+    event :ready do
+      transition :from => 'pending', :to => 'ready'
+    end
+    event :pend do
+      transition :from => 'ready', :to => 'pending'
+    end
+    event :ship do
+      transition :from => 'ready', :to => 'shipped'
+    end
+
+    after_transition :to => 'shipped', :do => :after_ship
+  end
+
+  def editable_by?(user)
+    !shipped?
+  end
+
+  def manifest
+    inventory_units.group_by(&:variant).map do |i|
+      OpenStruct.new(:variant => i.first, :quantity => i.last.length)
+    end
+  end
+
+
+  def line_items
+    if order.complete? and Spree::Config[:track_inventory_levels]
+      order.line_items.select {|li| inventory_units.map(&:variant_id).include?(li.variant_id)}
+    else
+      order.line_items
+    end
+  end
+
+  # Updates various aspects of the Shipment while bypassing any callbacks.  Note that this method takes an explicit reference to the
+  # Order object.  This is necessary because the association actually has a stale (and unsaved) copy of the Order and so it will not
+  # yield the correct results.
+  def update!(order)
+    old_state = self.state
+    new_state = determine_state(order)
+    update_attribute_without_callbacks "state", determine_state(order)
+    after_ship if new_state == 'shipped' and old_state != 'shipped'
+  end
+
+  private
+
+  def generate_shipment_number
+    return self.number unless self.number.blank?
+    record = true
+    while record
+      random = "H" + Array.new(11){rand(9)}.join
+      record = Shipment.find(:first, :conditions => ["number = ?", random])
+    end
+    self.number = random
+  end
+
+  def description_for_shipping_charge
+    "#{I18n.t(:shipping)} (#{shipping_method.name})"
+  end
+
+  # def transition_order
+  #   update_attribute(:shipped_at, Time.now)
+  #   # transition order to shipped if all shipments have been shipped
+  #   order.ship! if order.shipments.all?(&:shipped?)
+  # end
+
+  def validate_shipping_method
+    unless shipping_method.nil?
+      errors.add :shipping_method, I18n.t("is_not_available_to_shipment_address") unless shipping_method.zone.include?(address)
+    end
+  end
+
+  def release_inventory_units
+    inventory_units.each {|unit| unit.update_attribute(:shipment_id, nil)}
+  end
+
+  # Determines the appropriate +state+ according to the following logic:
+  #
+  # pending    unless +order.payment_state+ is +paid+
+  # shipped    if already shipped (ie. does not change the state)
+  # ready      all other cases
+  def determine_state(order)
+    return "pending" if self.inventory_units.any? {|unit| unit.backordered?}
+    return "shipped" if state == "shipped"
+    order.payment_state == "balance_due" ? "pending" : "ready"
+  end
+
+  # Determines whether or not inventory units should be associated with the shipment.  This is always +false+ when
+  # +Spree::Config[:track_inventory_levels]+ is set to +false.+  Otherwise its +true+ whenever the order is completed
+  # (and not canceled.)
+  def require_inventory
+    return false unless Spree::Config[:track_inventory_levels]
+    order.completed? && !order.canceled?
+  end
+
+  def after_ship
+    inventory_units.each &:ship!
+    ShipmentMailer.shipped_email(self).deliver
+  end
+
+  def ensure_correct_adjustment
+    if adjustment
+      adjustment.originator = shipping_method
+      adjustment.save
+    else
+      shipping_method.create_adjustment(I18n.t(:shipping), order, self, true)
+      reload #ensure adjustment is present on later saves
+    end
+  end
+
+  def update_order
+    order.update!
+  end
+end