Schlaefer / Saito

app/Model/Entry.php

Indentation +935 added lines, -935 removed lines

@@ -1,8 +1,8 @@ 
 <?php
 
-	use Saito\User\ForumsUserInterface;
+    use Saito\User\ForumsUserInterface;
 
-	App::uses('AppModel', 'Model');
+    App::uses('AppModel', 'Model');
 
 /**
  *
@@ -23,225 +23,225 @@ 
  * @td After mlf is gone `edited_by` should conatin a User.id, not the username string.
  *
  */
-	class Entry extends AppModel {
-
-		public $name = 'Entry';
-
-		public $primaryKey = 'id';
-
-		public $actsAs = [
-			'Markup',
-			'Containable',
-			'Search.Searchable',
-			'Tree'
-		];
-
-		public $findMethods = array(
-			'feed' => true,
-			'entry' => true
-		);
-
-		/**
-		 * Fields for search plugin
-		 *
-		 * @var array
-		 */
-		public $filterArgs = [
-				'subject' => ['type' => 'like'],
-				'text' => ['type' => 'like'],
-				'name' => ['type' => 'like'],
-				'category_id' => ['type' => 'value'],
-		];
-
-		public $belongsTo = array(
-			'Category' => array(
-				'className' => 'Category',
-				'foreignKey' => 'category_id',
-			),
-			'User' => array(
-				'className' => 'User',
-				'foreignKey' => 'user_id',
-				'counterCache' => true,
-			),
-		);
-
-		public $hasMany = array(
-			'Bookmark' => array(
-				'foreignKey' => 'entry_id',
-				'dependent' => true,
-			),
-			'Esevent' => array(
-				'foreignKey' => 'subject',
-				'conditions' => array('Esevent.subject' => 'Entry.id'),
-			),
-			'UserRead' => [
-				'foreignKey' => 'entry_id',
-				'dependent' => true
-			]
-		);
-
-		public $validate = [
-				'subject' => [
-						'notEmpty' => ['rule' => 'notBlank'],
-						'maxLength' => ['rule' => 'validateSubjectMaxLength']
-				],
-				'category_id' => [
-						'notEmpty' => ['rule' => 'notBlank'],
-						'numeric' => ['rule' => 'numeric'],
-						'isAllowed' => ['rule' => 'validateCategoryIsAllowed']
-				],
-				'user_id' => ['rule' => 'numeric'],
-				'views' => ['rule' => ['comparison', '>=', 0]],
-			// used in full text search
-				'name' => array()
-		];
-
-		/**
-		 * Fields allowed in public output
-		 *
-		 * @var array
-		 */
-		protected $_allowedPublicOutputFields = [
-			'Entry.id',
-			'Entry.pid',
-			'Entry.tid',
-			'Entry.time',
-			'Entry.last_answer',
-			'Entry.edited',
-			'Entry.edited_by',
-			'Entry.user_id',
-			'Entry.name',
-			'Entry.subject',
-			'Entry.category_id',
-			'Entry.text',
-			'Entry.locked',
-			'Entry.fixed',
-			'Entry.views',
-			'User.username'
-		];
-
-		/**
-		 * field list necessary for displaying a thread_line
-		 *
-		 * Entry.text determine if Entry is n/t
-		 *
-		 * @var string
-		 */
-		public $threadLineFieldList = [
-			'Entry.id',
-			'Entry.pid',
-			'Entry.tid',
-			'Entry.subject',
-			'Entry.text',
-			'Entry.time',
-			'Entry.fixed',
-			'Entry.last_answer',
-			'Entry.views',
-			'Entry.user_id',
-			'Entry.locked',
-			'Entry.name',
-			'Entry.solves',
-
-			'User.username',
-
-			'Category.accession',
-			'Category.category',
-			'Category.description'
-		];
-
-		/**
-		 * fields additional to $threadLineFieldList to show complete entry
-		 *
-		 * @var string
-		 */
-		public $showEntryFieldListAdditional = [
-			'Entry.edited',
-			'Entry.edited_by',
-			'Entry.ip',
-			'Entry.category_id',
-
-			'User.id',
-			'User.signature',
-			'User.user_place'
-		];
-
-		/**
-		 * Allowed external user input
-		 *
-		 * @var array
-		 */
-		public $allowedInputFields = [
-			'create' => [
-				'category_id',
-				'pid',
-				'subject',
-				'text'
-			],
-			'update' => [
-				'id',
-				'category_id',
-				'subject',
-				'text'
-			]
-		];
-
-		protected $_settings = [
-			'edit_period' => 20,
-			'subject_maxlength' => 100
-		];
+    class Entry extends AppModel {
+
+        public $name = 'Entry';
+
+        public $primaryKey = 'id';
+
+        public $actsAs = [
+            'Markup',
+            'Containable',
+            'Search.Searchable',
+            'Tree'
+        ];
+
+        public $findMethods = array(
+            'feed' => true,
+            'entry' => true
+        );
+
+        /**
+         * Fields for search plugin
+         *
+         * @var array
+         */
+        public $filterArgs = [
+                'subject' => ['type' => 'like'],
+                'text' => ['type' => 'like'],
+                'name' => ['type' => 'like'],
+                'category_id' => ['type' => 'value'],
+        ];
+
+        public $belongsTo = array(
+            'Category' => array(
+                'className' => 'Category',
+                'foreignKey' => 'category_id',
+            ),
+            'User' => array(
+                'className' => 'User',
+                'foreignKey' => 'user_id',
+                'counterCache' => true,
+            ),
+        );
+
+        public $hasMany = array(
+            'Bookmark' => array(
+                'foreignKey' => 'entry_id',
+                'dependent' => true,
+            ),
+            'Esevent' => array(
+                'foreignKey' => 'subject',
+                'conditions' => array('Esevent.subject' => 'Entry.id'),
+            ),
+            'UserRead' => [
+                'foreignKey' => 'entry_id',
+                'dependent' => true
+            ]
+        );
+
+        public $validate = [
+                'subject' => [
+                        'notEmpty' => ['rule' => 'notBlank'],
+                        'maxLength' => ['rule' => 'validateSubjectMaxLength']
+                ],
+                'category_id' => [
+                        'notEmpty' => ['rule' => 'notBlank'],
+                        'numeric' => ['rule' => 'numeric'],
+                        'isAllowed' => ['rule' => 'validateCategoryIsAllowed']
+                ],
+                'user_id' => ['rule' => 'numeric'],
+                'views' => ['rule' => ['comparison', '>=', 0]],
+            // used in full text search
+                'name' => array()
+        ];
+
+        /**
+         * Fields allowed in public output
+         *
+         * @var array
+         */
+        protected $_allowedPublicOutputFields = [
+            'Entry.id',
+            'Entry.pid',
+            'Entry.tid',
+            'Entry.time',
+            'Entry.last_answer',
+            'Entry.edited',
+            'Entry.edited_by',
+            'Entry.user_id',
+            'Entry.name',
+            'Entry.subject',
+            'Entry.category_id',
+            'Entry.text',
+            'Entry.locked',
+            'Entry.fixed',
+            'Entry.views',
+            'User.username'
+        ];
+
+        /**
+         * field list necessary for displaying a thread_line
+         *
+         * Entry.text determine if Entry is n/t
+         *
+         * @var string
+         */
+        public $threadLineFieldList = [
+            'Entry.id',
+            'Entry.pid',
+            'Entry.tid',
+            'Entry.subject',
+            'Entry.text',
+            'Entry.time',
+            'Entry.fixed',
+            'Entry.last_answer',
+            'Entry.views',
+            'Entry.user_id',
+            'Entry.locked',
+            'Entry.name',
+            'Entry.solves',
+
+            'User.username',
+
+            'Category.accession',
+            'Category.category',
+            'Category.description'
+        ];
+
+        /**
+         * fields additional to $threadLineFieldList to show complete entry
+         *
+         * @var string
+         */
+        public $showEntryFieldListAdditional = [
+            'Entry.edited',
+            'Entry.edited_by',
+            'Entry.ip',
+            'Entry.category_id',
+
+            'User.id',
+            'User.signature',
+            'User.user_place'
+        ];
+
+        /**
+         * Allowed external user input
+         *
+         * @var array
+         */
+        public $allowedInputFields = [
+            'create' => [
+                'category_id',
+                'pid',
+                'subject',
+                'text'
+            ],
+            'update' => [
+                'id',
+                'category_id',
+                'subject',
+                'text'
+            ]
+        ];
+
+        protected $_settings = [
+            'edit_period' => 20,
+            'subject_maxlength' => 100
+        ];
 
 /**
  * Caching for isRoot()
  *
  * @var array
  */
-		protected $_isRoot = [];
-
-		/**
-		 * @param ForumsUserInterface $User
-		 * @param array $options
-		 * @return array|mixed
-		 */
-		public function getRecentEntries(CurrentUserComponent $User, array $options = []) {
-			Stopwatch::start('Model->User->getRecentEntries()');
-
-			$options += [
-				'user_id' => null,
-				'limit' => 10,
-				'category_id' => $User->Categories->getAllowed()
-			];
-
-			$_cacheKey = 'Entry.recentEntries-' . md5(serialize($options));
-			$_cachedEntry = Cache::read($_cacheKey, 'entries');
-			if ($_cachedEntry) {
-				Stopwatch::stop('Model->User->getRecentEntries()');
-				return $_cachedEntry;
-			}
-
-			$conditions = array();
-			if ($options['user_id'] !== null) {
-				$conditions[]['Entry.user_id'] = $options['user_id'];
-			}
-			if ($options['category_id'] !== null):
-				$conditions[]['Entry.category_id'] = $options['category_id'];
-			endif;
-
-			$result = $this->find(
-				'all',
-				[
-					'contain' => array('User', 'Category'),
-					'fields' => $this->threadLineFieldList,
-					'conditions' => $conditions,
-					'limit' => $options['limit'],
-					'order' => 'time DESC'
-				]
-			);
-
-			Cache::write($_cacheKey, $result, 'entries');
-
-			Stopwatch::stop('Model->User->getRecentEntries()');
-			return $result;
-		}
+        protected $_isRoot = [];
+
+        /**
+         * @param ForumsUserInterface $User
+         * @param array $options
+         * @return array|mixed
+         */
+        public function getRecentEntries(CurrentUserComponent $User, array $options = []) {
+            Stopwatch::start('Model->User->getRecentEntries()');
+
+            $options += [
+                'user_id' => null,
+                'limit' => 10,
+                'category_id' => $User->Categories->getAllowed()
+            ];
+
+            $_cacheKey = 'Entry.recentEntries-' . md5(serialize($options));
+            $_cachedEntry = Cache::read($_cacheKey, 'entries');
+            if ($_cachedEntry) {
+                Stopwatch::stop('Model->User->getRecentEntries()');
+                return $_cachedEntry;
+            }
+
+            $conditions = array();
+            if ($options['user_id'] !== null) {
+                $conditions[]['Entry.user_id'] = $options['user_id'];
+            }
+            if ($options['category_id'] !== null):
+                $conditions[]['Entry.category_id'] = $options['category_id'];
+            endif;
+
+            $result = $this->find(
+                'all',
+                [
+                    'contain' => array('User', 'Category'),
+                    'fields' => $this->threadLineFieldList,
+                    'conditions' => $conditions,
+                    'limit' => $options['limit'],
+                    'order' => 'time DESC'
+                ]
+            );
+
+            Cache::write($_cacheKey, $result, 'entries');
+
+            Stopwatch::stop('Model->User->getRecentEntries()');
+            return $result;
+        }
 
 /**
  * Finds the thread-id for a posting
@@ -250,233 +250,233 @@ 
  * @return int Thread-Id
  * @throws UnexpectedValueException
  */
-		public function getThreadId($id) {
-			$entry = $this->find(
-				'first',
-				[
-					'contain' => false,
-					'conditions' => ['Entry.id' => $id],
-					'fields' => 'Entry.tid'
-
-				]
-			);
-			if ($entry == false) {
-				throw new UnexpectedValueException('Posting not found. Posting-Id: ' . $id);
-			}
-			return $entry['Entry']['tid'];
-		}
+        public function getThreadId($id) {
+            $entry = $this->find(
+                'first',
+                [
+                    'contain' => false,
+                    'conditions' => ['Entry.id' => $id],
+                    'fields' => 'Entry.tid'
+
+                ]
+            );
+            if ($entry == false) {
+                throw new UnexpectedValueException('Posting not found. Posting-Id: ' . $id);
+            }
+            return $entry['Entry']['tid'];
+        }
 
 /**
  * Shorthand for reading an entry with full data
  */
-		public function get($id) {
-			return $this->find('entry',
-					['conditions' => [$this->alias . '.id' => $id]]);
-		}
+        public function get($id) {
+            return $this->find('entry',
+                    ['conditions' => [$this->alias . '.id' => $id]]);
+        }
 
 /**
  * @param $id
  * @return mixed
  * @throws UnexpectedValueException
  */
-		public function getParentId($id) {
-			$entry = $this->find(
-				'first',
-				[
-					'contain' => false,
-					'conditions' => ['Entry.id' => $id],
-					'fields' => 'Entry.pid'
-
-				]
-			);
-			if ($entry == false) {
-				throw new UnexpectedValueException('Posting not found. Posting-Id: ' . $id);
-			}
-			return $entry['Entry']['pid'];
-		}
-
-		/**
-		 * creates a new root or child entry for a node
-		 *
-		 * fields in $data are filtered
-		 *
-		 * @param $data
-		 * @return array|bool|mixed
-		 */
-		public function createPosting($data) {
-			if (!isset($data[$this->alias]['pid'])) {
-				$data[$this->alias]['pid'] = 0;
-			}
-
-			if (isset($data[$this->alias]['subject']) === false) {
-				return false;
-			}
-
-			try {
-				$this->prepare($data, ['preFilterFields' => 'create']);
-			} catch (Exception $e) {
-				return false;
-			}
-
-			$data[$this->alias]['user_id'] = $this->CurrentUser->getId();
-			$data[$this->alias]['name'] = $this->CurrentUser['username'];
-
-			$data[$this->alias]['time'] = bDate();
-			$data[$this->alias]['last_answer'] = bDate();
-			$data[$this->alias]['ip'] = self::_getIp();
-
-			$this->create();
-			$_newPosting = $this->save($data);
-
-			if ($_newPosting === false) {
-				return false;
-			}
-
-			$_newPostingId = $this->id;
-
-			// make sure we pass the complete ['Entry'] dataset to events
-			$this->contain();
-			$_newPosting = $this->read();
-
-			if ($this->isRoot($data)) {
-				// thread-id of new thread is its own id
-				if ($this->save(['tid' => $_newPostingId], false, ['tid']) === false) {
-					// @td raise error and/or roll back new entry
-					return false;
-				} else {
-					$_newPosting[$this->alias]['tid'] = $_newPostingId;
-					$this->Category->id = $data[$this->alias]['category_id'];
-					$this->Category->updateThreadCounter();
-				}
-				$this->_dispatchEvent(
-					'Model.Thread.create',
-					[
-						'subject' => $_newPosting[$this->alias]['id'],
-						'data' => $_newPosting
-					]
-				);
-			} else {
-				// update last answer time of root entry
-				$this->clear();
-				$this->id = $_newPosting[$this->alias]['tid'];
-				$this->set('last_answer', $_newPosting[$this->alias]['last_answer']);
-				if ($this->save() === false) {
-					// @td raise error and/or roll back new entry
-					return false;
-				}
-
-				$this->_dispatchEvent(
-					'Model.Entry.replyToEntry',
-					[
-						'subject' => $_newPosting[$this->alias]['pid'],
-						'data' => $_newPosting
-					]
-				);
-				$this->_dispatchEvent(
-					'Model.Entry.replyToThread',
-					[
-						'subject' => $_newPosting[$this->alias]['tid'],
-						'data' => $_newPosting
-					]
-				);
-			}
-
-			$this->id = $_newPostingId;
-			$_newPosting[$this->alias]['subject'] = Sanitize::html($_newPosting[$this->alias]['subject']);
-			$_newPosting[$this->alias]['text'] = Sanitize::html($_newPosting[$this->alias]['text']);
-			return $_newPosting;
-		}
-
-		/**
-		 * Updates a posting
-		 *
-		 * fields in $data are filtered except for $id!
-		 *
-		 * @param $data
-		 * @param null $CurrentUser
-		 * @return array|mixed
-		 * @throws NotFoundException
-		 * @throws InvalidArgumentException
-		 */
-		public function update($data, $CurrentUser = null) {
-			if ($CurrentUser !== null) {
-				$this->CurrentUser = $CurrentUser;
-			}
-
-			if (empty($data[$this->alias]['id'])) {
-				throw new InvalidArgumentException('Missing entry id in arguments.');
-			}
-
-			$id = $data[$this->alias]['id'];
-			if (!$this->exists($id)) {
-				throw new NotFoundException(sprintf('Entry with id `%s` not found.', $id));
-			}
-
-			$this->prepare($data, ['preFilterFields' => 'update']);
-
-			// prevents normal user of changing category of complete thread when answering
-			// @todo this should be refactored together with the change category handling in beforeSave()
-			if ($this->isRoot($data) === false) {
-				unset($data[$this->alias]['category_id']);
-			}
-
-			$data[$this->alias]['edited'] = bDate();
-			$data[$this->alias]['edited_by'] = $this->CurrentUser['username'];
-
-			$this->validator()->add(
-				'edited_by',
-				'isEditingAllowed',
-				[
-					'rule' => 'validateEditingAllowed'
-				]
-			);
-
-			$result = $this->save($data);
-
-			if ($result) {
-				$this->contain();
-				$result = $this->read() + $data;
-				$this->_dispatchEvent(
-					'Model.Entry.update',
-					[
-						'subject' => $result[$this->alias]['id'],
-						'data' => $result
-					]
-				);
-			}
-
-			return $result;
-		}
-
-		/**
-		 * Update view counter on all entries in a thread
-		 *
-		 * Note that this function unbinds the model associations for performance.
-		 * Otherwise updateAll() left joins all associated models.
-		 *
-		 * @param $tid thread-ID
-		 * @param $uid entries with this user-id are not updated
-		 */
-		public function threadIncrementViews($tid, $uid = null) {
-			Stopwatch::start('Entry::threadIncrementViews');
-			$_where = ['Entry.tid' => $tid];
-			if ($uid && is_int($uid)) {
-				$_where['Entry.user_id !='] = $uid;
-			}
-			// $_belongsTo = $this->belongsTo;
-			$this->unbindModel(['belongsTo' => array_keys($this->belongsTo)]);
-			$this->updateAll(['Entry.views' => 'Entry.views + 1'], $_where);
-			// $this->bindModel(['belongsTo' => $_belongsTo]);
-			Stopwatch::stop('Entry::threadIncrementViews');
-		}
+        public function getParentId($id) {
+            $entry = $this->find(
+                'first',
+                [
+                    'contain' => false,
+                    'conditions' => ['Entry.id' => $id],
+                    'fields' => 'Entry.pid'
+
+                ]
+            );
+            if ($entry == false) {
+                throw new UnexpectedValueException('Posting not found. Posting-Id: ' . $id);
+            }
+            return $entry['Entry']['pid'];
+        }
+
+        /**
+         * creates a new root or child entry for a node
+         *
+         * fields in $data are filtered
+         *
+         * @param $data
+         * @return array|bool|mixed
+         */
+        public function createPosting($data) {
+            if (!isset($data[$this->alias]['pid'])) {
+                $data[$this->alias]['pid'] = 0;
+            }
+
+            if (isset($data[$this->alias]['subject']) === false) {
+                return false;
+            }
+
+            try {
+                $this->prepare($data, ['preFilterFields' => 'create']);
+            } catch (Exception $e) {
+                return false;
+            }
+
+            $data[$this->alias]['user_id'] = $this->CurrentUser->getId();
+            $data[$this->alias]['name'] = $this->CurrentUser['username'];
+
+            $data[$this->alias]['time'] = bDate();
+            $data[$this->alias]['last_answer'] = bDate();
+            $data[$this->alias]['ip'] = self::_getIp();
+
+            $this->create();
+            $_newPosting = $this->save($data);
+
+            if ($_newPosting === false) {
+                return false;
+            }
+
+            $_newPostingId = $this->id;
+
+            // make sure we pass the complete ['Entry'] dataset to events
+            $this->contain();
+            $_newPosting = $this->read();
+
+            if ($this->isRoot($data)) {
+                // thread-id of new thread is its own id
+                if ($this->save(['tid' => $_newPostingId], false, ['tid']) === false) {
+                    // @td raise error and/or roll back new entry
+                    return false;
+                } else {
+                    $_newPosting[$this->alias]['tid'] = $_newPostingId;
+                    $this->Category->id = $data[$this->alias]['category_id'];
+                    $this->Category->updateThreadCounter();
+                }
+                $this->_dispatchEvent(
+                    'Model.Thread.create',
+                    [
+                        'subject' => $_newPosting[$this->alias]['id'],
+                        'data' => $_newPosting
+                    ]
+                );
+            } else {
+                // update last answer time of root entry
+                $this->clear();
+                $this->id = $_newPosting[$this->alias]['tid'];
+                $this->set('last_answer', $_newPosting[$this->alias]['last_answer']);
+                if ($this->save() === false) {
+                    // @td raise error and/or roll back new entry
+                    return false;
+                }
+
+                $this->_dispatchEvent(
+                    'Model.Entry.replyToEntry',
+                    [
+                        'subject' => $_newPosting[$this->alias]['pid'],
+                        'data' => $_newPosting
+                    ]
+                );
+                $this->_dispatchEvent(
+                    'Model.Entry.replyToThread',
+                    [
+                        'subject' => $_newPosting[$this->alias]['tid'],
+                        'data' => $_newPosting
+                    ]
+                );
+            }
+
+            $this->id = $_newPostingId;
+            $_newPosting[$this->alias]['subject'] = Sanitize::html($_newPosting[$this->alias]['subject']);
+            $_newPosting[$this->alias]['text'] = Sanitize::html($_newPosting[$this->alias]['text']);
+            return $_newPosting;
+        }
+
+        /**
+         * Updates a posting
+         *
+         * fields in $data are filtered except for $id!
+         *
+         * @param $data
+         * @param null $CurrentUser
+         * @return array|mixed
+         * @throws NotFoundException
+         * @throws InvalidArgumentException
+         */
+        public function update($data, $CurrentUser = null) {
+            if ($CurrentUser !== null) {
+                $this->CurrentUser = $CurrentUser;
+            }
+
+            if (empty($data[$this->alias]['id'])) {
+                throw new InvalidArgumentException('Missing entry id in arguments.');
+            }
+
+            $id = $data[$this->alias]['id'];
+            if (!$this->exists($id)) {
+                throw new NotFoundException(sprintf('Entry with id `%s` not found.', $id));
+            }
+
+            $this->prepare($data, ['preFilterFields' => 'update']);
+
+            // prevents normal user of changing category of complete thread when answering
+            // @todo this should be refactored together with the change category handling in beforeSave()
+            if ($this->isRoot($data) === false) {
+                unset($data[$this->alias]['category_id']);
+            }
+
+            $data[$this->alias]['edited'] = bDate();
+            $data[$this->alias]['edited_by'] = $this->CurrentUser['username'];
+
+            $this->validator()->add(
+                'edited_by',
+                'isEditingAllowed',
+                [
+                    'rule' => 'validateEditingAllowed'
+                ]
+            );
+
+            $result = $this->save($data);
+
+            if ($result) {
+                $this->contain();
+                $result = $this->read() + $data;
+                $this->_dispatchEvent(
+                    'Model.Entry.update',
+                    [
+                        'subject' => $result[$this->alias]['id'],
+                        'data' => $result
+                    ]
+                );
+            }
+
+            return $result;
+        }
+
+        /**
+         * Update view counter on all entries in a thread
+         *
+         * Note that this function unbinds the model associations for performance.
+         * Otherwise updateAll() left joins all associated models.
+         *
+         * @param $tid thread-ID
+         * @param $uid entries with this user-id are not updated
+         */
+        public function threadIncrementViews($tid, $uid = null) {
+            Stopwatch::start('Entry::threadIncrementViews');
+            $_where = ['Entry.tid' => $tid];
+            if ($uid && is_int($uid)) {
+                $_where['Entry.user_id !='] = $uid;
+            }
+            // $_belongsTo = $this->belongsTo;
+            $this->unbindModel(['belongsTo' => array_keys($this->belongsTo)]);
+            $this->updateAll(['Entry.views' => 'Entry.views + 1'], $_where);
+            // $this->bindModel(['belongsTo' => $_belongsTo]);
+            Stopwatch::stop('Entry::threadIncrementViews');
+        }
 
 /**
  *
  * @mb `views` into extra related table if performance becomes a problem
  */
-		public function incrementViews($id, $amount = 1) {
-			$this->increment($id, 'views', $amount);
-		}
+        public function incrementViews($id, $amount = 1) {
+            $this->increment($id, 'views', $amount);
+        }
 
 /**
  * tree of a single node and its subentries
@@ -489,77 +489,77 @@ 
  * @param array $options
  * @return array tree
  */
-		public function treeForNode($id, $options = array()) {
-			$options += [
-				'root' => false,
-				'complete' => false
-			];
-
-			if ($options['root']) {
-				$tid = $id;
-			} else {
-				$tid = $this->getThreadId($id);
-			}
-
-			$fields = null;
-			if ($options['complete']) {
-				$fields = array_merge($this->threadLineFieldList, $this->showEntryFieldListAdditional);
-			}
-
-			$tree = $this->treesForThreads([$tid], null, $fields);
-
-			if ((int)$tid !== (int)$id) {
-				$tree = $this->treeGetSubtree($tree, $id);
-			}
-
-			return $tree;
-		}
-
-		/**
-		 * trees for multiple tids
-		 *
-		 * @param $ids
-		 * @param null $order
-		 * @param null $fieldlist
-		 * @return array|bool false if no threads or array with Posting
-		 */
-		public function treesForThreads($ids, $order = null, $fieldlist = null) {
-			if (empty($ids)) {
-				return [];
-			}
-
-			Stopwatch::start('Model->Entries->treeForThreads() DB');
-
-			if (empty($order)) {
-				$order = 'last_answer ASC';
-			}
-
-			if ($fieldlist === null) {
-				$fieldlist = $this->threadLineFieldList;
-			}
-
-			$entries = $this->_getThreadEntries(
-				$ids,
-				['order' => $order, 'fields' => $fieldlist]
-			);
-
-			Stopwatch::stop('Model->Entries->treeForThreads() DB');
-			Stopwatch::start('Model->Entries->treeForThreads() CPU');
-
-			$threads = false;
-			if ($entries) {
-				$threads = [];
-				$entries = $this->treeBuild($entries);
-				foreach ($entries as $thread) {
-					$id = (int)$thread['Entry']['tid'];
-					$threads[$id] = $thread;
-				}
-			}
-
-			Stopwatch::stop('Model->Entries->treeForThreads() CPU');
-
-			return $threads;
-		}
+        public function treeForNode($id, $options = array()) {
+            $options += [
+                'root' => false,
+                'complete' => false
+            ];
+
+            if ($options['root']) {
+                $tid = $id;
+            } else {
+                $tid = $this->getThreadId($id);
+            }
+
+            $fields = null;
+            if ($options['complete']) {
+                $fields = array_merge($this->threadLineFieldList, $this->showEntryFieldListAdditional);
+            }
+
+            $tree = $this->treesForThreads([$tid], null, $fields);
+
+            if ((int)$tid !== (int)$id) {
+                $tree = $this->treeGetSubtree($tree, $id);
+            }
+
+            return $tree;
+        }
+
+        /**
+         * trees for multiple tids
+         *
+         * @param $ids
+         * @param null $order
+         * @param null $fieldlist
+         * @return array|bool false if no threads or array with Posting
+         */
+        public function treesForThreads($ids, $order = null, $fieldlist = null) {
+            if (empty($ids)) {
+                return [];
+            }
+
+            Stopwatch::start('Model->Entries->treeForThreads() DB');
+
+            if (empty($order)) {
+                $order = 'last_answer ASC';
+            }
+
+            if ($fieldlist === null) {
+                $fieldlist = $this->threadLineFieldList;
+            }
+
+            $entries = $this->_getThreadEntries(
+                $ids,
+                ['order' => $order, 'fields' => $fieldlist]
+            );
+
+            Stopwatch::stop('Model->Entries->treeForThreads() DB');
+            Stopwatch::start('Model->Entries->treeForThreads() CPU');
+
+            $threads = false;
+            if ($entries) {
+                $threads = [];
+                $entries = $this->treeBuild($entries);
+                foreach ($entries as $thread) {
+                    $id = (int)$thread['Entry']['tid'];
+                    $threads[$id] = $thread;
+                }
+            }
+
+            Stopwatch::stop('Model->Entries->treeForThreads() CPU');
+
+            return $threads;
+        }
 
 /**
  * @param       $tid
@@ -574,82 +574,82 @@ 
  *  )
  * </pre>
  */
-		protected function _getThreadEntries($tid, array $params = []) {
-			$params += [
-				'fields' => $this->threadLineFieldList,
-				'order' => 'last_answer ASC'
-			];
-			$threads = $this->find(
-				'all',
-				[
-					'conditions' => ['tid' => $tid],
-					'contain' => ['User', 'Category'],
-					'fields' => $params['fields'],
-					'order' => $params['order']
-				]
-			);
-
-			return $threads;
-		}
-
-		/**
-		 * Marks a sub-entry as solution to a root entry
-		 *
-		 * @param $id
-		 * @return bool
-		 * @throws InvalidArgumentException
-		 * @throws ForbiddenException
-		 */
-		public function toggleSolve($id) {
-			$entry = $this->get($id);
-			if (empty($entry) || $this->isRoot($entry)) {
-				throw new InvalidArgumentException;
-			}
-
-			$root = $this->get($entry['Entry']['tid']);
-			if ((int)$root['User']['id'] !== $this->CurrentUser->getId()) {
-				throw new ForbiddenException;
-			}
-
-			if ($entry[$this->alias]['solves']) {
-				$value = 0;
-			} else {
-				$value = $entry[$this->alias]['tid'];
-			}
-			$this->id = $id;
-			$success = $this->saveField('solves', $value);
-			if (!$success) {
-				return $success;
-			}
-			$this->_dispatchEvent('Model.Entry.update',
-					['subject' => $id, 'data' => $entry]);
-			$entry[$this->alias]['solves'] = $value;
-			return $success;
-		}
-
-		public function toggle($key) {
-			$result = parent::toggle($key);
-			if ($key === 'locked') {
-				$this->_threadLock($result);
-			}
-
-			$this->contain();
-			$entry = $this->read();
-
-			$this->_dispatchEvent(
-				'Model.Entry.update',
-				[
-					'subject' => $entry[$this->alias]['id'],
-					'data' => $entry
-				]
-			);
-
-			return $result;
-		}
-
-		public function beforeFind($queryData) {
-			parent::beforeFind($queryData);
-			/*
+        protected function _getThreadEntries($tid, array $params = []) {
+            $params += [
+                'fields' => $this->threadLineFieldList,
+                'order' => 'last_answer ASC'
+            ];
+            $threads = $this->find(
+                'all',
+                [
+                    'conditions' => ['tid' => $tid],
+                    'contain' => ['User', 'Category'],
+                    'fields' => $params['fields'],
+                    'order' => $params['order']
+                ]
+            );
+
+            return $threads;
+        }
+
+        /**
+         * Marks a sub-entry as solution to a root entry
+         *
+         * @param $id
+         * @return bool
+         * @throws InvalidArgumentException
+         * @throws ForbiddenException
+         */
+        public function toggleSolve($id) {
+            $entry = $this->get($id);
+            if (empty($entry) || $this->isRoot($entry)) {
+                throw new InvalidArgumentException;
+            }
+
+            $root = $this->get($entry['Entry']['tid']);
+            if ((int)$root['User']['id'] !== $this->CurrentUser->getId()) {
+                throw new ForbiddenException;
+            }
+
+            if ($entry[$this->alias]['solves']) {
+                $value = 0;
+            } else {
+                $value = $entry[$this->alias]['tid'];
+            }
+            $this->id = $id;
+            $success = $this->saveField('solves', $value);
+            if (!$success) {
+                return $success;
+            }
+            $this->_dispatchEvent('Model.Entry.update',
+                    ['subject' => $id, 'data' => $entry]);
+            $entry[$this->alias]['solves'] = $value;
+            return $success;
+        }
+
+        public function toggle($key) {
+            $result = parent::toggle($key);
+            if ($key === 'locked') {
+                $this->_threadLock($result);
+            }
+
+            $this->contain();
+            $entry = $this->read();
+
+            $this->_dispatchEvent(
+                'Model.Entry.update',
+                [
+                    'subject' => $entry[$this->alias]['id'],
+                    'data' => $entry
+                ]
+            );
+
+            return $result;
+        }
+
+        public function beforeFind($queryData) {
+            parent::beforeFind($queryData);
+            /*
 				* workarround for possible cakephp join error for associated tables
 				* and virtual fields
 				*
@@ -659,17 +659,17 @@ 
 				*
 				* checkout in cakephp mailing list/bug tracker
 				*/
-			$this->User->virtualFields = null;
-		}
+            $this->User->virtualFields = null;
+        }
 
-		public function beforeValidate($options = array()) {
-			parent::beforeValidate($options);
+        public function beforeValidate($options = array()) {
+            parent::beforeValidate($options);
 
-			//* in n/t posting delete unnecessary body text
-			if (isset($this->data['Entry']['text'])) {
-				$this->data['Entry']['text'] = rtrim($this->data['Entry']['text']);
-			}
-		}
+            //* in n/t posting delete unnecessary body text
+            if (isset($this->data['Entry']['text'])) {
+                $this->data['Entry']['text'] = rtrim($this->data['Entry']['text']);
+            }
+        }
 
 /**
  * Deletes entry and all it's subentries and associated data
@@ -677,43 +677,43 @@ 
  * @return bool
  * @throws Exception
  */
-		public function deleteNode($id = null) {
-			if (empty($id)) {
-				$id = $this->id;
-			}
-
-			$this->contain();
-			$entry = $this->findById($id);
-
-			if (empty($entry)) {
-				throw new Exception;
-			}
-
-			$_idsToDelete = $this->getIdsForNode($id);
-			$success = $this->deleteAll(
-				[$this->alias . '.id' => $_idsToDelete],
-				true,
-				true
-			);
-
-			if ($success):
-				if ($this->isRoot($entry)) {
-					$this->Category->id = $entry['Entry']['category_id'];
-					$this->Category->updateThreadCounter();
-					$this->Esevent->deleteSubject($id, 'thread');
-				}
-				foreach ($_idsToDelete as $_entryId) {
-					$this->Esevent->deleteSubject($_entryId, 'entry');
-				}
-
-				$this->_dispatchEvent(
-					'Model.Thread.change',
-					['subject' => $entry[$this->alias]['tid']]
-				);
-			endif;
-
-			return $success;
-		}
+        public function deleteNode($id = null) {
+            if (empty($id)) {
+                $id = $this->id;
+            }
+
+            $this->contain();
+            $entry = $this->findById($id);
+
+            if (empty($entry)) {
+                throw new Exception;
+            }
+
+            $_idsToDelete = $this->getIdsForNode($id);
+            $success = $this->deleteAll(
+                [$this->alias . '.id' => $_idsToDelete],
+                true,
+                true
+            );
+
+            if ($success):
+                if ($this->isRoot($entry)) {
+                    $this->Category->id = $entry['Entry']['category_id'];
+                    $this->Category->updateThreadCounter();
+                    $this->Esevent->deleteSubject($id, 'thread');
+                }
+                foreach ($_idsToDelete as $_entryId) {
+                    $this->Esevent->deleteSubject($_entryId, 'entry');
+                }
+
+                $this->_dispatchEvent(
+                    'Model.Thread.change',
+                    ['subject' => $entry[$this->alias]['tid']]
+                );
+            endif;
+
+            return $success;
+        }
 
 /**
  * Get the ID of all subentries of and including entry $id
@@ -721,16 +721,16 @@ 
  * @param int $id
  * @return array Ids
  */
-		public function getIdsForNode($id) {
-			$subthread = $this->treeForNode($id);
-			$func = function (&$tree, &$entry) {
-				$tree['ids'][] = (int)$entry['Entry']['id'];
-			};
-			Entry::mapTreeElements($subthread, $func);
-			sort($subthread['ids']);
+        public function getIdsForNode($id) {
+            $subthread = $this->treeForNode($id);
+            $func = function (&$tree, &$entry) {
+                $tree['ids'][] = (int)$entry['Entry']['id'];
+            };
+            Entry::mapTreeElements($subthread, $func);
+            sort($subthread['ids']);
 
-			return $subthread['ids'];
-		}
+            return $subthread['ids'];
+        }
 
 /**
  * Anonymizes the entries for a user
@@ -739,24 +739,24 @@ 
  *
  * @return bool success
  */
-		public function anonymizeEntriesFromUser($userId) {
-			// remove username from all entries and reassign to anonyme user
-			$success = $this->updateAll(
-				[
-					'Entry.name' => "NULL",
-					'Entry.edited_by' => "NULL",
-					'Entry.ip' => "NULL",
-					'Entry.user_id' => 0,
-				],
-				['Entry.user_id' => $userId]
-			);
-
-			if ($success) {
-				$this->_dispatchEvent('Cmd.Cache.clear', ['cache' => 'Thread']);
-			}
-
-			return $success;
-		}
+        public function anonymizeEntriesFromUser($userId) {
+            // remove username from all entries and reassign to anonyme user
+            $success = $this->updateAll(
+                [
+                    'Entry.name' => "NULL",
+                    'Entry.edited_by' => "NULL",
+                    'Entry.ip' => "NULL",
+                    'Entry.user_id' => 0,
+                ],
+                ['Entry.user_id' => $userId]
+            );
+
+            if ($success) {
+                $this->_dispatchEvent('Cmd.Cache.clear', ['cache' => 'Thread']);
+            }
+
+            return $success;
+        }
 
 /**
  * Maps all elements in $tree to function $func
@@ -768,23 +768,23 @@ 
  *
  * @return string
  */
-		public static function mapTreeElements(&$leafs, callable $func, $context = null, &$tree = null) {
-			if ($tree === null) {
-				$tree = & $leafs;
-			}
-			foreach ($leafs as $leaf):
-				$result = $func($tree, $leaf, $context);
-				if ($result === 'break') {
-					return 'break';
-				}
-				if (isset($leaf['_children'])) {
-					$result = self::mapTreeElements($leaf['_children'], $func, $context, $tree);
-					if ($result === 'break') {
-						return 'break';
-					}
-				}
-			endforeach;
-		}
+        public static function mapTreeElements(&$leafs, callable $func, $context = null, &$tree = null) {
+            if ($tree === null) {
+                $tree = & $leafs;
+            }
+            foreach ($leafs as $leaf):
+                $result = $func($tree, $leaf, $context);
+                if ($result === 'break') {
+                    return 'break';
+                }
+                if (isset($leaf['_children'])) {
+                    $result = self::mapTreeElements($leaf['_children'], $func, $context, $tree);
+                    if ($result === 'break') {
+                        return 'break';
+                    }
+                }
+            endforeach;
+        }
 
 /**
  * Merge thread on to entry $targetId
@@ -792,74 +792,74 @@ 
  * @param int $targetId id of the entry the thread should be appended to
  * @return bool true if merge was successfull false otherwise
  */
-		public function threadMerge($targetId) {
-			$threadIdSource = $this->id;
-
-			$this->contain();
-			$sourceEntry = $this->findById($threadIdSource);
-
-			// check that source is thread and not an entry
-			if ($sourceEntry[$this->alias]['pid'] != 0) {
-				return false;
-			}
-
-			$this->contain();
-			$targetEntry = $this->findById($targetId);
-
-			// check that target exists
-			if (!$targetEntry) {
-				return false;
-			}
-
-			// check that a thread is not merged onto itself
-			if ($targetEntry[$this->alias]['tid'] === $sourceEntry[$this->alias]['tid']) {
-				return false;
-			}
-
-			// set target entry as new parent entry
-			$this->data = [];
-			$this->set('pid', $targetEntry[$this->alias]['id']);
-			if ($this->save()) {
-				// associate all entries in source thread to target thread
-				$this->updateAll(
-					['tid' => $targetEntry[$this->alias]['tid']],
-					['tid' => $this->id]
-				);
-
-				// appended source entries get category of target thread
-				$this->_threadChangeCategory(
-					$targetEntry[$this->alias]['tid'],
-					$targetEntry[$this->alias]['category_id']
-				);
-
-				// update target thread last answer if source is newer
-				$sourceLastAnswer = $this->field('last_answer');
-				if (strtotime($sourceLastAnswer) > strtotime($targetEntry[$this->alias]['last_answer'])) {
-					$this->id = $targetEntry[$this->alias]['tid'];
-					$this->set('last_answer', $sourceLastAnswer);
-					$this->save();
-				}
-
-				// propagate pinned property from target to source
-				$isTargetPinned = (bool)$targetEntry[$this->alias]['locked'];
-				if ($sourceEntry[$this->alias]['locked'] !== $isTargetPinned) {
-					$this->id = $targetEntry[$this->alias]['tid'];
-					$this->_threadLock($isTargetPinned);
-				}
-
-				$this->Esevent->transferSubjectForEventType(
-					$threadIdSource,
-					$targetEntry[$this->alias]['tid'],
-					'thread'
-				);
-				$this->_dispatchEvent(
-					'Model.Thread.change',
-					['subject' => $targetEntry[$this->alias]['tid']]
-				);
-				return true;
-			}
-			return false;
-		}
+        public function threadMerge($targetId) {
+            $threadIdSource = $this->id;
+
+            $this->contain();
+            $sourceEntry = $this->findById($threadIdSource);
+
+            // check that source is thread and not an entry
+            if ($sourceEntry[$this->alias]['pid'] != 0) {
+                return false;
+            }
+
+            $this->contain();
+            $targetEntry = $this->findById($targetId);
+
+            // check that target exists
+            if (!$targetEntry) {
+                return false;
+            }
+
+            // check that a thread is not merged onto itself
+            if ($targetEntry[$this->alias]['tid'] === $sourceEntry[$this->alias]['tid']) {
+                return false;
+            }
+
+            // set target entry as new parent entry
+            $this->data = [];
+            $this->set('pid', $targetEntry[$this->alias]['id']);
+            if ($this->save()) {
+                // associate all entries in source thread to target thread
+                $this->updateAll(
+                    ['tid' => $targetEntry[$this->alias]['tid']],
+                    ['tid' => $this->id]
+                );
+
+                // appended source entries get category of target thread
+                $this->_threadChangeCategory(
+                    $targetEntry[$this->alias]['tid'],
+                    $targetEntry[$this->alias]['category_id']
+                );
+
+                // update target thread last answer if source is newer
+                $sourceLastAnswer = $this->field('last_answer');
+                if (strtotime($sourceLastAnswer) > strtotime($targetEntry[$this->alias]['last_answer'])) {
+                    $this->id = $targetEntry[$this->alias]['tid'];
+                    $this->set('last_answer', $sourceLastAnswer);
+                    $this->save();
+                }
+
+                // propagate pinned property from target to source
+                $isTargetPinned = (bool)$targetEntry[$this->alias]['locked'];
+                if ($sourceEntry[$this->alias]['locked'] !== $isTargetPinned) {
+                    $this->id = $targetEntry[$this->alias]['tid'];
+                    $this->_threadLock($isTargetPinned);
+                }
+
+                $this->Esevent->transferSubjectForEventType(
+                    $threadIdSource,
+                    $targetEntry[$this->alias]['tid'],
+                    'thread'
+                );
+                $this->_dispatchEvent(
+                    'Model.Thread.change',
+                    ['subject' => $targetEntry[$this->alias]['tid']]
+                );
+                return true;
+            }
+            return false;
+        }
 
 /**
  * Test if entry is thread-root
@@ -871,36 +871,36 @@ 
  * @return mixed
  * @throws InvalidArgumentException
  */
-		public function isRoot($id = null) {
-			if ($id === null) {
-				$id = $this->id;
-			}
-
-			$md5 = md5(serialize($id));
-			if (isset($this->_isRoot[$md5]) === false) {
-				// $id was $entry array
-				if (is_array($id) && isset($id[$this->alias]['pid'])) {
-					$entry = $id;
-				} else {
-					if (is_array($id) && isset($id[$this->alias]['id'])) {
-						$id = $id[$this->alias]['id'];
-					} elseif (empty($id)) {
-						throw new InvalidArgumentException();
-					}
-					$entry = $this->find(
-						'first',
-						array(
-							'contain' => false,
-							'conditions' => array(
-								'id' => $id,
-							)
-						)
-					);
-				}
-				$this->_isRoot[$md5] = empty($entry[$this->alias]['pid']);
-			}
-			return $this->_isRoot[$md5];
-		}
+        public function isRoot($id = null) {
+            if ($id === null) {
+                $id = $this->id;
+            }
+
+            $md5 = md5(serialize($id));
+            if (isset($this->_isRoot[$md5]) === false) {
+                // $id was $entry array
+                if (is_array($id) && isset($id[$this->alias]['pid'])) {
+                    $entry = $id;
+                } else {
+                    if (is_array($id) && isset($id[$this->alias]['id'])) {
+                        $id = $id[$this->alias]['id'];
+                    } elseif (empty($id)) {
+                        throw new InvalidArgumentException();
+                    }
+                    $entry = $this->find(
+                        'first',
+                        array(
+                            'contain' => false,
+                            'conditions' => array(
+                                'id' => $id,
+                            )
+                        )
+                    );
+                }
+                $this->_isRoot[$md5] = empty($entry[$this->alias]['pid']);
+            }
+            return $this->_isRoot[$md5];
+        }
 
 /**
  * Preprocesses entry data before saving it
@@ -911,85 +911,85 @@ 
  * @throws InvalidArgumentException
  * @throws ForbiddenException
  */
-		public function prepare(&$data, array $options = []) {
-			$options += [
-				'isRoot' => null
-			];
-
-			if (isset($options['preFilterFields'])) {
-				$org = $data;
-				$this->filterFields($data, $options['preFilterFields']);
-				if (isset($org['Event'])) {
-					$data['Event'] = $org['Event'];
-				}
-			}
-			unset($options['preFilterFields']);
-
-			$isRoot = $options['isRoot'];
-			unset($options['isRoot']);
-
-			if ($isRoot === null) {
-				$isRoot = $this->isRoot($data);
-			}
-			// adds info from parent entry to an answer
-			if ($isRoot === false) {
-				if (!isset($data[$this->alias]['pid'])) {
-					$pid = $this->getParentId($data[$this->alias]['id']);
-				} else {
-					$pid = $data[$this->alias]['pid'];
-				}
-				$parent = $this->get($pid, true);
-				if ($parent === false) {
-					throw new InvalidArgumentException;
-				}
-
-				// @todo highly @bogus should be a validator?
-				$parentPosting = $this->dic->newInstance('\Saito\Posting\Posting', ['rawData' => $parent]);
-				if ($parentPosting->isAnsweringForbidden()) {
-					throw new ForbiddenException;
-				}
-
-				// if new subject is empty use the parent's subject
-				if (empty($data[$this->alias]['subject'])) {
-					$data[$this->alias]['subject'] = $parent[$this->alias]['subject'];
-				}
-
-				$data[$this->alias]['tid'] = $parent[$this->alias]['tid'];
-				$data[$this->alias]['category_id'] = $parent[$this->alias]['category_id'];
-			}
-
-			//= markup preprocessing
-			if (empty($data[$this->alias]['text']) === false) {
-				$data[$this->alias]['text'] = $this->prepareMarkup($data[$this->alias]['text']);
-			}
-		}
-
-		protected function _findEntry($state, $query, $results = []) {
-			if ($state === 'before') {
-				$query['contain'] = ['User', 'Category'];
-				$query['fields'] = array_merge($this->threadLineFieldList, $this->showEntryFieldListAdditional);
-				return $query;
-			}
-			if ($results) {
-				return $results[0];
-			}
-			return $results;
-		}
+        public function prepare(&$data, array $options = []) {
+            $options += [
+                'isRoot' => null
+            ];
+
+            if (isset($options['preFilterFields'])) {
+                $org = $data;
+                $this->filterFields($data, $options['preFilterFields']);
+                if (isset($org['Event'])) {
+                    $data['Event'] = $org['Event'];
+                }
+            }
+            unset($options['preFilterFields']);
+
+            $isRoot = $options['isRoot'];
+            unset($options['isRoot']);
+
+            if ($isRoot === null) {
+                $isRoot = $this->isRoot($data);
+            }
+            // adds info from parent entry to an answer
+            if ($isRoot === false) {
+                if (!isset($data[$this->alias]['pid'])) {
+                    $pid = $this->getParentId($data[$this->alias]['id']);
+                } else {
+                    $pid = $data[$this->alias]['pid'];
+                }
+                $parent = $this->get($pid, true);
+                if ($parent === false) {
+                    throw new InvalidArgumentException;
+                }
+
+                // @todo highly @bogus should be a validator?
+                $parentPosting = $this->dic->newInstance('\Saito\Posting\Posting', ['rawData' => $parent]);
+                if ($parentPosting->isAnsweringForbidden()) {
+                    throw new ForbiddenException;
+                }
+
+                // if new subject is empty use the parent's subject
+                if (empty($data[$this->alias]['subject'])) {
+                    $data[$this->alias]['subject'] = $parent[$this->alias]['subject'];
+                }
+
+                $data[$this->alias]['tid'] = $parent[$this->alias]['tid'];
+                $data[$this->alias]['category_id'] = $parent[$this->alias]['category_id'];
+            }
+
+            //= markup preprocessing
+            if (empty($data[$this->alias]['text']) === false) {
+                $data[$this->alias]['text'] = $this->prepareMarkup($data[$this->alias]['text']);
+            }
+        }
+
+        protected function _findEntry($state, $query, $results = []) {
+            if ($state === 'before') {
+                $query['contain'] = ['User', 'Category'];
+                $query['fields'] = array_merge($this->threadLineFieldList, $this->showEntryFieldListAdditional);
+                return $query;
+            }
+            if ($results) {
+                return $results[0];
+            }
+            return $results;
+        }
 
 /**
  * Implements the custom find type 'feed'
  *
  * Add parameters for generating a rss/json-feed with find('feed', …)
  */
-		protected function _findFeed($state, $query, $results = array()) {
-			if ($state == 'before') {
-				$query['contain'] = array('User');
-				$query['fields'] = $this->_allowedPublicOutputFields;
-				$query['limit'] = 10;
-				return $query;
-			}
-			return $results;
-		}
+        protected function _findFeed($state, $query, $results = array()) {
+            if ($state == 'before') {
+                $query['contain'] = array('User');
+                $query['fields'] = $this->_allowedPublicOutputFields;
+                $query['limit'] = 10;
+                return $query;
+            }
+            return $results;
+        }
 
 /**
  * Locks or unlocks a whole thread
@@ -998,57 +998,57 @@ 
  *
  * @param bool $value
  */
-		protected function _threadLock($value) {
-			$tid = $this->field('tid');
-			$this->contain();
-			// @bogus throws error on $value = false
-			$value = $value ? 1 : 0;
-			$this->updateAll(['locked' => $value], ['tid' => $tid]);
-		}
-
-		public function paginateCount($conditions, $recursive, $extra) {
-			if (isset($extra['getInitialThreads'])) {
-				$this->Category->contain();
-				$categories = $this->Category->find(
-					'all',
-					[
-						'conditions' => array('id' => $conditions['Entry.category_id']),
-						'fields' => array('thread_count')
-					]
-				);
-				$count = array_sum(Set::extract('/Category/thread_count', $categories));
-			} else {
-				$parameters = array('conditions' => $conditions);
-				if ($recursive != $this->recursive) {
-					$parameters['recursive'] = $recursive;
-				}
-				$count = $this->find('count', array_merge($parameters, $extra));
-			}
-			return $count;
-		}
-
-		public function beforeSave($options = array()) {
-			$success = true;
-
-			//# change category of thread if category of root entry changed
-			$modified = !empty($this->id);
-			if (isset($this->data[$this->alias]['category_id']) && $modified) {
-				$oldEntry = $this->find('first',
-					['contain' => false, 'conditions' => ['Entry.id' => $this->id]]);
-
-				if ($oldEntry && (int)$oldEntry[$this->alias]['pid'] === 0) {
-					$categoryChanged = (int)$this->data[$this->alias]['category_id'] !== (int)$oldEntry[$this->alias]['category_id'];
-					if ($categoryChanged) {
-						$success = $success && $this->_threadChangeCategory(
-								$oldEntry[$this->alias]['tid'],
-								$this->data[$this->alias]['category_id']
-							);
-					}
-				}
-			}
-
-			return $success && parent::beforeSave($options);
-		}
+        protected function _threadLock($value) {
+            $tid = $this->field('tid');
+            $this->contain();
+            // @bogus throws error on $value = false
+            $value = $value ? 1 : 0;
+            $this->updateAll(['locked' => $value], ['tid' => $tid]);
+        }
+
+        public function paginateCount($conditions, $recursive, $extra) {
+            if (isset($extra['getInitialThreads'])) {
+                $this->Category->contain();
+                $categories = $this->Category->find(
+                    'all',
+                    [
+                        'conditions' => array('id' => $conditions['Entry.category_id']),
+                        'fields' => array('thread_count')
+                    ]
+                );
+                $count = array_sum(Set::extract('/Category/thread_count', $categories));
+            } else {
+                $parameters = array('conditions' => $conditions);
+                if ($recursive != $this->recursive) {
+                    $parameters['recursive'] = $recursive;
+                }
+                $count = $this->find('count', array_merge($parameters, $extra));
+            }
+            return $count;
+        }
+
+        public function beforeSave($options = array()) {
+            $success = true;
+
+            //# change category of thread if category of root entry changed
+            $modified = !empty($this->id);
+            if (isset($this->data[$this->alias]['category_id']) && $modified) {
+                $oldEntry = $this->find('first',
+                    ['contain' => false, 'conditions' => ['Entry.id' => $this->id]]);
+
+                if ($oldEntry && (int)$oldEntry[$this->alias]['pid'] === 0) {
+                    $categoryChanged = (int)$this->data[$this->alias]['category_id'] !== (int)$oldEntry[$this->alias]['category_id'];
+                    if ($categoryChanged) {
+                        $success = $success && $this->_threadChangeCategory(
+                                $oldEntry[$this->alias]['tid'],
+                                $this->data[$this->alias]['category_id']
+                            );
+                    }
+                }
+            }
+
+            return $success && parent::beforeSave($options);
+        }
 
 /**
  * check that entries are only in existing and allowed categories
@@ -1056,35 +1056,35 @@ 
  * @param $check
  * @return bool
  */
-		public function validateCategoryIsAllowed($check) {
-			$availableCategories = $this->CurrentUser->Categories->getAllowed();
-			if (!isset($availableCategories[$check['category_id']])) {
-				return false;
-			}
-			return true;
-		}
-
-		/**
-		 * @param $check
-		 * @return bool
-		 * @throws Exception
-		 */
-		public function validateEditingAllowed($check) {
-			$id = $this->data[$this->alias]['id'];
-			$entry = $this->get($id);
-			if (empty($entry)) {
-				throw new Exception(sprintf('Entry %s not found.', $entry));
-			}
-
-			$posting = $this->dic->newInstance('\Saito\Posting\Posting', ['rawData' => $entry]);
-			$forbidden = $posting->isEditingAsCurrentUserForbidden();
-
-			if (is_bool($forbidden)) {
-				return !$forbidden;
-			} else {
-				return $forbidden;
-			}
-		}
+        public function validateCategoryIsAllowed($check) {
+            $availableCategories = $this->CurrentUser->Categories->getAllowed();
+            if (!isset($availableCategories[$check['category_id']])) {
+                return false;
+            }
+            return true;
+        }
+
+        /**
+         * @param $check
+         * @return bool
+         * @throws Exception
+         */
+        public function validateEditingAllowed($check) {
+            $id = $this->data[$this->alias]['id'];
+            $entry = $this->get($id);
+            if (empty($entry)) {
+                throw new Exception(sprintf('Entry %s not found.', $entry));
+            }
+
+            $posting = $this->dic->newInstance('\Saito\Posting\Posting', ['rawData' => $entry]);
+            $forbidden = $posting->isEditingAsCurrentUserForbidden();
+
+            if (is_bool($forbidden)) {
+                return !$forbidden;
+            } else {
+                return $forbidden;
+            }
+        }
 
 /**
  *
@@ -1097,9 +1097,9 @@ 
  * @param $check
  * @return bool
  */
-		public function validateSubjectMaxLength($check) {
-			return mb_strlen($check['subject']) <= $this->_setting('subject_maxlength');
-		}
+        public function validateSubjectMaxLength($check) {
+            return mb_strlen($check['subject']) <= $this->_setting('subject_maxlength');
+        }
 
 /**
  * Changes the category of a thread.
@@ -1113,20 +1113,20 @@ 
  * @throws NotFoundException
  * @throws InvalidArgumentException
  */
-		protected function _threadChangeCategory($tid = null, $newCategoryId = null) {
-			if (empty($tid)) {
-				throw new InvalidArgumentException;
-			}
-			$this->Category->contain();
-			$categoryExists = $this->Category->findById($newCategoryId);
-			if (!$categoryExists) {
-				throw new NotFoundException;
-			}
-			$out = $this->updateAll(
-				['Entry.category_id' => $newCategoryId],
-				['Entry.tid' => $tid]
-			);
-			return $out;
-		}
-
-	}
\ No newline at end of file
+        protected function _threadChangeCategory($tid = null, $newCategoryId = null) {
+            if (empty($tid)) {
+                throw new InvalidArgumentException;
+            }
+            $this->Category->contain();
+            $categoryExists = $this->Category->findById($newCategoryId);
+            if (!$categoryExists) {
+                throw new NotFoundException;
+            }
+            $out = $this->updateAll(
+                ['Entry.category_id' => $newCategoryId],
+                ['Entry.tid' => $tid]
+            );
+            return $out;
+        }
+
+    }
\ No newline at end of file

