home

หน้าแรก
 Computer >> คอมพิวเตอร์ >  >> การเขียนโปรแกรม >> Ruby

วิธีการขายการซื้อแบบครั้งเดียวใน Rails ด้วย Stripe

บริษัทหลายล้านแห่งใช้ Stripe ให้บริการโครงสร้างพื้นฐานการชำระเงินสำหรับแอปพลิเคชันเพื่อจัดการการสมัครรับข้อมูลและการซื้อแบบครั้งเดียว Stripe Checkout ช่วยให้เรารับชำระเงินด้วยบัตรได้อย่างง่ายดายผ่านหน้าการชำระเงินที่โฮสต์ ซึ่งสร้างขึ้นเพื่อเพิ่มการแปลง การรวมสิ่งนี้เข้ากับเว็บฮุคช่วยให้นักพัฒนาสามารถขายผลิตภัณฑ์และการสมัครรับข้อมูล แล้วส่งมอบแบบดิจิทัล

แม้ว่าในทางเทคนิคจะเป็นไปได้ที่จะจัดการการชำระเงินด้วยตนเองโดยใช้ผู้ให้บริการที่มีอยู่ แต่ Stripe ให้ประโยชน์มากมาย สำหรับการเริ่มต้น มันเร็วกว่า Stripe มีพนักงานมากกว่า 4,000 คนที่ทำงานเกี่ยวกับการชำระเงินที่ง่าย ปลอดภัย และสะดวกที่สุด

นอกจากนี้ การชำระเงินของคุณ 'ขับเคลื่อนโดย Stripe' เป็นวิธีที่ง่ายในการสร้างความไว้วางใจจากลูกค้าและเพิ่มการแปลง ลูกค้ามักลังเลที่จะให้ข้อมูลบัตรหรือข้อมูลธนาคารแก่ทุกเว็บไซต์ที่เยี่ยมชม และถูกต้องตามนั้น

Stripe ไม่ใช่ผู้ให้บริการรายเดียวในพื้นที่ชำระเงินออนไลน์ Paddle เป็นอีกหนึ่งผู้เล่นรายใหญ่ในพื้นที่การชำระเงินออนไลน์ Paddle มีคุณสมบัติมากมายที่คล้ายกับ Stripe แต่สำหรับค่าธรรมเนียมที่สูงขึ้นเล็กน้อยและประสบการณ์ของนักพัฒนาซอฟต์แวร์ที่แย่ลงกว่าเดิมเล็กน้อย ในขณะที่คู่แข่งรายอื่นๆ หลายรายเป็นทางเลือกแทน Stripe แต่ความนิยมที่แท้จริงของผลิตภัณฑ์สำหรับการชำระเงินออนไลน์ทำให้พวกเขาเป็นตัวเลือกที่ง่าย

เป็นเรื่องปกติที่บริษัท SaaS จะจัดการกับการสมัครรับข้อมูลแบบประจำ แต่ผลิตภัณฑ์จำนวนมากจะได้รับประโยชน์จากการขายผลิตภัณฑ์ดิจิทัลแบบครั้งเดียว โครงสร้างพื้นฐานของ Stripe นั้นง่ายพอๆ กัน แต่เอกสารประกอบดูเหมือนจะไม่อยู่ในหัวข้อ

ตั้งค่า

เพื่ออธิบายขั้นตอน เราจะสร้างแอปพลิเคชันที่อนุญาตให้ผู้ใช้จ่ายเงินเพื่อโพสต์โฆษณาบนกระดานแบบ Craigslist สำหรับตัวอย่างเฉพาะของเรา แอปพลิเคชันของเราจะเป็นเว็บไซต์สำหรับผู้ที่กำลังมองหาเพื่อนร่วมห้อง ผู้ใช้สามารถเรียกดูกระดานได้ฟรีแต่ต้องเสียค่าธรรมเนียมในการลงโฆษณาของตนเอง

สร้างบัญชี Stripe

ในการเริ่มต้น คุณจะต้องไปที่เว็บไซต์ของ Stripe เพื่อสร้างบัญชี ลงทะเบียนด้วยข้อมูลของคุณหรือข้อมูลธุรกิจของคุณ ถ้ามี

วิธีการขายการซื้อแบบครั้งเดียวใน Rails ด้วย Stripe ภาพหน้าจอของหน้าลงชื่อสมัครใช้ Stripe

บทความนี้จะไม่อธิบายรายละเอียดที่แน่นอนของการสร้างบัญชี แต่เอกสารประกอบจะตอบคำถามที่คุณสงสัยได้ เรามีความสนใจเป็นพิเศษในการชำระเงินและการจ่ายเงิน ผลิตภัณฑ์หรือโดยเฉพาะอย่างยิ่ง Stripe Checkout .

สร้างแอป Rails พื้นฐาน

