rails_trade 0.0.1

data/app/controllers/the_trade_admin/payment_methods_controller.rb

@@ -0,0 +1,111 @@
+class RailsTradeAdmin::PaymentMethodsController < RailsTradeAdmin::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 unverified
+    @payment_methods = PaymentMethod.includes(:payment_references).unscoped.where(verified: [false, nil]).default_where(query_params).page(params[:page]).references(:payment_references)
+  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 new
+    @payment_method = PaymentMethod.new
+
+    respond_to do |format|
+      format.html
+      format.js
+    end
+  end
+
+  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, notice: 'Payment method was successfully created.' }
+        format.js
+      else
+        format.html { render :new }
+        format.js
+      end
+    end
+  end
+
+  def show
+  end
+
+  def edit
+    respond_to do |format|
+      format.html
+      format.js
+    end
+  end
+
+  def update
+    if @payment_method.update(payment_method_params)
+      redirect_to admin_payment_methods_url, notice: 'Payment method was successfully updated.'
+    else
+      render :edit
+    end
+  end
+
+  def verify
+    @payment_method.update(verified: true)
+
+    redirect_back fallback_location: unverified_admin_payment_methods_url
+  end
+
+  def merge_from
+    @payment_method.merge_from(params[:other_id])
+
+    redirect_back fallback_location: unverified_admin_payment_methods_url
+  end
+
+  def edit_references
+
+  end
+
+  def update_references
+
+  end
+
+  def destroy
+    @payment_method.destroy
+    redirect_to admin_payment_methods_url, notice: 'Payment method was successfully destroyed.'
+  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
+
+  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_reference_params
+    params.fetch(:payment_reference, {}).permit(:account_type, :account_id)
+  end
+
+end

data/app/controllers/the_trade_admin/payment_orders_controller.rb

@@ -0,0 +1,56 @@
+class RailsTradeAdmin::PaymentOrdersController < RailsTradeAdmin::BaseController
+  before_action :set_payment
+  before_action :set_payment_order, only: [:update, :cancel]
+  after_action only: [:create] do
+    mark_audits(Payment: [:payment_orders])
+  end
+
+  def new
+    @payment_order = PaymentOrder.new
+    @orders = @payment.pending_orders
+  end
+
+  def create
+    @payment_order = @payment.payment_orders.build(payment_order_params)
+
+    if @payment_order.confirm!
+      respond_to do |format|
+        format.js
+      end
+    else
+      render 'create_fail'
+    end
+  end
+
+  def update
+    @payment_order.assign_attributes payment_order_params
+    if @payment_order.confirm!
+      respond_to do |format|
+        format.js
+      end
+    else
+      render 'create_fail'
+    end
+  end
+
+  def cancel
+    @payment_order.revert_confirm!
+    respond_to do |format|
+      format.js
+    end
+  end
+
+  private
+  def set_payment_order
+    @payment_order = PaymentOrder.find(params[:id])
+  end
+
+  def set_payment
+    @payment = Payment.find(params[:payment_id])
+  end
+
+  def payment_order_params
+    params.fetch(:payment_order, {}).permit(:order_id, :check_amount).merge(state: 'confirmed')
+  end
+
+end

data/app/controllers/the_trade_admin/payment_references_controller.rb

