class Braintree_Util in Commerce Braintree 7
Braintree Utility methods
@copyright 2010 Braintree Payment Solutions
Hierarchy
- class \Braintree_Util
Expanded class hierarchy of Braintree_Util
File
- braintree_php/
lib/ Braintree/ Util.php, line 15
View source
class Braintree_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 Braintree_$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 Braintree_$attributeName objects, or a single element array
*/
public static function extractAttributeAsArray(&$attribArray, $attributeName) {
if (!isset($attribArray[$attributeName])) {
return array();
}
// 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 array(
$data,
);
}
unset($attribArray[$attributeName]);
return $objectArray;
}
/**
* throws an exception based on the type of error
* @param string $statusCode HTTP status code to throw exception from
* @throws Braintree_Exception multiple types depending on the error
*
*/
public static function throwStatusCodeException($statusCode, $message = null) {
switch ($statusCode) {
case 401:
throw new Braintree_Exception_Authentication();
break;
case 403:
throw new Braintree_Exception_Authorization($message);
break;
case 404:
throw new Braintree_Exception_NotFound();
break;
case 426:
throw new Braintree_Exception_UpgradeRequired();
break;
case 500:
throw new Braintree_Exception_ServerError();
break;
case 503:
throw new Braintree_Exception_DownForMaintenance();
break;
default:
throw new Braintree_Exception_Unexpected('Unexpected HTTP_RESPONSE #' . $statusCode);
break;
}
}
/**
* removes the Braintree_ header from a classname
*
* @param string $name Braintree_ClassName
* @return camelCased classname minus Braintree_ header
*/
public static function cleanClassName($name) {
$name = str_replace('Braintree_', '', $name);
// lcfirst only exists >= 5.3
if (false === function_exists('lcfirst')) {
function lcfirst($str) {
return (string) (strtolower(substr($str, 0, 1)) . substr($str, 1));
}
}
return lcfirst($name);
}
/**
*
* @param string $name className
* @return string Braintree_ClassName
*/
public static function buildClassName($name) {
return 'Braintree_' . ucfirst($name);
}
/**
* convert alpha-beta-gamma to alphaBetaGamma
*
* @access public
* @param string $string
* @return string modified string
*/
public static function delimiterToCamelCase($string, $delimiter = '[\\-\\_]') {
return preg_replace('/' . $delimiter . '(\\w)/e', 'strtoupper("$1")', $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 var $string
* @return var modified string
*/
public static function camelCaseToDelimiter($string, $delimiter = '-') {
return preg_replace('/([A-Z])/e', '"' . $delimiter . '" . strtolower("$1")', $string);
}
/**
*
* @param array $array associative array to implode
* @param string $separator (optional, defaults to =)
* @param string $glue (optional, defaults to ', ')
*/
public static function implodeAssociativeArray($array, $separator = '=', $glue = ', ') {
// build a new array with joined keys and values
$tmpArray = null;
foreach ($array as $key => $value) {
$tmpArray[] = $key . $separator . $value;
}
// implode and return the new array
return is_array($tmpArray) ? implode($glue, $tmpArray) : false;
}
public static function attributesToString($attributes) {
foreach ($attributes as $key => $value) {
if (is_array($value)) {
$pAttrib = "";
foreach ($value as $obj) {
$pAttrib .= sprintf('%s', $obj);
}
}
else {
if ($value instanceof DateTime) {
$pAttrib = $value
->format(DateTime::RFC850);
}
else {
$pAttrib = $value;
}
}
$printableAttribs[$key] = sprintf('%s', $pAttrib);
}
return Braintree_Util::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 = array();
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 = array();
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;
}
}
Members
Name | Modifiers | Type | Description | Overrides |
---|---|---|---|---|
Braintree_Util:: |
public static | function | ||
Braintree_Util:: |
public static | function | ||
Braintree_Util:: |
public static | function | find capitals and convert to delimiter + lowercase | |
Braintree_Util:: |
public static | function | removes the Braintree_ header from a classname | |
Braintree_Util:: |
public static | function | convert alpha-beta-gamma to alphaBetaGamma | |
Braintree_Util:: |
public static | function | convert alpha-beta-gamma to alpha_beta_gamma | |
Braintree_Util:: |
public static | function | extracts an attribute and returns an array of objects | |
Braintree_Util:: |
public static | function | ||
Braintree_Util:: |
public static | function | throws an exception based on the type of error | |
Braintree_Util:: |
public static | function | verify user request structure | |
Braintree_Util:: |
private static | function | flattens a numerically indexed nested array to a single level | |
Braintree_Util:: |
private static | function | ||
Braintree_Util:: |
private static | function | removes wildcard entries from the invalid keys array |