app/Model/Esnotification.php

Indentation +29 added lines, -29 removed lines

@@ -8,43 +8,43 @@
  */
 class Esnotification extends AppModel {
 
-	//The Associations below have been created with all possible keys, those that are not needed can be removed
+    //The Associations below have been created with all possible keys, those that are not needed can be removed
 
 /**
  * belongsTo associations
  *
  * @var array
  */
-	public $belongsTo = array(
-		'User' => array(
-			'className' => 'User',
-			'foreignKey' => 'user_id',
-			'conditions' => '',
-			'fields' => '',
-			'order' => ''
-		),
-		'Esevent' => array(
-			'className' => 'Esevent',
-			'foreignKey' => 'esevent_id',
-			'conditions' => '',
-			'fields' => '',
-			'order' => ''
-		)
-	);
+    public $belongsTo = array(
+        'User' => array(
+            'className' => 'User',
+            'foreignKey' => 'user_id',
+            'conditions' => '',
+            'fields' => '',
+            'order' => ''
+        ),
+        'Esevent' => array(
+            'className' => 'Esevent',
+            'foreignKey' => 'esevent_id',
+            'conditions' => '',
+            'fields' => '',
+            'order' => ''
+        )
+    );
 
-	public function beforeSave($options = array()) {
-		if (empty($this->data[$this->alias]['deactivate'])) {
-			$this->data[$this->alias]['deactivate'] = mt_rand(0, 99999999);
-		}
+    public function beforeSave($options = array()) {
+        if (empty($this->data[$this->alias]['deactivate'])) {
+            $this->data[$this->alias]['deactivate'] = mt_rand(0, 99999999);
+        }
 
-		return parent::beforeSave();
-	}
+        return parent::beforeSave();
+    }
 
-	public function deleteNotificationWithId($id) {
-			return $this->delete($id, false);
-	}
+    public function deleteNotificationWithId($id) {
+            return $this->delete($id, false);
+    }
 
-	public function deleteAllFromUser($userId) {
-		return $this->deleteAll(array('user_id' => $userId), false);
-	}
+    public function deleteAllFromUser($userId) {
+        return $this->deleteAll(array('user_id' => $userId), false);
+    }
 }

