Cms\Model\Language

Complexity

Total Complexity

43

Size/Duplication

Total Lines	315
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	7

Importance

Changes

0

31 Methods

Rating	Name	Duplication	Size	Complexity
A	getSource()	0	4	1
A	afterCreate()	0	5	1
A	afterUpdate()	0	5	1
A	afterSave()	0	5	1
A	afterDelete()	0	5	1
A	buildCmsLanguagesCache()	0	24	3
A	afterValidation()	0	7	2
A	afterValidationOnCreate()	0	5	1
A	findCachedLanguages()	0	4	1
A	findCachedLanguagesIso()	0	11	3
A	findCachedByIso()	0	9	3
A	cacheKey()	0	4	1
A	getUpperSortorder()	0	6	1
A	setOnlyOnePrimary()	0	19	5
A	setId()	0	4	1
A	getId()	0	4	1
A	setIso()	0	4	1
A	getIso()	0	4	1
A	setName()	0	4	1
A	getName()	0	4	1
A	setSortorder()	0	4	1
A	getSortorder()	0	4	1
A	setUrl()	0	4	1
A	getUrl()	0	4	1
A	setPrimary()	0	4	1
A	getPrimary()	0	4	1
A	setShort_name()	0	4	1
A	getShort_name()	0	4	1
A	setLocale()	0	4	1
A	getLocale()	0	4	1
A	validation()	0	46	2

<?php
/**
 * @copyright Copyright (c) 2011 - 2014 Oleksandr Torosh (http://wezoom.net)
 * @author Oleksandr Torosh <web@wezoom.net>
 */

namespace Cms\Model;

use Application\Mvc\Helper\CmsCache;
use Phalcon\DI;
use Phalcon\Mvc\Model;
use Phalcon\Validation;
use Phalcon\Validation\Validator\Uniqueness;
use Phalcon\Validation\Validator\PresenceOf;

class Language extends Model
{

    public function getSource()
    {
        return "language";
    }

    public $id;
    public $iso;
    public $locale;
    public $name;
    public $short_name;
    public $url;
    public $sortorder;
    public $primary;

    public function validation()
    {
        $validator = new Validation();

        /**
        * ISO
        */
        $validator->add('iso', new Uniqueness([
            'model' => $this,
            "message" => "The inputted ISO language is existing"
        ]));
        $validator->add('iso', new PresenceOf([
            'model' => $this,
            'message' => 'ISO is required'
        ]));

        /**
        * Name
        */
        $validator->add('name', new Uniqueness([
            'model' => $this,
            "message" => "The inputted name is existing"
        ]));
        $validator->add('name', new PresenceOf([
            'model' => $this,
            'message' => 'Name is required'
        ]));

        /**
        * URL
        */
        $validator->add('url', new Uniqueness([
            'model' => $this,
            "message" => "The inputted URL is existing"
        ]
    ));

    if ($this->primary == 0) {
        $validator->add('url', new PresenceOf([
            'model' => $this,
            'message' => 'URL is required'
        ]));
    }

    return $this->validationHasFailed() != true;
}

    public function afterCreate()
    {
        $this->sortorder = $this->getUpperSortorder() + 1;

    }

    public function afterUpdate()
    {
        $cache = $this->getDI()->get('cache');

The method get cannot be called on $this->getDI() (of type null).

        $cache->delete(self::cacheKey());
    }

    public function afterSave()
    {
        CmsCache::getInstance()->save('languages', $this->buildCmsLanguagesCache());
        CmsCache::getInstance()->save('translates', Translate::buildCmsTranslatesCache());
    }

    public function afterDelete()
    {
        CmsCache::getInstance()->save('languages', $this->buildCmsLanguagesCache());
        CmsCache::getInstance()->save('translates', Translate::buildCmsTranslatesCache());
    }

