My-Commerce_core 1.0.0

data/app/controllers/admin/product_groups_controller.rb

@@ -0,0 +1,46 @@
+class Admin::ProductGroupsController < Admin::ResourceController
+  before_filter :patch_params, :only => [:update]
+  
+  def preview
+    @product_group = ProductGroup.new(params[:product_group])
+    @product_group.name = "for_preview"
+    respond_with(@product_group) { |format| format.html { render :partial => 'preview', :layout => false } }
+  end
+
+  protected
+
+    def find_resource
+      ProductGroup.find_by_permalink(params[:id])
+    end
+     
+    def location_after_save
+      edit_admin_product_group_path(@product_group)
+    end
+
+    def collection
+      params[:search] ||= {}
+      params[:search][:meta_sort] ||= "name.asc"
+      @search = super.metasearch(params[:search])
+      @collection = @search.paginate( :per_page => Spree::Config[:per_page],
+                                      :page     => params[:page])
+    end
+    
+  private
+
+    # Consolidate argument arrays for nested product_scope attributes
+    # Necessary for product scopes with multiple arguments
+    def patch_params
+      if params["product_group"] and params["product_group"]["product_scopes_attributes"].is_a?(Array)
+        params["product_group"]["product_scopes_attributes"] = params["product_group"]["product_scopes_attributes"].group_by {|a| a["id"]}.map do |scope_id, attrs|
+          a = { "id" => scope_id, "arguments" => attrs.map{|a| a["arguments"] }.flatten }
+          if name = attrs.first["name"]
+            a["name"] = name
+          end
+          a
+        end
+      end
+    end
+
+
+
+end

data/app/controllers/admin/product_properties_controller.rb

@@ -0,0 +1,10 @@
+class Admin::ProductPropertiesController < Admin::ResourceController
+  belongs_to :product, :find_by => :permalink
+  before_filter :find_properties
+
+  private
+
+  def find_properties
+    @properties = Property.all.map(&:name)
+  end
+end

data/app/controllers/admin/product_scopes_controller.rb

@@ -0,0 +1,35 @@
+class Admin::ProductScopesController < Admin::BaseController
+  helper 'admin/product_groups'
+
+  respond_to :html, :js
+
+  def create
+    @product_group = ProductGroup.find_by_permalink(params[:product_group_id])
+    @product_scope = @product_group.product_scopes.build(params[:product_scope])
+    if @product_scope.save
+      respond_with(@product_scope) do |format|
+        format.html { redirect_to edit_admin_product_group_path(@product_group) }
+        format.js   { render :layout => false }
+      end
+    else
+      respond_with(@product_scope)
+    end
+  end
+
+  def destroy
+    @product_scope = ProductScope.find(params[:id])
+    if @product_scope.destroy
+      @product_group = @product_scope.product_group
+      @product_group.update_memberships
+      respond_with(@product_scope) do |format|
+        format.html { redirect_to edit_admin_product_group_path(@product_group) }
+        format.js   { render :layout => false }
+      end
+    else
+      respond_with(@product_scope) do |format|
+        format.html { redirect_to edit_admin_product_group_path(@product_scope.product_group) }
+      end
+    end
+  end
+
+end

data/app/controllers/admin/products_controller.rb