app/Model/Behavior/TreeBehavior.php

Indentation +52 added lines, -52 removed lines

@@ -1,35 +1,35 @@ 
 <?php
 
-	class TreeBehavior extends ModelBehavior {
-
-		public function treeGetSubtree(Model $Model, $tree, $_nodeId) {
-			$func = function (&$tree, &$entry, $_nodeId) {
-				if ((int)$entry['Entry']['id'] === (int)$_nodeId) {
-					$tree = array($entry);
-					return 'break';
-				}
-			};
-			Entry::mapTreeElements($tree, $func, $_nodeId);
-			return $tree;
-		}
-
-		public function treeBuild(Model $Model, $threads) {
-			$tree = array();
-			foreach ($threads as $thread) {
-				$id = $thread[$Model->alias]['id'];
-				$pid = $thread[$Model->alias]['pid'];
-				$tree[$id] = isset($tree[$id]) ? $tree[$id] + $thread : $thread;
-				$tree[$pid]['_children'][] = &$tree[$id];
-			}
-
-			// It's possible to do uasort before tree build and  get the same results,
-			// without _sortTreesAfterTime
-			// but then *all* entries have to be sorted whereas now only subthreads with childs
-			// are sorted. So using _sortTreesAfterTime is actually faster in praxis.
-			$_sortedTrees = $this->_sortTreesAfterTime($tree[0]['_children']);
-
-			return $_sortedTrees;
-		}
+    class TreeBehavior extends ModelBehavior {
+
+        public function treeGetSubtree(Model $Model, $tree, $_nodeId) {
+            $func = function (&$tree, &$entry, $_nodeId) {
+                if ((int)$entry['Entry']['id'] === (int)$_nodeId) {
+                    $tree = array($entry);
+                    return 'break';
+                }
+            };
+            Entry::mapTreeElements($tree, $func, $_nodeId);
+            return $tree;
+        }
+
+        public function treeBuild(Model $Model, $threads) {
+            $tree = array();
+            foreach ($threads as $thread) {
+                $id = $thread[$Model->alias]['id'];
+                $pid = $thread[$Model->alias]['pid'];
+                $tree[$id] = isset($tree[$id]) ? $tree[$id] + $thread : $thread;
+                $tree[$pid]['_children'][] = &$tree[$id];
+            }
+
+            // It's possible to do uasort before tree build and  get the same results,
+            // without _sortTreesAfterTime
+            // but then *all* entries have to be sorted whereas now only subthreads with childs
+            // are sorted. So using _sortTreesAfterTime is actually faster in praxis.
+            $_sortedTrees = $this->_sortTreesAfterTime($tree[0]['_children']);
+
+            return $_sortedTrees;
+        }
 
 /**
  * Sort all entries in trees after time
@@ -38,25 +38,25 @@ 
  * @param int $level
  * @return array
  */
-		protected function _sortTreesAfterTime($in, $level = 0) {
-			if ($level > 0) {
-				uasort($in, [$this, '_sort']);
-			}
-
-			foreach ($in as $k => $v) {
-				if (isset($v['_children'])) {
-					$in[$k]['_children'] = $this->_sortTreesAfterTime($v['_children'], $level + 1);
-				}
-			}
-			return $in;
-		}
-
-		protected function _sort($a, $b) {
-			if ($a['Entry']['time'] === $b['Entry']['time']) {
-				return ($a['Entry']['id'] > $b['Entry']['id']) ? 1 : -1;
-			} else {
-				return ($a['Entry']['time'] > $b['Entry']['time']) ? 1 : -1;
-			}
-		}
-
-	}
+        protected function _sortTreesAfterTime($in, $level = 0) {
+            if ($level > 0) {
+                uasort($in, [$this, '_sort']);
+            }
+
+            foreach ($in as $k => $v) {
+                if (isset($v['_children'])) {
+                    $in[$k]['_children'] = $this->_sortTreesAfterTime($v['_children'], $level + 1);
+                }
+            }
+            return $in;
+        }
+
+        protected function _sort($a, $b) {
+            if ($a['Entry']['time'] === $b['Entry']['time']) {
+                return ($a['Entry']['id'] > $b['Entry']['id']) ? 1 : -1;
+            } else {
+                return ($a['Entry']['time'] > $b['Entry']['time']) ? 1 : -1;
+            }
+        }
+
+    }