    private function buildCmsLanguagesCache()
    {
        $modelsManager = DI::getDefault()->get('modelsManager');

The method get cannot be called on \Phalcon\DI::getDefault() (of type null).

        $qb = $modelsManager->createBuilder();
        $qb->from('Cms\Model\Language');
        $qb->orderBy('primary DESC, sortorder ASC');

        $entries = $qb->getQuery()->execute();
        $save = [];
        if ($entries->count()) {
            foreach ($entries as $el) {
                $save[$el->getIso()] = [
                    'id'         => $el->getId(),
                    'iso'        => $el->getIso(),
                    'locale'     => $el->getLocale(),
                    'name'       => $el->getName(),
                    'short_name' => $el->getShort_name(),
                    'url'        => $el->getUrl(),
                    'primary'    => $el->getPrimary(),
                ];
            }
        }
        return $save;
    }

    public function afterValidation()
    {
        if (!$this->sortorder) {
            $this->sortorder = $this->getUpperSortorder();
        }

    }

    public function afterValidationOnCreate()
    {
        $this->sortorder = $this->getUpperSortorder() + 1;

    }

    public static function findCachedLanguages()
    {
        return CmsCache::getInstance()->get('languages');
    }

    public static function findCachedLanguagesIso()
    {
        $languages = self::findCachedLanguages();
        $iso_array = [];
        if (!empty($languages)) {
            foreach ($languages as $lang) {
                $iso_array[] = $lang['iso'];
            }
        }
        return $iso_array;
    }

    public static function findCachedByIso($iso)
    {
        $languages = self::findCachedLanguages();
        foreach ($languages as $lang) {
            if ($iso == $lang['iso']) {
                return $lang;
            }
        }
    }

    public static function cacheKey()
    {
        return HOST_HASH . md5('Language::findCachedLanguages');
    }

    public function getUpperSortorder()
    {
        $count = self::count();
        return $count;

    }

    public function setOnlyOnePrimary()
    {
        if ($this->getPrimary() == 1) {
            $languages = $this->find();

Are you sure the assignment to $languages is correct as $this->find() (which targets Phalcon\Mvc\Model::find()) seems to always return null.

            foreach ($languages as $lang) {

The expression $languages of type null is not traversable.

                if ($lang->getId() != $this->getId()) {
                    $lang->setPrimary(0);
                    $lang->save();
                }
            }
        } else {
            $primary = $this->findFirst("primary = '1'");

Are you sure the assignment to $primary is correct as $this->findFirst('primary = \'1\'') (which targets Phalcon\Mvc\Model::findFirst()) seems to always return null.

            if (!$primary) {
                $this->setPrimary(1);
                $this->save();
                $this->getDI()->get('flash')->notice('There should always be a primary language');

The method get cannot be called on $this->getDI() (of type null).

            }
        }
    }

    /**
     * @param mixed $id
     */
    public function setId($id)
    {
        $this->id = $id;
    }

    /**
     * @return mixed
     */
    public function getId()
    {
        return $this->id;
    }

    /**
     * @param mixed $iso
     */
    public function setIso($iso)
    {
        $this->iso = $iso;
    }

    /**
     * @return mixed
     */
    public function getIso()
    {
        return $this->iso;
    }

    /**
     * @param mixed $name
     */
    public function setName($name)
    {
        $this->name = $name;
    }

    /**
     * @return mixed
     */
    public function getName()
    {
        return $this->name;
    }

    /**
     * @param mixed $sortorder
     */
    public function setSortorder($sortorder)
    {
        $this->sortorder = $sortorder;
    }

    /**
     * @return mixed
     */
    public function getSortorder()
    {
        return $this->sortorder;
    }

    /**
     * @param mixed $url
     */
    public function setUrl($url)
    {
        $this->url = $url;
    }

    /**
     * @return mixed
     */
    public function getUrl()
    {
        return $this->url;
    }

    /**
     * @param mixed $primary
     */
    public function setPrimary($primary)
    {
        $this->primary = $primary;
    }

    /**
     * @return mixed
     */
    public function getPrimary()
    {
        return $this->primary;
    }

    /**
     * @param mixed $short_name
     */
    public function setShort_name($short_name)
    {
        $this->short_name = $short_name;
    }

    /**
     * @return mixed
     */
    public function getShort_name()
    {
        return $this->short_name;
    }

    /**
     * @param mixed $locale
     */
    public function setLocale($locale)
    {
        $this->locale = $locale;
    }

    /**
     * @return mixed
     */
    public function getLocale()
    {
        return $this->locale;
    }

}