rails_trade 0.0.2 → 0.0.3

data/app/controllers/trade/admin/order_payments_controller.rb

@@ -1,55 +1,57 @@
-class Trade::Admin::OrderPaymentsController < Trade::Admin::BaseController
-  before_action :set_order
-  before_action :set_payment_order, only: [:destroy]
-  after_action only: [:create] do
-    mark_audits(instance: :@order, include: [:payment_orders])
-  end
+module Trade
+  class Admin::OrderPaymentsController < Admin::BaseController
+    before_action :set_order
+    before_action :set_payment_order, only: [:destroy]
+    after_action only: [:create] do
+      mark_audits(instance: :@order, include: [:payment_orders])
+    end
 
-  def index
-    @payment_orders = @order.payment_orders
-  end
+    def index
+      @payment_orders = @order.payment_orders
+    end
 
-  def new
-    @payment_order = PaymentOrder.new
-    @payments = @order.pending_payments
-  end
+    def new
+      @payment_order = PaymentOrder.new
+      @payments = @order.pending_payments
+    end
+
+    def create
+      @payment_order = @order.payment_orders.build(payment_order_params)
+      @order = @payment_order.order
 
-  def create
-    @payment_order = @order.payment_orders.build(payment_order_params)
-    @order = @payment_order.order
+      if @payment_order.save
+        respond_to do |format|
+          format.js
+        end
+      else
+        render 'create_fail'
+      end
+    end
 
-    if @payment_order.save
+    def destroy
+      if @payment_order.init?
+        @payment_order.destroy
+      end
       respond_to do |format|
         format.js
       end
-    else
-      render 'create_fail'
     end
-  end
 
-  def destroy
-    if @payment_order.init?
-      @payment_order.destroy
-    end
-    respond_to do |format|
-      format.js
+    private
+    def set_payment_order
+      @payment_order = PaymentOrder.find(params[:id])
     end
-  end
 
-  private
-  def set_payment_order
-    @payment_order = PaymentOrder.find(params[:id])
-  end
+    def set_order
+      @order = Order.find(params[:order_id])
+    end
 
-  def set_order
-    @order = Order.find(params[:order_id])
-  end
+    def payment_order_params
+      params.fetch(:payment_order, {}).permit(
+        :payment_id,
+        :check_amount
+      )
+    end
 
-  def payment_order_params
-    params.fetch(:payment_order, {}).permit(
-      :payment_id,
-      :check_amount
-    )
   end
-
 end

data/app/controllers/trade/admin/orders_controller.rb

@@ -1,110 +1,100 @@
-class Trade::Admin::OrdersController < Trade::Admin::BaseController
-  before_action :set_order, only: [:show, :edit, :update, :refund, :destroy]
-  skip_before_action :verify_authenticity_token, only: [:refresh]
+module Trade
+  class Admin::OrdersController < Admin::BaseController
+    before_action :set_order, only: [:show, :edit, :update, :refund, :destroy]
+    skip_before_action :verify_authenticity_token, only: [:refresh]
 
-  def index
-    q_params = {}
-    q_params.merge! default_params
-    q_params.merge! params.permit(:id, :uuid, :user_id, :buyer_type, :buyer_id, :payment_status, :payment_type)
+    def index
+      q_params = {}
+      q_params.merge! default_params
+      q_params.merge! params.permit(:id, :uuid, :user_id, :member_id, :payment_status, :payment_type)
 
-    @orders = Order.includes(:user).default_where(q_params).order(id: :desc).page(params[:page])
-  end
-
-  def payments
-    @orders = Order.default_where(params.permit(:id, :payment_status)).default_where(params.fetch(:q, {}).permit(:uuid)).page(params[:page])
-  end
-
-  def new
-    @order = Order.new(buyer_id: params[:buyer_id])
-    if params[:cart_item_id]
-      @order.migrate_from_cart_item(params[:cart_item_id])
-    else
-      @order.migrate_from_cart_items
+      @orders = Order.includes(:user).default_where(q_params).order(id: :desc).page(params[:page])
     end
 
-    respond_to do |format|
-      format.html
-      format.json { render json: @order }
+    def payments
+      q_params = {}
+      q_params.merge! params.permit(:id, :payment_status, :uuid)
+
+      @orders = Order.default_where(q_params).page(params[:page])
     end
-  end
 