เมื่อตั้งค่าบัญชี Stripe ของคุณแล้ว ก็ถึงเวลาสร้างแอป Rails พื้นฐานที่เราจะใช้สำหรับการผสานรวม หากคุณกำลังรวมแอปที่มีอยู่หรือสนใจแค่ส่วน Stripe ของบทช่วยสอน ให้ข้ามไปที่ "Basic Stripe Integration"

ฉันจะใช้เวอร์ชันต่อไปนี้สำหรับตัวอย่างนี้:

  • ราง 6.1
  • ทับทิม 3.0.0

สมมติว่าคุณติดตั้งทั้ง Ruby และ Rails แล้ว ให้ดำเนินการต่อไปนี้:

rails new roommate-board

ชื่อที่ฉันเลือกสำหรับแอปคือ roommate-board แต่คุณสามารถเลือกอย่างอื่นได้ เพียงสลับชื่อที่อื่นที่คุณเห็นในโค้ดตัวอย่าง

เปลี่ยนเป็นไดเร็กทอรีที่เพิ่งสร้างด้วยสิ่งต่อไปนี้:

cd roommate-board

จากนั้นเรียกใช้แอปด้วยสิ่งต่อไปนี้:

rails s

หากคุณเห็นหน้าต้อนรับทั่วไปของ Rails เมื่อคุณไปที่ localhost:3000 ยินดีด้วย เราพร้อมที่จะเขียนโค้ดแล้ว!

อันดับแรก เราจะเพิ่ม Devise เพื่อจัดการการพิสูจน์ตัวตนผู้ใช้สำหรับเรา เพียงเพิ่ม gem 'devise' ไปยัง Gemfile ของคุณแล้วเรียกใช้สิ่งต่อไปนี้:

bundle install

ถัดไป ใช้ตัวสร้าง Devise เพื่อตั้งค่าโดยเรียกใช้สิ่งต่อไปนี้:

rails generate devise:install

ถัดไป เชื่อมต่อ Devise กับ User model โดยเรียกใช้สิ่งต่อไปนี้:

rails generate devise User

และสุดท้าย เรียกใช้การย้ายข้อมูลดังต่อไปนี้:

rails db:migrate

สร้างบอร์ดเพื่อนร่วมห้อง

หากคุณกำลังอ่านข้อความนี้ คุณอาจสนใจการรวม Stripe มากกว่าการออกแบบส่วนหน้า ดังนั้นเราจึงไม่ต้องกังวลกับการจัดสไตล์ตัวอย่างของเรา

ขั้นตอนต่อไปของเราคือ สร้างแบบจำลองสำหรับการโพสต์ ! เราจะใช้เครื่องมือสร้างที่มีประโยชน์ของ Rails เพื่อสร้างแบบจำลอง การโยกย้าย ตัวควบคุม และเส้นทาง เพียงเรียกใช้สิ่งต่อไปนี้:

rails generate scaffold Post address:string rent:integer content:text

โมเดลนี้ไม่มีทุกสิ่งที่จำเป็นในการรวม Stripe เราจะเพิ่มในภายหลังในกรณีที่คุณกำลังอ้างอิงบทช่วยสอนนี้สำหรับโครงการที่คุณไม่มีความหรูหราในการเริ่มต้นจากศูนย์ เรียกใช้การย้ายข้อมูลเพื่อสร้างตารางฐานข้อมูลดังต่อไปนี้:

rails db:migrate

ต่อไป เราจะสร้างมุมมองดัชนีสำหรับโพสต์ที่รูทของแอปพลิเคชันของเรา เพื่อความสะดวก. ใน config/routes.rb , เพิ่มบรรทัดต่อไปนี้:

root 'posts#index'

ขณะนี้ว่างมาก และไม่มีวิธีที่ชัดเจนในการลงชื่อเข้าใช้ ออกจากระบบ หรือลงชื่อสมัครใช้ ฟังก์ชันมีอยู่แล้ว ดังนั้นให้เพิ่มลิงก์ในส่วนหัวเพื่อให้ผู้ใช้เข้าใจได้ชัดเจน ใน app/views/layouts/application.html.erb เราจะเพิ่มลิงก์ที่จำเป็น ไฟล์ของฉันมีลักษณะเช่นนี้หลังจากทำการเปลี่ยนแปลง:

<!DOCTYPE html>
<html>
  <head>
    <title>RoommateBoard</title>
    <meta name="viewport" content="width=device-width,initial-scale=1">
    <%= csrf_meta_tags %>
    <%= csp_meta_tag %>

    <%= stylesheet_link_tag 'application', media: 'all', 'data-turbolinks-track': 'reload' %>
    <%= javascript_pack_tag 'application', 'data-turbolinks-track': 'reload' %>
  </head>

  <body>
    <header>
      <nav>
        <a href="/#" class="block">
          <h1>Roommate Board</h1>
        </a>
        <% if user_signed_in? %>
          <%= link_to "Manage Posts", manage_posts_url %>
          <%= link_to "Sign Out", destroy_user_session_url, :method => 'delete' %>
        <% else %>
          <%= link_to "New Post", new_user_registration_url %>
        <% end %>
      </nav>
    </header>
    <%= yield %>
  </body>
