AliasModel

Complexity

Total Complexity

29

Size/Duplication

Total Lines	231
Duplicated Lines	5.19 %

Coupling/Cohesion

Components	2
Dependencies	3

Test Coverage

Coverage

83.93%

Importance

Changes	4
Bugs	0	Features	1

12 Methods

Rating	Name	Duplication	Size	Complexity
A	getName()	0	4	1
A	getEscapedName()	0	8	2
A	setName()	0	7	1
A	getAlias()	0	8	3
A	setAlias()	0	4	1
A	resetAlias()	0	6	1
C	getURL()	12	31	7
A	fetchFromAlias()	0	4	1
A	fetchFromSlug()	0	10	2
B	generateAlias()	0	28	4
B	getUniqueAlias()	0	25	5
A	getDisallowedAliases()	0	4	1

<?php
/**
 * This file contains functionality relating to database objects that have a custom URL such as teams and players
 *
 * @package    BZiON\Models
 * @license    https://github.com/allejo/bzion/blob/master/LICENSE.md GNU General Public License Version 3
 */

/**
 * A Model that has a URL and an alias
 * @package    BZiON\Models
 */
abstract class AliasModel extends UrlModel implements NamedModel
{
    /**
     * The name of the object
     * @var string
     */
    protected $name;

    /**
     * A unique URL-friendly identifier for the object
     * @var string
     */
    protected $alias;

    /**
     * Get the name of the object
     * @return string
     */
    public function getName()
    {
        return $this->name;
    }

    /**
     * Get the name of the team, safe for use in your HTML
     *
     * @return string The name of the team
     */
    public function getEscapedName()
    {
        if (!$this->valid) {
            return "<em>None</em>";
        }

        return $this->escape($this->name);
    }

    /**
     * Change the object's name
     *
     * @return self
     */
    public function setName($name)
    {
        $this->updateProperty($this->name, 'name', $name);
        $this->resetAlias();

        return $this;
    }

    /**
     * Get an object's alias
     * @return string|int The alias (or ID if the alias doesn't exist)
     */
    public function getAlias()
    {
        if ($this->alias !== null && $this->alias != "") {
            return $this->alias;
        }

        return $this->getId();
    }

    /**
     * Set a model's alias
     * @param  string $alias The new alias
     * @return void
     */
    public function setAlias($alias)
    {
        $this->updateProperty($this->alias, 'alias', $alias);
    }

    /**
     * Reset a model's alias based on its name
     * @return self
     */
    public function resetAlias()
    {
        $alias = static::generateAlias($this->name, $this->id);

        return $this->updateProperty($this->alias, 'alias', $alias);
    }

    /**
     * {@inheritdoc}
     *
     * @todo Redirect models with wrong alias when bzion.site.url_type === 'permalink'
     */
    public function getURL($action = 'show', $absolute = false, $params = array(), $vanity = false)
    {
        if (!$this->isValid()) {
            return "";
        }

        $forbiddenAliases = array('edit', 'delete', 'kick', 'invite', 'change-leader', 'matches', 'members');

        if (Service::getParameter('bzion.site.url_type') === 'permalink' && $this instanceof DuplexUrlInterface && !$vanity) {
            // Add both the alias and the ID to the URL if the model supports them

            // Make sure the alias is not forbidden
            if (in_array(strtolower($action), $forbiddenAliases)) {

This code seems to be duplicated across your project.

                $alias = $this->getId();
            } else {
                $alias = $this->alias;
            }

            // Add the alias to the query parameters
            $params = $params + array('alias' => $alias);
            $alias = $this->getId();
        } else {

This code seems to be duplicated across your project.

            if (in_array(strtolower($action), $forbiddenAliases)) {
                $alias = $this->getId();
            } else {
                $alias = $this->getAlias();
            }
        }

        return $this->getLink($alias, $action, $absolute, $params);
    }

    /**
     * Gets an entity from the supplied alias
     * @param  string     $alias The object's alias
     * @return AliasModel
     */
    public static function fetchFromAlias($alias)
    {
        return static::get(self::fetchIdFrom($alias, "alias"));
    }

    /**
     * {@inheritdoc}
     * @return AliasModel
     */
    public static function fetchFromSlug($slug)
    {
        if (ctype_digit((string) $slug)) {
            // Slug is an integer, we can fetch by ID
            return static::get((int) $slug);
        } else {
            // Slug is something else, we can fetch by alias
            return self::fetchFromAlias($slug);
        }
    }

    /**
     * Generate a URL-friendly unique alias for an object name
     *
     * @param  string      $name The original object name
     * @param  int|null    $id   The ID of the object, if it's being edited and not created
     * @return string|null The generated alias, or Null if we couldn't make one
     */
    public static function generateAlias($name, $id = null)
    {
        // Convert name to lowercase
        $name = strtolower($name);

        // List of characters which should be converted to dashes
        $makeDash = array(' ', '_');

        $name = str_replace($makeDash, '-', $name);

        // Only keep letters, numbers and dashes - delete everything else
        $name = preg_replace("/[^a-zA-Z\-0-9]+/", "", $name);

        if (str_replace('-', '', $name) == '') {
            // The name only contains symbols or Unicode characters!
            // This means we can't convert it to an alias
            return null;
        }

        // An alias name can't only contain numbers, because it will be
        // indistinguishable from an ID. If it does, add a dash in the end.
        // Also prevent aliases from taking names such as "new",
        while (preg_match("/^[0-9]+$/", $name)) {
            $name = $name . '-';
        }

        return self::getUniqueAlias($name, ($id) ?: 0);
    }

    /**
     * Make sure that the generated alias provided is unique
     *
     * @param  string $alias The alias
     * @param  int    $id    The ID of the object, if it's being edited and not created
     * @return string An alias that is guaranteed to be unique
     */
    private static function getUniqueAlias($alias, $id = 0)
    {
        // Try to find duplicates
        $db = Database::getInstance();
        $result = $db->query("SELECT alias FROM " . static::TABLE . " WHERE id != ? AND alias REGEXP ?", array($id, "^" . $alias . "[0-9]*$"));

        // Convert the multi-dimensional array that $db->query() gave us into
        // a single-dimensional one.
        $aliases = (is_array($result)) ? array_column($result, 'alias') : array();

        // If there's already an entry with the alias we generated, put a number
        // in the end of it and keep incrementing it until there is we find
        // an open spot.
        $currentAlias = $alias;
        for ($i = 2;; ++$i) {
            if (!in_array($currentAlias, $aliases)
            &&  !in_array($currentAlias, static::getDisallowedAliases())) {
                break;
            }

            $currentAlias = $alias . $i;
        }

        return $currentAlias;
    }

    /**
     * Get a list of aliases that should not be given to objects
     *
     * For example, you want to prevent teams from getting the "new" alias.
     * Otherwise, the team's link would be http://example.com/bzion/teams/new,
     * and the user would go to the team creation page instead of the team's page.
     * Disallowed aliases will have a number appended, so the URL would be
     * http://example.com/bzion/teams/new2
     *
     * @return string[]
     */
    protected static function getDisallowedAliases()
    {
        return array('new');
    }
}