Einführung

Wir haben PAY.JP eingeführt, um Kreditkartenzahlungen mit einer persönlichen App durchzuführen. Es wird als Memorandum zur Funktionsimplementierung beschrieben.

Vorheriger Artikel Implementieren der Funktion zum Registrieren / Löschen von Kreditkarten in PAY.JP

Voraussetzungen

Rails 5.2.4.2
Ruby 2.5.1 --Verwenden Sie ein Gerät
Verwenden Sie haml --Verwenden Sie VS Code

Wir haben ein Kartenmodell und einen Kartencontroller erstellt, um Karteninformationen bis zum letzten Mal zu registrieren. Dieses Mal erstellen wir ein neues Kaufmodell und einen neuen Controller und führen den Kaufprozess durch.

Verfahren

Erstellen Sie ein Modell
Erstellen Sie eine Tabelle
Erstellen eines Controllers

Modell erstellen

Dieses Mal erstellen wir ein Auftragsmodell.

class Order < ApplicationRecord
  belongs_to :user
  has_many :products, through: :order_details
  has_many :order_details, dependent: :destroy
  belongs_to :card
  belongs_to :address

  enum postage: {burden: 0, free: 1}
  enum status: {bezahlt: 0,Vorbereitung für die Lieferung: 1,Geliefert: 2}

  def add_items(cart)
    cart.line_items.target.each do |item|
      item.cart_id = nil
      line_items << item
    end
  end
end

Seit ich die EC-Site erstellt habe, habe ich die Instanzmethode usw. definiert, weil sie die Warenkorbfunktion usw. implementiert, aber dieses Mal werde ich sie weglassen, weil ich mich auf die Kauffunktion konzentriere. Eine Zeile von gehört zu: Karte ist also der Teil, den Sie verwenden möchten.

Eine Tabelle erstellen

Erstellen Sie die Migrationsdatei wie folgt.


class CreateOrders < ActiveRecord::Migration[5.2]
  def change
    create_table :orders do |t|
      t.references :user, foreign_key: true
      t.references :address, foreign_key: true
      t.references :card, foreign_key: true
      t.references :product, foreign_key: true
      t.integer :quantity, null: false
      t.integer :status, default: 0, null: false
      t.integer :postage, default: 0, null: false
      t.integer :price, null: false
      t.timestamps
    end
  end
end

Die Karte wird als externer Schlüssel installiert.

Controller erstellen

Wir werden einen Auftragscontroller erstellen. Dieses Mal werden wir zwei Aktionen verwenden, neu und erstellen.


class OrdersController < ApplicationController
  before_action :set_cart
  before_action :user_signed_in
  before_action :set_user
  before_action :set_card
  before_action :set_address

  require "payjp"

  #Auftragserfassungsbildschirm
  def new
    @line_items = current_cart.line_items
    @cart = current_cart
    if @cart.line_items.empty?
      redirect_to current_cart, notice: "Einkaufswagen ist leer"
      return
    end
    if @card.present?
      customer = Payjp::Customer.retrieve(@card.customer_id)
      default_card_information = customer.cards.retrieve(@card.card_id)
      @card_info = customer.cards.retrieve(@card.card_id)
      @exp_month = default_card_information.exp_month.to_s
      @exp_year = default_card_information.exp_year.to_s.slice(2,3)
      customer_card = customer.cards.retrieve(@card.card_id)
      @card_brand = customer_card.brand
      case @card_brand
      when "Visa"
        @card_src = "icon_visa.png "
      when "JCB"
        @card_src = "icon_jcb.png "
      when "MasterCard"
        @card_src = "icon_mastercard.png "
      when "American Express"
        @card_src = "icon_amex.png "
      when "Diners Club"
        @card_src = "icon_diners.png "
      when "Discover"
        @card_src = "icon_discover.png "
      end
      @order = Order.new
    end
  end

  #Eine Bestellung registrieren
  def create
    unless user_signed_in?
      redirect_to cart_path(@current_cart), notice: "Bitte loggen Sie sich ein"
      return
    end
    @purchaseByCard = Payjp::Charge.create(
    amount: @cart.total_price,
    customer: @card.customer_id,
    currency: 'jpy',
    card: params['payjpToken']
    )
    @order = Order.new(order_params)
    @order.add_items(current_cart)
    if @purchaseByCard.save && @order.save!
      OrderDetail.create_items(@order, @cart.line_items)
      flash[:notice] = 'Die Bestellung ist abgeschlossen. Sie können den Bestellverlauf auf Meine Seite überprüfen.'
      redirect_to root_path
    else
      flash[:alert] = "Die Bestellung konnte nicht registriert werden"
      redirect_to action: :new
    end
  end

  private
  def order_params
    params.permit(:user_id, :address_id, :card_id, :quantity, :price)
  end

  def set_user
    @user = current_user
  end

  def set_cart
    @cart = current_cart
  end

  def set_card
    @card = Card.find_by(user_id: current_user.id)
  end

  def set_address
    @address = Address.find_by(user_id: current_user.id)
  end

  def user_signed_in
    unless user_signed_in?
      redirect_to cart_path(@cart.id), alert: "Sie müssen sich anmelden, um zur Kasse zu gelangen"
    end
  end
end

Die neue Aktion hat die Form einer Kaufbestätigungsseite. Wenn sich der Benutzer nicht registriert hat, kann die Kaufbestätigungsseite überhaupt nicht besucht werden. Darüber hinaus handelt es sich um eine Spezifikation, mit der der Benutzer die Karte auf "Meine Seite" registrieren kann.

Wenn Sie Ihre Karte zum ersten Mal auf der Kaufbestätigungsseite registrieren möchten, möchten Sie möglicherweise die Instanzvariable der neuen Aktion des im vorherigen Artikel erstellten Kartencontrollers aufrufen.

Die Aktion zum Erstellen erfordert Folgendes: Der Inhalt wird zur einfachen Anzeige extrahiert.


def create
  @purchaseByCard = Payjp::Charge.create(
  amount: @cart.total_price,
  customer: @card.customer_id,
  currency: 'jpy',
  card: params['payjpToken']
  )
  if @purchaseByCard.save
    flash[:notice] = 'Die Bestellung ist abgeschlossen.'
    redirect_to root_path
  else
    flash[:alert] = "Die Bestellung konnte nicht registriert werden"
    redirect_to action: :new
  end
end

Wenn der Kauf oben abgeschlossen ist, werden die Verkäufe auch in PAY.JP registriert, wie unten gezeigt. alt