fix labels and text editors for Quest creation

This commit is contained in:
oliver 2016-01-15 12:33:07 +01:00
commit 476c18b6a9
4278 changed files with 1196345 additions and 0 deletions

608
core/Agent.inc Normal file
View file

@ -0,0 +1,608 @@
<?php
/**
* NRE
*
* @author coderkun <olli@coderkun.de>
* @copyright 2013 coderkun (http://www.coderkun.de)
* @license http://www.gnu.org/licenses/gpl.html
* @link http://www.coderkun.de/projects/nre
*/
namespace nre\core;
/**
* Abstract class for the implementation af an Agent.
*
* @author coderkun <olli@coderkun.de>
*/
abstract class Agent
{
/**
* Name of BottomlevelAgent for showing inline errors
*
* @var string
*/
const INLINEERROR_AGENT = 'inlineerror';
/**
* Current request
*
* @var Request
*/
private $request;
/**
* Current response
*
* @var Response
*/
private $response;
/**
* Log-system
*
* @var Logger
*/
protected $log;
/**
* SubAgents
*
* @var array
*/
protected $subAgents = array();
/**
* Controller of this Agent
*
* @var Controller
*/
public $controller = null;
/**
* Load the class of an Agent.
*
* @static
* @throws \nre\exceptions\AgentNotFoundException
* @throws \nre\exceptions\AgentNotValidException
* @param string $agentName Name of the Agent to load
*/
public static function load($agentName)
{
// Determine full classname
$agentType = self::getAgentType();
$className = self::getClassName($agentName, $agentType);
try {
// Load class
ClassLoader::load($className);
// Validate class
$parentAgentClassName = ClassLoader::concatClassNames($agentType, 'agent');
$parentAgentClassName = "\\nre\\agents\\$parentAgentClassName";
ClassLoader::check($className, $parentAgentClassName);
}
catch(\nre\exceptions\ClassNotValidException $e) {
throw new \nre\exceptions\AgentNotValidException($e->getClassName());
}
catch(\nre\exceptions\ClassNotFoundException $e) {
throw new \nre\exceptions\AgentNotFoundException($e->getClassName());
}
}
/**
* Instantiate an Agent (Factory Pattern).
*
* @static
* @throws \nre\exceptions\DatamodelException
* @throws \nre\exceptions\DriverNotValidException
* @throws \nre\exceptions\DriverNotFoundException
* @throws \nre\exceptions\ViewNotFoundException
* @throws \nre\exceptions\ModelNotValidException
* @throws \nre\exceptions\ModelNotFoundException
* @throws \nre\exceptions\ControllerNotValidException
* @throws \nre\exceptions\ControllerNotFoundException
* @param string $agentName Name of the Agent to instantiate
* @param Request $request Current request
* @param Response $respone Current respone
* @param Logger $log Log-system
*/
public static function factory($agentName, Request $request, Response $response, Logger $log=null)
{
// Determine full classname
$agentType = self::getAgentType();
$className = self::getClassName($agentName, $agentType);
// Construct and return Agent
return new $className($request, $response, $log);
}
/**
* Determine the type of an Agent.
*
* @static
* @return string Agent type
*/
private static function getAgentType()
{
return strtolower(ClassLoader::getClassName(get_called_class()));
}
/**
* Determine the classname for the given Agent name.
*
* @static
* @param string $agentName Agent name to get classname of
* @param string $agentType Agent type of given Agent name
* @return string Classname for the Agent name
*/
private static function getClassName($agentName, $agentType)
{
$className = ClassLoader::concatClassNames($agentName, 'agent');
return \nre\configs\AppConfig::$app['namespace']."agents\\$agentType\\$className";
}
/**
* Construct a new Agent.
*
* @throws \nre\exceptions\DatamodelException
* @throws \nre\exceptions\DriverNotValidException
* @throws \nre\exceptions\DriverNotFoundException
* @throws \nre\exceptions\ViewNotFoundException
* @throws \nre\exceptions\ModelNotValidException
* @throws \nre\exceptions\ModelNotFoundException
* @throws \nre\exceptions\ControllerNotValidException
* @throws \nre\exceptions\ControllerNotFoundException
* @param Request $request Current request
* @param Response $respone Current response
* @param Logger $log Log-system
*/
protected function __construct(Request $request, Response $response, Logger $log=null)
{
// Store values
$this->request = $request;
$this->response = $response;
$this->log = $log;
// Construct SubAgent
$this->actionConstruct();
// Load corresponding Controller
$this->loadController();
}
/**
* Run the Controller of this Agent and its SubAgents.
*
* @throws \nre\exceptions\ParamsNotValidException
* @throws \nre\exceptions\IdNotFoundException
* @throws \nre\exceptions\DatamodelException
* @throws \nre\exceptions\ActionNotFoundException
* @param Request $request Current request
* @param Response $response Current response
* @return \Exception Last occurred exception of SubAgents
*/
public function run(Request $request, Response $response)
{
// Check Controller
if(!is_null($this->controller))
{
// Call prefilter
$this->controller->preFilter($request, $response);
// Run controller
$this->controller->run($request, $response);
// Call postfilter
$this->controller->postFilter($request, $response);
}
// Run SubAgents
$exception = null;
foreach($this->subAgents as &$subAgent)
{
try {
$subAgent['object']->run(
$request,
$subAgent['response']
);
}
catch(ParamsNotValidException $e) {
$subAgent = $this->errorInline($subAgent, $request, $e);
}
catch(IdNotFoundException $e) {
$subAgent = $this->errorInline($subAgent, $request, $e);
}
catch(DatamodelException $e) {
$exception = $e;
$subAgent = $this->errorInline($subAgent, $request, $e);
}
catch(ActionNotFoundException $e) {
$subAgent = $this->errorInline($subAgent, $request, $e);
}
}
// Return last occurred exception
return $exception;
}
/**
* Generate output of the Controller of this Agent and its
* SubAgents.
*
* @param array $data View data
* @return string Generated output
*/
public function render($data=array())
{
// Check Controller
if(!is_null($this->controller))
{
// Render SubAgents
foreach($this->subAgents as $subAgent)
{
$label = array_key_exists('label', $subAgent) ? $subAgent['label'] : $subAgent['name'];
$data[$label] = $this->renderSubAgent($subAgent);
}
// Render the Controller of this agent
return $this->controller->render($data);
}
}
/**
* Construct SubAgents (per Action).
*/
protected function actionConstruct()
{
// Action ermitteln
$action = $this->response->getParam(2);
if(is_null($action)) {
$action = $this->request->getParam(2, 'action');
$this->response->addParam($action);
}
// Initialisierungsmethode für diese Action ausführen
if(method_exists($this, $action))
{
call_user_func_array(
array(
$this,
$action
),
array(
$this->request,
$this->response
)
);
}
}
/**
* Load the Controller of this Agent.
*
* @throws \nre\exceptions\DatamodelException
* @throws \nre\exceptions\DriverNotValidException
* @throws \nre\exceptions\DriverNotFoundException
* @throws \nre\exceptions\ViewNotFoundException
* @throws \nre\exceptions\ModelNotValidException
* @throws \nre\exceptions\ModelNotFoundException
* @throws \nre\exceptions\ControllerNotValidException
* @throws \nre\exceptions\ControllerNotFoundException
*/
protected function loadController()
{
// Determine Controller name
$controllerName = ClassLoader::getClassName(get_class($this));
// Determine ToplevelAgent
$toplevelAgentName = $this->response->getParam(0);
if(is_null($toplevelAgentName)) {
$toplevelAgentName = $this->request->getParam(0, 'toplevel');
$this->response->addParam($toplevelAgentName);
}
// Determine Action
$action = $this->response->getParam(2);
if(is_null($action)) {
$action = $this->request->getParam(2, 'action');
$this->response->addParam($action);
}
// Load Controller
Controller::load($controllerName);
// Construct Controller
$this->controller = Controller::factory($controllerName, $toplevelAgentName, $action, $this);
}
/**
* Log an error.
*
* @param \Exception $exception Occurred exception
* @param int $logMode Log mode
*/
protected function log($exception, $logMode)
{
if(is_null($this->log)) {
return;
}
$this->log->log(
$exception->getMessage(),
$logMode
);
}
/**
* Load a SubAgent and add it.
*
* @throws \nre\exceptions\ServiceUnavailableException
* @throws \nre\exceptions\AgentNotFoundException
* @throws \nre\exceptions\AgentNotValidException
* @param string $agentName Name of the Agent to load
* @param mixed Additional parameters for the agent
*/
protected function addSubAgent($agentName)
{
try {
call_user_func_array(
array(
$this,
'_addSubAgent'
),
func_get_args()
);
}
catch(DatamodelException $e) {
$this->subAgents[] = $this->newInlineError($agentName, $e);
}
}
/**
* Load a SubAgent and add it.
*
* @throws \nre\exceptions\ServiceUnavailableException
* @throws \nre\exceptions\DatamodelException
* @throws \nre\exceptions\AgentNotFoundException
* @throws \nre\exceptions\AgentNotValidException
* @param string $agentName Name of the Agent to load
* @param mixed Additional parameters for the agent
*/
protected function _addSubAgent($agentName)
{
try {
// Load Agent
\nre\agents\BottomlevelAgent::load($agentName);
// Construct Agent
$this->subAgents[] = call_user_func_array(
array(
$this,
'newSubAgent'
),
func_get_args()
);
}
catch(ViewNotFoundException $e) {
$this->subAgents[] = $this->newInlineError($agentName, $e);
}
catch(DriverNotValidException $e) {
$this->subAgents[] = $this->newInlineError($agentName, $e);
}
catch(DriverNotFoundException $e) {
$this->subAgents[] = $this->newInlineError($agentName, $e);
}
catch(ModelNotValidException $e) {
$this->subAgents[] = $this->newInlineError($agentName, $e);
}
catch(ModelNotFoundException $e) {
$this->subAgents[] = $this->newInlineError($agentName, $e);
}
catch(ControllerNotValidException $e) {
$this->subAgents[] = $this->newInlineError($agentName, $e);
}
catch(ControllerNotFoundException $e) {
$this->subAgents[] = $this->newInlineError($agentName, $e);
}
catch(AgentNotValidException $e) {
$this->subAgents[] = $this->newInlineError($agentName, $e);
}
catch(AgentNotFoundException $e) {
$this->subAgents[] = $this->newInlineError($agentName, $e);
}
}
/**
* Create a new SubAgent.
*
* @throws \nre\exceptions\DatamodelException
* @param string $agentName Agent name
* @return array SubAgent
*/
private function newSubAgent($agentName)
{
// Response
$response = clone $this->response;
$response->clearParams(1);
$params = func_get_args();
if(count($params) < 2 || empty($params[1])) {
$params[1] = \nre\configs\CoreConfig::$defaults['action'];
}
call_user_func_array(
array(
$response,
'addParams'
),
$params
);
return array(
'name' => strtolower($agentName),
'response' => $response,
'object' => \nre\agents\BottomlevelAgent::factory(
$agentName,
$this->request,
$response,
$this->log
)
);
}
/**
* Render a SubAgent.
*
* @param array $subAgent SubAgent to render
* @return string Generated output
*/
private function renderSubAgent(&$subAgent)
{
// Check for InlineError
if(array_key_exists('inlineerror', $subAgent) && !empty($subAgent['inlineerror'])) {
return file_get_contents($subAgent['inlineerror']);
}
// Rendern SubAgent and return its output
return $subAgent['object']->render();
}
/**
* Handle the exception of a SubAgent.
*
* @param array $subAgent Original (Sub-) Agent
* @param Request $request Current request
* @param Excepiton $exception Occurred exception
* @return array InlineError-SubAgent
*/
private function errorInline($subAgent, $request, $exception)
{
// Create the SubAgent for the exception
$subAgent = $this->newInlineError($subAgent['name'], $exception);
// Run the InlineError-SubAgent
try {
$subAgent['object']->run(
$request,
$subAgent['response']
);
}
catch(ActionNotFoundException $e) {
$this->log($e, Logger::LOGMODE_AUTO);
$subAgent['inlineerror'] = $this->newInlineErrorService();
}
// Return the InlineError-SubAgent
return $subAgent;
}
/**
* Create a new InlineError.
*
* @param string $label Name of the original Agent
* @param \Exception $exception Occurred exception
*/
private function newInlineError($label, $exception)
{
// Log error
$this->log($exception, Logger::LOGMODE_AUTO);
// Determine Agent name
$agentName = self::INLINEERROR_AGENT;
// Create SugAgent
$subAgent = array();
try {
// Load Agenten
\nre\agents\BottomlevelAgent::load($agentName);
// Construct Agent
$subAgent = $this->newSubAgent($agentName);
$subAgent['label'] = $label;
$subAgent['response']->addParam($exception);
}
catch(ViewNotFoundException $e) {
$subAgent['inlineerror'] = $this->newInlineErrorService();
}
catch(DatamodelException $e) {
$subAgent['inlineerror'] = $this->newInlineErrorService();
}
catch(DriverNotValidException $e) {
$subAgent['inlineerror'] = $this->newInlineErrorService();
}
catch(DriverNotFoundException $e) {
$subAgent['inlineerror'] = $this->newInlineErrorService();
}
catch(ModelNotValidException $e) {
$subAgent['inlineerror'] = $this->newInlineErrorService();
}
catch(ModelNotFoundException $e) {
$subAgent['inlineerror'] = $this->newInlineErrorService();
}
catch(ControllerNotValidException $e) {
$subAgent['inlineerror'] = $this->newInlineErrorService();
}
catch(ControllerNotFoundException $e) {
$subAgent['inlineerror'] = $this->newInlineErrorService();
}
catch(AgentNotValidException $e) {
$subAgent['inlineerror'] = $this->newInlineErrorService();
}
catch(AgentNotFoundException $e) {
$subAgent['inlineerror'] = $this->newInlineErrorService();
}
// Return SubAgent
return $subAgent;
}
/**
* Handle a hardcore error that could not be handled by the
* system.
*/
private function newInlineErrorService()
{
// Read and return static error file
return ROOT.DS.\nre\configs\CoreConfig::getClassDir('views').DS.\nre\configs\CoreConfig::$defaults['inlineErrorFile'].\nre\configs\Config::getFileExt('views');
}
}
?>

