Page::getOgImages() - Code Metrics - JuKu/JuKuCMS - Measure and Improve Code Quality continuously with Scrutinizer

Page::getOgImages() A
last analyzed 2018-09-20 13:04 UTC

↳ Parent: Page

Complexity

Conditions	2
Paths	2

Size

Total Lines	6
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	2
eloc	3
nc	2
nop	0
dl	0
loc	6
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 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 getSitemapChangeFreq () : string {
		return $this->row['sitemap_changefreq'];
	}

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

	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 getSitemapChangeFreq () : string {
274			return $this->row['sitemap_changefreq'];
275			}
276
277			public function getSitemapPriority () : string {
278			return $this->row['sitemap_priority'];
279			}
280
281			public function activate (bool $bool = true) {
282			$this->row['activated'] = ($bool ? 1 : 0);
283			}
284
285			public function isTrash () : bool {
286			return $this->row['activated'] == 2;
287			}
288
289			public function isEditable () : bool {
290			return $this->row['editable'] == 1;
291			}
292
293			public function isDeletable () : bool {
294			return $this->row['deletable'] == 1;
295			}
296
297			public function isActivated () : bool {
298			return $this->row['activated'] == 1;
299			}
300
301			public function moveToTrash () {
302			self::movePageToTrash($this->pageID);
303
304			//clear cache
305			$this->clearCache();
306			}
307
308			/**
309			* restore page from trash
310			*/
311			public function restore () {
312			self::restorePage($this->pageID);
313
314			//clear cache
315			$this->clearCache();
316			}
317
318			/**
319			* save changes into database
320			*/
321			public function save () {
322			//TODO: add code here
323			}
324
325			public function clearCache () {
326			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...
327			throw new IllegalStateException("pageID isn't set.");
328			}
329
330			//clear cache
331			Cache::clear("pages", "pageID_" . $this->getPageID());
332			Cache::clear("pages", "page_" . $this->getAlias());
333			}
334
335			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 {
336			//throw event
337			Events::throwEvent("create_page", array(
338			'alias' => &$alias,
339			'title' => &$title,
340			'page_type' => &$page_type,
341			'content' => &$content,
342			'folder' => &$folder,
343			'global_menu' => &$globalMenu,
344			'local_menu' => &$localMenu,
345			'parentID' => &$parentID,
346			'sitemap' => &$sitemap,
347			'published' => &$published,
348			'editable' => &$editable,
349			'author' => &$author
350			));
351
352			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...
353			//get userID of author
354			$author = User::getIDByUsernameFromDB($author);
355
356			if ($author == -1) {
357			//username doesnt exists, so choose first user
358			$author = 1;
359			}
360			} else {
361			$author = (int) $author;
362			}
363
364			Database::getInstance()->execute("INSERT INTO `{praefix}pages` (
365			`id`, `alias`, `title`, `content`, `parent`, `folder`, `global_menu`, `local_menu`, `page_type`, `design`, `sitemap`, `published`, `version`, `last_update`, `created`, `editable`, `deletable`, `author`, `activated`
366			) VALUES (
367			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'
368			) ON DUPLICATE KEY UPDATE `alias` = :alias, `editable` = :editable, `deletable` = :deletable; ", array(
369			'alias' => $alias,
370			'title' => $title,
371			'content' => $content,
372			'parent' => $parentID,
373			'folder' => $folder,
374			'globalMenu' => $globalMenu,
375			'localMenu' => $localMenu,
376			'pageType' => $page_type,
377			'sitemap' => ($sitemap ? 1 : 0),
378			'published' => ($published ? 1 : 0),
379			'editable' => ($editable ? 1 : 0),
380			'deletable' => ($deletable ? 1 : 0),
381			'author' => $author
382			));
383
384			Cache::clear("pages");
385
386			//return page id
387			$insertID = Database::getInstance()->lastInsertId();
388
389			//throw event
390			Events::throwEvent("created_page", array(
391			'alias' => $alias,
392			'title' => $title,
393			'insertID' => $insertID
394			));
395
396			//get pageID by alias
397			$pageID = Page::getPageIDByAlias($alias);
398
399			//set default rights, allow page for administrators, registered users, guests and bots
400			PageRights::setDefaultAllowedGroups($pageID, array(1, 2, 3, 4));
401
402			return $pageID;
403			}
404
405			public static function delete (string $alias) {
406			$delete = true;
407
408			//plugins can avoid deletion or change alias
409			Events::throwEvent("delete_page_alias", array(
410			'alias' => &$alias,
411			'delete' => &$delete
412			));
413
414			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...
415			//remove page from database
416			Database::getInstance()->execute("DELETE FROM `{praefix}pages` WHERE `alias` = :alias; ", array('alias' => $alias));
417
418			Cache::clear("pages");
419			}
420			}
421
422			public static function deleteByID (int $id) {
423			$delete = true;
424
425			//plugins can avoid deletion or change alias
426			Events::throwEvent("delete_page_id", array(
427			'alias' => &$id,
428			'delete' => &$delete
429			));
430
431			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...
432			//remove page from database
433			Database::getInstance()->execute("DELETE FROM `{praefix}pages` WHERE `id` = :id; ", array('id' => $id));
434
435			Cache::clear("pages");
436			}
437			}
438
439			public static function get (string $alias) : Page {
440			$page = new Page();
441			$page->load($alias);
442
443			return $page;
444			}
445
446			public static function setPageType (string $alias, string $page_type) {
447			Events::throwEvent("set_pagetype", array(
448			'alias' => &$alias,
449			'page_type' => &$page_type
450			));
451
452			Database::getInstance()->execute("UPDATE `{praefix}pages` SET `page_type` = :page_type WHERE `alias` = :alias; ", array(
453			'alias' => $alias,
454			'page_type' => $page_type
455			));
456
457			Cache::clear("pages");
458			}
459
460			/**
461			* get id of page by alias
462			*
463			* only use this method for database upgrade, because their is no caching for this method!
464			*
465			* @param string $alias alias of page
466			*
467			* @throws IllegalStateException if alias doesnt exists
468			*
469			* @return int pageID
470			*/
471			public static function getPageIDByAlias (string $alias) : int {
472			$row = Database::getInstance()->getRow("SELECT * FROM `{praefix}pages` WHERE `alias` = :alias; ", array('alias' => $alias));
473
474			if (!$row) {
475			throw new IllegalStateException("page with alias '" . $alias . "' doesnt exists.");
476			}
477
478			return $row['id'];
479			}
480
481			public static function lockPage (int $pageID, int $userID) {
482			Database::getInstance()->execute("UPDATE `{praefix}pages` SET `locked_by` = :userID, `locked_timestamp` = CURRENT_TIMESTAMP WHERE `id` = :pageID; ", array(
483			'userID' => $userID,
484			'pageID' => $pageID
485			));
486
487			//clear cache
488			Cache::clear("pages", "pageID_" . $pageID);
489			}
490
491			public static function unlockPage (int $pageID) {
492			Database::getInstance()->execute("UPDATE `{praefix}pages` SET `locked_by` = '-1' WHERE `id` = :pageID; ", array(
493			'pageID' => $pageID
494			));
495
496			//clear cache
497			Cache::clear("pages", "pageID_" . $pageID);
498			}
499
500			protected static function movePageToTrash (int $pageID) {
501			Database::getInstance()->execute("UPDATE `{praefix}pages` SET `activated` = 2 WHERE `id` = :pageID; ", array(
502			'pageID' => $pageID
503			));
504
505			//clear cache
506			Cache::clear("pages", "pageID_" . $pageID);
507			}
508
509			protected static function restorePage (int $pageID) {
510			Database::getInstance()->execute("UPDATE `{praefix}pages` SET `activated` = 1 WHERE `id` = :pageID; ", array(
511			'pageID' => $pageID
512			));
513
514			//clear cache
515			Cache::clear("pages", "pageID_" . $pageID);
516			}
517
518			public static function exists (string $alias) : bool {
519			$row = Database::getInstance()->getRow("SELECT * FROM `{praefix}pages` WHERE `alias` = :alias; ", array(
520			'alias' => $alias
521			));
522
523			return $row !== false;
524			}
525
526			}
527
528			?>
			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...
529

JuKu / JuKuCMS

Page::getOgImages() A last analyzed 2018-09-20 13:04 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Page::getOgImages() A
last analyzed 2018-09-20 13:04 UTC