-  def refresh
-    @order = Order.new(buyer_id: params[:buyer_id])
-    @order.assign_attributes order_params
+    def new
+      @order = Order.new
 
-    if params[:cart_item_id]
-      cart_item = CartItem.find(params[:cart_item_id])
-      cart_item.update extra: @order.extra
-      @order.migrate_from_cart_item(params[:cart_item_id])
-    else
-      @order.migrate_from_cart_items
+      if params[:cart_item_id]
+        @order.migrate_from_cart_item(params[:cart_item_id])
+      else
+        @order.migrate_from_cart_items
+      end
     end
 
-    respond_to do |format|
-      format.js
-      format.html
-      format.json { render json: @order }
+    def refresh
+      @order = Order.new(buyer_id: params[:buyer_id])
+      @order.assign_attributes order_params
+
+      if params[:cart_item_id]
+        cart_item = CartItem.find(params[:cart_item_id])
+        cart_item.update extra: @order.extra
+        @order.migrate_from_cart_item(params[:cart_item_id])
+      else
+        @order.migrate_from_cart_items
+      end
     end
-  end
 
-  def create
-    @order = Order.new(order_params)
+    def create
+      @order = Order.new(order_params)
 
-    respond_to do |format|
       if @order.save
-        format.html { redirect_to admin_order_url(@order) }
-        format.json { render json: @order, status: :created, location: @order }
+        render 'create'
       else
-        format.html { render action: 'new' }
-        format.json { render json: @order.errors, status: :unprocessable_entity }
+        render 'new', locals: { model: @order }, status: :unprocessable_entity
       end
     end
-  end
 
-  def show
-  end
+    def show
+    end
 
-  def update
-    if @order.update(order_params)
-      redirect_to @order
-    else
-      render :edit
+    def edit
     end
-  end
 
-  def refund
-    @order.apply_for_refund
+    def update
+      @order.assign_attributes order_params
 
-    respond_to do |format|
-      format.html { redirect_to admin_orders_url(id: @order.id) }
-      format.json { render json: @order.as_json(include: [:refunds]) }
+      if @order.save
+        render 'update'
+      else
+        render :edit, locals: { model: @order }, status: :unprocessable_entity
+      end
     end
-  end
 
-  def destroy
-    @order.destroy
-    redirect_to admin_orders_url(buyer_id: @order.buyer_id)
-  end
+    def refund
+      @order.apply_for_refund
+    end
 
-  private
-  def set_order
-    @order = Order.find(params[:id])
-  end
+    def destroy
+      @order.destroy
+    end
 
-  def order_params
-    p = params.fetch(:order, {}).permit(
-      :buyer_type,
-      :buyer_id,
-      :quantity,
-      :payment_id,
-      :payment_type,
-      :address_id,
-      :invoice_address_id,
-      :amount,
-      trade_items_attributes: [:deliver_on, :advance_price, :comment],
-      trade_promotes_attributes: [:promote_id]
-    )
-    p.merge! default_form_params
-  end
+    private
+    def set_order
+      @order = Order.find(params[:id])
+    end
 
+    def order_params
+      p = params.fetch(:order, {}).permit(
+        :buyer_type,
+        :buyer_id,
+        :quantity,
+        :payment_id,
+        :payment_type,
+        :address_id,
+        :invoice_address_id,
+        :amount,
+        trade_items_attributes: [:deliver_on, :advance_price, :comment],
+        trade_promotes_attributes: [:promote_id]
+      )
+      p.merge! default_form_params
+    end
+
+  end
 end

data/app/controllers/trade/admin/payment_methods_controller.rb

@@ -1,114 +1,101 @@
-class Trade::Admin::PaymentMethodsController < Trade::Admin::BaseController
-  before_action :set_payment_method, only: [:show, :edit, :update, :verify, :merge_from, :destroy]
+module Trade
+  class Admin::PaymentMethodsController < Admin::BaseController
+    before_action :set_payment_method, only: [:show, :edit, :update, :verify, :merge_from, :destroy]
 
-  def index
-    @payment_methods = PaymentMethod.includes(:payment_references).default_where(query_params).page(params[:page])
-  end
+    def index
+      query_params = {
+        myself: false
+      }
+      query_params.merge! params.permit(:id, :myself, :account_name, :account_num, :bank, 'buyers.name-like')
 
