Source for file paypal_types.php

Documentation is available at paypal_types.php

  1. <?php
  2.  
  3. /**
  4.  * Preparation of WebService DataTypes
  5.  * 
  6.  * Copyright (C) 2007 Israel Ekpo
  7.  * 
  8.  * Contains the class which has methods that generates a list of datatypes (arrays) used by the webs service.
  9.  * Most of the datatypes are passed to the SoapClient->__soapCall() method as multi-dimensional arrays.
  10.  * 
  11.  * @package PaypalTypes
  12.  * @author Israel Ekpo <israelekpo@sourceforge.net>
  13.  * @copyright Copyright 2007, Israel Ekpo
  14.  * @version 0.1.0
  15.  * @license http://phppaypalpro.sourceforge.net/LICENSE.txt BSD License
  16.  * @filesource
  17.  */
  18.  
  19. /**
  20.  * This class contains the list of all the Data Types used when contacting the Paypal webservice
  21.  * 
  22.  * @package PaypalTypes
  23.  * @author Israel Ekpo <israelekpo@sourceforge.net>
  24.  * @copyright Copyright 2007, Israel Ekpo
  25.  * @license http://phppaypalpro.sourceforge.net/LICENSE.txt BSD License
  26.  * @version 0.1.0
  27.  * @filesource
  28.  */
  29. class PayPalTypes
  30. {   
  31.     /**
  32.      * Formats the Amount according to the BasicAmountType
  33.      *
  34.      * This method creates a classical example of an element that has an attribute.
  35.      * For example <element attribute1='attr1' attribute2='attr2'>value</element>
  36.      * will be created as array('_' => 'value', 'attr1' => 'attribute1', 'attr2' => 'attribute2');
  37.      * 
  38.      * @param string $amount 
  39.      * @param string $currencyID 
  40.      * @usedby PaypalTypes::PaymentDetailsType()
  41.      * @usedby PaypalTypes::PaymentDetailsItemType()
  42.      * @return BasicAmountType 
  43.      */
  44.     static public function BasicAmountType($amount = '0.00', $currencyID = 'USD')
  45.     {
  46.         $BasicAmountType['_'] = number_format($amount, 2);
  47.         $BasicAmountType['currencyID'] = $currencyID;
  48.         
  49.         return $BasicAmountType;
  50.     }
  51.     
  52.     /**
  53.      * Prepares the AddressType
  54.      * 
  55.      * This method is used to generate the AddressType for Payment information.
  56.      *
  57.      * @param string $Name 
  58.      * @param string $Street1 
  59.      * @param string $Street2 
  60.      * @param string $CityName 
  61.      * @param string $StateOrProvince 
  62.      * @param string $PostalCode 
  63.      * @param string $Country 
  64.      * @param string $Phone 
  65.      * @return AddressType 
  66.      */
  67.     static public function AddressType($Name = '', $Street1 = '', $Street2 = '', $CityName = '', $StateOrProvince = '', $PostalCode = '', $Country = '', $Phone = '')
  68.     {
  69.         $AddressType['Name'] = $Name;
  70.         $AddressType['Street1'] = $Street1;
  71.         $AddressType['Street2'] = $Street2;
  72.         $AddressType['CityName'] = $CityName;
  73.         $AddressType['StateOrProvince'] = $StateOrProvince;
  74.         $AddressType['Country'] = $Country;
  75.         $AddressType['PostalCode'] = $PostalCode;
  76.         $AddressType['Phone'] = $Phone;
  77.         
  78.         return $AddressType;
  79.     }
  80.     
  81.     /**
  82.      * Prepares the PersonNameType
  83.      * 
  84.      * The person name type is used to format the name information for onward inclusion in the SOAP message.
  85.      *
  86.      * @param string $Salutation 
  87.      * @param string $FirstName 
  88.      * @param string $MiddleName 
  89.      * @param string $LastName 
  90.      * @param string $Suffix 
  91.      * @return PersonNameType 
  92.      */
  93.     static public function PersonNameType($Salutation = '', $FirstName = '', $MiddleName = '', $LastName = '', $Suffix = '')
  94.     {
  95.         if ($Salutation)
  96.         {
  97.             $PersonNameType['Salutation'] = $Salutation;
  98.         }
  99.         
  100.         $PersonNameType['FirstName'] = $FirstName;
  101.         
  102.         if ($MiddleName)
  103.         {
  104.             $PersonNameType['MiddleName'] = $MiddleName;
  105.         }
  106.         
  107.         $PersonNameType['LastName']  = $LastName;
  108.         
  109.         if ($Suffix)
  110.         {
  111.             $PersonNameType['Suffix'] = $Suffix;
  112.         }
  113.         
  114.         return $PersonNameType;
  115.     }
  116.     
  117.     /**
  118.      * Prepares the PayerInfoType
  119.      *
  120.      * The PayerInfoType uses the AddressType and PersonNameType to generate a multi-dimensional array
  121.      * that will in turn be used as part of a SOAP message.
  122.      * 
  123.      * @param EmailAddressType $Payer e.g buyer@gmail.com
  124.      * @param string $PayerID 
  125.      * @param string $PayerStatus verified, unverified
  126.      * @param PersonNameType $PayerName 
  127.      * @param string $PayerCountry 
  128.      * @param string $PayerBusiness 
  129.      * @param AddressType $Address 
  130.      * @param string $ContactPhone 
  131.      * @return PayerInfoType 
  132.      */
  133.     static public function PayerInfoType($Payer = '', $PayerID = '', $PayerStatus = 'verified', $PayerName, $PayerCountry= 'US', $PayerBusiness = '', $Address, $ContactPhone = '')
  134.     {
  135.         $PayerInfoType['Payer'] = $Payer;
  136.         $PayerInfoType['PayerID'] = $PayerID;
  137.         $PayerInfoType['PayerStatus'] = $PayerStatus;
  138.         $PayerInfoType['PayerName'] = $PayerName;
  139.         $PayerInfoType['PayerCountry'] = $PayerCountry;
  140.         
  141.         if ($PayerBusiness)
  142.         {
  143.             $PayerInfoType['PayerBusiness'] = $PayerBusiness;
  144.         }
  145.         
  146.         $PayerInfoType['Address'] = $Address;
  147.         
  148.         if ($ContactPhone)
  149.         {
  150.             $PayerInfoType['ContactPhone'] = $ContactPhone;
  151.         }
  152.         
  153.         return $PayerInfoType;
  154.     }
  155.     
  156.     /**
  157.      * Makes the CreditCardDetailsType
  158.      * 
  159.      * This is a very essential data type because it has to be formatted correctly. This method is used to
  160.      * generate an array that is going to be part of the payment details submitted to paypal.
  161.      *
  162.      * @param string $CreditCardType Visa,MasterCard,Amex,Discover,Solo,Switch
  163.      * @param string $CreditCardNumber 
  164.      * @param int $ExpMonth 
  165.      * @param int $ExpYear 
  166.      * @param PayerInfoType $CardOwner 
  167.      * @param string $CVV2 
  168.      * @return CreditCardDetailsType 
  169.      */
  170.     static public function CreditCardDetailsType($CreditCardType, $CreditCardNumber, $ExpMonth, $ExpYear, $CardOwner, $CVV2 = '')
  171.     {
  172.         $CreditCardDetailsType['CreditCardType'] = $CreditCardType;
  173.         $CreditCardDetailsType['CreditCardNumber'] = $CreditCardNumber;
  174.         $CreditCardDetailsType['ExpMonth'] = $ExpMonth;
  175.         $CreditCardDetailsType['ExpYear'] = $ExpYear;
  176.         $CreditCardDetailsType['CardOwner'] = $CardOwner;
  177.         
  178.         if($CVV2)
  179.         {
  180.             $CreditCardDetailsType['CVV2'] = $CVV2;
  181.         }
  182.         
  183.         return $CreditCardDetailsType;
  184.     }
  185.     
  186.     /**
  187.      * Makes PaymentDetailsItemType
  188.      *
  189.      * This generates details about a particular payment item. An array is returned which contains the name, quantity
  190.      * and amound of each item added to the payment.
  191.      * 
  192.      * @param string $Name 
  193.      * @param string $Number 
  194.      * @param integer $Quantity 
  195.      * @param BasicAmountType $Tax 
  196.      * @param BasicAmountType $Amount 
  197.      * @param string $CurrencyID 
  198.      * @return PaymentDetailsItemType 
  199.      */
  200.     static public function PaymentDetailsItemType($Name = '', $Number = '', $Quantity = 1, $Tax = '', $Amount = '', $CurrencyID = 'USD')
  201.     {
  202.         $PaymentDetailsItemType['Name'] = $Name;
  203.         $PaymentDetailsItemType['Number'] = $Number;
  204.         $PaymentDetailsItemType['Quantity'] = $Quantity;
  205.         
  206.         if ($Tax)
  207.         {
  208.             $PaymentDetailsItemType['Tax'] = self::BasicAmountType($Tax, $CurrencyID);
  209.         }
  210.         
  211.         if ($Amount)
  212.         {
  213.             $PaymentDetailsItemType['Amount'] = self::BasicAmountType($Amount, $CurrencyID);
  214.         }
  215.         
  216.         return $PaymentDetailsItemType;
  217.     }
  218.     
  219.     /**
  220.      * Creates the PaymentDetailsType
  221.      *
  222.      * This is a critical part of the DoDirectPayment and DoExpressCheckOutPayment operations.
  223.      * The payment details is an overall summary of the payment to be sent to the paypal web service.
  224.      * 
  225.      * @param BasicAmountType $OrderTotal 
  226.      * @param BasicAmountType $ItemTotal 
  227.      * @param BasicAmountType $ShippingTotal 
  228.      * @param BasicAmountType $HandlingTotal 
  229.      * @param BasicAmountType $TaxTotal 
  230.      * @param string $OrderDescription 
  231.      * @param string $Custom 
  232.      * @param string $InvoiceID 
  233.      * @param string $ButtonSource 
  234.      * @param string $NotifyURL Paypal IPN URL
  235.      * @param AddressType $ShipToAddress 
  236.      * @param PaymentDetailsItemType $PaymentDetailsItem 
  237.      * @param string $CurrencyID 
  238.      * @return PaymentDetailsType 
  239.      */
  240.     static public function PaymentDetailsType($OrderTotal, $ItemTotal ='0.00', $ShippingTotal = '0.00', $HandlingTotal = '0.00', $TaxTotal = '0.00', $OrderDescription = '', $Custom = '', $InvoiceID = '', $ButtonSource = '', $NotifyURL = '', $ShipToAddress = '', $PaymentDetailsItem = array(), $CurrencyID= 'USD')
  241.     {
  242.         $PaymentDetailsType['OrderTotal'] = self::BasicAmountType($OrderTotal, $CurrencyID);
  243.         $PaymentDetailsType['ItemTotal'] = self::BasicAmountType($ItemTotal, $CurrencyID);
  244.         $PaymentDetailsType['ShippingTotal'] = self::BasicAmountType($ShippingTotal, $CurrencyID);
  245.         $PaymentDetailsType['HandlingTotal'] = self::BasicAmountType($HandlingTotal, $CurrencyID);
  246.         $PaymentDetailsType['TaxTotal'] = self::BasicAmountType($TaxTotal, $CurrencyID);
  247.         $PaymentDetailsType['OrderDescription'] = $OrderDescription;
  248.         $PaymentDetailsType['Custom'] = $Custom;
  249.         $PaymentDetailsType['InvoiceID'] = $InvoiceID;
  250.         $PaymentDetailsType['ButtonSource'] = $ButtonSource;
  251.         $PaymentDetailsType['NotifyURL'] = $NotifyURL;
  252.         $PaymentDetailsType['ShipToAddress'] = $ShipToAddress;
  253.         $PaymentDetailsType['PaymentDetailsItem'] = $PaymentDetailsItem;
  254.  
  255.         return $PaymentDetailsType;
  256.     }
  257.     
  258.     /**
  259.      * Prepares the DoDirectPaymentRequestDetailsType
  260.      *
  261.      * This basically returns a multi-dimensional array with the Payment Action. Credit Card information, User IP
  262.      * address and the merchant's session id.
  263.      * 
  264.      * @param string $PaymentAction This could be a Sale or Order.
  265.      * @param PaymentDetailsType $PaymentDetails 
  266.      * @param CreditCardDetailsType $CreditCard 
  267.      * @param string $IPAddress 
  268.      * @param string $MerchantSessionId 
  269.      * @return DoDirectPaymentRequestDetailsType 
  270.      */
  271.     static public function DoDirectPaymentRequestDetailsType($PaymentAction, $PaymentDetails, $CreditCard, $IPAddress, $MerchantSessionId)
  272.     {
  273.         $DoDirectPaymentRequestDetailsType['PaymentAction'] = $PaymentAction;
  274.         $DoDirectPaymentRequestDetailsType['PaymentDetails'] = $PaymentDetails;
  275.         $DoDirectPaymentRequestDetailsType['CreditCard'] = $CreditCard;
  276.         $DoDirectPaymentRequestDetailsType['IPAddress'] = $IPAddress;
  277.         $DoDirectPaymentRequestDetailsType['MerchantSessionId'] = $MerchantSessionId;
  278.         
  279.         return $DoDirectPaymentRequestDetailsType;
  280.     }
  281.     
  282.     /**
  283.      * Prepares the SetExpressCheckoutRequestDetailsType
  284.      * 
  285.      * This is an array with the Amount, Return URL, Cancellation URL and Payment Action (Sale or Order)
  286.      *
  287.      * @param BasicAmountType $OrderTotal 
  288.      * @param string $ReturnURL 
  289.      * @param string $CancelURL 
  290.      * @param string $PaymentAction Sale or Order
  291.      * @return SetExpressCheckoutRequestDetailsType 
  292.      */
  293.     static public function SetExpressCheckoutRequestDetailsType($OrderTotal, $ReturnURL, $CancelURL, $PaymentAction, $currencyID = 'USD')
  294.     {
  295.         $SetExpressCheckoutRequestDetailsType['OrderTotal'] = self::BasicAmountType($OrderTotal, $currencyID);
  296.         $SetExpressCheckoutRequestDetailsType['ReturnURL'] = $ReturnURL;
  297.         $SetExpressCheckoutRequestDetailsType['CancelURL'] = $CancelURL;
  298.         $SetExpressCheckoutRequestDetailsType['PaymentAction'] = $PaymentAction;
  299.         
  300.         return $SetExpressCheckoutRequestDetailsType;
  301.     }
  302.     
  303.     /**
  304.      * Makes the DoExpressCheckoutPaymentRequestDetailsType
  305.      *
  306.      * This returns the Payment action, Token value, Payer ID and Payment details as a multi-dimensional array.
  307.      * 
  308.      * @param string $PaymentAction Order or Sale
  309.      * @param string $Token 
  310.      * @param string $PayerID 
  311.      * @param PaymentDetailsType $PaymentDetails 
  312.      * @return DoExpressCheckoutPaymentRequestDetailsType 
  313.      */
  314.     static public function DoExpressCheckoutPaymentRequestDetailsType($PaymentAction, $Token, $PayerID, $PaymentDetails)
  315.     {
  316.         $DoExpressCheckoutPaymentRequestDetailsType['PaymentAction'] = $PaymentAction;
  317.         $DoExpressCheckoutPaymentRequestDetailsType['Token'] = $Token;
  318.         $DoExpressCheckoutPaymentRequestDetailsType['PayerID'] = $PayerID;
  319.         $DoExpressCheckoutPaymentRequestDetailsType['PaymentDetails'] = $PaymentDetails;
  320.         
  321.         return $DoExpressCheckoutPaymentRequestDetailsType;
  322.     }
  323.     
  324.     /**
  325.      * Makes the UserIdPasswordType
  326.      *
  327.      * This prepares the authentication message to be passed to paypal. It is an array
  328.      * with the Username, Password and Signature of the user. If the payment is being made on behalf of
  329.      * another account then the username of that account has to be passed as the subject.
  330.      * 
  331.      * @param string $Username 
  332.      * @param string $Password 
  333.      * @param string $Signature 
  334.      * @param string $Subject 
  335.      * @return UserIdPasswordType 
  336.      */
  337.     static public function UserIdPasswordType($Username = '', $Password = '', $Signature = '', $Subject= '')
  338.     {
  339.         
  340.        $UserIdPasswordType['Username'] = $Username;
  341.        $UserIdPasswordType['Password'] = $Password;
  342.        $UserIdPasswordType['Signature'] = $Signature;
  343.        
  344.        if ($Subject)
  345.        {
  346.            $UserIdPasswordType['Subject'] = $Subject;
  347.        }
  348.        
  349.        return $UserIdPasswordType;
  350.     }
  351.     
  352.     /**
  353.      * Returns the date in the ISO 8601 format
  354.      *
  355.      * Generates the ISO 8601 format using the UNIX timestamp supplied. Like 2007-02-02T01:36:06-05:00
  356.      * which is basically the year, month, day, 24-hour format, minutes, seconds and time zone like -05:00 for EST
  357.      * 
  358.      * @param integer $timeStamp the Unix Timestamp
  359.      * @return string 
  360.      */
  361.     static public function dateTimeType($timeStamp = 0)
  362.     {
  363.         $timeStamp = (int) $timeStamp;
  364.         
  365.         if (!$timeStamp)
  366.         {
  367.             return date('c');
  368.         }
  369.         else 
  370.         {
  371.             return date('c', $timeStamp);
  372.         }
  373.     }
  374.     
  375.     /**
  376.      * Generates the TransactionSearchRequestType
  377.      * 
  378.      * Prepares a multi-dimensional array to be used in the search.
  379.      *
  380.      * @uses self::dateTimeType
  381.      * @param integer $StartDate UNIXTIMESTAMP
  382.      * @param intefer $EndDate UNIXTIMESTAMP
  383.      * @param string $PayerEmail 
  384.      * @param string $ReceiverEmail 
  385.      * @param string $ReceiptID 
  386.      * @param string $TransactionID 
  387.      * @param string $PayerName 
  388.      * @param string $AuctionItemNumber 
  389.      * @param string $InvoiceID 
  390.      * @param string $CardNumber 
  391.      * @param string $TransactionClass 
  392.      * @param BasicAmountType $Amount 
  393.      * @param string $CurrencyCode 
  394.      * @param string $Status 
  395.      * @return TransactionSearchRequestType 
  396.      */
  397.     static public function TransactionSearchRequestType($StartDate, $EndDate = 0, $PayerEmail = '', $ReceiverEmail = '', $ReceiptID = '', $TransactionID = '', $PayerName = '', $AuctionItemNumber = '', $InvoiceID = '', $CardNumber = '', $TransactionClass = '', $Amount = '', $CurrencyCode = '', $Status = '', $currencyID = 'USD')
  398.     {
  399.         $TransactionSearchRequestType['StartDate'] = self::dateTimeType($StartDate);
  400.         
  401.         if ($EndDate)
  402.         {
  403.             $TransactionSearchRequestType['EndDate'] = self::dateTimeType($EndDate);
  404.         }
  405.         
  406.         if ($PayerEmail)
  407.         {
  408.             $TransactionSearchRequestType['Payer'] = $PayerEmail;
  409.         }
  410.         
  411.         if ($ReceiverEmail)
  412.         {
  413.             $TransactionSearchRequestType['Receiver'] = $ReceiverEmail;
  414.         }
  415.         
  416.         if ($ReceiptID)
  417.         {
  418.             $TransactionSearchRequestType['ReceiptID'] = $ReceiptID;
  419.         }
  420.                 
  421.         if ($TransactionID)
  422.         {
  423.             $TransactionSearchRequestType['TransactionID'] = $TransactionID;
  424.         }
  425.         
  426.         if ($PayerName)
  427.         {
  428.             $TransactionSearchRequestType['PayerName'] = $PayerName;
  429.         }
  430.         
  431.         if ($AuctionItemNumber)
  432.         {
  433.             $TransactionSearchRequestType['AuctionItemNumber'] = $AuctionItemNumber;
  434.         }
  435.                 
  436.         if ($InvoiceID)
  437.         {
  438.             $TransactionSearchRequestType['InvoiceID'] = $InvoiceID;
  439.         }
  440.         
  441.         if ($CardNumber)
  442.         {
  443.             $TransactionSearchRequestType['CardNumber'] = $CardNumber;
  444.         }
  445.         
  446.         if ($TransactionClass)
  447.         {
  448.             $TransactionSearchRequestType['TransactionClass'] = $TransactionClass; 
  449.         }
  450.         
  451.         if ($Amount)
  452.         {
  453.             $TransactionSearchRequestType['Amount'] = self::BasicAmountType($Amount, $currencyID);
  454.         }
  455.  
  456.         if ($CurrencyCode)
  457.         {
  458.             $TransactionSearchRequestType['CurrencyCode'] = $CurrencyCode;
  459.         }
  460.         
  461.         if ($Status)
  462.         {
  463.             $TransactionSearchRequestType['Status'] = $Status;
  464.         }
  465.         
  466.         return $TransactionSearchRequestType;       
  467.     }
  468. }
  469. ?>

Documentation generated on Sat, 03 Feb 2007 20:59:05 -0800 by phpDocumentor 1.3.1