FM / Braintree

/home/desid573/public_html/app/braintree/lib/Braintree/

/home/desid573/public_html/app/braintree/lib/Braintree

Name	Size	Mode	Actions
Dispute/	-	0755	rm
Error/	-	0755	rm
Exception/	-	0755	rm
MerchantAccount/	-	0755	rm
Result/	-	0755	rm
Subscription/	-	0755	rm
Test/	-	0755	rm
Transaction/	-	0755	rm
Xml/	-	0755	rm
AccountUpdaterDailyReport.php	1006	0644	edit dl rm
AchMandate.php	1251	0644	edit dl rm
AddOn.php	1015	0644	edit dl rm
AddOnGateway.php	952	0644	edit dl rm
Address.php	3993	0644	edit dl rm
AddressGateway.php	9073	0644	edit dl rm
AmexExpressCheckoutCard.php	2326	0644	edit dl rm
AndroidPayCard.php	2633	0644	edit dl rm
ApplePayCard.php	2866	0644	edit dl rm
ApplePayGateway.php	2055	0644	edit dl rm
ApplePayOptions.php	589	0644	edit dl rm
AuthorizationAdjustment.php	830	0644	edit dl rm
Base.php	1825	0644	edit dl rm
BinData.php	960	0644	edit dl rm
ClientToken.php	1149	0644	edit dl rm
ClientTokenGateway.php	3279	0644	edit dl rm
CoinbaseAccount.php	2722	0644	edit dl rm
Collection.php	3321	0644	edit dl rm
Configuration.php	17551	0644	edit dl rm
ConnectedMerchantPayPalStatusChanged.php	873	0644	edit dl rm
ConnectedMerchantStatusTransitioned.php	868	0644	edit dl rm
CredentialsParser.php	4231	0644	edit dl rm
CreditCard.php	10336	0644	edit dl rm
CreditCardGateway.php	15270	0644	edit dl rm
CreditCardVerification.php	2168	0644	edit dl rm
CreditCardVerificationGateway.php	2304	0644	edit dl rm
CreditCardVerificationSearch.php	1501	0644	edit dl rm
Customer.php	13482	0644	edit dl rm
CustomerGateway.php	21473	0644	edit dl rm
CustomerSearch.php	2674	0644	edit dl rm
Descriptor.php	228	0644	edit dl rm
Digest.php	1603	0644	edit dl rm
Disbursement.php	1748	0644	edit dl rm
DisbursementDetails.php	670	0644	edit dl rm
Discount.php	906	0644	edit dl rm
DiscountGateway.php	744	0644	edit dl rm
Dispute.php	6074	0644	edit dl rm
DisputeGateway.php	8649	0644	edit dl rm
DisputeSearch.php	1851	0644	edit dl rm
DocumentUpload.php	1529	0644	edit dl rm
DocumentUploadGateway.php	1843	0644	edit dl rm
EndsWithNode.php	437	0644	edit dl rm
EqualityNode.php	247	0644	edit dl rm
EuropeBankAccount.php	1693	0644	edit dl rm
Exception.php	231	0644	edit dl rm
FacilitatedDetails.php	794	0644	edit dl rm
FacilitatorDetails.php	823	0644	edit dl rm
Gateway.php	4762	0644	edit dl rm
GrantedPaymentInstrumentUpdate.php	2082	0644	edit dl rm
GraphQL.php	1145	0644	edit dl rm
Http.php	9377	0644	edit dl rm
IbanBankAccount.php	1415	0644	edit dl rm
IdealPayment.php	2362	0644	edit dl rm
IdealPaymentGateway.php	2897	0644	edit dl rm
Instance.php	1810	0644	edit dl rm
IsNode.php	407	0644	edit dl rm
KeyValueNode.php	409	0644	edit dl rm
LocalPaymentCompleted.php	1700	0644	edit dl rm
MasterpassCard.php	4393	0644	edit dl rm
Merchant.php	952	0644	edit dl rm
MerchantAccount.php	2612	0644	edit dl rm
MerchantAccountGateway.php	5761	0644	edit dl rm
MerchantGateway.php	1331	0644	edit dl rm
Modification.php	531	0644	edit dl rm
MultipleValueNode.php	905	0644	edit dl rm
MultipleValueOrTextNode.php	988	0644	edit dl rm
OAuthAccessRevocation.php	577	0644	edit dl rm
OAuthCredentials.php	742	0644	edit dl rm
OAuthGateway.php	3885	0644	edit dl rm
OAuthResult.php	721	0644	edit dl rm
PaginatedCollection.php	2822	0644	edit dl rm
PaginatedResult.php	659	0644	edit dl rm
PartialMatchNode.php	412	0644	edit dl rm
PartnerMerchant.php	909	0644	edit dl rm
PaymentInstrumentType.php	755	0644	edit dl rm
PaymentMethod.php	980	0644	edit dl rm
PaymentMethodGateway.php	9642	0644	edit dl rm
PaymentMethodNonce.php	1633	0644	edit dl rm
PaymentMethodNonceGateway.php	1550	0644	edit dl rm
PaymentMethodParser.php	2251	0644	edit dl rm
PayPalAccount.php	2903	0644	edit dl rm
PayPalAccountGateway.php	5170	0644	edit dl rm
Plan.php	1941	0644	edit dl rm
PlanGateway.php	820	0644	edit dl rm
ProcessorResponseTypes.php	332	0644	edit dl rm
RangeNode.php	782	0644	edit dl rm
ResourceCollection.php	3415	0644	edit dl rm
RevokedPaymentMethodMetadata.php	1427	0644	edit dl rm
RiskData.php	743	0644	edit dl rm
SamsungPayCard.php	4160	0644	edit dl rm
SettlementBatchSummary.php	1131	0644	edit dl rm
SettlementBatchSummaryGateway.php	2840	0644	edit dl rm
SignatureService.php	462	0644	edit dl rm
Subscription.php	5488	0644	edit dl rm
SubscriptionGateway.php	7535	0644	edit dl rm
SubscriptionSearch.php	1562	0644	edit dl rm
TestingGateway.php	1442	0644	edit dl rm
TextNode.php	257	0644	edit dl rm
ThreeDSecureInfo.php	786	0644	edit dl rm
Transaction.php	23045	0644	edit dl rm
TransactionGateway.php	20448	0644	edit dl rm
TransactionLineItem.php	1378	0644	edit dl rm
TransactionLineItemGateway.php	1889	0644	edit dl rm
TransactionSearch.php	7880	0644	edit dl rm
TransparentRedirect.php	3049	0644	edit dl rm
TransparentRedirectGateway.php	8993	0644	edit dl rm
UnknownPaymentMethod.php	1561	0644	edit dl rm
UsBankAccount.php	3122	0644	edit dl rm
UsBankAccountGateway.php	2902	0644	edit dl rm
UsBankAccountVerification.php	2718	0644	edit dl rm
UsBankAccountVerificationGateway.php	4023	0644	edit dl rm
UsBankAccountVerificationSearch.php	1542	0644	edit dl rm
Util.php	16974	0644	edit dl rm
VenmoAccount.php	1989	0644	edit dl rm
Version.php	591	0644	edit dl rm
VisaCheckoutCard.php	5034	0644	edit dl rm
WebhookNotification.php	5822	0644	edit dl rm
WebhookNotificationGateway.php	2516	0644	edit dl rm
WebhookTesting.php	328	0644	edit dl rm
WebhookTestingGateway.php	19483	0644	edit dl rm
Xml.php	658	0644	edit dl rm