</html>

นี่เป็นลิงก์ไปยังหน้าแรก และเมื่อผู้ใช้คลิก "โพสต์ใหม่" พวกเขาจะถูกนำไปที่หน้าลงทะเบียน หากลงชื่อเข้าใช้แล้ว จะเปลี่ยนเป็นปุ่ม "จัดการโพสต์" และปุ่ม "ออกจากระบบ" โดยไม่ต้องใส่สไตล์และไม่ได้ลงชื่อเข้าใช้ ตอนนี้หน้ารากจะมีลักษณะดังนี้:

วิธีการขายการซื้อแบบครั้งเดียวใน Rails ด้วย Stripe ภาพหน้าจอของหน้าดัชนีโพสต์พื้นฐาน

ต่อไป เราต้องการกำหนดขอบเขตการโพสต์แต่ละรายการให้กับผู้ใช้ที่ไม่ซ้ำ . โดยพื้นฐานแล้ว เราจะสร้างความสัมพันธ์ของ trust_to ระหว่างการโพสต์และผู้ใช้ พร้อมด้วยตรรกะที่เกี่ยวข้อง เราจะเริ่มด้วยเครื่องมือสร้างการโยกย้ายที่สะดวกของ Rails เพียงเรียกใช้สิ่งต่อไปนี้:

rails g migration AddUserIdToPosts

ตอนนี้แก้ไขไฟล์การโยกย้ายใน db/migrate/ มีลักษณะดังนี้:

class AddUserIdToPosts < ActiveRecord::Migration[6.1]
  def change
    add_column :posts, :user_id, :integer
  end
end

สุดท้าย ให้เรียกใช้การย้ายข้อมูลดังต่อไปนี้:

rails db migrate

ต่อไป เราจะเพิ่มการเชื่อมโยงให้กับโมเดลด้วยตัวมันเอง . ใน app/models/post.rb , เพิ่มบรรทัดต่อไปนี้:

belongs_to :user

และใน app/models/user.rb , เพิ่มสิ่งต่อไปนี้:

has_many :posts

การเชื่อมโยงแบบสองทิศทางนี้ช่วยให้เรามีวิธี Rails ที่มีประโยชน์ เช่นวิธีที่เรากำลังจะใช้ในการสร้างและวิธีการใหม่ ไปที่ app/controllers/posts_controller.rb (ตัวควบคุมการโพสต์) และดูที่ ใหม่ กระบวนการ. แทนที่จะเป็น @post = Post.new , ใช้ @post = current_user.posts.build .

ใน สร้าง วิธีการ เราจะทำสิ่งที่คล้ายกัน แทนที่ @post = Post.new(post_params) ด้วย @post = current_user.posts.build(post_params) . วิธีการใหม่และการสร้างสรรค์ร่วมกันควรมีลักษณะดังนี้:

# GET /posts/new
def new
  @post = current_user.posts.build
end

  # POST /posts or /posts.json
def create
  @post = current_user.posts.build(post_params)

  respond_to do |format|
    if @post.save
      format.html { redirect_to @post, notice: "Post was successfully created." }
      format.json { render :show, status: :created, location: @post }
    else
      format.html { render :new, status: :unprocessable_entity }
      format.json { render json: @post.errors, status: :unprocessable_entity }
    end
  end
end

สิ่งนี้ทำให้มั่นใจได้ว่าแอตทริบิวต์ id ของผู้ใช้จะถูกเก็บไว้ในทุกโพสต์ แต่ไม่ได้หยุดผู้ใช้รายอื่นจากการแก้ไขหรือลบโพสต์ที่ไม่ใช่ของพวกเขา! ใน PostsController เดียวกัน เรามาเขียนวิธีการที่ทำให้เรามีตัวบ่งชี้บูลีนว่าผู้ใช้เป็นเจ้าของการโพสต์หรือไม่ เพิ่มสิ่งนี้ที่ด้านล่างของคอนโทรลเลอร์:

def user_owns_post?
  @post.user == current_user
end

ใน แก้ไข วิธีเพิ่มสิ่งต่อไปนี้ (มันจะเป็นรหัสเดียวในนั้น):

unless user_owns_post?
  # Redirect them to an error page
  redirect_to posts_path, flash: { error: "You are not the owner of that post!" }
end

ใน ทำลาย วิธีเพิ่มสิ่งนี้ที่จุดเริ่มต้น:

unless user_owns_post?
  # Redirect them to an error page
  redirect_to posts_path, flash: { error: "You are not the owner of that post!" }
end

ต่อไป เราจำเป็นต้องมีฟังก์ชันบางอย่างสำหรับผู้ใช้เพื่อจัดการโพสต์ที่มีอยู่ . เป้าหมายสุดท้ายคือให้ผู้ใช้สร้างโพสต์และให้โพสต์อยู่ในสถานะร่างก่อนชำระเงิน เมื่อพวกเขาชำระเงิน จะถูกตั้งค่าให้เปิดใช้งานสำหรับพวกเขา! ใน PostsController ให้เพิ่มวิธีการใหม่:

def manage
  @posts = current_user.posts
end

ถัดไป เพิ่มเส้นทางเพื่อให้ผู้ใช้ไปถึงที่นั่น! ใน config/routes.rb , เพิ่มสิ่งต่อไปนี้:

get "/manage_posts/" =>'posts#manage'

สุดท้าย เราจะสร้างมุมมองสำหรับการจัดการโพสต์! เพิ่มไฟล์ใหม่ app/views/posts/manage.html.erb . จากนั้นคัดลอกเนื้อหาทั้งหมดของ app/views/posts/index.html.erb เข้าไปในนั้น เพียงเปลี่ยนส่วนหัวจาก "โพสต์" เป็น "จัดการโพสต์" นี่เป็นหน้าดัชนีโดยพื้นฐานแล้ว แต่ด้วยการโพสต์ของผู้ใช้แต่ละรายเป็นโพสต์เดียวที่จัดทำดัชนีด้วยตรรกะของตัวควบคุมของเรา ในทางเทคนิค เราสามารถทำได้ในหน้าดัชนีแต่ละหน้า แต่การแยกนี้ทำให้เพิ่มฟังก์ชันอื่นๆ ในภายหลังได้ง่ายขึ้น ตัวอย่างเช่น ตอนนี้เราจะเพิ่มลิงก์เพื่อสร้างโพสต์ใหม่ ในหน้าการจัดการนี้

ใต้ส่วนหัว เพียงเพิ่มสิ่งต่อไปนี้:

<%= link_to "New Post", new_post_url%>

นี่คือการตั้งค่าทั้งหมดที่เราต้องการ! เป็นความคิดที่ดีที่จะดำเนินการตรวจสอบเพื่อให้แน่ใจว่าทุกอย่างทำงานอย่างถูกต้อง ตอนนี้คุณควรจะทำสิ่งต่อไปนี้ได้:

  • สร้างบัญชีผู้ใช้
  • ลงชื่อเข้าใช้
  • ออกจากระบบ
  • ดูดัชนีของการโพสต์ที่มีอยู่
  • ตั้งกระทู้ใหม่

หากทุกอย่างเป็นไปตามที่คุณคาดหวัง ก็ถึงเวลาที่จะไปสู่การรวม Stripe!

การรวมแถบ

การเพิ่มอัญมณีทับทิมลายทาง

ในการเริ่มต้น เราจะเพิ่มอัญมณี Stripe Ruby ใน Gemfile ของคุณ ให้เพิ่มบรรทัดต่อไปนี้:

gem 'stripe'

ตามด้วยการวิ่ง:

bundle install

สำหรับตอนต่อไป คุณจะต้องใช้ คีย์ Stripe API . บนคอนโซล Stripe ให้คลิก "นักพัฒนา" บนแถบด้านข้าง ตัวเลือกสำหรับ "คีย์ API" จะแสดงขึ้นเอง ดังนั้นโปรดคลิกถัดไป จด "รหัสลับ" ของคุณไว้ เพราะเราต้องการใช้ในไม่ช้า

แต่ก่อนอื่น ให้สร้างตัวเริ่มต้นใน config/initializers . สร้างหนึ่งชื่อ stripe.rb . ในไฟล์นี้ ให้เพิ่มบรรทัดเดียวที่มีลักษณะดังนี้ (แต่แทนที่คีย์ลับของคุณ):

Stripe.api_key = <insert your key here as a string>

การจัดเก็บหนังสือรับรอง Stripe

อย่างไรก็ตาม วิธีการจัดเก็บข้อมูลรับรองของเรานี้ไม่ปลอดภัย เราไม่ควรเก็บความลับในการผลิตเป็นข้อความธรรมดา ซึ่งจะถูกติดตามโดย git และทุกคนที่อ่านโค้ดเบสสามารถเข้าถึงได้ โชคดีที่ Rails มีวิธีจัดเก็บข้อมูลรับรองอย่างปลอดภัย

ในเชลล์ของคุณ ให้รัน EDITOR=vim bin/rails credentials:edit เพื่อยกเลิกการเข้ารหัสและเปิดไฟล์ข้อมูลรับรองเป็นกลุ่ม กดปุ่ม 'i' บนแป้นพิมพ์เพื่อเปลี่ยนเป็นโหมดแทรก เพิ่มส่วนใหม่ที่มีลักษณะดังนี้:

stripe:
  secret: your-secret-key
  public: your-public-key

ถัดไป บันทึกไฟล์และออกจากกลุ่ม มีสองสามวิธีในการทำเช่นนี้ แต่ที่ฉันชอบคือการกดปุ่ม Escape (เพื่อออกจากโหมดแทรก) แล้วพิมพ์ :wq ตามด้วยปุ่ม Enter หากคุณต้องการทราบข้อมูลเพิ่มเติมเกี่ยวกับวิธีที่ Rails จัดการกับข้อมูลรับรองที่เข้ารหัส นี่เป็นแหล่งข้อมูลที่ดี

เมื่อข้อมูลประจำตัวถูกเก็บไว้อย่างปลอดภัยแล้ว ให้สลับรหัสตัวเริ่มต้นที่ไม่ปลอดภัยด้วยสิ่งนี้:

Stripe.api_key = Rails.application.credentials[:stripe][:secret]

การเชื่อมโยงไปยังแถบการชำระเงินจากผลิตภัณฑ์

มีวิธีที่แตกต่างกันสองสามวิธีที่เราสามารถใช้ประโยชน์จาก Stripe สำหรับการชำระเงิน แต่ตัวเลือกที่ยอดเยี่ยมคือ Stripe Checkout Stripe Checkout เป็น หน้าการชำระเงินที่โฮสต์ หมายความว่าคุณไม่ได้สร้างอินเทอร์เฟซผู้ใช้ใดๆ สำหรับธุรกรรมจริง ผู้ใช้จะคลิกปุ่ม ถูกเปลี่ยนเส้นทางไปที่ Stripe แล้วเปลี่ยนเส้นทางกลับไปที่แอปพลิเคชันของคุณหลังจากการชำระเงินเสร็จสิ้น ทำให้การจัดการบริบทค่อนข้างท้าทาย แต่ช่วยขจัดภาระในการสร้างแบบฟอร์มการชำระเงินและช่วยให้ Stripe ทำงานมากมายเพื่อเพิ่ม Conversion สูงสุด คุณสามารถรับการชำระเงินประเภทอื่นนอกเหนือจากบัตรได้อย่างง่ายดาย รวมถึงธุรกรรม ACH หรือวิธีการชำระเงินระหว่างประเทศมากมาย

ในการเริ่มต้น สร้างตัวควบคุมเพื่อจัดการขั้นตอนการชำระเงิน . สร้าง app/controllers/checkout_controller.rb . ในนั้น เราจะเขียนวิธีการจัดการกับการสร้างเซสชันการชำระเงิน

def create
  @session = Stripe::Checkout::Session.create({
    success_url: root_url,
    cancel_url: manage_posts_url,
    payment_method_types: ['card'],
    line_items: [{
        name: "Roommate Posting",
        amount: 2000,
        currency: "usd",
        quantity: 1
    }],
    mode: 'payment',
    metadata: {post_id: params[:post_id]},
    customer_email: current_user.email,
    success_url: manage_posts_url,
    cancel_url: manage_posts_url
  })

  respond_to do |format|
    format.js
  end
end

การดำเนินการนี้จะสร้างเซสชันการชำระเงินหนึ่งรายการพร้อมบริบทที่จำเป็นสำหรับ Stripe เพื่อใช้เวทย์มนตร์ เราส่งต่อรายการบรรทัดเดียว ซึ่งเราฮาร์ดโค้ดไว้ที่นี่ เนื่องจากแอปพลิเคชันของเรามีผลิตภัณฑ์เดียวเท่านั้น แต่นี่จะเป็นเรื่องง่ายที่จะใช้พารามิเตอร์ที่ส่งผ่านเพื่อปรับแต่งการชำระเงินสำหรับผลิตภัณฑ์เฉพาะ ตัวแปร "Amount" คือต้นทุนของผลิตภัณฑ์ เป็นเซ็นต์ . นอกจากนี้ยังควรค่าแก่การกล่าวขวัญว่าเราส่งผ่านอีเมลของผู้ใช้ปัจจุบันเพื่อความเรียบง่าย สิ่งสุดท้ายที่คุณควรพูดถึงคือเราส่งต่อ id ของโพสต์เป็น ข้อมูลเมตา . ซึ่งจะทำให้เราสามารถดำเนินการซื้อของผู้ใช้ในส่วน Web hooks ได้อย่างง่ายดาย!

ต่อไป เราต้องการวิธีเรียกวิธีการนี้อย่างชัดเจน

ใน config/routes.rb ให้เพิ่มบรรทัดต่อไปนี้เพื่อสร้างเส้นทางไปยังคอนโทรลเลอร์