163
core/Api.inc Normal file
View file

@ -0,0 +1,163 @@
<?php
/**
* NRE
*
* @author coderkun <olli@coderkun.de>
* @copyright 2013 coderkun (http://www.coderkun.de)
* @license http://www.gnu.org/licenses/gpl.html
* @link http://www.coderkun.de/projects/nre
*/
namespace nre\core;
/**
* Abstract class to implement an API.
*
* The API is the center of each application and specifies how and what
* to run and render.
*
* @author coderkun <olli@coderkun.de>
*/
abstract class Api
{
/**
* Die aktuelle Anfrage
*
* @var Request
*/
protected $request;
/**
* Der Toplevelagent
*
* @var \nre\agents\ToplevelAgent
*/
private $toplevelAgent = null;
/**
* Die aktuelle Antwort
*
* @var Response
*/
protected $response;
/**
* Log-System
*
* @var Logger
*/
protected $log;
/**
* Construct a new API.
*
* @param Request $request Current request
* @param Response $response Current response
*/
public function __construct(Request $request, Response $response)
{
// Store request
$this->request = $request;
// Store response
$this->response = $response;
// Init logging
$this->log = new \nre\core\Logger();
}
/**
* Run the application.
*
* @throws \nre\exceptions\DatamodelException
* @throws \nre\exceptions\DriverNotValidException
* @throws \nre\exceptions\DriverNotFoundException
* @throws \nre\exceptions\ViewNotFoundException
* @throws \nre\exceptions\ModelNotValidException
* @throws \nre\exceptions\ModelNotFoundException
* @throws \nre\exceptions\ControllerNotValidException
* @throws \nre\exceptions\ControllerNotFoundException
* @throws \nre\exceptions\AgentNotValidException
* @throws \nre\exceptions\AgentNotFoundException
* @return \Exception Last occurred exception of an subagent
*/
public function run()
{
// Load ToplevelAgent
$this->loadToplevelAgent();
// Run ToplevelAgent
return $this->toplevelAgent->run($this->request, $this->response);
}
/**
* Render the output.
*/
public function render()
{
// Check exit-status
if($this->response->getExit()) {
return;
}
// Render ToplevelAgent
$this->response->setOutput($this->toplevelAgent->render());
}
/**
* Log an exception
*
* @param \Exception $exception Occurred exception
* @param int $logMode Log-mode
*/
protected function log($exception, $logMode)
{
$this->log->log(
$exception->getMessage(),
$logMode
);
}
/**
* Load the ToplevelAgent specified by the request.
*
* @throws \nre\exceptions\ServiceUnavailableException
* @throws \nre\exceptions\AgentNotValidException
* @throws \nre\exceptions\AgentNotFoundException
*/
private function loadToplevelAgent()
{
// Determine agent
$agentName = $this->response->getParam(0);
if(is_null($agentName)) {
$agentName = $this->request->getParam(0, 'toplevel');
$this->response->addParam($agentName);
}
// Load agent
\nre\agents\ToplevelAgent::load($agentName);
// Construct agent
$this->toplevelAgent = \nre\agents\ToplevelAgent::factory(
$agentName,
$this->request,
$this->response,
$this->log
);
}
}
?>

98
core/Autoloader.inc Normal file
View file

@ -0,0 +1,98 @@
<?php
/**
* NRE
*
* @author coderkun <olli@coderkun.de>
* @copyright 2013 coderkun (http://www.coderkun.de)
* @license http://www.gnu.org/licenses/gpl.html
* @link http://www.coderkun.de/projects/nre
*/
namespace nre\core;
/**
* Autoloader.
*
* This class tries to load not yet used classes.
*
* @author coderkun <olli@coderkun.de>
*/
class Autoloader
{
/**
* Private construct().
*/
private function __construct() {}
/**
* Private clone().
*/
private function __clone() {}
/**
* Register load-method.
*/
public static function register()
{
spl_autoload_register(
array(
get_class(),
'load'
)
);
}
/**
* Look for the given class and try to load it.
*
* @param string $fullClassName Name of class to load
*/
public static function load($fullClassName)
{
$fullClassNameA = explode('\\', $fullClassName);
if(strpos($fullClassName, \nre\configs\CoreConfig::$core['namespace']) !== 0)
{
// App
$className = array_slice($fullClassNameA, substr_count(\nre\configs\AppConfig::$app['namespace'], '\\'));
array_unshift($className, \nre\configs\CoreConfig::getClassDir('app'));
$filename = ROOT.DS.implode(DS, $className).\nre\configs\CoreConfig::getFileExt('includes');
if(file_exists($filename)) {
require_once($filename);
}
}
else
{
// Core
$className = array_slice($fullClassNameA, substr_count(\nre\configs\CoreConfig::$core['namespace'], '\\'));
$filename = ROOT.DS.implode(DS, $className).\nre\configs\CoreConfig::getFileExt('includes');
if(file_exists($filename)) {
require_once($filename);
}
}
}
/**
* Determine classtype of a class.
*
* @param string $className Name of the class to determine the classtype of
* @return string Classtype of the given class
*/
public static function getClassType($className)
{
// CamelCase
return strtolower(preg_replace('/^.*([A-Z][^A-Z]+)$/', '$1', $className));
}
}
?>

129
core/ClassLoader.inc Normal file
View file

@ -0,0 +1,129 @@
<?php
/**
* NRE
*
* @author coderkun <olli@coderkun.de>
* @copyright 2013 coderkun (http://www.coderkun.de)
* @license http://www.gnu.org/licenses/gpl.html
* @link http://www.coderkun.de/projects/nre
*/
namespace nre\core;
/**
* Class for safely loading classes.
*
* @author coderkun <olli@coderkun.de>
*/
class ClassLoader
{
/**
* Load a class.
*
* @throws \nre\exceptions\ClassNotFoundException
* @param string $className Name of the class to load
*/
public static function load($fullClassName)
{
// Determine folder to look in
$className = explode('\\', $fullClassName);
$className = array_slice($className, substr_count(\nre\configs\AppConfig::$app['namespace'], '\\'));
// Determine filename
$fileName = ROOT.DS.implode(DS, $className). \nre\configs\CoreConfig::getFileExt('includes');
// Check file
if(!file_exists($fileName))
{
throw new \nre\exceptions\ClassNotFoundException(
$fullClassName
);
}
// Include file
include_once($fileName);
}
/**
* Check inheritance of a class.
*
* @throws \nre\exceptions\ClassNotValidException
* @param string $className Name of the class to check
* @param string $parentClassName Name of the parent class
*/
public static function check($className, $parentClassName)
{
// Check if class is subclass of parent class
if(!is_subclass_of($className, $parentClassName)) {
throw new \nre\exceptions\ClassNotValidException(
$className
);
}
}
/**
* Strip the namespace from a class name.
*
* @param string $class Name of a class including its namespace
* @return string Name of the given class without its namespace
*/
public static function stripNamespace($class)
{
return array_slice(explode('\\', $class), -1)[0];
}
/**
* Strip the class type from a class name.
*
* @param string $className Name of a class
* @return string Name of the given class without its class type
*/
public static function stripClassType($className)
{
return preg_replace('/^(.*)[A-Z][^A-Z]+$/', '$1', $className);
}
/**
* Strip the namespace and the class type of a full class name
* to get only its name.
*
* @param string $class Full name of a class
* @return string Only the name of the given class
*/
public static function getClassName($class)
{
return self::stripClassType(self::stripNamespace($class));
}
/**
* Concatenate strings to a class name following the CamelCase
* pattern.
*
* @param string $className1 Arbitrary number of strings to concat
* @return string Class name as CamelCase
*/
public static function concatClassNames($className1)
{
return implode('', array_map(
function($arg) {
return ucfirst(strtolower($arg));
},
func_get_args()
));
}
}
?>

159
core/Component.inc Normal file
View file

@ -0,0 +1,159 @@
<?php
/**
* NRE
*
* @author coderkun <olli@coderkun.de>
* @copyright 2013 coderkun (http://www.coderkun.de)
* @license http://www.gnu.org/licenses/gpl.html
* @link http://www.coderkun.de/projects/nre
*/
namespace nre\core;
/**
* Abstract class to implement a (Controller) Component.
*
* @author coderkun <olli@coderkun.de>
*/
abstract class Component
{
/**
* Load the class of a Component.
*
* @throws \nre\exceptions\ComponentNotFoundException
* @throws \nre\exceptions\ComponentNotValidException
* @param string $componentName Name of the Component to load
*/
public static function load($componentName)
{
// Determine full classname
$className = self::getClassName($componentName);
try {
// Load class
ClassLoader::load($className);
// Validate class
ClassLoader::check($className, get_class());
}
catch(\nre\exceptions\ClassNotValidException $e) {
throw new \nre\exceptions\ComponentNotValidException($e->getClassName());
}
catch(\nre\exceptions\ClassNotFoundException $e) {
throw new \nre\exceptions\ComponentNotFoundException($e->getClassName());
}
}
/**
* Instantiate a Component (Factory Pattern).
*
* @param string $componentName Name of the Component to instantiate
*/
public static function factory($componentName)
{
// Determine full classname
$className = self::getClassName($componentName);
// Construct and return Controller
return new $className();
}
/**
* Determine the classname for the given Component name.
*
* @param string $componentName Component name to get classname of
* @return string Classname for the Component name
*/
private static function getClassName($componentName)
{
$className = \nre\core\ClassLoader::concatClassNames($componentName, \nre\core\ClassLoader::stripNamespace(get_class()));
return \nre\configs\AppConfig::$app['namespace']."controllers\\components\\$className";
}
/**
* Construct a new (Controller) Component.
*
* @throws \nre\exceptions\DriverNotFoundException
* @throws \nre\exceptions\DriverNotValidException
* @throws \nre\exceptions\ModelNotValidException
* @throws \nre\exceptions\ModelNotFoundException
*/
protected function __construct()
{
// Load Models
$this->loadModels();
}
/**
* Load the Models of this Component.
*
* @throws \nre\exceptions\DriverNotFoundException
* @throws \nre\exceptions\DriverNotValidException
* @throws \nre\exceptions\ModelNotValidException
* @throws \nre\exceptions\ModelNotFoundException
*/
protected function loadModels()
{
// Determine Models
$explicit = false;
$models = \nre\core\ClassLoader::stripClassType(\nre\core\ClassLoader::stripNamespace(get_class($this)));
if(property_exists($this, 'models'))
{
$models = $this->models;
$explicit = true;
}
if(!is_array($models)) {
$models = array($models);
}
// Models of parent classes
$parent = $this;
while($parent = get_parent_class($parent))
{
$properties = get_class_vars($parent);
if(array_key_exists('models', $properties)) {
$models = array_merge($models, $properties['models']);
}
}
$models = array_unique($models);
// Load Models
foreach($models as &$model)
{
try {
// Load class
Model::load($model);
// Construct Model
$modelName = ucfirst(strtolower($model));
$this->$modelName = Model::factory($model);
}
catch(\nre\exceptions\ModelNotValidException $e) {
if($explicit) {
throw $e;
}
}
catch(\nre\exceptions\ModelNotFoundException $e) {
if($explicit) {
throw $e;
}
}
}
}
}
?>

49
core/Config.inc Normal file
View file

@ -0,0 +1,49 @@
<?php
/**
* NRE
*
* @author coderkun <olli@coderkun.de>
* @copyright 2013 coderkun (http://www.coderkun.de)
* @license http://www.gnu.org/licenses/gpl.html
* @link http://www.coderkun.de/projects/nre
*/
namespace nre\core;
/**
* Configuration.
*
* This class does not hold any configuration value but helps to
* determine values that can be hold by AppConfig or CoreConfig.
*
* @author coderkun <olli@coderkun.de>
*/
final class Config
{
/**
* Get a default value.
*
* @param string $index Index of value to get
*/
public static function getDefault($index)
{
if(array_key_exists($index, \nre\configs\AppConfig::$defaults)) {
return \nre\configs\AppConfig::$defaults[$index];
}
if(array_key_exists($index, \nre\configs\CoreConfig::$defaults)) {
return \nre\configs\CoreConfig::$defaults[$index];
}
return null;
}
}
?>

431
core/Controller.inc Normal file
View file

@ -0,0 +1,431 @@
<?php
/**
* NRE
*
* @author coderkun <olli@coderkun.de>
* @copyright 2013 coderkun (http://www.coderkun.de)
* @license http://www.gnu.org/licenses/gpl.html
* @link http://www.coderkun.de/projects/nre
*/
namespace nre\core;
/**
* Abstract class for implementing a Controller.
*
* @author coderkun <olli@coderkun.de>
*/
abstract class Controller
{
/**
* Corresponding Agent
*
* @var Agent
*/
protected $agent;
/**
* View of the Controller
*
* @var View
*/
protected $view = null;
/**
* Data to pass to the View
*
* @var array
*/
protected $viewData = array();
/**
* Current request
*
* @var Request
*/
protected $request = null;
/**
* Current response
*
* @var Response
*/
protected $response = null;
/**
* Load the class of a Controller.
*
* @throws \nre\exceptions\ControllerNotFoundException
* @throws \nre\exceptions\ControllerNotValidException
* @param string $controllerName Name of the Controller to load
*/
public static function load($controllerName)
{
// Determine full classname
$className = self::getClassName($controllerName);
try {
// Load class
ClassLoader::load($className);
// Validate class
ClassLoader::check($className, get_class());
}
catch(\nre\exceptions\ClassNotValidException $e) {
throw new \nre\exceptions\ControllerNotValidException($e->getClassName());
}
catch(\nre\exceptions\ClassNotFoundException $e) {
throw new \nre\exceptions\ControllerNotFoundException($e->getClassName());
}
}
/**
* Instantiate a Controller (Factory Pattern).
*
* @throws \nre\exceptions\DatamodelException
* @throws \nre\exceptions\DriverNotFoundException
* @throws \nre\exceptions\DriverNotValidException
* @throws \nre\exceptions\ModelNotValidException
* @throws \nre\exceptions\ModelNotFoundException
* @throws \nre\exceptions\ViewNotFoundException
* @param string $controllerName Name of the Controller to instantiate
* @param string $layoutName Name of the current Layout
* @param string $action Current Action
* @param string $agent Corresponding Agent
*/
public static function factory($controllerName, $layoutName, $action, $agent)
{
// Determine full classname
$className = self::getClassName($controllerName);
// Construct and return Controller
return new $className($layoutName, $action, $agent);
}
/**
* Determine the classname for the given Controller name.
*
* @param string $controllerName Controller name to get classname of
* @return string Classname for the Controller name
*/
private static function getClassName($controllerName)
{
$className = \nre\core\ClassLoader::concatClassNames($controllerName, \nre\core\ClassLoader::stripNamespace(get_class()));
return \nre\configs\AppConfig::$app['namespace']."controllers\\$className";
}
/**
* Construct a new Controller.
*
* @throws \nre\exceptions\DriverNotFoundException
* @throws \nre\exceptions\DriverNotValidException
* @throws \nre\exceptions\ModelNotValidException
* @throws \nre\exceptions\ModelNotFoundException
* @throws \nre\exceptions\ViewNotFoundException
* @param string $layoutName Name of the current Layout
* @param string $action Current Action
* @param Agent $agent Corresponding Agent
*/
protected function __construct($layoutName, $action, $agent)
{
// Store values
$this->agent = $agent;
// Load Components
$this->loadComponents();
// Load Models
$this->loadModels();
// Load View
$this->loadView($layoutName, $action);
}
/**
* Prefilter that is executed before running the Controller.
*
* @param Request $request Current request
* @param Response $response Current response
*/
public function preFilter(Request $request, Response $response)
{
// Request speichern
$this->request = $request;
// Response speichern
$this->response = $response;
}
/**
* Prefilter that is executed after running the Controller.
*
* @param Request $request Current request
* @param Response $response Current response
*/
public function postFilter(Request $request, Response $response)
{
}
/**
* Run the Controller.
*
* This method executes the Action of the Controller defined by
* the current Request.
*
* @throws \nre\exceptions\ParamsNotValidException
* @throws \nre\exceptions\IdNotFoundException
* @throws \nre\exceptions\DatamodelException
* @throws \nre\exceptions\ActionNotFoundException
* @param Request $request Current request
* @param Response $response Current response
*/
public function run(Request $request, Response $response)
{
// Determine Action
$action = $response->getParam(2, 'action');
if(!method_exists($this, $action)) {
throw new \nre\exceptions\ActionNotFoundException($action);
}
// Determine parameters
$params = $response->getParams(3);
if(empty($params)) {
$params = $request->getParams(3);
}
// Fill missing parameters
$rc = new \ReflectionClass($this);
$nullParamsCount = $rc->getMethod($action)->getNumberOfParameters() - count($params);
$nullParams = ($nullParamsCount > 0 ? array_fill(0, $nullParamsCount, NULL) : array());
// Call Action
call_user_func_array(
array(
$this,
$action
),
array_merge(
$params,
$nullParams
)
);
}
/**
* Generate the output.
*
* @param array $viewData Data to pass to the View
* @return string Generated output
*/
public function render($viewData=null)
{
// Combine given data and data of this Controller
$data = $this->viewData;
if(!is_null($viewData)) {
$data = array_merge($viewData, $data);
}
// Rendern and return output
return $this->view->render($data);
}
/**
* Set data for the View.
*
* @param string $name Key
* @param mixed $data Value
*/
protected function set($name, $data)
{
$this->viewData[$name] = $data;
}
/**
* Redirect to the given URL.
*
* @param string $url Relative URL
*/
protected function redirect($url)
{
$url = 'http://'.$_SERVER['HTTP_HOST'].$url;
header('Location: '.$url);
exit;
}
/**
* Check if Models of this Controller are loaded and available.
*
* @param string $modelName Arbitrary number of Models to check
* @return bool All given Models are loaded and available
*/
protected function checkModels($modelName)
{
foreach(func_get_args() as $modelName)
{
if(!isset($this->$modelName) || !is_subclass_of($this->$modelName, 'Model')) {
return false;
}
}
return true;
}
/**
* Get the View of the Controller
*
* @return View View of the Controller
*/
protected function getView()
{
return $this->view;
}
/**
* Load the Components of this Controller.
*
* @throws \nre\exceptions\ComponentNotValidException
* @throws \nre\exceptions\ComponentNotFoundException
*/
private function loadComponents()
{
// Determine components
$components = array();
if(property_exists($this, 'components')) {
$components = $this->components;
}
if(!is_array($components)) {
$components = array($components);
}
// Components of parent classes
$parent = $this;
while($parent = get_parent_class($parent))
{
$properties = get_class_vars($parent);
if(array_key_exists('components', $properties)) {
$components = array_merge($components, $properties['components']);
}
}
// Load components
foreach($components as &$component)
{
// Load class
Component::load($component);
// Construct component
$componentName = ucfirst(strtolower($component));
$this->$componentName = Component::factory($component);
}
}
/**
* Load the Models of this Controller.
*
* @throws \nre\exceptions\DatamodelException
* @throws \nre\exceptions\DriverNotFoundException
* @throws \nre\exceptions\DriverNotValidException
* @throws \nre\exceptions\ModelNotValidException
* @throws \nre\exceptions\ModelNotFoundException
*/
protected function loadModels()
{
// Determine Models
$explicit = false;
$models = \nre\core\ClassLoader::stripClassType(\nre\core\ClassLoader::stripNamespace(get_class($this)));
if(property_exists($this, 'models'))
{
$models = $this->models;
$explicit = true;
}
if(!is_array($models)) {
$models = array($models);
}
// Models of parent classes
$parent = $this;
while($parent = get_parent_class($parent))
{
$properties = get_class_vars($parent);
if(array_key_exists('models', $properties)) {
$models = array_merge($models, $properties['models']);
}
}
$models = array_unique($models);
// Load Models
foreach($models as &$model)
{
try {
// Load class
Model::load($model);
// Construct Model
$modelName = ucfirst(strtolower($model));
$this->$modelName = Model::factory($model);
}
catch(\nre\exceptions\ModelNotValidException $e) {
if($explicit) {
throw $e;
}
}
catch(\nre\exceptions\ModelNotFoundException $e) {
if($explicit) {
throw $e;
}
}
}
}
/**
* Load the View of this Controller.
*
* @throws \nre\exceptions\ViewNotFoundException
* @param string $layoutName Name of the current Layout
* @param string $action Current Action
*/
protected function loadView($layoutName, $action)
{
// Check Layout name
if(is_null($layoutName)) {
return;
}
// Determine controller name
$controllerName = \nre\core\ClassLoader::getClassName(get_class($this));
// Load view
$isToplevel = is_subclass_of($this->agent, '\nre\agents\ToplevelAgent');
$this->view = View::loadAndFactory($layoutName, $controllerName, $action, $isToplevel);
}
}
?>

97
core/Driver.inc Normal file
View file

@ -0,0 +1,97 @@
<?php
/**
* NRE
*
* @author coderkun <olli@coderkun.de>
* @copyright 2013 coderkun (http://www.coderkun.de)
* @license http://www.gnu.org/licenses/gpl.html
* @link http://www.coderkun.de/projects/nre
*/
namespace nre\core;
/**
* Abstract class for implementing a Driver.
*
* @author coderkun <olli@coderkun.de>
*/
abstract class Driver
{
/**
* Load the class of a Driver.
*
* @throws \nre\exceptions\DriverNotFoundException
* @throws \nre\exceptions\DriverNotValidException
* @param string $driverName Name of the Driver to load
*/
public static function load($driverName)
{
// Determine full classname
$className = self::getClassName($driverName);
try {
// Load class
ClassLoader::load($className);
// Validate class
ClassLoader::check($className, get_class());
}
catch(\nre\exceptions\ClassNotValidException $e) {
throw new \nre\exceptions\DriverNotValidException($e->getClassName());
}
catch(\nre\exceptions\ClassNotFoundException $e) {
throw new \nre\exceptions\DriverNotFoundException($e->getClassName());
}
}
/**
* Instantiate a Driver (Factory Pattern).
*
* @param string $driverName Name of the Driver to instantiate
* @param array $config Configuration settings
*/
public static function factory($driverName, $config)
{
// Determine full classname
$className = self::getClassName($driverName);
// Construct and return Driver
return $className::singleton($config);
}
/**
* Determine the classname for the given Driver name.
*
* @param string $driverName Driver name to get classname of
* @return string Classname fore the Driver name
*/
private static function getClassName($driverName)
{
$className = ClassLoader::concatClassNames($driverName, ClassLoader::stripNamespace(get_class()));
return "\\nre\\drivers\\$className";
}
/**
* Construct a new Driver.
*/
protected function __construct()
{
}
}
?>

65
core/Exception.inc Normal file
View file

@ -0,0 +1,65 @@
<?php
/**
* NRE
*
* @author coderkun <olli@coderkun.de>
* @copyright 2013 coderkun (http://www.coderkun.de)
* @license http://www.gnu.org/licenses/gpl.html
* @link http://www.coderkun.de/projects/nre
*/
namespace nre\core;
/**
* Exception class.
*
* @author coderkun <olli@coderkun.de>
*/
class Exception extends \Exception
{
/**
* Construct a new exception.
*
* @param string $message Error message
* @param int $code Error code
* @param string $name Name to insert
*/
function __construct($message, $code, $name=null)
{
parent::__construct(
$this->concat(
$message,
$name
),
$code
);
}
/**
* Insert the name in a message
*
* @param string $message Error message
* @param string $name Name to insert
*/
private function concat($message, $name)
{
if(is_null($name)) {
return $message;
}
return "$message: $name";
}
}
?>

313
core/Linker.inc Normal file
View file

@ -0,0 +1,313 @@
<?php
/**
* NRE
*
* @author coderkun <olli@coderkun.de>
* @copyright 2013 coderkun (http://www.coderkun.de)
* @license http://www.gnu.org/licenses/gpl.html
* @link http://www.coderkun.de/projects/nre
*/
namespace nre\core;
/**
* Class to create web links based on the current request.
*
* @author coderkun <olli@coderkun.de>
*/
class Linker
{
/**
* Current request
*
* @var Request
*/
private $request;
/**
* Construct a new linker.
*
* @param Request $request Current request
*/
function __construct(\nre\requests\WebRequest $request)
{
$this->request = $request;
}
/**
* Mask parameters to be used in an URL.
*
* @param string $param1 First parameter
* @return string Masked parameters as string
*/
public static function createLinkParam($param1)
{
return implode(
\nre\configs\CoreConfig::$classes['linker']['url']['delimiter'],
call_user_func_array(
'\nre\core\Linker::createLinkParams',
func_get_args()
)
);
}
/**
* Mask parameters to be used in an URL.
*
* @param string $param1 First parameter
* @return string Masked parameters as array
*/
public static function createLinkParams($param1)
{
// Parameters
$linkParams = array();
$params = func_get_args();
foreach($params as $param)
{
// Delete critical signs
$specials = array('/', '?', '&', '#');
foreach($specials as &$special) {
$param = str_replace($special, '', $param);
}
// Process parameter
$param = str_replace(
' ',
\nre\configs\CoreConfig::$classes['linker']['url']['delimiter'],
substr(
$param,
0,
\nre\configs\CoreConfig::$classes['linker']['url']['length']
)
);
// Encode parameter
$linkParams[] = $param;
}
// Return link parameters
return $linkParams;
}
/**
* Create a web link.
*
* @param array $params Parameters to use
* @param int $offset Ignore first parameters
* @param bool $exclusiveParams Use only the given parameters
* @param array $getParams GET-parameter to use
* @param bool $exclusiveGetParams Use only the given GET-parameters
* @param string $anchor Target anchor
* @param bool $absolute Include hostname etc. for an absolute URL
* @return string Created link
*/
public function link($params=null, $offset=0, $exclusiveParams=true, $getParams=null, $exclusiveGetParams=true, $anchor=null, $absolute=false)
{
// Make current request to response
$response = new \nre\responses\WebResponse();
// Check parameters
if(is_null($params)) {
$params = array();
}
elseif(!is_array($params)) {
$params = array($params);
}
// Set parameters from request
$reqParams = array_slice($this->request->getParams(), 1, $offset);
if(count($reqParams) < $offset && $offset > 0) {
$reqParams[] = $this->request->getParam(1, 'intermediate');
}
if(count($reqParams) < $offset && $offset > 1) {
$reqParams[] = $this->request->getParam(2, 'action');
}
$params = array_merge($reqParams, $params);
// Use Layout
$layout = \nre\configs\AppConfig::$defaults['toplevel'];
if(!empty($getParams) && array_key_exists('layout', $getParams)) {
$layout = $getParams['layout'];
}
array_unshift($params, $layout);
// Use parameters from request only
if(!$exclusiveParams)
{
$params = array_merge(
$params,
array_slice(
$this->request->getParams(),
count($params)
)
);
}
// Encode parameters
$params = array_map('rawurlencode', $params);
// Set parameters
call_user_func_array(
array(
$response,
'addParams'
),
$params
);
// Check GET-parameters
if(is_null($getParams)) {
$getParams = array();
}
elseif(!is_array($params)) {
$params = array($params);
}
if(!$exclusiveGetParams)
{
$getParams = array_merge(
$this->request->getGetParams(),
$getParams
);
}
// Set GET-parameters
$response->addGetParams($getParams);
// Create and return link
return self::createLink($this->request, $response, $anchor, $absolute);
}
/**
* Create a link from an URL.
*
* @param string $url URL to create link from
* @param bool $absolute Create absolute URL
* @return string Created link
*/
public function hardlink($url, $absolute=false)
{
return $this->createUrl($url, $this->request, $absolute);
}
/**
* Create a link.
*
* @param Request $request Current request
* @param Response $response Current response
* @param string $anchor Anchor on target
* @param bool $absolute Create absolute link
* @return string Created link
*/
private static function createLink(Request $request, Response $response, $anchor=null, $absolute=false)
{
// Check response
if(is_null($response)) {
return null;
}
// Get parameters
$params = $response->getParams(1);
// Check Action
if(count($params) == 2 && $params[1] == \nre\configs\CoreConfig::$defaults['action']) {
array_pop($params);
}
// Set parameters
$link = implode('/', $params);
// Apply reverse-routes
$link = $request->applyReverseRoutes($link);
// Get GET-parameters
$getParams = $response->getGetParams();
// Layout überprüfen
if(array_key_exists('layout', $getParams) && $getParams['layout'] == \nre\configs\AppConfig::$defaults['toplevel']) {
unset($getParams['layout']);
}
// Set GET-parameters
if(array_key_exists('url', $getParams)) {
unset($getParams['url']);
}
if(count($getParams) > 0) {
$link .= '?'.http_build_query($getParams);
}
// Add anchor
if(!is_null($anchor)) {
$link .= "#$anchor";
}
// Create URL
$url = self::createUrl($link, $request, $absolute);
return $url;
}
/**
* Adapt a link to the environment.
*
* @param string $url URL
* @param Request $request Current request
* @param bool $absolute Create absolute URL
* @return string Adapted URL
*/
private static function createUrl($url, Request $request, $absolute=false)
{
// Variables
$server = $_SERVER['SERVER_NAME'];
$uri = $_SERVER['REQUEST_URI'];
$prefix = '';
// Determine prefix
$ppos = array(strlen($uri));
if(($p = strpos($uri, '/'.$request->getParam(1, 'intermediate'))) !== false) {
$ppos[] = $p;
}
$prefix = substr($uri, 0, min($ppos));
// Create absolute URL
if($absolute) {
$prefix = "http://$server/".trim($prefix, '/');
}
// Put URL together
$url = rtrim($prefix, '/').'/'.ltrim($url, '/');
// Return URL
return $url;
}
}
?>

143
core/Logger.inc Normal file
View file

@ -0,0 +1,143 @@
<?php
/**
* NRE
*
* @author coderkun <olli@coderkun.de>
* @copyright 2013 coderkun (http://www.coderkun.de)
* @license http://www.gnu.org/licenses/gpl.html
* @link http://www.coderkun.de/projects/nre
*/
namespace nre\core;
/**
* Class to log messages to different targets.
*
* @author coderkun <olli@coderkun.de>
*/
class Logger
{
/**
* Log mode: Detect automatic
*
* @var int
*/
const LOGMODE_AUTO = 0;
/**
* Log mode: Print to screen
*
* @var int
*/
const LOGMODE_SCREEN = 1;
/**
* Log mode: Use PHP-logging mechanism
*
* @var int
*/
const LOGMODE_PHP = 2;
/**
* Do not auto-log to screen
*
* @var boolean
*/
private $autoLogToScreenDisabled = false;
/**
* Construct a new logger.
*/
public function __construct()
{
}
/**
* Log a message.
*
* @param string $message Message to log
* @param int $logMode Log mode to use
*/
public function log($message, $logMode=self::LOGMODE_AUTO)
{
// Choose log mode automatically
if($logMode == self::LOGMODE_AUTO) {
$logMode = $this->getAutoLogMode();
}
// Print message to screen
if($logMode & self::LOGMODE_SCREEN) {
$this->logToScreen($message);
}
// Use PHP-logging mechanism
if($logMode & self::LOGMODE_PHP) {
$this->logToPhp($message);
}
}
/**
* Disable logging to screen when the log mode is automatically
* detected.
*/
public function disableAutoLogToScreen()
{
$this->autoLogToScreenDisabled = true;
}
/**
* Print a message to screen.
*
* @param string $message Message to print
*/
private function logToScreen($message)
{
echo "$message<br>\n";
}
/**
* Log a message by using PHP-logging mechanism.
*
* @param string $message Message to log
*/
private function logToPhp($message)
{
error_log($message, 0);
}
/**
* Detect log mode automatically by distinguishing between
* production and test environment.
*
* @return int Automatically detected log mode
*/
private function getAutoLogMode()
{
return ($this->isLocalhost() && !$this->autoLogToScreenDisabled) ? self::LOGMODE_SCREEN : self::LOGMODE_PHP;
}
/**
* Detect if the server is running as localhost without domain.
*
* @return boolean Wheather server is running as localhost or not
*/
private function isLocalhost()
{
return (strpos($_SERVER['HTTP_HOST'], '.') === false);
}
}
?>

141
core/Model.inc Normal file
View file

@ -0,0 +1,141 @@
<?php
/**
* NRE
*
* @author coderkun <olli@coderkun.de>
* @copyright 2013 coderkun (http://www.coderkun.de)
* @license http://www.gnu.org/licenses/gpl.html
* @link http://www.coderkun.de/projects/nre
*/
namespace nre\core;
/**
* Abstract class for implementing a Model.
*
* @author coderkun <olli@coderkun.de>
*/
abstract class Model
{
/**
* Load the class of a Model.
*
* @throws \nre\exceptions\ModelNotFoundException
* @throws \nre\exceptions\ModelNotValidException
* @param string $modelName Name of the Model to load
*/
public static function load($modelName)
{
// Determine full classname
$className = self::getClassName($modelName);
try {
// Load class
ClassLoader::load($className);
// Validate class
ClassLoader::check($className, get_class());
}
catch(\nre\exceptions\ClassNotValidException $e) {
throw new \nre\exceptions\ModelNotValidException($e->getClassName());
}
catch(\nre\exceptions\ClassNotFoundException $e) {
throw new \nre\exceptions\ModelNotFoundException($e->getClassName());
}
}
/**
* Instantiate a Model (Factory Pattern).
*
* @param string $modelName Name of the Model to instantiate
*/
public static function factory($modelName)
{
// Determine full classname
$className = self::getClassName($modelName);
// Construct and return Model
return new $className();
}
/**
* Determine the classname for the given Model name.
*
* @param string $modelName Model name to get classname of
* @return string Classname fore the Model name
*/
private static function getClassName($modelName)
{
$className = ClassLoader::concatClassNames($modelName, ClassLoader::stripNamespace(get_class()));
return \nre\configs\AppConfig::$app['namespace']."models\\$className";
}
/**
* Construct a new Model.
*
* TODO Catch exception
*
* @throws \nre\exceptions\DatamodelException
* @throws \nre\exceptions\DriverNotFoundException
* @throws \nre\exceptions\DriverNotValidException
* @throws \nre\exceptions\ModelNotValidException
* @throws \nre\exceptions\ModelNotFoundException
*/
protected function __construct()
{
// Load Models
$this->loadModels();
}
/**
* Load the Models of this Model.
*
* @throws \nre\exceptions\DatamodelException
* @throws \nre\exceptions\DriverNotFoundException
* @throws \nre\exceptions\DriverNotValidException
* @throws \nre\exceptions\ModelNotValidException
* @throws \nre\exceptions\ModelNotFoundException
*/
private function loadModels()
{
// Determine Models
$models = array();
if(property_exists($this, 'models')) {
$models = $this->models;
}
if(!is_array($models)) {
$models = array($models);
}
// Load Models
foreach($models as $model)
{
// Load class
Model::load($model);
// Construct Model
$modelName = ucfirst(strtolower($model));
$this->$modelName = Model::factory($model);
}
}
}
?>

64
core/Request.inc Normal file
View file

@ -0,0 +1,64 @@
<?php
/**
* NRE
*
* @author coderkun <olli@coderkun.de>
* @copyright 2013 coderkun (http://www.coderkun.de)
* @license http://www.gnu.org/licenses/gpl.html
* @link http://www.coderkun.de/projects/nre
*/
namespace nre\core;
/**
* Base class to represent a request.
*
* @author coderkun <olli@coderkun.de>
*/
class Request
{
/**
* Passed parameters
*
* @var array
*/
protected $params = array();
/**
* Get a parameter.
*
* @param int $index Index of parameter
* @param string $defaultIndex Index of default configuration value for this parameter
* @return string Value of parameter
*/
public function getParam($index, $defaultIndex=null)
{
// Return parameter
if(count($this->params) > $index) {
return $this->params[$index];
}
// Return default value
return \nre\core\Config::getDefault($defaultIndex);
}
/**
* Get all parameters from index on.
*
* @param int $offset Offset-index
* @return array Parameter values
*/
public function getParams($offset=0)
{
return array_slice($this->params, $offset);
}
}
?>

158
core/Response.inc Normal file
View file

@ -0,0 +1,158 @@
<?php
/**
* NRE
*
* @author coderkun <olli@coderkun.de>
* @copyright 2013 coderkun (http://www.coderkun.de)
* @license http://www.gnu.org/licenses/gpl.html
* @link http://www.coderkun.de/projects/nre
*/
namespace nre\core;
/**
* Base class to represent a response.
*
* @author coderkun <olli@coderkun.de>
*/
class Response
{
/**
* Applied parameters
*
* @var array
*/
protected $params = array();
/**
* Generated output
*
* @var string
*/
private $output = '';
/**
* Abort futher execution
*
* @var bool
*/
private $exit = false;
/**
* Add a parameter.
*
* @param mixed $value Value of parameter
*/
public function addParam($value)
{
$this->params[] = $value;
}
/**
* Add multiple parameters.
*
* @param mixed $value1 Value of first parameter
* @param mixed Values of further parameters
*/
public function addParams($value1)
{
$this->params = array_merge(
$this->params,
func_get_args()
);
}
/**
* Delete all stored parameters (from offset on).
*
* @param int $offset Offset-index
*/
public function clearParams($offset=0)
{
$this->params = array_slice($this->params, 0, $offset);
}
/**
* Get a parameter.
*
* @param int $index Index of parameter
* @param string $defaultIndex Index of default configuration value for this parameter
* @return string Value of parameter
*/
public function getParam($index, $defaultIndex=null)
{
// Return parameter
if(count($this->params) > $index) {
return $this->params[$index];
}
// Return default value
return \nre\core\Config::getDefault($defaultIndex);
}
/**
* Get all parameters from index on.
*
* @param int $offset Offset-index
* @return array Parameter values
*/
public function getParams($offset=0)
{
return array_slice($this->params, $offset);
}
/**
* Set output.
*
* @param string $output Generated output
*/
public function setOutput($output)
{
$this->output = $output;
}
/**
* Get generated output.
*
* @return string Generated output
*/
public function getOutput()
{
return $this->output;
}
/**
* Set exit-state.
*
* @param bool $exit Abort further execution
*/
public function setExit($exit=true)
{
$this->exit = $exit;
}
/**
* Get exit-state.
*
* @return bool Abort further execution
*/
public function getExit()
{
return $this->exit;
}
}
?>

124
core/View.inc Normal file
View file

@ -0,0 +1,124 @@
<?php
/**
* NRE
*
* @author coderkun <olli@coderkun.de>
* @copyright 2013 coderkun (http://www.coderkun.de)
* @license http://www.gnu.org/licenses/gpl.html
* @link http://www.coderkun.de/projects/nre
*/
namespace nre\core;
/**
* View.
*
* Class to encapsulate a template file and to provide rendering methods.
*
* @author coderkun <olli@coderkun.de>
*/
class View
{
/**
* Template filename
*
* @var string
*/
protected $templateFilename;
/**
* Load and instantiate the View of an Agent.
*
* @throws \nre\exceptions\ViewNotFoundException
* @param string $layoutName Name of Layout in use
* @param string $agentName Name of the Agent
* @param string $action Current Action
* @param bool $isToplevel Agent is a ToplevelAgent
*/
public static function loadAndFactory($layoutName, $agentName=null, $action=null, $isToplevel=false)
{
return new View($layoutName, $agentName, $action, $isToplevel);
}
/**
* Construct a new View.
*
* @throws \nre\exceptions\ViewNotFoundException
* @param string $layoutName Name of Layout in use
* @param string $agentName Name of the Agent
* @param string $action Current Action
* @param bool $isToplevel Agent is a ToplevelAgent
*/
protected function __construct($layoutName, $agentName=null, $action=null, $isToplevel=false)
{
// Create template filename
// LayoutName
$fileName = ROOT.DS. \nre\configs\CoreConfig::getClassDir('views').DS. strtolower($layoutName).DS;
// AgentName and Action
if(strtolower($agentName) != strtolower($layoutName) || !$isToplevel) {
$fileName .= strtolower($agentName).DS.strtolower($action);
}
else {
$fileName .= strtolower($layoutName);
}
// File extension
$fileName .= \nre\configs\CoreConfig::getFileExt('views');
// Check template file
if(!file_exists($fileName)) {
throw new \nre\exceptions\ViewNotFoundException($fileName);
}
// Save filename
$this->templateFilename = $fileName;
}
/**
* Generate output
*
* @param array $data Data to have available in the template file
*/
public function render($data)
{
// Extract data
if(!is_null($data)) {
extract($data, EXTR_SKIP);
}
// Buffer output
ob_start();
// Include template
include($this->templateFilename);
// Return buffered output
return ob_get_clean();
}
/**
* Get template filename.
*
* @return string Template filename
*/
public function getTemplateFilename()
{
return $this->templateFilename;
}
}
?>

75
core/WebUtils.inc Normal file
View file

@ -0,0 +1,75 @@
<?php
/**
* NRE
*
* @author coderkun <olli@coderkun.de>
* @copyright 2013 coderkun (http://www.coderkun.de)
* @license http://www.gnu.org/licenses/gpl.html
* @link http://www.coderkun.de/projects/nre
*/
namespace nre\core;
/**
* Class that holds several web-specific methods and properties.
*
* @author coderkun <olli@coderkun.de>
*/
class WebUtils
{
/**
* HTTP-statuscode 403: Forbidden
*
* @var int
*/
const HTTP_FORBIDDEN = 403;
/**
* HTTP-statuscode 404: Not Found
*
* @var int
*/
const HTTP_NOT_FOUND = 404;
/**
* HTTP-statuscode 503: Service Unavailable
*
* @var int
*/
const HTTP_SERVICE_UNAVAILABLE = 503;
/**
* HTTP-header strings
*
* @var array
*/
public static $httpStrings = array(
200 => 'OK',
304 => 'Not Modified',
403 => 'Forbidden',
404 => 'Not Found',
503 => 'Service Unavailable'
);
/**
* Get the HTTP-header of a HTTP-statuscode
*
* @param int $httpStatusCode HTTP-statuscode
* @return string HTTP-header of HTTP-statuscode
*/
public static function getHttpHeader($httpStatusCode)
{
if(!array_key_exists($httpStatusCode, self::$httpStrings)) {
$httpStatusCode = 200;
}
return sprintf("HTTP/1.1 %d %s\n", $httpStatusCode, self::$httpStrings[$httpStatusCode]);
}
}
?>