app/Model/Behavior/MarkupBehavior.php

Indentation +28 added lines, -28 removed lines

@@ -1,35 +1,35 @@
 <?php
 
-	App::uses('ModelBehavior', 'Model');
+    App::uses('ModelBehavior', 'Model');
 
-	class MarkupBehavior extends ModelBehavior {
+    class MarkupBehavior extends ModelBehavior {
 
-		/**
-		 * @var Saito\Markup\Preprocessor
-		 */
-		protected $_Preprocessor;
+        /**
+         * @var Saito\Markup\Preprocessor
+         */
+        protected $_Preprocessor;
 
-		/**
-		 * @param Model $Model
-		 * @param $string
-		 * @return string
-		 */
-		public function prepareMarkup(Model $Model, $string) {
-			if (empty($string)) {
-				return $string;
-			}
-			return $this->_getPreprocessor()->process($string);
-		}
+        /**
+         * @param Model $Model
+         * @param $string
+         * @return string
+         */
+        public function prepareMarkup(Model $Model, $string) {
+            if (empty($string)) {
+                return $string;
+            }
+            return $this->_getPreprocessor()->process($string);
+        }
 
-		protected function _getPreprocessor() {
-			if ($this->_Preprocessor === null) {
-				$settings = Configure::read('Saito.Settings.Parser');
-				$this->_Preprocessor = \Saito\Plugin::getParserClassInstance(
-					'Preprocessor',
-					$settings
-				);
-			}
-			return $this->_Preprocessor;
-		}
+        protected function _getPreprocessor() {
+            if ($this->_Preprocessor === null) {
+                $settings = Configure::read('Saito.Settings.Parser');
+                $this->_Preprocessor = \Saito\Plugin::getParserClassInstance(
+                    'Preprocessor',
+                    $settings
+                );
+            }
+            return $this->_Preprocessor;
+        }
 
-	}
+    }