@@ -0,0 +1,113 @@
+class Admin::ProductsController < Admin::ResourceController
+  before_filter :check_json_authenticity, :only => :index
+  before_filter :load_data, :except => :index
+  update.before :update_before
+
+  def index
+   respond_with(@collection) do |format|
+      format.html
+      format.json { render :json => json_data }
+    end
+  end
+
+  # override the destory method to set deleted_at value
+  # instead of actually deleting the product.
+  def destroy
+    @product = Product.find_by_permalink(params[:id])
+    @product.deleted_at = Time.now()
+
+    @product.variants.each do |v|
+      v.deleted_at = Time.now()
+      v.save
+    end
+
+    if @product.save
+      flash.notice = I18n.t("notice_messages.product_deleted")
+    else
+      flash.notice = I18n.t("notice_messages.product_not_deleted")
+    end
+
+    respond_with(@product) do |format|
+      format.html { redirect_to collection_url }
+      format.js  { render_js_for_destroy }
+    end
+  end
+
+  def clone
+    @new = @product.duplicate
+
+    if @new.save
+      flash.notice = I18n.t("notice_messages.product_cloned")
+    else
+      flash.notice = I18n.t("notice_messages.product_not_cloned")
+    end
+
+    respond_with(@new) { |format| format.html { redirect_to edit_admin_product_url(@new) } }
+  end
+
+  protected
+
+  def find_resource
+    Product.find_by_permalink(params[:id])
+  end
+
+  def location_after_save
+    edit_admin_product_url(@product)
+  end
+
+  # Allow different formats of json data to suit different ajax calls
+  def json_data
+    json_format = params[:json_format] or 'default'
+    case json_format
+    when 'basic'
+      collection.map {|p| {'id' => p.id, 'name' => p.name}}.to_json
+    else
+      collection.to_json(:include => {:variants => {:include => {:option_values => {:include => :option_type}, :images => {}}}, :images => {}, :master => {}})
+    end
+  end
+
+  def load_data
+    @tax_categories = TaxCategory.order(:name)
+    @shipping_categories = ShippingCategory.order(:name)
+  end
+
+  def collection
+    return @collection if @collection.present?
+
+    unless request.xhr?
+      params[:search] ||= {}
+      # Note: the MetaSearch scopes are on/off switches, so we need to select "not_deleted" explicitly if the switch is off
+      if params[:search][:deleted_at_is_null].nil?
+        params[:search][:deleted_at_is_null] = "1"
+      end
+
+      params[:search][:meta_sort] ||= "name.asc"
+      @search = super.metasearch(params[:search])
+
+      pagination_options = {:include   => {:variants => [:images, :option_values]},
+                            :per_page  => Spree::Config[:admin_products_per_page],
+                            :page      => params[:page]}
+
+      @collection = @search.relation.group_by_products_id.paginate(pagination_options)
+    else
+      includes = [{:variants => [:images,  {:option_values => :option_type}]}, :master, :images]
+
+      @collection = super.where(["name #{LIKE} ?", "%#{params[:q]}%"])
+      @collection = @collection.includes(includes).limit(params[:limit] || 10)
+
+      tmp = super.where(["variants.sku #{LIKE} ?", "%#{params[:q]}%"])
+      tmp = tmp.includes(:variants_including_master).limit(params[:limit] || 10)
+      @collection.concat(tmp)
+
+      @collection.uniq
+    end
+
+  end
+
+  def update_before
+    # note: we only reset the product properties if we're receiving a post from the form on that tab
+    return unless params[:clear_product_properties]
+    params[:product] ||= {}
+  end
+
+end

data/app/controllers/admin/products_controller.rb~

