mirror of
https://github.com/FH-Complete/FHC-Core.git
synced 2026-06-01 12:19:28 +00:00
paolo
396 lines
10 KiB
PHP
396 lines
10 KiB
PHP
<?php
|
|
|
|
if (! defined("BASEPATH")) exit("No direct script access allowed");
|
|
|
|
/**
|
|
*
|
|
*/
|
|
class PCRMLib
|
|
{
|
|
const RESOURCE_PARAMETER = "resource";
|
|
const FUNCTION_PARAMETER = "function";
|
|
const REG_SPLIT_EXPR = "/\//";
|
|
const LIB_PREFIX = "Lib";
|
|
const LIB_FILE_EXTENSION = ".php";
|
|
const LIBS_PATH = "libraries";
|
|
const MODEL_PREFIX = "_model";
|
|
|
|
// Black list of resources that are no allowed to be used
|
|
private static $RESOURCES_BLACK_LIST = array(
|
|
"PCRMLib", // disabled self loading
|
|
"LogLib", // hardly usefull and virtually dangerous
|
|
"MigrationLib", // virtually dangerous, DB manipulation
|
|
"FilesystemLib" // virtually dangerous, direct access to file system
|
|
);
|
|
|
|
/**
|
|
* Object initialization
|
|
*/
|
|
public function __construct()
|
|
{
|
|
// Gets CI instance
|
|
$this->ci =& get_instance();
|
|
|
|
// Loads helper message to manage returning messages
|
|
$this->ci->load->helper("message");
|
|
|
|
$this->ci->load->library("PermissionLib");
|
|
}
|
|
|
|
/**
|
|
* Everything starts here...
|
|
*/
|
|
public function start($callParameters, $permissionType)
|
|
{
|
|
$result = null;
|
|
$parameters = $this->_getParameters($callParameters);
|
|
$validation = $this->_validateCall($parameters);
|
|
|
|
// If the validation was passed
|
|
if ($validation->error == EXIT_SUCCESS)
|
|
{
|
|
$loaded = null;
|
|
// If the given resource is a model
|
|
if (strpos($parameters->resourceName, PCRMLib::MODEL_PREFIX) !== false)
|
|
{
|
|
// Try to load the model
|
|
$result = $this->_loadModel($parameters->resourcePath, $parameters->resourceName);
|
|
if ($result->error == EXIT_SUCCESS)
|
|
{
|
|
$loaded = $result->retval;
|
|
}
|
|
}
|
|
// If the given resource is a library
|
|
else if (strpos($parameters->resourceName, PCRMLib::LIB_PREFIX) !== false)
|
|
{
|
|
// Check if the resource is already loaded, it works only with libraries and drivers
|
|
$isLoaded = $this->ci->load->is_loaded($parameters->resourceName);
|
|
// If not loaded then load it
|
|
if ($isLoaded === false)
|
|
{
|
|
// Checks if the operation is permitted by the API caller
|
|
// Only for libraries, permissions are automatically handled by models
|
|
$result = $this->checkLibraryPermission(
|
|
$parameters->resourcePath,
|
|
$parameters->resourceName,
|
|
$parameters->function,
|
|
$permissionType
|
|
);
|
|
if ($result->error == EXIT_ERROR)
|
|
{
|
|
$loaded = null;
|
|
}
|
|
else
|
|
{
|
|
// Try to load the library
|
|
$result = $this->_loadLibrary($parameters->resourcePath, $parameters->resourceName);
|
|
if ($result->error == EXIT_SUCCESS)
|
|
{
|
|
$loaded = $result->retval;
|
|
}
|
|
}
|
|
}
|
|
// If it is already loaded $isLoaded contains the instance of the library
|
|
else
|
|
{
|
|
$loaded = $isLoaded;
|
|
}
|
|
}
|
|
// Wrong selection!
|
|
else
|
|
{
|
|
$result = $this->_error("Neither a lib nor model: " . $parameters->resourcePath . $parameters->resourceName);
|
|
}
|
|
|
|
// If the resource was found and loaded
|
|
if (!is_null($loaded))
|
|
{
|
|
$result = $this->_callThis($parameters->resourceName, $parameters->function, $parameters->parameters);
|
|
}
|
|
else
|
|
{
|
|
// Resource not loaded
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$result = $validation;
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Gets the parameters from the call
|
|
*/
|
|
private function _getParameters($parametersArray)
|
|
{
|
|
$parameters = new stdClass();
|
|
$parameters->parameters = array();
|
|
$count = 0;
|
|
|
|
foreach ($parametersArray as $parameterName => $parameterValue)
|
|
{
|
|
// The name of the resource, path included
|
|
if ($parameterName == PCRMLib::RESOURCE_PARAMETER)
|
|
{
|
|
// Separates the resource path from the resource name
|
|
$splittedResource = preg_split(PCRMLib::REG_SPLIT_EXPR, $parameterValue);
|
|
$parameters->resourceName = $splittedResource[count($splittedResource) - 1];
|
|
$parameters->resourcePath = str_replace($parameters->resourceName, "", $parameterValue);
|
|
}
|
|
// The name of the function
|
|
else if ($parameterName == PCRMLib::FUNCTION_PARAMETER)
|
|
{
|
|
$parameters->function = $parameterValue;
|
|
}
|
|
// It is assumed that all other parameters are the parameters to be passed to the function
|
|
// They will be passed to the function in the same order in which they are passed to
|
|
// this controller
|
|
else
|
|
{
|
|
$parameters->parameters[$count++] = $parameterValue;
|
|
}
|
|
}
|
|
|
|
return $parameters;
|
|
}
|
|
|
|
/**
|
|
* Validate the given parameters
|
|
*/
|
|
private function _validateCall($parameters)
|
|
{
|
|
if (!is_object($parameters))
|
|
{
|
|
return $this->_error("Parameter is not an object");
|
|
}
|
|
if (!isset($parameters->resourcePath))
|
|
{
|
|
return $this->_error("Resource path is not specified");
|
|
}
|
|
if (!isset($parameters->resourceName))
|
|
{
|
|
return $this->_error("Resource name is not specified");
|
|
}
|
|
if (!isset($parameters->function))
|
|
{
|
|
return $this->_error("Function is not specified");
|
|
}
|
|
if (!is_array($parameters->parameters))
|
|
{
|
|
return $this->_error("Parameters are not specified");
|
|
}
|
|
if (in_array($parameters->resourceName, PCRMLib::$RESOURCES_BLACK_LIST))
|
|
{
|
|
return $this->_error("You are trying to access to unauthorized resources");
|
|
}
|
|
|
|
return $this->_success("Input data are valid");
|
|
}
|
|
|
|
/**
|
|
* Loads a model using the given path and name
|
|
*
|
|
* NOTE: the models automatically handle the permissions
|
|
*/
|
|
private function _loadModel($resourcePath, $resourceName)
|
|
{
|
|
$loaded = null;
|
|
$result = null;
|
|
|
|
try
|
|
{
|
|
$loaded = $this->ci->load->model($resourcePath . $resourceName);
|
|
}
|
|
catch (Exception $e)
|
|
{
|
|
// Errors while loading the model
|
|
$result = $this->_error("Errors while loading the model: " . $e->getMessage());
|
|
}
|
|
|
|
if (!is_null($loaded))
|
|
{
|
|
$result = $this->_success($loaded);
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
private function checkLibraryPermission($resourcePath, $resourceName, $function, $permissionType)
|
|
{
|
|
$result = null;
|
|
$permissionPath = "";
|
|
|
|
if ($resourcePath != "")
|
|
{
|
|
$permissionPath = $resourcePath;
|
|
}
|
|
|
|
$permissionPath .= $resourceName . "." . $function;
|
|
|
|
if ($this->ci->permissionlib->hasPermission($permissionPath, $permissionType) === false)
|
|
{
|
|
$result = $this->_error(lang("fhc_".FHC_NORIGHT)." -> ".$permissionPath, FHC_NORIGHT);
|
|
}
|
|
else
|
|
{
|
|
$result = $this->_success("Has permission");
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Loads a library using the given path and name
|
|
*
|
|
* The method "library" of the class CI_Loader provided by CI has some limitations,
|
|
* so to be able to check errors was used a workaround.
|
|
* It consists in:
|
|
* - Checking if the file (identified by parameters $resourcePath and $resourceName) exists
|
|
* - If exists it will be loaded using the method "file" from CI_Loader
|
|
* - Checks if the loaded file contains a class identified by parameter $resourceName
|
|
*
|
|
* If one of the previous tests fails, it will be returned a null value
|
|
*/
|
|
private function _loadLibrary($resourcePath, $resourceName)
|
|
{
|
|
$loaded = null;
|
|
|
|
try
|
|
{
|
|
// Gets all the configured resources paths
|
|
$packagePaths = $this->ci->load->get_package_paths();
|
|
// Looking for a file in every paths with the same name of the resource
|
|
$found = null;
|
|
for ($i = 0; $i < count($packagePaths) && is_null($found); $i++)
|
|
{
|
|
$file = $packagePaths[$i] . PCRMLib::LIBS_PATH . DIRECTORY_SEPARATOR .
|
|
$resourcePath . $resourceName . PCRMLib::LIB_FILE_EXTENSION;
|
|
if (file_exists($file))
|
|
{
|
|
$found = $file;
|
|
}
|
|
}
|
|
|
|
// If the file was found
|
|
if (!is_null($found))
|
|
{
|
|
// Load the file
|
|
$loaded = $this->ci->load->file($found);
|
|
// If the resource is not present inside the file
|
|
if (!class_exists($resourceName))
|
|
{
|
|
$loaded = null;
|
|
// Same phrase error as load->model() provided by CI
|
|
$result = $this->_error($found . " exists, but doesn't declare class " . $resourceName);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$loaded = null;
|
|
// Same phrase error as load->model() provided by CI
|
|
$result = $this->_error("Unable to load the requested class: " . $resourceName);
|
|
}
|
|
}
|
|
catch (Exception $e)
|
|
{
|
|
// Errors while loading the library
|
|
$result = $this->_error("Errors while loading the library: " . $e->getMessage());
|
|
}
|
|
|
|
if (!is_null($loaded))
|
|
{
|
|
$result = $this->_success($loaded);
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Calls a method of a class with the given parameters and returns its result
|
|
*
|
|
* @param string $resourceName identifies the class name
|
|
* @param string $function identifies the method name
|
|
* @param array $parameters contains the parameters to be passed to the method
|
|
*/
|
|
private function _callThis($resourceName, $function, $parameters)
|
|
{
|
|
$result = null;
|
|
|
|
try
|
|
{
|
|
// Get informations about the function
|
|
$reflectionMethod = new ReflectionMethod($resourceName, $function);
|
|
// If the number of given parameters is greater or equal to the number of
|
|
// parameters required by the function
|
|
if (count($parameters) >= $reflectionMethod->getNumberOfRequiredParameters())
|
|
{
|
|
// If the function is static
|
|
if ($reflectionMethod->isStatic() === true)
|
|
{
|
|
$classMethod = $resourceName . "::" . $function;
|
|
}
|
|
// If the function is not static
|
|
else
|
|
{
|
|
$classMethod = array(new $resourceName(), $function);
|
|
}
|
|
|
|
// If the resource's function is callable
|
|
if (is_callable($classMethod))
|
|
{
|
|
|
|
// Call resource->function()
|
|
// @ was applied to prevent really ugly and unmanageable errors
|
|
$resultCall = @call_user_func_array($classMethod, $parameters);
|
|
// If errors occurred while running it
|
|
// NOTE: if the called function via call_user_func_array returns a boolean set as false,
|
|
// it will be recognized like a running error. A little bit tricky ;)
|
|
if ($resultCall === false)
|
|
{
|
|
$result = $this->_error("Error running " . $resourceName . "->" . $function . "()");
|
|
}
|
|
// Returns the result of resource->function()
|
|
else
|
|
{
|
|
$result = $this->_success($resultCall);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$result = $this->_error($resourceName . "->" . $function . "() is not callable!");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$result = $this->_error(
|
|
"Number of required parameters: " . $reflectionMethod->getNumberOfRequiredParameters() .
|
|
". Given: " . count($parameters)
|
|
);
|
|
}
|
|
}
|
|
catch (Exception $e)
|
|
{
|
|
$result = $this->_error($e->getMessage());
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
/*
|
|
*
|
|
*/
|
|
private function _error($retval = '', $message = EXIT_ERROR)
|
|
{
|
|
return error($retval, $message);
|
|
}
|
|
|
|
/*
|
|
*
|
|
*/
|
|
private function _success($retval, $message = EXIT_SUCCESS)
|
|
{
|
|
return success($retval, $message);
|
|
}
|
|
} |