app/Model/Upload.php

Indentation +23 added lines, -23 removed lines

@@ -7,24 +7,24 @@ 
  */
 class Upload extends AppModel {
 
-	public $name = 'Upload';
+    public $name = 'Upload';
 
-	public $recursive = -1;
+    public $recursive = -1;
 
-	public $actsAs = array('FileUpload.FileUpload');
+    public $actsAs = array('FileUpload.FileUpload');
 
-	public $belongsTo = array('User');
+    public $belongsTo = array('User');
 
-	public function deleteAllFromUser($userId) {
-		return $this->deleteAll(
-			array(
-				'Upload.user_id' => $userId
-			),
-			false,
-			// call beforeDelete FileUploader plugin callback to remove files from disk
-			true
-		);
-	}
+    public function deleteAllFromUser($userId) {
+        return $this->deleteAll(
+            array(
+                'Upload.user_id' => $userId
+            ),
+            false,
+            // call beforeDelete FileUploader plugin callback to remove files from disk
+            true
+        );
+    }
 
 /**
  * Returns the number of uploads a user `user_id` has made
@@ -33,14 +33,14 @@ 
  *
  * @return int
  */
-	public function countUser($userId) {
-		$number = $this->find(
-			'count',
-			array(
-				'conditions' => array('user_id' => $userId)
-			)
-		);
-		return (int)$number;
-	}
+    public function countUser($userId) {
+        $number = $this->find(
+            'count',
+            array(
+                'conditions' => array('user_id' => $userId)
+            )
+        );
+        return (int)$number;
+    }
 
 }
