Elgg / Elgg

engine/classes/ElggMemcache.php

Doc Comments +1 added lines, -1 removed lines

@@ -113,7 +113,7 @@
 	 * @param int    $unused1 Unused
 	 * @param int    $unused2 Unused
 	 *
-	 * @return mixed
+	 * @return ElggEntity
 	 */
 	public function load($key, $unused1 = 0, $unused2 = null) {
 		$key = $this->makeMemcacheKey($key);

Indentation +165 added lines, -165 removed lines

@@ -5,172 +5,172 @@
  */
 class ElggMemcache extends \ElggSharedMemoryCache {
 
-	/**
-	 * TTL of saved items (default timeout after a day to prevent anything getting too stale)
-	 */
-	private $ttl = 86400;
-
-	/**
-	 * @var \Stash\Pool
-	 */
-	private $stash_pool;
-
-	/**
-	 * Constructor
-	 *
-	 * @param string      $namespace The namespace for this cache to write to
-	 * @param \Stash\Pool $pool      The cache pool to use. Default is memcache.
-	 * @param int         $ttl       The TTL in seconds. Default is from $CONFIG->memcache_expires.
-	 *
-	 * @throws ConfigurationException
-	 *
-	 * @see _elgg_get_memcache() Core developers should use this instead of direct construction.
-	 */
-	public function __construct($namespace = 'default', \Stash\Pool $pool = null, $ttl = null) {
-		parent::__construct();
-
-		$this->setNamespace($namespace);
-
-		if (!$pool) {
-			$pool = _elgg_services()->memcacheStashPool;
-			if (!$pool) {
-				throw new \ConfigurationException('No memcache servers defined, please populate the $this->CONFIG->memcache_servers variable');
-			}
-		}
-		$this->stash_pool = $pool;
-
-		if ($ttl === null) {
-			$ttl = _elgg_config()->memcache_expires;
-		}
-		if (isset($ttl)) {
-			$this->ttl = $ttl;
-		}
+    /**
+     * TTL of saved items (default timeout after a day to prevent anything getting too stale)
+     */
+    private $ttl = 86400;
+
+    /**
+     * @var \Stash\Pool
+     */
+    private $stash_pool;
+
+    /**
+     * Constructor
+     *
+     * @param string      $namespace The namespace for this cache to write to
+     * @param \Stash\Pool $pool      The cache pool to use. Default is memcache.
+     * @param int         $ttl       The TTL in seconds. Default is from $CONFIG->memcache_expires.
+     *
+     * @throws ConfigurationException
+     *
+     * @see _elgg_get_memcache() Core developers should use this instead of direct construction.
+     */
+    public function __construct($namespace = 'default', \Stash\Pool $pool = null, $ttl = null) {
+        parent::__construct();
+
+        $this->setNamespace($namespace);
+
+        if (!$pool) {
+            $pool = _elgg_services()->memcacheStashPool;
+            if (!$pool) {
+                throw new \ConfigurationException('No memcache servers defined, please populate the $this->CONFIG->memcache_servers variable');
+            }
+        }
+        $this->stash_pool = $pool;
+
+        if ($ttl === null) {
+            $ttl = _elgg_config()->memcache_expires;
+        }
+        if (isset($ttl)) {
+            $this->ttl = $ttl;
+        }
 		
-		// make sure memcache is reset
-		_elgg_services()->events->registerHandler('cache:flush', 'system', [$this, 'clear']);
-	}
-
-	/**
-	 * Set the default TTL.
-	 *
-	 * @param int $ttl The TTL in seconds from now. Default is no expiration.
-	 *
-	 * @return void
-	 */
-	public function setDefaultExpiry($ttl = 0) {
-		$this->ttl = $ttl;
-	}
-
-	/**
-	 * Combine a key with the namespace.
-	 * Memcache can only accept <250 char key. If the given key is too long it is shortened.
-	 *
-	 * @param string $key The key
-	 *
-	 * @return string The new key.
-	 */
-	private function makeMemcacheKey($key) {
-		// using stacks grouping http://www.stashphp.com/Grouping.html#stacks
-		// this will allowing clearing the namespace later
-		return "/{$this->getNamespace()}/$key";
-	}
-
-	/**
-	 * Saves a name and value to the cache
-	 *
-	 * @param string  $key  Name
-	 * @param string  $data Value
-	 * @param integer $ttl  TTL of cache item (seconds), 0 for no expiration, null for default.
-	 *
-	 * @return bool
-	 */
-	public function save($key, $data, $ttl = null) {
-		$key = $this->makeMemcacheKey($key);
-
-		if ($ttl === null) {
-			$ttl = $this->ttl;
-		}
-
-		$item = $this->stash_pool->getItem($key);
-
-		$item->set($data);
-		$item->expiresAfter($ttl);
-		$result = $item->save();
-
-		if ($result) {
-			_elgg_services()->logger->info("MEMCACHE: SAVE SUCCESS $key");
-		} else {
-			_elgg_services()->logger->error("MEMCACHE: SAVE FAIL $key");
-		}
-
-		return $result;
-	}
-
-	/**
-	 * Retrieves data.
-	 *
-	 * @param string $key     Name of data to retrieve
-	 * @param int    $unused1 Unused
-	 * @param int    $unused2 Unused
-	 *
-	 * @return mixed
-	 */
-	public function load($key, $unused1 = 0, $unused2 = null) {
-		$key = $this->makeMemcacheKey($key);
-
-		$item = $this->stash_pool->getItem($key);
-
-		$item->setInvalidationMethod(\Stash\Invalidation::NONE);
-		$value = $item->get();
-
-		if ($item->isMiss()) {
-			_elgg_services()->logger->info("MEMCACHE: LOAD MISS $key");
-			return false;
-		}
-
-		_elgg_services()->logger->info("MEMCACHE: LOAD HIT $key");
-
-		return $value;
-	}
-
-	/**
-	 * Delete data
-	 *
-	 * @param string $key Name of data
-	 *
-	 * @return bool
-	 */
-	public function delete($key) {
-		$key = $this->makeMemcacheKey($key);
-		return $this->stash_pool->getItem($key)->clear();
-	}
-
-	/**
-	 * Clears all values in the namespace of this cache
-	 *
-	 * @return bool
-	 */
-	public function clear() {
-		// using stacks grouping http://www.stashphp.com/Grouping.html#stacks
-		// this will clear all key keys beneath it
-		return $this->stash_pool->getItem("/{$this->getNamespace()}")->clear();
-	}
+        // make sure memcache is reset
+        _elgg_services()->events->registerHandler('cache:flush', 'system', [$this, 'clear']);
+    }
+
+    /**
+     * Set the default TTL.
+     *
+     * @param int $ttl The TTL in seconds from now. Default is no expiration.
+     *
+     * @return void
+     */
+    public function setDefaultExpiry($ttl = 0) {
+        $this->ttl = $ttl;
+    }
+
+    /**
+     * Combine a key with the namespace.
+     * Memcache can only accept <250 char key. If the given key is too long it is shortened.
+     *
+     * @param string $key The key
+     *
+     * @return string The new key.
+     */
+    private function makeMemcacheKey($key) {
+        // using stacks grouping http://www.stashphp.com/Grouping.html#stacks
+        // this will allowing clearing the namespace later
+        return "/{$this->getNamespace()}/$key";
+    }
+
+    /**
+     * Saves a name and value to the cache
+     *
+     * @param string  $key  Name
+     * @param string  $data Value
+     * @param integer $ttl  TTL of cache item (seconds), 0 for no expiration, null for default.
+     *
+     * @return bool
+     */
+    public function save($key, $data, $ttl = null) {
+        $key = $this->makeMemcacheKey($key);
+
+        if ($ttl === null) {
+            $ttl = $this->ttl;
+        }
+
+        $item = $this->stash_pool->getItem($key);
+
+        $item->set($data);
+        $item->expiresAfter($ttl);
+        $result = $item->save();
+
+        if ($result) {
+            _elgg_services()->logger->info("MEMCACHE: SAVE SUCCESS $key");
+        } else {
+            _elgg_services()->logger->error("MEMCACHE: SAVE FAIL $key");
+        }
+
+        return $result;
+    }
+
+    /**
+     * Retrieves data.
+     *
+     * @param string $key     Name of data to retrieve
+     * @param int    $unused1 Unused
+     * @param int    $unused2 Unused
+     *
+     * @return mixed
+     */
+    public function load($key, $unused1 = 0, $unused2 = null) {
+        $key = $this->makeMemcacheKey($key);
+
+        $item = $this->stash_pool->getItem($key);
+
+        $item->setInvalidationMethod(\Stash\Invalidation::NONE);
+        $value = $item->get();
+
+        if ($item->isMiss()) {
+            _elgg_services()->logger->info("MEMCACHE: LOAD MISS $key");
+            return false;
+        }
+
+        _elgg_services()->logger->info("MEMCACHE: LOAD HIT $key");
+
+        return $value;
+    }
+
+    /**
+     * Delete data
+     *
+     * @param string $key Name of data
+     *
+     * @return bool
+     */
+    public function delete($key) {
+        $key = $this->makeMemcacheKey($key);
+        return $this->stash_pool->getItem($key)->clear();
+    }
+
+    /**
+     * Clears all values in the namespace of this cache
+     *
+     * @return bool
+     */
+    public function clear() {
+        // using stacks grouping http://www.stashphp.com/Grouping.html#stacks
+        // this will clear all key keys beneath it
+        return $this->stash_pool->getItem("/{$this->getNamespace()}")->clear();
+    }
 	
-	/**
-	 * Set the namespace of this cache.
-	 *
-	 * This will also add the Memcache namespace prefix as defined in settings.php
-	 *
-	 * @param string $namespace Namespace for cache
-	 *
-	 * @return void
-	 */
-	public function setNamespace($namespace = "default") {
-		$config_prefix = _elgg_services()->config->getVolatile('memcache_namespace_prefix');
-		if ($config_prefix) {
-			$namespace = $config_prefix . $namespace;
-		}
+    /**
+     * Set the namespace of this cache.
+     *
+     * This will also add the Memcache namespace prefix as defined in settings.php
+     *
+     * @param string $namespace Namespace for cache
+     *
+     * @return void
+     */
+    public function setNamespace($namespace = "default") {
+        $config_prefix = _elgg_services()->config->getVolatile('memcache_namespace_prefix');
+        if ($config_prefix) {
+            $namespace = $config_prefix . $namespace;
+        }
 		
-		parent::setNamespace($namespace);
-	}
+        parent::setNamespace($namespace);
+    }
 }

engine/classes/ElggBatch.php

Indentation +384 added lines, -384 removed lines

@@ -72,389 +72,389 @@
  */
 class ElggBatch implements BatchResult {
 
-	/**
-	 * The objects to iterate over.
-	 *
-	 * @var array
-	 */
-	private $results = [];
-
-	/**
-	 * The function used to get results.
-	 *
-	 * @var callable
-	 */
-	private $getter = null;
-
-	/**
-	 * The given $options to alter and pass to the getter.
-	 *
-	 * @var array
-	 */
-	private $options = [];
-
-	/**
-	 * The number of results to grab at a time.
-	 *
-	 * @var int
-	 */
-	private $chunkSize = 25;
-
-	/**
-	 * A callback function to pass results through.
-	 *
-	 * @var callable
-	 */
-	private $callback = null;
-
-	/**
-	 * Start after this many results.
-	 *
-	 * @var int
-	 */
-	private $offset = 0;
-
-	/**
-	 * Stop after this many results.
-	 *
-	 * @var int
-	 */
-	private $limit = 0;
-
-	/**
-	 * Number of processed results.
-	 *
-	 * @var int
-	 */
-	private $retrievedResults = 0;
-
-	/**
-	 * The index of the current result within the current chunk
-	 *
-	 * @var int
-	 */
-	private $resultIndex = 0;
-
-	/**
-	 * The index of the current chunk
-	 *
-	 * @var int
-	 */
-	private $chunkIndex = 0;
-
-	/**
-	 * The number of results iterated through
-	 *
-	 * @var int
-	 */
-	private $processedResults = 0;
-
-	/**
-	 * Is the getter a valid callback
-	 *
-	 * @var bool
-	 */
-	private $validGetter = null;
-
-	/**
-	 * The result of running all entities through the callback function.
-	 *
-	 * @var mixed
-	 */
-	public $callbackResult = null;
-
-	/**
-	 * If false, offset will not be incremented. This is used for callbacks/loops that delete.
-	 *
-	 * @var bool
-	 */
-	private $incrementOffset = true;
-
-	/**
-	 * Entities that could not be instantiated during a fetch
-	 *
-	 * @var \stdClass[]
-	 */
-	private $incompleteEntities = [];
-
-	/**
-	 * Total number of incomplete entities fetched
-	 *
-	 * @var int
-	 */
-	private $totalIncompletes = 0;
-
-	/**
-	 * Batches operations on any elgg_get_*() or compatible function that supports
-	 * an options array.
-	 *
-	 * Instead of returning all objects in memory, it goes through $chunk_size
-	 * objects, then requests more from the server.  This avoids OOM errors.
-	 *
-	 * @param string $getter     The function used to get objects.  Usually
-	 *                           an elgg_get_*() function, but can be any valid PHP callback.
-	 * @param array  $options    The options array to pass to the getter function. If limit is
-	 *                           not set, 10 is used as the default. In most cases that is not
-	 *                           what you want.
-	 * @param mixed  $callback   An optional callback function that all results will be passed
-	 *                           to upon load.  The callback needs to accept $result, $getter,
-	 *                           $options.
-	 * @param int    $chunk_size The number of entities to pull in before requesting more.
-	 *                           You have to balance this between running out of memory in PHP
-	 *                           and hitting the db server too often.
-	 * @param bool   $inc_offset Increment the offset on each fetch. This must be false for
-	 *                           callbacks that delete rows. You can set this after the
-	 *                           object is created with {@link \ElggBatch::setIncrementOffset()}.
-	 */
-	public function __construct($getter, $options, $callback = null, $chunk_size = 25,
-			$inc_offset = true) {
+    /**
+     * The objects to iterate over.
+     *
+     * @var array
+     */
+    private $results = [];
+
+    /**
+     * The function used to get results.
+     *
+     * @var callable
+     */
+    private $getter = null;
+
+    /**
+     * The given $options to alter and pass to the getter.
+     *
+     * @var array
+     */
+    private $options = [];
+
+    /**
+     * The number of results to grab at a time.
+     *
+     * @var int
+     */
+    private $chunkSize = 25;
+
+    /**
+     * A callback function to pass results through.
+     *
+     * @var callable
+     */
+    private $callback = null;
+
+    /**
+     * Start after this many results.
+     *
+     * @var int
+     */
+    private $offset = 0;
+
+    /**
+     * Stop after this many results.
+     *
+     * @var int
+     */
+    private $limit = 0;
+
+    /**
+     * Number of processed results.
+     *
+     * @var int
+     */
+    private $retrievedResults = 0;
+
+    /**
+     * The index of the current result within the current chunk
+     *
+     * @var int
+     */
+    private $resultIndex = 0;
+
+    /**
+     * The index of the current chunk
+     *
+     * @var int
+     */
+    private $chunkIndex = 0;
+
+    /**
+     * The number of results iterated through
+     *
+     * @var int
+     */
+    private $processedResults = 0;
+
+    /**
+     * Is the getter a valid callback
+     *
+     * @var bool
+     */
+    private $validGetter = null;
+
+    /**
+     * The result of running all entities through the callback function.
+     *
+     * @var mixed
+     */
+    public $callbackResult = null;
+
+    /**
+     * If false, offset will not be incremented. This is used for callbacks/loops that delete.
+     *
+     * @var bool
+     */
+    private $incrementOffset = true;
+
+    /**
+     * Entities that could not be instantiated during a fetch
+     *
+     * @var \stdClass[]
+     */
+    private $incompleteEntities = [];
+
+    /**
+     * Total number of incomplete entities fetched
+     *
+     * @var int
+     */
+    private $totalIncompletes = 0;
+
+    /**
+     * Batches operations on any elgg_get_*() or compatible function that supports
+     * an options array.
+     *
+     * Instead of returning all objects in memory, it goes through $chunk_size
+     * objects, then requests more from the server.  This avoids OOM errors.
+     *
+     * @param string $getter     The function used to get objects.  Usually
+     *                           an elgg_get_*() function, but can be any valid PHP callback.
+     * @param array  $options    The options array to pass to the getter function. If limit is
+     *                           not set, 10 is used as the default. In most cases that is not
+     *                           what you want.
+     * @param mixed  $callback   An optional callback function that all results will be passed
+     *                           to upon load.  The callback needs to accept $result, $getter,
+     *                           $options.
+     * @param int    $chunk_size The number of entities to pull in before requesting more.
+     *                           You have to balance this between running out of memory in PHP
+     *                           and hitting the db server too often.
+     * @param bool   $inc_offset Increment the offset on each fetch. This must be false for
+     *                           callbacks that delete rows. You can set this after the
+     *                           object is created with {@link \ElggBatch::setIncrementOffset()}.
+     */
+    public function __construct($getter, $options, $callback = null, $chunk_size = 25,
+            $inc_offset = true) {
 		
-		$this->getter = $getter;
-		$this->options = $options;
-		$this->callback = $callback;
-		$this->chunkSize = $chunk_size;
-		$this->setIncrementOffset($inc_offset);
-
-		if ($this->chunkSize <= 0) {
-			$this->chunkSize = 25;
-		}
-
-		// store these so we can compare later
-		$this->offset = elgg_extract('offset', $options, 0);
-		$this->limit = elgg_extract('limit', $options, _elgg_config()->default_limit);
-
-		// if passed a callback, create a new \ElggBatch with the same options
-		// and pass each to the callback.
-		if ($callback && is_callable($callback)) {
-			$batch = new \ElggBatch($getter, $options, null, $chunk_size, $inc_offset);
-
-			$all_results = null;
-
-			foreach ($batch as $result) {
-				$result = call_user_func($callback, $result, $getter, $options);
-
-				if (!isset($all_results)) {
-					if ($result === true || $result === false || $result === null) {
-						$all_results = $result;
-					} else {
-						$all_results = [];
-					}
-				}
-
-				if (($result === true || $result === false || $result === null) && !is_array($all_results)) {
-					$all_results = $result && $all_results;
-				} else {
-					$all_results[] = $result;
-				}
-			}
-
-			$this->callbackResult = $all_results;
-		}
-	}
-
-	/**
-	 * Tell the process that an entity was incomplete during a fetch
-	 *
-	 * @param \stdClass $row
-	 *
-	 * @access private
-	 */
-	public function reportIncompleteEntity(\stdClass $row) {
-		$this->incompleteEntities[] = $row;
-	}
-
-	/**
-	 * Fetches the next chunk of results
-	 *
-	 * @return bool
-	 */
-	private function getNextResultsChunk() {
-
-		// always reset results.
-		$this->results = [];
-
-		if (!isset($this->validGetter)) {
-			$this->validGetter = is_callable($this->getter);
-		}
-
-		if (!$this->validGetter) {
-			return false;
-		}
-
-		$limit = $this->chunkSize;
-
-		// if someone passed limit = 0 they want everything.
-		if ($this->limit != 0) {
-			if ($this->retrievedResults >= $this->limit) {
-				return false;
-			}
-
-			// if original limit < chunk size, set limit to original limit
-			// else if the number of results we'll fetch if greater than the original limit
-			if ($this->limit < $this->chunkSize) {
-				$limit = $this->limit;
-			} elseif ($this->retrievedResults + $this->chunkSize > $this->limit) {
-				// set the limit to the number of results remaining in the original limit
-				$limit = $this->limit - $this->retrievedResults;
-			}
-		}
-
-		if ($this->incrementOffset) {
-			$offset = $this->offset + $this->retrievedResults;
-		} else {
-			$offset = $this->offset + $this->totalIncompletes;
-		}
-
-		$current_options = [
-			'limit' => $limit,
-			'offset' => $offset,
-			'__ElggBatch' => $this,
-		];
-
-		$options = array_merge($this->options, $current_options);
-
-		$this->incompleteEntities = [];
-		$this->results = call_user_func($this->getter, $options);
-
-		// batch result sets tend to be large; we don't want to cache these.
-		_elgg_services()->db->disableQueryCache();
-
-		$num_results = count($this->results);
-		$num_incomplete = count($this->incompleteEntities);
-
-		$this->totalIncompletes += $num_incomplete;
-
-		if ($this->incompleteEntities) {
-			// pad the front of the results with nulls representing the incompletes
-			array_splice($this->results, 0, 0, array_pad([], $num_incomplete, null));
-			// ...and skip past them
-			reset($this->results);
-			for ($i = 0; $i < $num_incomplete; $i++) {
-				next($this->results);
-			}
-		}
-
-		if ($this->results) {
-			$this->chunkIndex++;
-
-			// let the system know we've jumped past the nulls
-			$this->resultIndex = $num_incomplete;
-
-			$this->retrievedResults += ($num_results + $num_incomplete);
-			if ($num_results == 0) {
-				// This fetch was *all* incompletes! We need to fetch until we can either
-				// offer at least one row to iterate over, or give up.
-				return $this->getNextResultsChunk();
-			}
-			_elgg_services()->db->enableQueryCache();
-			return true;
-		} else {
-			_elgg_services()->db->enableQueryCache();
-			return false;
-		}
-	}
-
-	/**
-	 * Increment the offset from the original options array? Setting to
-	 * false is required for callbacks that delete rows.
-	 *
-	 * @param bool $increment Set to false when deleting data
-	 * @return void
-	 */
-	public function setIncrementOffset($increment = true) {
-		$this->incrementOffset = (bool) $increment;
-	}
-
-	/**
-	 * Implements Iterator
-	 */
-
-	/**
-	 * {@inheritdoc}
-	 */
-	public function rewind() {
-		$this->resultIndex = 0;
-		$this->retrievedResults = 0;
-		$this->processedResults = 0;
-
-		// only grab results if we haven't yet or we're crossing chunks
-		if ($this->chunkIndex == 0 || $this->limit > $this->chunkSize) {
-			$this->chunkIndex = 0;
-			$this->getNextResultsChunk();
-		}
-	}
-
-	/**
-	 * {@inheritdoc}
-	 */
-	public function current() {
-		return current($this->results);
-	}
-
-	/**
-	 * {@inheritdoc}
-	 */
-	public function key() {
-		return $this->processedResults;
-	}
-
-	/**
-	 * {@inheritdoc}
-	 */
-	public function next() {
-		// if we'll be at the end.
-		if (($this->processedResults + 1) >= $this->limit && $this->limit > 0) {
-			$this->results = [];
-			return false;
-		}
-
-		// if we'll need new results.
-		if (($this->resultIndex + 1) >= $this->chunkSize) {
-			if (!$this->getNextResultsChunk()) {
-				$this->results = [];
-				return false;
-			}
-
-			$result = current($this->results);
-		} else {
-			// the function above resets the indexes, so only inc if not
-			// getting new set
-			$this->resultIndex++;
-			$result = next($this->results);
-		}
-
-		$this->processedResults++;
-		return $result;
-	}
-
-	/**
-	 * {@inheritdoc}
-	 */
-	public function valid() {
-		if (!is_array($this->results)) {
-			return false;
-		}
-		$key = key($this->results);
-		return ($key !== null && $key !== false);
-	}
-
-	/**
-	 * Count the total results available at this moment.
-	 *
-	 * As this performs a separate query, the count returned may not match the number of results you can
-	 * fetch via iteration on a very active DB.
-	 *
-	 * @see Countable::count()
-	 * @return int
-	 */
-	public function count() {
-		if (!is_callable($this->getter)) {
-			$inspector = new \Elgg\Debug\Inspector();
-			throw new RuntimeException("Getter is not callable: " . $inspector->describeCallable($this->getter));
-		}
-
-		$options = array_merge($this->options, ['count' => true]);
-
-		return call_user_func($this->getter, $options);
-	}
+        $this->getter = $getter;
+        $this->options = $options;
+        $this->callback = $callback;
+        $this->chunkSize = $chunk_size;
+        $this->setIncrementOffset($inc_offset);
+
+        if ($this->chunkSize <= 0) {
+            $this->chunkSize = 25;
+        }
+
+        // store these so we can compare later
+        $this->offset = elgg_extract('offset', $options, 0);
+        $this->limit = elgg_extract('limit', $options, _elgg_config()->default_limit);
+
+        // if passed a callback, create a new \ElggBatch with the same options
+        // and pass each to the callback.
+        if ($callback && is_callable($callback)) {
+            $batch = new \ElggBatch($getter, $options, null, $chunk_size, $inc_offset);
+
+            $all_results = null;
+
+            foreach ($batch as $result) {
+                $result = call_user_func($callback, $result, $getter, $options);
+
+                if (!isset($all_results)) {
+                    if ($result === true || $result === false || $result === null) {
+                        $all_results = $result;
+                    } else {
+                        $all_results = [];
+                    }
+                }
+
+                if (($result === true || $result === false || $result === null) && !is_array($all_results)) {
+                    $all_results = $result && $all_results;
+                } else {
+                    $all_results[] = $result;
+                }
+            }
+
+            $this->callbackResult = $all_results;
+        }
+    }
+
+    /**
+     * Tell the process that an entity was incomplete during a fetch
+     *
+     * @param \stdClass $row
+     *
+     * @access private
+     */
+    public function reportIncompleteEntity(\stdClass $row) {
+        $this->incompleteEntities[] = $row;
+    }
+
+    /**
+     * Fetches the next chunk of results
+     *
+     * @return bool
+     */
+    private function getNextResultsChunk() {
+
+        // always reset results.
+        $this->results = [];
+
+        if (!isset($this->validGetter)) {
+            $this->validGetter = is_callable($this->getter);
+        }
+
+        if (!$this->validGetter) {
+            return false;
+        }
+
+        $limit = $this->chunkSize;
+
+        // if someone passed limit = 0 they want everything.
+        if ($this->limit != 0) {
+            if ($this->retrievedResults >= $this->limit) {
+                return false;
+            }
+
+            // if original limit < chunk size, set limit to original limit
+            // else if the number of results we'll fetch if greater than the original limit
+            if ($this->limit < $this->chunkSize) {
+                $limit = $this->limit;
+            } elseif ($this->retrievedResults + $this->chunkSize > $this->limit) {
+                // set the limit to the number of results remaining in the original limit
+                $limit = $this->limit - $this->retrievedResults;
+            }
+        }
+
+        if ($this->incrementOffset) {
+            $offset = $this->offset + $this->retrievedResults;
+        } else {
+            $offset = $this->offset + $this->totalIncompletes;
+        }
+
+        $current_options = [
+            'limit' => $limit,
+            'offset' => $offset,
+            '__ElggBatch' => $this,
+        ];
+
+        $options = array_merge($this->options, $current_options);
+
+        $this->incompleteEntities = [];
+        $this->results = call_user_func($this->getter, $options);
+
+        // batch result sets tend to be large; we don't want to cache these.
+        _elgg_services()->db->disableQueryCache();
+
+        $num_results = count($this->results);
+        $num_incomplete = count($this->incompleteEntities);
+
+        $this->totalIncompletes += $num_incomplete;
+
+        if ($this->incompleteEntities) {
+            // pad the front of the results with nulls representing the incompletes
+            array_splice($this->results, 0, 0, array_pad([], $num_incomplete, null));
+            // ...and skip past them
+            reset($this->results);
+            for ($i = 0; $i < $num_incomplete; $i++) {
+                next($this->results);
+            }
+        }
+
+        if ($this->results) {
+            $this->chunkIndex++;
+
+            // let the system know we've jumped past the nulls
+            $this->resultIndex = $num_incomplete;
+
+            $this->retrievedResults += ($num_results + $num_incomplete);
+            if ($num_results == 0) {
+                // This fetch was *all* incompletes! We need to fetch until we can either
+                // offer at least one row to iterate over, or give up.
+                return $this->getNextResultsChunk();
+            }
+            _elgg_services()->db->enableQueryCache();
+            return true;
+        } else {
+            _elgg_services()->db->enableQueryCache();
+            return false;
+        }
+    }
+
+    /**
+     * Increment the offset from the original options array? Setting to
+     * false is required for callbacks that delete rows.
+     *
+     * @param bool $increment Set to false when deleting data
+     * @return void
+     */
+    public function setIncrementOffset($increment = true) {
+        $this->incrementOffset = (bool) $increment;
+    }
+
+    /**
+     * Implements Iterator
+     */
+
+    /**
+     * {@inheritdoc}
+     */
+    public function rewind() {
+        $this->resultIndex = 0;
+        $this->retrievedResults = 0;
+        $this->processedResults = 0;
+
+        // only grab results if we haven't yet or we're crossing chunks
+        if ($this->chunkIndex == 0 || $this->limit > $this->chunkSize) {
+            $this->chunkIndex = 0;
+            $this->getNextResultsChunk();
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function current() {
+        return current($this->results);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function key() {
+        return $this->processedResults;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function next() {
+        // if we'll be at the end.
+        if (($this->processedResults + 1) >= $this->limit && $this->limit > 0) {
+            $this->results = [];
+            return false;
+        }
+
+        // if we'll need new results.
+        if (($this->resultIndex + 1) >= $this->chunkSize) {
+            if (!$this->getNextResultsChunk()) {
+                $this->results = [];
+                return false;
+            }
+
+            $result = current($this->results);
+        } else {
+            // the function above resets the indexes, so only inc if not
+            // getting new set
+            $this->resultIndex++;
+            $result = next($this->results);
+        }
+
+        $this->processedResults++;
+        return $result;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function valid() {
+        if (!is_array($this->results)) {
+            return false;
+        }
+        $key = key($this->results);
+        return ($key !== null && $key !== false);
+    }
+
+    /**
+     * Count the total results available at this moment.
+     *
+     * As this performs a separate query, the count returned may not match the number of results you can
+     * fetch via iteration on a very active DB.
+     *
+     * @see Countable::count()
+     * @return int
+     */
+    public function count() {
+        if (!is_callable($this->getter)) {
+            $inspector = new \Elgg\Debug\Inspector();
+            throw new RuntimeException("Getter is not callable: " . $inspector->describeCallable($this->getter));
+        }
+
+        $options = array_merge($this->options, ['count' => true]);
+
+        return call_user_func($this->getter, $options);
+    }
 }

engine/classes/Elgg/Cache/MetadataCache.php

Indentation +223 added lines, -223 removed lines

@@ -11,228 +11,228 @@
  */
 class MetadataCache {
 
-	/**
-	 * The cached values (or null for known to be empty).
-	 *
-	 * @var array
-	 */
-	protected $values = [];
-
-	/**
-	 * @var \ElggSession
-	 */
-	protected $session;
-
-	/**
-	 * @var ElggSharedMemoryCache
-	 */
-	protected $cache;
-
-	/**
-	 * Constructor
-	 *
-	 * @param ElggSharedMemoryCache $cache Cache
-	 */
-	public function __construct(ElggSharedMemoryCache $cache = null) {
-		if (!$cache) {
-			$cache = new NullCache();
-		}
-		$this->cache = $cache;
-	}
-
-	/**
-	 * Set the visible metadata for an entity in the cache
-	 *
-	 * Note this does NOT invalidate any other part of the cache.
-	 *
-	 * @param int   $entity_guid The GUID of the entity
-	 * @param array $values      The metadata values to cache
-	 * @return void
-	 *
-	 * @access private For testing only
-	 */
-	public function inject($entity_guid, array $values) {
-		$this->values[$entity_guid] = $values;
-	}
-
-	/**
-	 * Get the metadata for a particular name. Note, this can return an array of values.
-	 *
-	 * Warning: You should always call isLoaded() beforehand to verify that this
-	 * function's return value can be trusted.
-	 *
-	 * @see isLoaded
-	 *
-	 * @param int    $entity_guid The GUID of the entity
-	 * @param string $name        The metadata name
-	 *
-	 * @return array|string|int|null null = value does not exist
-	 */
-	public function getSingle($entity_guid, $name) {
-		if (isset($this->values[$entity_guid])
-				&& array_key_exists($name, $this->values[$entity_guid])) {
-			return $this->values[$entity_guid][$name];
-		} else {
-			return null;
-		}
-	}
-
-	/**
-	 * Forget about all metadata for an entity.
-	 *
-	 * @param int $entity_guid The GUID of the entity
-	 * @return void
-	 */
-	public function clear($entity_guid) {
-		unset($this->values[$entity_guid]);
-		$this->cache->delete($entity_guid);
-	}
-
-	/**
-	 * If true, getSingle() will return an accurate values from the DB
-	 *
-	 * @param int $entity_guid The GUID of the entity
-	 * @return bool
-	 */
-	public function isLoaded($entity_guid) {
-		return array_key_exists($entity_guid, $this->values);
-	}
-
-	/**
-	 * Clear entire cache
-	 *
-	 * @return void
-	 */
-	public function clearAll() {
-		foreach (array_keys($this->values) as $guid) {
-			$this->cache->delete($guid);
-		}
-		$this->values = [];
-	}
-
-	/**
-	 * Invalidate based on options passed to the global *_metadata functions
-	 *
-	 * @param array $options Options passed to elgg_(delete|disable|enable)_metadata
-	 *                       "guid" if given, invalidation will be limited to this entity
-	 * @return void
-	 */
-	public function invalidateByOptions(array $options) {
-		if (empty($options['guid'])) {
-			$this->clearAll();
-		} else {
-			$this->clear($options['guid']);
-		}
-	}
-
-	/**
-	 * Populate the cache from a set of entities
-	 *
-	 * @param int|array $guids Array of or single GUIDs
-	 * @return void
-	 */
-	public function populateFromEntities($guids) {
-		if (empty($guids)) {
-			return;
-		}
+    /**
+     * The cached values (or null for known to be empty).
+     *
+     * @var array
+     */
+    protected $values = [];
+
+    /**
+     * @var \ElggSession
+     */
+    protected $session;
+
+    /**
+     * @var ElggSharedMemoryCache
+     */
+    protected $cache;
+
+    /**
+     * Constructor
+     *
+     * @param ElggSharedMemoryCache $cache Cache
+     */
+    public function __construct(ElggSharedMemoryCache $cache = null) {
+        if (!$cache) {
+            $cache = new NullCache();
+        }
+        $this->cache = $cache;
+    }
+
+    /**
+     * Set the visible metadata for an entity in the cache
+     *
+     * Note this does NOT invalidate any other part of the cache.
+     *
+     * @param int   $entity_guid The GUID of the entity
+     * @param array $values      The metadata values to cache
+     * @return void
+     *
+     * @access private For testing only
+     */
+    public function inject($entity_guid, array $values) {
+        $this->values[$entity_guid] = $values;
+    }
+
+    /**
+     * Get the metadata for a particular name. Note, this can return an array of values.
+     *
+     * Warning: You should always call isLoaded() beforehand to verify that this
+     * function's return value can be trusted.
+     *
+     * @see isLoaded
+     *
+     * @param int    $entity_guid The GUID of the entity
+     * @param string $name        The metadata name
+     *
+     * @return array|string|int|null null = value does not exist
+     */
+    public function getSingle($entity_guid, $name) {
+        if (isset($this->values[$entity_guid])
+                && array_key_exists($name, $this->values[$entity_guid])) {
+            return $this->values[$entity_guid][$name];
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * Forget about all metadata for an entity.
+     *
+     * @param int $entity_guid The GUID of the entity
+     * @return void
+     */
+    public function clear($entity_guid) {
+        unset($this->values[$entity_guid]);
+        $this->cache->delete($entity_guid);
+    }
+
+    /**
+     * If true, getSingle() will return an accurate values from the DB
+     *
+     * @param int $entity_guid The GUID of the entity
+     * @return bool
+     */
+    public function isLoaded($entity_guid) {
+        return array_key_exists($entity_guid, $this->values);
+    }
+
+    /**
+     * Clear entire cache
+     *
+     * @return void
+     */
+    public function clearAll() {
+        foreach (array_keys($this->values) as $guid) {
+            $this->cache->delete($guid);
+        }
+        $this->values = [];
+    }
+
+    /**
+     * Invalidate based on options passed to the global *_metadata functions
+     *
+     * @param array $options Options passed to elgg_(delete|disable|enable)_metadata
+     *                       "guid" if given, invalidation will be limited to this entity
+     * @return void
+     */
+    public function invalidateByOptions(array $options) {
+        if (empty($options['guid'])) {
+            $this->clearAll();
+        } else {
+            $this->clear($options['guid']);
+        }
+    }
+
+    /**
+     * Populate the cache from a set of entities
+     *
+     * @param int|array $guids Array of or single GUIDs
+     * @return void
+     */
+    public function populateFromEntities($guids) {
+        if (empty($guids)) {
+            return;
+        }
 		
-		$version = (int) _elgg_config()->version;
-		if (!empty($version) && ($version < 2016110900)) {
-			// can't use this during upgrade from 2.x to 3.0
-			return;
-		}
-
-		if (!is_array($guids)) {
-			$guids = [$guids];
-		}
-		$guids = array_unique($guids);
-
-		foreach ($guids as $i => $guid) {
-			$value = $this->cache->load($guid);
-			if ($value !== false) {
-				$this->values[$guid] = unserialize($value);
-				unset($guids[$i]);
-			}
-		}
-		if (empty($guids)) {
-			return;
-		}
-
-		// could be useful at some point in future
-		//$guids = $this->filterMetadataHeavyEntities($guids);
-
-		$options = [
-			'guids' => $guids,
-			'limit' => 0,
-			'callback' => false,
-			'distinct' => false,
-			'order_by' => 'n_table.entity_guid, n_table.time_created ASC, n_table.id ASC',
-		];
-		$data = _elgg_services()->metadataTable->getAll($options);
-
-		// make sure we show all entities as loaded
-		foreach ($guids as $guid) {
-			$this->values[$guid] = null;
-		}
-
-		// build up metadata for each entity, save when GUID changes (or data ends)
-		$last_guid = null;
-		$metadata = [];
-		$last_row_idx = count($data) - 1;
-		foreach ($data as $i => $row) {
-			$name = $row->name;
-			$value = ($row->value_type === 'text') ? $row->value : (int) $row->value;
-			$guid = $row->entity_guid;
-			if ($guid !== $last_guid) {
-				if ($last_guid) {
-					$this->values[$last_guid] = $metadata;
-				}
-				$metadata = [];
-			}
-			if (isset($metadata[$name])) {
-				$metadata[$name] = (array) $metadata[$name];
-				$metadata[$name][] = $value;
-			} else {
-				$metadata[$name] = $value;
-			}
-			if (($i == $last_row_idx)) {
-				$this->values[$guid] = $metadata;
-			}
-			$last_guid = $guid;
-		}
-
-		foreach ($guids as $guid) {
-			$this->cache->save($guid, serialize($this->values[$guid]));
-		}
-	}
-
-	/**
-	 * Filter out entities whose concatenated metadata values (INTs casted as string)
-	 * exceed a threshold in characters. This could be used to avoid overpopulating the
-	 * cache if RAM usage becomes an issue.
-	 *
-	 * @param array $guids GUIDs of entities to examine
-	 * @param int   $limit Limit in characters of all metadata (with ints casted to strings)
-	 * @return array
-	 */
-	public function filterMetadataHeavyEntities(array $guids, $limit = 1024000) {
-		$db_prefix = _elgg_config()->dbprefix;
-
-		$options = [
-			'guids' => $guids,
-			'limit' => 0,
-			'callback' => false,
-			'selects' => ['SUM(LENGTH(n_table.value)) AS bytes'],
-			'order_by' => 'n_table.entity_guid, n_table.time_created ASC',
-			'group_by' => 'n_table.entity_guid',
-		];
-		$data = _elgg_services()->metadataTable->getAll($options);
-		// don't cache if metadata for entity is over 10MB (or rolled INT)
-		foreach ($data as $row) {
-			if ($row->bytes > $limit || $row->bytes < 0) {
-				array_splice($guids, array_search($row->entity_guid, $guids), 1);
-			}
-		}
-		return $guids;
-	}
+        $version = (int) _elgg_config()->version;
+        if (!empty($version) && ($version < 2016110900)) {
+            // can't use this during upgrade from 2.x to 3.0
+            return;
+        }
+
+        if (!is_array($guids)) {
+            $guids = [$guids];
+        }
+        $guids = array_unique($guids);
+
+        foreach ($guids as $i => $guid) {
+            $value = $this->cache->load($guid);
+            if ($value !== false) {
+                $this->values[$guid] = unserialize($value);
+                unset($guids[$i]);
+            }
+        }
+        if (empty($guids)) {
+            return;
+        }
+
+        // could be useful at some point in future
+        //$guids = $this->filterMetadataHeavyEntities($guids);
+
+        $options = [
+            'guids' => $guids,
+            'limit' => 0,
+            'callback' => false,
+            'distinct' => false,
+            'order_by' => 'n_table.entity_guid, n_table.time_created ASC, n_table.id ASC',
+        ];
+        $data = _elgg_services()->metadataTable->getAll($options);
+
+        // make sure we show all entities as loaded
+        foreach ($guids as $guid) {
+            $this->values[$guid] = null;
+        }
+
+        // build up metadata for each entity, save when GUID changes (or data ends)
+        $last_guid = null;
+        $metadata = [];
+        $last_row_idx = count($data) - 1;
+        foreach ($data as $i => $row) {
+            $name = $row->name;
+            $value = ($row->value_type === 'text') ? $row->value : (int) $row->value;
+            $guid = $row->entity_guid;
+            if ($guid !== $last_guid) {
+                if ($last_guid) {
+                    $this->values[$last_guid] = $metadata;
+                }
+                $metadata = [];
+            }
+            if (isset($metadata[$name])) {
+                $metadata[$name] = (array) $metadata[$name];
+                $metadata[$name][] = $value;
+            } else {
+                $metadata[$name] = $value;
+            }
+            if (($i == $last_row_idx)) {
+                $this->values[$guid] = $metadata;
+            }
+            $last_guid = $guid;
+        }
+
+        foreach ($guids as $guid) {
+            $this->cache->save($guid, serialize($this->values[$guid]));
+        }
+    }
+
+    /**
+     * Filter out entities whose concatenated metadata values (INTs casted as string)
+     * exceed a threshold in characters. This could be used to avoid overpopulating the
+     * cache if RAM usage becomes an issue.
+     *
+     * @param array $guids GUIDs of entities to examine
+     * @param int   $limit Limit in characters of all metadata (with ints casted to strings)
+     * @return array
+     */
+    public function filterMetadataHeavyEntities(array $guids, $limit = 1024000) {
+        $db_prefix = _elgg_config()->dbprefix;
+
+        $options = [
+            'guids' => $guids,
+            'limit' => 0,
+            'callback' => false,
+            'selects' => ['SUM(LENGTH(n_table.value)) AS bytes'],
+            'order_by' => 'n_table.entity_guid, n_table.time_created ASC',
+            'group_by' => 'n_table.entity_guid',
+        ];
+        $data = _elgg_services()->metadataTable->getAll($options);
+        // don't cache if metadata for entity is over 10MB (or rolled INT)
+        foreach ($data as $row) {
+            if ($row->bytes > $limit || $row->bytes < 0) {
+                array_splice($guids, array_search($row->entity_guid, $guids), 1);
+            }
+        }
+        return $guids;
+    }
 }

engine/classes/Elgg/BatchUpgrader.php

Spacing +1 added lines, -1 removed lines

@@ -71,7 +71,7 @@
 		/** @var Result $result */
 		$result = null;
 
-		$condition = function () use (&$count, &$processed, &$result, $started) {
+		$condition = function() use (&$count, &$processed, &$result, $started) {
 			if ((microtime(true) - $started) >= $this->config->batch_run_time_in_secs) {
 				return false;
 			}

Indentation +118 added lines, -118 removed lines

@@ -17,132 +17,132 @@
  */
 class BatchUpgrader {
 
-	/**
-	 * @var $config Config
-	 */
-	private $config;
-
-	/**
-	 * Constructor
-	 *
-	 * @param Config $config Site configuration
-	 */
-	public function __construct(Config $config) {
-		$this->config = $config;
-
-		// Custom limit can be defined in settings.php if necessary
-		if (empty($this->config->batch_run_time_in_secs)) {
-			$this->config->batch_run_time_in_secs = 4;
-		}
-	}
-
-	/**
-	 * Call the upgrade's run() for a short period of time, or until it completes
-	 *
-	 * @param ElggUpgrade $upgrade Upgrade to run
-	 * @return array
-	 * @throws \RuntimeException
-	 */
-	public function run(ElggUpgrade $upgrade) {
-		// Upgrade also disabled data, so the compatibility is
-		// preserved in case the data ever gets enabled again
-		$ha = access_get_show_hidden_status();
-		access_show_hidden_entities(true);
-
-		$started = microtime(true);
-
-		// Get the class taking care of the actual upgrading
-		$batch = $upgrade->getBatch();
+    /**
+     * @var $config Config
+     */
+    private $config;
+
+    /**
+     * Constructor
+     *
+     * @param Config $config Site configuration
+     */
+    public function __construct(Config $config) {
+        $this->config = $config;
+
+        // Custom limit can be defined in settings.php if necessary
+        if (empty($this->config->batch_run_time_in_secs)) {
+            $this->config->batch_run_time_in_secs = 4;
+        }
+    }
+
+    /**
+     * Call the upgrade's run() for a short period of time, or until it completes
+     *
+     * @param ElggUpgrade $upgrade Upgrade to run
+     * @return array
+     * @throws \RuntimeException
+     */
+    public function run(ElggUpgrade $upgrade) {
+        // Upgrade also disabled data, so the compatibility is
+        // preserved in case the data ever gets enabled again
+        $ha = access_get_show_hidden_status();
+        access_show_hidden_entities(true);
+
+        $started = microtime(true);
+
+        // Get the class taking care of the actual upgrading
+        $batch = $upgrade->getBatch();
 			
-		if (!$batch) {
-			throw new \RuntimeException(elgg_echo('admin:upgrades:error:invalid_batch', [$upgrade->title, $upgrade->guid]));
-		}
+        if (!$batch) {
+            throw new \RuntimeException(elgg_echo('admin:upgrades:error:invalid_batch', [$upgrade->title, $upgrade->guid]));
+        }
 
-		$count = $batch->countItems();
+        $count = $batch->countItems();
 		
-		$batch_failure_count = 0;
-		$batch_success_count = 0;
-		$errors = [];
-
-		$processed = (int) $upgrade->processed;
-		$offset = (int) $upgrade->offset;
-		$has_errors = (bool) $upgrade->has_errors;
-
-		/** @var Result $result */
-		$result = null;
-
-		$condition = function () use (&$count, &$processed, &$result, $started) {
-			if ((microtime(true) - $started) >= $this->config->batch_run_time_in_secs) {
-				return false;
-			}
-			if ($result && $result->wasMarkedComplete()) {
-				return false;
-			}
-
-			return ($count === Batch::UNKNOWN_COUNT || ($count > $processed));
-		};
+        $batch_failure_count = 0;
+        $batch_success_count = 0;
+        $errors = [];
+
+        $processed = (int) $upgrade->processed;
+        $offset = (int) $upgrade->offset;
+        $has_errors = (bool) $upgrade->has_errors;
+
+        /** @var Result $result */
+        $result = null;
+
+        $condition = function () use (&$count, &$processed, &$result, $started) {
+            if ((microtime(true) - $started) >= $this->config->batch_run_time_in_secs) {
+                return false;
+            }
+            if ($result && $result->wasMarkedComplete()) {
+                return false;
+            }
+
+            return ($count === Batch::UNKNOWN_COUNT || ($count > $processed));
+        };
 		
-		while ($condition()) {
-			$result = $batch->run(new Result(), $offset);
+        while ($condition()) {
+            $result = $batch->run(new Result(), $offset);
 
-			$failure_count = $result->getFailureCount();
-			$success_count = $result->getSuccessCount();
+            $failure_count = $result->getFailureCount();
+            $success_count = $result->getSuccessCount();
 
-			$batch_failure_count += $failure_count;
-			$batch_success_count += $success_count;
+            $batch_failure_count += $failure_count;
+            $batch_success_count += $success_count;
 
-			$total = $failure_count + $success_count;
+            $total = $failure_count + $success_count;
 			
-			if ($batch->needsIncrementOffset()) {
-				// Offset needs to incremented by the total amount of processed
-				// items so the upgrade we won't get stuck upgrading the same
-				// items over and over.
-				$offset += $total;
-			} else {
-				// Offset doesn't need to be incremented, so we mark only
-				// the items that caused a failure.
-				$offset += $failure_count;
-			}
-
-			if ($failure_count > 0) {
-				$has_errors = true;
-			}
-
-			$processed += $total;
-
-			$errors = array_merge($errors, $result->getErrors());
-		}
-
-		access_show_hidden_entities($ha);
-
-		$upgrade->processed = $processed;
-		$upgrade->offset = $offset;
-		$upgrade->has_errors = $has_errors;
+            if ($batch->needsIncrementOffset()) {
+                // Offset needs to incremented by the total amount of processed
+                // items so the upgrade we won't get stuck upgrading the same
+                // items over and over.
+                $offset += $total;
+            } else {
+                // Offset doesn't need to be incremented, so we mark only
+                // the items that caused a failure.
+                $offset += $failure_count;
+            }
+
+            if ($failure_count > 0) {
+                $has_errors = true;
+            }
+
+            $processed += $total;
+
+            $errors = array_merge($errors, $result->getErrors());
+        }
+
+        access_show_hidden_entities($ha);
+
+        $upgrade->processed = $processed;
+        $upgrade->offset = $offset;
+        $upgrade->has_errors = $has_errors;
 		
-		$completed = ($result && $result->wasMarkedComplete()) || ($processed >= $count);
-		if ($completed) {
-			// Upgrade is finished
-			if ($has_errors) {
-				// The upgrade was finished with errors. Reset offset
-				// and errors so the upgrade can start from a scratch
-				// if attempted to run again.
-				$upgrade->processed = 0;
-				$upgrade->offset = 0;
-				$upgrade->has_errors = false;
-			} else {
-				// Everything has been processed without errors
-				// so the upgrade can be marked as completed.
-				$upgrade->setCompleted();
-			}
-		}
-
-		// Give feedback to the user interface about the current batch.
-		return [
-			'errors' => $errors,
-			'numErrors' => $batch_failure_count,
-			'numSuccess' => $batch_success_count,
-			'isComplete' => $result && $result->wasMarkedComplete(),
-		];
-	}
+        $completed = ($result && $result->wasMarkedComplete()) || ($processed >= $count);
+        if ($completed) {
+            // Upgrade is finished
+            if ($has_errors) {
+                // The upgrade was finished with errors. Reset offset
+                // and errors so the upgrade can start from a scratch
+                // if attempted to run again.
+                $upgrade->processed = 0;
+                $upgrade->offset = 0;
+                $upgrade->has_errors = false;
+            } else {
+                // Everything has been processed without errors
+                // so the upgrade can be marked as completed.
+                $upgrade->setCompleted();
+            }
+        }
+
+        // Give feedback to the user interface about the current batch.
+        return [
+            'errors' => $errors,
+            'numErrors' => $batch_failure_count,
+            'numSuccess' => $batch_success_count,
+            'isComplete' => $result && $result->wasMarkedComplete(),
+        ];
+    }
 
 }

engine/classes/Elgg/Database/UsersTable.php

Indentation +518 added lines, -518 removed lines

@@ -21,518 +21,518 @@ 
  */
 class UsersTable {
 
-	use \Elgg\TimeUsing;
-
-	/**
-	 * @var Conf
-	 */
-	protected $config;
-
-	/**
-	 * @var Database
-	 */
-	protected $db;
-
-	/**
-	 * @var EntityTable
-	 */
-	protected $entities;
-
-	/**
-	 * @var EntityCache
-	 */
-	protected $entity_cache;
-
-	/**
-	 * @var EventsService
-	 */
-	protected $events;
-
-	/**
-	 * @var string
-	 */
-	protected $table;
-
-	/**
-	 * Constructor
-	 *
-	 * @param Conf          $config   Config
-	 * @param Database      $db       Database
-	 * @param EntityTable   $entities Entity table
-	 * @param EntityCache   $cache    Entity cache
-	 * @param EventsService $events   Event service
-	 */
-	public function __construct(
-	Conf $config, Database $db, EntityTable $entities, EntityCache $cache, EventsService $events
-	) {
-		$this->config = $config;
-		$this->db = $db;
-		$this->table = $this->db->prefix . "users_entity";
-		$this->entities = $entities;
-		$this->entity_cache = $cache;
-		$this->events = $events;
-	}
-
-	/**
-	 * Return the user specific details of a user by a row.
-	 *
-	 * @param int $guid The \ElggUser guid
-	 *
-	 * @return mixed
-	 * @access private
-	 */
-	public function getRow($guid) {
-		$sql = "
+    use \Elgg\TimeUsing;
+
+    /**
+     * @var Conf
+     */
+    protected $config;
+
+    /**
+     * @var Database
+     */
+    protected $db;
+
+    /**
+     * @var EntityTable
+     */
+    protected $entities;
+
+    /**
+     * @var EntityCache
+     */
+    protected $entity_cache;
+
+    /**
+     * @var EventsService
+     */
+    protected $events;
+
+    /**
+     * @var string
+     */
+    protected $table;
+
+    /**
+     * Constructor
+     *
+     * @param Conf          $config   Config
+     * @param Database      $db       Database
+     * @param EntityTable   $entities Entity table
+     * @param EntityCache   $cache    Entity cache
+     * @param EventsService $events   Event service
+     */
+    public function __construct(
+    Conf $config, Database $db, EntityTable $entities, EntityCache $cache, EventsService $events
+    ) {
+        $this->config = $config;
+        $this->db = $db;
+        $this->table = $this->db->prefix . "users_entity";
+        $this->entities = $entities;
+        $this->entity_cache = $cache;
+        $this->events = $events;
+    }
+
+    /**
+     * Return the user specific details of a user by a row.
+     *
+     * @param int $guid The \ElggUser guid
+     *
+     * @return mixed
+     * @access private
+     */
+    public function getRow($guid) {
+        $sql = "
 			SELECT * FROM {$this->table}
 			WHERE guid = :guid
 		";
-		$params = [
-			':guid' => $guid,
-		];
-		return $this->db->getDataRow($sql, null, $params);
-	}
-
-	/**
-	 * Disables all of a user's entities
-	 *
-	 * @param int $owner_guid The owner GUID
-	 * @return bool Depending on success
-	 * @deprecated 2.3
-	 */
-	public function disableEntities($owner_guid) {
-		return $this->entities->disableEntities($owner_guid);
-	}
-
-	/**
-	 * Ban a user (calls events, stores the reason)
-	 *
-	 * @param int    $user_guid The user guid
-	 * @param string $reason    A reason
-	 * @return bool
-	 */
-	public function ban($user_guid, $reason = "") {
-
-		$user = get_entity($user_guid);
-
-		if (!$user instanceof ElggUser || !$user->canEdit()) {
-			return false;
-		}
-
-		if (!$this->events->trigger('ban', 'user', $user)) {
-			return false;
-		}
-
-		$user->ban_reason = $reason;
-
-		_elgg_invalidate_cache_for_entity($user_guid);
-		_elgg_invalidate_memcache_for_entity($user_guid);
-
-		if ($this->markBanned($user_guid, true)) {
-			return true;
-		}
-
-		return false;
-	}
-
-	/**
-	 * Mark a user entity banned or unbanned.
-	 *
-	 * @note Use ban() or unban()
-	 *
-	 * @param int  $guid   User GUID
-	 * @param bool $banned Mark the user banned?
-	 * @return int Num rows affected
-	 */
-	public function markBanned($guid, $banned) {
-
-		$query = "
+        $params = [
+            ':guid' => $guid,
+        ];
+        return $this->db->getDataRow($sql, null, $params);
+    }
+
+    /**
+     * Disables all of a user's entities
+     *
+     * @param int $owner_guid The owner GUID
+     * @return bool Depending on success
+     * @deprecated 2.3
+     */
+    public function disableEntities($owner_guid) {
+        return $this->entities->disableEntities($owner_guid);
+    }
+
+    /**
+     * Ban a user (calls events, stores the reason)
+     *
+     * @param int    $user_guid The user guid
+     * @param string $reason    A reason
+     * @return bool
+     */
+    public function ban($user_guid, $reason = "") {
+
+        $user = get_entity($user_guid);
+
+        if (!$user instanceof ElggUser || !$user->canEdit()) {
+            return false;
+        }
+
+        if (!$this->events->trigger('ban', 'user', $user)) {
+            return false;
+        }
+
+        $user->ban_reason = $reason;
+
+        _elgg_invalidate_cache_for_entity($user_guid);
+        _elgg_invalidate_memcache_for_entity($user_guid);
+
+        if ($this->markBanned($user_guid, true)) {
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Mark a user entity banned or unbanned.
+     *
+     * @note Use ban() or unban()
+     *
+     * @param int  $guid   User GUID
+     * @param bool $banned Mark the user banned?
+     * @return int Num rows affected
+     */
+    public function markBanned($guid, $banned) {
+
+        $query = "
 			UPDATE {$this->table}
 			SET banned = :banned
 			WHERE guid = :guid
 		";
 
-		$params = [
-			':banned' => $banned ? 'yes' : 'no',
-			':guid' => (int) $guid,
-		];
+        $params = [
+            ':banned' => $banned ? 'yes' : 'no',
+            ':guid' => (int) $guid,
+        ];
 
-		return $this->db->updateData($query, true, $params);
-	}
+        return $this->db->updateData($query, true, $params);
+    }
 
-	/**
-	 * Unban a user (calls events, removes the reason)
-	 *
-	 * @param int $user_guid Unban a user
-	 * @return bool
-	 */
-	public function unban($user_guid) {
+    /**
+     * Unban a user (calls events, removes the reason)
+     *
+     * @param int $user_guid Unban a user
+     * @return bool
+     */
+    public function unban($user_guid) {
 
-		$user = get_entity($user_guid);
+        $user = get_entity($user_guid);
 
-		if (!$user instanceof ElggUser || !$user->canEdit()) {
-			return false;
-		}
+        if (!$user instanceof ElggUser || !$user->canEdit()) {
+            return false;
+        }
 
-		if (!$this->events->trigger('unban', 'user', $user)) {
-			return false;
-		}
+        if (!$this->events->trigger('unban', 'user', $user)) {
+            return false;
+        }
 
-		$user->deleteMetadata('ban_reason');
+        $user->deleteMetadata('ban_reason');
 
-		_elgg_invalidate_cache_for_entity($user_guid);
-		_elgg_invalidate_memcache_for_entity($user_guid);
+        _elgg_invalidate_cache_for_entity($user_guid);
+        _elgg_invalidate_memcache_for_entity($user_guid);
 
-		return $this->markBanned($user_guid, false);
-	}
+        return $this->markBanned($user_guid, false);
+    }
 
-	/**
-	 * Makes user $guid an admin.
-	 *
-	 * @param int $user_guid User guid
-	 * @return bool
-	 */
-	public function makeAdmin($user_guid) {
-		$user = get_entity($user_guid);
+    /**
+     * Makes user $guid an admin.
+     *
+     * @param int $user_guid User guid
+     * @return bool
+     */
+    public function makeAdmin($user_guid) {
+        $user = get_entity($user_guid);
 
-		if (!$user instanceof ElggUser || !$user->canEdit()) {
-			return false;
-		}
+        if (!$user instanceof ElggUser || !$user->canEdit()) {
+            return false;
+        }
 
-		if (!$this->events->trigger('make_admin', 'user', $user)) {
-			return false;
-		}
+        if (!$this->events->trigger('make_admin', 'user', $user)) {
+            return false;
+        }
 
-		$query = "
+        $query = "
 			UPDATE {$this->table}
 			SET admin = 'yes'
 			WHERE guid = :guid
 		";
 
-		$params = [
-			':guid' => (int) $user_guid,
-		];
+        $params = [
+            ':guid' => (int) $user_guid,
+        ];
 
-		_elgg_invalidate_cache_for_entity($user_guid);
-		_elgg_invalidate_memcache_for_entity($user_guid);
+        _elgg_invalidate_cache_for_entity($user_guid);
+        _elgg_invalidate_memcache_for_entity($user_guid);
 
-		if ($this->db->updateData($query, true, $params)) {
-			return true;
-		}
+        if ($this->db->updateData($query, true, $params)) {
+            return true;
+        }
 
-		return false;
-	}
+        return false;
+    }
 
-	/**
-	 * Removes user $guid's admin flag.
-	 *
-	 * @param int $user_guid User GUID
-	 * @return bool
-	 */
-	public function removeAdmin($user_guid) {
+    /**
+     * Removes user $guid's admin flag.
+     *
+     * @param int $user_guid User GUID
+     * @return bool
+     */
+    public function removeAdmin($user_guid) {
 
-		$user = get_entity($user_guid);
+        $user = get_entity($user_guid);
 
-		if (!$user instanceof ElggUser || !$user->canEdit()) {
-			return false;
-		}
+        if (!$user instanceof ElggUser || !$user->canEdit()) {
+            return false;
+        }
 
-		if (!$this->events->trigger('remove_admin', 'user', $user)) {
-			return false;
-		}
+        if (!$this->events->trigger('remove_admin', 'user', $user)) {
+            return false;
+        }
 
-		$query = "
+        $query = "
 			UPDATE {$this->table}
 			SET admin = 'no'
 			WHERE guid = :guid
 		";
 
-		$params = [
-			':guid' => (int) $user_guid,
-		];
-
-		_elgg_invalidate_cache_for_entity($user_guid);
-		_elgg_invalidate_memcache_for_entity($user_guid);
-
-		if ($this->db->updateData($query, true, $params)) {
-			return true;
-		}
-
-		return false;
-	}
-
-	/**
-	 * Get user by username
-	 *
-	 * @param string $username The user's username
-	 *
-	 * @return ElggUser|false Depending on success
-	 */
-	public function getByUsername($username) {
-
-		// Fixes #6052. Username is frequently sniffed from the path info, which,
-		// unlike $_GET, is not URL decoded. If the username was not URL encoded,
-		// this is harmless.
-		$username = rawurldecode($username);
-
-		if (!$username) {
-			return false;
-		}
-
-		$entity = $this->entity_cache->getByUsername($username);
-		if ($entity) {
-			return $entity;
-		}
-
-		$users = $this->entities->getEntitiesFromAttributes([
-			'types' => 'user',
-			'attribute_name_value_pairs' => [
-				'name' => 'username',
-				'value' => $username,
-			],
-			'limit' => 1,
-		]);
-		return $users ? $users[0] : false;
-	}
-
-	/**
-	 * Get an array of users from an email address
-	 *
-	 * @param string $email Email address
-	 * @return array
-	 */
-	public function getByEmail($email) {
-		if (!$email) {
-			return [];
-		}
-
-		$users = $this->entities->getEntitiesFromAttributes([
-			'types' => 'user',
-			'attribute_name_value_pairs' => [
-				'name' => 'email',
-				'value' => $email,
-			],
-			'limit' => 1,
-		]);
-
-		return $users ? : [];
-	}
-
-	/**
-	 * Return users (or the number of them) who have been active within a recent period.
-	 *
-	 * @param array $options Array of options with keys:
-	 *
-	 *   seconds (int)  => Length of period (default 600 = 10min)
-	 *   limit   (int)  => Limit (default 10)
-	 *   offset  (int)  => Offset (default 0)
-	 *   count   (bool) => Return a count instead of users? (default false)
-	 *
-	 * @return \ElggUser[]|int
-	 */
-	public function findActive(array $options = []) {
+        $params = [
+            ':guid' => (int) $user_guid,
+        ];
+
+        _elgg_invalidate_cache_for_entity($user_guid);
+        _elgg_invalidate_memcache_for_entity($user_guid);
+
+        if ($this->db->updateData($query, true, $params)) {
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Get user by username
+     *
+     * @param string $username The user's username
+     *
+     * @return ElggUser|false Depending on success
+     */
+    public function getByUsername($username) {
+
+        // Fixes #6052. Username is frequently sniffed from the path info, which,
+        // unlike $_GET, is not URL decoded. If the username was not URL encoded,
+        // this is harmless.
+        $username = rawurldecode($username);
+
+        if (!$username) {
+            return false;
+        }
+
+        $entity = $this->entity_cache->getByUsername($username);
+        if ($entity) {
+            return $entity;
+        }
+
+        $users = $this->entities->getEntitiesFromAttributes([
+            'types' => 'user',
+            'attribute_name_value_pairs' => [
+                'name' => 'username',
+                'value' => $username,
+            ],
+            'limit' => 1,
+        ]);
+        return $users ? $users[0] : false;
+    }
+
+    /**
+     * Get an array of users from an email address
+     *
+     * @param string $email Email address
+     * @return array
+     */
+    public function getByEmail($email) {
+        if (!$email) {
+            return [];
+        }
+
+        $users = $this->entities->getEntitiesFromAttributes([
+            'types' => 'user',
+            'attribute_name_value_pairs' => [
+                'name' => 'email',
+                'value' => $email,
+            ],
+            'limit' => 1,
+        ]);
+
+        return $users ? : [];
+    }
+
+    /**
+     * Return users (or the number of them) who have been active within a recent period.
+     *
+     * @param array $options Array of options with keys:
+     *
+     *   seconds (int)  => Length of period (default 600 = 10min)
+     *   limit   (int)  => Limit (default 10)
+     *   offset  (int)  => Offset (default 0)
+     *   count   (bool) => Return a count instead of users? (default false)
+     *
+     * @return \ElggUser[]|int
+     */
+    public function findActive(array $options = []) {
 	
-		$options = array_merge([
-			'seconds' => 600,
-			'limit' => $this->config->default_limit,
-		], $options);
-
-		// cast options we're sending to hook
-		foreach (['seconds', 'limit', 'offset'] as $key) {
-			$options[$key] = (int) $options[$key];
-		}
-		$options['count'] = (bool) $options['count'];
-
-		// allow plugins to override
-		$params = [
-			'seconds' => $options['seconds'],
-			'limit' => $options['limit'],
-			'offset' => $options['offset'],
-			'count' => $options['count'],
-			'options' => $options,
-		];
-		$data = _elgg_services()->hooks->trigger('find_active_users', 'system', $params, null);
-		// check null because the handler could legitimately return falsey values.
-		if ($data !== null) {
-			return $data;
-		}
-
-		$dbprefix = $this->config->dbprefix;
-		$time = $this->getCurrentTime()->getTimestamp() - $options['seconds'];
-		return elgg_get_entities([
-			'type' => 'user',
-			'limit' => $options['limit'],
-			'offset' => $options['offset'],
-			'count' => $options['count'],
-			'joins' => ["join {$dbprefix}users_entity u on e.guid = u.guid"],
-			'wheres' => ["u.last_action >= {$time}"],
-			'order_by' => "u.last_action desc",
-		]);
-	}
-
-	/**
-	 * Registers a user, returning false if the username already exists
-	 *
-	 * @param string $username              The username of the new user
-	 * @param string $password              The password
-	 * @param string $name                  The user's display name
-	 * @param string $email                 The user's email address
-	 * @param bool   $allow_multiple_emails Allow the same email address to be
-	 *                                      registered multiple times?
-	 *
-	 * @return int|false The new user's GUID; false on failure
-	 * @throws RegistrationException
-	 */
-	public function register($username, $password, $name, $email, $allow_multiple_emails = false) {
-
-		// no need to trim password
-		$username = trim($username);
-		$name = trim(strip_tags($name));
-		$email = trim($email);
-
-		// A little sanity checking
-		if (empty($username) || empty($password) || empty($name) || empty($email)) {
-			return false;
-		}
-
-		// Make sure a user with conflicting details hasn't registered and been disabled
-		$access_status = access_get_show_hidden_status();
-		access_show_hidden_entities(true);
-
-		if (!validate_email_address($email)) {
-			throw new RegistrationException(_elgg_services()->translator->translate('registration:emailnotvalid'));
-		}
-
-		if (!validate_password($password)) {
-			throw new RegistrationException(_elgg_services()->translator->translate('registration:passwordnotvalid'));
-		}
-
-		if (!validate_username($username)) {
-			throw new RegistrationException(_elgg_services()->translator->translate('registration:usernamenotvalid'));
-		}
-
-		if ($user = get_user_by_username($username)) {
-			throw new RegistrationException(_elgg_services()->translator->translate('registration:userexists'));
-		}
-
-		if ((!$allow_multiple_emails) && (get_user_by_email($email))) {
-			throw new RegistrationException(_elgg_services()->translator->translate('registration:dupeemail'));
-		}
-
-		access_show_hidden_entities($access_status);
-
-		// Create user
-		$user = new ElggUser();
-		$user->username = $username;
-		$user->email = $email;
-		$user->name = $name;
-		$user->access_id = ACCESS_PUBLIC;
-		$user->setPassword($password);
-		$user->owner_guid = 0; // Users aren't owned by anyone, even if they are admin created.
-		$user->container_guid = 0; // Users aren't contained by anyone, even if they are admin created.
-		$user->language = _elgg_services()->translator->getCurrentLanguage();
-		if ($user->save() === false) {
-			return false;
-		}
-
-		// Turn on email notifications by default
-		$user->setNotificationSetting('email', true);
+        $options = array_merge([
+            'seconds' => 600,
+            'limit' => $this->config->default_limit,
+        ], $options);
+
+        // cast options we're sending to hook
+        foreach (['seconds', 'limit', 'offset'] as $key) {
+            $options[$key] = (int) $options[$key];
+        }
+        $options['count'] = (bool) $options['count'];
+
+        // allow plugins to override
+        $params = [
+            'seconds' => $options['seconds'],
+            'limit' => $options['limit'],
+            'offset' => $options['offset'],
+            'count' => $options['count'],
+            'options' => $options,
+        ];
+        $data = _elgg_services()->hooks->trigger('find_active_users', 'system', $params, null);
+        // check null because the handler could legitimately return falsey values.
+        if ($data !== null) {
+            return $data;
+        }
+
+        $dbprefix = $this->config->dbprefix;
+        $time = $this->getCurrentTime()->getTimestamp() - $options['seconds'];
+        return elgg_get_entities([
+            'type' => 'user',
+            'limit' => $options['limit'],
+            'offset' => $options['offset'],
+            'count' => $options['count'],
+            'joins' => ["join {$dbprefix}users_entity u on e.guid = u.guid"],
+            'wheres' => ["u.last_action >= {$time}"],
+            'order_by' => "u.last_action desc",
+        ]);
+    }
+
+    /**
+     * Registers a user, returning false if the username already exists
+     *
+     * @param string $username              The username of the new user
+     * @param string $password              The password
+     * @param string $name                  The user's display name
+     * @param string $email                 The user's email address
+     * @param bool   $allow_multiple_emails Allow the same email address to be
+     *                                      registered multiple times?
+     *
+     * @return int|false The new user's GUID; false on failure
+     * @throws RegistrationException
+     */
+    public function register($username, $password, $name, $email, $allow_multiple_emails = false) {
+
+        // no need to trim password
+        $username = trim($username);
+        $name = trim(strip_tags($name));
+        $email = trim($email);
+
+        // A little sanity checking
+        if (empty($username) || empty($password) || empty($name) || empty($email)) {
+            return false;
+        }
+
+        // Make sure a user with conflicting details hasn't registered and been disabled
+        $access_status = access_get_show_hidden_status();
+        access_show_hidden_entities(true);
+
+        if (!validate_email_address($email)) {
+            throw new RegistrationException(_elgg_services()->translator->translate('registration:emailnotvalid'));
+        }
+
+        if (!validate_password($password)) {
+            throw new RegistrationException(_elgg_services()->translator->translate('registration:passwordnotvalid'));
+        }
+
+        if (!validate_username($username)) {
+            throw new RegistrationException(_elgg_services()->translator->translate('registration:usernamenotvalid'));
+        }
+
+        if ($user = get_user_by_username($username)) {
+            throw new RegistrationException(_elgg_services()->translator->translate('registration:userexists'));
+        }
+
+        if ((!$allow_multiple_emails) && (get_user_by_email($email))) {
+            throw new RegistrationException(_elgg_services()->translator->translate('registration:dupeemail'));
+        }
+
+        access_show_hidden_entities($access_status);
+
+        // Create user
+        $user = new ElggUser();
+        $user->username = $username;
+        $user->email = $email;
+        $user->name = $name;
+        $user->access_id = ACCESS_PUBLIC;
+        $user->setPassword($password);
+        $user->owner_guid = 0; // Users aren't owned by anyone, even if they are admin created.
+        $user->container_guid = 0; // Users aren't contained by anyone, even if they are admin created.
+        $user->language = _elgg_services()->translator->getCurrentLanguage();
+        if ($user->save() === false) {
+            return false;
+        }
+
+        // Turn on email notifications by default
+        $user->setNotificationSetting('email', true);
 	
-		return $user->getGUID();
-	}
-
-	/**
-	 * Generates a unique invite code for a user
-	 *
-	 * @param string $username The username of the user sending the invitation
-	 *
-	 * @return string Invite code
-	 * @see validateInviteCode
-	 */
-	public function generateInviteCode($username) {
-		$time = $this->getCurrentTime()->getTimestamp();
-		return "$time." . _elgg_services()->hmac->getHmac([(int) $time, $username])->getToken();
-	}
-
-	/**
-	 * Validate a user's invite code
-	 *
-	 * @param string $username The username
-	 * @param string $code     The invite code
-	 *
-	 * @return bool
-	 * @see generateInviteCode
-	 */
-	public function validateInviteCode($username, $code) {
-		// validate the format of the token created by ->generateInviteCode()
-		if (!preg_match('~^(\d+)\.([a-zA-Z0-9\-_]+)$~', $code, $m)) {
-			return false;
-		}
-		$time = $m[1];
-		$mac = $m[2];
-
-		return _elgg_services()->hmac->getHmac([(int) $time, $username])->matchesToken($mac);
-	}
-
-	/**
-	 * Set the validation status for a user.
-	 *
-	 * @param int    $user_guid The user's GUID
-	 * @param bool   $status    Validated (true) or unvalidated (false)
-	 * @param string $method    Optional method to say how a user was validated
-	 * @return bool
-	 */
-	public function setValidationStatus($user_guid, $status, $method = '') {
-		$user = get_user($user_guid);
-		if (!$user) {
-			return false;
-		}
-
-		$result1 = create_metadata($user->guid, 'validated', (int) $status);
-		$result2 = create_metadata($user->guid, 'validated_method', $method);
-		if ($result1 && $result2) {
-			if ((bool) $status) {
-				elgg_trigger_after_event('validate', 'user', $user);
-			} else {
-				elgg_trigger_after_event('invalidate', 'user', $user);
-			}
-			return true;
-		} else {
-			return false;
-		}
-	}
-
-	/**
-	 * Gets the validation status of a user.
-	 *
-	 * @param int $user_guid The user's GUID
-	 * @return bool|null Null means status was not set for this user.
-	 */
-	public function getValidationStatus($user_guid) {
-		$user = get_entity($user_guid);
-		if (!$user || !isset($user->validated)) {
-			return null;
-		}
-		return (bool) $user->validated;
-	}
-
-	/**
-	 * Sets the last action time of the given user to right now.
-	 *
-	 * @see _elgg_session_boot The session boot calls this at the beginning of every request
-	 *
-	 * @param ElggUser $user User entity
-	 * @return void
-	 */
-	public function setLastAction(ElggUser $user) {
-
-		$time = $this->getCurrentTime()->getTimestamp();
-
-		if ($user->last_action == $time) {
-			// no change required
-			return;
-		}
-
-		$query = "
+        return $user->getGUID();
+    }
+
+    /**
+     * Generates a unique invite code for a user
+     *
+     * @param string $username The username of the user sending the invitation
+     *
+     * @return string Invite code
+     * @see validateInviteCode
+     */
+    public function generateInviteCode($username) {
+        $time = $this->getCurrentTime()->getTimestamp();
+        return "$time." . _elgg_services()->hmac->getHmac([(int) $time, $username])->getToken();
+    }
+
+    /**
+     * Validate a user's invite code
+     *
+     * @param string $username The username
+     * @param string $code     The invite code
+     *
+     * @return bool
+     * @see generateInviteCode
+     */
+    public function validateInviteCode($username, $code) {
+        // validate the format of the token created by ->generateInviteCode()
+        if (!preg_match('~^(\d+)\.([a-zA-Z0-9\-_]+)$~', $code, $m)) {
+            return false;
+        }
+        $time = $m[1];
+        $mac = $m[2];
+
+        return _elgg_services()->hmac->getHmac([(int) $time, $username])->matchesToken($mac);
+    }
+
+    /**
+     * Set the validation status for a user.
+     *
+     * @param int    $user_guid The user's GUID
+     * @param bool   $status    Validated (true) or unvalidated (false)
+     * @param string $method    Optional method to say how a user was validated
+     * @return bool
+     */
+    public function setValidationStatus($user_guid, $status, $method = '') {
+        $user = get_user($user_guid);
+        if (!$user) {
+            return false;
+        }
+
+        $result1 = create_metadata($user->guid, 'validated', (int) $status);
+        $result2 = create_metadata($user->guid, 'validated_method', $method);
+        if ($result1 && $result2) {
+            if ((bool) $status) {
+                elgg_trigger_after_event('validate', 'user', $user);
+            } else {
+                elgg_trigger_after_event('invalidate', 'user', $user);
+            }
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * Gets the validation status of a user.
+     *
+     * @param int $user_guid The user's GUID
+     * @return bool|null Null means status was not set for this user.
+     */
+    public function getValidationStatus($user_guid) {
+        $user = get_entity($user_guid);
+        if (!$user || !isset($user->validated)) {
+            return null;
+        }
+        return (bool) $user->validated;
+    }
+
+    /**
+     * Sets the last action time of the given user to right now.
+     *
+     * @see _elgg_session_boot The session boot calls this at the beginning of every request
+     *
+     * @param ElggUser $user User entity
+     * @return void
+     */
+    public function setLastAction(ElggUser $user) {
+
+        $time = $this->getCurrentTime()->getTimestamp();
+
+        if ($user->last_action == $time) {
+            // no change required
+            return;
+        }
+
+        $query = "
 			UPDATE {$this->table}
 			SET
 				prev_last_action = last_action,
@@ -540,44 +540,44 @@ 
 			WHERE guid = :guid
 		";
 
-		$params = [
-			':last_action' => $time,
-			':guid' => (int) $user->guid,
-		];
+        $params = [
+            ':last_action' => $time,
+            ':guid' => (int) $user->guid,
+        ];
 
-		// these writes actually work, we just type hint read-only.
-		$user->prev_last_action = $user->last_action;
-		$user->last_action = $time;
+        // these writes actually work, we just type hint read-only.
+        $user->prev_last_action = $user->last_action;
+        $user->last_action = $time;
 
-		execute_delayed_write_query($query, null, $params);
+        execute_delayed_write_query($query, null, $params);
 
-		$this->entity_cache->set($user);
+        $this->entity_cache->set($user);
 
-		// If we save the user to memcache during this request, then we'll end up with the
-		// old (incorrect) attributes cached (notice the above query is delayed). So it's
-		// simplest to just resave the user after all plugin code runs.
-		register_shutdown_function(function () use ($user, $time) {
-			$this->entities->updateLastAction($user, $time); // keep entity table in sync
-			$user->storeInPersistedCache(_elgg_get_memcache('new_entity_cache'), $time);
-		});
-	}
+        // If we save the user to memcache during this request, then we'll end up with the
+        // old (incorrect) attributes cached (notice the above query is delayed). So it's
+        // simplest to just resave the user after all plugin code runs.
+        register_shutdown_function(function () use ($user, $time) {
+            $this->entities->updateLastAction($user, $time); // keep entity table in sync
+            $user->storeInPersistedCache(_elgg_get_memcache('new_entity_cache'), $time);
+        });
+    }
 
-	/**
-	 * Sets the last logon time of the given user to right now.
-	 *
-	 * @param ElggUser $user User entity
-	 * @return void
-	 */
-	public function setLastLogin(ElggUser $user) {
+    /**
+     * Sets the last logon time of the given user to right now.
+     *
+     * @param ElggUser $user User entity
+     * @return void
+     */
+    public function setLastLogin(ElggUser $user) {
 
-		$time = $this->getCurrentTime()->getTimestamp();
+        $time = $this->getCurrentTime()->getTimestamp();
 
-		if ($user->last_login == $time) {
-			// no change required
-			return;
-		}
+        if ($user->last_login == $time) {
+            // no change required
+            return;
+        }
 
-		$query = "
+        $query = "
 			UPDATE {$this->table}
 			SET
 				prev_last_login = last_login,
@@ -585,24 +585,24 @@ 
 			WHERE guid = :guid
 		";
 
-		$params = [
-			':last_login' => $time,
-			':guid' => (int) $user->guid,
-		];
+        $params = [
+            ':last_login' => $time,
+            ':guid' => (int) $user->guid,
+        ];
 
-		// these writes actually work, we just type hint read-only.
-		$user->prev_last_login = $user->last_login;
-		$user->last_login = $time;
+        // these writes actually work, we just type hint read-only.
+        $user->prev_last_login = $user->last_login;
+        $user->last_login = $time;
 
-		execute_delayed_write_query($query, null, $params);
+        execute_delayed_write_query($query, null, $params);
 
-		$this->entity_cache->set($user);
+        $this->entity_cache->set($user);
 
-		// If we save the user to memcache during this request, then we'll end up with the
-		// old (incorrect) attributes cached. Hence we want to invalidate as late as possible.
-		// the user object gets saved
-		register_shutdown_function(function () use ($user) {
-			$user->storeInPersistedCache(_elgg_get_memcache('new_entity_cache'));
-		});
-	}
+        // If we save the user to memcache during this request, then we'll end up with the
+        // old (incorrect) attributes cached. Hence we want to invalidate as late as possible.
+        // the user object gets saved
+        register_shutdown_function(function () use ($user) {
+            $user->storeInPersistedCache(_elgg_get_memcache('new_entity_cache'));
+        });
+    }
 }

engine/classes/Elgg/Database/Plugins.php

Spacing +7 added lines, -7 removed lines

@@ -93,7 +93,7 @@ 
 		if ($handle) {
 			while ($plugin_dir = readdir($handle)) {
 				// must be directory and not begin with a .
-				if (substr($plugin_dir, 0, 1) !== '.' && is_dir($dir . $plugin_dir)) {
+				if (substr($plugin_dir, 0, 1) !== '.' && is_dir($dir.$plugin_dir)) {
 					$plugin_dirs[] = $plugin_dir;
 				}
 			}
@@ -176,7 +176,7 @@ 
 			} else {
 				// create new plugin
 				// priority is forced to last in save() if not set.
-				$plugin = new \ElggPlugin($mod_dir . $plugin_id);
+				$plugin = new \ElggPlugin($mod_dir.$plugin_id);
 				$plugin->save();
 			}
 		}
@@ -223,7 +223,7 @@ 
 	 * @return \ElggPlugin|null
 	 */
 	function get($plugin_id) {
-		return $this->plugins_by_id->get($plugin_id, function () use ($plugin_id) {
+		return $this->plugins_by_id->get($plugin_id, function() use ($plugin_id) {
 			$plugin_id = sanitize_string($plugin_id);
 			$db_prefix = _elgg_config()->dbprefix;
 
@@ -451,7 +451,7 @@ 
 		$plugins = elgg_get_entities_from_relationship($options);
 		elgg_set_ignore_access($old_ia);
 
-		usort($plugins, function (\ElggPlugin $a, \ElggPlugin $b) {
+		usort($plugins, function(\ElggPlugin $a, \ElggPlugin $b) {
 			$a_value = $a->getVolatileData('select:value');
 			$b_value = $b->getVolatileData('select:value');
 
@@ -563,11 +563,11 @@ 
 				if (!$id) {
 					throw new \InvalidArgumentException("You must pass the plugin id for user settings");
 				}
-				$name = ELGG_PLUGIN_USER_SETTING_PREFIX . "$id:$name";
+				$name = ELGG_PLUGIN_USER_SETTING_PREFIX."$id:$name";
 				break;
 	
 			case 'internal':
-				$name = ELGG_PLUGIN_INTERNAL_PREFIX . $name;
+				$name = ELGG_PLUGIN_INTERNAL_PREFIX.$name;
 				break;
 		}
 	
@@ -746,7 +746,7 @@ 
 		'priority'	'before blog'		--		after	'move it'
 		*/
 		$strings = [];
-		$strings['type'] = $translator->translate('ElggPlugin:Dependencies:' . ucwords($dep_system));
+		$strings['type'] = $translator->translate('ElggPlugin:Dependencies:'.ucwords($dep_system));
 	
 		switch ($type) {
 			case 'elgg_release':

Indentation +958 added lines, -958 removed lines

@@ -16,713 +16,713 @@ 
  * @since 1.10.0
  */
 class Plugins {
-	use Profilable;
+    use Profilable;
 
-	/**
-	 * @var \ElggPlugin[]
-	 */
-	private $boot_plugins = [];
+    /**
+     * @var \ElggPlugin[]
+     */
+    private $boot_plugins = [];
 
-	/**
-	 * @var array|null
-	 */
-	private $provides_cache;
+    /**
+     * @var array|null
+     */
+    private $provides_cache;
 
-	/**
-	 * @var string[] Active plugins, with plugin ID => GUID. Missing keys imply inactive plugins.
-	 */
-	private $active_guids = [];
+    /**
+     * @var string[] Active plugins, with plugin ID => GUID. Missing keys imply inactive plugins.
+     */
+    private $active_guids = [];
 
-	/**
-	 * @var bool Has $active_guids been populated?
-	 */
-	private $active_guids_known = false;
+    /**
+     * @var bool Has $active_guids been populated?
+     */
+    private $active_guids_known = false;
 
-	/**
-	 * @var Pool
-	 */
-	private $plugins_by_id;
+    /**
+     * @var Pool
+     */
+    private $plugins_by_id;
 
-	/**
-	 * @var PluginSettingsCache
-	 */
-	private $settings_cache;
+    /**
+     * @var PluginSettingsCache
+     */
+    private $settings_cache;
 
-	/**
-	 * Constructor
-	 *
-	 * @param Pool                $pool  Cache for referencing plugins by ID
-	 * @param PluginSettingsCache $cache Plugin settings cache
-	 */
-	public function __construct(Pool $pool, PluginSettingsCache $cache) {
-		$this->plugins_by_id = $pool;
-		$this->settings_cache = $cache;
-	}
+    /**
+     * Constructor
+     *
+     * @param Pool                $pool  Cache for referencing plugins by ID
+     * @param PluginSettingsCache $cache Plugin settings cache
+     */
+    public function __construct(Pool $pool, PluginSettingsCache $cache) {
+        $this->plugins_by_id = $pool;
+        $this->settings_cache = $cache;
+    }
 
-	/**
-	 * Set the list of active plugins according to the boot data cache
-	 *
-	 * @param \ElggPlugin[] $plugins Set of active plugins
-	 * @return void
-	 */
-	public function setBootPlugins(array $plugins) {
-		$this->boot_plugins = $plugins;
-		foreach ($plugins as $plugin) {
-			$this->plugins_by_id->put($plugin->getID(), $plugin);
-		}
-	}
+    /**
+     * Set the list of active plugins according to the boot data cache
+     *
+     * @param \ElggPlugin[] $plugins Set of active plugins
+     * @return void
+     */
+    public function setBootPlugins(array $plugins) {
+        $this->boot_plugins = $plugins;
+        foreach ($plugins as $plugin) {
+            $this->plugins_by_id->put($plugin->getID(), $plugin);
+        }
+    }
 
-	/**
-	 * Returns a list of plugin directory names from a base directory.
-	 *
-	 * @param string $dir A dir to scan for plugins. Defaults to config's plugins_path.
-	 *                    Must have a trailing slash.
-	 *
-	 * @return array Array of directory names (not full paths)
-	 * @access private
-	 */
-	function getDirsInDir($dir = null) {
-		if (!$dir) {
-			$dir = elgg_get_plugins_path();
-		}
-	
-		$plugin_dirs = [];
-		$handle = opendir($dir);
-	
-		if ($handle) {
-			while ($plugin_dir = readdir($handle)) {
-				// must be directory and not begin with a .
-				if (substr($plugin_dir, 0, 1) !== '.' && is_dir($dir . $plugin_dir)) {
-					$plugin_dirs[] = $plugin_dir;
-				}
-			}
-		}
-	
-		sort($plugin_dirs);
-	
-		return $plugin_dirs;
-	}
-	
-	/**
-	 * Discovers plugins in the plugins_path setting and creates \ElggPlugin
-	 * entities for them if they don't exist.  If there are plugins with entities
-	 * but not actual files, will disable the \ElggPlugin entities and mark as inactive.
-	 * The \ElggPlugin object holds config data, so don't delete.
-	 *
-	 * @return bool
-	 * @access private
-	 */
-	function generateEntities() {
-	
-		$mod_dir = elgg_get_plugins_path();
-		$db_prefix = _elgg_config()->dbprefix;
-	
-		// ignore access in case this is called with no admin logged in - needed for creating plugins perhaps?
-		$old_ia = elgg_set_ignore_access(true);
-	
-		// show hidden entities so that we can enable them if appropriate
-		$old_access = access_show_hidden_entities(true);
-	
-		$known_plugins = elgg_get_entities_from_relationship([
-			'type' => 'object',
-			'subtype' => 'plugin',
-			'selects' => ['plugin_oe.*'],
-			'joins' => ["JOIN {$db_prefix}objects_entity plugin_oe on plugin_oe.guid = e.guid"],
-			'limit' => ELGG_ENTITIES_NO_VALUE,
-		]);
-		/* @var \ElggPlugin[] $known_plugins */
-	
-		if (!$known_plugins) {
-			$known_plugins = [];
-		}
-	
-		// map paths to indexes
-		$id_map = [];
-		foreach ($known_plugins as $i => $plugin) {
-			// if the ID is wrong, delete the plugin because we can never load it.
-			$id = $plugin->getID();
-			if (!$id) {
-				$plugin->delete();
-				unset($known_plugins[$i]);
-				continue;
-			}
-			$id_map[$plugin->getID()] = $i;
-		}
-	
-		$physical_plugins = $this->getDirsInDir($mod_dir);
-		if (!$physical_plugins) {
-			return false;
-		}
-	
-		// check real plugins against known ones
-		foreach ($physical_plugins as $plugin_id) {
-			// is this already in the db?
-			if (array_key_exists($plugin_id, $id_map)) {
-				$index = $id_map[$plugin_id];
-				$plugin = $known_plugins[$index];
-				// was this plugin deleted and its entity disabled?
-				if (!$plugin->isEnabled()) {
-					$plugin->enable();
-					$plugin->deactivate();
-					$plugin->setPriority('last');
-				}
-	
-				// remove from the list of plugins to disable
-				unset($known_plugins[$index]);
-			} else {
-				// create new plugin
-				// priority is forced to last in save() if not set.
-				$plugin = new \ElggPlugin($mod_dir . $plugin_id);
-				$plugin->save();
-			}
-		}
-	
-		// everything remaining in $known_plugins needs to be disabled
-		// because they are entities, but their dirs were removed.
-		// don't delete the entities because they hold settings.
-		foreach ($known_plugins as $plugin) {
-			if ($plugin->isActive()) {
-				$plugin->deactivate();
-			}
-			// remove the priority.
-			$name = $this->namespacePrivateSetting('internal', 'priority');
-			remove_private_setting($plugin->guid, $name);
-			if ($plugin->isEnabled()) {
-				$plugin->disable();
-			}
-		}
-	
-		access_show_hidden_entities($old_access);
-		elgg_set_ignore_access($old_ia);
-	
-		return true;
-	}
-	
-	/**
-	 * Cache a reference to this plugin by its ID
-	 *
-	 * @param \ElggPlugin $plugin
-	 *
-	 * @access private
-	 */
-	function cache(\ElggPlugin $plugin) {
-		$this->plugins_by_id->put($plugin->getID(), $plugin);
-	}
-	
-	/**
-	 * Returns an \ElggPlugin object with the path $path.
-	 *
-	 * @param string $plugin_id The id (dir name) of the plugin. NOT the guid.
-	 * @return \ElggPlugin|null
-	 */
-	function get($plugin_id) {
-		return $this->plugins_by_id->get($plugin_id, function () use ($plugin_id) {
-			$plugin_id = sanitize_string($plugin_id);
-			$db_prefix = _elgg_config()->dbprefix;
+    /**
+     * Returns a list of plugin directory names from a base directory.
+     *
+     * @param string $dir A dir to scan for plugins. Defaults to config's plugins_path.
+     *                    Must have a trailing slash.
+     *
+     * @return array Array of directory names (not full paths)
+     * @access private
+     */
+    function getDirsInDir($dir = null) {
+        if (!$dir) {
+            $dir = elgg_get_plugins_path();
+        }
+	
+        $plugin_dirs = [];
+        $handle = opendir($dir);
+	
+        if ($handle) {
+            while ($plugin_dir = readdir($handle)) {
+                // must be directory and not begin with a .
+                if (substr($plugin_dir, 0, 1) !== '.' && is_dir($dir . $plugin_dir)) {
+                    $plugin_dirs[] = $plugin_dir;
+                }
+            }
+        }
+	
+        sort($plugin_dirs);
+	
+        return $plugin_dirs;
+    }
+	
+    /**
+     * Discovers plugins in the plugins_path setting and creates \ElggPlugin
+     * entities for them if they don't exist.  If there are plugins with entities
+     * but not actual files, will disable the \ElggPlugin entities and mark as inactive.
+     * The \ElggPlugin object holds config data, so don't delete.
+     *
+     * @return bool
+     * @access private
+     */
+    function generateEntities() {
+	
+        $mod_dir = elgg_get_plugins_path();
+        $db_prefix = _elgg_config()->dbprefix;
+	
+        // ignore access in case this is called with no admin logged in - needed for creating plugins perhaps?
+        $old_ia = elgg_set_ignore_access(true);
+	
+        // show hidden entities so that we can enable them if appropriate
+        $old_access = access_show_hidden_entities(true);
+	
+        $known_plugins = elgg_get_entities_from_relationship([
+            'type' => 'object',
+            'subtype' => 'plugin',
+            'selects' => ['plugin_oe.*'],
+            'joins' => ["JOIN {$db_prefix}objects_entity plugin_oe on plugin_oe.guid = e.guid"],
+            'limit' => ELGG_ENTITIES_NO_VALUE,
+        ]);
+        /* @var \ElggPlugin[] $known_plugins */
+	
+        if (!$known_plugins) {
+            $known_plugins = [];
+        }
+	
+        // map paths to indexes
+        $id_map = [];
+        foreach ($known_plugins as $i => $plugin) {
+            // if the ID is wrong, delete the plugin because we can never load it.
+            $id = $plugin->getID();
+            if (!$id) {
+                $plugin->delete();
+                unset($known_plugins[$i]);
+                continue;
+            }
+            $id_map[$plugin->getID()] = $i;
+        }
+	
+        $physical_plugins = $this->getDirsInDir($mod_dir);
+        if (!$physical_plugins) {
+            return false;
+        }
+	
+        // check real plugins against known ones
+        foreach ($physical_plugins as $plugin_id) {
+            // is this already in the db?
+            if (array_key_exists($plugin_id, $id_map)) {
+                $index = $id_map[$plugin_id];
+                $plugin = $known_plugins[$index];
+                // was this plugin deleted and its entity disabled?
+                if (!$plugin->isEnabled()) {
+                    $plugin->enable();
+                    $plugin->deactivate();
+                    $plugin->setPriority('last');
+                }
+	
+                // remove from the list of plugins to disable
+                unset($known_plugins[$index]);
+            } else {
+                // create new plugin
+                // priority is forced to last in save() if not set.
+                $plugin = new \ElggPlugin($mod_dir . $plugin_id);
+                $plugin->save();
+            }
+        }
+	
+        // everything remaining in $known_plugins needs to be disabled
+        // because they are entities, but their dirs were removed.
+        // don't delete the entities because they hold settings.
+        foreach ($known_plugins as $plugin) {
+            if ($plugin->isActive()) {
+                $plugin->deactivate();
+            }
+            // remove the priority.
+            $name = $this->namespacePrivateSetting('internal', 'priority');
+            remove_private_setting($plugin->guid, $name);
+            if ($plugin->isEnabled()) {
+                $plugin->disable();
+            }
+        }
+	
+        access_show_hidden_entities($old_access);
+        elgg_set_ignore_access($old_ia);
+	
+        return true;
+    }
+	
+    /**
+     * Cache a reference to this plugin by its ID
+     *
+     * @param \ElggPlugin $plugin
+     *
+     * @access private
+     */
+    function cache(\ElggPlugin $plugin) {
+        $this->plugins_by_id->put($plugin->getID(), $plugin);
+    }
+	
+    /**
+     * Returns an \ElggPlugin object with the path $path.
+     *
+     * @param string $plugin_id The id (dir name) of the plugin. NOT the guid.
+     * @return \ElggPlugin|null
+     */
+    function get($plugin_id) {
+        return $this->plugins_by_id->get($plugin_id, function () use ($plugin_id) {
+            $plugin_id = sanitize_string($plugin_id);
+            $db_prefix = _elgg_config()->dbprefix;
 
-			$options = [
-				'type' => 'object',
-				'subtype' => 'plugin',
-				'joins' => ["JOIN {$db_prefix}objects_entity oe on oe.guid = e.guid"],
-				'selects' => ["oe.title", "oe.description"],
-				'wheres' => ["oe.title = '$plugin_id'"],
-				'limit' => 1,
-				'distinct' => false,
-			];
+            $options = [
+                'type' => 'object',
+                'subtype' => 'plugin',
+                'joins' => ["JOIN {$db_prefix}objects_entity oe on oe.guid = e.guid"],
+                'selects' => ["oe.title", "oe.description"],
+                'wheres' => ["oe.title = '$plugin_id'"],
+                'limit' => 1,
+                'distinct' => false,
+            ];
 
-			$plugins = elgg_get_entities($options);
+            $plugins = elgg_get_entities($options);
 
-			if ($plugins) {
-				return $plugins[0];
-			}
+            if ($plugins) {
+                return $plugins[0];
+            }
 
-			return null;
-		});
-	}
-	
-	/**
-	 * Returns if a plugin exists in the system.
-	 *
-	 * @warning This checks only plugins that are registered in the system!
-	 * If the plugin cache is outdated, be sure to regenerate it with
-	 * {@link _elgg_generate_plugin_objects()} first.
-	 *
-	 * @param string $id The plugin ID.
-	 * @return bool
-	 */
-	function exists($id) {
-		return (bool) $this->get($id);
-	}
-	
-	/**
-	 * Returns the highest priority of the plugins
-	 *
-	 * @return int
-	 * @access private
-	 */
-	function getMaxPriority() {
-		$db_prefix = _elgg_config()->dbprefix;
-		$priority = $this->namespacePrivateSetting('internal', 'priority');
-		$plugin_subtype = get_subtype_id('object', 'plugin');
-	
-		$q = "SELECT MAX(CAST(ps.value AS unsigned)) as max
+            return null;
+        });
+    }
+	
+    /**
+     * Returns if a plugin exists in the system.
+     *
+     * @warning This checks only plugins that are registered in the system!
+     * If the plugin cache is outdated, be sure to regenerate it with
+     * {@link _elgg_generate_plugin_objects()} first.
+     *
+     * @param string $id The plugin ID.
+     * @return bool
+     */
+    function exists($id) {
+        return (bool) $this->get($id);
+    }
+	
+    /**
+     * Returns the highest priority of the plugins
+     *
+     * @return int
+     * @access private
+     */
+    function getMaxPriority() {
+        $db_prefix = _elgg_config()->dbprefix;
+        $priority = $this->namespacePrivateSetting('internal', 'priority');
+        $plugin_subtype = get_subtype_id('object', 'plugin');
+	
+        $q = "SELECT MAX(CAST(ps.value AS unsigned)) as max
 			FROM {$db_prefix}entities e, {$db_prefix}private_settings ps
 			WHERE ps.name = '$priority'
 			AND ps.entity_guid = e.guid
 			AND e.type = 'object' and e.subtype = $plugin_subtype";
 	
-		$data = get_data($q);
-		if ($data) {
-			$max = $data[0]->max;
-		} else {
-			$max = 1;
-		}
-	
-		// can't have a priority of 0.
-		return ($max) ? $max : 1;
-	}
-	
-	/**
-	 * Returns if a plugin is active for a current site.
-	 *
-	 * @param string $plugin_id The plugin ID
-	 * @return bool
-	 */
-	function isActive($plugin_id) {
-		if ($this->active_guids_known) {
-			return isset($this->active_guids[$plugin_id]);
-		}
+        $data = get_data($q);
+        if ($data) {
+            $max = $data[0]->max;
+        } else {
+            $max = 1;
+        }
+	
+        // can't have a priority of 0.
+        return ($max) ? $max : 1;
+    }
+	
+    /**
+     * Returns if a plugin is active for a current site.
+     *
+     * @param string $plugin_id The plugin ID
+     * @return bool
+     */
+    function isActive($plugin_id) {
+        if ($this->active_guids_known) {
+            return isset($this->active_guids[$plugin_id]);
+        }
 
-		$site = elgg_get_site_entity();
-	
-		if (!($site instanceof \ElggSite)) {
-			return false;
-		}
-	
-		$plugin = $this->get($plugin_id);
-	
-		if (!$plugin) {
-			return false;
-		}
-	
-		return $plugin->isActive($site->guid);
-	}
-	
-	/**
-	 * Loads all active plugins in the order specified in the tool admin panel.
-	 *
-	 * @note This is called on every page load. If a plugin is active and problematic, it
-	 * will be disabled and a visible error emitted. This does not check the deps system because
-	 * that was too slow.
-	 *
-	 * @return bool
-	 * @access private
-	 */
-	function load() {
-		if ($this->timer) {
-			$this->timer->begin([__METHOD__]);
-		}
+        $site = elgg_get_site_entity();
+	
+        if (!($site instanceof \ElggSite)) {
+            return false;
+        }
+	
+        $plugin = $this->get($plugin_id);
+	
+        if (!$plugin) {
+            return false;
+        }
+	
+        return $plugin->isActive($site->guid);
+    }
+	
+    /**
+     * Loads all active plugins in the order specified in the tool admin panel.
+     *
+     * @note This is called on every page load. If a plugin is active and problematic, it
+     * will be disabled and a visible error emitted. This does not check the deps system because
+     * that was too slow.
+     *
+     * @return bool
+     * @access private
+     */
+    function load() {
+        if ($this->timer) {
+            $this->timer->begin([__METHOD__]);
+        }
 
-		$plugins_path = elgg_get_plugins_path();
-		$start_flags = ELGG_PLUGIN_INCLUDE_START |
-						ELGG_PLUGIN_REGISTER_VIEWS |
-						ELGG_PLUGIN_REGISTER_ACTIONS |
-						ELGG_PLUGIN_REGISTER_LANGUAGES |
-						ELGG_PLUGIN_REGISTER_WIDGETS |
-						ELGG_PLUGIN_REGISTER_CLASSES;
-	
-		if (!$plugins_path) {
-			return false;
-		}
-	
-		// temporary disable all plugins if there is a file called 'disabled' in the plugin dir
-		if (file_exists("$plugins_path/disabled")) {
-			if (elgg_is_admin_logged_in() && elgg_in_context('admin')) {
-				system_message(_elgg_services()->translator->translate('plugins:disabled'));
-			}
-			return false;
-		}
+        $plugins_path = elgg_get_plugins_path();
+        $start_flags = ELGG_PLUGIN_INCLUDE_START |
+                        ELGG_PLUGIN_REGISTER_VIEWS |
+                        ELGG_PLUGIN_REGISTER_ACTIONS |
+                        ELGG_PLUGIN_REGISTER_LANGUAGES |
+                        ELGG_PLUGIN_REGISTER_WIDGETS |
+                        ELGG_PLUGIN_REGISTER_CLASSES;
+	
+        if (!$plugins_path) {
+            return false;
+        }
+	
+        // temporary disable all plugins if there is a file called 'disabled' in the plugin dir
+        if (file_exists("$plugins_path/disabled")) {
+            if (elgg_is_admin_logged_in() && elgg_in_context('admin')) {
+                system_message(_elgg_services()->translator->translate('plugins:disabled'));
+            }
+            return false;
+        }
 
-		$config = _elgg_config();
+        $config = _elgg_config();
 	
-		if ($config->system_cache_loaded) {
-			$start_flags = $start_flags & ~ELGG_PLUGIN_REGISTER_VIEWS;
-		}
+        if ($config->system_cache_loaded) {
+            $start_flags = $start_flags & ~ELGG_PLUGIN_REGISTER_VIEWS;
+        }
 	
-		if (!empty($GLOBALS['_ELGG']->i18n_loaded_from_cache)) {
-			$start_flags = $start_flags & ~ELGG_PLUGIN_REGISTER_LANGUAGES;
-		}
+        if (!empty($GLOBALS['_ELGG']->i18n_loaded_from_cache)) {
+            $start_flags = $start_flags & ~ELGG_PLUGIN_REGISTER_LANGUAGES;
+        }
 	
-		$plugins = $this->boot_plugins;
-		if (!$plugins) {
-			$this->active_guids_known = true;
-			return true;
-		}
+        $plugins = $this->boot_plugins;
+        if (!$plugins) {
+            $this->active_guids_known = true;
+            return true;
+        }
 
-		$return = true;
-		foreach ($plugins as $plugin) {
-			$id = $plugin->getID();
-			try {
-				$plugin->start($start_flags);
-				$this->active_guids[$id] = $plugin->guid;
-			} catch (Exception $e) {
-				$disable_plugins = _elgg_config()->auto_disable_plugins;
-				if ($disable_plugins === null) {
-					$disable_plugins = true;
-				}
-				if ($disable_plugins) {
-					$plugin->deactivate();
+        $return = true;
+        foreach ($plugins as $plugin) {
+            $id = $plugin->getID();
+            try {
+                $plugin->start($start_flags);
+                $this->active_guids[$id] = $plugin->guid;
+            } catch (Exception $e) {
+                $disable_plugins = _elgg_config()->auto_disable_plugins;
+                if ($disable_plugins === null) {
+                    $disable_plugins = true;
+                }
+                if ($disable_plugins) {
+                    $plugin->deactivate();
 				
-					$msg = _elgg_services()->translator->translate('PluginException:CannotStart',
-									[$id, $plugin->guid, $e->getMessage()]);
-					elgg_add_admin_notice("cannot_start $id", $msg);
-					$return = false;
-				}
-			}
-		}
+                    $msg = _elgg_services()->translator->translate('PluginException:CannotStart',
+                                    [$id, $plugin->guid, $e->getMessage()]);
+                    elgg_add_admin_notice("cannot_start $id", $msg);
+                    $return = false;
+                }
+            }
+        }
 
-		$this->active_guids_known = true;
+        $this->active_guids_known = true;
 
-		if ($this->timer) {
-			$this->timer->end([__METHOD__]);
-		}
-		return $return;
-	}
-	
-	/**
-	 * Returns an ordered list of plugins
-	 *
-	 * @param string $status The status of the plugins. active, inactive, or all.
-	 * @return \ElggPlugin[]
-	 */
-	function find($status = 'active') {
-		$db_prefix = elgg_get_config('dbprefix');
-		$priority = $this->namespacePrivateSetting('internal', 'priority');
-		$site_guid = 1;
+        if ($this->timer) {
+            $this->timer->end([__METHOD__]);
+        }
+        return $return;
+    }
+	
+    /**
+     * Returns an ordered list of plugins
+     *
+     * @param string $status The status of the plugins. active, inactive, or all.
+     * @return \ElggPlugin[]
+     */
+    function find($status = 'active') {
+        $db_prefix = elgg_get_config('dbprefix');
+        $priority = $this->namespacePrivateSetting('internal', 'priority');
+        $site_guid = 1;
 		
-		// grab plugins
-		$options = [
-			'type' => 'object',
-			'subtype' => 'plugin',
-			'limit' => ELGG_ENTITIES_NO_VALUE,
-			'selects' => ['plugin_oe.*', 'ps.value'],
-			'joins' => [
-				"JOIN {$db_prefix}private_settings ps on ps.entity_guid = e.guid",
-				"JOIN {$db_prefix}objects_entity plugin_oe on plugin_oe.guid = e.guid"
-				],
-			'wheres' => ["ps.name = '$priority'"],
-			// ORDER BY CAST(ps.value) is super slow. We usort() below.
-			'order_by' => false,
-			'distinct' => false,
-		];
-	
-		switch ($status) {
-			case 'active':
-				$options['relationship'] = 'active_plugin';
-				$options['relationship_guid'] = $site_guid;
-				$options['inverse_relationship'] = true;
-				break;
-	
-			case 'inactive':
-				$options['wheres'][] = "NOT EXISTS (
+        // grab plugins
+        $options = [
+            'type' => 'object',
+            'subtype' => 'plugin',
+            'limit' => ELGG_ENTITIES_NO_VALUE,
+            'selects' => ['plugin_oe.*', 'ps.value'],
+            'joins' => [
+                "JOIN {$db_prefix}private_settings ps on ps.entity_guid = e.guid",
+                "JOIN {$db_prefix}objects_entity plugin_oe on plugin_oe.guid = e.guid"
+                ],
+            'wheres' => ["ps.name = '$priority'"],
+            // ORDER BY CAST(ps.value) is super slow. We usort() below.
+            'order_by' => false,
+            'distinct' => false,
+        ];
+	
+        switch ($status) {
+            case 'active':
+                $options['relationship'] = 'active_plugin';
+                $options['relationship_guid'] = $site_guid;
+                $options['inverse_relationship'] = true;
+                break;
+	
+            case 'inactive':
+                $options['wheres'][] = "NOT EXISTS (
 						SELECT 1 FROM {$db_prefix}entity_relationships active_er
 						WHERE active_er.guid_one = e.guid
 							AND active_er.relationship = 'active_plugin'
 							AND active_er.guid_two = $site_guid)";
-				break;
+                break;
 	
-			case 'all':
-			default:
-				break;
-		}
+            case 'all':
+            default:
+                break;
+        }
 	
-		$old_ia = elgg_set_ignore_access(true);
-		$plugins = elgg_get_entities_from_relationship($options);
-		elgg_set_ignore_access($old_ia);
+        $old_ia = elgg_set_ignore_access(true);
+        $plugins = elgg_get_entities_from_relationship($options);
+        elgg_set_ignore_access($old_ia);
 
-		usort($plugins, function (\ElggPlugin $a, \ElggPlugin $b) {
-			$a_value = $a->getVolatileData('select:value');
-			$b_value = $b->getVolatileData('select:value');
+        usort($plugins, function (\ElggPlugin $a, \ElggPlugin $b) {
+            $a_value = $a->getVolatileData('select:value');
+            $b_value = $b->getVolatileData('select:value');
 
-			if ($b_value !== $a_value) {
-				return $a_value - $b_value;
-			} else {
-				return $a->guid - $b->guid;
-			}
-		});
-	
-		return $plugins;
-	}
-	
-	/**
-	 * Reorder plugins to an order specified by the array.
-	 * Plugins not included in this array will be appended to the end.
-	 *
-	 * @note This doesn't use the \ElggPlugin->setPriority() method because
-	 *       all plugins are being changed and we don't want it to automatically
-	 *       reorder plugins.
-	 * @todo Can this be done in a single sql command?
-	 *
-	 * @param array $order An array of plugin ids in the order to set them
-	 * @return bool
-	 * @access private
-	 */
-	function setPriorities(array $order) {
-		$name = $this->namespacePrivateSetting('internal', 'priority');
-	
-		$plugins = $this->find('any');
-		if (!$plugins) {
-			return false;
-		}
-	
-		// reindex to get standard counting. no need to increment by 10.
-		// though we do start with 1
-		$order = array_values($order);
-	
-		$missing_plugins = [];
-		/* @var \ElggPlugin[] $missing_plugins */
-	
-		$priority = 0;
-		foreach ($plugins as $plugin) {
-			$plugin_id = $plugin->getID();
-	
-			if (!in_array($plugin_id, $order)) {
-				$missing_plugins[] = $plugin;
-				continue;
-			}
-	
-			$priority = array_search($plugin_id, $order) + 1;
-	
-			if (!$plugin->setPrivateSetting($name, $priority)) {
-				return false;
-			}
-		}
-	
-		// set the missing plugins' priorities
-		if (empty($missing_plugins)) {
-			return true;
-		}
+            if ($b_value !== $a_value) {
+                return $a_value - $b_value;
+            } else {
+                return $a->guid - $b->guid;
+            }
+        });
+	
+        return $plugins;
+    }
+	
+    /**
+     * Reorder plugins to an order specified by the array.
+     * Plugins not included in this array will be appended to the end.
+     *
+     * @note This doesn't use the \ElggPlugin->setPriority() method because
+     *       all plugins are being changed and we don't want it to automatically
+     *       reorder plugins.
+     * @todo Can this be done in a single sql command?
+     *
+     * @param array $order An array of plugin ids in the order to set them
+     * @return bool
+     * @access private
+     */
+    function setPriorities(array $order) {
+        $name = $this->namespacePrivateSetting('internal', 'priority');
+	
+        $plugins = $this->find('any');
+        if (!$plugins) {
+            return false;
+        }
+	
+        // reindex to get standard counting. no need to increment by 10.
+        // though we do start with 1
+        $order = array_values($order);
+	
+        $missing_plugins = [];
+        /* @var \ElggPlugin[] $missing_plugins */
+	
+        $priority = 0;
+        foreach ($plugins as $plugin) {
+            $plugin_id = $plugin->getID();
+	
+            if (!in_array($plugin_id, $order)) {
+                $missing_plugins[] = $plugin;
+                continue;
+            }
+	
+            $priority = array_search($plugin_id, $order) + 1;
+	
+            if (!$plugin->setPrivateSetting($name, $priority)) {
+                return false;
+            }
+        }
+	
+        // set the missing plugins' priorities
+        if (empty($missing_plugins)) {
+            return true;
+        }
 		
-		foreach ($missing_plugins as $plugin) {
-			$priority++;
-			if (!$plugin->setPrivateSetting($name, $priority)) {
-				return false;
-			}
-		}
-	
-		return true;
-	}
-	
-	/**
-	 * Reindexes all plugin priorities starting at 1.
-	 *
-	 * @return bool
-	 * @access private
-	 */
-	function reindexPriorities() {
-		return $this->setPriorities([]);
-	}
-	
-	/**
-	 * Namespaces a string to be used as a private setting name for a plugin.
-	 *
-	 * For user_settings, two namespaces are added: a user setting namespace and the
-	 * plugin id.
-	 *
-	 * For internal (plugin priority), there is a single internal namespace added.
-	 *
-	 * @param string $type The type of setting: user_setting or internal.
-	 * @param string $name The name to namespace.
-	 * @param string $id   The plugin's ID to namespace with.  Required for user_setting.
-	 * @return string
-	 * @access private
-	 */
-	function namespacePrivateSetting($type, $name, $id = null) {
-		switch ($type) {
-			// commented out because it breaks $plugin->$name access to variables
-			//case 'setting':
-			//	$name = ELGG_PLUGIN_SETTING_PREFIX . $name;
-			//	break;
-	
-			case 'user_setting':
-				if (!$id) {
-					throw new \InvalidArgumentException("You must pass the plugin id for user settings");
-				}
-				$name = ELGG_PLUGIN_USER_SETTING_PREFIX . "$id:$name";
-				break;
-	
-			case 'internal':
-				$name = ELGG_PLUGIN_INTERNAL_PREFIX . $name;
-				break;
-		}
-	
-		return $name;
-	}
-	
-	
-	/**
-	 * Returns an array of all provides from all active plugins.
-	 *
-	 * Array in the form array(
-	 * 	'provide_type' => array(
-	 * 		'provided_name' => array(
-	 * 			'version' => '1.8',
-	 * 			'provided_by' => 'provider_plugin_id'
-	 *  	)
-	 *  )
-	 * )
-	 *
-	 * @param string $type The type of provides to return
-	 * @param string $name A specific provided name to return. Requires $provide_type.
-	 *
-	 * @return array
-	 * @access private
-	 */
-	function getProvides($type = null, $name = null) {
-		if ($this->provides_cache === null) {
-			$active_plugins = $this->find('active');
+        foreach ($missing_plugins as $plugin) {
+            $priority++;
+            if (!$plugin->setPrivateSetting($name, $priority)) {
+                return false;
+            }
+        }
+	
+        return true;
+    }
+	
+    /**
+     * Reindexes all plugin priorities starting at 1.
+     *
+     * @return bool
+     * @access private
+     */
+    function reindexPriorities() {
+        return $this->setPriorities([]);
+    }
+	
+    /**
+     * Namespaces a string to be used as a private setting name for a plugin.
+     *
+     * For user_settings, two namespaces are added: a user setting namespace and the
+     * plugin id.
+     *
+     * For internal (plugin priority), there is a single internal namespace added.
+     *
+     * @param string $type The type of setting: user_setting or internal.
+     * @param string $name The name to namespace.
+     * @param string $id   The plugin's ID to namespace with.  Required for user_setting.
+     * @return string
+     * @access private
+     */
+    function namespacePrivateSetting($type, $name, $id = null) {
+        switch ($type) {
+            // commented out because it breaks $plugin->$name access to variables
+            //case 'setting':
+            //	$name = ELGG_PLUGIN_SETTING_PREFIX . $name;
+            //	break;
+	
+            case 'user_setting':
+                if (!$id) {
+                    throw new \InvalidArgumentException("You must pass the plugin id for user settings");
+                }
+                $name = ELGG_PLUGIN_USER_SETTING_PREFIX . "$id:$name";
+                break;
+	
+            case 'internal':
+                $name = ELGG_PLUGIN_INTERNAL_PREFIX . $name;
+                break;
+        }
+	
+        return $name;
+    }
+	
+	
+    /**
+     * Returns an array of all provides from all active plugins.
+     *
+     * Array in the form array(
+     * 	'provide_type' => array(
+     * 		'provided_name' => array(
+     * 			'version' => '1.8',
+     * 			'provided_by' => 'provider_plugin_id'
+     *  	)
+     *  )
+     * )
+     *
+     * @param string $type The type of provides to return
+     * @param string $name A specific provided name to return. Requires $provide_type.
+     *
+     * @return array
+     * @access private
+     */
+    function getProvides($type = null, $name = null) {
+        if ($this->provides_cache === null) {
+            $active_plugins = $this->find('active');
 		
-			$provides = [];
-	
-			foreach ($active_plugins as $plugin) {
-				$plugin_provides = [];
-				$manifest = $plugin->getManifest();
-				if ($manifest instanceof \ElggPluginManifest) {
-					$plugin_provides = $plugin->getManifest()->getProvides();
-				}
-				if ($plugin_provides) {
-					foreach ($plugin_provides as $provided) {
-						$provides[$provided['type']][$provided['name']] = [
-							'version' => $provided['version'],
-							'provided_by' => $plugin->getID()
-						];
-					}
-				}
-			}
+            $provides = [];
+	
+            foreach ($active_plugins as $plugin) {
+                $plugin_provides = [];
+                $manifest = $plugin->getManifest();
+                if ($manifest instanceof \ElggPluginManifest) {
+                    $plugin_provides = $plugin->getManifest()->getProvides();
+                }
+                if ($plugin_provides) {
+                    foreach ($plugin_provides as $provided) {
+                        $provides[$provided['type']][$provided['name']] = [
+                            'version' => $provided['version'],
+                            'provided_by' => $plugin->getID()
+                        ];
+                    }
+                }
+            }
 			
-			$this->provides_cache = $provides;
-		}
+            $this->provides_cache = $provides;
+        }
 		
-		if ($type && $name) {
-			if (isset($this->provides_cache[$type][$name])) {
-				return $this->provides_cache[$type][$name];
-			} else {
-				return false;
-			}
-		} elseif ($type) {
-			if (isset($this->provides_cache[$type])) {
-				return $this->provides_cache[$type];
-			} else {
-				return false;
-			}
-		}
-	
-		return $this->provides_cache;
-	}
-	
-	/**
-	 * Deletes all cached data on plugins being provided.
-	 *
-	 * @return boolean
-	 * @access private
-	 */
-	function invalidateProvidesCache() {
-		$this->provides_cache = null;
-		return true;
-	}
+        if ($type && $name) {
+            if (isset($this->provides_cache[$type][$name])) {
+                return $this->provides_cache[$type][$name];
+            } else {
+                return false;
+            }
+        } elseif ($type) {
+            if (isset($this->provides_cache[$type])) {
+                return $this->provides_cache[$type];
+            } else {
+                return false;
+            }
+        }
+	
+        return $this->provides_cache;
+    }
+	
+    /**
+     * Deletes all cached data on plugins being provided.
+     *
+     * @return boolean
+     * @access private
+     */
+    function invalidateProvidesCache() {
+        $this->provides_cache = null;
+        return true;
+    }
 
-	/**
-	 * Delete the cache holding whether plugins are active or not
-	 *
-	 * @return void
-	 * @access private
-	 */
-	public function invalidateIsActiveCache() {
-		$this->active_guids = [];
-		$this->active_guids_known = false;
-	}
-	
-	/**
-	 * Checks if a plugin is currently providing $type and $name, and optionally
-	 * checking a version.
-	 *
-	 * @param string $type       The type of the provide
-	 * @param string $name       The name of the provide
-	 * @param string $version    A version to check against
-	 * @param string $comparison The comparison operator to use in version_compare()
-	 *
-	 * @return array An array in the form array(
-	 * 	'status' => bool Does the provide exist?,
-	 * 	'value' => string The version provided
-	 * )
-	 * @access private
-	 */
-	function checkProvides($type, $name, $version = null, $comparison = 'ge') {
-		$provided = $this->getProvides($type, $name);
-		if (!$provided) {
-			return [
-				'status' => false,
-				'value' => ''
-			];
-		}
-	
-		if ($version) {
-			$status = version_compare($provided['version'], $version, $comparison);
-		} else {
-			$status = true;
-		}
-	
-		return [
-			'status' => $status,
-			'value' => $provided['version']
-		];
-	}
-	
-	/**
-	 * Returns an array of parsed strings for a dependency in the
-	 * format: array(
-	 * 	'type'			=>	requires, conflicts, or provides.
-	 * 	'name'			=>	The name of the requirement / conflict
-	 * 	'value'			=>	A string representing the expected value: <1, >=3, !=enabled
-	 * 	'local_value'	=>	The current value, ("Not installed")
-	 * 	'comment'		=>	Free form text to help resovle the problem ("Enable / Search for plugin <link>")
-	 * )
-	 *
-	 * @param array $dep An \ElggPluginPackage dependency array
-	 * @return array
-	 * @access private
-	 */
-	function getDependencyStrings($dep) {
-		$translator = _elgg_services()->translator;
-		$dep_system = elgg_extract('type', $dep);
-		$info = elgg_extract('dep', $dep);
-		$type = elgg_extract('type', $info);
-	
-		if (!$dep_system || !$info || !$type) {
-			return false;
-		}
-	
-		// rewrite some of these to be more readable
-		$comparison = elgg_extract('comparison', $info);
-		switch ($comparison) {
-			case 'lt':
-				$comparison = '<';
-				break;
-			case 'gt':
-				$comparison = '>';
-				break;
-			case 'ge':
-				$comparison = '>=';
-				break;
-			case 'le':
-				$comparison = '<=';
-				break;
-			default:
-				//keep $comparison value intact
-				break;
-		}
-	
-		/*
+    /**
+     * Delete the cache holding whether plugins are active or not
+     *
+     * @return void
+     * @access private
+     */
+    public function invalidateIsActiveCache() {
+        $this->active_guids = [];
+        $this->active_guids_known = false;
+    }
+	
+    /**
+     * Checks if a plugin is currently providing $type and $name, and optionally
+     * checking a version.
+     *
+     * @param string $type       The type of the provide
+     * @param string $name       The name of the provide
+     * @param string $version    A version to check against
+     * @param string $comparison The comparison operator to use in version_compare()
+     *
+     * @return array An array in the form array(
+     * 	'status' => bool Does the provide exist?,
+     * 	'value' => string The version provided
+     * )
+     * @access private
+     */
+    function checkProvides($type, $name, $version = null, $comparison = 'ge') {
+        $provided = $this->getProvides($type, $name);
+        if (!$provided) {
+            return [
+                'status' => false,
+                'value' => ''
+            ];
+        }
+	
+        if ($version) {
+            $status = version_compare($provided['version'], $version, $comparison);
+        } else {
+            $status = true;
+        }
+	
+        return [
+            'status' => $status,
+            'value' => $provided['version']
+        ];
+    }
+	
+    /**
+     * Returns an array of parsed strings for a dependency in the
+     * format: array(
+     * 	'type'			=>	requires, conflicts, or provides.
+     * 	'name'			=>	The name of the requirement / conflict
+     * 	'value'			=>	A string representing the expected value: <1, >=3, !=enabled
+     * 	'local_value'	=>	The current value, ("Not installed")
+     * 	'comment'		=>	Free form text to help resovle the problem ("Enable / Search for plugin <link>")
+     * )
+     *
+     * @param array $dep An \ElggPluginPackage dependency array
+     * @return array
+     * @access private
+     */
+    function getDependencyStrings($dep) {
+        $translator = _elgg_services()->translator;
+        $dep_system = elgg_extract('type', $dep);
+        $info = elgg_extract('dep', $dep);
+        $type = elgg_extract('type', $info);
+	
+        if (!$dep_system || !$info || !$type) {
+            return false;
+        }
+	
+        // rewrite some of these to be more readable
+        $comparison = elgg_extract('comparison', $info);
+        switch ($comparison) {
+            case 'lt':
+                $comparison = '<';
+                break;
+            case 'gt':
+                $comparison = '>';
+                break;
+            case 'ge':
+                $comparison = '>=';
+                break;
+            case 'le':
+                $comparison = '<=';
+                break;
+            default:
+                //keep $comparison value intact
+                break;
+        }
+	
+        /*
 		'requires'	'plugin oauth_lib'	<1.3	1.3		'downgrade'
 		'requires'	'php setting bob'	>3		3		'change it'
 		'conflicts'	'php setting'		>3		4		'change it'
@@ -730,304 +730,304 @@ 
 		'provides'	'plugin oauth_lib'	1.3		--		--
 		'priority'	'before blog'		--		after	'move it'
 		*/
-		$strings = [];
-		$strings['type'] = $translator->translate('ElggPlugin:Dependencies:' . ucwords($dep_system));
-	
-		switch ($type) {
-			case 'elgg_release':
-				// 'Elgg Version'
-				$strings['name'] = $translator->translate('ElggPlugin:Dependencies:Elgg');
-				$strings['expected_value'] = "$comparison {$info['version']}";
-				$strings['local_value'] = $dep['value'];
-				$strings['comment'] = '';
-				break;
-	
-			case 'php_version':
-				// 'PHP version'
-				$strings['name'] = $translator->translate('ElggPlugin:Dependencies:PhpVersion');
-				$strings['expected_value'] = "$comparison {$info['version']}";
-				$strings['local_value'] = $dep['value'];
-				$strings['comment'] = '';
-				break;
+        $strings = [];
+        $strings['type'] = $translator->translate('ElggPlugin:Dependencies:' . ucwords($dep_system));
+	
+        switch ($type) {
+            case 'elgg_release':
+                // 'Elgg Version'
+                $strings['name'] = $translator->translate('ElggPlugin:Dependencies:Elgg');
+                $strings['expected_value'] = "$comparison {$info['version']}";
+                $strings['local_value'] = $dep['value'];
+                $strings['comment'] = '';
+                break;
+	
+            case 'php_version':
+                // 'PHP version'
+                $strings['name'] = $translator->translate('ElggPlugin:Dependencies:PhpVersion');
+                $strings['expected_value'] = "$comparison {$info['version']}";
+                $strings['local_value'] = $dep['value'];
+                $strings['comment'] = '';
+                break;
 			
-			case 'php_extension':
-				// PHP Extension %s [version]
-				$strings['name'] = $translator->translate('ElggPlugin:Dependencies:PhpExtension', [$info['name']]);
-				if ($info['version']) {
-					$strings['expected_value'] = "$comparison {$info['version']}";
-					$strings['local_value'] = $dep['value'];
-				} else {
-					$strings['expected_value'] = '';
-					$strings['local_value'] = '';
-				}
-				$strings['comment'] = '';
-				break;
-	
-			case 'php_ini':
-				$strings['name'] = $translator->translate('ElggPlugin:Dependencies:PhpIni', [$info['name']]);
-				$strings['expected_value'] = "$comparison {$info['value']}";
-				$strings['local_value'] = $dep['value'];
-				$strings['comment'] = '';
-				break;
-	
-			case 'plugin':
-				$strings['name'] = $translator->translate('ElggPlugin:Dependencies:Plugin', [$info['name']]);
-				$expected = $info['version'] ? "$comparison {$info['version']}" : $translator->translate('any');
-				$strings['expected_value'] = $expected;
-				$strings['local_value'] = $dep['value'] ? $dep['value'] : '--';
-				$strings['comment'] = '';
-				break;
-	
-			case 'priority':
-				$expected_priority = ucwords($info['priority']);
-				$real_priority = ucwords($dep['value']);
-				$strings['name'] = $translator->translate('ElggPlugin:Dependencies:Priority');
-				$strings['expected_value'] = $translator->translate("ElggPlugin:Dependencies:Priority:$expected_priority", [$info['plugin']]);
-				$strings['local_value'] = $translator->translate("ElggPlugin:Dependencies:Priority:$real_priority", [$info['plugin']]);
-				$strings['comment'] = '';
-				break;
-		}
-	
-		if ($dep['type'] == 'suggests') {
-			if ($dep['status']) {
-				$strings['comment'] = $translator->translate('ok');
-			} else {
-				$strings['comment'] = $translator->translate('ElggPlugin:Dependencies:Suggests:Unsatisfied');
-			}
-		} else {
-			if ($dep['status']) {
-				$strings['comment'] = $translator->translate('ok');
-			} else {
-				$strings['comment'] = $translator->translate('error');
-			}
-		}
-	
-		return $strings;
-	}
-	
-	/**
-	 * Returns an array of all plugin user settings for a user.
-	 *
-	 * @param int    $user_guid  The user GUID or 0 for the currently logged in user.
-	 * @param string $plugin_id  The plugin ID (Required)
-	 * @param bool   $return_obj Return settings as an object? This can be used to in reusable
-	 *                           views where the settings are passed as $vars['entity'].
-	 * @return array
-	 * @see \ElggPlugin::getAllUserSettings()
-	 */
-	function getAllUserSettings($user_guid = 0, $plugin_id = null, $return_obj = false) {
-		$plugin = $this->get($plugin_id);
-		if (!$plugin) {
-			return false;
-		}
-	
-		$settings = $plugin->getAllUserSettings((int) $user_guid);
-	
-		if ($settings && $return_obj) {
-			$return = new \stdClass;
-	
-			foreach ($settings as $k => $v) {
-				$return->$k = $v;
-			}
-	
-			return $return;
-		} else {
-			return $settings;
-		}
-	}
-	
-	/**
-	 * Set a user specific setting for a plugin.
-	 *
-	 * @param string $name      The name. Note: cannot be "title".
-	 * @param mixed  $value     The value.
-	 * @param int    $user_guid The user GUID or 0 for the currently logged in user.
-	 * @param string $plugin_id The plugin ID (Required)
-	 *
-	 * @return bool
-	 * @see \ElggPlugin::setUserSetting()
-	 */
-	function setUserSetting($name, $value, $user_guid = 0, $plugin_id = null) {
-		$plugin = $this->get($plugin_id);
-		if (!$plugin) {
-			return false;
-		}
+            case 'php_extension':
+                // PHP Extension %s [version]
+                $strings['name'] = $translator->translate('ElggPlugin:Dependencies:PhpExtension', [$info['name']]);
+                if ($info['version']) {
+                    $strings['expected_value'] = "$comparison {$info['version']}";
+                    $strings['local_value'] = $dep['value'];
+                } else {
+                    $strings['expected_value'] = '';
+                    $strings['local_value'] = '';
+                }
+                $strings['comment'] = '';
+                break;
+	
+            case 'php_ini':
+                $strings['name'] = $translator->translate('ElggPlugin:Dependencies:PhpIni', [$info['name']]);
+                $strings['expected_value'] = "$comparison {$info['value']}";
+                $strings['local_value'] = $dep['value'];
+                $strings['comment'] = '';
+                break;
+	
+            case 'plugin':
+                $strings['name'] = $translator->translate('ElggPlugin:Dependencies:Plugin', [$info['name']]);
+                $expected = $info['version'] ? "$comparison {$info['version']}" : $translator->translate('any');
+                $strings['expected_value'] = $expected;
+                $strings['local_value'] = $dep['value'] ? $dep['value'] : '--';
+                $strings['comment'] = '';
+                break;
+	
+            case 'priority':
+                $expected_priority = ucwords($info['priority']);
+                $real_priority = ucwords($dep['value']);
+                $strings['name'] = $translator->translate('ElggPlugin:Dependencies:Priority');
+                $strings['expected_value'] = $translator->translate("ElggPlugin:Dependencies:Priority:$expected_priority", [$info['plugin']]);
+                $strings['local_value'] = $translator->translate("ElggPlugin:Dependencies:Priority:$real_priority", [$info['plugin']]);
+                $strings['comment'] = '';
+                break;
+        }
+	
+        if ($dep['type'] == 'suggests') {
+            if ($dep['status']) {
+                $strings['comment'] = $translator->translate('ok');
+            } else {
+                $strings['comment'] = $translator->translate('ElggPlugin:Dependencies:Suggests:Unsatisfied');
+            }
+        } else {
+            if ($dep['status']) {
+                $strings['comment'] = $translator->translate('ok');
+            } else {
+                $strings['comment'] = $translator->translate('error');
+            }
+        }
+	
+        return $strings;
+    }
+	
+    /**
+     * Returns an array of all plugin user settings for a user.
+     *
+     * @param int    $user_guid  The user GUID or 0 for the currently logged in user.
+     * @param string $plugin_id  The plugin ID (Required)
+     * @param bool   $return_obj Return settings as an object? This can be used to in reusable
+     *                           views where the settings are passed as $vars['entity'].
+     * @return array
+     * @see \ElggPlugin::getAllUserSettings()
+     */
+    function getAllUserSettings($user_guid = 0, $plugin_id = null, $return_obj = false) {
+        $plugin = $this->get($plugin_id);
+        if (!$plugin) {
+            return false;
+        }
+	
+        $settings = $plugin->getAllUserSettings((int) $user_guid);
+	
+        if ($settings && $return_obj) {
+            $return = new \stdClass;
+	
+            foreach ($settings as $k => $v) {
+                $return->$k = $v;
+            }
+	
+            return $return;
+        } else {
+            return $settings;
+        }
+    }
+	
+    /**
+     * Set a user specific setting for a plugin.
+     *
+     * @param string $name      The name. Note: cannot be "title".
+     * @param mixed  $value     The value.
+     * @param int    $user_guid The user GUID or 0 for the currently logged in user.
+     * @param string $plugin_id The plugin ID (Required)
+     *
+     * @return bool
+     * @see \ElggPlugin::setUserSetting()
+     */
+    function setUserSetting($name, $value, $user_guid = 0, $plugin_id = null) {
+        $plugin = $this->get($plugin_id);
+        if (!$plugin) {
+            return false;
+        }
 
-		return $plugin->setUserSetting($name, $value, (int) $user_guid);
-	}
-	
-	/**
-	 * Unsets a user-specific plugin setting
-	 *
-	 * @param string $name      Name of the setting
-	 * @param int    $user_guid The user GUID or 0 for the currently logged in user.
-	 * @param string $plugin_id The plugin ID (Required)
-	 *
-	 * @return bool
-	 * @see \ElggPlugin::unsetUserSetting()
-	 */
-	function unsetUserSetting($name, $user_guid = 0, $plugin_id = null) {
-		$plugin = $this->get($plugin_id);
-		if (!$plugin) {
-			return false;
-		}
+        return $plugin->setUserSetting($name, $value, (int) $user_guid);
+    }
+	
+    /**
+     * Unsets a user-specific plugin setting
+     *
+     * @param string $name      Name of the setting
+     * @param int    $user_guid The user GUID or 0 for the currently logged in user.
+     * @param string $plugin_id The plugin ID (Required)
+     *
+     * @return bool
+     * @see \ElggPlugin::unsetUserSetting()
+     */
+    function unsetUserSetting($name, $user_guid = 0, $plugin_id = null) {
+        $plugin = $this->get($plugin_id);
+        if (!$plugin) {
+            return false;
+        }
 
-		return $plugin->unsetUserSetting($name, (int) $user_guid);
-	}
-	
-	/**
-	 * Get a user specific setting for a plugin.
-	 *
-	 * @param string $name      The name of the setting.
-	 * @param int    $user_guid The user GUID or 0 for the currently logged in user.
-	 * @param string $plugin_id The plugin ID (Required)
-	 * @param mixed  $default   The default value to return if none is set
-	 *
-	 * @return mixed
-	 * @see \ElggPlugin::getUserSetting()
-	 */
-	function getUserSetting($name, $user_guid = 0, $plugin_id = null, $default = null) {
-		$plugin = $this->get($plugin_id);
-		if (!$plugin) {
-			return false;
-		}
+        return $plugin->unsetUserSetting($name, (int) $user_guid);
+    }
+	
+    /**
+     * Get a user specific setting for a plugin.
+     *
+     * @param string $name      The name of the setting.
+     * @param int    $user_guid The user GUID or 0 for the currently logged in user.
+     * @param string $plugin_id The plugin ID (Required)
+     * @param mixed  $default   The default value to return if none is set
+     *
+     * @return mixed
+     * @see \ElggPlugin::getUserSetting()
+     */
+    function getUserSetting($name, $user_guid = 0, $plugin_id = null, $default = null) {
+        $plugin = $this->get($plugin_id);
+        if (!$plugin) {
+            return false;
+        }
 
-		return $plugin->getUserSetting($name, (int) $user_guid, $default);
-	}
-	
-	/**
-	 * Set a setting for a plugin.
-	 *
-	 * @param string $name      The name of the setting - note, can't be "title".
-	 * @param mixed  $value     The value.
-	 * @param string $plugin_id The plugin ID (Required)
-	 *
-	 * @return bool
-	 * @see \ElggPlugin::setSetting()
-	 */
-	function setSetting($name, $value, $plugin_id) {
-		$plugin = $this->get($plugin_id);
-		if (!$plugin) {
-			return false;
-		}
+        return $plugin->getUserSetting($name, (int) $user_guid, $default);
+    }
+	
+    /**
+     * Set a setting for a plugin.
+     *
+     * @param string $name      The name of the setting - note, can't be "title".
+     * @param mixed  $value     The value.
+     * @param string $plugin_id The plugin ID (Required)
+     *
+     * @return bool
+     * @see \ElggPlugin::setSetting()
+     */
+    function setSetting($name, $value, $plugin_id) {
+        $plugin = $this->get($plugin_id);
+        if (!$plugin) {
+            return false;
+        }
 
-		return $plugin->setSetting($name, $value);
-	}
-	
-	/**
-	 * Get setting for a plugin.
-	 *
-	 * @param string $name      The name of the setting.
-	 * @param string $plugin_id The plugin ID (Required)
-	 * @param mixed  $default   The default value to return if none is set
-	 *
-	 * @return mixed
-	 * @see \ElggPlugin::getSetting()
-	 */
-	function getSetting($name, $plugin_id, $default = null) {
-		$plugin = $this->get($plugin_id);
-		if (!$plugin) {
-			return false;
-		}
+        return $plugin->setSetting($name, $value);
+    }
+	
+    /**
+     * Get setting for a plugin.
+     *
+     * @param string $name      The name of the setting.
+     * @param string $plugin_id The plugin ID (Required)
+     * @param mixed  $default   The default value to return if none is set
+     *
+     * @return mixed
+     * @see \ElggPlugin::getSetting()
+     */
+    function getSetting($name, $plugin_id, $default = null) {
+        $plugin = $this->get($plugin_id);
+        if (!$plugin) {
+            return false;
+        }
 
-		return $plugin->getSetting($name, $default);
-	}
-	
-	/**
-	 * Unsets a plugin setting.
-	 *
-	 * @param string $name      The name of the setting.
-	 * @param string $plugin_id The plugin ID (Required)
-	 *
-	 * @return bool
-	 * @see \ElggPlugin::unsetSetting()
-	 */
-	function unsetSetting($name, $plugin_id) {
-		$plugin = $this->get($plugin_id);
-		if (!$plugin) {
-			return false;
-		}
+        return $plugin->getSetting($name, $default);
+    }
+	
+    /**
+     * Unsets a plugin setting.
+     *
+     * @param string $name      The name of the setting.
+     * @param string $plugin_id The plugin ID (Required)
+     *
+     * @return bool
+     * @see \ElggPlugin::unsetSetting()
+     */
+    function unsetSetting($name, $plugin_id) {
+        $plugin = $this->get($plugin_id);
+        if (!$plugin) {
+            return false;
+        }
 
-		return $plugin->unsetSetting($name);
-	}
-	
-	/**
-	 * Unsets all plugin settings for a plugin.
-	 *
-	 * @param string $plugin_id The plugin ID (Required)
-	 *
-	 * @return bool
-	 * @see \ElggPlugin::unsetAllSettings()
-	 */
-	function unsetAllSettings($plugin_id) {
-		$plugin = $this->get($plugin_id);
-		if (!$plugin) {
-			return false;
-		}
-	
-		return $plugin->unsetAllSettings();
-	}
-	
-	/**
-	 * Returns entities based upon plugin user settings.
-	 * Takes all the options for {@link elgg_get_entities_from_private_settings()}
-	 * in addition to the ones below.
-	 *
-	 * @param array $options Array in the format:
-	 *
-	 * 	plugin_id => STR The plugin id. Required.
-	 *
-	 * 	plugin_user_setting_names => null|ARR private setting names
-	 *
-	 * 	plugin_user_setting_values => null|ARR metadata values
-	 *
-	 * 	plugin_user_setting_name_value_pairs => null|ARR (
-	 *                                         name => 'name',
-	 *                                         value => 'value',
-	 *                                         'operand' => '=',
-	 *                                        )
-	 * 	                             Currently if multiple values are sent via
-	 *                               an array (value => array('value1', 'value2')
-	 *                               the pair's operand will be forced to "IN".
-	 *
-	 * 	plugin_user_setting_name_value_pairs_operator => null|STR The operator to use for combining
-	 *                                        (name = value) OPERATOR (name = value); default AND
-	 *
-	 * @return mixed int If count, int. If not count, array. false on errors.
-	 */
-	function getEntitiesFromUserSettings(array $options = []) {
-		$singulars = ['plugin_user_setting_name', 'plugin_user_setting_value',
-			'plugin_user_setting_name_value_pair'];
-	
-		$options = _elgg_normalize_plural_options_array($options, $singulars);
-	
-		// rewrite plugin_user_setting_name_* to the right PS ones.
-		$map = [
-			'plugin_user_setting_names' => 'private_setting_names',
-			'plugin_user_setting_values' => 'private_setting_values',
-			'plugin_user_setting_name_value_pairs' => 'private_setting_name_value_pairs',
-			'plugin_user_setting_name_value_pairs_operator' => 'private_setting_name_value_pairs_operator',
-		];
-	
-		foreach ($map as $plugin => $private) {
-			if (!isset($options[$plugin])) {
-				continue;
-			}
-	
-			if (isset($options[$private])) {
-				if (!is_array($options[$private])) {
-					$options[$private] = [$options[$private]];
-				}
-	
-				$options[$private] = array_merge($options[$private], $options[$plugin]);
-			} else {
-				$options[$private] = $options[$plugin];
-			}
-		}
-	
-		$prefix = $this->namespacePrivateSetting('user_setting', '', $options['plugin_id']);
-		$options['private_setting_name_prefix'] = $prefix;
-	
-		return elgg_get_entities_from_private_settings($options);
-	}
+        return $plugin->unsetSetting($name);
+    }
+	
+    /**
+     * Unsets all plugin settings for a plugin.
+     *
+     * @param string $plugin_id The plugin ID (Required)
+     *
+     * @return bool
+     * @see \ElggPlugin::unsetAllSettings()
+     */
+    function unsetAllSettings($plugin_id) {
+        $plugin = $this->get($plugin_id);
+        if (!$plugin) {
+            return false;
+        }
+	
+        return $plugin->unsetAllSettings();
+    }
+	
+    /**
+     * Returns entities based upon plugin user settings.
+     * Takes all the options for {@link elgg_get_entities_from_private_settings()}
+     * in addition to the ones below.
+     *
+     * @param array $options Array in the format:
+     *
+     * 	plugin_id => STR The plugin id. Required.
+     *
+     * 	plugin_user_setting_names => null|ARR private setting names
+     *
+     * 	plugin_user_setting_values => null|ARR metadata values
+     *
+     * 	plugin_user_setting_name_value_pairs => null|ARR (
+     *                                         name => 'name',
+     *                                         value => 'value',
+     *                                         'operand' => '=',
+     *                                        )
+     * 	                             Currently if multiple values are sent via
+     *                               an array (value => array('value1', 'value2')
+     *                               the pair's operand will be forced to "IN".
+     *
+     * 	plugin_user_setting_name_value_pairs_operator => null|STR The operator to use for combining
+     *                                        (name = value) OPERATOR (name = value); default AND
+     *
+     * @return mixed int If count, int. If not count, array. false on errors.
+     */
+    function getEntitiesFromUserSettings(array $options = []) {
+        $singulars = ['plugin_user_setting_name', 'plugin_user_setting_value',
+            'plugin_user_setting_name_value_pair'];
+	
+        $options = _elgg_normalize_plural_options_array($options, $singulars);
+	
+        // rewrite plugin_user_setting_name_* to the right PS ones.
+        $map = [
+            'plugin_user_setting_names' => 'private_setting_names',
+            'plugin_user_setting_values' => 'private_setting_values',
+            'plugin_user_setting_name_value_pairs' => 'private_setting_name_value_pairs',
+            'plugin_user_setting_name_value_pairs_operator' => 'private_setting_name_value_pairs_operator',
+        ];
+	
+        foreach ($map as $plugin => $private) {
+            if (!isset($options[$plugin])) {
+                continue;
+            }
+	
+            if (isset($options[$private])) {
+                if (!is_array($options[$private])) {
+                    $options[$private] = [$options[$private]];
+                }
+	
+                $options[$private] = array_merge($options[$private], $options[$plugin]);
+            } else {
+                $options[$private] = $options[$plugin];
+            }
+        }
+	
+        $prefix = $this->namespacePrivateSetting('user_setting', '', $options['plugin_id']);
+        $options['private_setting_name_prefix'] = $prefix;
+	
+        return elgg_get_entities_from_private_settings($options);
+    }
 }

engine/lib/upgrade.php

Indentation +30 added lines, -30 removed lines

@@ -16,13 +16,13 @@ 
  * @todo used by elgg_get_upgrade_files
  */
 function elgg_get_upgrade_file_version($filename) {
-	preg_match('/^([0-9]{10})([\.a-z0-9-_]+)?\.(php)$/i', $filename, $matches);
+    preg_match('/^([0-9]{10})([\.a-z0-9-_]+)?\.(php)$/i', $filename, $matches);
 
-	if (isset($matches[1])) {
-		return (int) $matches[1];
-	}
+    if (isset($matches[1])) {
+        return (int) $matches[1];
+    }
 
-	return false;
+    return false;
 }
 
 /**
@@ -35,33 +35,33 @@ 
  * @todo the wire and groups plugins and the installer are using this
  */
 function elgg_get_upgrade_files($upgrade_path = null) {
-	if (!$upgrade_path) {
-		$upgrade_path = elgg_get_engine_path() . '/lib/upgrades/';
-	}
-	$upgrade_path = sanitise_filepath($upgrade_path);
-	$handle = opendir($upgrade_path);
+    if (!$upgrade_path) {
+        $upgrade_path = elgg_get_engine_path() . '/lib/upgrades/';
+    }
+    $upgrade_path = sanitise_filepath($upgrade_path);
+    $handle = opendir($upgrade_path);
 
-	if (!$handle) {
-		return false;
-	}
+    if (!$handle) {
+        return false;
+    }
 
-	$upgrade_files = [];
+    $upgrade_files = [];
 
-	while ($upgrade_file = readdir($handle)) {
-		// make sure this is a well formed upgrade.
-		if (is_dir($upgrade_path . '$upgrade_file')) {
-			continue;
-		}
-		$upgrade_version = elgg_get_upgrade_file_version($upgrade_file);
-		if (!$upgrade_version) {
-			continue;
-		}
-		$upgrade_files[] = $upgrade_file;
-	}
+    while ($upgrade_file = readdir($handle)) {
+        // make sure this is a well formed upgrade.
+        if (is_dir($upgrade_path . '$upgrade_file')) {
+            continue;
+        }
+        $upgrade_version = elgg_get_upgrade_file_version($upgrade_file);
+        if (!$upgrade_version) {
+            continue;
+        }
+        $upgrade_files[] = $upgrade_file;
+    }
 
-	sort($upgrade_files);
+    sort($upgrade_files);
 
-	return $upgrade_files;
+    return $upgrade_files;
 }
 
 /**
@@ -72,7 +72,7 @@ 
  * @todo the hack in the 2011010101 upgrade requires this
  */
 function _elgg_upgrade_unlock() {
-	$prefix = _elgg_config()->dbprefix;
-	delete_data("drop table {$prefix}upgrade_lock");
-	elgg_log('Upgrade unlocked.', 'NOTICE');
+    $prefix = _elgg_config()->dbprefix;
+    delete_data("drop table {$prefix}upgrade_lock");
+    elgg_log('Upgrade unlocked.', 'NOTICE');
 }

mod/discussions/start.php

Indentation +407 added lines, -407 removed lines

@@ -10,57 +10,57 @@ 
  */
 function discussion_init() {
 
-	elgg_register_page_handler('discussion', 'discussion_page_handler');
+    elgg_register_page_handler('discussion', 'discussion_page_handler');
 
-	elgg_register_plugin_hook_handler('entity:url', 'object', 'discussion_set_topic_url');
+    elgg_register_plugin_hook_handler('entity:url', 'object', 'discussion_set_topic_url');
 
-	// commenting not allowed on discussion topics (use a different annotation)
-	elgg_register_plugin_hook_handler('permissions_check:comment', 'object', 'discussion_comment_override');
-	elgg_register_plugin_hook_handler('permissions_check', 'object', 'discussion_can_edit_reply');
+    // commenting not allowed on discussion topics (use a different annotation)
+    elgg_register_plugin_hook_handler('permissions_check:comment', 'object', 'discussion_comment_override');
+    elgg_register_plugin_hook_handler('permissions_check', 'object', 'discussion_can_edit_reply');
 
-	// discussion reply menu
-	elgg_register_plugin_hook_handler('register', 'menu:entity', 'discussion_reply_menu_setup');
+    // discussion reply menu
+    elgg_register_plugin_hook_handler('register', 'menu:entity', 'discussion_reply_menu_setup');
 
-	// allow non-owners to add replies to discussion
-	elgg_register_plugin_hook_handler('container_logic_check', 'object', 'discussion_reply_container_logic_override');
-	elgg_register_plugin_hook_handler('container_permissions_check', 'object', 'discussion_reply_container_permissions_override');
+    // allow non-owners to add replies to discussion
+    elgg_register_plugin_hook_handler('container_logic_check', 'object', 'discussion_reply_container_logic_override');
+    elgg_register_plugin_hook_handler('container_permissions_check', 'object', 'discussion_reply_container_permissions_override');
 
-	elgg_register_event_handler('update:after', 'object', 'discussion_update_reply_access_ids');
+    elgg_register_event_handler('update:after', 'object', 'discussion_update_reply_access_ids');
 
-	// add link to owner block
-	elgg_register_plugin_hook_handler('register', 'menu:owner_block', 'discussion_owner_block_menu');
+    // add link to owner block
+    elgg_register_plugin_hook_handler('register', 'menu:owner_block', 'discussion_owner_block_menu');
 
-	// Register for search.
-	elgg_register_plugin_hook_handler('search', 'object:discussion', 'discussion_search_discussion');
+    // Register for search.
+    elgg_register_plugin_hook_handler('search', 'object:discussion', 'discussion_search_discussion');
 
-	// because replies are not comments, need of our menu item
-	elgg_register_plugin_hook_handler('register', 'menu:river', 'discussion_add_to_river_menu');
+    // because replies are not comments, need of our menu item
+    elgg_register_plugin_hook_handler('register', 'menu:river', 'discussion_add_to_river_menu');
 
-	// add the forum tool option
-	add_group_tool_option('forum', elgg_echo('groups:enableforum'), true);
-	elgg_extend_view('groups/tool_latest', 'discussion/group_module');
+    // add the forum tool option
+    add_group_tool_option('forum', elgg_echo('groups:enableforum'), true);
+    elgg_extend_view('groups/tool_latest', 'discussion/group_module');
 
-	// TODO remove in 3.0
-	elgg_register_js('elgg.discussion', elgg_get_simplecache_url('discussion/discussion.js'));
+    // TODO remove in 3.0
+    elgg_register_js('elgg.discussion', elgg_get_simplecache_url('discussion/discussion.js'));
 
-	elgg_register_ajax_view('ajax/discussion/reply/edit');
+    elgg_register_ajax_view('ajax/discussion/reply/edit');
 
-	// notifications
-	elgg_register_plugin_hook_handler('get', 'subscriptions', 'discussion_get_subscriptions');
-	elgg_register_notification_event('object', 'discussion');
-	elgg_register_plugin_hook_handler('prepare', 'notification:create:object:discussion', 'discussion_prepare_notification');
-	elgg_register_notification_event('object', 'discussion_reply');
-	elgg_register_plugin_hook_handler('prepare', 'notification:create:object:discussion_reply', 'discussion_prepare_reply_notification');
+    // notifications
+    elgg_register_plugin_hook_handler('get', 'subscriptions', 'discussion_get_subscriptions');
+    elgg_register_notification_event('object', 'discussion');
+    elgg_register_plugin_hook_handler('prepare', 'notification:create:object:discussion', 'discussion_prepare_notification');
+    elgg_register_notification_event('object', 'discussion_reply');
+    elgg_register_plugin_hook_handler('prepare', 'notification:create:object:discussion_reply', 'discussion_prepare_reply_notification');
 
-	// allow ecml in discussion
-	elgg_register_plugin_hook_handler('get_views', 'ecml', 'discussion_ecml_views_hook');
+    // allow ecml in discussion
+    elgg_register_plugin_hook_handler('get_views', 'ecml', 'discussion_ecml_views_hook');
 
-	// allow to be liked
-	elgg_register_plugin_hook_handler('likes:is_likable', 'object:discussion', 'Elgg\Values::getTrue');
-	elgg_register_plugin_hook_handler('likes:is_likable', 'object:discussion_reply', 'Elgg\Values::getTrue');
+    // allow to be liked
+    elgg_register_plugin_hook_handler('likes:is_likable', 'object:discussion', 'Elgg\Values::getTrue');
+    elgg_register_plugin_hook_handler('likes:is_likable', 'object:discussion_reply', 'Elgg\Values::getTrue');
 
-	// Add latest discussions tab to /groups/all page
-	elgg_register_plugin_hook_handler('register', 'menu:filter:groups/all', 'discussion_setup_groups_filter_tabs');
+    // Add latest discussions tab to /groups/all page
+    elgg_register_plugin_hook_handler('register', 'menu:filter:groups/all', 'discussion_setup_groups_filter_tabs');
 }
 
 /**
@@ -78,59 +78,59 @@ 
  */
 function discussion_page_handler($page) {
 
-	if (!isset($page[0])) {
-		$page[0] = 'all';
-	}
-
-	elgg_push_breadcrumb(elgg_echo('discussion'), 'discussion/all');
-
-	switch ($page[0]) {
-		case 'all':
-			echo elgg_view_resource('discussion/all');
-			break;
-		case 'owner':
-			echo elgg_view_resource('discussion/owner', [
-				'guid' => elgg_extract(1, $page),
-			]);
-			break;
-		case 'group':
-			echo elgg_view_resource('discussion/group', [
-				'guid' => elgg_extract(1, $page),
-			]);
-			break;
-		case 'add':
-			echo elgg_view_resource('discussion/add', [
-				'guid' => elgg_extract(1, $page),
-			]);
-			break;
-		case 'reply':
-			switch (elgg_extract(1, $page)) {
-				case 'edit':
-					echo elgg_view_resource('discussion/reply/edit', [
-						'guid' => elgg_extract(2, $page),
-					]);
-					break;
-				case 'view':
-					discussion_redirect_to_reply(elgg_extract(2, $page), elgg_extract(3, $page));
-					break;
-				default:
-					return false;
-			}
-			break;
-		case 'edit':
-			echo elgg_view_resource('discussion/edit', [
-				'guid' => elgg_extract(1, $page),
-			]);
-			break;
-		case 'view':
-			echo elgg_view_resource('discussion/view', [
-				'guid' => elgg_extract(1, $page),
-			]);
-			break;
-		default:
-			return false;
-	}
-	return true;
+    if (!isset($page[0])) {
+        $page[0] = 'all';
+    }
+
+    elgg_push_breadcrumb(elgg_echo('discussion'), 'discussion/all');
+
+    switch ($page[0]) {
+        case 'all':
+            echo elgg_view_resource('discussion/all');
+            break;
+        case 'owner':
+            echo elgg_view_resource('discussion/owner', [
+                'guid' => elgg_extract(1, $page),
+            ]);
+            break;
+        case 'group':
+            echo elgg_view_resource('discussion/group', [
+                'guid' => elgg_extract(1, $page),
+            ]);
+            break;
+        case 'add':
+            echo elgg_view_resource('discussion/add', [
+                'guid' => elgg_extract(1, $page),
+            ]);
+            break;
+        case 'reply':
+            switch (elgg_extract(1, $page)) {
+                case 'edit':
+                    echo elgg_view_resource('discussion/reply/edit', [
+                        'guid' => elgg_extract(2, $page),
+                    ]);
+                    break;
+                case 'view':
+                    discussion_redirect_to_reply(elgg_extract(2, $page), elgg_extract(3, $page));
+                    break;
+                default:
+                    return false;
+            }
+            break;
+        case 'edit':
+            echo elgg_view_resource('discussion/edit', [
+                'guid' => elgg_extract(1, $page),
+            ]);
+            break;
+        case 'view':
+            echo elgg_view_resource('discussion/view', [
+                'guid' => elgg_extract(1, $page),
+            ]);
+            break;
+        default:
+            return false;
+    }
+    return true;
 }
 
 /**
@@ -143,57 +143,57 @@ 
  * @access private
  */
 function discussion_redirect_to_reply($reply_guid, $fallback_guid) {
-	$fail = function () {
-		register_error(elgg_echo('discussion:reply:error:notfound'));
-		forward(REFERER);
-	};
-
-	$reply = get_entity($reply_guid);
-	if (!$reply) {
-		// try fallback
-		$fallback = get_entity($fallback_guid);
-		if (!elgg_instanceof($fallback, 'object', 'discussion')) {
-			$fail();
-		}
-
-		register_error(elgg_echo('discussion:reply:error:notfound_fallback'));
-		forward($fallback->getURL());
-	}
-
-	if (!elgg_instanceof($reply, 'object', 'discussion_reply')) {
-		$fail();
-	}
-
-	// start with topic URL
-	$topic = $reply->getContainerEntity();
-
-	// this won't work with threaded comments, but core doesn't support that yet
-	$count = elgg_get_entities([
-		'type' => 'object',
-		'subtype' => $reply->getSubtype(),
-		'container_guid' => $topic->guid,
-		'count' => true,
-		'wheres' => ["e.guid < " . (int) $reply->guid],
-	]);
-	$limit = (int) get_input('limit', 0);
-	if (!$limit) {
-		$limit = _elgg_config()->default_limit;
-	}
-	$offset = floor($count / $limit) * $limit;
-	if (!$offset) {
-		$offset = null;
-	}
-
-	$url = elgg_http_add_url_query_elements($topic->getURL(), [
-		'offset' => $offset,
-	]);
+    $fail = function () {
+        register_error(elgg_echo('discussion:reply:error:notfound'));
+        forward(REFERER);
+    };
+
+    $reply = get_entity($reply_guid);
+    if (!$reply) {
+        // try fallback
+        $fallback = get_entity($fallback_guid);
+        if (!elgg_instanceof($fallback, 'object', 'discussion')) {
+            $fail();
+        }
+
+        register_error(elgg_echo('discussion:reply:error:notfound_fallback'));
+        forward($fallback->getURL());
+    }
+
+    if (!elgg_instanceof($reply, 'object', 'discussion_reply')) {
+        $fail();
+    }
+
+    // start with topic URL
+    $topic = $reply->getContainerEntity();
+
+    // this won't work with threaded comments, but core doesn't support that yet
+    $count = elgg_get_entities([
+        'type' => 'object',
+        'subtype' => $reply->getSubtype(),
+        'container_guid' => $topic->guid,
+        'count' => true,
+        'wheres' => ["e.guid < " . (int) $reply->guid],
+    ]);
+    $limit = (int) get_input('limit', 0);
+    if (!$limit) {
+        $limit = _elgg_config()->default_limit;
+    }
+    $offset = floor($count / $limit) * $limit;
+    if (!$offset) {
+        $offset = null;
+    }
+
+    $url = elgg_http_add_url_query_elements($topic->getURL(), [
+        'offset' => $offset,
+    ]);
 	
-	// make sure there's only one fragment (#)
-	$parts = parse_url($url);
-	$parts['fragment'] = "elgg-object-{$reply->guid}";
-	$url = elgg_http_build_url($parts, false);
+    // make sure there's only one fragment (#)
+    $parts = parse_url($url);
+    $parts['fragment'] = "elgg-object-{$reply->guid}";
+    $url = elgg_http_build_url($parts, false);
 
-	forward($url);
+    forward($url);
 }
 
 /**
@@ -209,21 +209,21 @@ 
  * @return string
  */
 function discussion_set_topic_url($hook, $type, $url, $params) {
-	$entity = $params['entity'];
+    $entity = $params['entity'];
 
-	if (!$entity instanceof ElggObject) {
-		return;
-	}
+    if (!$entity instanceof ElggObject) {
+        return;
+    }
 
-	if ($entity->getSubtype() === 'discussion') {
-		$title = elgg_get_friendly_title($entity->title);
-		return "discussion/view/{$entity->guid}/{$title}";
-	}
+    if ($entity->getSubtype() === 'discussion') {
+        $title = elgg_get_friendly_title($entity->title);
+        return "discussion/view/{$entity->guid}/{$title}";
+    }
 
-	if ($entity->getSubtype() === 'discussion_reply') {
-		$topic = $entity->getContainerEntity();
-		return "discussion/reply/view/{$entity->guid}/{$topic->guid}";
-	}
+    if ($entity->getSubtype() === 'discussion_reply') {
+        $topic = $entity->getContainerEntity();
+        return "discussion/reply/view/{$entity->guid}/{$topic->guid}";
+    }
 }
 
 /**
@@ -236,9 +236,9 @@ 
  * @return bool
  */
 function discussion_comment_override($hook, $type, $return, $params) {
-	if (elgg_instanceof($params['entity'], 'object', 'discussion')) {
-		return false;
-	}
+    if (elgg_instanceof($params['entity'], 'object', 'discussion')) {
+        return false;
+    }
 }
 
 /**
@@ -251,15 +251,15 @@ 
  * @return ElggMenuItem[] $return
  */
 function discussion_owner_block_menu($hook, $type, $return, $params) {
-	if (elgg_instanceof($params['entity'], 'group')) {
-		if ($params['entity']->forum_enable != "no") {
-			$url = "discussion/group/{$params['entity']->guid}";
-			$item = new ElggMenuItem('discussion', elgg_echo('discussion:group'), $url);
-			$return[] = $item;
-		}
-	}
-
-	return $return;
+    if (elgg_instanceof($params['entity'], 'group')) {
+        if ($params['entity']->forum_enable != "no") {
+            $url = "discussion/group/{$params['entity']->guid}";
+            $item = new ElggMenuItem('discussion', elgg_echo('discussion:group'), $url);
+            $return[] = $item;
+        }
+    }
+
+    return $return;
 }
 
 /**
@@ -275,39 +275,39 @@ 
  * @return ElggMenuItem[] $return
  */
 function discussion_add_to_river_menu($hook, $type, $return, $params) {
-	if (!elgg_is_logged_in() || elgg_in_context('widgets')) {
-		return $return;
-	}
-
-	$item = $params['item'];
-	$object = $item->getObjectEntity();
-
-	if (elgg_instanceof($object, 'object', 'discussion')) {
-		/* @var $object ElggObject */
-		if ($object->canWriteToContainer(0, 'object', 'discussion_reply')) {
-				$options = [
-				'name' => 'reply',
-				'href' => "#discussion-reply-{$object->guid}",
-				'text' => elgg_view_icon('speech-bubble'),
-				'title' => elgg_echo('reply:this'),
-				'rel' => 'toggle',
-				'priority' => 50,
-				];
-				$return[] = ElggMenuItem::factory($options);
-		}
-	} else if (elgg_instanceof($object, 'object', 'discussion_reply')) {
-		/* @var $object ElggDiscussionReply */
-		if (!$object->canComment()) {
-			// Discussion replies cannot be commented
-			foreach ($return as $key => $item) {
-				if ($item->getName() === 'comment') {
-					unset($return[$key]);
-				}
-			}
-		}
-	}
-
-	return $return;
+    if (!elgg_is_logged_in() || elgg_in_context('widgets')) {
+        return $return;
+    }
+
+    $item = $params['item'];
+    $object = $item->getObjectEntity();
+
+    if (elgg_instanceof($object, 'object', 'discussion')) {
+        /* @var $object ElggObject */
+        if ($object->canWriteToContainer(0, 'object', 'discussion_reply')) {
+                $options = [
+                'name' => 'reply',
+                'href' => "#discussion-reply-{$object->guid}",
+                'text' => elgg_view_icon('speech-bubble'),
+                'title' => elgg_echo('reply:this'),
+                'rel' => 'toggle',
+                'priority' => 50,
+                ];
+                $return[] = ElggMenuItem::factory($options);
+        }
+    } else if (elgg_instanceof($object, 'object', 'discussion_reply')) {
+        /* @var $object ElggDiscussionReply */
+        if (!$object->canComment()) {
+            // Discussion replies cannot be commented
+            foreach ($return as $key => $item) {
+                if ($item->getName() === 'comment') {
+                    unset($return[$key]);
+                }
+            }
+        }
+    }
+
+    return $return;
 }
 
 /**
@@ -320,23 +320,23 @@ 
  * @return Elgg\Notifications\Notification
  */
 function discussion_prepare_notification($hook, $type, $notification, $params) {
-	$entity = $params['event']->getObject();
-	$owner = $params['event']->getActor();
-	$language = $params['language'];
-
-	$descr = $entity->description;
-	$title = $entity->title;
-
-	$notification->subject = elgg_echo('discussion:topic:notify:subject', [$title], $language);
-	$notification->body = elgg_echo('discussion:topic:notify:body', [
-		$owner->name,
-		$title,
-		$descr,
-		$entity->getURL()
-	], $language);
-	$notification->summary = elgg_echo('discussion:topic:notify:summary', [$entity->title], $language);
-	$notification->url = $entity->getURL();
-	return $notification;
+    $entity = $params['event']->getObject();
+    $owner = $params['event']->getActor();
+    $language = $params['language'];
+
+    $descr = $entity->description;
+    $title = $entity->title;
+
+    $notification->subject = elgg_echo('discussion:topic:notify:subject', [$title], $language);
+    $notification->body = elgg_echo('discussion:topic:notify:body', [
+        $owner->name,
+        $title,
+        $descr,
+        $entity->getURL()
+    ], $language);
+    $notification->summary = elgg_echo('discussion:topic:notify:summary', [$entity->title], $language);
+    $notification->url = $entity->getURL();
+    return $notification;
 }
 
 /**
@@ -349,22 +349,22 @@ 
  * @return Elgg\Notifications\Notification
  */
 function discussion_prepare_reply_notification($hook, $type, $notification, $params) {
-	$reply = $params['event']->getObject();
-	$topic = $reply->getContainerEntity();
-	$poster = $reply->getOwnerEntity();
-	$language = elgg_extract('language', $params);
-
-	$notification->subject = elgg_echo('discussion:reply:notify:subject', [$topic->title], $language);
-	$notification->body = elgg_echo('discussion:reply:notify:body', [
-		$poster->name,
-		$topic->title,
-		$reply->description,
-		$reply->getURL(),
-	], $language);
-	$notification->summary = elgg_echo('discussion:reply:notify:summary', [$topic->title], $language);
-	$notification->url = $reply->getURL();
+    $reply = $params['event']->getObject();
+    $topic = $reply->getContainerEntity();
+    $poster = $reply->getOwnerEntity();
+    $language = elgg_extract('language', $params);
+
+    $notification->subject = elgg_echo('discussion:reply:notify:subject', [$topic->title], $language);
+    $notification->body = elgg_echo('discussion:reply:notify:body', [
+        $poster->name,
+        $topic->title,
+        $reply->description,
+        $reply->getURL(),
+    ], $language);
+    $notification->summary = elgg_echo('discussion:reply:notify:summary', [$topic->title], $language);
+    $notification->url = $reply->getURL();
 	
-	return $notification;
+    return $notification;
 }
 
 /**
@@ -378,25 +378,25 @@ 
  * @return array
  */
 function discussion_get_subscriptions($hook, $type, $subscriptions, $params) {
-	$reply = $params['event']->getObject();
+    $reply = $params['event']->getObject();
 
-	if (!elgg_instanceof($reply, 'object', 'discussion_reply')) {
-		return $subscriptions;
-	}
+    if (!elgg_instanceof($reply, 'object', 'discussion_reply')) {
+        return $subscriptions;
+    }
 
-	$container_guid = $reply->getContainerEntity()->container_guid;
-	$container_subscriptions = elgg_get_subscriptions_for_container($container_guid);
+    $container_guid = $reply->getContainerEntity()->container_guid;
+    $container_subscriptions = elgg_get_subscriptions_for_container($container_guid);
 
-	return ($subscriptions + $container_subscriptions);
+    return ($subscriptions + $container_subscriptions);
 }
 
 /**
  * Parse ECML on discussion views
  */
 function discussion_ecml_views_hook($hook, $type, $return_value, $params) {
-	$return_value['forum/viewposts'] = elgg_echo('discussion:ecml:discussion');
+    $return_value['forum/viewposts'] = elgg_echo('discussion:ecml:discussion');
 
-	return $return_value;
+    return $return_value;
 }
 
 
@@ -410,29 +410,29 @@ 
  * @return boolean True if user is discussion or group owner
  */
 function discussion_can_edit_reply($hook, $type, $return, $params) {
-	/** @var $reply ElggEntity */
-	$reply = $params['entity'];
-	$user = $params['user'];
+    /** @var $reply ElggEntity */
+    $reply = $params['entity'];
+    $user = $params['user'];
 
-	if (!elgg_instanceof($reply, 'object', 'discussion_reply')) {
-		return $return;
-	}
+    if (!elgg_instanceof($reply, 'object', 'discussion_reply')) {
+        return $return;
+    }
 
-	if ($reply->owner_guid == $user->guid) {
-	    return true;
-	}
+    if ($reply->owner_guid == $user->guid) {
+        return true;
+    }
 
-	$discussion = $reply->getContainerEntity();
-	if ($discussion->owner_guid == $user->guid) {
-		return true;
-	}
+    $discussion = $reply->getContainerEntity();
+    if ($discussion->owner_guid == $user->guid) {
+        return true;
+    }
 
-	$container = $discussion->getContainerEntity();
-	if (elgg_instanceof($container, 'group') && $container->owner_guid == $user->guid) {
-		return true;
-	}
+    $container = $discussion->getContainerEntity();
+    if (elgg_instanceof($container, 'group') && $container->owner_guid == $user->guid) {
+        return true;
+    }
 
-	return false;
+    return false;
 }
 
 /**
@@ -447,22 +447,22 @@ 
  */
 function discussion_reply_container_logic_override($hook, $type, $return, $params) {
 
-	$container = elgg_extract('container', $params);
-	$subtype = elgg_extract('subtype', $params);
+    $container = elgg_extract('container', $params);
+    $subtype = elgg_extract('subtype', $params);
 
-	if ($type !== 'object' || $subtype !== 'discussion_reply') {
-		return;
-	}
+    if ($type !== 'object' || $subtype !== 'discussion_reply') {
+        return;
+    }
 
-	if (!elgg_instanceof($container, 'object', 'discussion')) {
-		// only discussions can contain discussion replies
-		return false;
-	}
+    if (!elgg_instanceof($container, 'object', 'discussion')) {
+        // only discussions can contain discussion replies
+        return false;
+    }
 
-	if ($container->status == 'closed') {
-		// do not allow new replies in closed discussions
-		return false;
-	}
+    if ($container->status == 'closed') {
+        // do not allow new replies in closed discussions
+        return false;
+    }
 }
 
 /**
@@ -475,25 +475,25 @@ 
  * @return boolean $return
  */
 function discussion_reply_container_permissions_override($hook, $type, $return, $params) {
-	if ($params['subtype'] !== 'discussion_reply') {
-		return $return;
-	}
+    if ($params['subtype'] !== 'discussion_reply') {
+        return $return;
+    }
 
-	/** @var $discussion ElggEntity */
-	$discussion = $params['container'];
-	$user = $params['user'];
+    /** @var $discussion ElggEntity */
+    $discussion = $params['container'];
+    $user = $params['user'];
 	
-	$container = $discussion->getContainerEntity();
+    $container = $discussion->getContainerEntity();
 
-	if (elgg_instanceof($container, 'group')) {
-		// Only group members are allowed to reply
-		// to a discussion within a group
-		if (!$container->canWriteToContainer($user->guid)) {
-			return false;
-		}
-	}
+    if (elgg_instanceof($container, 'group')) {
+        // Only group members are allowed to reply
+        // to a discussion within a group
+        if (!$container->canWriteToContainer($user->guid)) {
+            return false;
+        }
+    }
 
-	return true;
+    return true;
 }
 
 /**
@@ -504,30 +504,30 @@ 
  * @param ElggObject $object ElggObject
  */
 function discussion_update_reply_access_ids($event, $type, $object) {
-	if (!elgg_instanceof($object, 'object', 'discussion')) {
-		return;
-	}
-
-	$ia = elgg_set_ignore_access(true);
-	$options = [
-		'type' => 'object',
-		'subtype' => 'discussion_reply',
-		'container_guid' => $object->getGUID(),
-		'limit' => 0,
-	];
-	$batch = new ElggBatch('elgg_get_entities', $options);
-	foreach ($batch as $reply) {
-		if ($reply->access_id == $object->access_id) {
-			// Assume access_id of the replies is up-to-date
-			break;
-		}
-
-		// Update reply access_id
-		$reply->access_id = $object->access_id;
-		$reply->save();
-	}
-
-	elgg_set_ignore_access($ia);
+    if (!elgg_instanceof($object, 'object', 'discussion')) {
+        return;
+    }
+
+    $ia = elgg_set_ignore_access(true);
+    $options = [
+        'type' => 'object',
+        'subtype' => 'discussion_reply',
+        'container_guid' => $object->getGUID(),
+        'limit' => 0,
+    ];
+    $batch = new ElggBatch('elgg_get_entities', $options);
+    foreach ($batch as $reply) {
+        if ($reply->access_id == $object->access_id) {
+            // Assume access_id of the replies is up-to-date
+            break;
+        }
+
+        // Update reply access_id
+        $reply->access_id = $object->access_id;
+        $reply->save();
+    }
+
+    elgg_set_ignore_access($ia);
 }
 
 /**
@@ -540,56 +540,56 @@ 
  * @return ElggMenuItem[] $return
  */
 function discussion_reply_menu_setup($hook, $type, $return, $params) {
-	/** @var $reply ElggEntity */
-	$reply = elgg_extract('entity', $params);
-
-	if (empty($reply) || !elgg_instanceof($reply, 'object', 'discussion_reply')) {
-		return $return;
-	}
-
-	if (!elgg_is_logged_in()) {
-		return $return;
-	}
-
-	if (elgg_in_context('widgets')) {
-		return $return;
-	}
-
-	$remove = [];
-
-	$user = elgg_get_logged_in_user_entity();
-
-	// Allow discussion topic owner, group owner and admins to edit and delete
-	if ($reply->canEdit() && !elgg_in_context('activity')) {
-		$return[] = ElggMenuItem::factory([
-			'name' => 'edit',
-			'text' => elgg_echo('edit'),
-			'href' => "discussion/reply/edit/{$reply->guid}",
-			'priority' => 150,
-		]);
-
-		$return[] = ElggMenuItem::factory([
-			'name' => 'delete',
-			'text' => elgg_view_icon('delete'),
-			'href' => "action/discussion/reply/delete?guid={$reply->guid}",
-			'priority' => 150,
-			'is_action' => true,
-			'confirm' => elgg_echo('deleteconfirm'),
-		]);
-	} else {
-		// Edit and delete links can be removed from all other users
-		$remove[] = 'edit';
-		$remove[] = 'delete';
-	}
-
-	// Remove unneeded menu items
-	foreach ($return as $key => $item) {
-		if (in_array($item->getName(), $remove)) {
-			unset($return[$key]);
-		}
-	}
-
-	return $return;
+    /** @var $reply ElggEntity */
+    $reply = elgg_extract('entity', $params);
+
+    if (empty($reply) || !elgg_instanceof($reply, 'object', 'discussion_reply')) {
+        return $return;
+    }
+
+    if (!elgg_is_logged_in()) {
+        return $return;
+    }
+
+    if (elgg_in_context('widgets')) {
+        return $return;
+    }
+
+    $remove = [];
+
+    $user = elgg_get_logged_in_user_entity();
+
+    // Allow discussion topic owner, group owner and admins to edit and delete
+    if ($reply->canEdit() && !elgg_in_context('activity')) {
+        $return[] = ElggMenuItem::factory([
+            'name' => 'edit',
+            'text' => elgg_echo('edit'),
+            'href' => "discussion/reply/edit/{$reply->guid}",
+            'priority' => 150,
+        ]);
+
+        $return[] = ElggMenuItem::factory([
+            'name' => 'delete',
+            'text' => elgg_view_icon('delete'),
+            'href' => "action/discussion/reply/delete?guid={$reply->guid}",
+            'priority' => 150,
+            'is_action' => true,
+            'confirm' => elgg_echo('deleteconfirm'),
+        ]);
+    } else {
+        // Edit and delete links can be removed from all other users
+        $remove[] = 'edit';
+        $remove[] = 'delete';
+    }
+
+    // Remove unneeded menu items
+    foreach ($return as $key => $item) {
+        if (in_array($item->getName(), $remove)) {
+            unset($return[$key]);
+        }
+    }
+
+    return $return;
 }
 
 /**
@@ -602,20 +602,20 @@ 
  */
 function discussion_search_discussion($hook, $type, $value, $params) {
 
-	if (empty($params) || !is_array($params)) {
-		return $value;
-	}
+    if (empty($params) || !is_array($params)) {
+        return $value;
+    }
 
-	$subtype = elgg_extract("subtype", $params);
-	if (empty($subtype) || ($subtype !== "discussion")) {
-		return $value;
-	}
+    $subtype = elgg_extract("subtype", $params);
+    if (empty($subtype) || ($subtype !== "discussion")) {
+        return $value;
+    }
 
-	unset($params["subtype"]);
-	$params["subtypes"] = ["discussion", "discussion_reply"];
+    unset($params["subtype"]);
+    $params["subtypes"] = ["discussion", "discussion_reply"];
 
-	// trigger the 'normal' object search as it can handle the added options
-	return elgg_trigger_plugin_hook('search', 'object', $params, []);
+    // trigger the 'normal' object search as it can handle the added options
+    return elgg_trigger_plugin_hook('search', 'object', $params, []);
 }
 
 /**
@@ -625,37 +625,37 @@ 
  * @return array
  */
 function discussion_prepare_form_vars($topic = null) {
-	// input names => defaults
-	$values = [
-		'title' => '',
-		'description' => '',
-		'status' => '',
-		'access_id' => ACCESS_DEFAULT,
-		'tags' => '',
-		'container_guid' => elgg_get_page_owner_guid(),
-		'guid' => null,
-		'topic' => $topic,
-		'entity' => $topic,
-	];
-
-	if ($topic) {
-		foreach (array_keys($values) as $field) {
-			if (isset($topic->$field)) {
-				$values[$field] = $topic->$field;
-			}
-		}
-	}
-
-	if (elgg_is_sticky_form('topic')) {
-		$sticky_values = elgg_get_sticky_values('topic');
-		foreach ($sticky_values as $key => $value) {
-			$values[$key] = $value;
-		}
-	}
-
-	elgg_clear_sticky_form('topic');
-
-	return $values;
+    // input names => defaults
+    $values = [
+        'title' => '',
+        'description' => '',
+        'status' => '',
+        'access_id' => ACCESS_DEFAULT,
+        'tags' => '',
+        'container_guid' => elgg_get_page_owner_guid(),
+        'guid' => null,
+        'topic' => $topic,
+        'entity' => $topic,
+    ];
+
+    if ($topic) {
+        foreach (array_keys($values) as $field) {
+            if (isset($topic->$field)) {
+                $values[$field] = $topic->$field;
+            }
+        }
+    }
+
+    if (elgg_is_sticky_form('topic')) {
+        $sticky_values = elgg_get_sticky_values('topic');
+        foreach ($sticky_values as $key => $value) {
+            $values[$key] = $value;
+        }
+    }
+
+    elgg_clear_sticky_form('topic');
+
+    return $values;
 }
 
 /**
@@ -669,15 +669,15 @@ 
  */
 function discussion_setup_groups_filter_tabs($hook, $type, $return, $params) {
 
-	$filter_value = elgg_extract('filter_value', $params);
+    $filter_value = elgg_extract('filter_value', $params);
 
-	$return[] = ElggMenuItem::factory([
-		'name' => 'discussion',
-		'text' => elgg_echo('discussion:latest'),
-		'href' => 'groups/all?filter=discussion',
-		'priority' => 500,
-		'selected' => $filter_value == 'discussion',
-	]);
+    $return[] = ElggMenuItem::factory([
+        'name' => 'discussion',
+        'text' => elgg_echo('discussion:latest'),
+        'href' => 'groups/all?filter=discussion',
+        'priority' => 500,
+        'selected' => $filter_value == 'discussion',
+    ]);
 
-	return $return;
+    return $return;
 }

engine/lib/admin.php

Indentation +640 added lines, -640 removed lines

@@ -29,27 +29,27 @@ 
  * @since 1.8.0
  */
 function elgg_get_admins(array $options = []) {
-	$config = _elgg_config();
-
-	if (isset($options['joins'])) {
-		if (!is_array($options['joins'])) {
-			$options['joins'] = [$options['joins']];
-		}
-		$options['joins'][] = "join {$config->dbprefix}users_entity u on e.guid=u.guid";
-	} else {
-		$options['joins'] = ["join {$config->dbprefix}users_entity u on e.guid=u.guid"];
-	}
-
-	if (isset($options['wheres'])) {
-		if (!is_array($options['wheres'])) {
-			$options['wheres'] = [$options['wheres']];
-		}
-		$options['wheres'][] = "u.admin = 'yes'";
-	} else {
-		$options['wheres'][] = "u.admin = 'yes'";
-	}
-
-	return elgg_get_entities($options);
+    $config = _elgg_config();
+
+    if (isset($options['joins'])) {
+        if (!is_array($options['joins'])) {
+            $options['joins'] = [$options['joins']];
+        }
+        $options['joins'][] = "join {$config->dbprefix}users_entity u on e.guid=u.guid";
+    } else {
+        $options['joins'] = ["join {$config->dbprefix}users_entity u on e.guid=u.guid"];
+    }
+
+    if (isset($options['wheres'])) {
+        if (!is_array($options['wheres'])) {
+            $options['wheres'] = [$options['wheres']];
+        }
+        $options['wheres'][] = "u.admin = 'yes'";
+    } else {
+        $options['wheres'][] = "u.admin = 'yes'";
+    }
+
+    return elgg_get_entities($options);
 }
 
 /**
@@ -69,7 +69,7 @@ 
  * @since 1.8.0
  */
 function elgg_add_admin_notice($id, $message) {
-	return _elgg_services()->adminNotices->add($id, $message);
+    return _elgg_services()->adminNotices->add($id, $message);
 }
 
 /**
@@ -81,7 +81,7 @@ 
  * @since 1.8.0
  */
 function elgg_delete_admin_notice($id) {
-	return _elgg_services()->adminNotices->delete($id);
+    return _elgg_services()->adminNotices->delete($id);
 }
 
 /**
@@ -93,7 +93,7 @@ 
  * @since 1.8.0
  */
 function elgg_get_admin_notices(array $options = []) {
-	return _elgg_services()->adminNotices->find($options);
+    return _elgg_services()->adminNotices->find($options);
 }
 
 /**
@@ -105,7 +105,7 @@ 
  * @since 1.8.0
  */
 function elgg_admin_notice_exists($id) {
-	return _elgg_services()->adminNotices->exists($id);
+    return _elgg_services()->adminNotices->exists($id);
 }
 
 /**
@@ -117,17 +117,17 @@ 
  * @access private
  */
 function _elgg_create_notice_of_pending_upgrade($event, $type, $object) {
-	if ($object instanceof \ElggUpgrade) {
-		// Link to the Upgrades section
-		$link = elgg_view('output/url', [
-			'href' => 'admin/upgrades',
-			'text' => elgg_echo('admin:view_upgrades'),
-		]);
+    if ($object instanceof \ElggUpgrade) {
+        // Link to the Upgrades section
+        $link = elgg_view('output/url', [
+            'href' => 'admin/upgrades',
+            'text' => elgg_echo('admin:view_upgrades'),
+        ]);
 
-		$message = elgg_echo('admin:pending_upgrades');
+        $message = elgg_echo('admin:pending_upgrades');
 
-		elgg_add_admin_notice('pending_upgrades', "$message $link");
-	}
+        elgg_add_admin_notice('pending_upgrades', "$message $link");
+    }
 }
 
 /**
@@ -137,85 +137,85 @@ 
  */
 function _elgg_admin_init() {
 
-	elgg_register_css('elgg.admin', elgg_get_simplecache_url('admin.css'));
+    elgg_register_css('elgg.admin', elgg_get_simplecache_url('admin.css'));
 
-	elgg_extend_view('admin.css', 'lightbox/elgg-colorbox-theme/colorbox.css');
+    elgg_extend_view('admin.css', 'lightbox/elgg-colorbox-theme/colorbox.css');
 		
-	elgg_register_plugin_hook_handler('register', 'menu:admin_header', '_elgg_admin_header_menu');
-	elgg_register_plugin_hook_handler('register', 'menu:admin_footer', '_elgg_admin_footer_menu');
-	elgg_register_plugin_hook_handler('register', 'menu:page', '_elgg_admin_page_menu');
-	elgg_register_plugin_hook_handler('register', 'menu:page', '_elgg_admin_page_menu_plugin_settings');
-
-	// maintenance mode
-	if (elgg_get_config('elgg_maintenance_mode', null)) {
-		elgg_register_plugin_hook_handler('route', 'all', '_elgg_admin_maintenance_handler', 600);
-		elgg_register_plugin_hook_handler('action', 'all', '_elgg_admin_maintenance_action_check', 600);
-		elgg_register_css('maintenance', elgg_get_simplecache_url('maintenance.css'));
-
-		elgg_register_menu_item('topbar', [
-			'name' => 'maintenance_mode',
-			'href' => 'admin/configure_utilities/maintenance',
-			'text' => elgg_echo('admin:maintenance_mode:indicator_menu_item'),
-			'priority' => 900,
-		]);
-	}
-
-	elgg_register_action('admin/user/ban', '', 'admin');
-	elgg_register_action('admin/user/unban', '', 'admin');
-	elgg_register_action('admin/user/delete', '', 'admin');
-	elgg_register_action('admin/user/resetpassword', '', 'admin');
-	elgg_register_action('admin/user/makeadmin', '', 'admin');
-	elgg_register_action('admin/user/removeadmin', '', 'admin');
-
-	elgg_register_action('admin/site/update_basic', '', 'admin');
-	elgg_register_action('admin/site/update_advanced', '', 'admin');
-	elgg_register_action('admin/site/flush_cache', '', 'admin');
-	elgg_register_action('admin/site/unlock_upgrade', '', 'admin');
-	elgg_register_action('admin/site/set_robots', '', 'admin');
-	elgg_register_action('admin/site/set_maintenance_mode', '', 'admin');
-
-	elgg_register_action('admin/upgrades/upgrade_database_guid_columns', '', 'admin');
-	elgg_register_action('admin/site/regenerate_secret', '', 'admin');
-	elgg_register_action('admin/upgrade', '', 'admin');
-
-	elgg_register_action('admin/menu/save', '', 'admin');
-
-	elgg_register_action('admin/delete_admin_notice', '', 'admin');
+    elgg_register_plugin_hook_handler('register', 'menu:admin_header', '_elgg_admin_header_menu');
+    elgg_register_plugin_hook_handler('register', 'menu:admin_footer', '_elgg_admin_footer_menu');
+    elgg_register_plugin_hook_handler('register', 'menu:page', '_elgg_admin_page_menu');
+    elgg_register_plugin_hook_handler('register', 'menu:page', '_elgg_admin_page_menu_plugin_settings');
+
+    // maintenance mode
+    if (elgg_get_config('elgg_maintenance_mode', null)) {
+        elgg_register_plugin_hook_handler('route', 'all', '_elgg_admin_maintenance_handler', 600);
+        elgg_register_plugin_hook_handler('action', 'all', '_elgg_admin_maintenance_action_check', 600);
+        elgg_register_css('maintenance', elgg_get_simplecache_url('maintenance.css'));
+
+        elgg_register_menu_item('topbar', [
+            'name' => 'maintenance_mode',
+            'href' => 'admin/configure_utilities/maintenance',
+            'text' => elgg_echo('admin:maintenance_mode:indicator_menu_item'),
+            'priority' => 900,
+        ]);
+    }
+
+    elgg_register_action('admin/user/ban', '', 'admin');
+    elgg_register_action('admin/user/unban', '', 'admin');
+    elgg_register_action('admin/user/delete', '', 'admin');
+    elgg_register_action('admin/user/resetpassword', '', 'admin');
+    elgg_register_action('admin/user/makeadmin', '', 'admin');
+    elgg_register_action('admin/user/removeadmin', '', 'admin');
+
+    elgg_register_action('admin/site/update_basic', '', 'admin');
+    elgg_register_action('admin/site/update_advanced', '', 'admin');
+    elgg_register_action('admin/site/flush_cache', '', 'admin');
+    elgg_register_action('admin/site/unlock_upgrade', '', 'admin');
+    elgg_register_action('admin/site/set_robots', '', 'admin');
+    elgg_register_action('admin/site/set_maintenance_mode', '', 'admin');
+
+    elgg_register_action('admin/upgrades/upgrade_database_guid_columns', '', 'admin');
+    elgg_register_action('admin/site/regenerate_secret', '', 'admin');
+    elgg_register_action('admin/upgrade', '', 'admin');
+
+    elgg_register_action('admin/menu/save', '', 'admin');
+
+    elgg_register_action('admin/delete_admin_notice', '', 'admin');
 	
-	elgg_register_action('admin/security/settings', '', 'admin');
-
-	elgg_register_simplecache_view('admin.css');
-
-	// widgets
-	$widgets = ['online_users', 'new_users', 'content_stats', 'banned_users', 'admin_welcome', 'control_panel', 'cron_status'];
-	foreach ($widgets as $widget) {
-		elgg_register_widget_type(
-				$widget,
-				elgg_echo("admin:widget:$widget"),
-				elgg_echo("admin:widget:$widget:help"),
-				['admin']
-		);
-	}
-
-	// automatic adding of widgets for admin
-	elgg_register_event_handler('make_admin', 'user', '_elgg_add_admin_widgets');
+    elgg_register_action('admin/security/settings', '', 'admin');
+
+    elgg_register_simplecache_view('admin.css');
+
+    // widgets
+    $widgets = ['online_users', 'new_users', 'content_stats', 'banned_users', 'admin_welcome', 'control_panel', 'cron_status'];
+    foreach ($widgets as $widget) {
+        elgg_register_widget_type(
+                $widget,
+                elgg_echo("admin:widget:$widget"),
+                elgg_echo("admin:widget:$widget:help"),
+                ['admin']
+        );
+    }
+
+    // automatic adding of widgets for admin
+    elgg_register_event_handler('make_admin', 'user', '_elgg_add_admin_widgets');
 	
-	elgg_register_notification_event('user', '', ['make_admin', 'remove_admin']);
-	elgg_register_plugin_hook_handler('get', 'subscriptions', '_elgg_admin_get_admin_subscribers_admin_action');
-	elgg_register_plugin_hook_handler('get', 'subscriptions', '_elgg_admin_get_user_subscriber_admin_action');
-	elgg_register_plugin_hook_handler('prepare', 'notification:make_admin:user:', '_elgg_admin_prepare_admin_notification_make_admin');
-	elgg_register_plugin_hook_handler('prepare', 'notification:make_admin:user:', '_elgg_admin_prepare_user_notification_make_admin');
-	elgg_register_plugin_hook_handler('prepare', 'notification:remove_admin:user:', '_elgg_admin_prepare_admin_notification_remove_admin');
-	elgg_register_plugin_hook_handler('prepare', 'notification:remove_admin:user:', '_elgg_admin_prepare_user_notification_remove_admin');
+    elgg_register_notification_event('user', '', ['make_admin', 'remove_admin']);
+    elgg_register_plugin_hook_handler('get', 'subscriptions', '_elgg_admin_get_admin_subscribers_admin_action');
+    elgg_register_plugin_hook_handler('get', 'subscriptions', '_elgg_admin_get_user_subscriber_admin_action');
+    elgg_register_plugin_hook_handler('prepare', 'notification:make_admin:user:', '_elgg_admin_prepare_admin_notification_make_admin');
+    elgg_register_plugin_hook_handler('prepare', 'notification:make_admin:user:', '_elgg_admin_prepare_user_notification_make_admin');
+    elgg_register_plugin_hook_handler('prepare', 'notification:remove_admin:user:', '_elgg_admin_prepare_admin_notification_remove_admin');
+    elgg_register_plugin_hook_handler('prepare', 'notification:remove_admin:user:', '_elgg_admin_prepare_user_notification_remove_admin');
 	
-	// Add notice about pending upgrades
-	elgg_register_event_handler('create', 'object', '_elgg_create_notice_of_pending_upgrade');
-
-	elgg_register_page_handler('admin', '_elgg_admin_page_handler');
-	elgg_register_page_handler('admin_plugin_text_file', '_elgg_admin_markdown_page_handler');
-	elgg_register_page_handler('robots.txt', '_elgg_robots_page_handler');
-	elgg_register_page_handler('phpinfo', '_elgg_phpinfo_page_handler');
-	elgg_register_page_handler('admin_plugins_refresh', '_elgg_ajax_plugins_update');
+    // Add notice about pending upgrades
+    elgg_register_event_handler('create', 'object', '_elgg_create_notice_of_pending_upgrade');
+
+    elgg_register_page_handler('admin', '_elgg_admin_page_handler');
+    elgg_register_page_handler('admin_plugin_text_file', '_elgg_admin_markdown_page_handler');
+    elgg_register_page_handler('robots.txt', '_elgg_robots_page_handler');
+    elgg_register_page_handler('phpinfo', '_elgg_phpinfo_page_handler');
+    elgg_register_page_handler('admin_plugins_refresh', '_elgg_ajax_plugins_update');
 }
 
 /**
@@ -225,13 +225,13 @@ 
  * @return Elgg\Http\OkResponse
  */
 function _elgg_ajax_plugins_update() {
-	elgg_admin_gatekeeper();
-	elgg_set_context('admin');
+    elgg_admin_gatekeeper();
+    elgg_set_context('admin');
 
-	return elgg_ok_response([
-		'list' => elgg_view('admin/plugins', ['list_only' => true]),
-		'sidebar' => elgg_view('admin/sidebar'),
-	]);
+    return elgg_ok_response([
+        'list' => elgg_view('admin/plugins', ['list_only' => true]),
+        'sidebar' => elgg_view('admin/sidebar'),
+    ]);
 }
 
 /**
@@ -248,52 +248,52 @@ 
  * @since 3.0
  */
 function _elgg_admin_header_menu($hook, $type, $return, $params) {
-	if (!elgg_in_context('admin') || !elgg_is_admin_logged_in()) {
-		return;
-	}
-
-	$admin = elgg_get_logged_in_user_entity();
-
-	$admin_icon = elgg_view_entity_icon($admin, 'tiny');
-	$admin_link = elgg_view('output/url', [
-		'href' => $admin->getURL(),
-		'text' => $admin->name,
-	]);
-
-	$return[] = \ElggMenuItem::factory([
-		'name' => 'admin_profile',
-		'href' => false,
-		'text' => "$admin_link $admin_icon",
-		'priority' => 1000,
-	]);
-
-	$return[] = \ElggMenuItem::factory([
-		'name' => 'admin_logout',
-		'href' => 'action/logout',
-		'text' => elgg_echo('logout'),
-		'is_trusted' => true,
-		'priority' => 900,
-	]);
-
-	$return[] = \ElggMenuItem::factory([
-		'name' => 'view_site',
-		'href' => elgg_get_site_url(),
-		'text' => elgg_echo('admin:view_site'),
-		'is_trusted' => true,
-		'priority' => 800,
-	]);
-
-	if (elgg_get_config('elgg_maintenance_mode')) {
-		$return[] = \ElggMenuItem::factory([
-			'name' => 'maintenance',
-			'href' => 'admin/configure_utilities/maintenance',
-			'text' => elgg_echo('admin:configure_utilities:maintenance'),
-			'link_class' => 'elgg-maintenance-mode-warning',
-			'priority' => 700,
-		]);
-	}
+    if (!elgg_in_context('admin') || !elgg_is_admin_logged_in()) {
+        return;
+    }
+
+    $admin = elgg_get_logged_in_user_entity();
+
+    $admin_icon = elgg_view_entity_icon($admin, 'tiny');
+    $admin_link = elgg_view('output/url', [
+        'href' => $admin->getURL(),
+        'text' => $admin->name,
+    ]);
+
+    $return[] = \ElggMenuItem::factory([
+        'name' => 'admin_profile',
+        'href' => false,
+        'text' => "$admin_link $admin_icon",
+        'priority' => 1000,
+    ]);
+
+    $return[] = \ElggMenuItem::factory([
+        'name' => 'admin_logout',
+        'href' => 'action/logout',
+        'text' => elgg_echo('logout'),
+        'is_trusted' => true,
+        'priority' => 900,
+    ]);
+
+    $return[] = \ElggMenuItem::factory([
+        'name' => 'view_site',
+        'href' => elgg_get_site_url(),
+        'text' => elgg_echo('admin:view_site'),
+        'is_trusted' => true,
+        'priority' => 800,
+    ]);
+
+    if (elgg_get_config('elgg_maintenance_mode')) {
+        $return[] = \ElggMenuItem::factory([
+            'name' => 'maintenance',
+            'href' => 'admin/configure_utilities/maintenance',
+            'text' => elgg_echo('admin:configure_utilities:maintenance'),
+            'link_class' => 'elgg-maintenance-mode-warning',
+            'priority' => 700,
+        ]);
+    }
 	
-	return $return;
+    return $return;
 }
 
 /**
@@ -310,35 +310,35 @@ 
  * @since 3.0
  */
 function _elgg_admin_footer_menu($hook, $type, $return, $params) {
-	if (!elgg_in_context('admin') || !elgg_is_admin_logged_in()) {
-		return;
-	}
-
-	$return[] = \ElggMenuItem::factory([
-		'name' => 'faq',
-		'text' => elgg_echo('admin:footer:faq'),
-		'href' => 'http://learn.elgg.org/en/stable/appendix/faqs.html',
-	]);
-
-	$return[] = \ElggMenuItem::factory([
-		'name' => 'manual',
-		'text' => elgg_echo('admin:footer:manual'),
-		'href' => 'http://learn.elgg.org/en/stable/admin/index.html',
-	]);
-
-	$return[] = \ElggMenuItem::factory([
-		'name' => 'community_forums',
-		'text' => elgg_echo('admin:footer:community_forums'),
-		'href' => 'http://elgg.org/groups/all/',
-	]);
-
-	$return[] = \ElggMenuItem::factory([
-		'name' => 'blog',
-		'text' => elgg_echo('admin:footer:blog'),
-		'href' => 'https://elgg.org/blog/all',
-	]);
+    if (!elgg_in_context('admin') || !elgg_is_admin_logged_in()) {
+        return;
+    }
+
+    $return[] = \ElggMenuItem::factory([
+        'name' => 'faq',
+        'text' => elgg_echo('admin:footer:faq'),
+        'href' => 'http://learn.elgg.org/en/stable/appendix/faqs.html',
+    ]);
+
+    $return[] = \ElggMenuItem::factory([
+        'name' => 'manual',
+        'text' => elgg_echo('admin:footer:manual'),
+        'href' => 'http://learn.elgg.org/en/stable/admin/index.html',
+    ]);
+
+    $return[] = \ElggMenuItem::factory([
+        'name' => 'community_forums',
+        'text' => elgg_echo('admin:footer:community_forums'),
+        'href' => 'http://elgg.org/groups/all/',
+    ]);
+
+    $return[] = \ElggMenuItem::factory([
+        'name' => 'blog',
+        'text' => elgg_echo('admin:footer:blog'),
+        'href' => 'https://elgg.org/blog/all',
+    ]);
 	
-	return $return;
+    return $return;
 }
 
 /**
@@ -354,148 +354,148 @@ 
  * @since 3.0
  */
 function _elgg_admin_page_menu(\Elgg\Hook $hook) {
-	if (!elgg_in_context('admin') || !elgg_is_admin_logged_in()) {
-		return;
-	}
+    if (!elgg_in_context('admin') || !elgg_is_admin_logged_in()) {
+        return;
+    }
 	
-	$return = $hook->getValue();
-
-	// administer
-	$return[] = \ElggMenuItem::factory([
-		'name' => 'dashboard',
-		'href' => 'admin',
-		'text' => elgg_echo('admin:dashboard'),
-		'priority' => 10,
-		'section' => 'administer',
-	]);
+    $return = $hook->getValue();
+
+    // administer
+    $return[] = \ElggMenuItem::factory([
+        'name' => 'dashboard',
+        'href' => 'admin',
+        'text' => elgg_echo('admin:dashboard'),
+        'priority' => 10,
+        'section' => 'administer',
+    ]);
 	
-	$return[] = \ElggMenuItem::factory([
-		'name' => 'plugins',
-		'href' => 'admin/plugins',
-		'text' => elgg_echo('admin:plugins'),
-		'priority' => 30,
-		'section' => 'administer',
-	]);
-
-	$return[] = \ElggMenuItem::factory([
-		'name' => 'users',
-		'text' => elgg_echo('admin:users'),
-		'priority' => 40,
-		'section' => 'administer',
-	]);
-	$return[] = \ElggMenuItem::factory([
-		'name' => 'users:online',
-		'text' => elgg_echo('admin:users:online'),
-		'href' => 'admin/users/online',
-		'priority' => 10,
-		'section' => 'administer',
-		'parent_name' => 'users',
-	]);
-	$return[] = \ElggMenuItem::factory([
-		'name' => 'users:admins',
-		'text' => elgg_echo('admin:users:admins'),
-		'href' => 'admin/users/admins',
-		'priority' => 20,
-		'section' => 'administer',
-		'parent_name' => 'users',
-	]);
-	$return[] = \ElggMenuItem::factory([
-		'name' => 'users:newest',
-		'text' => elgg_echo('admin:users:newest'),
-		'href' => 'admin/users/newest',
-		'priority' => 30,
-		'section' => 'administer',
-		'parent_name' => 'users',
-	]);
-	$return[] = \ElggMenuItem::factory([
-		'name' => 'users:add',
-		'text' => elgg_echo('admin:users:add'),
-		'href' => 'admin/users/add',
-		'priority' => 40,
-		'section' => 'administer',
-		'parent_name' => 'users',
-	]);
-	$return[] = \ElggMenuItem::factory([
-		'name' => 'upgrades',
-		'href' => 'admin/upgrades',
-		'text' => elgg_echo('admin:upgrades'),
-		'priority' => 600,
-		'section' => 'administer',
-	]);
+    $return[] = \ElggMenuItem::factory([
+        'name' => 'plugins',
+        'href' => 'admin/plugins',
+        'text' => elgg_echo('admin:plugins'),
+        'priority' => 30,
+        'section' => 'administer',
+    ]);
+
+    $return[] = \ElggMenuItem::factory([
+        'name' => 'users',
+        'text' => elgg_echo('admin:users'),
+        'priority' => 40,
+        'section' => 'administer',
+    ]);
+    $return[] = \ElggMenuItem::factory([
+        'name' => 'users:online',
+        'text' => elgg_echo('admin:users:online'),
+        'href' => 'admin/users/online',
+        'priority' => 10,
+        'section' => 'administer',
+        'parent_name' => 'users',
+    ]);
+    $return[] = \ElggMenuItem::factory([
+        'name' => 'users:admins',
+        'text' => elgg_echo('admin:users:admins'),
+        'href' => 'admin/users/admins',
+        'priority' => 20,
+        'section' => 'administer',
+        'parent_name' => 'users',
+    ]);
+    $return[] = \ElggMenuItem::factory([
+        'name' => 'users:newest',
+        'text' => elgg_echo('admin:users:newest'),
+        'href' => 'admin/users/newest',
+        'priority' => 30,
+        'section' => 'administer',
+        'parent_name' => 'users',
+    ]);
+    $return[] = \ElggMenuItem::factory([
+        'name' => 'users:add',
+        'text' => elgg_echo('admin:users:add'),
+        'href' => 'admin/users/add',
+        'priority' => 40,
+        'section' => 'administer',
+        'parent_name' => 'users',
+    ]);
+    $return[] = \ElggMenuItem::factory([
+        'name' => 'upgrades',
+        'href' => 'admin/upgrades',
+        'text' => elgg_echo('admin:upgrades'),
+        'priority' => 600,
+        'section' => 'administer',
+    ]);
 	
-	$return[] = \ElggMenuItem::factory([
-		'name' => 'administer_utilities',
-		'text' => elgg_echo('admin:administer_utilities'),
-		'priority' => 50,
-		'section' => 'administer',
-	]);
+    $return[] = \ElggMenuItem::factory([
+        'name' => 'administer_utilities',
+        'text' => elgg_echo('admin:administer_utilities'),
+        'priority' => 50,
+        'section' => 'administer',
+    ]);
 	
-	// configure
-	$return[] = \ElggMenuItem::factory([
-		'name' => 'settings:basic',
-		'href' => 'admin/settings/basic',
-		'text' => elgg_echo('admin:settings:basic'),
-		'priority' => 10,
-		'section' => 'configure',
-	]);
-	$return[] = \ElggMenuItem::factory([
-		'name' => 'settings:advanced',
-		'href' => 'admin/settings/advanced',
-		'text' => elgg_echo('admin:settings:advanced'),
-		'priority' => 20,
-		'section' => 'configure',
-	]);
-	$return[] = \ElggMenuItem::factory([
-		'name' => 'security',
-		'href' => 'admin/security',
-		'text' => elgg_echo('admin:security'),
-		'priority' => 30,
-		'section' => 'configure',
-	]);
-
-	$return[] = \ElggMenuItem::factory([
-		'name' => 'configure_utilities',
-		'text' => elgg_echo('admin:configure_utilities'),
-		'priority' => 600,
-		'section' => 'configure',
-	]);
-	$return[] = \ElggMenuItem::factory([
-		'name' => 'configure_utilities:maintenance',
-		'text' => elgg_echo('admin:configure_utilities:maintenance'),
-		'href' => 'admin/configure_utilities/maintenance',
-		'section' => 'configure',
-		'parent_name' => 'configure_utilities',
-	]);
-	$return[] = \ElggMenuItem::factory([
-		'name' => 'configure_utilities:menu_items',
-		'text' => elgg_echo('admin:configure_utilities:menu_items'),
-		'href' => 'admin/configure_utilities/menu_items',
-		'section' => 'configure',
-		'parent_name' => 'configure_utilities',
-	]);
-	$return[] = \ElggMenuItem::factory([
-		'name' => 'configure_utilities:robots',
-		'text' => elgg_echo('admin:configure_utilities:robots'),
-		'href' => 'admin/configure_utilities/robots',
-		'section' => 'configure',
-		'parent_name' => 'configure_utilities',
-	]);
+    // configure
+    $return[] = \ElggMenuItem::factory([
+        'name' => 'settings:basic',
+        'href' => 'admin/settings/basic',
+        'text' => elgg_echo('admin:settings:basic'),
+        'priority' => 10,
+        'section' => 'configure',
+    ]);
+    $return[] = \ElggMenuItem::factory([
+        'name' => 'settings:advanced',
+        'href' => 'admin/settings/advanced',
+        'text' => elgg_echo('admin:settings:advanced'),
+        'priority' => 20,
+        'section' => 'configure',
+    ]);
+    $return[] = \ElggMenuItem::factory([
+        'name' => 'security',
+        'href' => 'admin/security',
+        'text' => elgg_echo('admin:security'),
+        'priority' => 30,
+        'section' => 'configure',
+    ]);
+
+    $return[] = \ElggMenuItem::factory([
+        'name' => 'configure_utilities',
+        'text' => elgg_echo('admin:configure_utilities'),
+        'priority' => 600,
+        'section' => 'configure',
+    ]);
+    $return[] = \ElggMenuItem::factory([
+        'name' => 'configure_utilities:maintenance',
+        'text' => elgg_echo('admin:configure_utilities:maintenance'),
+        'href' => 'admin/configure_utilities/maintenance',
+        'section' => 'configure',
+        'parent_name' => 'configure_utilities',
+    ]);
+    $return[] = \ElggMenuItem::factory([
+        'name' => 'configure_utilities:menu_items',
+        'text' => elgg_echo('admin:configure_utilities:menu_items'),
+        'href' => 'admin/configure_utilities/menu_items',
+        'section' => 'configure',
+        'parent_name' => 'configure_utilities',
+    ]);
+    $return[] = \ElggMenuItem::factory([
+        'name' => 'configure_utilities:robots',
+        'text' => elgg_echo('admin:configure_utilities:robots'),
+        'href' => 'admin/configure_utilities/robots',
+        'section' => 'configure',
+        'parent_name' => 'configure_utilities',
+    ]);
 	
-	// information
-	$return[] = \ElggMenuItem::factory([
-		'name' => 'statistics',
-		'href' => 'admin/statistics',
-		'text' => elgg_echo('admin:statistics'),
-		'section' => 'information',
-	]);
-	$return[] = \ElggMenuItem::factory([
-		'name' => 'server',
-		'href' => 'admin/server',
-		'text' => elgg_echo('admin:server'),
-		'section' => 'information',
-	]);
+    // information
+    $return[] = \ElggMenuItem::factory([
+        'name' => 'statistics',
+        'href' => 'admin/statistics',
+        'text' => elgg_echo('admin:statistics'),
+        'section' => 'information',
+    ]);
+    $return[] = \ElggMenuItem::factory([
+        'name' => 'server',
+        'href' => 'admin/server',
+        'text' => elgg_echo('admin:server'),
+        'section' => 'information',
+    ]);
 		
-	return $return;
+    return $return;
 }
 
 /**
@@ -511,56 +511,56 @@ 
  * @since 3.0
  */
 function _elgg_admin_page_menu_plugin_settings(\Elgg\Hook $hook) {
-	if (!elgg_in_context('admin') || !elgg_is_admin_logged_in()) {
-		return;
-	}
+    if (!elgg_in_context('admin') || !elgg_is_admin_logged_in()) {
+        return;
+    }
 	
-	// plugin settings
-	$active_plugins = elgg_get_plugins('active');
-	if (!$active_plugins) {
-		// nothing added because no items
-		return;
-	}
+    // plugin settings
+    $active_plugins = elgg_get_plugins('active');
+    if (!$active_plugins) {
+        // nothing added because no items
+        return;
+    }
 	
-	$plugins_with_settings = [];
+    $plugins_with_settings = [];
 	
-	foreach ($active_plugins as $plugin) {
-		$plugin_id = $plugin->getID();
+    foreach ($active_plugins as $plugin) {
+        $plugin_id = $plugin->getID();
 		
-		if (!elgg_view_exists("plugins/{$plugin_id}/settings") ) {
-			continue;
-		}
-		$plugin_name = $plugin->getDisplayName();
-		$plugins_with_settings[$plugin_name] = [
-			'name' => $plugin_id,
-			'href' => "admin/plugin_settings/$plugin_id",
-			'text' => $plugin_name,
-			'parent_name' => 'plugin_settings',
-			'section' => 'configure',
-		];
-	}
+        if (!elgg_view_exists("plugins/{$plugin_id}/settings") ) {
+            continue;
+        }
+        $plugin_name = $plugin->getDisplayName();
+        $plugins_with_settings[$plugin_name] = [
+            'name' => $plugin_id,
+            'href' => "admin/plugin_settings/$plugin_id",
+            'text' => $plugin_name,
+            'parent_name' => 'plugin_settings',
+            'section' => 'configure',
+        ];
+    }
 	
-	if (empty($plugins_with_settings)) {
-		return;
-	}
+    if (empty($plugins_with_settings)) {
+        return;
+    }
 
-	$return = $hook->getValue();
+    $return = $hook->getValue();
 	
-	$return[] = \ElggMenuItem::factory([
-		'name' => 'plugin_settings',
-		'text' => elgg_echo('admin:plugin_settings'),
-		'section' => 'configure',
-	]);
+    $return[] = \ElggMenuItem::factory([
+        'name' => 'plugin_settings',
+        'text' => elgg_echo('admin:plugin_settings'),
+        'section' => 'configure',
+    ]);
 	
-	ksort($plugins_with_settings);
-	$priority = 0;
-	foreach ($plugins_with_settings as $plugin_item) {
-		$priority += 10;
-		$plugin_item['priority'] = $priority;
-		$return[] = \ElggMenuItem::factory($plugin_item);
-	}
+    ksort($plugins_with_settings);
+    $priority = 0;
+    foreach ($plugins_with_settings as $plugin_item) {
+        $priority += 10;
+        $plugin_item['priority'] = $priority;
+        $return[] = \ElggMenuItem::factory($plugin_item);
+    }
 	
-	return $return;
+    return $return;
 }
 
 /**
@@ -572,53 +572,53 @@ 
  * @access private
  */
 function _elgg_admin_page_handler($page) {
-	elgg_admin_gatekeeper();
-	elgg_set_context('admin');
-
-	elgg_unregister_css('elgg');
-	elgg_require_js('elgg/admin');
-
-	// default to dashboard
-	if (!isset($page[0]) || empty($page[0])) {
-		$page = ['dashboard'];
-	}
-
-	// was going to fix this in the page_handler() function but
-	// it's commented to explicitly return a string if there's a trailing /
-	if (empty($page[count($page) - 1])) {
-		array_pop($page);
-	}
-
-	$vars = ['page' => $page];
-
-	// special page for plugin settings since we create the form for them
-	if ($page[0] == 'plugin_settings') {
-		if (isset($page[1]) && (elgg_view_exists("plugins/{$page[1]}/settings"))) {
-			$view = 'admin/plugin_settings';
-			$plugin = elgg_get_plugin_from_id($page[1]);
-			$vars['plugin'] = $plugin;
-
-			$title = elgg_echo("admin:{$page[0]}");
-		} else {
-			forward('', '404');
-		}
-	} else {
-		$view = 'admin/' . implode('/', $page);
-		$title = elgg_echo("admin:{$page[0]}");
-		if (count($page) > 1) {
-			$title .= ' : ' . elgg_echo('admin:' .  implode(':', $page));
-		}
-	}
-
-	// gets content and prevents direct access to 'components' views
-	if ($page[0] == 'components' || !($content = elgg_view($view, $vars))) {
-		$title = elgg_echo('admin:unknown_section');
-		$content = elgg_echo('admin:unknown_section');
-	}
-
-	$body = elgg_view_layout('admin', ['content' => $content, 'title' => $title]);
-	echo elgg_view_page($title, $body, 'admin');
-	return true;
+    elgg_admin_gatekeeper();
+    elgg_set_context('admin');
+
+    elgg_unregister_css('elgg');
+    elgg_require_js('elgg/admin');
+
+    // default to dashboard
+    if (!isset($page[0]) || empty($page[0])) {
+        $page = ['dashboard'];
+    }
+
+    // was going to fix this in the page_handler() function but
+    // it's commented to explicitly return a string if there's a trailing /
+    if (empty($page[count($page) - 1])) {
+        array_pop($page);
+    }
+
+    $vars = ['page' => $page];
+
+    // special page for plugin settings since we create the form for them
+    if ($page[0] == 'plugin_settings') {
+        if (isset($page[1]) && (elgg_view_exists("plugins/{$page[1]}/settings"))) {
+            $view = 'admin/plugin_settings';
+            $plugin = elgg_get_plugin_from_id($page[1]);
+            $vars['plugin'] = $plugin;
+
+            $title = elgg_echo("admin:{$page[0]}");
+        } else {
+            forward('', '404');
+        }
+    } else {
+        $view = 'admin/' . implode('/', $page);
+        $title = elgg_echo("admin:{$page[0]}");
+        if (count($page) > 1) {
+            $title .= ' : ' . elgg_echo('admin:' .  implode(':', $page));
+        }
+    }
+
+    // gets content and prevents direct access to 'components' views
+    if ($page[0] == 'components' || !($content = elgg_view($view, $vars))) {
+        $title = elgg_echo('admin:unknown_section');
+        $content = elgg_echo('admin:unknown_section');
+    }
+
+    $body = elgg_view_layout('admin', ['content' => $content, 'title' => $title]);
+    echo elgg_view_page($title, $body, 'admin');
+    return true;
 }
 
 /**
@@ -638,13 +638,13 @@ 
  * @access private
  */
 function _elgg_admin_markdown_page_handler($pages) {
-	elgg_set_context('admin');
+    elgg_set_context('admin');
 
-	echo elgg_view_resource('admin/plugin_text_file', [
-		'plugin_id' => elgg_extract(0, $pages),
-		'filename' => elgg_extract(1, $pages),
-	]);
-	return true;
+    echo elgg_view_resource('admin/plugin_text_file', [
+        'plugin_id' => elgg_extract(0, $pages),
+        'filename' => elgg_extract(1, $pages),
+    ]);
+    return true;
 }
 
 /**
@@ -653,8 +653,8 @@ 
  * @access private
  */
 function _elgg_robots_page_handler() {
-	echo elgg_view_resource('robots.txt');
-	return true;
+    echo elgg_view_resource('robots.txt');
+    return true;
 }
 
 /**
@@ -663,8 +663,8 @@ 
  * @access private
  */
 function _elgg_phpinfo_page_handler() {
-	echo elgg_view_resource('phpinfo');
-	return true;
+    echo elgg_view_resource('phpinfo');
+    return true;
 }
 
 /**
@@ -676,20 +676,20 @@ 
  * @access private
  */
 function _elgg_admin_maintenance_allow_url($current_url) {
-	$site_path = preg_replace('~^https?~', '', elgg_get_site_url());
-	$current_path = preg_replace('~^https?~', '', $current_url);
-	if (0 === strpos($current_path, $site_path)) {
-		$current_path = ($current_path === $site_path) ? '' : substr($current_path, strlen($site_path));
-	} else {
-		$current_path = false;
-	}
-
-	// allow plugins to control access for specific URLs/paths
-	$params = [
-		'current_path' => $current_path,
-		'current_url' => $current_url,
-	];
-	return (bool) elgg_trigger_plugin_hook('maintenance:allow', 'url', $params, false);
+    $site_path = preg_replace('~^https?~', '', elgg_get_site_url());
+    $current_path = preg_replace('~^https?~', '', $current_url);
+    if (0 === strpos($current_path, $site_path)) {
+        $current_path = ($current_path === $site_path) ? '' : substr($current_path, strlen($site_path));
+    } else {
+        $current_path = false;
+    }
+
+    // allow plugins to control access for specific URLs/paths
+    $params = [
+        'current_path' => $current_path,
+        'current_url' => $current_url,
+    ];
+    return (bool) elgg_trigger_plugin_hook('maintenance:allow', 'url', $params, false);
 }
 
 /**
@@ -698,23 +698,23 @@ 
  * @access private
  */
 function _elgg_admin_maintenance_handler($hook, $type, $info) {
-	if (elgg_is_admin_logged_in()) {
-		return;
-	}
+    if (elgg_is_admin_logged_in()) {
+        return;
+    }
 
-	if ($info['identifier'] == 'action' && $info['segments'][0] == 'login') {
-		return;
-	}
+    if ($info['identifier'] == 'action' && $info['segments'][0] == 'login') {
+        return;
+    }
 
-	if (_elgg_admin_maintenance_allow_url(current_page_url())) {
-		return;
-	}
+    if (_elgg_admin_maintenance_allow_url(current_page_url())) {
+        return;
+    }
 
-	elgg_unregister_plugin_hook_handler('register', 'menu:login', '_elgg_login_menu_setup');
+    elgg_unregister_plugin_hook_handler('register', 'menu:login', '_elgg_login_menu_setup');
 
-	echo elgg_view_resource('maintenance');
+    echo elgg_view_resource('maintenance');
 
-	return false;
+    return false;
 }
 
 /**
@@ -727,34 +727,34 @@ 
  * @return bool
  */
 function _elgg_admin_maintenance_action_check($hook, $type) {
-	if (elgg_is_admin_logged_in()) {
-		return true;
-	}
+    if (elgg_is_admin_logged_in()) {
+        return true;
+    }
 
-	if ($type == 'login') {
-		$username = get_input('username');
+    if ($type == 'login') {
+        $username = get_input('username');
 
-		$user = get_user_by_username($username);
+        $user = get_user_by_username($username);
 
-		if (!$user) {
-			$users = get_user_by_email($username);
-			if ($users) {
-				$user = $users[0];
-			}
-		}
+        if (!$user) {
+            $users = get_user_by_email($username);
+            if ($users) {
+                $user = $users[0];
+            }
+        }
 
-		if ($user && $user->isAdmin()) {
-			return true;
-		}
-	}
+        if ($user && $user->isAdmin()) {
+            return true;
+        }
+    }
 
-	if (_elgg_admin_maintenance_allow_url(current_page_url())) {
-		return true;
-	}
+    if (_elgg_admin_maintenance_allow_url(current_page_url())) {
+        return true;
+    }
 
-	register_error(elgg_echo('actionunauthorized'));
+    register_error(elgg_echo('actionunauthorized'));
 
-	return false;
+    return false;
 }
 
 /**
@@ -768,30 +768,30 @@ 
  * @access private
  */
 function _elgg_add_admin_widgets($event, $type, $user) {
-	elgg_set_ignore_access(true);
-
-	// check if the user already has widgets
-	if (elgg_get_widgets($user->getGUID(), 'admin')) {
-		return true;
-	}
-
-	// In the form column => array of handlers in order, top to bottom
-	$adminWidgets = [
-		1 => ['control_panel', 'admin_welcome'],
-		2 => ['online_users', 'new_users', 'content_stats'],
-	];
-
-	foreach ($adminWidgets as $column => $handlers) {
-		foreach ($handlers as $position => $handler) {
-			$guid = elgg_create_widget($user->getGUID(), $handler, 'admin');
-			if ($guid) {
-				$widget = get_entity($guid);
-				/* @var \ElggWidget $widget */
-				$widget->move($column, $position);
-			}
-		}
-	}
-	elgg_set_ignore_access(false);
+    elgg_set_ignore_access(true);
+
+    // check if the user already has widgets
+    if (elgg_get_widgets($user->getGUID(), 'admin')) {
+        return true;
+    }
+
+    // In the form column => array of handlers in order, top to bottom
+    $adminWidgets = [
+        1 => ['control_panel', 'admin_welcome'],
+        2 => ['online_users', 'new_users', 'content_stats'],
+    ];
+
+    foreach ($adminWidgets as $column => $handlers) {
+        foreach ($handlers as $position => $handler) {
+            $guid = elgg_create_widget($user->getGUID(), $handler, 'admin');
+            if ($guid) {
+                $widget = get_entity($guid);
+                /* @var \ElggWidget $widget */
+                $widget->move($column, $position);
+            }
+        }
+    }
+    elgg_set_ignore_access(false);
 }
 
 /**
@@ -806,39 +806,39 @@ 
  */
 function _elgg_admin_get_admin_subscribers_admin_action($hook, $type, $return_value, $params) {
 	
-	if (!_elgg_config()->security_notify_admins) {
-		return;
-	}
+    if (!_elgg_config()->security_notify_admins) {
+        return;
+    }
 	
-	$event = elgg_extract('event', $params);
-	if (!($event instanceof \Elgg\Notifications\Event)) {
-		return;
-	}
+    $event = elgg_extract('event', $params);
+    if (!($event instanceof \Elgg\Notifications\Event)) {
+        return;
+    }
 	
-	if (!in_array($event->getAction(), ['make_admin', 'remove_admin'])) {
-		return;
-	}
+    if (!in_array($event->getAction(), ['make_admin', 'remove_admin'])) {
+        return;
+    }
 	
-	$user = $event->getObject();
-	if (!($user instanceof \ElggUser)) {
-		return;
-	}
+    $user = $event->getObject();
+    if (!($user instanceof \ElggUser)) {
+        return;
+    }
 	
-	/* @var $admin_batch \Elgg\BatchResult */
-	$admin_batch = elgg_get_admins([
-		'limit' => false,
-		'wheres' => [
-			"e.guid <> {$user->getGUID()}",
-		],
-		'batch' => true,
-	]);
+    /* @var $admin_batch \Elgg\BatchResult */
+    $admin_batch = elgg_get_admins([
+        'limit' => false,
+        'wheres' => [
+            "e.guid <> {$user->getGUID()}",
+        ],
+        'batch' => true,
+    ]);
 	
-	/* @var $admin \ElggUser */
-	foreach ($admin_batch as $admin) {
-		$return_value[$admin->getGUID()] = ['email'];
-	}
+    /* @var $admin \ElggUser */
+    foreach ($admin_batch as $admin) {
+        $return_value[$admin->getGUID()] = ['email'];
+    }
 	
-	return $return_value;
+    return $return_value;
 }
 
 /**
@@ -853,39 +853,39 @@ 
  */
 function _elgg_admin_prepare_admin_notification_make_admin($hook, $type, $return_value, $params) {
 	
-	if (!($return_value instanceof \Elgg\Notifications\Notification)) {
-		return;
-	}
+    if (!($return_value instanceof \Elgg\Notifications\Notification)) {
+        return;
+    }
 	
-	$recipient = elgg_extract('recipient', $params);
-	$object = elgg_extract('object', $params);
-	$actor = elgg_extract('sender', $params);
-	$language = elgg_extract('language', $params);
+    $recipient = elgg_extract('recipient', $params);
+    $object = elgg_extract('object', $params);
+    $actor = elgg_extract('sender', $params);
+    $language = elgg_extract('language', $params);
 	
-	if (!($recipient instanceof ElggUser) || !($object instanceof ElggUser) || !($actor instanceof ElggUser)) {
-		return;
-	}
+    if (!($recipient instanceof ElggUser) || !($object instanceof ElggUser) || !($actor instanceof ElggUser)) {
+        return;
+    }
 	
-	if ($recipient->getGUID() === $object->getGUID()) {
-		// recipient is the user being acted on, this is handled elsewhere
-		return;
-	}
+    if ($recipient->getGUID() === $object->getGUID()) {
+        // recipient is the user being acted on, this is handled elsewhere
+        return;
+    }
 	
-	$site = elgg_get_site_entity();
+    $site = elgg_get_site_entity();
 	
-	$return_value->subject = elgg_echo('admin:notification:make_admin:admin:subject', [$site->name], $language);
-	$return_value->body = elgg_echo('admin:notification:make_admin:admin:body', [
-		$recipient->name,
-		$actor->name,
-		$object->name,
-		$site->name,
-		$object->getURL(),
-		$site->getURL(),
-	], $language);
-
-	$return_value->url = elgg_normalize_url('admin/users/admins');
+    $return_value->subject = elgg_echo('admin:notification:make_admin:admin:subject', [$site->name], $language);
+    $return_value->body = elgg_echo('admin:notification:make_admin:admin:body', [
+        $recipient->name,
+        $actor->name,
+        $object->name,
+        $site->name,
+        $object->getURL(),
+        $site->getURL(),
+    ], $language);
+
+    $return_value->url = elgg_normalize_url('admin/users/admins');
 	
-	return $return_value;
+    return $return_value;
 }
 
 /**
@@ -900,39 +900,39 @@ 
  */
 function _elgg_admin_prepare_admin_notification_remove_admin($hook, $type, $return_value, $params) {
 	
-	if (!($return_value instanceof \Elgg\Notifications\Notification)) {
-		return;
-	}
+    if (!($return_value instanceof \Elgg\Notifications\Notification)) {
+        return;
+    }
 	
-	$recipient = elgg_extract('recipient', $params);
-	$object = elgg_extract('object', $params);
-	$actor = elgg_extract('sender', $params);
-	$language = elgg_extract('language', $params);
+    $recipient = elgg_extract('recipient', $params);
+    $object = elgg_extract('object', $params);
+    $actor = elgg_extract('sender', $params);
+    $language = elgg_extract('language', $params);
 	
-	if (!($recipient instanceof ElggUser) || !($object instanceof ElggUser) || !($actor instanceof ElggUser)) {
-		return;
-	}
+    if (!($recipient instanceof ElggUser) || !($object instanceof ElggUser) || !($actor instanceof ElggUser)) {
+        return;
+    }
 	
-	if ($recipient->getGUID() === $object->getGUID()) {
-		// recipient is the user being acted on, this is handled elsewhere
-		return;
-	}
+    if ($recipient->getGUID() === $object->getGUID()) {
+        // recipient is the user being acted on, this is handled elsewhere
+        return;
+    }
 	
-	$site = elgg_get_site_entity();
+    $site = elgg_get_site_entity();
 	
-	$return_value->subject = elgg_echo('admin:notification:remove_admin:admin:subject', [$site->name], $language);
-	$return_value->body = elgg_echo('admin:notification:remove_admin:admin:body', [
-		$recipient->name,
-		$actor->name,
-		$object->name,
-		$site->name,
-		$object->getURL(),
-		$site->getURL(),
-	], $language);
-
-	$return_value->url = elgg_normalize_url('admin/users/admins');
+    $return_value->subject = elgg_echo('admin:notification:remove_admin:admin:subject', [$site->name], $language);
+    $return_value->body = elgg_echo('admin:notification:remove_admin:admin:body', [
+        $recipient->name,
+        $actor->name,
+        $object->name,
+        $site->name,
+        $object->getURL(),
+        $site->getURL(),
+    ], $language);
+
+    $return_value->url = elgg_normalize_url('admin/users/admins');
 	
-	return $return_value;
+    return $return_value;
 }
 
 /**
@@ -947,27 +947,27 @@ 
  */
 function _elgg_admin_get_user_subscriber_admin_action($hook, $type, $return_value, $params) {
 	
-	if (!_elgg_config()->security_notify_user_admin) {
-		return;
-	}
+    if (!_elgg_config()->security_notify_user_admin) {
+        return;
+    }
 	
-	$event = elgg_extract('event', $params);
-	if (!($event instanceof \Elgg\Notifications\Event)) {
-		return;
-	}
+    $event = elgg_extract('event', $params);
+    if (!($event instanceof \Elgg\Notifications\Event)) {
+        return;
+    }
 	
-	if (!in_array($event->getAction(), ['make_admin', 'remove_admin'])) {
-		return;
-	}
+    if (!in_array($event->getAction(), ['make_admin', 'remove_admin'])) {
+        return;
+    }
 	
-	$user = $event->getObject();
-	if (!($user instanceof \ElggUser)) {
-		return;
-	}
+    $user = $event->getObject();
+    if (!($user instanceof \ElggUser)) {
+        return;
+    }
 	
-	$return_value[$user->getGUID()] = ['email'];
+    $return_value[$user->getGUID()] = ['email'];
 	
-	return $return_value;
+    return $return_value;
 }
 
 /**
@@ -982,37 +982,37 @@ 
  */
 function _elgg_admin_prepare_user_notification_make_admin($hook, $type, $return_value, $params) {
 	
-	if (!($return_value instanceof \Elgg\Notifications\Notification)) {
-		return;
-	}
+    if (!($return_value instanceof \Elgg\Notifications\Notification)) {
+        return;
+    }
 	
-	$recipient = elgg_extract('recipient', $params);
-	$object = elgg_extract('object', $params);
-	$actor = elgg_extract('sender', $params);
-	$language = elgg_extract('language', $params);
+    $recipient = elgg_extract('recipient', $params);
+    $object = elgg_extract('object', $params);
+    $actor = elgg_extract('sender', $params);
+    $language = elgg_extract('language', $params);
 	
-	if (!($recipient instanceof ElggUser) || !($object instanceof ElggUser) || !($actor instanceof ElggUser)) {
-		return;
-	}
+    if (!($recipient instanceof ElggUser) || !($object instanceof ElggUser) || !($actor instanceof ElggUser)) {
+        return;
+    }
 	
-	if ($recipient->getGUID() !== $object->getGUID()) {
-		// recipient is some other user, this is handled elsewhere
-		return;
-	}
+    if ($recipient->getGUID() !== $object->getGUID()) {
+        // recipient is some other user, this is handled elsewhere
+        return;
+    }
 	
-	$site = elgg_get_site_entity();
+    $site = elgg_get_site_entity();
 	
-	$return_value->subject = elgg_echo('admin:notification:make_admin:user:subject', [$site->name], $language);
-	$return_value->body = elgg_echo('admin:notification:make_admin:user:body', [
-		$recipient->name,
-		$actor->name,
-		$site->name,
-		$site->getURL(),
-	], $language);
-
-	$return_value->url = elgg_normalize_url('admin');
+    $return_value->subject = elgg_echo('admin:notification:make_admin:user:subject', [$site->name], $language);
+    $return_value->body = elgg_echo('admin:notification:make_admin:user:body', [
+        $recipient->name,
+        $actor->name,
+        $site->name,
+        $site->getURL(),
+    ], $language);
+
+    $return_value->url = elgg_normalize_url('admin');
 	
-	return $return_value;
+    return $return_value;
 }
 
 /**
@@ -1027,39 +1027,39 @@ 
  */
 function _elgg_admin_prepare_user_notification_remove_admin($hook, $type, $return_value, $params) {
 	
-	if (!($return_value instanceof \Elgg\Notifications\Notification)) {
-		return;
-	}
+    if (!($return_value instanceof \Elgg\Notifications\Notification)) {
+        return;
+    }
 	
-	$recipient = elgg_extract('recipient', $params);
-	$object = elgg_extract('object', $params);
-	$actor = elgg_extract('sender', $params);
-	$language = elgg_extract('language', $params);
+    $recipient = elgg_extract('recipient', $params);
+    $object = elgg_extract('object', $params);
+    $actor = elgg_extract('sender', $params);
+    $language = elgg_extract('language', $params);
 	
-	if (!($recipient instanceof ElggUser) || !($object instanceof ElggUser) || !($actor instanceof ElggUser)) {
-		return;
-	}
+    if (!($recipient instanceof ElggUser) || !($object instanceof ElggUser) || !($actor instanceof ElggUser)) {
+        return;
+    }
 	
-	if ($recipient->getGUID() !== $object->getGUID()) {
-		// recipient is some other user, this is handled elsewhere
-		return;
-	}
+    if ($recipient->getGUID() !== $object->getGUID()) {
+        // recipient is some other user, this is handled elsewhere
+        return;
+    }
 	
-	$site = elgg_get_site_entity();
+    $site = elgg_get_site_entity();
 	
-	$return_value->subject = elgg_echo('admin:notification:remove_admin:user:subject', [$site->name], $language);
-	$return_value->body = elgg_echo('admin:notification:remove_admin:user:body', [
-		$recipient->name,
-		$actor->name,
-		$site->name,
-		$site->getURL(),
-	], $language);
-
-	$return_value->url = false;
+    $return_value->subject = elgg_echo('admin:notification:remove_admin:user:subject', [$site->name], $language);
+    $return_value->body = elgg_echo('admin:notification:remove_admin:user:body', [
+        $recipient->name,
+        $actor->name,
+        $site->name,
+        $site->getURL(),
+    ], $language);
+
+    $return_value->url = false;
 	
-	return $return_value;
+    return $return_value;
 }
 
 return function(\Elgg\EventsService $events, \Elgg\HooksRegistrationService $hooks) {
-	$events->registerHandler('init', 'system', '_elgg_admin_init');
+    $events->registerHandler('init', 'system', '_elgg_admin_init');
 };