forgeos_commerce 1.9.0

data/app/controllers/admin/transporter_rules_controller.rb

@@ -0,0 +1,307 @@
+class Admin::TransporterRulesController < Admin::BaseController
+
+  before_filter :new_transporter, :only => [:new, :create]
+  before_filter :get_transporter, :only => [ :show, :edit, :update, :destroy, :duplicate, :activate ]
+  before_filter :get_rules, :only => [ :show, :edit ]
+  before_filter :get_product_types, :only => [ :new, :create, :show, :edit, :duplicate ]
+  before_filter :get_geo_zones, :only => [ :new, :create, :show, :edit, :duplicate ]
+
+  def index
+    respond_to do |format|
+      format.html
+      format.json do
+        sort
+        render :layout => false
+      end
+    end
+  end
+
+  def categories
+    respond_to do |format|
+      format.json do
+        # list categories like a tree
+        render :json => GeoZone.find_all_by_parent_id(nil, :order => 'printable_name').collect{ |g| g.to_jstree(:transporter_rules)}.to_json
+      end
+    end
+  end
+
+  def show
+  end
+
+  def new
+  end
+
+  def duplicate
+    @transporter = @transporter.clone
+    render :action => 'new'
+  end
+
+  def create
+    result = true
+
+    @shipping_methods = params[:shipping_method]
+
+    @shipping_methods.each do |shipping_method|
+      new_shipping_method = defined?(@parent_id) ? TransporterRule.new : TransporterRule.new(params[:transporter_rule])
+
+      rule_condition = build_conditions(shipping_method)
+
+      new_shipping_method.conditions = "[#{rule_condition.join(', ')}]"
+      new_shipping_method.variables = shipping_method[1][:price][0]
+
+      result = new_shipping_method.save
+
+      unless defined?(@parent_id)
+        @parent_id = new_shipping_method.id
+      else
+        new_shipping_method.update_attribute(:parent_id, @parent_id)
+      end
+    end
+
+    if result
+      flash[:notice] = I18n.t('transporter.create.success').capitalize
+      render :action => :edit
+    else
+      flash[:error] = I18n.t('transporter.create.failed').capitalize
+      render :action => :new
+    end
+  end
+
+  def edit
+  end
+
+  # TODO Fix bug when deleting the two (or more) first rules, the first isn't destroy, but the second (& others) yes | Check order of index in the hash params[:shipping_method]
+  def update
+
+    result = true
+    parent_transporter_deleted = false
+    @parent_id = @transporter.id
+    @transporter.update_attributes(params[:transporter_rule])
+    # Get rules to delete
+    @transporters_to_delete = params[:shipping_methods_to_delete]
+    unless @transporters_to_delete.nil?
+      @transporters_to_delete.each do |item_id|
+          transporter = TransporterRule.find_by_id(item_id)
+
+          if transporter == @transporter
+            parent_transporter_deleted = true
+            @transporter_name = transporter.name
+            @transporter_description = transporter.description
+          else
+            parent_transporter_deleted = false
+            transporter.destroy
+          end
+      end
+    end
+
+    # Get new & existing rules, create or update
+    @shipping_methods = params[:shipping_method]
+
+    @shipping_methods.each do |shipping_method|
+
+      rule_condition = build_conditions shipping_method
+      transporter_id = shipping_method[0]
+
+      # If rule exists
+      if new_shipping_method = TransporterRule.find_by_id(transporter_id)
+        result = new_shipping_method.update_attribute(:conditions, "[#{rule_condition.join(', ')}]")
+        result = new_shipping_method.update_attribute(:variables, shipping_method[1][:price][0])
+        # Get the new parent_id & update name/description to this one
+        check_parent_transporter parent_transporter_deleted, shipping_method, new_shipping_method
+
+        result = new_shipping_method.update_attribute(:parent_id, @parent_id) if new_shipping_method.id != @parent_id
+
+      else
+
+        # If delivery type change
+        if @delivery_type != params[:delivery_type] && shipping_method == @shipping_methods.first
+          new_shipping_method = TransporterRule.find_by_id(@parent_id)
+          result = new_shipping_method.update_attribute(:conditions, "[#{rule_condition.join(', ')}]")
+          result = new_shipping_method.update_attribute(:variables, shipping_method[1][:price][0])
+          result = new_shipping_method.update_attribute(:parent_id, @parent_id)
+
+        else
+          new_shipping_method = TransporterRule.new
+
+          new_shipping_method.conditions = "[#{rule_condition.join(', ')}]"
+          new_shipping_method.variables = shipping_method[1][:price][0]
+
+          result = new_shipping_method.save
+
+          # Get the new parent_id & update name/description to this one
+          check_parent_transporter parent_transporter_deleted, shipping_method, new_shipping_method
+          result = new_shipping_method.update_attribute(:parent_id, @parent_id)
+
+        end
+      end
+    end
+
+    # Destroy the parent transporter at the end
+    @transporter.destroy if parent_transporter_deleted
+
+    if result
+      flash[:notice] = I18n.t('transporter.update.success').capitalize
+      redirect_to :action => :edit
+    else
+      flash[:error] = I18n.t('transporter.update.failed').capitalize
+      render :action => :edit
+    end
+  end
+
+  def destroy
+    if @transporter.destroy
+      flash[:notice] = I18n.t('transporter.destroy.success').capitalize
+    else
+      flash[:error] = I18n.t('transporter.destroy.failed').capitalize
+    end
+    respond_to do |wants|
+      wants.html do
+        redirect_to([forgeos_commerce, :admin, :transporters])
+      end
+      wants.js
+    end
+  end
+
+  def activate
+    render :text => @transporter.activate
+  end
+
+  private
+    def get_transporter
+      unless @transporter = TransporterRule.find_by_id(params[:id])
+        flash[:notice] = I18n.t('transporter.not_exist').capitalize
+        return redirect_to([forgeos_commerce, :admin, :transporters])
+      end
+    end
+
+    def new_transporter
+      @transporter = TransporterRule.new(params[:transporter_rule])
+    end
+
+    def get_rules
+      @rules = parse_transporters
+    end
+
+    def build_conditions shipping_method
+      rule_condition = []
+      if params[:delivery_type] == "weight"
+        rule_condition << 'Cart'
+      else
+        rule_condition << 'Product'
+      end
+      rule_condition << ':cart'
+
+      shipping_method[1][:values].each_with_index do |value, index|
+
+        case params[:delivery_type]
+          when 'weight'
+            condition = "m.#{params[:delivery_type]}"
+          when 'geo_zone'
+            condition = "m.geo_zone_id"
+          when 'product_type'
+            condition = "m.product_type_id"
+          when 'product'
+            condition = "m.id"
+        end
+
+        condition += ".#{shipping_method[1][:conds][index]}(#{value})"
+        rule_condition << condition
+      end
+      rule_condition
+    end
+
+    def parse_transporters
+
+      @delivery_type = get_delivery_type
+
+      transporters = [@transporter]
+      transporters += @transporter.children
+
+      rules = {}
+      transporters.each do |transporter|
+
+        db_condition = transporter.conditions
+        array_db_condition = db_condition.split(',')
+        conditions = []
+        conditions << array_db_condition[2]
+        conditions << array_db_condition[3] unless array_db_condition[3].nil?
+
+        transporter_rules = {}
+        conditions.each_with_index do |condition, _index|
+          hash_rule = {}
+
+          array_condition = condition.split('.')
+          operator_value = array_condition[2]
+
+          hash_rule[:value] = operator_value[/\-?\d+/]
+          hash_rule[:operator] = operator_value[0, operator_value.index('(')]
+          transporter_rules[_index] = hash_rule
+        end
+
+        rules[transporter.id] = transporter_rules
+        rules[transporter.id][:price] = transporter.variables
+
+      end
+      rules.sort
+    end
+
+    def get_product_types
+      @product_types = ProductType.all(:include => :translations , :order => 'product_type_translations.name' ).collect{|c| [c.name, c.id]}
+    end
+
+    def get_geo_zones
+      @geo_zones = GeoZone.all( :order => :printable_name ).collect{|c| [c.name, c.id]}
+    end
+
+    def get_delivery_type
+      db_delivery_type = @transporter.conditions.split('.')[1]
+
+      case db_delivery_type
+        when 'weight'
+          @delivery_type = db_delivery_type
+        when 'geo_zone_id'
+          @delivery_type = 'geo_zone'
+        when 'product_type_id'
+          @delivery_type = 'product_type'
+        when 'id'
+          @delivery_type = 'product'
+      end
+
+      @delivery_type
+    end
+
+    def check_parent_transporter(parent_transporter_deleted, shipping_method, new_shipping_method)
+
+      if parent_transporter_deleted && shipping_method == @shipping_methods.first
+        @parent_id = new_shipping_method.id
+        new_shipping_method.update_attributes(:name, @transporter_name, :description => @transporter_description,:parent_id => nil)
+      end
+
+    end
+
+    def sort
+      columns = %w(id name active)
+
+      per_page = params[:iDisplayLength].to_i
+      offset =  params[:iDisplayStart].to_i
+      page = (offset / per_page) + 1
+      order = "rules.#{columns[params[:iSortCol_0].to_i]} #{params[:sSortDir_0].upcase}"
+
+      options = {
+        :include => :geo_zones ,
+        :conditions => { :parent_id => nil },
+        :order => order,
+        :page => page,
+        :per_page => per_page
+      }
+
+      options[:conditions] = ['geo_zones_transporter_rules.geo_zone_id = ?', params[:category_id]] if params[:category_id]
+
+      if params[:sSearch] && !params[:sSearch].blank?
+        options[:star] = true
+        @transporters = TransporterRule.search(params[:sSearch],options)
+      else
+        @transporters = TransporterRule.paginate(options)
+      end
+    end
+end

data/app/controllers/admin/users_controller.rb

@@ -0,0 +1,100 @@
+class Admin::UsersController < Admin::BaseController
+  def edit
+    respond_to do |format|
+      format.html
+      format.json do
+        sort_orders
+        render :layout => false
+      end
+    end
+  end
+
+private
+
+  def new_user
+    @user = User.new(params[:user])
+    @user.address_deliveries.build if @user.address_deliveries.empty?
+    @user.address_invoices.build if @user.address_invoices.empty?
+  end
+
+  def sort
+    columns = %w(lastname lastname email count(orders.id) '' max(orders.created_at) created_at activated_at)
+
+    per_page = params[:iDisplayLength] ? params[:iDisplayLength].to_i : 10
+    offset = params[:iDisplayStart] ? params[:iDisplayStart].to_i : 0
+    page = (offset / per_page) + 1
+    order_column = params[:iSortCol_0].to_i
+    order = "#{columns[order_column]} #{params[:sSortDir_0] ? params[:sSortDir_0].upcase : 'ASC'}"
+
+    conditions = {}
+    includes = []
+    group_by = []
+    options = { :order => order, :page => page, :per_page => per_page }
+
+    if params[:category_id]
+      conditions[:categories_elements] = { :category_id => params[:category_id] }
+      includes << :categories
+    end
+
+    case order_column
+    when 3, 5
+      group_by << 'people.id'
+      includes << :orders
+    end
+
+    options[:group] = group_by.join(', ') unless group_by.empty?
+    options[:conditions] = conditions unless conditions.empty?
+    options[:include] = includes unless includes.empty?
+
+    if params[:sSearch] && !params[:sSearch].blank?
+      options[:star] = true
+      @users = User.search(params[:sSearch],options)
+    else
+      @users = User.paginate(options)
+    end
+  end
+
+  def sort_orders
+    columns = %w(id id sum(order_details.price) count(order_details.id) created_at people.lastname status)
+
+    per_page = params[:iDisplayLength] ? params[:iDisplayLength].to_i : 10
+    offset = params[:iDisplayStart] ? params[:iDisplayStart].to_i : 0
+    page = (offset / per_page) + 1
+
+    conditions = {}
+    options = { :page => page, :per_page => per_page }
+
+    case params[:filter]
+    when 'status'
+      conditions[:status] = params[:status]
+    when 'user'
+      conditions[:user_id] = params[:user_id]
+    end
+
+    order_column = params[:iSortCol_0].to_i
+    includes = []
+    group_by = []
+
+    case order_column
+    when 2, 3
+      group_by << 'orders.id'
+      includes << :order_details
+    when 5
+      includes << :user
+    end
+
+    order = "#{columns[order_column]} #{params[:sSortDir_0] ? params[:sSortDir_0].upcase : 'ASC'}"
+
+    options[:group] = group_by.join(', ') unless group_by.empty?
+    options[:conditions] = conditions unless conditions.empty?
+    options[:include] = includes unless includes.empty?
+    options[:order] = order unless order.squeeze.blank?
+
+    if params[:sSearch] && !params[:sSearch].blank?
+      options[:star] = true
+      @orders = Order.search(params[:sSearch],options)
+    else
+      @orders = Order.paginate(options)
+    end
+  end
+end