@@ -0,0 +1,54 @@
+class RailsTradeAdmin::PaymentReferencesController < RailsTradeAdmin::BaseController
+  before_action :set_payment_method
+  before_action :set_payment_reference, only: [:show, :edit, :update, :destroy]
+
+  def index
+    @payment_references = PaymentReference.all
+  end
+
+  def show
+  end
+
+  def new
+    @payment_reference = @payment_method.payment_references.build
+  end
+
+  def edit
+  end
+
+  def create
+    @payment_reference = @payment_method.payment_references.build(payment_reference_params)
+
+    if @payment_reference.save
+      redirect_to admin_payment_methods_url, notice: 'Payment reference was successfully created.'
+    else
+      render :new
+    end
+  end
+
+  def update
+    if @payment_reference.update(payment_reference_params)
+      redirect_to @payment_reference, notice: 'Payment reference was successfully updated.'
+    else
+      render :edit
+    end
+  end
+
+  def destroy
+    @payment_reference.destroy
+  end
+
+  private
+  def set_payment_method
+    @payment_method = PaymentMethod.find(params[:payment_method_id])
+  end
+
+  def set_payment_reference
+    @payment_reference = PaymentReference.find(params[:id])
+  end
+
+  def payment_reference_params
+    params.fetch(:payment_reference, {}).permit(:buyer_id)
+  end
+
+end

data/app/controllers/the_trade_admin/payment_strategies_controller.rb

@@ -0,0 +1,50 @@
+class RailsTradeAdmin::PaymentStrategiesController < RailsTradeAdmin::BaseController
+  before_action :set_payment_strategy, only: [:show, :edit, :update, :destroy]
+
+  def index
+    @payment_strategies = PaymentStrategy.all
+  end
+
+  def show
+  end
+
+  def new
+    @payment_strategy = PaymentStrategy.new
+  end
+
+  def edit
+  end
+
+  def create
+    @payment_strategy = PaymentStrategy.new(payment_strategy_params)
+
+    if @payment_strategy.save
+      redirect_to admin_payment_strategies_url, notice: 'Payment strategy was successfully created.'
+    else
+      render :new
+    end
+  end
+
+  def update
+    if @payment_strategy.update(payment_strategy_params)
+      redirect_to admin_payment_strategies_url, notice: 'Payment strategy was successfully updated.'
+    else
+      render :edit
+    end
+  end
+
+  def destroy
+    @payment_strategy.destroy
+    redirect_to admin_payment_strategies_url, notice: 'Payment strategy was successfully destroyed.'
+  end
+
+  private
+  def set_payment_strategy
+    @payment_strategy = PaymentStrategy.find(params[:id])
+  end
+
+  def payment_strategy_params
+    params.fetch(:payment_strategy, {}).permit(:name, :strategy, :period)
+  end
+
+end

data/app/controllers/the_trade_admin/payments_controller.rb

@@ -0,0 +1,89 @@
+class RailsTradeAdmin::PaymentsController < RailsTradeAdmin::BaseController
+  before_action :set_payment, only: [:show, :edit, :update, :analyze, :adjust, :destroy]
+
+  def dashboard
+
+  end
+
+  def index
+    @payments = Payment.default_where(params.permit(:type, :state, :'payment_orders.state', :id))
+      .default_where(params.fetch(:q, {}).permit(:'buyer_name-like', :buyer_identifier, :buyer_bank, :payment_uuid, :'orders.uuid'))
+      .permit_with(the_role_user)
+      .order(id: :desc).page(params[:page])
+  end
+
+  def show
+  end
+
+  def new
+    @payment = Payment.new
+  end
+
+  def create
+    if params[:order_id].present?
+      @order = Order.find params[:order_id]
+      @payment = @order.payments.build(payment_params.merge(creator_id: the_role_user.id))
+    else
+      @payment = Payment.new(payment_params.merge(creator_id: the_role_user.id))
+    end
+
+    if @payment.save
+      redirect_to admin_payments_url, notice: 'Payment was successfully created.'
+    else
+      render :new
+    end
+  end
+
+  def edit
+  end
+
+  def update
+    if @payment.update(payment_params)
+      redirect_to admin_payments_url, notice: 'Payment was successfully updated.'
+    else
+      render :edit
+    end
+  end
+
+  def analyze
+    @payment.analyze_payment_method
+
+    respond_to do |format|
+      format.js
+    end
+  end
+
+  def adjust
+    @payment.analyze_adjust_amount
+    respond_to do |format|
+      format.js
+      format.html { redirect_to admin_payments_url, notice: 'Payment was successfully updated.' }
+    end
+  end
+
+  def destroy
+    @payment.destroy
+    redirect_to admin_payments_url, notice: 'Payment was successfully destroyed.'
+  end
+
+  private
+  def set_payment
+    @payment = Payment.find(params[:id])
+  end
+
+  def payment_params
+    p = params.fetch(:payment, {}).permit(:type,
+                                          :payment_uuid,
+                                          :total_amount,
+                                          :fee_amount,
+                                          :income_amount,
+                                          :notified_at,
+                                          :comment,
+                                          :buyer_name,
+                                          :buyer_identifier,
+                                          :buyer_bank
+    )
+    p.reverse_merge(type: 'BankPayment')
+  end
+
+end

