Spletno Mesto

Vključevanje načinov plačevanja v obliki Stripe in PayPal v Ruby on Rails

Ključna lastnost velikih podjetij za e-trgovino, kot so AliExpress, Ebay in Amazon, je varen način obdelave plačil, ki je bistvenega pomena za njihovo poslovanje. Če ta funkcija ne uspe, bi bile posledice uničujoče. To velja za vodilne v industriji in Razvijalci Ruby on Rails delo na aplikacijah za e-trgovino.

Kibernetska varnost je bistvenega pomena za preprečevanje napadov, način za povečanje varnosti transakcijskega postopka pa je, če to zahteva tretja storitev. Vključitev plačilnih prehodov v aplikacijo je način za dosego tega cilja, saj zagotavljajo pooblastila uporabnika, šifriranje podatkov in nadzorno ploščo, tako da lahko sproti spremljate stanje transakcije.

V spletu obstajajo različne storitve prehodnih plačil, v tem članku pa se bom osredotočil na integracijo Črta in PayPal v aplikacijo Rails. Če omenimo še nekaj drugih: Amazon Payments, Square, SecurePay, WorldPay, Authorize.Net, 2Checkout.com, Braintree, Amazon ali BlueSnap.



Kako deluje integracija plačilnega prehoda

Splošno zastopanje za transakcije, ki vključujejo plačilne prehode
Splošno zastopanje za transakcije, ki vključujejo plačilne prehode

Na splošno bo v vaši aplikaciji obrazec / gumb, kjer se lahko uporabnik prijavi / vstavi podatke o kreditni kartici. PayPal in Stripe že naredita ta prvi korak bolj varen z uporabo iframe obrazci ali popups ki vaši aplikaciji preprečujejo shranjevanje občutljivih podatkov o kreditni kartici uporabnika, saj bodo vrnili žeton, ki predstavlja to transakcijo. Nekateri uporabniki se morda tudi počutijo bolj samozavestne pri obdelavi plačil, saj vedo, da neodvisna storitev upravlja postopek transakcije, zato je to lahko privlačnost tudi za vašo aplikacijo.

Po potrditvi uporabniških podatkov bo plačilni prehod potrdil plačilo tako, da se obrne na plačilni procesor, ki komunicira z bankami, da bi poravnal plačila. To zagotavlja, da se transakcija pravilno bremeni / knjiži v dobro.

Stripe uporablja obrazec za kreditno kartico, v katerem zahteva številko kreditne kartice, cvv in datum poteka veljavnosti. Uporabnik mora torej na zavarovane vnose Stripe vnesti podatke o kreditni kartici. Po posredovanju teh podatkov vaša aplikacija na koncu obdela to plačilo z žetonom.

Za razliko od Stripe, PayPal uporabnika preusmeri na prijavno stran PayPal. Uporabnik avtorizira in izbere način plačila prek PayPal-a in znova bo vaš zadnji del obdeloval žetone namesto uporabniško občutljivih podatkov.

Pomembno je omeniti, da mora za ta dva plačilna prehoda vaš zadnji del zahtevati nadaljnje izvajanje transakcij prek API-jev Stripe ali PayPal, ki bodo dali odgovor OK / NOK, zato mora vaša aplikacija uporabnika preusmeriti na uspešno stran ali stran z napako.

Namen tega članka je zagotoviti hiter vodnik za integracijo teh dveh plačilnih prehodov v eno samo aplikacijo. Za vse teste bomo za simulacijo plačil uporabljali peskovnike in testne račune, ki jih zagotavljata Stripe in PayPal.

Nastaviti

Pred integracijo plačilnih prehodov bomo izvedli namestitev za inicializacijo aplikacije z dodajanjem draguljev, tabel zbirke podatkov in strani s kazalom. Ta projekt je bil ustvarjen z uporabo različic Rails 5.2.3 in Ruby 2.6.3.

Opomba: Lahko si ogledate novo Funkcije Rails 6 v našem nedavnem članku .

Korak 1: Inicializirajte aplikacijo Rails.

Inicializirajte projekt tako, da zaženete inicializacijo projekta z rails ukaz z imenom vaše aplikacije:

rails new YOUR_APP_NAME

In cd v mapi z aplikacijami.

2. korak: Namestite dragulje.

Poleg draguljev Stripe in PayPal je bilo dodanih še nekaj drugih draguljev:

  • devise: uporablja se za avtentikacijo in avtorizacijo uporabnika
  • haml: orodje za predloge za upodabljanje uporabniških strani
  • jquery-rails: za jquery v čelnih skriptih
  • money-rails: za prikaz formatiranih denarnih vrednosti

Dodajte med svoje Gemfile:

gem 'devise', '>= 4.7.1' gem 'haml' gem 'jquery-rails' gem 'money-rails'

Po dodajanju se zažene v vašem CLI:

bundle install

3. korak: Inicializirajte dragulje.

Nekateri od teh draguljev bodo poleg namestitve z bundle zahtevali tudi inicializacijo.

Namestitev naprave:

rails g devise:install

Inicializacija money-rails:

rails g money_rails:initializer

Inicializirajte jquery-rails z dodajanjem na dno app/assets/javascripts/application.js naslednji:

//= require jquery //= require jquery_ujs

4. korak: Tabele in selitve

V tem projektu bodo uporabljene tri tabele Uporabniki , Izdelki , in Naročila .

  • Users: Ustvari se z zasnovo
  • Products stolpci:
    • name
    • price_cents
    • Stripe_plan_name: ID, ki predstavlja naročniški načrt, ustvarjen v programu Stripe, tako da se lahko uporabniki nanj naročijo. To polje je obvezno samo za izdelke, povezane s načrtom Stripe.
    • paypal_plan_name: Enako kot stripe_plan_name ampak za PayPal
  • Orders stolpci:
    • product_id
    • user_id
    • status: To vas bo obvestilo, če je naročilo v teku, neuspešno ali plačano.
    • token: To je žeton, ustvarjen iz API-jev (Stripe ali PayPal), da se inicializira transakcija.
    • price_cents: Podobno kot izdelek, vendar se uporablja, da se ta vrednost ohrani v zapisu naročila
    • payment_gateway: Shranjuje, kateri plačilni prehod se uporablja za naročilo PayPal ali Stripe
    • customer_id: To bo uporabljeno za Stripe, da bo stranko Stripe shranilo za naročnino, podrobneje pa bo razloženo v naslednjem poglavju.

Za generiranje teh tabel je treba ustvariti nekaj selitev:

Za ustvarjanje Tabela uporabnikov . Zaženi:

rails g devise User