data/app/controllers/admin/vouchers_controller.rb

@@ -0,0 +1,207 @@
+class Admin::VouchersController < Admin::BaseController
+  before_filter :get_voucher, :only => [:activate,:destroy]
+
+  def activate
+    render :text => @voucher.activate
+  end
+
+  def index
+    respond_to do |format|
+      format.html
+      format.json do
+        sort
+        render :layout => false
+      end
+    end
+  end
+
+  def new
+    @default_attributes = %w(price name description weight sku stock product_type_id brand_id).collect do |n|
+      [t(n, :count => 1), n]
+    end
+
+    @attributes = Attribute.all(:select => 'id, access_method').collect do |a|
+      [a.name, a.access_method]
+    end
+
+    @cart_attributes = [
+      [t(:quantity,:scope=>[:special_offer,:cart]),'Total items quantity'],
+      [t(:weight,:scope=>[:special_offer,:cart]), 'Total weight'],
+      [t(:price,:scope=>[:special_offer,:cart]),'Total amount'],
+      [t(:shipping,:scope=>[:special_offer,:cart]),'Shipping method']
+    ]
+
+    @disable_attributes = t(:disabled,:scope=>[:special_offer,:attributes])
+
+    @for = [
+      [t(:product_in_cart,:scope=>[:special_offer,:_for]), 'Product'],
+      [t(:cart,:scope=>[:special_offer,:_for]), 'Cart']
+    ]
+
+    @conditions = [
+      [t(:is,:scope=>[:special_offer,:conditions]), "=="],
+      [t(:is_not,:scope=>[:special_offer,:conditions]),"not=="],
+      [t(:equal_or_greater_than,:scope=>[:special_offer,:conditions]),">="],
+      [t(:equal_or_less_than,:scope=>[:special_offer,:conditions]),"<="],
+      [t(:greater_than,:scope=>[:special_offer,:conditions]), ">"],
+      [t(:less_than,:scope=>[:special_offer,:conditions]),"<"]
+    ]
+
+    @end = [
+      [t(:date,:scope=>[:special_offer,:end]),'Date'],
+      [t(:total_use,:scope=>[:special_offer,:end]),'Total number of offer use'],
+      [t(:user_total_use,:scope=>[:special_offer,:end]),'Customer number of offer use']
+    ]
+
+    @discount_type = [
+      [t(:percent,:scope=>[:special_offer,:action]),0],
+      [t(:fixed,:scope=>[:special_offer,:action]),1]
+    ]
+
+    @product_attributes = [t(:main,:scope=>[:special_offer,:attributes,:disabled])]+
+      @default_attributes+
+      [t(:attribute,:scope=>[:special_offer,:attributes,:disabled])]+
+      @attributes
+    @products = Product.actives(:select => 'products.id, sku', :order => 'sku')
+  end
+
+  def create
+    return flash[:error] = 'Fields' unless params[:rule_builder]
+
+    @main_attributes = %w(price name description weight sku stock product_type_id brand_id)
+
+    conditions = []
+    params[:rule][:targets].each_with_index do |rule_target, index|
+      conditions << generate_condition(rule_target, index)
+    end
+
+    matchers = if params[:rule_builder]['for'] == 'Cart'
+      ['Cart',':cart']
+    else
+      [':is_a?', 'Product',':product']
+    end
+
+    generate_rule(matchers, conditions, generate_variables, (params[:rule_builder][:if] == 'Any'))
+
+    redirect_to :action => 'index'
+  end
+
+  def destroy
+    if @voucher.destroy
+      flash[:notice] = "Voucher destroy"
+    else
+      flash[:error] = "Voucher not destroy"
+    end
+    respond_to do |wants|
+      wants.html do
+        redirect_to([forgeos_commerce, :admin, :vouchers])
+      end
+      wants.js
+    end
+  end
+
+private
+
+  def get_voucher
+    unless @voucher = VoucherRule.find_by_id(params[:id])
+      flash[:error] = t('voucher.found.failed')
+      return redirect_to([forgeos_commerce, :admin, :vouchers])
+    end
+  end
+
+  def generate_variables
+    # Build Action variables
+    variables = {}
+    params[:act][:targets].each_with_index do |action, index|
+      case "#{action}"
+      when '0'
+        variables[:discount] = params[:act][:values][index].to_i
+        variables[:fixed_discount] = (params[:act][:conds][index] != '0')
+      when '1'
+        variables[:product_ids] ||= []
+        variables[:product_ids] << params[:act][:values][index].to_i
+      when '2'
+        variables[:shipping] = true
+      when '3'
+        variables[:cart_discount] = params[:act][:values][index]
+        variables[:fixed_discount] = (params[:act][:conds][index] != '0')
+      end
+    end
+    return variables
+  end
+
+  def generate_rule(matchers,conditions,variables, or_rule = false)
+    rule = VoucherRule.new
+    rule.name = params[:rule_builder][:name]
+    rule.code = params[:voucher_code]
+    rule.description = params[:rule_builder][:description]
+    rule.active = params[:rule_builder][:active]
+    rule.conditions = if or_rule
+      "OR(#{conditions.map{ |condition| "[#{(matchers + [condition]).join(', ')}]" }.join(', ')})"
+    else
+      "[#{(matchers + conditions).join(', ')}]"
+    end
+    rule.variables = variables
+    rule.save
+    return rule
+  end
+
+  def generate_condition(rule_target, index)
+    rule_target = rule_target.parameterize('_').to_s
+    target = case rule_target
+    when 'total_items_quantity'
+      'total_items'
+    when 'total_weight'
+      'weight'
+    when 'total_amount'
+      'total'
+    when 'shipping_method'
+      'transporter_id'
+    else
+      rule_target
+    end
+
+    value = params[:rule][:values][index]
+
+    # if String type then add ''
+    value_column = Product.columns_hash[target] ||
+      Product::Translation.columns_hash[target]
+    if (value_column and [:string, :text].include?(value_column.type)) or
+      custom_attribute = Attribute.find_by_access_method(target)
+      value = "'#{value}'"
+      target = "#{target}_value" if custom_attribute
+    end
+
+    return "m.#{target}.#{params[:rule][:conds][index]}(#{value})"
+  end
+
+  def sort
+    columns = %w(rules.name rules.name active code rules.use)
+
+    per_page = params[:iDisplayLength].to_i
+    offset =  params[:iDisplayStart].to_i
+    page = (offset / per_page) + 1
+    order = "#{columns[params[:iSortCol_0].to_i]} #{params[:sSortDir_0].upcase}"
+
+    conditions = { :parent_id => nil }
+    options = { :page => page, :per_page => per_page }
+
+    includes = []
+    if params[:category_id]
+      conditions[:categories_elements] = { :category_id => params[:category_id] }
+      includes << :categories
+    end
+
+    options[:conditions] = conditions unless conditions.empty?
+    options[:include] = includes unless includes.empty?
+    options[:order] = order unless order.squeeze.blank?
+
+    if params[:sSearch] && !params[:sSearch].blank?
+      options[:star] = true
+      @vouchers = VoucherRule.search(params[:sSearch],options)
+    else
+      @vouchers = VoucherRule.paginate(options)
+    end
+  end
+
+end