\ No newline at end of file

app/Model/AppModel.php

Indentation +261 added lines, -261 removed lines

@@ -1,291 +1,291 @@
 <?php
 
-	App::uses('Model', 'Model');
-	App::uses('Sanitize', 'Utility');
-	App::uses('CakeEvent', 'Event');
-	App::uses('SaitoEventManager', 'Lib/Saito/Event');
+    App::uses('Model', 'Model');
+    App::uses('Sanitize', 'Utility');
+    App::uses('CakeEvent', 'Event');
+    App::uses('SaitoEventManager', 'Lib/Saito/Event');
 
-	// import here so that `cake schema ...` cli works
-	App::import('Lib', 'Stopwatch.Stopwatch');
+    // import here so that `cake schema ...` cli works
+    App::import('Lib', 'Stopwatch.Stopwatch');
 
-	class AppModel extends Model {
+    class AppModel extends Model {
 
-		/**
-		 * @var array model settings; can be overwritten by DB or config Settings
-		 */
-		protected $_settings = [];
+        /**
+         * @var array model settings; can be overwritten by DB or config Settings
+         */
+        protected $_settings = [];
 
-		/**
-		 * @var array predefined fields for filterFields()
-		 */
-		public $allowedInputFields = [];
+        /**
+         * @var array predefined fields for filterFields()
+         */
+        public $allowedInputFields = [];
 
-		# Entry->User->UserOnline
-		public $recursive = 1;
+        # Entry->User->UserOnline
+        public $recursive = 1;
 
-		public $SharedObjects;
+        public $SharedObjects;
 
-		/** * @var SaitoEventManager */
-		protected $_SEM;
+        /** * @var SaitoEventManager */
+        protected $_SEM;
 
-		public function __construct($id = false, $table = null, $ds = null) {
-			parent::__construct($id, $table, $ds);
-			$this->_dispatchEvent('Event.Saito.Model.initialize');
-		}
+        public function __construct($id = false, $table = null, $ds = null) {
+            parent::__construct($id, $table, $ds);
+            $this->_dispatchEvent('Event.Saito.Model.initialize');
+        }
 
-		public function __get($name) {
-			switch ($name) {
-				case 'dic':
-					return ClassRegistry::getObject('dic');
-				default:
-					if (isset($this->SharedObjects[$name])) {
-						return $this->SharedObjects[$name];
-					}
-			}
-			return parent::__get($name);
-		}
+        public function __get($name) {
+            switch ($name) {
+                case 'dic':
+                    return ClassRegistry::getObject('dic');
+                default:
+                    if (isset($this->SharedObjects[$name])) {
+                        return $this->SharedObjects[$name];
+                    }
+            }
+            return parent::__get($name);
+        }
 
-		public function toggle($key) {
-			$this->contain();
-			$value = $this->read($key);
-			$value = ($value[$this->alias][$key] == 0) ? 1 : 0;
-			$this->set($key, $value);
-			$this->save();
-			return $value;
-		}
+        public function toggle($key) {
+            $this->contain();
+            $value = $this->read($key);
+            $value = ($value[$this->alias][$key] == 0) ? 1 : 0;
+            $this->set($key, $value);
+            $this->save();
+            return $value;
+        }
 
-		/**
-		 * filters out all fields $fields in $data
-		 *
-		 * works only on current model, not associations
-		 *
-		 * @param $data
-		 * @param $fields
-		 */
-		public function filterFields(&$data, $fields) {
-			if (is_string($fields) && isset($this->allowedInputFields[$fields])) {
-				$fields = $this->allowedInputFields[$fields];
-			}
-			$fields = array_flip($fields);
-			$data = [
-				$this->alias => array_intersect_key($data[$this->alias], $fields)
-			];
-		}
+        /**
+         * filters out all fields $fields in $data
+         *
+         * works only on current model, not associations
+         *
+         * @param $data
+         * @param $fields
+         */
+        public function filterFields(&$data, $fields) {
+            if (is_string($fields) && isset($this->allowedInputFields[$fields])) {
+                $fields = $this->allowedInputFields[$fields];
+            }
+            $fields = array_flip($fields);
+            $data = [
+                $this->alias => array_intersect_key($data[$this->alias], $fields)
+            ];
+        }
 
-		public function requireFields(&$data, array $required) {
-			return $this->_mapFields($data, $required,
-				function (&$data, $model, $field) {
-					if (!isset($data[$model][$field])) {
-						return false;
-					}
-					return true;
-				});
-		}
+        public function requireFields(&$data, array $required) {
+            return $this->_mapFields($data, $required,
+                function (&$data, $model, $field) {
+                    if (!isset($data[$model][$field])) {
+                        return false;
+                    }
+                    return true;
+                });
+        }
 
-		public function unsetFields(&$data, array $unset = ['id']) {
-			return $this->_mapFields($data, $unset,
-				function (&$data, $model, $field) {
-					if (isset($data[$model][$field])) {
-						unset($data[$model][$field]);
-					}
-					return true;
-				});
-		}
+        public function unsetFields(&$data, array $unset = ['id']) {
+            return $this->_mapFields($data, $unset,
+                function (&$data, $model, $field) {
+                    if (isset($data[$model][$field])) {
+                        unset($data[$model][$field]);
+                    }
+                    return true;
+                });
+        }
 
-		protected function _mapFields(&$data, $fields, callable $func) {
-			if (isset(reset($data)[$this->alias])) {
-				foreach ($data as &$d) {
-					if (!$this->_mapFields($d, $fields, $func)) {
-						return false;
-					}
-				}
-				return true;
-			}
+        protected function _mapFields(&$data, $fields, callable $func) {
+            if (isset(reset($data)[$this->alias])) {
+                foreach ($data as &$d) {
+                    if (!$this->_mapFields($d, $fields, $func)) {
+                        return false;
+                    }
+                }
+                return true;
+            }
 
-			if (!isset($data[$this->alias])) {
-				$data = [$this->alias => $data];
-			}
-			foreach ($fields as $field) {
-				if (strpos($field, '.') !== false) {
-					list($model, $field) = explode('.', $field, 2);
-				} else {
-					$model = $this->alias;
-				}
-				if ($model !== $this->alias) {
-					continue;
-				}
-				if (!$func($data, $model, $field)) {
-					return false;
-				}
-			}
-			return true;
-		}
+            if (!isset($data[$this->alias])) {
+                $data = [$this->alias => $data];
+            }
+            foreach ($fields as $field) {
+                if (strpos($field, '.') !== false) {
+                    list($model, $field) = explode('.', $field, 2);
+                } else {
+                    $model = $this->alias;
+                }
+                if ($model !== $this->alias) {
+                    continue;
+                }
+                if (!$func($data, $model, $field)) {
+                    return false;
+                }
+            }
+            return true;
+        }
 
-		/**
-		 * Increments value of a field
-		 *
-		 * @param $id
-		 * @param $field
-		 * @param int $amount
-		 * @throws InvalidArgumentException
-		 */
-		public function increment($id, $field, $amount = 1) {
-			if (!is_int($amount)) {
-				throw new InvalidArgumentException;
-			}
-			$operator = '+';
-			if ($amount < 0) {
-				$operator = '-';
-				$amount *= -1;
-			}
-			$field = $this->alias . '.' . $field;
-			$this->updateAll([$field => "$field $operator $amount"],
-				[$this->alias . '.id' => $id]);
-		}
+        /**
+         * Increments value of a field
+         *
+         * @param $id
+         * @param $field
+         * @param int $amount
+         * @throws InvalidArgumentException
+         */
+        public function increment($id, $field, $amount = 1) {
+            if (!is_int($amount)) {
+                throw new InvalidArgumentException;
+            }
+            $operator = '+';
+            if ($amount < 0) {
+                $operator = '-';
+                $amount *= -1;
+            }
+            $field = $this->alias . '.' . $field;
+            $this->updateAll([$field => "$field $operator $amount"],
+                [$this->alias . '.id' => $id]);
+        }
 
-		public function pipeMerger(array $data) {
-			$out = [];
-			foreach ($data as $key => $value) {
-				$out[] = "$key=$value";
-			}
-			return implode(' | ', $out);
-		}
+        public function pipeMerger(array $data) {
+            $out = [];
+            foreach ($data as $key => $value) {
+                $out[] = "$key=$value";
+            }
+            return implode(' | ', $out);
+        }
 
-		/**
-		 * Splits String 'a=b|c=d|e=f' into an array('a'=>'b', 'c'=>'d', 'e'=>'f')
-		 *
-		 * @param string $pipeString
-		 * @return array
-		 */
-		protected function _pipeSplitter($pipeString) {
-			$unpipedArray = array();
-			$ranks = explode('|', $pipeString);
-			foreach ($ranks as $rank) :
-				$matches = array();
-				$matched = preg_match('/(\w+)\s*=\s*(.*)/', trim($rank), $matches);
-				if ($matched) {
-					$unpipedArray[$matches[1]] = $matches[2];
-				}
-			endforeach;
-			return $unpipedArray;
-		}
+        /**
+         * Splits String 'a=b|c=d|e=f' into an array('a'=>'b', 'c'=>'d', 'e'=>'f')
+         *
+         * @param string $pipeString
+         * @return array
+         */
+        protected function _pipeSplitter($pipeString) {
+            $unpipedArray = array();
+            $ranks = explode('|', $pipeString);
+            foreach ($ranks as $rank) :
+                $matches = array();
+                $matched = preg_match('/(\w+)\s*=\s*(.*)/', trim($rank), $matches);
+                if ($matched) {
+                    $unpipedArray[$matches[1]] = $matches[2];
+                }
+            endforeach;
+            return $unpipedArray;
+        }
 
-		protected static function _getIp() {
-			$ip = null;
-			if (Configure::read('Saito.Settings.store_ip')):
-				$ip = env('REMOTE_ADDR');
-				if (Configure::read('Saito.Settings.store_ip_anonymized')):
-					$ip = self::_anonymizeIp($ip);
-				endif;
-			endif;
-			return $ip;
-		}
+        protected static function _getIp() {
+            $ip = null;
+            if (Configure::read('Saito.Settings.store_ip')):
+                $ip = env('REMOTE_ADDR');
+                if (Configure::read('Saito.Settings.store_ip_anonymized')):
+                    $ip = self::_anonymizeIp($ip);
+                endif;
+            endif;
+            return $ip;
+        }
 
-		/**
-		 * Dispatches an event
-		 *
-		 * - Always passes the issuing model class as subject
-		 * - Wrapper for CakeEvent boilerplate code
-		 * - Easier to test
-		 *
-		 * @param string $event event identifier `Model.<modelname>.<event>`
-		 * @param array $data additional event data
-		 */
-		protected function _dispatchEvent($event, $data = []) {
-			$this->getEventManager()->dispatch(new CakeEvent($event, $this, $data));
-			// propagate event on Saito's event bus
-			$this->dispatchSaitoEvent($event, $data);
-		}
+        /**
+         * Dispatches an event
+         *
+         * - Always passes the issuing model class as subject
+         * - Wrapper for CakeEvent boilerplate code
+         * - Easier to test
+         *
+         * @param string $event event identifier `Model.<modelname>.<event>`
+         * @param array $data additional event data
+         */
+        protected function _dispatchEvent($event, $data = []) {
+            $this->getEventManager()->dispatch(new CakeEvent($event, $this, $data));
+            // propagate event on Saito's event bus
+            $this->dispatchSaitoEvent($event, $data);
+        }
 
-		public function dispatchSaitoEvent($event, $data) {
-			if (!$this->_SEM) {
-				$this->_SEM = SaitoEventManager::getInstance();
-			}
-			$this->_SEM->dispatch($event, $data + ['Model' => $this]);
-		}
+        public function dispatchSaitoEvent($event, $data) {
+            if (!$this->_SEM) {
+                $this->_SEM = SaitoEventManager::getInstance();
+            }
+            $this->_SEM->dispatch($event, $data + ['Model' => $this]);
+        }
 
-		/**
-		 * Rough and tough ip anonymizer
-		 *
-		 * @param string $ip
-		 * @return string
-		 */
-		protected static function _anonymizeIp($ip) {
-			$strlen = strlen($ip);
-			if ($strlen > 6) :
-				$divider = (int)floor($strlen / 4) + 1;
-				$ip = substr_replace($ip, '…', $divider, $strlen - (2 * $divider));
-			endif;
+        /**
+         * Rough and tough ip anonymizer
+         *
+         * @param string $ip
+         * @return string
+         */
+        protected static function _anonymizeIp($ip) {
+            $strlen = strlen($ip);
+            if ($strlen > 6) :
+                $divider = (int)floor($strlen / 4) + 1;
+                $ip = substr_replace($ip, '…', $divider, $strlen - (2 * $divider));
+            endif;
 
-			return $ip;
-		}
+            return $ip;
+        }
 
-		/**
-		 * gets app setting
-		 *
-		 * falls back to local definition if available
-		 *
-		 * @param $name
-		 * @return mixed
-		 * @throws UnexpectedValueException
-		 */
-		protected function _setting($name) {
-			$setting = Configure::read('Saito.Settings.' . $name);
-			if ($setting !== null) {
-				return $setting;
-			}
-			if (isset($this->_settings[$name])) {
-				return $this->_settings[$name];
-			}
-			throw new UnexpectedValueException;
-		}
+        /**
+         * gets app setting
+         *
+         * falls back to local definition if available
+         *
+         * @param $name
+         * @return mixed
+         * @throws UnexpectedValueException
+         */
+        protected function _setting($name) {
+            $setting = Configure::read('Saito.Settings.' . $name);
+            if ($setting !== null) {
+                return $setting;
+            }
+            if (isset($this->_settings[$name])) {
+                return $this->_settings[$name];
+            }
+            throw new UnexpectedValueException;
+        }
 
-		public function isUniqueCiString($fields) {
-			// lazy: only one field
-			if (!is_array($fields) || count($fields) > 1) {
-				throw InvalidArgumentException();
-			}
-			$key = key($fields);
-			$fields = [
-				"LOWER({$this->alias}.{$key})" => mb_strtolower(current($fields))
-			];
-			return $this->isUnique($fields);
-		}
+        public function isUniqueCiString($fields) {
+            // lazy: only one field
+            if (!is_array($fields) || count($fields) > 1) {
+                throw InvalidArgumentException();
+            }
+            $key = key($fields);
+            $fields = [
+                "LOWER({$this->alias}.{$key})" => mb_strtolower(current($fields))
+            ];
+            return $this->isUnique($fields);
+        }
 
-		/**
-		 * Inclusive Validation::range()
-		 *
-		 * @param array $check
-		 * @param float $lower
-		 * @param float $upper
-		 * @return bool
-		 * @see https://github.com/cakephp/cakephp/issues/3304
-		 */
-		public function inRange($check, $lower = null, $upper = null) {
-			$check = reset($check);
-			if (!is_numeric($check)) {
-				return false;
-			}
-			if (isset($lower) && isset($upper)) {
-				return ($check >= $lower && $check <= $upper);
-			}
-			// fallback to 'parent'
-			return Validation::range($check, $lower, $upper);
-		}
+        /**
+         * Inclusive Validation::range()
+         *
+         * @param array $check
+         * @param float $lower
+         * @param float $upper
+         * @return bool
+         * @see https://github.com/cakephp/cakephp/issues/3304
+         */
+        public function inRange($check, $lower = null, $upper = null) {
+            $check = reset($check);
+            if (!is_numeric($check)) {
+                return false;
+            }
+            if (isset($lower) && isset($upper)) {
+                return ($check >= $lower && $check <= $upper);
+            }
+            // fallback to 'parent'
+            return Validation::range($check, $lower, $upper);
+        }
 
-		/**
-		 * Logs current SQL log
-		 *
-		 * Set debug to 2 to enable SQL logging!
-		 */
-		public function logSql() {
-			if (Configure::read('debug') < 2) {
-				trigger_error('You must set debug level to at least 2 to enable SQL-logging',
-					E_USER_NOTICE);
-			}
-			$dbo = $this->getDatasource();
-			$logs = $dbo->getLog();
-			$this->log($logs['log']);
-		}
+        /**
+         * Logs current SQL log
+         *
+         * Set debug to 2 to enable SQL logging!
+         */
+        public function logSql() {
+            if (Configure::read('debug') < 2) {
+                trigger_error('You must set debug level to at least 2 to enable SQL-logging',
+                    E_USER_NOTICE);
+            }
+            $dbo = $this->getDatasource();
+            $logs = $dbo->getLog();
+            $this->log($logs['log']);
+        }
 
-	}
+    }