Za ustvarjanje Tabela izdelkov . Ustvari selitev tako, da zaženeš:

rails generate migration CreateProducts name:string stripe_plan_name:string paypal_plan_name:string

Odprite svojo ustvarjeno migracijsko datoteko, ki naj bo na naslovu db/migrate/, in spremenite, da bo vaša selitev podobna tej:

class CreateProducts

Za ustvarjanje Tabela naročil . Ustvari selitev tako, da zaženeš:

rails generate migration CreateOrders product_id:integer user_id:integer status:integer token:string charge_id:string error_message:string customer_id:string payment_gateway:integer

Še enkrat odprite svojo ustvarjeno migracijsko datoteko, ki naj bo na naslovu db/migrate/ in spremenite to datoteko, da bo videti podobno tej:

class CreateOrders

Izvedite selitve baze podatkov z izvajanjem:

rails db:migrate

5. korak: Ustvari modele.

Uporabniški model je že ustvarjen iz namestitve naprave in na njem ne bodo potrebne nobene spremembe. Poleg tega bosta ustvarjena dva modela Izdelka in Naročilo .

Izdelka. Dodajte novo datoteko, app/models/product.rb, z:

class Product

Naročilo. Dodajte novo datoteko, app/models/order.rb, z:

class Order { where(created_at: 1.minutes.ago..DateTime.now) } def set_paid self.status = Order.statuses[:paid] end def set_failed self.status = Order.statuses[:failed] end def set_paypal_executed self.status = Order.statuses[:paypal_executed] end end

6. korak: Popolnite bazo podatkov.

V konzoli bo ustvarjen uporabnik in dva izdelka. Evidenca naročil bo ustvarjena v skladu s preizkusi plačil.

  • Zaženi rails s
  • V brskalniku obiščite http://localhost:3000
  • Preusmerjeni boste na stran za prijavo.
  • Prijavite uporabnika tako, da izpolnite njegov e-poštni naslov in geslo.
  • V vašem terminalu bodo pozvani naslednji dnevniki, ki prikazujejo, da je bil v vaši bazi podatkov ustvarjen uporabnik:
User Create (0.1ms) INSERT INTO 'users' ('email', 'encrypted_password', 'created_at', 'updated_at') VALUES (?, ?, ?, ?) …
  • Ustvarite dva izdelka brez naročnin, tako da zaženete rails c in doda:
    • Product.create(name: 'Awesome T-Shirt', price_cents: 3000)
    • Product.create(name: 'Awesome Sneakers', price_cents: 5000)

7. korak: Ustvarite indeksno stran

Glavna stran projekta vključuje izbor izdelkov za nakupe ali naročnine. Poleg tega ima tudi razdelek za izbiro načina plačila (Stripe ali PayPal). Gumb za oddajo se uporablja tudi za vsako vrsto prehoda za plačilo, saj bomo za PayPal dodali lastno zasnovo gumba prek njegove knjižnice JavaScript.

Najprej ustvarite poti za index in submit v config/routes.rb.

Rails.application.routes.draw do devise_for :users get '/', to: 'orders#index' post '/orders/submit', to: 'orders#submit' end

Ustvarjanje in dodajanje dejanj index in submit v upravljavcu naročil app/controllers/orders_controller.rb. The orders#index action shrani dve spremenljivki, ki ju je treba porabiti v čelnem koncu: @products_purchase ki ima seznam izdelkov brez načrtov in @products_subscription ki ima izdelke tako z načrti PayPal kot Stripe.

class OrdersController

Ustvari datoteko v app/views/orders/index.html.haml. Ta datoteka vsebuje vse vnose, ki jih bomo poslali na svoj zadnji del prek metode oddaje, ter interakcijo za plačilne prehode in izbiro izdelka. Tu je nekaj atributov vhodnega imena:

  • Orders[product_id] shrani ID izdelka.
  • Orders[payment_gateway] vsebuje plačilni prehod z vrednostmi Stripe ali PayPal za drugega.
%div %h1 List of products = form_tag({:controller => 'orders', :action => 'submit' }, {:id => 'order-details'}) do %input{id:'order-type', :type=>'hidden', :value=>'stripe', :name=>'orders[payment_gateway]'} .form_row %h4 Charges/Payments - @products_purchase.each do |product| %div{'data-charges-and-payments-section': true} = radio_button_tag 'orders[product_id]', product.id, @products_purchase.first == product %span{id: 'radioButtonName#{product.id}'} #{product.name} %span{id: 'radioButtonPrice#{product.id}', :'data-price' => '#{product.price_cents}'} #{humanized_money_with_symbol product.price} %br %h4 Subscriptions - @products_subscription.each do |product| %div = radio_button_tag 'orders[product_id]', product.id, false %span{id: 'radioButtonName#{product.id}'} #{product.name} %span{id: 'radioButtonPrice#{product.id}', :'data-price' => '#{product.price_cents}'} #{humanized_money_with_symbol product.price} %br %hr %h1 Payment Method .form_row %div = radio_button_tag 'payment-selection', 'stripe', true, onclick: 'changeTab();' %span Stripe %br %div = radio_button_tag 'payment-selection', 'paypal', false, onclick: 'changeTab();' %span Paypal %br %br %div{id:'tab-stripe', class:'paymentSelectionTab active'} %div{id:'card-element'} %div{id:'card-errors', role:'alert'} %br %br = submit_tag 'Buy it!', id: 'submit-stripe' %div{id:'tab-paypal', class:'paymentSelectionTab'} %div{id: 'submit-paypal'} %br %br %hr :javascript function changeTab() { var newActiveTabID = $('input[name='payment-selection']:checked').val(); $('.paymentSelectionTab').removeClass('active'); $('#tab-' + newActiveTabID).addClass('active'); } :css #card-element { width:500px; } .paymentSelectionTab { display: none; } .paymentSelectionTab.active { display: block !important; }

Če aplikacijo zaženete z rails s in obiščite svojo stran v http://localhost:3000. Stran bi morali videti tako:

Surova indeksna stran brez integracije Stripe in PayPal
Surova indeksna stran brez integracije Stripe in PayPal

Shranjevanje poverilnic za plačilni prehod

Tipke PayPal in Stripe bodo shranjene v datoteki, ki ji Git ne sledi. V tej datoteki sta shranjeni dve vrsti ključev za vsak prehod za plačilo in za zdaj bomo zanje uporabljali navidezno vrednost. Dodatna navodila za ustvarjanje teh tipk so predstavljena v nadaljnjih razdelkih.

Korak 1: Dodajte to v .gitignore.

/config/application.yml

