Page::getOgDescription() - Code Metrics - Inspection of "added opengraph tag description, closed #204 ." - JuKu/JuKuCMS - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 833ded...e0bbff )

by Justin

created 2018-09-06 22:25 UTC

Page::getOgDescription() A

↳ Parent: Page

Complexity

Conditions	2
Paths	2

Size

Total Lines	2
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?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 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 getOgImage () : string {
		return $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 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 getLeftSidebarID () : int {
203			return $this->row['sidebar_left'];
204			}
205
206			public function getRightSidebarID () : int {
207			return $this->row['sidebar_right'];
208			}
209
210			public function getMetaDescription () : string {
211			return $this->row['meta_description'];
212			}
213
214			public function getMetaKeywords () : string {
215			return $this->row['meta_keywords'];
216			}
217
218			public function getMetaRobotsOptions () : string {
219			return $this->row['meta_robots'];
220			}
221
222			public function getMetaCanonicals () : string {
223			return $this->row['meta_canonicals'];
224			}
225
226			public function getOgType () : string {
227			return $this->row['og_type'];
228			}
229
230			public function getOgTitle () : string {
231			return !empty($this->row['og_title']) ? $this->row['og_title'] : $this->getTitle();
232			}
233
234			public function getOgDescription () : string {
235			return !empty($this->row['og_description']) ? $this->row['og_description'] : $this->getMetaDescription();
236			}
237
238			public function getOgImage () : string {
239			return $this->row['og_image'];
240			}
241
242			public function getAuthorID () : int {
243			return $this->row['author'];
244			}
245
246			public function getAuthor () : User {
247			if ($this->author == null) {
248			//load author
249			$this->author = new User();
250
251			if ($this->getAuthorID() <= 0) {
252			throw new IllegalArgumentException("authorID has to be > 0.");
253			}
254
255			$this->author->load($this->getAuthorID());
256			}
257
258			return $this->author;
259			}
260
261			public function activate (bool $bool = true) {
262			$this->row['activated'] = ($bool ? 1 : 0);
263			}
264
265			public function isTrash () : bool {
266			return $this->row['activated'] == 2;
267			}
268
269			public function isEditable () : bool {
270			return $this->row['editable'] == 1;
271			}
272
273			public function isDeletable () : bool {
274			return $this->row['deletable'] == 1;
275			}
276
277			public function isActivated () : bool {
278			return $this->row['activated'] == 1;
279			}
280
281			public function moveToTrash () {
282			self::movePageToTrash($this->pageID);
283
284			//clear cache
285			$this->clearCache();
286			}
287
288			/**
289			* restore page from trash
290			*/
291			public function restore () {
292			self::restorePage($this->pageID);
293
294			//clear cache
295			$this->clearCache();
296			}
297
298			/**
299			* save changes into database
300			*/
301			public function save () {
302			//TODO: add code here
303			}
304
305			public function clearCache () {
306			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...
307			throw new IllegalStateException("pageID isn't set.");
308			}
309
310			//clear cache
311			Cache::clear("pages", "pageID_" . $this->getPageID());
312			Cache::clear("pages", "page_" . $this->getAlias());
313			}
314
315			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 {
316			//throw event
317			Events::throwEvent("create_page", array(
318			'alias' => &$alias,
319			'title' => &$title,
320			'page_type' => &$page_type,
321			'content' => &$content,
322			'folder' => &$folder,
323			'global_menu' => &$globalMenu,
324			'local_menu' => &$localMenu,
325			'parentID' => &$parentID,
326			'sitemap' => &$sitemap,
327			'published' => &$published,
328			'editable' => &$editable,
329			'author' => &$author
330			));
331
332			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...
333			//get userID of author
334			$author = User::getIDByUsernameFromDB($author);
335
336			if ($author == -1) {
337			//username doesnt exists, so choose first user
338			$author = 1;
339			}
340			} else {
341			$author = (int) $author;
342			}
343
344			Database::getInstance()->execute("INSERT INTO `{praefix}pages` (
345			`id`, `alias`, `title`, `content`, `parent`, `folder`, `global_menu`, `local_menu`, `page_type`, `design`, `sitemap`, `published`, `version`, `last_update`, `created`, `editable`, `deletable`, `author`, `activated`
346			) VALUES (
347			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'
348			) ON DUPLICATE KEY UPDATE `alias` = :alias, `editable` = :editable, `deletable` = :deletable; ", array(
349			'alias' => $alias,
350			'title' => $title,
351			'content' => $content,
352			'parent' => $parentID,
353			'folder' => $folder,
354			'globalMenu' => $globalMenu,
355			'localMenu' => $localMenu,
356			'pageType' => $page_type,
357			'sitemap' => ($sitemap ? 1 : 0),
358			'published' => ($published ? 1 : 0),
359			'editable' => ($editable ? 1 : 0),
360			'deletable' => ($deletable ? 1 : 0),
361			'author' => $author
362			));
363
364			Cache::clear("pages");
365
366			//return page id
367			$insertID = Database::getInstance()->lastInsertId();
368
369			//throw event
370			Events::throwEvent("created_page", array(
371			'alias' => $alias,
372			'title' => $title,
373			'insertID' => $insertID
374			));
375
376			//get pageID by alias
377			$pageID = Page::getPageIDByAlias($alias);
378
379			//set default rights, allow page for administrators, registered users, guests and bots
380			PageRights::setDefaultAllowedGroups($pageID, array(1, 2, 3, 4));
381
382			return $pageID;
383			}
384
385			public static function delete (string $alias) {
386			$delete = true;
387
388			//plugins can avoid deletion or change alias
389			Events::throwEvent("delete_page_alias", array(
390			'alias' => &$alias,
391			'delete' => &$delete
392			));
393
394			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...
395			//remove page from database
396			Database::getInstance()->execute("DELETE FROM `{praefix}pages` WHERE `alias` = :alias; ", array('alias' => $alias));
397
398			Cache::clear("pages");
399			}
400			}
401
402			public static function deleteByID (int $id) {
403			$delete = true;
404
405			//plugins can avoid deletion or change alias
406			Events::throwEvent("delete_page_id", array(
407			'alias' => &$id,
408			'delete' => &$delete
409			));
410
411			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...
412			//remove page from database
413			Database::getInstance()->execute("DELETE FROM `{praefix}pages` WHERE `id` = :id; ", array('id' => $id));
414
415			Cache::clear("pages");
416			}
417			}
418
419			public static function get (string $alias) : Page {
420			$page = new Page();
421			$page->load($alias);
422
423			return $page;
424			}
425
426			public static function setPageType (string $alias, string $page_type) {
427			Events::throwEvent("set_pagetype", array(
428			'alias' => &$alias,
429			'page_type' => &$page_type
430			));
431
432			Database::getInstance()->execute("UPDATE `{praefix}pages` SET `page_type` = :page_type WHERE `alias` = :alias; ", array(
433			'alias' => $alias,
434			'page_type' => $page_type
435			));
436
437			Cache::clear("pages");
438			}
439
440			/**
441			* get id of page by alias
442			*
443			* only use this method for database upgrade, because their is no caching for this method!
444			*
445			* @param string $alias alias of page
446			*
447			* @throws IllegalStateException if alias doesnt exists
448			*
449			* @return int pageID
450			*/
451			public static function getPageIDByAlias (string $alias) : int {
452			$row = Database::getInstance()->getRow("SELECT * FROM `{praefix}pages` WHERE `alias` = :alias; ", array('alias' => $alias));
453
454			if (!$row) {
455			throw new IllegalStateException("page with alias '" . $alias . "' doesnt exists.");
456			}
457
458			return $row['id'];
459			}
460
461			public static function lockPage (int $pageID, int $userID) {
462			Database::getInstance()->execute("UPDATE `{praefix}pages` SET `locked_by` = :userID, `locked_timestamp` = CURRENT_TIMESTAMP WHERE `id` = :pageID; ", array(
463			'userID' => $userID,
464			'pageID' => $pageID
465			));
466
467			//clear cache
468			Cache::clear("pages", "pageID_" . $pageID);
469			}
470
471			public static function unlockPage (int $pageID) {
472			Database::getInstance()->execute("UPDATE `{praefix}pages` SET `locked_by` = '-1' WHERE `id` = :pageID; ", array(
473			'pageID' => $pageID
474			));
475
476			//clear cache
477			Cache::clear("pages", "pageID_" . $pageID);
478			}
479
480			protected static function movePageToTrash (int $pageID) {
481			Database::getInstance()->execute("UPDATE `{praefix}pages` SET `activated` = 2 WHERE `id` = :pageID; ", array(
482			'pageID' => $pageID
483			));
484
485			//clear cache
486			Cache::clear("pages", "pageID_" . $pageID);
487			}
488
489			protected static function restorePage (int $pageID) {
490			Database::getInstance()->execute("UPDATE `{praefix}pages` SET `activated` = 1 WHERE `id` = :pageID; ", array(
491			'pageID' => $pageID
492			));
493
494			//clear cache
495			Cache::clear("pages", "pageID_" . $pageID);
496			}
497
498			public static function exists (string $alias) : bool {
499			$row = Database::getInstance()->getRow("SELECT * FROM `{praefix}pages` WHERE `alias` = :alias; ", array(
500			'alias' => $alias
501			));
502
503			return $row !== false;
504			}
505
506			}
507
508			?>
			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...
509

JuKu / JuKuCMS

Push — master ( 833ded...e0bbff )

Page::getOgDescription() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like