@@ -0,0 +1,114 @@
+class Admin::ProductsController < Admin::ResourceController
+  before_filter :check_json_authenticity, :only => :index
+  before_filter :load_data, :except => :index
+  update.before :update_before
+
+  def index
+   p "indexxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxX" 
+   respond_with(@collection) do |format|
+      format.html
+      format.json { render :json => json_data }
+    end
+  end
+
+  # override the destory method to set deleted_at value
+  # instead of actually deleting the product.
+  def destroy
+    @product = Product.find_by_permalink(params[:id])
+    @product.deleted_at = Time.now()
+
+    @product.variants.each do |v|
+      v.deleted_at = Time.now()
+      v.save
+    end
+
+    if @product.save
+      flash.notice = I18n.t("notice_messages.product_deleted")
+    else
+      flash.notice = I18n.t("notice_messages.product_not_deleted")
+    end
+
+    respond_with(@product) do |format|
+      format.html { redirect_to collection_url }
+      format.js  { render_js_for_destroy }
+    end
+  end
+
+  def clone
+    @new = @product.duplicate
+
+    if @new.save
+      flash.notice = I18n.t("notice_messages.product_cloned")
+    else
+      flash.notice = I18n.t("notice_messages.product_not_cloned")
+    end
+
+    respond_with(@new) { |format| format.html { redirect_to edit_admin_product_url(@new) } }
+  end
+
+  protected
+
+  def find_resource
+    Product.find_by_permalink(params[:id])
+  end
+
+  def location_after_save
+    edit_admin_product_url(@product)
+  end
+
+  # Allow different formats of json data to suit different ajax calls
+  def json_data
+    json_format = params[:json_format] or 'default'
+    case json_format
+    when 'basic'
+      collection.map {|p| {'id' => p.id, 'name' => p.name}}.to_json
+    else
+      collection.to_json(:include => {:variants => {:include => {:option_values => {:include => :option_type}, :images => {}}}, :images => {}, :master => {}})
+    end
+  end
+
+  def load_data
+    @tax_categories = TaxCategory.order(:name)
+    @shipping_categories = ShippingCategory.order(:name)
+  end
+
+  def collection
+    return @collection if @collection.present?
+
+    unless request.xhr?
+      params[:search] ||= {}
+      # Note: the MetaSearch scopes are on/off switches, so we need to select "not_deleted" explicitly if the switch is off
+      if params[:search][:deleted_at_is_null].nil?
+        params[:search][:deleted_at_is_null] = "1"
+      end
+
+      params[:search][:meta_sort] ||= "name.asc"
+      @search = super.metasearch(params[:search])
+
+      pagination_options = {:include   => {:variants => [:images, :option_values]},
+                            :per_page  => Spree::Config[:admin_products_per_page],
+                            :page      => params[:page]}
+
+      @collection = @search.relation.group_by_products_id.paginate(pagination_options)
+    else
+      includes = [{:variants => [:images,  {:option_values => :option_type}]}, :master, :images]
+
+      @collection = super.where(["name #{LIKE} ?", "%#{params[:q]}%"])
+      @collection = @collection.includes(includes).limit(params[:limit] || 10)
+
+      tmp = super.where(["variants.sku #{LIKE} ?", "%#{params[:q]}%"])
+      tmp = tmp.includes(:variants_including_master).limit(params[:limit] || 10)
+      @collection.concat(tmp)
+
+      @collection.uniq
+    end
+
+  end
+
+  def update_before
+    # note: we only reset the product properties if we're receiving a post from the form on that tab
+    return unless params[:clear_product_properties]
+    params[:product] ||= {}
+  end
+
+end

data/app/controllers/admin/properties_controller.rb

@@ -0,0 +1,11 @@
+class Admin::PropertiesController < Admin::ResourceController
+
+  # Looks like this action is unused
+  def filtered
+    @properties = Property.where('lower(name) LIKE ?', "%#{params[:q].mb_chars.downcase}%").order(:name)
+    respond_with(@properties) do |format| 
+      format.html { render :template => "admin/properties/filtered.html.erb", :layout => false } 
+    end
+  end
+
+end

data/app/controllers/admin/prototypes_controller.rb

@@ -0,0 +1,26 @@
+class Admin::PrototypesController < Admin::ResourceController
+  after_filter :set_habtm_associations, :only => [:create, :update]
+
+  helper 'admin/product_properties'
+
+  def available
+    @prototypes = Prototype.order('name asc')
+    respond_with(@prototypes) do |format|
+      format.html { render :layout => !request.xhr? }
+    end
+  end
+
+  def select
+    @prototype ||= Prototype.find(params[:id])
+    @prototype_properties = @prototype.properties
+
+    respond_with(@prototypes)
+  end
+
+  private
+  
+  def set_habtm_associations
+    @prototype.property_ids = params[:property][:id] if params[:property]
+    @prototype.option_type_ids = params[:option_type][:id] if params[:option_type]
+  end
+end

data/app/controllers/admin/reports_controller.rb