post 'checkout/create' => 'checkout#create', as: "checkout_create"

ต่อไป เราจะเพิ่มปุ่มเพื่อส่งการชำระเงิน สำหรับโพสต์ใดๆ ในมุมมองจัดการโพสต์ ใน app/views/manage.html.erb เพิ่มคอลัมน์พิเศษในส่วนหัวโดยเพิ่มส่วนสุดท้ายนี้:

<th>Payment</th>

นอกจากนี้ ให้สลับ <th colspan="3"></th> ถึง <th colspan="4"></th> .

ถัดไป เพิ่มรายการอื่นในเนื้อหาของตารางสำหรับปุ่มชำระเงินเอง เป็นรายการที่สี่ในร่างกาย เพิ่มต่อไปนี้:

<td><%= button_to "Submit Payment", checkout_create_path, params: {:post_id => post.id }, remote: true %></td>

โดยรวมแล้ว มุมมองจัดการโพสต์ตอนนี้มีลักษณะดังนี้:

<p id="notice"><%= notice %></p>

<h1>Manage Posts</h1>
<%= link_to "New Post", new_post_url%>

<table>
  <thead>
    <tr>
      <th>Address</th>
      <th>Rent</th>
      <th>Content</th>
      <th>Payment</th>
      <th colspan="4"></th>
    </tr>
  </thead>

  <tbody>
    <% @posts.each do |post| %>
      <tr>
        <td><%= post.address %></td>
        <td><%= post.rent %></td>
        <td><%= post.content %></td>
        <td><%= button_to "Submit Payment", checkout_create_path, params: {:post_id => post.id }, remote: true %></td>
        <td><%= link_to 'Show', post %></td>
        <td><%= link_to 'Edit', edit_post_path(post) %></td>
        <td><%= link_to 'Destroy', post, method: :delete, data: { confirm: 'Are you sure?' } %></td>
      </tr>
    <% end %>
  </tbody>
</table>

<br>

<%= link_to 'New Post', new_post_path %>

จาวาสคริปต์

อย่าลืมเพิ่มแพ็คเกจ Stripe JavaScript ที่รวมไว้ใน app/views/application.html.erb ด้วยบรรทัดนี้:

<script src="https://js.stripe.com/v3/"></script>

ถัดไป คุณจะต้องเพิ่มไฟล์ใหม่ (และไดเรกทอรี!) ใน app/views/checkout/create.js.erb . ในไฟล์นี้ เพียงเพิ่มสิ่งต่อไปนี้เพื่อให้สามารถสร้างเซสชั่นการชำระเงินได้เมื่อคลิกปุ่มด้วยความช่วยเหลือของคอนโทรลเลอร์

var stripe = Stripe("<%= Rails.application.credentials[:stripe][:public] %>")

stripe.redirectToCheckout({
    sessionId: '<%= @session.id %>'
}).then(function (result) {
    console.log(result.error_message)
});

การตั้งค่าเว็บฮุค

ตอนนี้ เรามีวิธีให้ผู้ใช้ชำระค่าโพสต์ได้แล้ว! อย่างไรก็ตาม เราไม่มีวิธีให้แอปพลิเคชันทราบว่าโพสต์ได้รับการชำระเงินหรือเปิดใช้งานโพสต์เมื่อใด ในการเริ่มต้น ให้เพิ่มบูลีนให้กับโมเดลโพสต์เพื่อระบุว่าโพสต์ได้รับการชำระเงินแล้วหรือไม่ หากต้องการใช้เครื่องมือสร้างการย้ายข้อมูล Rails ให้เรียกใช้สิ่งต่อไปนี้:

rails g migration AddPaymentDetailsToPost

เปิดการย้ายข้อมูลนี้และเพิ่มบรรทัดต่อไปนี้:

add_column :posts, :is_paid, :boolean, :default => false

สิ่งนี้จะเพิ่มแอตทริบิวต์/คอลัมน์ให้กับตาราง/รุ่นของโพสต์ที่เรียกว่า is_paid . คุณลักษณะนี้เป็นบูลีนที่มีค่าเริ่มต้นเป็นเท็จ ซึ่งหมายความว่าเมื่อใดก็ตามที่สร้างโพสต์ จะมีการทำเครื่องหมายว่า ไม่ได้รับการชำระเงิน . เมื่อมีการชำระค่าโพสต์ เราจะพลิกบูลีนด้วยตนเอง แต่ก่อนอื่น ให้เรียกใช้การย้ายข้อมูลที่คุณเพิ่งเขียนด้วย:

rails db:migrate