data/app/controllers/the_trade_admin/produces_controller.rb

@@ -0,0 +1,66 @@
+class Admin::ProducesController < Admin::BaseController
+  before_action :set_produce, only: [:show, :edit, :update, :destroy]
+
+  def index
+    @produces = Produce.all
+  end
+
+  def show
+  end
+
+  def new
+    @produce = Produce.new
+  end
+
+  def edit
+  end
+
+  def create
+    @produce = Produce.new(produce_params)
+
+    respond_to do |format|
+      if @produce.save
+        format.html { redirect_to @produce, notice: 'Produce was successfully created.' }
+        format.json { render :show, status: :created, location: @produce }
+      else
+        format.html { render :new }
+        format.json { render json: @produce.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # PATCH/PUT /produces/1
+  # PATCH/PUT /produces/1.json
+  def update
+    respond_to do |format|
+      if @produce.update(produce_params)
+        format.html { redirect_to @produce, notice: 'Produce was successfully updated.' }
+        format.json { render :show, status: :ok, location: @produce }
+      else
+        format.html { render :edit }
+        format.json { render json: @produce.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # DELETE /produces/1
+  # DELETE /produces/1.json
+  def destroy
+    @produce.destroy
+    respond_to do |format|
+      format.html { redirect_to produces_url, notice: 'Produce was successfully destroyed.' }
+      format.json { head :no_content }
+    end
+  end
+
+  private
+    # Use callbacks to share common setup or constraints between actions.
+    def set_produce
+      @produce = Produce.find(params[:id])
+    end
+
+    # Never trust parameters from the scary internet, only allow the white list through.
+    def produce_params
+      params[:produce]
+    end
+end

data/app/controllers/the_trade_admin/promote_buyers_controller.rb

@@ -0,0 +1,39 @@
+class RailsTradeAdmin::PromoteBuyersController < RailsTradeAdmin::BaseController
+  before_action :set_promote_buyer, only: [:show, :edit, :update, :destroy]
+
+  def index
+    @promote_buyers = PromoteBuyer.includes(:buyer, :promote).default_where(params.permit(:buyer_id)).page(params[:page])
+  end
+
+  def show
+  end
+
+  def new
+    @promote_buyer = PromoteBuyer.new(buyer_id: params[:buyer_id], promote_id: params[:promote_id])
+  end
+
+  def create
+    @promote_buyer = PromoteBuyer.new(promote_buyer_params)
+
+    if @promote_buyer.save
+      redirect_to admin_promote_buyers_url(buyer_id: @promote_buyer.buyer_id), notice: 'Promote buyer was successfully created.'
+    else
+      render :new
+    end
+  end
+
+  def destroy
+    @promote_buyer.destroy
+    redirect_to admin_promote_buyers_url(buyer_id: @promote_buyer.buyer_id), notice: 'Promote buyer was successfully destroyed.'
+  end
+
+  private
+  def set_promote_buyer
+    @promote_buyer = PromoteBuyer.find(params[:id])
+  end
+
+  def promote_buyer_params
+    params.fetch(:promote_buyer, {}).permit(:buyer_id, :promote_id)
+  end
+
+end