Code Coverage |
||||||||||
Classes and Traits |
Functions and Methods |
Lines |
||||||||
Total | |
100.00% |
1 / 1 |
|
100.00% |
22 / 22 |
CRAP | |
100.00% |
185 / 185 |
PageDefinition | |
100.00% |
1 / 1 |
|
100.00% |
22 / 22 |
57 | |
100.00% |
185 / 185 |
__construct(\Scrivo\Context $context=null) | |
100.00% |
1 / 1 |
2 | |
100.00% |
8 / 8 |
|||
__get($name) | |
100.00% |
1 / 1 |
10 | |
100.00% |
10 / 10 |
|||
__set($name, $value) | |
100.00% |
1 / 1 |
7 | |
100.00% |
7 / 7 |
|||
setFields(\Scrivo\Context $context, array $rd) | |
100.00% |
1 / 1 |
2 | |
100.00% |
10 / 10 |
|||
getProperties() | |
100.00% |
1 / 1 |
2 | |
100.00% |
5 / 5 |
|||
getTabs() | |
100.00% |
1 / 1 |
2 | |
100.00% |
5 / 5 |
|||
setTitle(\Scrivo\String $title) | |
100.00% |
1 / 1 |
1 | |
100.00% |
2 / 2 |
|||
setDescription(\Scrivo\String $description) | |
100.00% |
1 / 1 |
1 | |
100.00% |
2 / 2 |
|||
setFileName(\Scrivo\String $action) | |
100.00% |
1 / 1 |
1 | |
100.00% |
2 / 2 |
|||
setConfigOnly($configOnly) | |
100.00% |
1 / 1 |
1 | |
100.00% |
5 / 5 |
|||
setTypeSet(array $typeSet) | |
100.00% |
1 / 1 |
1 | |
100.00% |
2 / 2 |
|||
setDefaultTabId($defaultTabId) | |
100.00% |
1 / 1 |
1 | |
100.00% |
5 / 5 |
|||
convertTypeSet(\Scrivo\String $typeSetString) | |
100.00% |
1 / 1 |
2 | |
100.00% |
6 / 6 |
|||
validateInsert() | |
100.00% |
1 / 1 |
1 | |
100.00% |
2 / 2 |
|||
insert() | |
100.00% |
1 / 1 |
4 | |
100.00% |
22 / 22 |
|||
validateUpdate() | |
100.00% |
1 / 1 |
1 | |
100.00% |
2 / 2 |
|||
update() | |
100.00% |
1 / 1 |
3 | |
100.00% |
20 / 20 |
|||
validateDelete(\Scrivo\Context $context, $id) | |
100.00% |
1 / 1 |
1 | |
100.00% |
2 / 2 |
|||
delete(\Scrivo\Context $context, $id) | |
100.00% |
1 / 1 |
3 | |
100.00% |
17 / 17 |
|||
fetch(\Scrivo\Context $context, $id) | |
100.00% |
1 / 1 |
4 | |
100.00% |
23 / 23 |
|||
select(\Scrivo\Context $context) | |
100.00% |
1 / 1 |
3 | |
100.00% |
14 / 14 |
|||
selectSelectable( \Scrivo\Context $context, $parentId) | |
100.00% |
1 / 1 |
4 | |
100.00% |
14 / 14 |
<?php | |
/* Copyright (c) 2013, Geert Bergman (geert@scrivo.nl) | |
* All rights reserved. | |
* | |
* Redistribution and use in source and binary forms, with or without | |
* modification, are permitted provided that the following conditions are met: | |
* | |
* 1. Redistributions of source code must retain the above copyright notice, | |
* this list of conditions and the following disclaimer. | |
* 2. Redistributions in binary form must reproduce the above copyright notice, | |
* this list of conditions and the following disclaimer in the documentation | |
* and/or other materials provided with the distribution. | |
* 3. Neither the name of "Scrivo" nor the names of its contributors may be | |
* used to endorse or promote products derived from this software without | |
* specific prior written permission. | |
* | |
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" | |
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | |
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE | |
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR | |
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF | |
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS | |
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN | |
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) | |
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE | |
* POSSIBILITY OF SUCH DAMAGE. | |
* | |
* $Id: PageDefinition.php 866 2013-08-25 16:22:35Z geert $ | |
*/ | |
/** | |
* Implementation of the \Scrivo\PageDefinition class. | |
*/ | |
namespace Scrivo; | |
/** | |
* The PageDefinition class is used to create a definition for a page. | |
* | |
* In the Scrivo user interface the editor will select a page definition to | |
* create a page from. The page definition holds a list of configurable | |
* properties (text blocks, images, urls, colors, etc) that can be edited for | |
* that page. See also the class PageDefinitionProperty that is used to define | |
* the individual properties and the class PageDefinitionTab that is used to | |
* distribute these properties over several tabs in the Scrivo user interface. | |
* | |
* Furthermore the page definition holds a reference to the PHP script that | |
* should be executed when rendering pages with this page definition | |
* definition. | |
* | |
* PageDefinitions can be suppressed in the user interface using the | |
* 'configOnly'property: for instance, there is no need to let the editor | |
* chose another page using the 'Home' page definition in a site. Or they can | |
* be shown conditionally in the interface: you can only select pages of page | |
* definition 'Main Menu' as sub pages of a page of page definition 'Home'. | |
* See the 'PageDefinitionHints' class for more details. | |
* | |
* TODO: field type_set now is a semicolon seperated list (DB data), better | |
* to serialize this data. | |
* TODO: field search_index_rule has no function anymore. | |
* | |
* @property-read int $id The page definition id (DB key). | |
* @property-read object $properties The page definition properties. | |
* @property-read \Scrivo\PageDefinitionTab[] $tabs The page definition tabs. | |
* @property boolean $configOnly Setting to suppress this page definition in | |
* the user interface. | |
* @property int $defaultTabId The id of the tab that should be shown in the | |
* user interface as the active tab when the editor selects a page using this | |
* page definition for editing. | |
* @property \Scrivo\String $description An additional description for the | |
* page definition. | |
* @property \Scrivo\String $action The location of the PHP script to | |
* execute when rendering pages using this page definition. | |
* @property \Scrivo\String $title A descriptive title for the page definition. | |
* @property int[] $typeSet The set of page types that the user can select | |
* in the user interface when creating/modifing pages using this page | |
* definition. | |
*/ | |
class PageDefinition { | |
/** | |
* The page definition id (DB key). | |
* @var int | |
*/ | |
private $id = 0; | |
/** | |
* A descriptive title for the page definition. | |
* @var \Scrivo\String | |
*/ | |
private $title = null; | |
/** | |
* An additional description for the page definition. | |
* @var \Scrivo\String | |
*/ | |
private $description = null; | |
/** | |
* The location of the PHP script to execute when rendering pages using | |
* this page definition. | |
* @var \Scrivo\String | |
*/ | |
private $action = null; | |
/** | |
* Setting to suppress this page definition in the user interface. | |
* @var boolean | |
*/ | |
private $configOnly = false; | |
/** | |
* The set of page types that the user can select in the user interface | |
* when creating/modifing pages using this page definition. | |
* @var int[] | |
*/ | |
private $typeSet = array(); | |
/** | |
* The id of the tab that should be shown in the user interface as the | |
* active tab when the editor selects a page using this page definition | |
* for editing. | |
* @var int | |
*/ | |
private $defaultTabId = 0; | |
/** | |
* The page definition properties as a PHP object in which the members | |
* correspond with the PHP selector names. | |
* @var \stdClass | |
*/ | |
protected $properties = null; | |
/** | |
* The page definition tabs. | |
* @var \Scrivo\PageDefinitionTab[] | |
*/ | |
protected $tabs = null; | |
/** | |
* A Scrivo context. | |
* @var \Scrivo\Context | |
*/ | |
private $context = null; | |
/** | |
* Create an empty page definition object. | |
* | |
* @param \Scrivo\Context $context A Scrivo context. | |
*/ | |
public function __construct(\Scrivo\Context $context=null) { | |
\Scrivo\ArgumentCheck::assertArgs(func_get_args(), array(null), 0); | |
if ($context) { | |
$this->title = new \Scrivo\String(); | |
$this->description = new \Scrivo\String(); | |
$this->action = new \Scrivo\String(); | |
$this->context = $context; | |
} | |
} | |
/** | |
* Implementation of the readable properties using the PHP magic | |
* method __get(). | |
* | |
* @param string $name The name of the property to get. | |
* | |
* @return mixed The value of the requested property. | |
*/ | |
public function __get($name) { | |
switch($name) { | |
case "id": return $this->id; | |
case "title": return $this->title; | |
case "description": return $this->description; | |
case "action": return $this->action; | |
case "configOnly": return $this->configOnly; | |
case "typeSet": return $this->typeSet; | |
case "defaultTabId": return $this->defaultTabId; | |
case "properties": return $this->getProperties(); | |
case "tabs": return $this->getTabs(); | |
} | |
throw new \Scrivo\SystemException("No such get-property '$name'."); | |
} | |
/** | |
* Implementation of the writable properties using the PHP magic | |
* method __set(). | |
* | |
* @param string $name The name of the property to set. | |
* @param mixed $value The value of the property to set. | |
*/ | |
public function __set($name, $value) { | |
switch($name) { | |
case "title": $this->setTitle($value); return; | |
case "description": $this->setDescription($value); return; | |
case "action": $this->setFileName($value); return; | |
case "configOnly": $this->setConfigOnly($value); return; | |
case "typeSet": $this->setTypeSet($value); return; | |
case "defaultTabId": $this->setDefaultTabId($value); return; | |
} | |
throw new \Scrivo\SystemException("No such set-property '$name'."); | |
} | |
/** | |
* Convenience method to set the fields of a page definition object from | |
* an array (result set row). | |
* | |
* @param \Scrivo\Context $context A Scrivo context. | |
* @param array $rd An array containing the field data using the database | |
* field names as keys. | |
*/ | |
private function setFields(\Scrivo\Context $context, array $rd) { | |
$this->id = intval($rd["page_definition_id"]); | |
$this->title = new \Scrivo\String($rd["title"]); | |
$this->description = new \Scrivo\String($rd["description"]); | |
$this->action = new \Scrivo\String($rd["action"]); | |
$this->configOnly = intval($rd["config_only"]) == 1 ? true : false; | |
$this->typeSet = | |
$this->convertTypeSet(new \Scrivo\String($rd["type_set"])); | |
$this->defaultTabId = intval($rd["default_tab_id"]); | |
$this->context = $context; | |
} | |
/** | |
* Get this page definition's property list. | |
* | |
* @return object This page definition's property list. | |
*/ | |
private function getProperties() { | |
if ($this->properties === null) { | |
$this->properties = (object) | |
\Scrivo\PagePropertyDefinition::select($this->context, $this->id); | |
} | |
return $this->properties; | |
} | |
/** | |
* Get this page definition's tabs. | |
* | |
* @return \Scrivo\PageDefinitionTab[] This page definition's tabs. | |
*/ | |
private function getTabs() { | |
if ($this->tabs === null) { | |
$this->tabs = | |
\Scrivo\PageDefinitionTab::select($this->context, $this->id); | |
} | |
return $this->tabs; | |
} | |
/** | |
* Set A descriptive title for the page definition. | |
* | |
* @param \Scrivo\String $title A descriptive title for the page | |
* definition. | |
*/ | |
private function setTitle(\Scrivo\String $title) { | |
$this->title = $title; | |
} | |
/** | |
* Set the additional description for the page definition. | |
* | |
* @param \Scrivo\String $description An additional description for the | |
* page definition. | |
*/ | |
private function setDescription(\Scrivo\String $description) { | |
$this->description = $description; | |
} | |
/** | |
* Set the location of the PHP script to execute when rendering pages | |
* using this page definition. | |
* | |
* @param \Scrivo\String $action The location of the PHP script to | |
* execute when rendering pages using this page definition. | |
*/ | |
private function setFileName(\Scrivo\String $action) { | |
$this->action = $action; | |
} | |
/** | |
* Set the setting to suppress this page definition in the user interface. | |
* | |
* @param boolean $configOnly Setting to suppress this page definition in | |
* the user interface. | |
*/ | |
private function setConfigOnly($configOnly) { | |
\Scrivo\ArgumentCheck::assertArgs(func_get_args(), array( | |
array(\Scrivo\ArgumentCheck::TYPE_BOOLEAN) | |
)); | |
$this->configOnly = $configOnly; | |
} | |
/** | |
* Set the set of page types that the user can select in the user interface | |
* when creating/modifing pages using this page definition. | |
* | |
* @param int[] $typeSet The set of page types that the user can select in | |
* the user interface when creating/modifing pages using this page | |
* definition. | |
*/ | |
private function setTypeSet(array $typeSet) { | |
$this->typeSet = $typeSet; | |
} | |
/** | |
* Set the id of the tab that should be shown in the user interface as | |
* the active tab when the editor selects a page using this page definition | |
* for editing. | |
* | |
* @param int $defaultTabId The id of the tab that should be shown in the | |
* user interface as the active tab when the editor selects a page using | |
* this page definition for editing. | |
*/ | |
private function setDefaultTabId($defaultTabId) { | |
\Scrivo\ArgumentCheck::assertArgs(func_get_args(), array( | |
array(\Scrivo\ArgumentCheck::TYPE_INTEGER) | |
)); | |
$this->defaultTabId = $defaultTabId; | |
} | |
/** | |
* Convert the semicolon seperated value from the database to an array. | |
* | |
* @param \Scrivo\String typeSetString An semicolon seperated string. | |
* @return int[] The type set as an array of integers. | |
*/ | |
private function convertTypeSet(\Scrivo\String $typeSetString) { | |
$ts = $typeSetString->split(new \Scrivo\String(";")); | |
$ts2 = array(); | |
foreach ($ts as $pageId) { | |
$ts2[] = intval((string)$pageId); | |
} | |
return $ts2; | |
} | |
/** | |
* Check if this page definition object can be inserted into the database. | |
* | |
* @throws \Scrivo\ApplicationException If the data is not accessible or | |
* one or more of the fields contain invalid data. | |
*/ | |
private function validateInsert() { | |
$this->context->checkPermission(\Scrivo\AccessController::WRITE_ACCESS); | |
} | |
/** | |
* Insert new page definition object data into the database. | |
* | |
* First it is checked if the data of this page definition object can be | |
* inserted into the database, then the data is inserted into the database. | |
* If no id was set a new object id is generated. | |
* | |
* @throws \Scrivo\ApplicationException If the data is not accessible or | |
* one or more of the fields contain invalid data. | |
*/ | |
public function insert() { | |
try { | |
$this->validateInsert(); | |
if (!$this->id) { | |
$this->id = $this->context->connection->generateId(); | |
} | |
$sth = $this->context->connection->prepare( | |
"INSERT INTO page_definition ( | |
instance_id, page_definition_id, title, description, action, | |
config_only, type_set, default_tab_id | |
) VALUES ( | |
:instId, :id, :title, :description, :action, | |
:configOnly, :typeSet, :defaultTabId | |
)"); | |
$this->context->connection->bindInstance($sth); | |
$sth->bindValue(":id", $this->id, \PDO::PARAM_INT); | |
$sth->bindValue(":title", $this->title, \PDO::PARAM_STR); | |
$sth->bindValue( | |
":description", $this->description, \PDO::PARAM_STR); | |
$sth->bindValue(":action", $this->action, \PDO::PARAM_STR); | |
$sth->bindValue(":configOnly", | |
$this->configOnly ? 1 : 0, \PDO::PARAM_INT); | |
$sth->bindValue(":typeSet", new \Scrivo\String( | |
implode(";", $this->typeSet)), \PDO::PARAM_INT); | |
$sth->bindValue( | |
":defaultTabId", $this->defaultTabId, \PDO::PARAM_INT); | |
$sth->execute(); | |
} catch(\PDOException $e) { | |
throw new \Scrivo\ResourceException($e); | |
} | |
} | |
/** | |
* Check if this page definition object can be updated in the database. | |
* | |
* @throws \Scrivo\ApplicationException If the data is not accessible or | |
* one or more of the fields contain invalid data. | |
*/ | |
private function validateUpdate() { | |
$this->context->checkPermission(\Scrivo\AccessController::WRITE_ACCESS); | |
} | |
/** | |
* Update existing page definition object data in the database. | |
* | |
* First it is checked if the data of this page definition object can be | |
* updated in the database, then the data is updated in the database. | |
* | |
* @throws \Scrivo\ApplicationException If the data is not accessible or | |
* one or more of the fields contain invalid data. | |
*/ | |
public function update() { | |
try { | |
$this->validateUpdate(); | |
$sth = $this->context->connection->prepare( | |
"UPDATE page_definition SET | |
title = :title, description = :description, | |
action = :action, config_only = :configOnly, | |
type_set = :typeSet, default_tab_id = :defaultTabId | |
WHERE instance_id = :instId AND page_definition_id = :id"); | |
$this->context->connection->bindInstance($sth); | |
$sth->bindValue(":id", $this->id, \PDO::PARAM_INT); | |
$sth->bindValue(":title", $this->title, \PDO::PARAM_STR); | |
$sth->bindValue( | |
":description", $this->description, \PDO::PARAM_STR); | |
$sth->bindValue(":action", $this->action, \PDO::PARAM_STR); | |
$sth->bindValue(":configOnly", | |
$this->configOnly ? 1 : 0, \PDO::PARAM_INT); | |
$sth->bindValue(":typeSet", new \Scrivo\String( | |
implode(";", $this->typeSet)), \PDO::PARAM_INT); | |
$sth->bindValue( | |
":defaultTabId", $this->defaultTabId, \PDO::PARAM_INT); | |
$sth->execute(); | |
unset($this->context->cache[$this->id]); | |
} catch(\PDOException $e) { | |
throw new \Scrivo\ResourceException($e); | |
} | |
} | |
/** | |
* Check if deletion of page definition object data does not violate any | |
* business rules. | |
* | |
* @param \Scrivo\Context $context A Scrivo context. | |
* @param int $id The object id of the page definition to select. | |
* | |
* @throws \Scrivo\ApplicationException If the data is not accessible or | |
* if it is not possible to delete the language data. | |
*/ | |
private static function validateDelete(\Scrivo\Context $context, $id) { | |
$context->checkPermission(\Scrivo\AccessController::WRITE_ACCESS); | |
} | |
/** | |
* Delete existing page definition data from the database. | |
* | |
* First it is is checked if it's possible to delete page definition data, | |
* then the page definition data including its dependencies is deleted from | |
* the database. | |
* | |
* @param \Scrivo\Context $context A Scrivo context. | |
* @param int $id The object id of the page definition to select. | |
* | |
* @throws \Scrivo\ApplicationException If the data is not accessible or | |
* if it is not possible to delete the page definition data. | |
*/ | |
public static function delete(\Scrivo\Context $context, $id) { | |
\Scrivo\ArgumentCheck::assertArgs(func_get_args(), array( | |
null, | |
array(\Scrivo\ArgumentCheck::TYPE_INTEGER) | |
)); | |
try { | |
self::validateDelete($context, $id); | |
foreach (array("page_property_definition", "page_definition_tab", "page_definition") | |
as $table) { | |
$sth = $context->connection->prepare( | |
"DELETE FROM $table | |
WHERE instance_id = :instId AND page_definition_id = :id"); | |
$context->connection->bindInstance($sth); | |
$sth->bindValue(":id", $id, \PDO::PARAM_INT); | |
$sth->execute(); | |
} | |
unset($context->cache[$id]); | |
} catch(\PDOException $e) { | |
throw new \Scrivo\ResourceException($e); | |
} | |
} | |
/** | |
* Fetch a page definition object from the database using its object id. | |
* | |
* @param \Scrivo\Context $context A Scrivo context. | |
* @param int $id The object id of the page definition to select. | |
* | |
* @return \Scrivo\PageDefinition The requested page definition object. | |
*/ | |
public static function fetch(\Scrivo\Context $context, $id) { | |
\Scrivo\ArgumentCheck::assertArgs(func_get_args(), array( | |
null, | |
array(\Scrivo\ArgumentCheck::TYPE_INTEGER) | |
)); | |
try { | |
// Try to retieve the page definition from the cache ... | |
if (isset($context->cache[$id])) { | |
// ... get it from the cache and set the context. | |
$pageDefinition = $context->cache[$id]; | |
$pageDefinition->context = $context; | |
} else { | |
// ... else retrieve it and set it in the cache. | |
$sth = $context->connection->prepare( | |
"SELECT page_definition_id, title, description, action, | |
config_only, type_set, default_tab_id | |
FROM page_definition | |
WHERE instance_id = :instId AND page_definition_id = :id"); | |
$context->connection->bindInstance($sth); | |
$sth->bindValue(":id", $id, \PDO::PARAM_INT); | |
$sth->execute(); | |
if ($sth->rowCount() != 1) { | |
throw new \Scrivo\SystemException( | |
"Failed to load page definition $id"); | |
} | |
$pageDefinition = new \Scrivo\PageDefinition(); | |
$pageDefinition->setFields( | |
$context, $sth->fetch(\PDO::FETCH_ASSOC)); | |
$context->cache[$id] = $pageDefinition; | |
} | |
return $pageDefinition; | |
} catch(\PDOException $e) { | |
throw new \Scrivo\ResourceException($e); | |
} | |
} | |
/** | |
* Select page definitions from the database. | |
* | |
* @param \Scrivo\Context $context A Scrivo context. | |
* | |
* @return \Scrivo\PageDefinition[id] An array containing the selected | |
* page definitions. | |
*/ | |
public static function select(\Scrivo\Context $context) { | |
\Scrivo\ArgumentCheck::assertArgs(func_get_args(), array(null)); | |
try { | |
$sth = $context->connection->prepare( | |
"SELECT page_definition_id, title, description, action, | |
config_only, type_set, default_tab_id | |
FROM page_definition | |
WHERE instance_id = :instId | |
ORDER BY title"); | |
$context->connection->bindInstance($sth); | |
$sth->execute(); | |
$res = array(); | |
while ($rd = $sth->fetch(\PDO::FETCH_ASSOC)) { | |
$li = new PageDefinition(); | |
$li->setFields($context, $rd); | |
$res[$li->id] = $li; | |
} | |
return $res; | |
} catch(\PDOException $e) { | |
throw new \Scrivo\ResourceException($e); | |
} | |
} | |
/** | |
* Select the list of page definitions that are selectable by a an editor. | |
* | |
* @param \Scrivo\Context $context A Scrivo context. | |
* @param int $parentId The id of the page where the editor wants to | |
* create a page underneath. | |
* | |
* @return PageDefinition[id] An array containing the selected page | |
* definitions. | |
*/ | |
public static function selectSelectable( | |
\Scrivo\Context $context, $parentId) { | |
\Scrivo\ArgumentCheck::assertArgs(func_get_args(), array( | |
null, | |
array(\Scrivo\ArgumentCheck::TYPE_INTEGER) | |
)); | |
// Select all the page definitions ... | |
$list = self::select($context); | |
// ... and the hints ... | |
$hints = new \Scrivo\PageDefinitionHints($context, $parentId, | |
\Scrivo\PageDefinitionHints::CHILD_PAGE_DEFINITION_REMAINING); | |
// ... and create a new list of page definitions that are not config | |
// only and have a count left according the hints list. | |
$pageDefinitions = array(); | |
foreach ($list as $k=>$pageDef) { | |
if (!$pageDef->configOnly && $hints[$k]->maxNoOfChildren !== 0) { | |
$pageDefinitions[$k] = $pageDef; | |
} | |
} | |
return $pageDefinitions; | |
} | |
} | |