-  def unverified
-    @payment_methods = PaymentMethod.includes(:payment_references).unscoped.where(verified: [false, nil]).default_where(query_params).page(params[:page]).references(:payment_references)
-  end
+      @payment_methods = PaymentMethod.includes(:payment_references).default_where(query_params).page(params[:page])
+    end
 
-  def mine
-    default_params = {
-      creator_id: the_audit_user.id
-    }
-    @payment_methods = PaymentMethod.includes(:payment_references).default_where(default_params).page(params[:page])
-  end
+    def unverified
+      q_params = {}
 
-  def new
-    @payment_method = PaymentMethod.new
+      @payment_methods = PaymentMethod.includes(:payment_references).unscoped.where(verified: [false, nil]).default_where(q_params).page(params[:page]).references(:payment_references)
+    end
 
-    respond_to do |format|
-      format.html
-      format.js
+    def mine
+      default_params = {
+        creator_id: the_audit_user.id
+      }
+      @payment_methods = PaymentMethod.includes(:payment_references).default_where(default_params).page(params[:page])
+    end
+
+    def new
+      @payment_method = PaymentMethod.new
     end
-  end
 
-  def create
-    @payment_method = PaymentMethod.new(payment_method_params.merge(verified: true, creator_id: the_audit_user.id))
+    def create
+      @payment_method = PaymentMethod.new(payment_method_params.merge(verified: true, creator_id: the_audit_user.id))
 
-    respond_to do |format|
-      if @payment_method.save
-        format.html { redirect_to admin_payment_methods_url }
-        format.js
-      else
-        format.html { render :new }
-        format.js
+      unless @payment_method.save
+        render :new, locals: { model: @payment_method }, status: :unprocessable_entity
       end
     end
-  end
 
-  def show
-  end
+    def show
+    end
 
-  def edit
-    respond_to do |format|
-      format.html
-      format.js
+    def edit
     end
-  end
 
-  def update
-    if @payment_method.update(payment_method_params)
-      redirect_to admin_payment_methods_url
-    else
-      render :edit
+    def update
+      @payment_method.assign_attributes(payment_method_params)
+
+      unless @payment_method.save
+        render :edit, locals: { model: @payment_method }, status: :unprocessable_entity
+      end
     end
-  end
 
-  def verify
-    @payment_method.update(verified: true)
+    def verify
+      @payment_method.update(verified: true)
 
-    redirect_back fallback_location: unverified_admin_payment_methods_url
-  end
+      redirect_back fallback_location: unverified_admin_payment_methods_url
+    end
 
-  def merge_from
-    @payment_method.merge_from(params[:other_id])
+    def merge_from
+      @payment_method.merge_from(params[:other_id])
 
-    redirect_back fallback_location: unverified_admin_payment_methods_url
-  end
+      redirect_back fallback_location: unverified_admin_payment_methods_url
+    end
 
-  def edit_references
+    def edit_references
 
-  end
+    end
 
-  def update_references
+    def update_references
 
-  end
+    end
 
-  def destroy
-    @payment_method.destroy
-    redirect_to admin_payment_methods_url
-  end
+    def destroy
+      @payment_method.destroy
+    end
 
-  private
-  def query_params
-    query_params = { myself: false }.with_indifferent_access
-    query_params.merge! params.fetch(:q, {}).permit(:account_name, :account_num, :bank, 'buyers.name-like')
-    query_params.merge! params.permit(:id, :myself)
-  end
+    private
+    def set_payment_method
+      @payment_method = PaymentMethod.unscoped.find(params[:id])
+    end
 
-  def set_payment_method
-    @payment_method = PaymentMethod.unscoped.find(params[:id])
-  end
+    def payment_method_params
+      p = params.fetch(:payment_method, {}).permit(
+        :type,
+        :account_name,
+        :account_num,
+        :bank,
+        :verified
+      )
+      p.merge! myself: false
+    end
 
-  def payment_method_params
-    p = params.fetch(:payment_method, {}).permit(
-      :type,
-      :account_name,
-      :account_num,
-      :bank,
-      :verified
-    )
-    p.merge! myself: false
-  end
+    def payment_reference_params
+      params.fetch(:payment_reference, {}).permit(
+        :account_type,
+        :account_id
+      )
+    end
 
-  def payment_reference_params
-    params.fetch(:payment_reference, {}).permit(
-      :account_type,
-      :account_id
-    )
   end
-
 end