เนื่องจากการชำระเงินไม่ได้ดำเนินการในทันที เราจึงไม่สามารถพึ่งพาการตอบสนอง API ที่ประสบความสำเร็จจาก Stripe เพื่อระบุว่างานได้รับเงินแล้ว เราสามารถระบุปลายทางในแอปพลิเคชันของเราสำหรับ Stripe เพื่อส่งคำขอโพสต์เมื่อการชำระเงินเสร็จสิ้นการประมวลผล กระบวนการนี้โดยทั่วไปจะเรียกว่า webhooks และจริง ๆ แล้วง่ายกว่าที่ฟัง!

ในการเริ่มต้น ให้สร้างคอนโทรลเลอร์ใหม่ใน app/controllers/ เรียกว่า WebhooksController ใน app/controllers/webhooks_controller.rb . นี้ , เขียนดังนี้:

class WebhooksController < ApplicationController
  skip_before_action :verify_authenticity_token

  def create
    payload = request.body.read
    sig_header = request.env['HTTP_STRIPE_SIGNATURE']
    event = nil

    begin
    event = Stripe::Webhook.construct_event(
      payload, sig_header, Rails.application.credentials[:stripe][:webhook]
    )
    rescue JSON::ParserError => e
      status 400
    return
    rescue Stripe::SignatureVerificationError => e
      # Invalid signature
      puts "Signature error"
      p e
      return
    end

    # Handle the event
    case event.type
    when 'checkout.session.completed'
      session = event.data.object
      post = Post.find_by(id: session.metadata.post_id)]
      post.is_paid = true
      post.save!
    end

    render json: { message: 'success' }
  end
end

นอกเหนือจากต้นแบบที่จำเป็น วิธีนี้จะมอบประเภทเหตุการณ์เฉพาะที่เรียกว่า checkout.session.completed . สิ่งที่เหลืออยู่ในด้าน Rails คือการเพิ่มเส้นทางไปที่ config/routes.rb :

resources :webhooks, only: [:create]

สุดท้าย คุณจะต้องเชื่อมต่อบัญชี Stripe ของคุณกับปลายทางนี้ในแดชบอร์ด Stripe เนื่องจากคุณจะระบุ URL ไปยังแดชบอร์ด Stripe สิ่งนี้จะไม่ทำงานในพื้นที่! คุณต้องปรับใช้สิ่งนี้กับปลายทางที่เข้าถึงอินเทอร์เน็ตได้เพื่อให้เว็บฮุคทำงานได้อย่างถูกต้อง

กลับไปที่ "นักพัฒนา" บนแดชบอร์ด Stripe แต่คราวนี้ ให้เลือก "Webhooks" ที่แผงด้านซ้าย ในส่วน "ปลายทาง" คลิก "เพิ่มปลายทาง" ระบุ URL แอปพลิเคชันของคุณต่อท้ายด้วย /webhooks และกำหนดกิจกรรม "checkout.session.completed"

และนั่นคือทั้งหมดสำหรับการรวม Stripe! ขั้นตอนสุดท้ายที่ใช้งานได้จริงสำหรับแอปพลิเคชันจำลองของเราคือให้หน้าดัชนีแสดงเฉพาะโพสต์ที่ชำระเงินแล้ว สามารถทำได้ง่ายๆ ในวิธีดัชนีของ app/controllers/posts_controller.rb . เปลี่ยนวิธีการดังนี้:

def index
  @posts = Post.where(:is_paid => true)
end

ตอนนี้ ผู้ใช้สามารถสร้างโพสต์ ชำระเงินด้วยการเช็คเอาท์ Stripe และให้แสดงบนหน้าแรกของแอปพลิเคชันโดยอัตโนมัติ!

เปลี่ยนเป็นการผลิต

เนื่องจากเว็บฮุคของคุณใช้งานได้เมื่อปรับใช้กับไซต์ที่ใช้งานจริงเท่านั้น จึงคุ้มค่าที่จะหารือเกี่ยวกับการเปลี่ยนแปลงที่จำเป็นสำหรับการทำให้ใช้งานได้ สำหรับการเริ่มต้น การสื่อสารของคุณต้อง เป็น HTTPS เพื่อให้การชำระเงิน Stripe ทำงาน หากคุณประสบปัญหาใดๆ โปรดตรวจสอบคอนโซล JavaScript เพื่อดูคำแนะนำจาก Stripe

มีโอกาสสูงที่คุณจะใช้คีย์ทดสอบของ Stripe ในการตั้งค่าเริ่มต้น หากคุณทำเช่นนั้น ส่วนคีย์ API ของแดชบอร์ด Stripe จะมีลักษณะดังนี้

วิธีการขายการซื้อแบบครั้งเดียวใน Rails ด้วย Stripe ภาพหน้าจอของคีย์ API แดชบอร์ด Stripe

