Page::isSitemapEnabled() - Code Metrics - Inspection of "changed admin editpage template, added sitemap opt..." - JuKu/JuKuCMS - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 2c1eb1...6e4c54 )

by Justin

created 2018-09-15 18:47 UTC

Page::isSitemapEnabled() A

↳ Parent: Page

Complexity

Conditions	1
Paths	1

Size

Total Lines	2
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
cc	1
eloc	1
c	1
b	0
f	1
nc	1
nop	0
dl	0
loc	2
rs	10

<?php

/**
 * Copyright (c) 2018 Justin Kuenzel (jukusoft.com)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

class Page {

	protected $pageID = -1;
	protected $alias = null;
	protected $row = null;
	protected $pagetype = "";

	protected $author = null;

	//changed columns to save with save()
	protected $changes = array();

	public function __construct() {
		//
	}

	public function load ($alias = null) {
		if ($alias == null) {
			if (isset($_REQUEST['page']) && !empty($_REQUEST['page'])) {
				$alias = Validator_String::get($_REQUEST['page']);
			} else {
				$alias = $this->getDomain()->getHomePage();
			}
		} else {
			//$alias = Database::getInstance()->escape($alias);
		}

		Events::throwEvent("get_alias", array(
			'alias' => &$alias,
			'page' => &$this,
			'domain' => $this->getDomain()
		));

		$this->alias = $alias;

		if (Cache::contains("pages", "page_" . $alias)) {
			$this->row = Cache::get("pages", "page_" . $alias);
		} else {
			$row = Database::getInstance()->getRow("SELECT * FROM `{praefix}pages` WHERE `alias` = :alias AND `activated` = '1'; ", array('alias' => $alias));

			if (!$row) {
				if (PHPUtils::strEqs("error404", $alias)) {
					throw new IllegalStateException("No page with alias 'error404' exists (requested alias: " . $alias . ").");
				}

				//page not found
				$new_alias = "error404";

				Events::throwEvent("load_page_error404", array(
					'alias' => &$new_alias,
					'original_alias' => $alias,
					'page' => &$this,
					'domain' => $this->getDomain()
				));

				$this->load($new_alias);
				return null;
			}

			$this->row = $row;

			//cache result
			Cache::put("pages", "page_" . $alias, $row);
		}

		//get pageID
		$this->pageID = $this->row['id'];

		//get name of page type (class name)
		$this->pagetype = $this->row['page_type'];
	}

	public function loadByID (int $pageID, bool $use_cache = true) {
		if ($use_cache && Cache::contains("pages", "pageID_" . $pageID)) {
			$this->row = Cache::get("pages", "pageID_" . $pageID);
		} else {
			$row = Database::getInstance()->getRow("SELECT * FROM `{praefix}pages` WHERE `id` = :pageID; ", array('pageID' => $pageID));

			if (!$row) {
				throw new IllegalStateException("Page with pageID " . $pageID . " doesnt exists!");
			}

			$this->row = $row;

			//cache result
			Cache::put("pages", "pageID_" . $pageID, $row);
		}

		$this->pageID = $this->row['id'];
		$this->alias = $this->row['alias'];

		//get name of page type (class name)
		$this->pagetype = $this->row['page_type'];
	}

	protected function getDomain () : Domain {
		return Registry::singleton()->getObject("domain");
	}

	public function reloadCache () {
		Cache::clear("pages");
	}

	public function getPageID () : int {
		return $this->row['id'];
	}

	public function getAlias () : string {
		return $this->alias;
	}

	public function getPageType () : string {
		return $this->pagetype;
	}

	public function getTitle () : string {
		return $this->row['title'];
	}

	public function setTitle (string $title) {
		$this->row['title'] = $title;
		$this->changes[] = "title";
	}

	public function getContent () : string {
		return $this->row['content'];
	}

	public function setContent (string $content) {
		$this->row['content'] = $content;
		$this->changes[] = "content";
		$this->changes[] = "content";
	}

	public function getGlobalMenuID () : int {
		return $this->row['global_menu'];
	}

	public function getLocalMenuID () : int {
		return $this->row['local_menu'];
	}

	public function getStyle () : string {
		return $this->row['design'];
	}

	public function getFolder () : string {
		return $this->row['folder'];
	}

	public function getLastEdit () {
		return $this->row['lastUpdate'];
	}

	public function hasCustomTemplate () : bool {
		return $this->row['template'] !== "none";
	}

	public function getCustomTemplate () : string {
		return $this->row['template'];
	}

	public function hasCustomPermissions () : bool {
		return $this->row['can_see_permissions'] !== "none";
	}

	public function listCustomPermissions () : array {
		return explode("|", $this->row['can_see_permissions']);
	}

	public function isPublished () : bool {
		return $this->row['published'] == 1;
	}

	public function publish () {
		$this->row['published'] = 1;
		$this->changes[] = "published";
	}

	public function getContentType () : string {
		return $this->row['content_type'];
	}

	public function getParentID () : int {
		return $this->row['parent'];
	}

	public function getLeftSidebarID () : int {
		return $this->row['sidebar_left'];
	}

	public function getRightSidebarID () : int {
		return $this->row['sidebar_right'];
	}

	public function getMetaDescription () : string {
		return $this->row['meta_description'];
	}

	public function getMetaKeywords () : string {
		return $this->row['meta_keywords'];
	}

	public function getMetaRobotsOptions () : string {
		return $this->row['meta_robots'];
	}

	public function getMetaCanonicals () : string {
		return $this->row['meta_canonicals'];
	}

	public function getOgType () : string {
		return $this->row['og_type'];
	}

	public function getOgTitle () : string {
		return !empty($this->row['og_title']) ? $this->row['og_title'] : $this->getTitle();
	}

	public function getOgDescription () : string {
		return !empty($this->row['og_description']) ? $this->row['og_description'] : $this->getMetaDescription();
	}

	public function getOgImages () : array {
		if (empty($this->row['og_image'])) {
			return array();
		}

		return explode(",", $this->row['og_image']);
	}

	public function getAuthorID () : int {
		return $this->row['author'];
	}

	public function getAuthor () : User {
		if ($this->author == null) {
			//load author
			$this->author = new User();

			if ($this->getAuthorID() <= 0) {
				throw new IllegalArgumentException("authorID has to be > 0.");
			}

			$this->author->load($this->getAuthorID());
		}

		return $this->author;
	}

	public function isSitemapEnabled () : bool {
		return $this->row['sitemap'] == 1;
	}

	public function activate (bool $bool = true) {
		$this->row['activated'] = ($bool ? 1 : 0);
	}

	public function isTrash () : bool {
		return $this->row['activated'] == 2;
	}

	public function isEditable () : bool {
		return $this->row['editable'] == 1;
	}

	public function isDeletable () : bool {
		return $this->row['deletable'] == 1;
	}

	public function isActivated () : bool {
		return $this->row['activated'] == 1;
	}

	public function moveToTrash () {
		self::movePageToTrash($this->pageID);

		//clear cache
		$this->clearCache();
	}

	/**
	 * restore page from trash
	 */
	public function restore () {
		self::restorePage($this->pageID);

		//clear cache
		$this->clearCache();
	}

	/**
	 * save changes into database
	 */
	public function save () {
		//TODO: add code here
	}

	public function clearCache () {
		if (!is_int($this->getPageID())) {

			throw new IllegalStateException("pageID isn't set.");
		}

		//clear cache
		Cache::clear("pages", "pageID_" . $this->getPageID());
		Cache::clear("pages", "page_" . $this->getAlias());
	}

	public static function createIfAbsent (string $alias, string $title, string $page_type, string $content = "", string $folder = "/", int $globalMenu = -1, int $localMenu = -1, int $parentID = -1, bool $sitemap = true, bool $published = true, bool $editable = true, bool $deletable = true, string $author = "system") : int {
		//throw event
		Events::throwEvent("create_page", array(
			'alias' => &$alias,
			'title' => &$title,
			'page_type' => &$page_type,
			'content' => &$content,
			'folder' => &$folder,
			'global_menu' => &$globalMenu,
			'local_menu' => &$localMenu,
			'parentID' => &$parentID,
			'sitemap' => &$sitemap,
			'published' => &$published,
			'editable' => &$editable,
			'author' => &$author
		));

		if (!is_int($author)) {

			//get userID of author
			$author = User::getIDByUsernameFromDB($author);

			if ($author == -1) {
				//username doesnt exists, so choose first user
				$author = 1;
			}
		} else {
			$author = (int) $author;
		}

		Database::getInstance()->execute("INSERT INTO `{praefix}pages` (
			`id`, `alias`, `title`, `content`, `parent`, `folder`, `global_menu`, `local_menu`, `page_type`, `design`, `sitemap`, `published`, `version`, `last_update`, `created`, `editable`, `deletable`, `author`, `activated`
		) VALUES (
			NULL, :alias, :title, :content, :parent, :folder, :globalMenu, :localMenu, :pageType, 'none', :sitemap, :published, '1', '0000-00-00 00:00:00', CURRENT_TIMESTAMP, :editable, :deletable, :author, '1'
		) ON DUPLICATE KEY UPDATE `alias` = :alias, `editable` = :editable, `deletable` = :deletable; ", array(
			'alias' => $alias,
			'title' => $title,
			'content' => $content,
			'parent' => $parentID,
			'folder' => $folder,
			'globalMenu' => $globalMenu,
			'localMenu' => $localMenu,
			'pageType' => $page_type,
			'sitemap' => ($sitemap ? 1 : 0),
			'published' => ($published ? 1 : 0),
			'editable' => ($editable ? 1 : 0),
			'deletable' => ($deletable ? 1 : 0),
			'author' => $author
		));

		Cache::clear("pages");

		//return page id
		$insertID = Database::getInstance()->lastInsertId();

		//throw event
		Events::throwEvent("created_page", array(
			'alias' => $alias,
			'title' => $title,
			'insertID' => $insertID
		));

		//get pageID by alias
		$pageID = Page::getPageIDByAlias($alias);

		//set default rights, allow page for administrators, registered users, guests and bots
		PageRights::setDefaultAllowedGroups($pageID, array(1, 2, 3, 4));

		return $pageID;
	}

	public static function delete (string $alias) {
		$delete = true;

		//plugins can avoid deletion or change alias
		Events::throwEvent("delete_page_alias", array(
			'alias' => &$alias,
			'delete' => &$delete
		));

		if ($delete) {

			//remove page from database
			Database::getInstance()->execute("DELETE FROM `{praefix}pages` WHERE `alias` = :alias; ", array('alias' => $alias));

			Cache::clear("pages");
		}
	}

	public static function deleteByID (int $id) {
		$delete = true;

		//plugins can avoid deletion or change alias
		Events::throwEvent("delete_page_id", array(
			'alias' => &$id,
			'delete' => &$delete
		));

		if ($delete) {

			//remove page from database
			Database::getInstance()->execute("DELETE FROM `{praefix}pages` WHERE `id` = :id; ", array('id' => $id));

			Cache::clear("pages");
		}
	}

	public static function get (string $alias) : Page {
		$page = new Page();
		$page->load($alias);

		return $page;
	}

	public static function setPageType (string $alias, string $page_type) {
		Events::throwEvent("set_pagetype", array(
			'alias' => &$alias,
			'page_type' => &$page_type
		));

		Database::getInstance()->execute("UPDATE `{praefix}pages` SET `page_type` = :page_type WHERE `alias` = :alias; ", array(
			'alias' => $alias,
			'page_type' => $page_type
		));

		Cache::clear("pages");
	}

	/**
	 * get id of page by alias
	 *
	 * only use this method for database upgrade, because their is no caching for this method!
	 *
	 * @param string $alias alias of page
	 *
	 * @throws IllegalStateException if alias doesnt exists
	 *
	 * @return int pageID
	 */
	public static function getPageIDByAlias (string $alias) : int {
		$row = Database::getInstance()->getRow("SELECT * FROM `{praefix}pages` WHERE `alias` = :alias; ", array('alias' => $alias));

		if (!$row) {
			throw new IllegalStateException("page with alias '" . $alias . "' doesnt exists.");
		}

		return $row['id'];
	}

	public static function lockPage (int $pageID, int $userID) {
		Database::getInstance()->execute("UPDATE `{praefix}pages` SET `locked_by` = :userID, `locked_timestamp` = CURRENT_TIMESTAMP WHERE `id` = :pageID; ", array(
			'userID' => $userID,
			'pageID' => $pageID
		));

		//clear cache
		Cache::clear("pages", "pageID_" . $pageID);
	}

	public static function unlockPage (int $pageID) {
		Database::getInstance()->execute("UPDATE `{praefix}pages` SET `locked_by` = '-1' WHERE `id` = :pageID; ", array(
			'pageID' => $pageID
		));

		//clear cache
		Cache::clear("pages", "pageID_" . $pageID);
	}

	protected static function movePageToTrash (int $pageID) {
		Database::getInstance()->execute("UPDATE `{praefix}pages` SET `activated` = 2 WHERE `id` = :pageID; ", array(
			'pageID' => $pageID
		));

		//clear cache
		Cache::clear("pages", "pageID_" . $pageID);
	}

	protected static function restorePage (int $pageID) {
		Database::getInstance()->execute("UPDATE `{praefix}pages` SET `activated` = 1 WHERE `id` = :pageID; ", array(
			'pageID' => $pageID
		));

		//clear cache
		Cache::clear("pages", "pageID_" . $pageID);
	}

	public static function exists (string $alias) : bool {
		$row = Database::getInstance()->getRow("SELECT * FROM `{praefix}pages` WHERE `alias` = :alias; ", array(
			'alias' => $alias
		));

		return $row !== false;
	}

}