@@ -0,0 +1,50 @@
+class Admin::ReportsController < Admin::BaseController
+  before_filter :load_data
+  respond_to :html
+
+  AVAILABLE_REPORTS = {
+    :sales_total => {:name => I18n.t(:sales_total), :description => I18n.t(:sales_total_description)}
+  }
+
+  def index
+    @reports = AVAILABLE_REPORTS
+    respond_with(@reports)
+  end
+
+  def sales_total
+    params[:search] = {} unless params[:search]
+
+    if params[:search][:created_at_greater_than].blank?
+      params[:search][:created_at_greater_than] = Time.zone.now.beginning_of_month
+    else
+      params[:search][:created_at_greater_than] = Time.zone.parse(params[:search][:created_at_greater_than]).beginning_of_day rescue Time.zone.now.beginning_of_month
+    end
+
+    if params[:search] && !params[:search][:created_at_less_than].blank?
+      params[:search][:created_at_less_than] =
+                                      Time.zone.parse(params[:search][:created_at_less_than]).end_of_day rescue ""
+    end
+
+    if params[:search].delete(:completed_at_is_not_null) == "1"
+      params[:search][:completed_at_is_not_null] = true
+    else
+      params[:search][:completed_at_is_not_null] = false
+    end
+
+    params[:search][:meta_sort] ||= "created_at.desc"
+
+    @search = Order.metasearch(params[:search])
+    @orders = @search
+    @item_total = @search.sum(:item_total)
+    @adjustment_total = @search.sum(:adjustment_total)
+    @sales_total = @search.sum(:total)
+
+    respond_with
+  end
+
+  private
+  def load_data
+
+  end
+
+end

data/app/controllers/admin/resource_controller.rb