Edit: /home/desid573/public_html/app/braintree/lib/Braintree/Util.php (16974B)

<?php
namespace Braintree;

use DateTime;
use InvalidArgumentException;

/**
 * Braintree Utility methods
 * PHP version 5
 */

class Util
{
    /**
     * extracts an attribute and returns an array of objects
     *
     * extracts the requested element from an array, and converts the contents
     * of its child arrays to objects of type $attributeName, or returns
     * an array with a single element containing the value of that array element
     *
     * @param array  $attribArray   attributes from a search response
     * @param string $attributeName indicates which element of the passed array to extract
     * @return array array of $attributeName objects, or a single element array
     */
    public static function extractAttributeAsArray(&$attribArray, $attributeName)
    {
        if(!isset($attribArray[$attributeName])):
            return [];
        endif;

// get what should be an array from the passed array
        $data = $attribArray[$attributeName];
        // set up the class that will be used to convert each array element
        $classFactory = self::buildClassName($attributeName) . '::factory';
        if(is_array($data)):
            // create an object from the data in each element
            $objectArray = array_map($classFactory, $data);
        else:
            return [$data];
        endif;

unset($attribArray[$attributeName]);
        return $objectArray;
    }
    /**
     * throws an exception based on the type of error
     * @param string $statusCode HTTP status code to throw exception from
     * @param null|string $message
     * @throws Exception multiple types depending on the error
     * @return void
     */
    public static function throwStatusCodeException($statusCode, $message=null)
    {
        switch($statusCode) {
        case 401:
            throw new Exception\Authentication();
            break;
        case 403:
            throw new Exception\Authorization($message);
            break;
        case 404:
            throw new Exception\NotFound();
            break;
        case 426:
            throw new Exception\UpgradeRequired();
            break;
        case 429:
            throw new Exception\TooManyRequests();
            break;
        case 500:
            throw new Exception\ServerError();
            break;
        case 503:
            throw new Exception\DownForMaintenance();
            break;
        default:
            throw new Exception\Unexpected('Unexpected HTTP_RESPONSE #' . $statusCode);
            break;
        }
    }

/**
     * throws an exception based on the type of error returned from graphql
     * @param array $response complete graphql response
     * @throws Exception multiple types depending on the error
     * @return void
     */
    public static function throwGraphQLResponseException($response)
    {
        if(!array_key_exists("errors", $response) || !($errors = $response["errors"])) {
            return;
        }

foreach ($errors as $error) {
            $message = $error["message"];
            if ($error["extensions"] == null) {
                throw new Exception\Unexpected("Unexpected exception:" . $message);
            }

$errorClass = $error["extensions"]["errorClass"];

if ($errorClass == "VALIDATION") {
                continue;
            } else if ($errorClass == "AUTHENTICATION") {
                throw new Exception\Authentication();
            } else if ($errorClass == "AUTHORIZATION") {
                throw new Exception\Authorization($message);
            } else if ($errorClass == "NOT_FOUND") {
                throw new Exception\NotFound();
            } else if ($errorClass == "UNSUPPORTED_CLIENT") {
                throw new Exception\UpgradeRequired();
            } else if ($errorClass == "RESOURCE_LIMIT") {
                throw new Exception\TooManyRequests();
            } else if ($errorClass == "INTERNAL") {
                throw new Exception\ServerError();
            } else if ($errorClass == "SERVICE_AVAILABILITY") {
                throw new Exception\DownForMaintenance();
            } else {
                throw new Exception\Unexpected('Unexpected exception ' . $message);
            }
        }
    }

/**
     *
     * @param string $className
     * @param object $resultObj
     * @return object returns the passed object if successful
     * @throws Exception\ValidationsFailed
     */
    public static function returnObjectOrThrowException($className, $resultObj)
    {
        $resultObjName = self::cleanClassName($className);
        if ($resultObj->success) {
            return $resultObj->$resultObjName;
        } else {
            throw new Exception\ValidationsFailed();
        }
    }

/**
     * removes the  header from a classname
     *
     * @param string $name ClassName
     * @return camelCased classname minus  header
     */
    public static function cleanClassName($name)
    {
        $classNamesToResponseKeys = [
            'Braintree\CreditCard' => 'creditCard',
            'Braintree_CreditCard' => 'creditCard',
            'Braintree\CreditCardGateway' => 'creditCard',
            'Braintree_CreditCardGateway' => 'creditCard',
            'Braintree\Customer' => 'customer',
            'Braintree_Customer' => 'customer',
            'Braintree\CustomerGateway' => 'customer',
            'Braintree_CustomerGateway' => 'customer',
            'Braintree\Subscription' => 'subscription',
            'Braintree_Subscription' => 'subscription',
            'Braintree\SubscriptionGateway' => 'subscription',
            'Braintree_SubscriptionGateway' => 'subscription',
            'Braintree\Transaction' => 'transaction',
            'Braintree_Transaction' => 'transaction',
            'Braintree\TransactionGateway' => 'transaction',
            'Braintree_TransactionGateway' => 'transaction',
            'Braintree\CreditCardVerification' => 'verification',
            'Braintree_CreditCardVerification' => 'verification',
            'Braintree\CreditCardVerificationGateway' => 'verification',
            'Braintree_CreditCardVerificationGateway' => 'verification',
            'Braintree\AddOn' => 'addOn',
            'Braintree_AddOn' => 'addOn',
            'Braintree\AddOnGateway' => 'addOn',
            'Braintree_AddOnGateway' => 'addOn',
            'Braintree\Discount' => 'discount',
            'Braintree_Discount' => 'discount',
            'Braintree\DiscountGateway' => 'discount',
            'Braintree_DiscountGateway' => 'discount',
            'Braintree\Dispute' => 'dispute',
            'Braintree_Dispute' => 'dispute',
            'Braintree\Dispute\EvidenceDetails' => 'evidence',
            'Braintree_Dispute_EvidenceDetails' => 'evidence',
            'Braintree\DocumentUpload' => 'documentUpload',
            'Braintree_DocumentUpload' => 'doumentUpload',
            'Braintree\Plan' => 'plan',
            'Braintree_Plan' => 'plan',
            'Braintree\PlanGateway' => 'plan',
            'Braintree_PlanGateway' => 'plan',
            'Braintree\Address' => 'address',
            'Braintree_Address' => 'address',
            'Braintree\AddressGateway' => 'address',
            'Braintree_AddressGateway' => 'address',
            'Braintree\SettlementBatchSummary' => 'settlementBatchSummary',
            'Braintree_SettlementBatchSummary' => 'settlementBatchSummary',
            'Braintree\SettlementBatchSummaryGateway' => 'settlementBatchSummary',
            'Braintree_SettlementBatchSummaryGateway' => 'settlementBatchSummary',
            'Braintree\Merchant' => 'merchant',
            'Braintree_Merchant' => 'merchant',
            'Braintree\MerchantGateway' => 'merchant',
            'Braintree_MerchantGateway' => 'merchant',
            'Braintree\MerchantAccount' => 'merchantAccount',
            'Braintree_MerchantAccount' => 'merchantAccount',
            'Braintree\MerchantAccountGateway' => 'merchantAccount',
            'Braintree_MerchantAccountGateway' => 'merchantAccount',
            'Braintree\OAuthCredentials' => 'credentials',
            'Braintree_OAuthCredentials' => 'credentials',
            'Braintree\OAuthResult' => 'result',
            'Braintree_OAuthResult' => 'result',
            'Braintree\PayPalAccount' => 'paypalAccount',
            'Braintree_PayPalAccount' => 'paypalAccount',
            'Braintree\PayPalAccountGateway' => 'paypalAccount',
            'Braintree_PayPalAccountGateway' => 'paypalAccount',
            'Braintree\UsBankAccountVerification' => 'usBankAccountVerification',
            'Braintree_UsBankAccountVerification' => 'usBankAccountVerification',
        ];

return $classNamesToResponseKeys[$name];
    }

/**
     *
     * @param string $name className
     * @return string ClassName
     */
    public static function buildClassName($name)
    {
        $responseKeysToClassNames = [
            'creditCard' => 'Braintree\CreditCard',
            'customer' => 'Braintree\Customer',
            'dispute' => 'Braintree\Dispute',
            'documentUpload' => 'Braintree\DocumentUpload',
            'subscription' => 'Braintree\Subscription',
            'transaction' => 'Braintree\Transaction',
            'verification' => 'Braintree\CreditCardVerification',
            'addOn' => 'Braintree\AddOn',
            'discount' => 'Braintree\Discount',
            'plan' => 'Braintree\Plan',
            'address' => 'Braintree\Address',
            'settlementBatchSummary' => 'Braintree\SettlementBatchSummary',
            'merchantAccount' => 'Braintree\MerchantAccount',
        ];

return (string) $responseKeysToClassNames[$name];
    }

/**
     * convert alpha-beta-gamma to alphaBetaGamma
     *
     * @access public
     * @param string $string
     * @param null|string $delimiter
     * @return string modified string
     */
    public static function delimiterToCamelCase($string, $delimiter = '[\-\_]')
    {
        static $callback = null;
        if ($callback === null) {
            $callback = function ($matches) {
                return strtoupper($matches[1]);
            };
        }

return preg_replace_callback('/' . $delimiter . '(\w)/', $callback, $string);
    }

/**
     * convert alpha-beta-gamma to alpha_beta_gamma
     *
     * @access public
     * @param string $string
     * @return string modified string
     */
    public static function delimiterToUnderscore($string)
    {
        return preg_replace('/-/', '_', $string);
    }

/**
     * find capitals and convert to delimiter + lowercase
     *
     * @access public
     * @param string $string
     * @param null|string $delimiter
     * @return string modified string
     */
    public static function camelCaseToDelimiter($string, $delimiter = '-')
    {
        return strtolower(preg_replace('/([A-Z])/', "$delimiter\\1", $string));
    }

public static function delimiterToCamelCaseArray($array, $delimiter = '[\-\_]')
    {
        $converted = [];
        foreach ($array as $key => $value) {
            if (is_string($key)) {
                $key = self::delimiterToCamelCase($key, $delimiter);
            }

if (is_array($value)) {
                // Make an exception for custom fields, which must be underscore (can't be
                // camelCase).
                if ($key === 'customFields') {
                    $value = self::delimiterToUnderscoreArray($value);
                } else {
                    $value = self::delimiterToCamelCaseArray($value, $delimiter);
                }
            }
            $converted[$key] = $value;
        }
        return $converted;
    }

public static function camelCaseToDelimiterArray($array, $delimiter = '-')
    {
        $converted = [];
        foreach ($array as $key => $value) {
            if (is_string($key)) {
                $key = self::camelCaseToDelimiter($key, $delimiter);
            }
            if (is_array($value)) {
                $value = self::camelCaseToDelimiterArray($value, $delimiter);
            }
            $converted[$key] = $value;
        }
        return $converted;
    }

public static function delimiterToUnderscoreArray($array)
    {
        $converted = [];
        foreach ($array as $key => $value) {
            $key = self::delimiterToUnderscore($key);
            $converted[$key] = $value;
        }
        return $converted;
    }

/**
     *
     * @param array $array associative array to implode
     * @param string $separator (optional, defaults to =)
     * @param string $glue (optional, defaults to ', ')
     * @return bool
     */
    public static function implodeAssociativeArray($array, $separator = '=', $glue = ', ')
    {
        // build a new array with joined keys and values
        $tmpArray = null;
        foreach ($array AS $key => $value) {
            if ($value instanceof DateTime) {
                $value = $value->format('r');
            }
            $tmpArray[] = $key . $separator . $value;
        }
        // implode and return the new array
        return (is_array($tmpArray)) ? implode($glue, $tmpArray) : false;
    }

public static function attributesToString($attributes) {
        $printableAttribs = [];
        foreach ($attributes AS $key => $value) {
            if (is_array($value)) {
                $pAttrib = self::attributesToString($value);
            } else if ($value instanceof DateTime) {
                $pAttrib = $value->format(DateTime::RFC850);
            } else {
                $pAttrib = $value;
            }
            $printableAttribs[$key] = sprintf('%s', $pAttrib);
        }
        return self::implodeAssociativeArray($printableAttribs);
    }

/**
     * verify user request structure
     *
     * compares the expected signature of a gateway request
     * against the actual structure sent by the user
     *
     * @param array $signature
     * @param array $attributes
     */
    public static function verifyKeys($signature, $attributes)
    {
        $validKeys = self::_flattenArray($signature);
        $userKeys = self::_flattenUserKeys($attributes);
        $invalidKeys = array_diff($userKeys, $validKeys);
        $invalidKeys = self::_removeWildcardKeys($validKeys, $invalidKeys);

if(!empty($invalidKeys)) {
            asort($invalidKeys);
            $sortedList = join(', ', $invalidKeys);
            throw new InvalidArgumentException('invalid keys: ' . $sortedList);
        }
    }
    /**
     * flattens a numerically indexed nested array to a single level
     * @param array $keys
     * @param string $namespace
     * @return array
     */
    private static function _flattenArray($keys, $namespace = null)
    {
        $flattenedArray = [];
        foreach($keys AS $key) {
            if(is_array($key)) {
                $theKeys = array_keys($key);
                $theValues = array_values($key);
                $scope = $theKeys[0];
                $fullKey = empty($namespace) ? $scope : $namespace . '[' . $scope . ']';
                $flattenedArray = array_merge($flattenedArray, self::_flattenArray($theValues[0], $fullKey));
            } else {
                $fullKey = empty($namespace) ? $key : $namespace . '[' . $key . ']';
                $flattenedArray[] = $fullKey;
            }
        }
        sort($flattenedArray);
        return $flattenedArray;
    }

private static function _flattenUserKeys($keys, $namespace = null)
    {
       $flattenedArray = [];

foreach($keys AS $key => $value) {
           $fullKey = empty($namespace) ? $key : $namespace;
           if (!is_numeric($key) && $namespace != null) {
              $fullKey .= '[' . $key . ']';
           }
           if (is_numeric($key) && is_string($value)) {
              $fullKey .= '[' . $value . ']';
           }
           if(is_array($value)) {
               $more = self::_flattenUserKeys($value, $fullKey);
               $flattenedArray = array_merge($flattenedArray, $more);
           } else {
               $flattenedArray[] = $fullKey;
           }
       }
       sort($flattenedArray);
       return $flattenedArray;
    }

/**
     * removes wildcard entries from the invalid keys array
     * @param array $validKeys
     * @param <array $invalidKeys
     * @return array
     */
    private static function _removeWildcardKeys($validKeys, $invalidKeys)
    {
        foreach($validKeys AS $key) {
            if (stristr($key, '[_anyKey_]')) {
                $wildcardKey = str_replace('[_anyKey_]', '', $key);
                foreach ($invalidKeys AS $index => $invalidKey) {
                    if (stristr($invalidKey, $wildcardKey)) {
                        unset($invalidKeys[$index]);
                    }
                }
            }
        }
        return $invalidKeys;
    }
}
class_alias('Braintree\Util', 'Braintree_Util');

cmd: