Share
PayPal är en av de mest populära betalningsplattformar som finns tillgängliga idag av många anledningar. Dess användarvänlighet och dess anslutning till eBay-plattformen är bara toppen av isberget. Medan en av dess mest populära funktioner är möjligheten att helt enkelt logga in på ditt PayPal-konto för att skicka in betalningar, kan köpmän som använder PayPal också acceptera kreditkort direkt som en traditionell butikskonto lösning skulle ge.
PayPal kallar den här lösningen Betalningar Pro, och jag ska visa dig exakt hur du kan hantera kreditkort direkt med PayPals API med hjälp av deras Payments Pro webbservice APIs.
Det första jag tycker om att göra med ett projekt är att skapa en grundläggande struktur för projektet. I så fall är vår struktur väldigt enkel eftersom vårt projekt består av endast 2 filer:
Som du kanske har gissat lagrar vi vår konfigurationsinformation i config.php, och vi hanterar faktiskt bearbetningskoden i process-kredit-card.php.
Vår /includes/config.php filen kommer att hysa våra värden för PayPal API-informationen vi behöver, inklusive slutadressen, API-versionen och vårt API-användarnamn, lösenord och signatur som vi ska använda.
// Ange sandlåda (testläge) till true / false. $ sandbox = TRUE; // Ange PayPal API-version och behörighetsuppgifter. $ api_version = '85 .0 '; $ api_endpoint = $ sandbox? 'https://api-3t.sandbox.paypal.com/nvp': 'https://api-3t.paypal.com/nvp'; $ api_username = $ sandbox? "SANDBOX_USERNAME_GOES_HERE": "LIVE_USERNAME_GOES_HERE"; $ api_password = $ sandbox? "SANDBOX_PASSWORD_GOES_HERE": "LIVE_PASSWORD_GOES_HERE"; $ api_signature = $ sandbox? "SANDBOX_SIGNATURE_GOES_HERE": "LIVE_SIGNATURE_GOES_HERE";
Granska config.php kod, kan du se det först ställer vi in en variabel för $ sandlåda. För tillfället lämnar vi det här SANN eftersom vi vill interagera med PayPals sandbox (test) servrar för utvecklingsändamål. Du måste komma ihåg att ändra detta till FALSK när du är redo att flytta ditt projekt till en live-server.
Därefter, baserat på värdet av $ sandlåda Vi ställer in värden för andra variabler för vår API-information. Du vill bara fylla i dessa platshållare med dina egna uppgifter i enlighet med detta. Nu är vi redo att bygga vårt kreditkortsbehandlingsskript.
Nu kan vi börja bygga vårt process-kredit-card.php sida. Det första vi behöver göra här är med vår config-fil.
Accentsconagua
// Inkludera config-filen require_once ('includes / config.php'); Därefter måste vi bygga en sträng med namnvärdespar som innehåller all den information vi behöver för att skicka PayPal för att kunna bearbeta denna betalning. En sträng med namnvärdespar ser precis ut som något du kan se när du skickar data via URL-parametrar. Vi behöver bara se till att våra parameternamn finns i alla kepsar.
PARAM1 = värde1 & PARAM2 = värde2 & PARAM3 = värde3 ... etc.
Så kanske du tänker på dig själv "Hur vet jag vad jag ska använda för mina variabla namn i min sträng?" Den goda nyheten är PayPal ger mycket bra dokumentation om detta. Vi kan se alla möjliga variabler som vi kan skicka PayPal inklusive kundinformation, beställningsdetaljer och kreditkortsinformation. Några av dessa uppgifter krävs för att kunna bearbeta en betalning, men många av de tillgängliga variablerna är frivilliga. För demonstrationsändamål, behåller vi det här ganska enkelt och skickar bara den information som krävs.
Vi lagrar alla våra förfrågningsparametrar i en array så att vi kan gå igenom denna array för att enkelt generera vår NVP-sträng. Alla förfrågningar kräver som standard följande parametrar:
METOD - Namnet på API-samtalet du gör.ANVÄNDARE - API användarnamnetPWD - API-lösenordetSIGNATUR - API-signaturenVERSION - API-versionenDå kan du referera till PayPal-dokumentationen för alla API-förfrågningar du vill göra för att se vilka andra parametrar som ska ingå. För denna demonstrations skull kommer vår matris att byggas enligt följande.
// Store förfråganparametrar i en array $ request_params = array ('METHOD' => 'DoDirectPayment', 'USER' => $ api_username, 'PWD' => $ api_password, 'SIGNATURE' => $ api_signatur, 'VERSION' = > $ api_version, 'PAYMENTACTION' => 'Försäljning', 'IPADDRESS' => $ _SERVER ['REMOTE_ADDR'], 'CREDITCARDTYPE' => 'MasterCard', 'ACCT' => '5522340006063638', 'EXPDATE' => ' 022013 ',' CVV2 '=' '456', 'FIRSTNAME' => 'Tester', 'LASTNAME' => 'Testerson', 'STREET' => '707 W. Bay Drive', 'CITY' => 'Largo ',' STATE '=>' FL ',' COUNTRYCODE '=>' US ',' ZIP '=>' 33770 ',' AMT '=>' 100,00 ',' CURRENCYCODE '=>' USD ',' DESC ' => 'Testa betalningar Pro'); Du märker att vi använder våra config variabler från config.php, och sedan laddar jag helt enkelt statiska data för de andra värdena. I ett standardprojekt kommer du troligtvis att fylla dessa värden med formulärdata, sessionsdata eller någon annan form av dynamisk data.
Nu kan vi helt enkelt gå igenom denna array för att generera vår NVP-sträng.
// Loop genom $ request_params array för att generera NVP-strängen. $ nvp_string = =; föreach ($ request_params som $ var => $ val) $ nvp_string. = '&'. $ var. '='. urlencode ($ val);
Värdet av $ nvp_string är nu:
METOD = DoDirectPayment&USER = sandbo ***** e.com&PWD = 12 *** 74&SIGNATURE = AiKZ ****** 6W18v&VERSION = 85,0&PAYMENTACTION = Sale&IPADDRESS = 72.135.111.9&CREDITCARDTYPE = Master&ACCT = 5522340006063638&EXPDATE = 022.013&CVV2 = 456&FIRSTNAME = Tester&LASTNAME = Testerson&STREET = 707 + W. + Bay + Drive&CITY = Largo&STATE = FL&COUNTRY = US&ZIP = 33770&AMT = 100,00&CurrencyCode = USD&DESC = Testning + Betalningar + Pro
Denna sträng är vad vi skickar till PayPal för vår begäran.
Nu när vår NVP-sträng är klar att gå måste vi skicka den till PayPal-servern som ska behandlas i enlighet med detta. För att göra detta använder vi PHP: s CURL-metoder.
// Skicka NVP-sträng till PayPal och lagra svar $ curl = curl_init (); curl_setopt ($ curl, CURLOPT_VERBOSE, 1); curl_setopt ($ curl, CURLOPT_SSL_VERIFYPEER, FALSE); curl_setopt ($ curl, CURLOPT_TIMEOUT, 30); curl_setopt ($ curl, CURLOPT_URL, $ api_endpoint); curl_setopt ($ curl, CURLOPT_RETURNTRANSFER, 1); curl_setopt ($ curl, CURLOPT_POSTFIELDS, $ nvp_string); $ result = curl_exec ($ curl); curl_close ($ curl);
Här kan du se att vi har setup CURL med några enkla alternativ och vi använder vår $ api_endpoint och $ nvp_string variabler i enlighet därmed.
Dessa data kommer att skickas över till PayPal och vi kommer att få API-svaret tillbaka i vår $ result variabel så att vi kan se resultatet och skicka användaren till en framgångsrik eller fel sida baserat på huruvida samtalet lyckades eller inte.
Värdet som vi kommer tillbaka i $ result från föregående steg blir en NVP-sträng precis som den vi genererade och skickade till PayPal. När vi kör vårt nuvarande skript får vi ett framgångsrikt svar som ser ut så här:
TIMESTAMP = 2012% 2d04% 2d16T07% 3a59% 3a36Z & CORRELATIONID = 9eb40cd84a7d3 & ACK = Framgång & VERSION = 85% 2E0 & BYGG = 2.764.190 & AMT = 100% 2e00 & currencyCode = USD & AVSCODE = X & CVV2MATCH = M & transactionId = 160896645A8111040
Ett enkelt sätt att analysera resultatet är att använda PHP parse_str () fungera. Detta laddar alla svardata till PHP-variabler som matchar de namn och värden som returneras i svaret. Till exempel om vi gör följande:
// Parsa API-svaret $ nvp_response_array = parse_str ($ result);
Vi skulle sluta med tillgång till följande PHP-variabler:
$ TIMESTAMP$ CORRELATIONID$ ACK$ VERSION$ BUILD$ AMT$ currencyCode$ AVSCODE$ CVV2MATCH$ transactionId Vi kan sedan fortsätta använda dessa variabler för att presentera informationen tillbaka till vår kund, fylla i värden i e-kvitton som vi skulle vilja generera, uppdatera databasinformation eller något annat som vi behöver göra när en order är klar.
De $ ACK värdet är vad som kommer att berätta om API-samtalet var framgångsrikt eller inte. Värden för $ ACK kan vara:
FramgångSuccessWithWarningFel FailureWithWarningDu kan enkelt omdirigera din användare där de behöver gå och visa dem information baserat på detta värde.
Ett felaktigt API-samtal kommer att resultera i ytterligare parametrar som ger information om varför transaktionen misslyckades. Om jag kör detta test igen med ett ogiltigt kreditkortsnummer får jag till exempel följande svar från PayPal:
TIMESTAMP = 2012% 2d04% 2d16T08% 3a08% 3a52Z & CORRELATIONID = 590d41dbb31e0 & ACK = Fel & VERSION = 85% 2E0 & BYGG = 2.764.190 & L_ERRORCODE0 = 10527 & L_SHORTMESSAGE0 = Ogiltig% 20Data & L_LONGMESSAGE0 = Denna% 20transaction% 20cannot% 20be% 20processed% 2e% 20Skicka% 20enter% 20a% 20valid% 20credit% 20card% 20number% 20and% 20type% 2e & L_SEVERITYCODE0 = fel & AMT = 100% 2e00 & currencyCode = USD
Nu när vi använder parse_str () vi slutar med följande PHP-variabler som är tillgängliga för oss:
$ TIMESTAMP$ CORRELATIONID$ ACK$ VERSION$ BUILD$ L_ERRORCODE0$ L_SHORTMESSAGE0$ L_LONGMESSAGE0$ L_SEVERITYCODE0$ AMT$ currencyCodeI detta fall, $ ACK visar ett misslyckande så vi vet att samtalet inte lyckades och vi kan kontrollera felparametrarna för mer information om vad som gick fel.
Medan den tidigare metoden för att analysera svaret fungerar bra, föredrar jag personligen att arbeta med datarrayer. Som sådan använder jag följande funktion för att konvertera PayPal-svaret till en array.
// Funktion för att konvertera NTP-sträng till en array-funktion NVPToArray ($ NVPString) $ proArray = array (); medan (strlen ($ NVPString)) // namn $ keypos = strpos ($ NVPString, '='); $ keyval = substr ($ NVPString, 0, $ keypos); // värde $ valuepos = strpos ($ NVPString, '&')? strpos ($ NVPString, '&'): strlen ($ NVPString); $ valval = substr ($ NVPString, $ keypos + 1, $ valuepos- $ keypos-1); // avkodning resp. $ proArray [$ keyval] = urldecode ($ valval); $ NVPString = substr ($ NVPString, $ valuepos + 1, strlen ($ NVPString)); returnera $ proArray;
Detta låter mig se alla svardata som finns tillgängliga genom att bara titta på innehållet i arrayen:
Om jag kör mitt skript igen nu får jag följande resultat på skärmen:
Array ([TIMESTAMP] => 2012-04-16T08: 15: 41Z [CORRELATIONID] => 9a652cbabfdd9 [ACK] => Framgång [VERSION] => 85.0 [BUILD] => 2764190 [AMT] => 100,00 [CURRENCYCODE] = > USD [AVSCODE] => X [CVV2MATCH] => M [TRANSACTIONID] => 6VR832690S591564M)
Och om jag skulle ge ett fel igen får jag följande:
Array ([TIMESTAMP] => 2012-04-16T08: 18: 46Z [CORRELATIONID] => 2db182b912a9 [ACK] => Misslyckande [VERSION] => 85.0 [BUILD] => 2764190 [L_ERRORCODE0] => 10527 [L_SHORTMESSAGE0] = > Invalid data [L_LONGMESSAGE0] => Denna transaktion kan inte behandlas. Ange ett giltigt kreditkortsnummer och skriv. [L_SEVERITYCODE0] => Fel [AMT] => 100,00 [CURRENCYCODE] => USD)
Du kan se att det här är en trevlig, lätt att navigera resultatmatris som innehåller allt vi kan behöva för att flytta användaren genom vår applikation och uppdatera datakällor efter behov.
Som du kan se är behandling av kreditkort med PayPal Payments Pro faktiskt ett mycket enkelt förfarande. Det handlar bara om några vanliga steg för att arbeta med API-webbtjänster, och en grundläggande kunskap om att arbeta med array-data kan också hjälpa till.
Lycka till och glad kodning!