@@ -0,0 +1,232 @@
+require 'spree_core/action_callbacks'
+class Admin::ResourceController < Admin::BaseController
+  helper_method :new_object_url, :edit_object_url, :object_url, :collection_url
+  before_filter :load_resource
+
+  respond_to :html
+  respond_to :js, :except => [:show, :index]
+
+  def new
+    respond_with(@object) do |format|
+      format.html { render :layout => !request.xhr? }
+      format.js { render :layout => false }
+    end
+  end
+
+  def edit
+    respond_with(@object) do |format|
+      format.html { render :layout => !request.xhr? }
+      format.js { render :layout => false }
+    end
+  end
+
+  def update
+    invoke_callbacks(:update, :before)
+     if controller_name == "taxonomies"
+    @image_object=@object.image
+    @image_object.update_attributes(:attachment => params[:taxon][:attachement])
+    end
+
+    if @object.update_attributes(params[object_name])
+     invoke_callbacks(:update, :after)
+      flash[:notice] = flash_message_for(@object, :successfully_updated)
+      respond_with(@object) do |format|
+        format.html { redirect_to location_after_save }
+        format.js   { render :layout => false }
+      end
+    else
+      invoke_callbacks(:update, :fails)
+      respond_with(@object)
+    end
+  end
+
+  def create
+    invoke_callbacks(:create, :before)
+    if @object.save
+     if controller_name == "taxonomies"
+       @object.create_image(:attachment=>params[:taxon][:attachement])
+    end
+      invoke_callbacks(:create, :after)
+      flash[:notice] = flash_message_for(@object, :successfully_created)
+      respond_with(@object) do |format|
+        format.html { redirect_to location_after_save }
+        format.js   { render :layout => false }
+      end
+    else
+      invoke_callbacks(:create, :fails)
+      respond_with(@object)
+    end
+  end
+
+  def destroy
+    invoke_callbacks(:destroy, :before)
+    if @object.destroy
+      invoke_callbacks(:destroy, :after)
+      flash[:notice] = flash_message_for(@object, :successfully_removed)
+      respond_with(@object) do |format|
+        format.html { redirect_to collection_url }
+        format.js   { render :partial => "/admin/shared/destroy" }
+      end
+    else
+      invoke_callbacks(:destroy, :fails)
+      respond_with(@object) do |format|
+        format.html { redirect_to collection_url }
+      end
+    end
+  end
+
+  protected
+
+  class << self
+    attr_accessor :parent_data
+    attr_accessor :callbacks
+
+    def belongs_to(model_name, options = {})
+      @parent_data ||= {}
+      @parent_data[:model_name] = model_name
+      @parent_data[:model_class] = model_name.to_s.classify.constantize
+      @parent_data[:find_by] = options[:find_by] || :id
+    end
+
+    def create
+      @callbacks ||= {}
+      @callbacks[:create] ||= Spree::ActionCallbacks.new
+    end
+
+    def update
+      @callbacks ||= {}
+      @callbacks[:update] ||= Spree::ActionCallbacks.new
+    end
+
+    def destroy
+      @callbacks ||= {}
+      @callbacks[:destroy] ||= Spree::ActionCallbacks.new
+    end
+  end
+
+  def model_class
+    controller_name.classify.constantize
+  end
+
+  def object_name
+    controller_name.singularize
+  end
+
+  def load_resource
+    if member_action?
+      @object ||= load_resource_instance
+      instance_variable_set("@#{object_name}", @object)
+    else
+      @collection ||= collection
+      instance_variable_set("@#{controller_name}", @collection)
+    end
+  end
+
+  def load_resource_instance
+    if new_actions.include?(params[:action].to_sym)
+      build_resource
+    elsif params[:id]
+      find_resource
+    end
+  end
+
+  def parent_data
+    self.class.parent_data
+  end
+
+  def parent
+    if parent_data.present?
+      @parent ||= parent_data[:model_class].where(parent_data[:find_by] => params["#{parent_data[:model_name]}_id"]).first
+      instance_variable_set("@#{parent_data[:model_name]}", @parent)
+    else
+      nil
+    end
+  end
+
+  def find_resource
+    if parent_data.present?
+      parent.send(controller_name).find(params[:id])
+    else
+      model_class.find(params[:id])
+    end
+  end
+
+  def build_resource
+    if parent_data.present?
+      parent.send(controller_name).build(params[object_name])
+    else
+      model_class.new(params[object_name])
+    end
+  end
+
+  def collection
+    return parent.send(controller_name) if parent_data.present?
+
+    if model_class.respond_to?(:accessible_by) && !current_ability.has_block?(params[:action], model_class)
+      model_class.accessible_by(current_ability)
+    else
+      model_class.scoped
+    end
+  end
+
+  def location_after_save
+    collection_url
+  end
+
+  def invoke_callbacks(action, callback_type)
+    callbacks = self.class.callbacks || {}
+    return if callbacks[action].nil?
+    case callback_type.to_sym
+      when :before then callbacks[action].before_methods.each {|method| send method }
+      when :after  then callbacks[action].after_methods.each  {|method| send method }
+      when :fails  then callbacks[action].fails_methods.each  {|method| send method }
+    end
+  end
+
+  # URL helpers
+
+  def new_object_url(options = {})
+    if parent_data.present?
+      new_polymorphic_url([:admin, parent, model_class], options)
+    else
+      new_polymorphic_url([:admin, model_class], options)
+    end
+  end
+
+  def edit_object_url(object, options = {})
+    if parent_data.present?
+      send "edit_admin_#{parent_data[:model_name]}_#{object_name}_url", parent, object, options
+    else
+      send "edit_admin_#{object_name}_url", object, options
+    end
+  end
+
+  def object_url(object = nil, options = {})
+    target = object ? object : @object
+    if parent_data.present?
+      send "admin_#{parent_data[:model_name]}_#{object_name}_url", parent, target, options
+    else
+      send "admin_#{object_name}_url", target, options
+    end
+  end
+
+  def collection_url(options = {})
+    if parent_data.present?
+      polymorphic_url([:admin, parent, model_class], options)
+    else
+      polymorphic_url([:admin, model_class], options)
+    end
+  end
+
+  def collection_actions
+    [:index]
+  end
+
+  def member_action?
+    !collection_actions.include? params[:action].to_sym
+  end
+
+  def new_actions
+    [:new, :create]
+  end
+end

data/app/controllers/admin/return_authorizations_controller.rb

@@ -0,0 +1,17 @@
+class Admin::ReturnAuthorizationsController < Admin::ResourceController
+  belongs_to :order, :find_by => :number
+
+  update.after :associate_inventory_units
+  create.after :associate_inventory_units
+
+  def fire
+    @return_authorization.send("#{params[:e]}!")
+    flash.notice = t('return_authorization_updated')
+    respond_with(@return_authorization) { |format| format.html { redirect_to :back } }
+  end
+
+  protected
+    def associate_inventory_units
+      params[:return_quantity].each { |variant_id, qty| @return_authorization.add_variant(variant_id.to_i, qty.to_i) }
+    end
+end