2. korak: Ustvarite datoteko s svojimi poverilnicami v config/application.yml. Vsebovati bi moral vse vaše peskovnike / testne ključe PayPal in Stripe za dostop do teh API-jev.

test: &default PAYPAL_ENV: sandbox PAYPAL_CLIENT_ID: YOUR_CREDENTIAL_HERE PAYPAL_CLIENT_SECRET: YOUR_CREDENTIAL_HERE STRIPE_PUBLISHABLE_KEY: YOUR_CREDENTIAL_HERE STRIPE_SECRET_KEY: YOUR_CREDENTIAL_HERE development: <<: *default

3. korak: Za shranjevanje spremenljivk iz datoteke config/application.yml ko se aplikacija zažene, dodajte te vrstice v config/application.rb znotraj Application razreda, tako da bodo na voljo v ENV.

config_file = Rails.application.config_for(:application) config_file.each do |key,value| ENV[key] = value end unless config_file.nil?

Konfiguracija črte

Dodali bomo dragulj za uporabo Stripe API: stripe-rails. Ustvarjanje računa Stripe je prav tako potrebno za obdelavo stroškov in naročnin. Če je treba, se lahko posvetujete z metodami API za Stripe API v uradna dokumentacija .

Korak 1: V svoj projekt dodajte dragulj s črtastimi tirnicami.

The trak-tirnice dragulj bo zagotovil vmesnik za vse zahteve API, uporabljene v tem projektu.

Dodajte to v Gemfile:

gem 'stripe-rails'

Zaženi:

bundle install

2. korak: Ustvari svoje ključe API.

