Page::movePageToTrash()   A
last analyzed

Complexity

Conditions 1
Paths 1

Size

Total Lines 7
Code Lines 3

Duplication

Lines 0
Ratio 0 %

Importance

Changes 2
Bugs 0 Features 2
Metric Value
cc 1
eloc 3
nc 1
nop 1
dl 0
loc 7
rs 10
c 2
b 0
f 2
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 by
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 by
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 by
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 by
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 by
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