app/Model/UserOnline.php

Indentation +96 added lines, -96 removed lines

@@ -3,35 +3,35 @@ 
 /**
  *  Class UserOnline
  */
-	class UserOnline extends AppModel {
+    class UserOnline extends AppModel {
 
-		public $name = 'UserOnline';
+        public $name = 'UserOnline';
 
-		public $useTable = 'useronline';
+        public $useTable = 'useronline';
 
-		public $actsAs = ['Containable'];
+        public $actsAs = ['Containable'];
 
-		public $belongsTo = [
-			'User' => [
-				'className' => 'User',
-				'foreignKey' => 'user_id'
-			]
-		];
+        public $belongsTo = [
+            'User' => [
+                'className' => 'User',
+                'foreignKey' => 'user_id'
+            ]
+        ];
 
-		public $validate = [
-			'uuid' => [
-				'rule' => 'isUnique',
-				'required' => true,
-				'allowEmpty' => false
-			]
-		];
+        public $validate = [
+            'uuid' => [
+                'rule' => 'isUnique',
+                'required' => true,
+                'allowEmpty' => false
+            ]
+        ];
 
 /**
  * Time in seconds until a user is considered offline
  *
  * @var int
  */
-		public $timeUntilOffline = 1200;
+        public $timeUntilOffline = 1200;
 
 /**
  * Sets user with `$id` online
@@ -40,72 +40,72 @@ 
  * @param boolean $loggedIn user is logged-in
  * @throws InvalidArgumentException
  */
-		public function setOnline($id, $loggedIn) {
-			if (empty($id)) {
-				throw new InvalidArgumentException('Invalid Argument $id in setOnline()');
-			}
-			if (!is_bool($loggedIn)) {
-				throw new InvalidArgumentException('Invalid Argument $logged_in in setOnline()');
-			}
-			$now = time();
-
-			$id = $this->_getShortendedId($id);
-			$data = [
-				'UserOnline' => [
-					'uuid' => $id,
-					'logged_in' => $loggedIn,
-					'time' => $now
-				]
-			];
-
-			if ($loggedIn) {
-				$data['UserOnline']['user_id'] = $id;
-			}
-
-			$user = $this->find('first', ['conditions' => ['uuid' => $id],
-				'recursive' => -1, 'callbacks' => false]);
-
-			if ($user) {
-				// only hit database if timestamp is outdated
-				if ($user['UserOnline']['time'] < ($now - $this->timeUntilOffline)) {
-					$this->id = $user['UserOnline']['id'];
-					$this->save($data);
-				}
-			} else {
-				$this->id = null;
-				$this->create();
-				$this->save($data);
-			}
-
-			$this->_deleteOutdated();
-		}
-
-		/**
-		 * Removes user with uuid `$id` from UserOnline
-		 *
-		 * @param $id
-		 *
-		 * @return bool
-		 */
-		public function setOffline($id) {
-			$id = $this->_getShortendedId($id);
-			return $this->deleteAll(['UserOnline.uuid' => $id], false);
-		}
-
-		public function getLoggedIn() {
-			Stopwatch::start('UserOnline->getLoggedIn()');
-			$loggedInUsers = $this->find(
-				'all',
-				[
-					'contain' => 'User',
-					'conditions' => ['UserOnline.logged_in' => true],
-					'fields' => ['User.id', 'User.username', 'User.user_type'],
-					'order' => ['LOWER(User.username)' => 'ASC']
-				]
-			);
-			Stopwatch::stop('UserOnline->getLoggedIn()');
-			return $loggedInUsers;
-		}
+        public function setOnline($id, $loggedIn) {
+            if (empty($id)) {
+                throw new InvalidArgumentException('Invalid Argument $id in setOnline()');
+            }
+            if (!is_bool($loggedIn)) {
+                throw new InvalidArgumentException('Invalid Argument $logged_in in setOnline()');
+            }
+            $now = time();
+
+            $id = $this->_getShortendedId($id);
+            $data = [
+                'UserOnline' => [
+                    'uuid' => $id,
+                    'logged_in' => $loggedIn,
+                    'time' => $now
+                ]
+            ];
+
+            if ($loggedIn) {
+                $data['UserOnline']['user_id'] = $id;
+            }
+
+            $user = $this->find('first', ['conditions' => ['uuid' => $id],
+                'recursive' => -1, 'callbacks' => false]);
+
+            if ($user) {
+                // only hit database if timestamp is outdated
+                if ($user['UserOnline']['time'] < ($now - $this->timeUntilOffline)) {
+                    $this->id = $user['UserOnline']['id'];
+                    $this->save($data);
+                }
+            } else {
+                $this->id = null;
+                $this->create();
+                $this->save($data);
+            }
+
+            $this->_deleteOutdated();
+        }
+
+        /**
+         * Removes user with uuid `$id` from UserOnline
+         *
+         * @param $id
+         *
+         * @return bool
+         */
+        public function setOffline($id) {
+            $id = $this->_getShortendedId($id);
+            return $this->deleteAll(['UserOnline.uuid' => $id], false);
+        }
+
+        public function getLoggedIn() {
+            Stopwatch::start('UserOnline->getLoggedIn()');
+            $loggedInUsers = $this->find(
+                'all',
+                [
+                    'contain' => 'User',
+                    'conditions' => ['UserOnline.logged_in' => true],
+                    'fields' => ['User.id', 'User.username', 'User.user_type'],
+                    'order' => ['LOWER(User.username)' => 'ASC']
+                ]
+            );
+            Stopwatch::stop('UserOnline->getLoggedIn()');
+            return $loggedInUsers;
+        }
 
 /**
  * deletes gone user
@@ -114,15 +114,15 @@ 
  *
  * @param string $timeDiff in minutes
  */
-		protected function _deleteOutdated($timeDiff = null) {
-			if ($timeDiff === null) {
-				$timeDiff = $this->timeUntilOffline;
-			}
-			$this->deleteAll(['time <' => time() - ($timeDiff)], false);
-		}
-
-		protected function _getShortendedId($id) {
-			return substr($id, 0, 32);
-		}
-
-	}
\ No newline at end of file
+        protected function _deleteOutdated($timeDiff = null) {
+            if ($timeDiff === null) {
+                $timeDiff = $this->timeUntilOffline;
+            }
+            $this->deleteAll(['time <' => time() - ($timeDiff)], false);
+        }
+
+        protected function _getShortendedId($id) {
+            return substr($id, 0, 32);
+        }
+
+    }
\ No newline at end of file

