/** * Gets the export view for the provided extension * @param string $extension * @return ExportView */ public function getExportView($extension) { if (!array_key_exists($extension, $this->extensions)) { throw new ZiboException($extension . ' is not a registered export extension'); } $objectFactory = new ObjectFactory(); return $objectFactory->create($this->extensions[$extension], self::INTERFACE_EXPORT_VIEW); }
public function testCreateNonExistingClassThrowsException() { try { $this->factory->create('nonExistingClass'); $this->fail('Exception expected for creating instance of non existing class'); } catch (ZiboException $e) { } }
/** * Constructs a new model manager * @return null */ private function __construct() { $this->models = array(); $objectFactory = new ObjectFactory(); $modelIO = $objectFactory->createFromConfig(self::CONFIG_MODEL_IO, self::DEFAULT_MODEL_IO, self::INTERFACE_MODEL_IO); $modelReader = new ModelReader($modelIO); $this->modelLoader = new ModelLoader($modelReader); $this->modelCache = $objectFactory->createFromConfig(self::CONFIG_MODEL_CACHE, self::DEFAULT_MODEL_CACHE, self::INTERFACE_MODEL_CACHE); }
/** * Creates a model * @param zibo\library\orm\definition\ModelTable $table Table definition of the model * @param string $modelClassName Class name for the model * @param string $dataClassName Class name for the data objects of the model * @return zibo\library\orm\model\Model * @throws */ public function createModel(ModelTable $table, $modelClassName = null, $dataClassName = null) { if (is_null($modelClassName)) { $modelClassName = ModelManager::DEFAULT_MODEL; } elseif (String::isEmpty($modelClassName)) { throw new ModelException('Provided class name for the model is empty'); } $modelMeta = new ModelMeta($table, $dataClassName); $objectFactory = new ObjectFactory(); return $objectFactory->create($modelClassName, ModelManager::INTERFACE_MODEL, array($modelMeta)); }
/** * Creates an instance of the provided dependency * @param string $interface Full class name of the interface or parent class * @param Dependency $dependency Definition of the class to create * @param array $exclude Array with the interface as key and an array with * id's of dependencies as key to exclude from the get calls. * @return mixed Instance of the dependency * @throws zibo\ZiboException when the dependency could not be created */ protected function create($interface, Dependency $dependency, array $exclude = null) { if (!self::$objectFactory) { self::$objectFactory = new ObjectFactory(); } if (!$exclude) { $exclude = array($interface => array($dependency->getId() => true)); } elseif (!isset($exclude[$interface])) { $exclude[$interface] = array($dependency->getId() => true); } else { $exclude[$interface][$dependency->getId()] = true; } $className = $dependency->getClassName(); $arguments = $dependency->getConstructorArguments(); $arguments = $this->getCallbackArguments($arguments, $exclude); $instance = self::$objectFactory->create($className, $interface, $arguments); $calls = $dependency->getCalls(); if ($calls) { foreach ($calls as $call) { $arguments = $this->getCallbackArguments($call->getArguments(), $exclude); $callback = new Callback(array($instance, $call->getMethodName())); $callback->invokeWithArrayArguments($arguments); } } return $instance; }
/** * Loads the profiles from the Zibo configuration. * @return array Array with Profile instances */ public function loadProfiles() { $profiles = array(); $configProfiles = Zibo::getInstance()->getConfigValue(self::CONFIG_PROFILES); if (!$configProfiles) { return $profiles; } if (!is_array($configProfiles)) { $configProfiles = array($configProfiles); } $objectFactory = new ObjectFactory(); foreach ($configProfiles as $name => $profileClassName) { $profile = $objectFactory->create($profileClassName, self::INTERFACE_PROFILE); $profiles[$name] = $profile; } return $profiles; }
/** * Loads the defined modules from the Zibo Configuration * @param zibo\core\Zibo $zibo Instance of Zibo * @return array Array with the defined modules * @throws zibo\ZiboException when a module could not be created * @see Module * @see CONFIG_MODULE */ public function loadModules(Zibo $zibo) { $configModules = $zibo->getConfigValue(self::CONFIG_MODULE); if (!$configModules) { return array(); } $objectFactory = new ObjectFactory(); $modules = array(); $configModules = Config::parseConfigTree($configModules); foreach ($configModules as $configKey => $moduleClass) { try { $modules[] = $objectFactory->create($moduleClass, self::INTERFACE_MODULE); } catch (ZiboException $exception) { throw new ZiboException('Could not create ' . $moduleClass . ' from the ' . $configKey . ' configuration key', 0, $exception); } } return $modules; }
/** * Gets the controller of a request. If the controller class name is the same as the clasa name * of the controller which is set through setController, the set controller will be used instead * of creating a new one. * @param Request $request * @return Controller * @throws zibo\ZiboException when no object factory has been set * @throws zibo\ZiboException when the controller could not be created */ protected function getController(Request $request) { try { $controller = $this->objectFactory->create($request->getControllerName(), self::INTERFACE_CONTROLLER); } catch (ZiboException $exception) { throw new ZiboException('Could not create controller ' . $request->getControllerName(), 0, $exception); } return $controller; }
/** * Loads the modifiers from the Zibo configuration * @return null */ private function loadModifiers() { $this->modifiers = array(); $objectFactory = new ObjectFactory(); $modifiers = Zibo::getInstance()->getConfigValue(self::CONFIG_MODIFIERS); foreach ($modifiers as $name => $className) { $this->modifiers[$name] = $objectFactory->create($className, self::INTERFACE_MODIFIER); } }
/** * Loads a set of requirements from the Zibo configuration. The checks of the requirements are also invoked * @param string $configKey The configuration key for the requirement set * @return array Array with Requirement instances */ public function loadRequirements($configKey) { $requirements = array(); $configRequirements = Zibo::getInstance()->getConfigValue($configKey); if (!$configRequirements) { return $requirements; } if (!is_array($configRequirements)) { $configRequirements = array($configRequirements); } $objectFactory = new ObjectFactory(); foreach ($configRequirements as $requirementClassName) { $requirement = $objectFactory->create($requirementClassName, self::INTERFACE_REQUIREMENT); $requirement->performCheck(); $requirements[] = $requirement; } return $requirements; }
/** * Gets all the available widgets * @return array Array with the namespace as key and an array as value. The array as value has * the name of the widget as key and an instance of the widget as value */ public function getWidgets() { $widgets = array(); foreach ($this->widgets as $namespace => $widgetClasses) { $widgets[$namespace] = array(); foreach ($widgetClasses as $name => $widgetClass) { $widgets[$namespace][$name] = $this->objectFactory->create($widgetClass, self::INTERFACE_WIDGET); } } return $this->orderWidgets($widgets); }
/** * Create a data container for the model * @param zibo\library\orm\model\meta\ModelMeta $meta the meta of the model * @param zibo\library\ObjectFactory $objectFactory factory for new objects * @param boolean $initialize set to true to get an object with default values, false to get an empty object * @return mixed a data container for the model */ private function initData(ModelMeta $meta, ObjectFactory $objectFactory, $initialize) { $data = $objectFactory->create($meta->getDataClassName()); if (!$initialize) { return $data; } $fields = $meta->getFields(); foreach ($fields as $field) { $name = $field->getName(); if ($field instanceof BelongsToField || $field instanceof HasOneField) { $data->{$name} = null; continue; } if ($field instanceof HasManyField) { $data->{$name} = array(); continue; } $data->{$name} = $field->getDefaultValue(); } return $data; }
/** * Gets the controller of a request. If the controller class name is the same as the clasa name * of the controller which is set through setController, the set controller will be used instead * of creating a new one. * @param Request $request * @return Controller * @throws zibo\ZiboException when no object factory has been set * @throws zibo\ZiboException when the controller could not be created */ protected function getController(Request $request) { if ($this->controller && $request->getControllerName() == get_class($this->controller)) { return $this->controller; } if ($this->objectFactory === null) { throw new ZiboException('Could not create controller ' . $request->getControllerName() . ': no ObjectFactory set'); } try { $controller = $this->objectFactory->create($request->getControllerName(), self::INTERFACE_CONTROLLER); } catch (ZiboException $e) { throw new ZiboException('Could not create controller ' . $request->getControllerName(), 0, $e); } return $controller; }
/** * Creates the opcode cache i/o from the Zibo configuration * @return zibo\library\cache\io\OpCacheIO */ public static function createIOFromConfig() { $class = Zibo::getInstance()->getConfigValue(self::CONFIG_IO); if (!$class) { throw new ZiboException('No opcode cache implementation set. Please set the ' . self::CONFIG_IO . ' configuration value.'); } $objectFactory = new ObjectFactory(); return $objectFactory->create($class, self::INTERFACE_IO); }
/** * Deliver this message to the mail transport * @param array $variables Variables for the mail * @param zibo\library\mail\transport\Mail $transport The transport implementation to use, if not provided, the transport will be provided throught the Zibo configuration * @return null */ public function send(array $variables = array(), Transport $transport = null) { if ($transport === null) { $objectFactory = new ObjectFactory(); $transport = $objectFactory->createFromConfig(self::CONFIG_TRANSPORT, self::DEFAULT_TRANSPORT, self::INTERFACE_TRANSPORT); } $transport->send($this, $variables); }
private function setDependencyInjector() { // creates the dependency injector $this->dependencyInjector = new DependencyInjector(); // gets the dependency container through the configuration $dependencyIO = $this->getConfigValue(self::CONFIG_DEPENDENCY_IO); if ($dependencyIO) { $objectFactory = new ObjectFactory(); $dependencyIO = $objectFactory->create($dependencyIO, self::INTERFACE_DEPENDENCY_IO); $container = $dependencyIO->getContainer($this); $this->dependencyInjector->setContainer($container); $this->dependencyInjector->setInstance($objectFactory); } // set Zibo to the dependency injector $this->dependencyInjector->setInstance($this); $this->dependencyInjector->setInstance($this->getEnvironment(), self::INTERFACE_ENVIRONMENT); $this->dependencyInjector->setInstance($this->fileBrowser, self::INTERFACE_FILE_BROWSER); }
/** * Action to create a diagram of the models * @return null */ public function erdAction() { if (!class_exists(self::CLASS_ERD) || func_num_args()) { $this->setError404(); return; } ini_set('max_execution_time', '300'); ini_set('memory_limit', '512M'); $models = ModelManager::getInstance()->getModels(true); $objectFactory = new ObjectFactory(); $layout = $objectFactory->createFromConfig(self::CONFIG_ERD_LAYOUT, self::DEFAULT_ERD_LAYOUT, self::INTERFACE_ERD_LAYOUT); $erd = new Erd(); $erd->setLayout($layout); $file = $erd->getFile($models); $this->setDownloadView($file); }
/** * Gets the negotiator implementation to use for locale negotiation. * * You can configure which class is being used with the configuration key "i18n.negotiator". * * @return zibo\library\i18n\locale\negotiator\Negotiator */ private function getNegotiator() { if (!$this->negotiator) { $objectFactory = new ObjectFactory(); $this->negotiator = $objectFactory->createFromConfig(self::CONFIG_NEGOTIATOR, self::CLASS_NEGOTIATOR, self::INTERFACE_NEGOTIATOR); } return $this->negotiator; }
/** * Registers a captcha in the manager * @param string $name Internal name of the captcha * @param string $className Class name of the captcha * @return null * @throws zibo\ZiboException when the internal name or class name is empty or invalid * @throws zibo\ZiboException when the captcha does not exist or is not a valid captcha class */ public function registerCaptcha($name, $className) { if (String::isEmpty($name)) { throw new ZiboException('Provided name is empty'); } if (String::isEmpty($className)) { throw new ZiboException('Provided captcha class name is empty'); } $objectFactory = new ObjectFactory(); $this->captchas[$name] = $objectFactory->create($className, self::INTERFACE_CAPTCHA); if (!$this->defaultCaptchaName) { $this->defaultCaptchaName = $name; } }
/** * Gets the view * @param array $result * @param joppa\content\model\ContentProperties $properties * @param integer $pages * @param integer $page * @return joppa\content\view\ContentView */ private function getView(array $result, ContentProperties $contentProperties, $pages = 1, $page = 1) { $view = $contentProperties->getView(); $listViews = ContentViewFactory::getInstance()->getOverviewViews(); if (!array_key_exists($view, $listViews)) { return null; } $viewClass = $listViews[$view]; $paginationProperties = null; if ($contentProperties->willShowPagination() && $pages > 1) { $paginationUrl = $this->request->getBasePath() . Request::QUERY_SEPARATOR . self::ACTION_PAGE . Request::QUERY_SEPARATOR . '%page%'; $paginationProperties = new PaginationProperties($paginationUrl, $pages, $page); } $moreUrl = null; if ($contentProperties->willShowMoreLink()) { $node = $this->models[NodeModel::NAME]->getNode($contentProperties->getMoreNode(), 0, $this->locale); $moreUrl = $this->request->getBaseUrl() . Request::QUERY_SEPARATOR . $node->getRoute(); } $objectFactory = new ObjectFactory(); $view = $objectFactory->create($viewClass, ContentViewFactory::INTERFACE_OVERVIEW); $view->setContent($this->properties->getWidgetId(), $result, $contentProperties, $paginationProperties, $moreUrl); return $view; }
/** * Loads the data managers from the Zibo configuration * @return null */ private function loadManagers() { $this->managers = array(); $objectFactory = new ObjectFactory(); $managers = Zibo::getInstance()->getConfigValue(self::CONFIG_MANAGERS); foreach ($managers as $name => $managerClass) { try { $manager = $objectFactory->create($managerClass, self::INTERFACE_MANAGER); $this->managers[$name] = $manager; } catch (Exception $exception) { Zibo::getInstance()->runEvent(Zibo::EVENT_LOG, $exception->getMessage(), $exception->getTraceAsString(), 1); } } }
/** * Get the model from the model element * @param DOMElement $modelElement model element in the xml root element * @param zibo\library\filesystem\File $file the file which is being read * @return zibo\library\orm\Model Model instance created from the read model definition * @throws zibo\library\orm\exception\OrmException when the model element has no name attribute */ protected function getModelFromElement(DOMElement $modelElement, File $file) { $modelName = $modelElement->getAttribute(self::ATTRIBUTE_NAME); if ($modelName == null) { throw new OrmException('No ' . self::ATTRIBUTE_NAME . ' attribute found for ' . self::TAG_MODEL . ' tag in ' . $file->getPath()); } $group = $modelElement->getAttribute(self::ATTRIBUTE_GROUP) ? $modelElement->getAttribute(self::ATTRIBUTE_GROUP) : null; $modelClassName = $modelElement->hasAttribute(self::ATTRIBUTE_MODEL_CLASS) ? $modelElement->getAttribute(self::ATTRIBUTE_MODEL_CLASS) : ModelManager::DEFAULT_MODEL; $dataClassName = $modelElement->hasAttribute(self::ATTRIBUTE_DATA_CLASS) ? $modelElement->getAttribute(self::ATTRIBUTE_DATA_CLASS) : ModelMeta::CLASS_DATA; $isLogged = $modelElement->getAttribute(self::ATTRIBUTE_LOG) ? Boolean::getBoolean($modelElement->getAttribute(self::ATTRIBUTE_LOG)) : false; $willBlockDeleteWhenUsed = $modelElement->getAttribute(self::ATTRIBUTE_WILL_BLOCK_DELETE) ? Boolean::getBoolean($modelElement->getAttribute(self::ATTRIBUTE_WILL_BLOCK_DELETE)) : false; $modelTable = new ModelTable($modelName, $isLogged); $modelTable->setGroup($group); $modelTable->setWillBlockDeleteWhenUsed($willBlockDeleteWhenUsed); $fields = $this->getFieldsFromElement($modelElement, $file, $modelName); foreach ($fields as $field) { $modelTable->addField($field); } $this->setIndexesFromElement($modelElement, $modelTable); $this->setFormatsFromElement($modelElement, $modelTable); $modelMeta = new ModelMeta($modelTable, $dataClassName); $objectFactory = new ObjectFactory(); return $objectFactory->create($modelClassName, ModelManager::INTERFACE_MODEL, array($modelMeta)); }
/** * Constructs a new translation manager * @return null * * @uses zibo\library\ObjectFactory::createFromConfig() */ public function __construct() { $objectFactory = new ObjectFactory(); $this->io = $objectFactory->createFromConfig(self::CONFIG_IO, self::CLASS_IO, self::INTERFACE_IO); $this->translators = array(); }
/** * Initializes the hash algorithm from the Zibo configuration * @param zibo\core\Zibo $zibo The Zibo instance * @param zibo\library\ObjectFactory $objectFactory Instance of an object factory * @return null */ private function initializeHashAlgorithm(Zibo $zibo, ObjectFactory $objectFactory) { $hashAlgorithms = $zibo->getConfigValue(EncryptionModule::CONFIG_HASH_ALGORITHM); $hashAlgorithmName = $zibo->getConfigValue(self::CONFIG_HASH_ALGORITHM, self::DEFAULT_HASH_ALGORITHM); if (!array_key_exists($hashAlgorithmName, $hashAlgorithms)) { throw new ZiboException('Provided password hash algorithm ' . $hashAlgorithmName . ' could not be found'); } $hashAlgorithmClass = $hashAlgorithms[$hashAlgorithmName]; $this->hashAlgorithm = $objectFactory->create($hashAlgorithmClass, EncryptionModule::INTERFACE_HASH_ALGORITHM); }
/** * Get the route I/O implementation. When no implementation is provided through the constructor, * a new implementation will be constructed based on the configuration. * @return zibo\core\router\io\RouterIO */ protected final function getIO() { if ($this->io) { return $this->io; } $objectFactory = new ObjectFactory(); $this->io = $objectFactory->createFromConfig(self::CONFIG_ROUTER_IO, self::DEFAULT_ROUTER_IO, self::CLASS_ROUTER_IO); return $this->io; }
/** * Gets the view * @param joppa\content\model\ContentProperties $properties * @param joppa\model\content\Content $content * @return joppa\content\view\ContentView */ private function getView(ContentProperties $contentProperties, $content) { $view = $contentProperties->getView(); $detailViews = ContentViewFactory::getInstance()->getDetailViews(); if (!array_key_exists($view, $detailViews)) { return null; } $viewClass = $detailViews[$view]; $objectFactory = new ObjectFactory(); $view = $objectFactory->create($viewClass, ContentViewFactory::INTERFACE_DETAIL); $view->setContent($this->properties->getWidgetId(), $content, $contentProperties); return $view; }
/** * Load the content mappers as defined in the Zibo configuration * @return null */ private function loadMappers() { $mappers = Zibo::getInstance()->getConfigValue(self::CONFIG_MAPPERS, array()); $objectFactory = new ObjectFactory(); $this->mappers = array(); foreach ($mappers as $type => $className) { $mapper = $objectFactory->create($className, self::CLASS_MAPPER); $this->mappers[$type] = $mapper; } }