เพียงคลิกปุ่มสลับข้าง "การดูข้อมูลการทดสอบ" เพื่อเปิดเผยความลับในการผลิตและคีย์สาธารณะของคุณ คุณจะต้องเปิดตัวจัดการข้อมูลรับรอง Rails ในลักษณะเดียวกับเมื่อก่อน และแทนที่คีย์ทดสอบด้วยสิ่งนี้ เพื่อให้แอปพลิเคชันของคุณประมวลผลข้อมูลสด อย่างไรก็ตาม สภาพแวดล้อมการทดสอบมีประโยชน์สำหรับการทำธุรกรรมทดสอบด้วยหมายเลขบัตรเครดิตปลอม หากคุณมีมากกว่าหนึ่งสภาพแวดล้อมหรือวางแผนที่จะเปลี่ยนสิ่งนี้บ่อยๆ คุณควรสร้างคู่คีย์/ค่าอื่นในตัวจัดการข้อมูลรับรองและใช้แบบไดนามิกในโค้ดของคุณ

บทสรุป

เราได้ใช้เวลามากมายในการสร้างแอปพลิเคชันตัวอย่างของเราและไม่ได้รวม Stripe ไว้นานเกินไป ต้องขอบคุณการชำระเงินของ Stripe เราส่งต่อความรับผิดชอบจำนวนมาก รวมถึงอินเทอร์เฟซผู้ใช้ ซึ่งช่วยเราประหยัดโค้ดได้มาก สิ่งนี้สร้างประสบการณ์ที่สอดคล้องกันสำหรับผู้ใช้ เนื่องจากการนำไปใช้อย่างแพร่หลายของ Stripe ในตลาดออนไลน์ ภารกิจของ Stripe คือการเพิ่ม GDP ของอินเทอร์เน็ต และพวกเขาต้องการแอปพลิเคชันเช่นคุณเพื่อทำเช่นนั้น ด้วยเหตุนี้ พวกเขาจึงมองหา ง่ายยิ่งขึ้น . อยู่เสมอ วิธีสำหรับคุณในการประมวลผลการชำระเงิน แม้ว่า Stripe Checkout จะใช้งานได้ค่อนข้างง่าย แต่เมื่อเร็ว ๆ นี้พวกเขากลับคิดหาวิธีที่เร็วกว่านี้

Stripe Payment Links เป็นผลิตภัณฑ์ใหม่ล่าสุดจาก Stripe ที่มีศักยภาพในการทำให้การผสานรวม Checkout ของเราแทบไม่มีความจำเป็น ทั้งหมดที่เราทำคือเปลี่ยนเส้นทางผู้ใช้ไปยังหน้าชำระเงินที่โฮสต์ และลิงก์ธรรมดามีศักยภาพที่จะทำให้สิ่งนี้ง่ายยิ่งขึ้นไปอีก ลิงก์การชำระเงินเป็นโซลูชันที่ไม่มีรหัสซึ่งดูเหมือนว่าจะส่งไปยังผู้ค้าปลีก แต่อาจใช้ได้ผลสำหรับกรณีการใช้งานนี้ โดยไม่คำนึงถึง Stripe Checkout ยังคงมีความยืดหยุ่นและการนำไปใช้ในตลาดมากขึ้นเล็กน้อย ดังนั้นจึงเป็นสิ่งสำคัญที่จะต้องเข้าใจอย่างถ่องแท้

สิ่งหนึ่งที่ธุรกิจจำนวนมากต้องเผชิญคือการจัดการภาษี โดยเฉพาะในระดับสากล Stripe เพิ่งเปิดตัวคุณลักษณะใหม่เพื่อจัดการสิ่งนี้โดยอัตโนมัติสำหรับธุรกิจ แต่ยังอยู่ในช่วงเบต้า เมื่อมีให้ใช้งานแล้ว จะช่วยลดภาระทางบัญชีของใครก็ตามที่ใช้ Stripe เพื่อดำเนินการชำระเงินได้อย่างมาก!

เอกสารของ Stripe และบทความที่มีอยู่ซึ่งมุ่งไปที่ Ruby on Rails นั้นเน้นไปที่การสมัครรับข้อมูลมากกว่าการซื้อเพียงครั้งเดียว การสมัครรับข้อมูลเป็นค่าบริการที่เกิดขึ้นประจำซึ่งแนบมากับผู้ใช้และผลิตภัณฑ์ ในตอนท้ายของ Stripe การนำไปใช้งานดูเหมือนการซื้อครั้งเดียวมาก อย่างไรก็ตาม ในด้านแอปพลิเคชัน เราจะต้องรวมการจัดการการสมัครรับข้อมูล อนุญาตให้ผู้ใช้จัดการการสมัครรับข้อมูล และตรวจสอบสถานะการสมัครเป็นระยะๆ บทความนี้เน้นที่การซื้อแบบครั้งเดียว แต่มีแหล่งข้อมูลมากมายในชุมชนหากคุณต้องการจัดการการสมัครรับข้อมูล