app/Model/Smiley.php

Indentation +64 added lines, -64 removed lines

@@ -1,79 +1,79 @@
 <?php
 
-	App::uses('AppSettingModel', 'Lib/Model');
+    App::uses('AppSettingModel', 'Lib/Model');
 
-	class Smiley extends AppSettingModel {
+    class Smiley extends AppSettingModel {
 
-		public $name = 'Smiley';
+        public $name = 'Smiley';
 
-		public $validate = [
-			'sort' => [
-				'numeric' => [
-					'rule' => ['numeric']
-				]
-			]
-		];
+        public $validate = [
+            'sort' => [
+                'numeric' => [
+                    'rule' => ['numeric']
+                ]
+            ]
+        ];
 
-		public $hasMany = [
-			'SmileyCode' => [
-				'className' => 'SmileyCode',
-				'foreignKey' => 'smiley_id'
-			]
-		];
+        public $hasMany = [
+            'SmileyCode' => [
+                'className' => 'SmileyCode',
+                'foreignKey' => 'smiley_id'
+            ]
+        ];
 
-		protected $_smilies;
+        protected $_smilies;
 
-		public function load($force = false) {
-			if ($force) {
-				$this->_smilies = null;
-				$this->clearCache();
-			}
+        public function load($force = false) {
+            if ($force) {
+                $this->_smilies = null;
+                $this->clearCache();
+            }
 
-			if ($this->_smilies !== null) {
-				return $this->_smilies;
-			}
+            if ($this->_smilies !== null) {
+                return $this->_smilies;
+            }
 
-			$this->_smilies = [];
-			$smiliesRaw = $this->find('all', ['order' => 'Smiley.sort ASC']);
+            $this->_smilies = [];
+            $smiliesRaw = $this->find('all', ['order' => 'Smiley.sort ASC']);
 
-			foreach ($smiliesRaw as $smileyRaw) {
-				// 'image' defaults to 'icon'
-				if (empty($smileyRaw['Smiley']['image'])) {
-					$smileyRaw['Smiley']['image'] = $smileyRaw['Smiley']['icon'];
-				}
-				// @bogus: if title is unknown it should be a problem
-				if ($smileyRaw['Smiley']['title'] === null) {
-					$smileyRaw['Smiley']['title'] = '';
-				}
-				// set type
-				$smileyRaw['Smiley']['type'] = $this->_getType($smileyRaw['Smiley']);
+            foreach ($smiliesRaw as $smileyRaw) {
+                // 'image' defaults to 'icon'
+                if (empty($smileyRaw['Smiley']['image'])) {
+                    $smileyRaw['Smiley']['image'] = $smileyRaw['Smiley']['icon'];
+                }
+                // @bogus: if title is unknown it should be a problem
+                if ($smileyRaw['Smiley']['title'] === null) {
+                    $smileyRaw['Smiley']['title'] = '';
+                }
+                // set type
+                $smileyRaw['Smiley']['type'] = $this->_getType($smileyRaw['Smiley']);
 
-				//= adds smiley-data to every smiley-code
-				if (isset($smileyRaw['SmileyCode'])) {
-					foreach ($smileyRaw['SmileyCode'] as $smileyRawCode) {
-						unset($smileyRaw['Smiley']['id']);
-						$smileyRaw['Smiley']['code'] = $smileyRawCode['code'];
-						$this->_smilies[] = $smileyRaw['Smiley'];
-					}
-				}
-			}
+                //= adds smiley-data to every smiley-code
+                if (isset($smileyRaw['SmileyCode'])) {
+                    foreach ($smileyRaw['SmileyCode'] as $smileyRawCode) {
+                        unset($smileyRaw['Smiley']['id']);
+                        $smileyRaw['Smiley']['code'] = $smileyRawCode['code'];
+                        $this->_smilies[] = $smileyRaw['Smiley'];
+                    }
+                }
+            }
 
-			Stopwatch::stop('Smiley::load');
-			return $this->_smilies;
-		}
+            Stopwatch::stop('Smiley::load');
+            return $this->_smilies;
+        }
 
-		/**
-		 * detects smiley type
-		 *
-		 * @param array $smiley
-		 * @return string image|font
-		 */
-		protected function _getType($smiley) {
-			if (preg_match('/^.*\.[\w]{3,4}$/i', $smiley['image'])) {
-				return 'image';
-			} else {
-				return 'font';
-			}
-		}
+        /**
+         * detects smiley type
+         *
+         * @param array $smiley
+         * @return string image|font
+         */
+        protected function _getType($smiley) {
+            if (preg_match('/^.*\.[\w]{3,4}$/i', $smiley['image'])) {
+                return 'image';
+            } else {
+                return 'font';
+            }
+        }
 
-	}
+    }

app/Model/UserBlock.php

Indentation +131 added lines, -131 removed lines

@@ -1,147 +1,147 @@
 <?php
 
-	App::uses('AppModel', 'Model');
-	App::import('Lib', 'UserBlocker');
+    App::uses('AppModel', 'Model');
+    App::import('Lib', 'UserBlocker');
 
-	/**
-	 * UserBlock Model
-	 *
-	 * states
-	 */
-	class UserBlock extends AppModel {
+    /**
+     * UserBlock Model
+     *
+     * states
+     */
+    class UserBlock extends AppModel {
 
-		public $actsAs = [
-			'Containable'
-		];
+        public $actsAs = [
+            'Containable'
+        ];
 
-		public $belongsTo = [
-			'User' => [
-				'className' => 'User',
-				'fields' => ['id', 'username'],
-				'foreignKey' => 'user_id'
-			],
-			'By' => [
-				'className' => 'User',
-				'fields' => ['id', 'username'],
-				'foreignKey' => 'blocked_by_user_id'
-			]
-		];
+        public $belongsTo = [
+            'User' => [
+                'className' => 'User',
+                'fields' => ['id', 'username'],
+                'foreignKey' => 'user_id'
+            ],
+            'By' => [
+                'className' => 'User',
+                'fields' => ['id', 'username'],
+                'foreignKey' => 'blocked_by_user_id'
+            ]
+        ];
 
-		public $findMethods = [
-			'toGc' => true
-		];
+        public $findMethods = [
+            'toGc' => true
+        ];
 
-		public $validate = [
-			'ends' => [
-				'rule' => ['datetime'],
-				'allowEmpty' => true
-			]
-		];
+        public $validate = [
+            'ends' => [
+                'rule' => ['datetime'],
+                'allowEmpty' => true
+            ]
+        ];
 
-		public function block($Blocker, $userId, $options) {
-			$Blocker->setUserBlockModel($this);
-			$success = $Blocker->block($userId, $options);
-			if ($success) {
-				$this->_updateIsBlocked($userId);
-			}
-			return $success;
-		}
+        public function block($Blocker, $userId, $options) {
+            $Blocker->setUserBlockModel($this);
+            $success = $Blocker->block($userId, $options);
+            if ($success) {
+                $this->_updateIsBlocked($userId);
+            }
+            return $success;
+        }
 
-		public function getBlockEndsForUser($userId) {
-			$block = $this->find('first', [
-				'contain' => false,
-				'conditions' => ['user_id' => $userId, 'ended' => null],
-				'order' => ['ends' => 'asc']
-			]);
-			return $block['UserBlock']['ends'];
-		}
+        public function getBlockEndsForUser($userId) {
+            $block = $this->find('first', [
+                'contain' => false,
+                'conditions' => ['user_id' => $userId, 'ended' => null],
+                'order' => ['ends' => 'asc']
+            ]);
+            return $block['UserBlock']['ends'];
+        }
 
-		/**
-		 * @param $id
-		 * @return bool true if unblocking was successful, false otherwise
-		 * @throws RuntimeException
-		 * @throws InvalidArgumentException
-		 */
-		public function unblock($id) {
-			$block = $this->find('first', [
-				'contain' => false,
-				'conditions' => ['id' => $id, 'ended' => null]
-			]);
-			if (empty($block)) {
-				throw new InvalidArgumentException(
-					"No active block with id $id found.",
-					1420485052
-				);
-			}
-			$success = (bool)$this->save([
-				'id' => $id,
-				'ended' => bDate(),
-				'ends' => null
-			]);
-			if (!$success) {
-				throw new RuntimeException;
-			}
-			$this->_updateIsBlocked($block[$this->alias]['user_id']);
-			return $success;
-		}
+        /**
+         * @param $id
+         * @return bool true if unblocking was successful, false otherwise
+         * @throws RuntimeException
+         * @throws InvalidArgumentException
+         */
+        public function unblock($id) {
+            $block = $this->find('first', [
+                'contain' => false,
+                'conditions' => ['id' => $id, 'ended' => null]
+            ]);
+            if (empty($block)) {
+                throw new InvalidArgumentException(
+                    "No active block with id $id found.",
+                    1420485052
+                );
+            }
+            $success = (bool)$this->save([
+                'id' => $id,
+                'ended' => bDate(),
+                'ends' => null
+            ]);
+            if (!$success) {
+                throw new RuntimeException;
+            }
+            $this->_updateIsBlocked($block[$this->alias]['user_id']);
+            return $success;
+        }
 
-		/**
-		 * Garbage collection
-		 *
-		 * called hourly from User model
-		 */
-		public function gc() {
-			$expired = $this->find('toGc');
-			foreach ($expired as $block) {
-				$this->unblock($block[$this->alias]['id']);
-			}
-		}
+        /**
+         * Garbage collection
+         *
+         * called hourly from User model
+         */
+        public function gc() {
+            $expired = $this->find('toGc');
+            foreach ($expired as $block) {
+                $this->unblock($block[$this->alias]['id']);
+            }
+        }
 
-		public function getAll() {
-			$blocklist = $this->find('all', [
-				'contain' => ['By', 'User'],
-				'order' => ['UserBlock.id' => 'DESC']
-			]);
-			$o = [];
-			foreach ($blocklist as $k => $b) {
-				$o[$k] = $b['UserBlock'];
-				$o[$k]['By'] = $b['By'];
-				$o[$k]['User'] = $b['User'];
-			}
-			return $o;
-		}
+        public function getAll() {
+            $blocklist = $this->find('all', [
+                'contain' => ['By', 'User'],
+                'order' => ['UserBlock.id' => 'DESC']
+            ]);
+            $o = [];
+            foreach ($blocklist as $k => $b) {
+                $o[$k] = $b['UserBlock'];
+                $o[$k]['By'] = $b['By'];
+                $o[$k]['User'] = $b['User'];
+            }
+            return $o;
+        }
 
-		public function getAllActive() {
-			$blocklist = $this->find('all', [
-				'contain' => false,
-				'conditions' => ['ended' => null],
-				'order' => ['UserBlock.id' => 'DESC']
-			]);
-			return $blocklist;
-		}
+        public function getAllActive() {
+            $blocklist = $this->find('all', [
+                'contain' => false,
+                'conditions' => ['ended' => null],
+                'order' => ['UserBlock.id' => 'DESC']
+            ]);
+            return $blocklist;
+        }
 
-		protected function _findToGc($state, $query, $results = array()) {
-			if ($state === 'before') {
-				$query['contain'] = false;
-				$query['conditions'] = [
-					'ends !=' => null,
-					'ends <' => bDate(),
-					'ended' => null
-				];
-				return $query;
-			}
-			return $results;
-		}
+        protected function _findToGc($state, $query, $results = array()) {
+            if ($state === 'before') {
+                $query['contain'] = false;
+                $query['conditions'] = [
+                    'ends !=' => null,
+                    'ends <' => bDate(),
+                    'ended' => null
+                ];
+                return $query;
+            }
+            return $results;
+        }
 
-		protected function _updateIsBlocked($userId) {
-			$blocks = $this->find('first', [
-				'contain' => false,
-				'conditions' => [
-					'ended' => null,
-					'user_id' => $userId
-				]
-			]);
-			$this->User->save(['id' => $userId, 'user_lock' => !empty($blocks)]);
-		}
+        protected function _updateIsBlocked($userId) {
+            $blocks = $this->find('first', [
+                'contain' => false,
+                'conditions' => [
+                    'ended' => null,
+                    'user_id' => $userId
+                ]
+            ]);
+            $this->User->save(['id' => $userId, 'user_lock' => !empty($blocks)]);
+        }
 
-	}
+    }