Če želite imeti ključe API za komunikacijo s Stripe, morate v Stripe ustvariti račun. Za preizkus aplikacije lahko uporabite način testiranja, zato v postopku ustvarjanja računa Stripe ni treba vnašati nobenih resničnih poslovnih podatkov.

  • Če ga še nimate, ustvarite račun v Stripe ( https://dashboard.stripe.com/ ).
  • Ko ste še vedno na nadzorni plošči Stripe, po prijavi preklopite Ogled testnih podatkov na.
  • Ob https://dashboard.stripe.com/test/apikeys , zamenjaj YOUR_CREDENTIAL_HERE za vrednosti STRIPE_PUBLISHABLE_KEY in STRIPE_SECRET_KEY v /config/application.yml z vsebino iz Publishable Key in Secret key.

3. korak: Inicializirajte modul Stripe

Poleg zamenjave tipk moramo še vedno inicializirati modul Stripe, tako da uporablja ključe, ki so že nastavljeni v naših ENV

Ustvari datoteko v config/initializers/stripe.rb z:

Rails.application.configure do config.stripe.secret_key = ENV['STRIPE_SECRET_KEY'] config.stripe.publishable_key = ENV['STRIPE_PUBLISHABLE_KEY'] end

4. korak: Vstavite trak na sprednji del.

Dodali bomo knjižnico Stripe JavaScript in logiko za pošiljanje žetona, ki predstavlja podatke o uporabniški kreditni kartici in bo obdelan v našem zaledju.

V index.html.haml datoteko, dodajte to na vrh datoteke. S tem boste uporabili modul Stripe (priskrbel ga je dragulj) za dodajanje knjižnice javascript Stripe na uporabniško stran.

= stripe_javascript_tag

Stripe uporablja varna vnosna polja, ki jih ustvari njihov API. Ker so ustvarjeni v iframe ustvarjen s tem API-jem, vam ne bo treba skrbeti za morebitne ranljivosti, ki obdelujejo podatke o uporabniških kreditnih karticah. Poleg tega vaš zadnji del ne bo mogel obdelati / shraniti nobenih uporabniško občutljivih podatkov in bo prejel samo žeton, ki predstavlja te informacije.

Ta vnosna polja se ustvarijo s klicem stripe.elements().create('card'). Po tem je treba le vrniti predmet z mount() tako, da kot argument posreduje element / razred elementa HTML, kamor naj bodo ti vhodi nameščeni. Več informacij najdete na Črta .

Ko uporabnik pritisne gumb za oddajo s plačilnim sredstvom Stripe, se na ustvarjenem elementu kartice Stripe izvede še en klic API, ki vrne obljubo:

stripe.createToken(card).then(function(result)

The result Če spremenljivka te funkcije nima dodeljene napake lastnosti, bo imela žeton, ki ga je mogoče pridobiti z dostopom do atributa result.token.id Ta žeton bo poslan na zadnji del.

Za izvedbo teh sprememb zamenjajte komentirano kodo // YOUR STRIPE AND PAYPAL CODE WILL BE HERE v index.html.haml z:

(function setupStripe() { //Initialize stripe with publishable key var stripe = Stripe('#{ENV['STRIPE_PUBLISHABLE_KEY']}'); //Create Stripe credit card elements. var elements = stripe.elements(); var card = elements.create('card'); //Add a listener in order to check if card.addEventListener('change', function(event) { //the div card-errors contains error details if any var displayError = document.getElementById('card-errors'); document.getElementById('submit-stripe').disabled = false; if (event.error) { // Display error displayError.textContent = event.error.message; } else { // Clear error displayError.textContent = ''; } }); // Mount Stripe card element in the #card-element div. card.mount('#card-element'); var form = document.getElementById('order-details'); // This will be called when the #submit-stripe button is clicked by the user. form.addEventListener('submit', function(event) { $('#submit-stripe').prop('disabled', true); event.preventDefault(); stripe.createToken(card).then(function(result) { if (result.error) { // Inform that there was an error. var errorElement = document.getElementById('card-errors'); errorElement.textContent = result.error.message; } else { // Now we submit the form. We also add a hidden input storing // the token. So our back-end can consume it. var $form = $('#order-details'); // Add a hidden input orders[token] $form.append($('').val(result.token.id)); // Set order type $('#order-type').val('stripe'); $form.submit(); } }); return false; }); }()); //YOUR PAYPAL CODE WILL BE HERE

Če obiščete svojo stran, mora biti z novimi polji varnega vnosa Stripe videti tako:

Kazalska stran, integrirana s črtastimi varnimi vnosnimi polji
Kazalska stran, integrirana s črtastimi varnimi vnosnimi polji

5. korak: Preizkusite svojo prijavo.

Izpolnite obrazec za kreditno kartico s preskusno kartico ( https://stripe.com/docs/testing ) in oddajte stran. Preverite, ali je submit dejanje se pokliče z vsemi parametri ( product_id , Payment_gateway , in žeton ) v izhodu strežnika.

Stripe

Stripe dajatve predstavljajo enkratne transakcije. Zato bi po transakciji z bremenitvijo Stripe prejeli denar neposredno od stranke. To je idealno za prodajo izdelkov, ki niso povezani z načrti. V naslednjem poglavju bom pokazal, kako narediti isto vrsto transakcije s PayPal, vendar je ime PayPal za to vrsto transakcije Plačilo .

V tem razdelku bom navedel tudi vse okostje za obdelavo in oddajo naročila. Naročilo ustvarimo v submit ukrep ob predložitvi obrazca Stripe. To naročilo bo sprva imelo v teku status, tako da, če gre kaj narobe med obdelavo tega naročila, bo naročilo še vedno v teku .

Če pride do napake pri klicih API-ja Stripe, vrstni red nastavimo v ni uspelo Če je polnjenje uspešno zaključeno, bo v plačan država. Uporabnik je preusmerjen tudi glede na odziv API-ja Stripe, kot je prikazano na naslednjem grafu:

Stripe transakcije.
Stripe transakcije.

Poleg tega se pri polnjenju Stripe vrne ID. Ta ID bomo shranili, da ga boste lahko pozneje poiskali na svoji nadzorni plošči Stripe. Ta ID se lahko uporablja tudi, če je treba vrniti naročilo. Kaj takega v tem članku ne bomo raziskovali.

Korak 1: Ustvari storitev Stripe.

Za predstavitev operacij Stripe s pomočjo API-ja Stripe bomo uporabili razred singleton. Za ustvarjanje naboja je metoda Stripe::Charge.create in vrnjeni atribut ID predmeta bo shranjen v zapisu naročila charge_id. To create funkcija se pokliče s posredovanjem žetona, ki izvira iz sprednjega dela, cene naročila in opisa.

Torej, ustvarite novo mapo app/services/orders in dodajte storitev Stripe: app/services/orders/stripe.rb ki vsebuje Orders::Stripe singleton razred, ki ima vnos v metodi execute.

class Orders::Stripe INVALID_STRIPE_OPERATION = 'Invalid Stripe Operation' def self.execute(order:, user:) product = order.product # Check if the order is a plan if product.stripe_plan_name.blank? charge = self.execute_charge(price_cents: product.price_cents, description: product.name, card_token: order.token) else #SUBSCRIPTIONS WILL BE HANDLED HERE end unless charge&.id.blank? # If there is a charge with id, set order paid. order.charge_id = charge.id order.set_paid end rescue Stripe::StripeError => e # If a Stripe error is raised from the API, # set status failed and an error message order.error_message = INVALID_STRIPE_OPERATION order.set_failed end private def self.execute_charge(price_cents:, description:, card_token:) Stripe::Charge.create({ amount: price_cents.to_s, currency: 'usd', description: description, source: card_token }) end end

2. korak: Izvedite dejanje oddaje in pokličite storitev Stripe.

V orders_controller.rb v submit dodajte naslednje action, ki bo v bistvu poklical storitev Orders::Stripe.execute. Upoštevajte, da sta bili dodani tudi dve novi zasebni funkciji: prepare_new_order in order_params.

def submit @order = nil #Check which type of order it is if order_params[:payment_gateway] == 'stripe' prepare_new_order Orders::Stripe.execute(order: @order, user: current_user) elsif order_params[:payment_gateway] == 'paypal' #PAYPAL WILL BE HANDLED HERE end ensure if @order&.save if @order.paid? # Success is rendered when order is paid and saved return render html: SUCCESS_MESSAGE elsif @order.failed? && [email protected] _message.blank? # Render error only if order failed and there is an error_message return render html: @order.error_message end end render html: FAILURE_MESSAGE end private # Initialize a new order and and set its user, product and price. def prepare_new_order @order = Order.new(order_params) @order.user_id = current_user.id @product = Product.find(@order.product_id) @order.price_cents = @product.price_cents end def order_params params.require(:orders).permit(:product_id, :token, :payment_gateway, :charge_id) end

3. korak: Preizkusite svojo prijavo.

Preverite, ali dejanje oddaje, ko je poklicano z veljavno preskusno kartico, preusmeri na uspešno sporočilo. Poleg tega preverite svoj Armaturna plošča s črtami če je prikazano tudi naročilo.

Stripe naročnine

Za ponavljajoča se plačila lahko ustvarite naročnine ali načrte. Pri tej vrsti izdelka se uporabniku zaračuna dnevno, tedensko, mesečno ali letno samodejno v skladu z konfiguracija načrta . V tem razdelku bomo uporabili polje za izdelek stripe_plan_name da shranimo ID načrta - pravzaprav lahko izberemo ID in ga bomo poklicali premium-plan, ki bo uporabljen za ustvarjanje relacije customer subscription.

Ustvarili bomo tudi nov stolpec za tabelo uporabnikov z imenom stripe_customer_id ki bo napolnjena z lastnostjo id objekta stranke Stripe. Stranka v obliki črte se ustvari, ko funkcija Stripe::Customer.create in lahko preverite stranke, ki so ustvarjene in povezane z vašim računom v ( https://dashboard.stripe.com/test/customers ). Stranke se ustvarijo s podajanjem source parameter, ki je v našem primeru žeton, ustvarjen na sprednjem delu, ki se pošlje ob oddaji obrazca.

Predmet stranke, pridobljen iz zadnjega omenjenega klica Stripe API, se uporablja tudi za ustvarjanje naročnine, ki se izvede s klicem customer.subscriptions.create in posredovanje ID načrta kot parametra.

Poleg tega je stripe-rails gem ponuja vmesnik za iskanje in posodabljanje stranke iz Stripe, kar storite tako, da pokličete Stripe::Customer.retrieve in Stripe::Customer.update.

Torej, ko uporabniški zapis že ima stripe_customer_id, namesto da ustvarimo novo stranko z uporabo Stripe::Customer.create, bomo poklicali Stripe::Customer.retrieve mimo stripe_customer_id kot parameter, čemur sledi Stripe::Customer.update in v tem primeru podajanje žetona parameter.

Najprej bomo ustvarili načrt z uporabo Stripe API, da bomo lahko ustvarili nov naročniški izdelek s pomočjo polja stripe_plan_name Potem bomo naredili spremembe v orders_controller in storitev Stripe, tako da se ureja ustvarjanje in izvajanje naročnin na Stripe.

Korak 1: Ustvarite načrt z uporabo Stripe API.

Odprite konzolo z ukazom rails c . Ustvarite naročnino za svoj račun Stripe z:

Stripe::Plan.create({ amount: 10000, interval: 'month', product: { name: 'Premium plan', }, currency: 'usd', id: 'premium-plan', })

Če je vrnjeni rezultat v tem koraku resničen, to pomeni, da je bil načrt uspešno ustvarjen in do njega lahko dostopate v svojem Armaturna plošča s črtami .

2. korak: Izdelajte izdelek v zbirki podatkov z stripe_plan_name set polja.

Zdaj ustvarite izdelek z stripe_plan_name nastavljeno kot premium-plan v bazi:

Product.create(price_cents: 10000, name: 'Premium Plan', stripe_plan_name: 'premium-plan')

3. korak: Ustvari selitev za dodajanje stolpca stripe_customer_id v users tabela.

V terminalu zaženite naslednje:

rails generate migration AddStripeCustomerIdToUser stripe_customer_id:string rails db:migrate

4. korak: Implementirajte naročninsko logiko v razredu storitev Stripe.

Dodajte še dve funkciji v zasebne metode app/services/orders/stripe.rb: execute_subscription je odgovoren za ustvarjanje naročnin v predmetu stranke. Funkcija find_or_create_customer je odgovoren za vrnitev že ustvarjene stranke ali z vrnitvijo novo ustvarjene stranke.

def self.execute_subscription(plan:, token:, customer:) customer.subscriptions.create({ plan: plan }) end def self.find_or_create_customer(card_token:, customer_id:, email:) if customer_id stripe_customer = Stripe::Customer.retrieve({ id: customer_id }) if stripe_customer stripe_customer = Stripe::Customer.update(stripe_customer.id, { source: card_token}) end else stripe_customer = Stripe::Customer.create({ email: email, source: card_token }) end stripe_customer end

Končno, v execute v isti datoteki (app/services/orders/stripe.rb), bomo najprej poklicali find_or_create_customer in nato izvedite naročnino s klicem execute_subscription s posredovanjem prejšnje pridobljene / ustvarjene stranke. Torej, zamenjajte komentar #SUBSCRIPTIONS WILL BE HANDLED HERE v execute z naslednjo kodo:

customer = self.find_or_create_customer(card_token: order.token, customer_id: user.stripe_customer_id, email: user.email) if customer user.update(stripe_customer_id: customer.id) order.customer_id = customer.id charge = self.execute_subscription(plan: product.stripe_plan_name, customer: customer)

5. korak: Preizkusite svojo prijavo.

Obiščite svoje spletno mesto, izberite naročniški izdelek Premium Plan in izpolnite veljavno testno kartico. Po oddaji vas mora preusmeriti na uspešno stran. Poleg tega preverite svoj Armaturna plošča s črtami če je bila naročnina uspešno ustvarjena.

Konfiguracija PayPal

Kot smo storili v Stripe, bomo tudi mi dodali dragulj za uporabo PayPal API: paypal-sdk-rest, prav tako pa je treba ustvariti račun PayPal. Uradno si lahko ogledate opisni potek dela za PayPal, ki uporablja ta dragulj Dokumentacija API-ja PayPal .

Korak 1: Dodajte paypal-sdk-rest dragulj za vaš projekt.

Dodajte to v Gemfile:

gem 'paypal-sdk-rest'

Zaženi:

bundle install

2. korak: Ustvari svoje ključe API.

Če želite imeti ključe API za komunikacijo s PayPal, boste morali ustvariti račun PayPal. Torej:

  • Ustvarite račun (ali uporabite svoj račun PayPal) na https://developer.paypal.com/ .
  • Še vedno prijavljeni v svoj račun, ustvarite dva računa v peskovniku na https://developer.paypal.com/developer/accounts/ :
    • Osebno (račun kupca) - to bo uporabljeno v vaših testih za plačila in naročnine.
    • Business (Merchant Account) - ta bo povezan z aplikacijo, ki bo imela ključe API, ki jih iščemo. Poleg tega je na tem računu mogoče spremljati vse transakcije.
  • Ustvarite aplikacijo na https://developer.paypal.com/developer/applications z uporabo prejšnjega poslovnega računa peskovnika.
  • Po tem koraku boste prejeli dva ključa za PayPal: Client ID in Secret.
  • V config/application.yml zamenjajte YOUR_CREDENTIAL_HERE od PAYPAL_CLIENT_ID in PAYPAL_CLIENT_SECRET s ključi, ki ste jih pravkar prejeli.

3. korak: Inicializirajte modul PayPal.

Podobno kot Stripe, moramo poleg zamenjave tipk v application.yml še vedno inicializirati modul PayPal, da bo lahko uporabil ključe, ki so že nastavljeni v našem ENV spremenljivka. V ta namen ustvarite datoteko v config/initializers/paypal.rb z:

PayPal::SDK.configure( mode: ENV['PAYPAL_ENV'], client_id: ENV['PAYPAL_CLIENT_ID'], client_secret: ENV['PAYPAL_CLIENT_SECRET'], ) PayPal::SDK.logger.level = Logger::INFO

4. korak: V prednji del integrirajte PayPal.

V index.html.haml dodajte to na vrh datoteke:

%script(src='https://www.paypal.com/sdk/js?client-id=#{ENV['PAYPAL_CLIENT_ID']}')

Za razliko od Stripe, PayPal uporablja samo gumb, ki ob kliku odpre varno pojavno okno, kjer se lahko uporabnik prijavi in ​​nadaljuje s plačilom / naročnino. Ta gumb lahko upodobite s klicem metode paypal.Button(PARAM1).render(PARAM2).

  • PARAM1 je objekt s konfiguracijo okolja in dvema funkcijama povratnega klica kot lastnosti: createOrder in onApprove.
  • PARAM2 označuje identifikator elementa HTML, na katerega naj bo pritrjen gumb PayPal.

Torej, še vedno v isti datoteki, zamenjajte komentirano kodo YOUR PAYPAL CODE WILL BE HERE z:

(function setupPaypal() { function isPayment() { return $('[data-charges-and-payments-section] input[name='orders[product_id]']:checked').length } function submitOrderPaypal(chargeID) { var $form = $('#order-details'); // Add a hidden input orders[charge_id] $form.append($('').val(chargeID)); // Set order type $('#order-type').val('paypal'); $form.submit(); } paypal.Buttons({ env: '#{ENV['PAYPAL_ENV']}', createOrder: function() { }, onApprove: function(data) { } }).render('#submit-paypal'); }());

5. korak: Preizkusite svojo prijavo.

Obiščite svojo stran in preverite, ali je gumb PayPal upodobljen, ko kot način plačila izberete PayPal.

PayPal transakcije

Logika transakcij PayPal je za razliko od Stripe nekoliko bolj zapletena, saj vključuje več zahtev, ki izvirajo od sprednjega do zadnjega dela. Zato ta odsek obstaja. Razložil bom bolj ali manj (brez kakršne koli kode), kako delujejo funkcije, opisane v createOrder in onApprove metode bodo uvedene in kaj se pričakuje tudi v zalednih procesih.

Korak 1: Ko uporabnik klikne gumb za oddajo PayPal, se odpre pojavno okno PayPal, ki zahteva uporabniške poverilnice, vendar je v stanju nalaganja. Povratni klic funkcije createOrder je poklican.

Pojavno okno PayPal, stanje nalaganja
Pojavno okno PayPal, stanje nalaganja

2. korak: V tej funkciji bomo izvedli zahtevo do našega zaledja, ki bo ustvarila plačilo / naročnino. To je sam začetek transakcije in stroški še ne bodo zaračunani, zato je transakcija dejansko v v teku država. Naš zadnji del bi nam moral vrniti žeton, ki bo ustvarjen z uporabo modula PayPal (na voljo prek dragulja paypal-rest-sdk

3. korak: Še vedno v createOrder povratni klic, vrnemo ta žeton, ustvarjen v našem zaledju, in če je vse v redu, bo pojavno okno PayPal prikazalo naslednje in zahtevalo uporabniške poverilnice:

Pojavno okno PayPal, poverilnice uporabnika
Pojavno okno PayPal, poverilnice uporabnika

4. korak: Ko se uporabnik prijavi in ​​izbere način plačila, se pojavno okno spremeni v naslednje:

Pojavno okno PayPal, pooblaščena transakcija
Pojavno okno PayPal, pooblaščena transakcija

5. korak: The onApprove zdaj je poklican povratni klic funkcije. Določili smo jo kot naslednjo: onApprove: function(data). The data predmet bo imel podatke o plačilu, da jih bo lahko izvršil. V tem povratnem klicu bo tokrat izvedena še ena zahteva za našo funkcijo zaledja, ki bo posredovala podatkovni objekt, da bo izvršila naročilo PayPal.

6. korak: Naš zadnji del izvede to transakcijo in vrne 200 (če je uspešna).

7. korak: Ko se vrne naš zadnji del, pošljemo obrazec. To je tretja zahteva, ki jo pošiljamo nazaj.

Upoštevajte, da imamo v tem postopku za razliko od Stripe tri zahteve za naš back-end. In stanje zapisov o naročilu bomo ustrezno sinhronizirali:

  • createOrder povratni klic: ustvari se transakcija in ustvari se tudi zapis naročila; zato je v a v teku privzeto.
  • onApprove povratni klic: Transakcija se izvrši in naše naročilo bo nastavljeno kot paypal_executed .
  • Stran z naročilom je oddana: Transakcija je bila že izvedena, zato se nič ne spremeni. Zapis naročila bo spremenil svoje stanje v plačan .

Celoten postopek je opisan v naslednjem grafu:

Transakcije PayPal
Transakcije PayPal

PayPal plačila

PayPal plačila sledijo isti logiki kot Stripe Charges, zato predstavljajo enkratne transakcije, vendar kot je bilo omenjeno v prejšnjem poglavju, imajo drugačno logiko toka. To so spremembe, ki jih bo treba izvesti za obdelavo plačil prek PayPal:

Korak 1: Ustvari nove poti za PayPal in izvrši plačila.

V config/routes.rb dodajte naslednje poti:

post 'orders/paypal/create_payment' => 'orders#paypal_create_payment', as: :paypal_create_payment post 'orders/paypal/execute_payment' => 'orders#paypal_execute_payment', as: :paypal_execute_payment

To bo ustvarilo dve novi poti za ustvarjanje in izvrševanje plačil, ki bosta obravnavani v paypal_create_payment in paypal_execute_payment metode krmilnika naročil.

2. korak: Ustvari storitev PayPal.

Dodajte razred singleton Orders::Paypal ob: app/services/orders/paypal.rb.

Ta služba bo sprva imela tri odgovornosti:

  • The create_payment metoda ustvari plačilo s klicem PayPal::SDK::REST::Payment.new. A žeton se generira in vrne na front-end.
  • The execute_payment metoda izvede plačilo tako, da najprej poišče prejšnji ustvarjeni predmet plačila preko PayPal::SDK::REST::Payment.find(payment_id) ki uporablja plačilni_id kot argument, ki ima enako vrednost kot charge_id shranjena v prejšnjem koraku v predmetu naročila. Po tem pokličemo execute v predmetu plačila z določenim plačnikom kot parametrom. Ta plačnik dobi prednji del, potem ko je uporabnik priskrbel poverilnice in v pojavnem oknu izbral plačilno sredstvo.
  • The finish metoda poišče naročilo po določenem charge_id poizvedovanje po nedavno ustvarjenih naročilih v paypal_executed država. Če je zapis najden, je označen kot plačan.
class Orders::Paypal def self.finish(charge_id) order = Order.paypal_executed.recently_created.find_by(charge_id: charge_id) return nil if order.nil? order.set_paid order end def self.create_payment(order:, product:) payment_price = (product.price_cents/100.0).to_s currency = 'USD' payment = PayPal::SDK::REST::Payment.new({ intent: 'sale', payer: { payment_method: 'paypal' }, redirect_urls: { return_url: '/', cancel_url: '/' }, transactions: [{ item_list: { items: [{ name: product.name, sku: product.name, price: payment_price, currency: currency, quantity: 1 } ] }, amount: { total: payment_price, currency: currency }, description: 'Payment for: #{product.name}' }] }) if payment.create order.token = payment.token order.charge_id = payment.id return payment.token if order.save end end def self.execute_payment(payment_id:, payer_id:) order = Order.recently_created.find_by(charge_id: payment_id) return false unless order payment = PayPal::SDK::REST::Payment.find(payment_id) if payment.execute( payer_id: payer_id ) order.set_paypal_executed return order.save end end

3. korak: V postopku oddaje pokličite storitev PayPal v krmilniku.

Dodajte povratni klic za prepare_new_order pred akcijo paypal_create_payment (ki bo dodan v naslednjem koraku) se zahteva tako, da se v datoteko app/controllers/orders_controller.rb doda naslednje:

class OrdersController

Ponovno v isti datoteki pokličite storitev PayPal pri dejanju oddaje, tako da zamenjate komentirano kodo #PAYPAL WILL BE HANDLED HERE. z naslednjim:

... elsif order_params[:payment_gateway] == 'paypal' @order = Orders::Paypal.finish(order_params[:token]) end ...

4. korak: Ustvarite dejanja za obdelavo zahtev.

Kljub temu v app/controllers/orders_controller.rb datoteko, ustvarite dva nova dejanja (ki bi morala biti javna) za obdelavo zahtev v paypal_create_payment in paypal_execute_payment poti:

  • The paypal_create_payment method: Pokliče našo servisno metodo create_payment. Če se to uspešno vrne, bo vrnilo naročilo žeton ustvaril Orders::Paypal.create_payment.
  • The paypal_execute_payment method: Pokliče našo servisno metodo execute_payment (ki izvrši naša plačila). Če je plačilo uspešno izvedeno, vrne 200.
... def paypal_create_payment result = Orders::Paypal.create_payment(order: @order, product: @product) if result render json: { token: result }, status: :ok else render json: {error: FAILURE_MESSAGE}, status: :unprocessable_entity end end def paypal_execute_payment if Orders::Paypal.execute_payment(payment_id: params[:paymentID], payer_id: params[:payerID]) render json: {}, status: :ok else render json: {error: FAILURE_MESSAGE}, status: :unprocessable_entity end end ...

5. korak: Izvedite funkcije povratnega klica za čelno stran za createOrder in onApprove.

Naj bo paypal.Button.render klic videti tako:

paypal.Buttons({ env: '#{ENV['PAYPAL_ENV']}', createOrder: function() { $('#order-type').val('paypal'); if (isPayment()) { return $.post('#{paypal_create_payment_url}', $('#order-details').serialize()).then(function(data) { return data.token; }); } else { } }, onApprove: function(data) { if (isPayment()) { return $.post('#{paypal_execute_payment_url}', { paymentID: data.paymentID, payerID: data.payerID }).then(function() { submitOrderPaypal(data.paymentID) }); } else { } } }).render('#submit-paypal');

Kot smo že omenili v prejšnjem razdelku, imenujemo paypal_create_payment_url za createOrder povratni klic in paypal_execute_payment_url za onApprove poklicati nazaj. Upoštevajte, da če zadnja zahteva vrne uspeh, oddamo naročilo, ki je tretja zahteva, poslana strežniku.

V createOrder vrne žeton (pridobljen na zadnji strani). V onApprove povratni klic, imamo dve lastnosti, preneseni na naš back-end paymentID in payerID. Ti bodo uporabljeni za izvedbo plačila.

Na koncu opazimo, da imamo dve prazni else klavzule, ker puščam prostor za naslednji razdelek, kjer bomo dodali naročnine na PayPal.

Če obiščete svojo stran po integraciji čelnega odseka JavaScript in izberete PayPal kot plačilno sredstvo, mora biti videti tako:

Indeksna stran po integraciji s PayPal
Indeksna stran po integraciji s PayPal

6. korak: Preizkusite svojo prijavo.

  • Obiščite indeksno stran.
  • Za način plačila izberite izdelek za plačilo / bremenitev in PayPal.
  • Kliknite gumb za oddajo PayPal.
  • V pojavnem oknu PayPal:
    • Uporabite poverilnice za račun kupca, ki ste ga ustvarili.
    • Prijavite se in potrdite svoje naročilo.
    • Pojavno okno se mora zapreti.
  • Preverite, ali ste preusmerjeni na stran za uspeh.
  • Na koncu preverite, ali je bilo naročilo izvedeno v računu PayPal, tako da se prijavite s svojim poslovnim računom na https://www.sandbox.paypal.com/signin in preverjanje armaturne plošče https://www.sandbox.paypal.com/listing/transactions .

Naročnine na PayPal

Načrti / dogovori / naročnine PayPal sledijo isti logiki kot naročnine Stripe in so ustvarjeni za ponavljajoča se plačila. S to vrsto izdelka se uporabniku zaračuna dnevno, tedensko, mesečno ali letno samodejno glede na njegovo konfiguracijo .

Uporabili bomo polje za izdelek paypal_plan_name, da bomo shranili ID paketa, ki ga je predložil PayPal. V tem primeru drugače kot Stripe ne izberemo ID-ja, PayPal pa vrne to vrednost, ki bo uporabljena za posodobitev zadnjega izdelka, ustvarjenega v naši bazi podatkov.

Za ustvarjanje naročnine ne customer podatki se zahtevajo v katerem koli koraku, saj je metoda onApprove verjetno to povezavo obravnava pri osnovni izvedbi. Tako bodo naše tabele ostale enake.

Korak 1: Ustvarite načrt z uporabo API-ja PayPal.

Odprite konzolo z ukazom rails c . Ustvarite naročnino za svoj račun PayPal z:

plan = PayPal::SDK::REST::Plan.new({ name: 'Premium Plan', description: 'Premium Plan', type: 'fixed', payment_definitions: [{ name: 'Premium Plan', type: 'REGULAR', frequency_interval: '1', frequency: 'MONTH', cycles: '12', amount: { currency: 'USD', value: '100.00' } }], merchant_preferences: { cancel_url: 'http://localhost:3000/', return_url: 'http://localhost:3000/', max_fail_attempts: '0', auto_bill_amount: 'YES', initial_fail_amount_action: 'CONTINUE' } }) plan.create plan_update = { op: 'replace', path: '/', value: { state: 'ACTIVE' } } plan.update(plan_update)

2. korak: Posodobite zadnji izdelek v zbirki podatkov paypal_plan_name z vrnjenim plan.id.

Zaženi:

Product.last.update(paypal_plan_name: plan.id)

3. korak: Dodajte poti za naročnino na PayPal.

Dodajte dve novi poti v config/routes.rb:

post 'orders/paypal/create_subscription' => 'orders#paypal_create_subscription', as: :paypal_create_subscription post 'orders/paypal/execute_subscription' => 'orders#paypal_execute_subscription', as: :paypal_execute_subscription

4. korak: Urejajte ustvarjanje in izvajanje v storitvi PayPal.

V Orders::Paypal dodajte še dve funkciji za ustvarjanje in izvajanje naročnin od app/services/orders/paypal.rb:

def self.create_subscription(order:, product:) agreement = PayPal::SDK::REST::Agreement.new({ name: product.name, description: 'Subscription for: #{product.name}', start_date: (Time.now.utc + 1.minute).iso8601, payer: { payment_method: 'paypal' }, plan: { id: product.paypal_plan_name } }) if agreement.create order.token = agreement.token return agreement.token if order.save end end def self.execute_subscription(token:) order = Order.recently_created.find_by(token: token) return false unless order agreement = PayPal::SDK::REST::Agreement.new agreement.token = token if agreement.execute order.charge_id = agreement.id order.set_paypal_executed return order.charge_id if order.save end end

V create_subscription inicializiramo pogodbo s klicem metode PayPal::SDK::REST::Agreement.new in mimo product.paypal_plan_name kot enega od njegovih lastnosti. Nato ga ustvarimo in zdaj bo za ta zadnji objekt nastavljen žeton. Žeton vrnemo tudi na sprednji del.

V execute_subscription najdemo order zapis, ustvarjen v prejšnjem klicu. Po tem inicializiramo nov dogovor, nastavimo žeton tega prejšnjega predmeta in ga izvršimo. Če je ta zadnji korak uspešno izveden, je stanje naročila nastavljeno na paypal_executed . In zdaj se vrnemo na sprednji del ID-ja pogodbe, ki je prav tako shranjen v order.chager_id.

5. korak: Dodajte dejanja za ustvarjanje in izvajanje naročnin v orders_controller.

Spremenite app/controllers/orders_controller.rb. Najprej na vrhu razreda, nato pa posodobite povratni klic prepare_new_order izvršiti tudi pred paypal_create_subscription je poklican:

class OrdersController

Prav tako v isti datoteki dodajte dve javni funkciji, tako da bosta poklicali Orders::Paypal storitev s podobnim tokom, kot ga že imamo pri PayPal plačilih:

... def paypal_create_subscription result = Orders::Paypal.create_subscription(order: @order, product: @product) if result render json: { token: result }, status: :ok else render json: {error: FAILURE_MESSAGE}, status: :unprocessable_entity end end def paypal_execute_subscription result = Orders::Paypal.execute_subscription(token: params[:subscriptionToken]) if result render json: { id: result}, status: :ok else render json: {error: FAILURE_MESSAGE}, status: :unprocessable_entity end end ...

6. korak: Dodajanje obdelovalcev naročnin za createOrder in onApprove povratne klice v sprednjem delu.

Na koncu v index.html.haml zamenjajte paypal.Buttons funkcija z naslednjim, kar bo zapolnilo dve prazni else smo imeli prej:

paypal.Buttons({ env: '#{ENV['PAYPAL_ENV']}', createOrder: function() { $('#order-type').val('paypal'); if (isPayment()) { return $.post('#{paypal_create_payment_url}', $('#order-details').serialize()).then(function(data) { return data.token; }); } else { return $.post('#{paypal_create_subscription_url}', $('#order-details').serialize()).then(function(data) { return data.token; }); } }, onApprove: function(data) { if (isPayment()) { return $.post('#{paypal_execute_payment_url}', { paymentID: data.paymentID, payerID: data.payerID }).then(function() { submitOrderPaypal(data.paymentID) }); } else { return $.post('#{paypal_execute_subscription_url}', { subscriptionToken: data.orderID }).then(function(executeData) { submitOrderPaypal(executeData.id) }); } } }).render('#submit-paypal');

Ustvarjanje in izvajanje naročnin ima podobno logiko kot pri plačilih. Ena razlika je v tem, da pri izvrševanju plačil podatki iz funkcije povratnega klica onApprove že ima paymentID predstavljajo charge_id za oddajo obrazca preko submitOrderPaypal(data.paymentID). Za naročnine dobimo charge_id šele po izvedbi z zahtevo POST na paypal_execute_subscription_url, tako da lahko pokličemo submitOrderPaypal(executeData.id).

7. korak: Preizkusite svojo prijavo.

  • Obiščite indeksno stran.
  • Za plačilno sredstvo izberite naročniški izdelek in PayPal.
  • Kliknite gumb za oddajo PayPal.
  • V pojavnem oknu PayPal:
    • Uporabite poverilnice za račun kupca, ki ste ga ustvarili.
    • Prijavite se in potrdite svoje naročilo.
    • Pojavno okno se mora zapreti.
  • Preverite, ali ste preusmerjeni na stran za uspeh.
  • Na koncu preverite, ali je bilo naročilo izvedeno v računu PayPal, tako da se prijavite s svojim poslovnim računom na https://www.sandbox.paypal.com/signin in preverjanje armaturne plošče https://www.sandbox.paypal.com/listing/transactions .

Zaključek

Po branju tega članka bi morali v svojo aplikacijo Rails vključiti plačila / stroške, pa tudi naročniške transakcije za PayPal in Stripe. Obstaja veliko točk, ki bi jih lahko izboljšali, vendar jih zaradi kratkosti nisem dodal v tem članku. Vse sem organiziral na podlagi predpostavke težavnosti:

  • Preprosteje:
    • Uporabite TLS (Transport Layer Security), da bodo vaše zahteve uporabljale HTTPS.
    • Izvedite konfiguracije proizvodnega okolja za PayPal in Stripe.
    • Dodajte novo stran, da bodo uporabniki lahko dostopali do zgodovine prejšnjih naročil.
  • Srednje:
    • Vračilo kupnine ali preklic naročnine.
    • Zagotovite rešitev za neregistrirana uporabniška plačila.
  • Težje:

Priporočam tudi branje o elementu Stripe Checkout, ki je še en način za integracijo Stripe v sprednji del. Za razliko od Stripe Elements, ki smo ga uporabili v tej vadnici, Stripe Checkout po kliku na gumb (podobno kot PayPal) odpre pojavno okno, kjer uporabnik izpolni podatke o kreditni kartici ALI se odloči za plačilo z Google Pay / Apple Pay https://stripe.com/docs/web .

Priporočilo za drugo obravnavo so varnostne strani za oba plačilna prehoda.

Na koncu hvala za branje tega članka! Lahko tudi preverite mojo Za ta vzorec projekta uporabljen projekt GitHub . Tam sem dodal rspec preskusi, pa tudi med razvojem.

Razumevanje osnov

Kaj je Stripe in kako deluje?

Stripe je podjetje, ki razvija programsko opremo za posameznike ali podjetja za izvajanje zavarovanih plačil prek interneta.

Kakšna je razlika med PayPal in Stripe?

Ponujajo različne aplikacije, ki vključujejo plačila, in imajo različne pristojbine za uporabo njihovih storitev.

Kaj je žeton plačilnega sredstva?

Tokenizacija plačil je postopek za obdelavo občutljivih podatkov uporabnikov in njihovo pretvorbo v žetone, zato ne pride do uhajanja občutljivih podatkov.

Je PayPal plačilni prehod ali procesor?

PayPal ni prehod, temveč popolna trgovska rešitev. Vendar pa uporablja plačilni prehod, imenovan Payflow.

Je Stripe plačilni prehod ali procesor?

Stripe je plačilni prehod, ki obdeluje kartice strank.

Potreba po hitrosti: retrospektiva ApeeScape JavaScript Coding Challenge

Back-End

Potreba po hitrosti: retrospektiva ApeeScape JavaScript Coding Challenge
Najboljši čas za objavo na TikTok za rekordne oglede v letu 2021

Najboljši čas za objavo na TikTok za rekordne oglede v letu 2021

Objava