/**
* Constructor
*
* This constructor fetches the local configuration path
* and constructs the config file for a certain module.
*
* After having the xml configuration file loaded, it'll create
* a Zend_Config_Xml instance and store it in $this->config
*
* @param string $name The name of the configuration to load
*/
public function __construct($name)
{
if (defined('ADMIN_CONF_PATH')) {
$config = ADMIN_CONF_PATH;
} else {
try {
$config = Zend_Registry::get('localConfigPath');
} catch (Zend_Exception $e) {}
}
$this->configFile = $config . $name . '.xml';
$this->configName = $name;
/**
* @TODO Remove me after the rewrite of the Config Reader. Move this to
* Frapi_Internal. I dislike inter-dependencies.
*/
if ($cachedConfig = Frapi_Internal::getCached('configFile-' . $name))
{
$this->config = $cachedConfig;
} else {
$helper = new Lupin_Config_Helper_XmlArray();
$this->config = $helper->parse($this->configFile);
Frapi_Internal::setCached('configFile-' . $name, $this->config);
}
$this->config = $this->config[$name];
}
/**
* Populate the Output
*
* This method populates the $this->response
* variable with the value returned from the
* action.
*
* @param Mixed $response Most of the times an array but could be and stdClass
* @param String $customTemplate The custom template file to use instead of the default one.
*
* @return Object $This object
*/
public function populateOutput($data, $customTemplate = false)
{
$directory = CUSTOM_OUTPUT . DIRECTORY_SEPARATOR . 'xml';
$file = $directory . DIRECTORY_SEPARATOR . ucfirst(strtolower($this->action)) . '.xml.tpl';
if ($customTemplate !== false) {
$file = $directory . DIRECTORY_SEPARATOR . 'custom' . DIRECTORY_SEPARATOR . $customTemplate . '.xml.tpl';
}
$xml = '';
$print = hash('md5', json_encode($data));
if ($response = Frapi_Internal::getCached($print)) {
$this->response = json_decode($response);
} elseif (file_exists($file)) {
ob_start();
echo '<?xml version="1.0" encoding="UTF-8"?>' . PHP_EOL;
include $file;
$xml = ob_get_contents();
ob_end_clean();
$this->response = $xml;
Frapi_Internal::setCached($print, json_encode($xml));
} elseif ($this->action == 'defaultError') {
$directory = LIBRARY_OUTPUT . DIRECTORY_SEPARATOR . 'xml';
$file = $directory . DIRECTORY_SEPARATOR . 'Defaulterror.xml.tpl';
ob_start();
echo '<?xml version="1.0" encoding="UTF-8"?>' . PHP_EOL;
include $file;
$xml = ob_get_contents();
ob_end_clean();
$this->response = $xml;
Frapi_Internal::setCached($print, json_encode($xml));
} else {
$this->response = $this->_generateXML($data);
}
return $this;
}
/**
* Find out whether a username is a valid one or not.
*
* This method is used from the Digest to figure out whether or not a user
* is a valid handle and one that should be used.
*
* @param string $partnerID Partner identifier (email).
*
* @return mixed Information about a user or a Boolean Whether the
* supplied partnerID are valid details.
*/
public static function isPartnerHandle($partnerID)
{
if (!($partners = Frapi_Internal::getCached("Partners.emails-keys"))) {
$partners = Frapi_Internal::getCachedPartners();
}
if (isset($partners[$partnerID]) && $partners[$partnerID]['email'] == $partnerID) {
return $partners[$partnerID];
}
return false;
}
/**
* This function is called from Frapi_Security::isPartner
* so this function must actually implement the validation
* of the partner.
*
* @param String $partnerID Partner identifier (email).
* @param String $partnerKey Partner key (sha1 hash).
*
* @return Boolean Whether the supplied partnerID and partnerKey are valid details.
*/
public static function isPartner($partnerID, $partnerKey)
{
if (!($partners = Frapi_Internal::getCached("Partners.emails-keys"))) {
$partners = Frapi_Internal::getCachedPartners();
}
if (isset($partners[$partnerID]) && $partners[$partnerID]['email'] == $partnerID && $partners[$partnerID]['api_key'] == $partnerKey) {
return true;
}
return false;
}
/**
* Load routes from APC, database etc.
* Prepare routes if necessary!
*
* @return void
*/
public function loadAndPrepareRoutes()
{
if ($routes = Frapi_Internal::getCached('Router.routes-prepared')) {
$this->setPreparedRoutes($routes);
} else {
$routes = array();
$ret = Frapi_Internal::getConfiguration('actions');
$rows = $ret->getAll('action');
foreach ($rows as $row) {
if (isset($row['route']) && !empty($row['route'])) {
$routes[$row['name']] = $row['route'];
}
}
$this->setPreparedRoutes($preparedRoutes = self::prepareRoutes($routes));
Frapi_Internal::setCached('Router.routes-prepared', $preparedRoutes);
}
}
/**
* Get default format from SQLite database
*
* A format (output type) has not been supplied
* so try to get default from backend.
*
* @return String The format.
*/
public function getDefaultFormatFromConfiguration()
{
if ($default_output_format = Frapi_Internal::getCached('Output.default-format')) {
return $default_output_format;
}
$conf = Frapi_Internal::getConfiguration('outputs');
$row = $conf->getByField('output', 'default', '1');
if (isset($row) && isset($row['name'])) {
Frapi_Internal::setCached('Output.default-format', $row['name']);
return $row['name'];
}
return Frapi_Controller_Api::DEFAULT_OUTPUT_FORMAT;
}
/**
* Private function to get error (statically, APC, or DB).
*
* This function tries to locate the error in progressively
* slower datastores (static class variable, APC, database)
* and will store the loaded errors in the faster stores.
*
* @param string $error_name Name of error.
* @param string $error_msg The actual message of the error.
* @param int $http_code This might be hard to grasp however, we are in a web
* industry dealing with the web. The code you are sending
* to your exception should really be represented by the
* HTTP Code returned to your users.
*
* @return array An array with the content of the error.
*/
private static function _get($error_name, $error_msg = false, $http_code = false)
{
if (!self::$_statically_loaded) {
$errors = Frapi_Internal::getCached('Errors.user-defined');
if ($errors) {
self::$_errors = $errors;
} elseif ($errors = self::_getErrorsFromDb()) {
self::$_errors = $errors;
Frapi_Internal::setCached('Errors.user-defined', $errors);
}
self::$_statically_loaded = true;
}
if (isset(self::$_errors[$error_name])) {
$error = self::$_errors[$error_name];
if ($error_msg !== false) {
$error['message'] = $error_msg;
}
if ($http_code !== false) {
$error['http_code'] = $http_code;
}
return $error;
}
return array(
'name' => $error_name,
'message' => $error_msg !== false ? $error_msg : $error_name,
'http_code' => $http_code !== false ? $http_code : '400',
);
}
/**
* Private function to get error (statically, APC, or DB).
*
* This function tries to locate the error in progressively
* slower datastores (static class variable, APC, database)
* and will store the loaded errors in the faster stores.
*
* @param string $error_name Name of error.
* @param string $error_msg The actual message of the error.
* @param int $http_code This might be hard to grasp however, we are in a web
* industry dealing with the web. The code you are sending
* to your exception should really be represented by the
* HTTP Code returned to your users.
* @param string $http_phrase The http phrase associated with the http_code
*
* @return array An array with the content of the error.
*/
private static function _get($error_name, $error_msg = false, $http_code = false, $http_phrase = false)
{
if (!self::$_statically_loaded) {
$errors = Frapi_Internal::getCached('Errors.user-defined');
if ($errors) {
self::$_errors = $errors;
} elseif ($errors = self::_getErrorsFromDb()) {
self::$_errors = $errors;
Frapi_Internal::setCached('Errors.user-defined', $errors);
}
self::$_statically_loaded = true;
}
if (isset(self::$_errors[$error_name])) {
$error = self::$_errors[$error_name];
if ($error_msg !== false) {
$error['message'] = $error_msg;
}
if ($http_code !== false) {
$error['http_code'] = $http_code;
}
if ($http_phrase !== false) {
$error['http_phrase'] = $http_phrase;
} else {
if (isset(Frapi_Response::$http_reason[$error['http_code']]) && !$error['http_phrase']) {
$error['http_phrase'] = Frapi_Response::$http_reason[$error['http_code']];
} else {
if ($error['message'] !== false && !$error['http_phrase']) {
$error['http_phrase'] = $error['message'];
}
}
}
return $error;
}
if ($http_phrase === false) {
if (isset(Frapi_Response::$http_reason[$http_code])) {
$http_phrase = Frapi_Response::$http_reason[$http_code];
} else {
if ($error_msg !== false) {
$http_phrase = $error_msg;
}
}
}
return array('name' => $error_name, 'message' => $error_msg !== false ? $error_msg : $error_name, 'http_code' => $http_code !== false ? $http_code : '400', 'http_phrase' => $http_phrase !== false ? $http_phrase : 'Bad Request');
}
public static function getEnabledFormats()
{
try {
if ($formats = Frapi_Internal::getCached('Output.formats-enabled')) {
return $formats;
}
$cache = new Frapi_Internal();
$outputs = $cache->getConfiguration('outputs')->getAll('output');
$formats = array();
foreach ($outputs as $output) {
if ($output['enabled'] == 1) {
$formats[] = strtolower($output['name']);
}
}
} catch (Exception $e) {
return false;
}
Frapi_Internal::setCached('Output.formats-enabled', $formats);
return $formats;
}
/**
* Test cache stores and retrieves items.
*
* @dataProvider keysValuesProvider
**/
public function testCacheStoreAndRetrieve($key, $value)
{
Frapi_Internal::setCached($key, $value);
$this->assertEquals($value, Frapi_Internal::getCached($key));
}