?>



1			<?php
2
3			/**
4			* Copyright (c) 2018 Justin Kuenzel (jukusoft.com)
5			*
6			* Licensed under the Apache License, Version 2.0 (the "License");
7			* you may not use this file except in compliance with the License.
8			* You may obtain a copy of the License at
9			*
10			* http://www.apache.org/licenses/LICENSE-2.0
11			*
12			* Unless required by applicable law or agreed to in writing, software
13			* distributed under the License is distributed on an "AS IS" BASIS,
14			* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15			* See the License for the specific language governing permissions and
16			* limitations under the License.
17			*/
18
19			class Page {
20
21			protected $pageID = -1;
22			protected $alias = null;
23			protected $row = null;
24			protected $pagetype = "";
25
26			protected $author = null;
27
28			//changed columns to save with save()
29			protected $changes = array();
30
31			public function __construct() {
32			//
33			}
34
35			public function load ($alias = null) {
36			if ($alias == null) {
37			if (isset($_REQUEST['page']) && !empty($_REQUEST['page'])) {
38			$alias = Validator_String::get($_REQUEST['page']);
39			} else {
40			$alias = $this->getDomain()->getHomePage();
41			}
42			} else {
43			//$alias = Database::getInstance()->escape($alias);
44			}
45
46			Events::throwEvent("get_alias", array(
47			'alias' => &$alias,
48			'page' => &$this,
49			'domain' => $this->getDomain()
50			));
51
52			$this->alias = $alias;
53
54			if (Cache::contains("pages", "page_" . $alias)) {
55			$this->row = Cache::get("pages", "page_" . $alias);
56			} else {
57			$row = Database::getInstance()->getRow("SELECT * FROM `{praefix}pages` WHERE `alias` = :alias AND `activated` = '1'; ", array('alias' => $alias));
58
59			if (!$row) {
60			if (PHPUtils::strEqs("error404", $alias)) {
61			throw new IllegalStateException("No page with alias 'error404' exists (requested alias: " . $alias . ").");
62			}
63
64			//page not found
65			$new_alias = "error404";
66
67			Events::throwEvent("load_page_error404", array(
68			'alias' => &$new_alias,
69			'original_alias' => $alias,
70			'page' => &$this,
71			'domain' => $this->getDomain()
72			));
73
74			$this->load($new_alias);
75			return null;
76			}
77
78			$this->row = $row;
79
80			//cache result
81			Cache::put("pages", "page_" . $alias, $row);
82			}
83
84			//get pageID
85			$this->pageID = $this->row['id'];
86
87			//get name of page type (class name)
88			$this->pagetype = $this->row['page_type'];
89			}
90
91			public function loadByID (int $pageID, bool $use_cache = true) {
92			if ($use_cache && Cache::contains("pages", "pageID_" . $pageID)) {
93			$this->row = Cache::get("pages", "pageID_" . $pageID);
94			} else {
95			$row = Database::getInstance()->getRow("SELECT * FROM `{praefix}pages` WHERE `id` = :pageID; ", array('pageID' => $pageID));
96
97			if (!$row) {
98			throw new IllegalStateException("Page with pageID " . $pageID . " doesnt exists!");
99			}
100
101			$this->row = $row;
102
103			//cache result
104			Cache::put("pages", "pageID_" . $pageID, $row);
105			}
106
107			$this->pageID = $this->row['id'];
108			$this->alias = $this->row['alias'];
109
110			//get name of page type (class name)
111			$this->pagetype = $this->row['page_type'];
112			}
113
114			protected function getDomain () : Domain {
115			return Registry::singleton()->getObject("domain");
116			}
117
118			public function reloadCache () {
119			Cache::clear("pages");
120			}
121
122			public function getPageID () : int {
123			return $this->row['id'];
124			}
125
126			public function getAlias () : string {
127			return $this->alias;
128			}
129
130			public function getPageType () : string {
131			return $this->pagetype;
132			}
133
134			public function getTitle () : string {
135			return $this->row['title'];
136			}
137
138			public function setTitle (string $title) {
139			$this->row['title'] = $title;
140			$this->changes[] = "title";
141			}
142
143			public function getContent () : string {
144			return $this->row['content'];
145			}
146
147			public function setContent (string $content) {
148			$this->row['content'] = $content;
149			$this->changes[] = "content";
150			$this->changes[] = "content";
151			}
152
153			public function getGlobalMenuID () : int {
154			return $this->row['global_menu'];
155			}
156
157			public function getLocalMenuID () : int {
158			return $this->row['local_menu'];
159			}
160
161			public function getStyle () : string {
162			return $this->row['design'];
163			}
164
165			public function getFolder () : string {
166			return $this->row['folder'];
167			}
168
169			public function getLastEdit () {
170			return $this->row['lastUpdate'];
171			}
172
173			public function hasCustomTemplate () : bool {
174			return $this->row['template'] !== "none";
175			}
176
177			public function getCustomTemplate () : string {
178			return $this->row['template'];
179			}
180
181			public function hasCustomPermissions () : bool {
182			return $this->row['can_see_permissions'] !== "none";
183			}
184
185			public function listCustomPermissions () : array {
186			return explode("\|", $this->row['can_see_permissions']);
187			}
188
189			public function isPublished () : bool {
190			return $this->row['published'] == 1;
191			}
192
193			public function publish () {
194			$this->row['published'] = 1;
195			$this->changes[] = "published";
196			}
197
198			public function getContentType () : string {
199			return $this->row['content_type'];
200			}
201
202			public function getParentID () : int {
203			return $this->row['parent'];
204			}
205
206			public function getLeftSidebarID () : int {
207			return $this->row['sidebar_left'];
208			}
209
210			public function getRightSidebarID () : int {
211			return $this->row['sidebar_right'];
212			}
213
214			public function getMetaDescription () : string {
215			return $this->row['meta_description'];
216			}
217
218			public function getMetaKeywords () : string {
219			return $this->row['meta_keywords'];
220			}
221
222			public function getMetaRobotsOptions () : string {
223			return $this->row['meta_robots'];
224			}
225
226			public function getMetaCanonicals () : string {
227			return $this->row['meta_canonicals'];
228			}
229
230			public function getOgType () : string {
231			return $this->row['og_type'];
232			}
233
234			public function getOgTitle () : string {
235			return !empty($this->row['og_title']) ? $this->row['og_title'] : $this->getTitle();
236			}
237
238			public function getOgDescription () : string {
239			return !empty($this->row['og_description']) ? $this->row['og_description'] : $this->getMetaDescription();
240			}
241
242			public function getOgImages () : array {
243			if (empty($this->row['og_image'])) {
244			return array();
245			}
246
247			return explode(",", $this->row['og_image']);
248			}
249
250			public function getAuthorID () : int {
251			return $this->row['author'];
252			}
253
254			public function getAuthor () : User {
255			if ($this->author == null) {
256			//load author
257			$this->author = new User();
258
259			if ($this->getAuthorID() <= 0) {
260			throw new IllegalArgumentException("authorID has to be > 0.");
261			}
262
263			$this->author->load($this->getAuthorID());
264			}
265
266			return $this->author;
267			}
268
269			public function isSitemapEnabled () : bool {
270			return $this->row['sitemap'] == 1;
271			}
272
273			public function activate (bool $bool = true) {
274			$this->row['activated'] = ($bool ? 1 : 0);
275			}
276
277			public function isTrash () : bool {
278			return $this->row['activated'] == 2;
279			}
280
281			public function isEditable () : bool {
282			return $this->row['editable'] == 1;
283			}
284
285			public function isDeletable () : bool {
286			return $this->row['deletable'] == 1;
287			}
288
289			public function isActivated () : bool {
290			return $this->row['activated'] == 1;
291			}
292
293			public function moveToTrash () {
294			self::movePageToTrash($this->pageID);
295
296			//clear cache
297			$this->clearCache();
298			}
299
300			/**
301			* restore page from trash
302			*/
303			public function restore () {
304			self::restorePage($this->pageID);
305
306			//clear cache
307			$this->clearCache();
308			}
309
310			/**
311			* save changes into database
312			*/
313			public function save () {
314			//TODO: add code here
315			}
316
317			public function clearCache () {
318			if (!is_int($this->getPageID())) {
			0 ignored issues – show introduced 2018-09-06 13:28 UTC by Report Bug Copy Issue Report The condition `is_int($this->getPageID())` is always `true`. Loading history...
319			throw new IllegalStateException("pageID isn't set.");
320			}
321
322			//clear cache
323			Cache::clear("pages", "pageID_" . $this->getPageID());
324			Cache::clear("pages", "page_" . $this->getAlias());
325			}
326
327			public static function createIfAbsent (string $alias, string $title, string $page_type, string $content = "", string $folder = "/", int $globalMenu = -1, int $localMenu = -1, int $parentID = -1, bool $sitemap = true, bool $published = true, bool $editable = true, bool $deletable = true, string $author = "system") : int {
328			//throw event
329			Events::throwEvent("create_page", array(
330			'alias' => &$alias,
331			'title' => &$title,
332			'page_type' => &$page_type,
333			'content' => &$content,
334			'folder' => &$folder,
335			'global_menu' => &$globalMenu,
336			'local_menu' => &$localMenu,
337			'parentID' => &$parentID,
338			'sitemap' => &$sitemap,
339			'published' => &$published,
340			'editable' => &$editable,
341			'author' => &$author
342			));
343
344			if (!is_int($author)) {
			0 ignored issues – show introduced 2018-08-27 15:51 UTC by Report Bug Copy Issue Report The condition `is_int($author)` is always `false`. Loading history...
345			//get userID of author
346			$author = User::getIDByUsernameFromDB($author);
347
348			if ($author == -1) {
349			//username doesnt exists, so choose first user
350			$author = 1;
351			}
352			} else {
353			$author = (int) $author;
354			}
355
356			Database::getInstance()->execute("INSERT INTO `{praefix}pages` (
357			`id`, `alias`, `title`, `content`, `parent`, `folder`, `global_menu`, `local_menu`, `page_type`, `design`, `sitemap`, `published`, `version`, `last_update`, `created`, `editable`, `deletable`, `author`, `activated`
358			) VALUES (
359			NULL, :alias, :title, :content, :parent, :folder, :globalMenu, :localMenu, :pageType, 'none', :sitemap, :published, '1', '0000-00-00 00:00:00', CURRENT_TIMESTAMP, :editable, :deletable, :author, '1'
360			) ON DUPLICATE KEY UPDATE `alias` = :alias, `editable` = :editable, `deletable` = :deletable; ", array(
361			'alias' => $alias,
362			'title' => $title,
363			'content' => $content,
364			'parent' => $parentID,
365			'folder' => $folder,
366			'globalMenu' => $globalMenu,
367			'localMenu' => $localMenu,
368			'pageType' => $page_type,
369			'sitemap' => ($sitemap ? 1 : 0),
370			'published' => ($published ? 1 : 0),
371			'editable' => ($editable ? 1 : 0),
372			'deletable' => ($deletable ? 1 : 0),
373			'author' => $author
374			));
375
376			Cache::clear("pages");
377
378			//return page id
379			$insertID = Database::getInstance()->lastInsertId();
380
381			//throw event
382			Events::throwEvent("created_page", array(
383			'alias' => $alias,
384			'title' => $title,
385			'insertID' => $insertID
386			));
387
388			//get pageID by alias
389			$pageID = Page::getPageIDByAlias($alias);
390
391			//set default rights, allow page for administrators, registered users, guests and bots
392			PageRights::setDefaultAllowedGroups($pageID, array(1, 2, 3, 4));
393
394			return $pageID;
395			}
396
397			public static function delete (string $alias) {
398			$delete = true;
399
400			//plugins can avoid deletion or change alias
401			Events::throwEvent("delete_page_alias", array(
402			'alias' => &$alias,
403			'delete' => &$delete
404			));
405
406			if ($delete) {
			0 ignored issues – show introduced 2018-04-02 18:25 UTC by Report Bug Copy Issue Report The condition `$delete` is always `true`. Loading history...
407			//remove page from database
408			Database::getInstance()->execute("DELETE FROM `{praefix}pages` WHERE `alias` = :alias; ", array('alias' => $alias));
409
410			Cache::clear("pages");
411			}
412			}
413
414			public static function deleteByID (int $id) {
415			$delete = true;
416
417			//plugins can avoid deletion or change alias
418			Events::throwEvent("delete_page_id", array(
419			'alias' => &$id,
420			'delete' => &$delete
421			));
422
423			if ($delete) {
			0 ignored issues – show introduced 2018-04-02 18:25 UTC by Report Bug Copy Issue Report The condition `$delete` is always `true`. Loading history...
424			//remove page from database
425			Database::getInstance()->execute("DELETE FROM `{praefix}pages` WHERE `id` = :id; ", array('id' => $id));
426
427			Cache::clear("pages");
428			}
429			}
430
431			public static function get (string $alias) : Page {
432			$page = new Page();
433			$page->load($alias);
434
435			return $page;
436			}
437
438			public static function setPageType (string $alias, string $page_type) {
439			Events::throwEvent("set_pagetype", array(
440			'alias' => &$alias,
441			'page_type' => &$page_type
442			));
443
444			Database::getInstance()->execute("UPDATE `{praefix}pages` SET `page_type` = :page_type WHERE `alias` = :alias; ", array(
445			'alias' => $alias,
446			'page_type' => $page_type
447			));
448
449			Cache::clear("pages");
450			}
451
452			/**
453			* get id of page by alias
454			*
455			* only use this method for database upgrade, because their is no caching for this method!
456			*
457			* @param string $alias alias of page
458			*
459			* @throws IllegalStateException if alias doesnt exists
460			*
461			* @return int pageID
462			*/
463			public static function getPageIDByAlias (string $alias) : int {
464			$row = Database::getInstance()->getRow("SELECT * FROM `{praefix}pages` WHERE `alias` = :alias; ", array('alias' => $alias));
465
466			if (!$row) {
467			throw new IllegalStateException("page with alias '" . $alias . "' doesnt exists.");
468			}
469
470			return $row['id'];
471			}
472
473			public static function lockPage (int $pageID, int $userID) {
474			Database::getInstance()->execute("UPDATE `{praefix}pages` SET `locked_by` = :userID, `locked_timestamp` = CURRENT_TIMESTAMP WHERE `id` = :pageID; ", array(
475			'userID' => $userID,
476			'pageID' => $pageID
477			));
478
479			//clear cache
480			Cache::clear("pages", "pageID_" . $pageID);
481			}
482
483			public static function unlockPage (int $pageID) {
484			Database::getInstance()->execute("UPDATE `{praefix}pages` SET `locked_by` = '-1' WHERE `id` = :pageID; ", array(
485			'pageID' => $pageID
486			));
487
488			//clear cache
489			Cache::clear("pages", "pageID_" . $pageID);
490			}
491
492			protected static function movePageToTrash (int $pageID) {
493			Database::getInstance()->execute("UPDATE `{praefix}pages` SET `activated` = 2 WHERE `id` = :pageID; ", array(
494			'pageID' => $pageID
495			));
496
497			//clear cache
498			Cache::clear("pages", "pageID_" . $pageID);
499			}
500
501			protected static function restorePage (int $pageID) {
502			Database::getInstance()->execute("UPDATE `{praefix}pages` SET `activated` = 1 WHERE `id` = :pageID; ", array(
503			'pageID' => $pageID
504			));
505
506			//clear cache
507			Cache::clear("pages", "pageID_" . $pageID);
508			}
509
510			public static function exists (string $alias) : bool {
511			$row = Database::getInstance()->getRow("SELECT * FROM `{praefix}pages` WHERE `alias` = :alias; ", array(
512			'alias' => $alias
513			));
514
515			return $row !== false;
516			}
517
518			}
519
520			?>
			0 ignored issues – show Best Practice introduced 2018-09-03 00:17 UTC by Report Bug Copy Issue Report It is not recommended to use PHP's closing tag `?>` in files other than templates. Using a closing tag in PHP files that only contain PHP code is not recommended as you might accidentally add whitespace after the closing tag which would then be output by PHP. This can cause severe problems, for example headers cannot be sent anymore. A simple precaution is to leave off the closing tag as it is not required, and it also has no negative effects whatsoever. Loading history...
521

JuKu / JuKuCMS

Push — master ( 2c1eb1...6e4c54 )

Page::isSitemapEnabled() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like