midgard\portable\api\error\exception

Complexity

Total Complexity

29

Size/Duplication

Total Lines	208
Duplicated Lines	0 %

Test Coverage

Coverage

65.08%

Importance

Changes	2
Bugs	0	Features	0

29 Methods

Rating	Name	Duplication	Size	Complexity
A	access_denied()	0	3	1
A	__construct()	0	5	1
A	invalid_object()	0	3	1
A	quota()	0	3	1
A	object_no_parent()	0	3	1
A	not_exists()	0	3	1
A	invalid_name()	0	3	1
A	object_name_exists()	0	3	1
A	duplicate()	0	3	1
A	object_no_storage()	0	3	1
A	no_metadata()	0	3	1
A	has_dependants()	0	3	1
A	range()	0	3	1
A	internal()	0	5	1
A	sg_notfound()	0	3	1
A	ok()	0	3	1
A	not_connected()	0	3	1
A	not_object()	0	3	1
A	tree_is_circular()	0	3	1
A	invalid_property_value()	0	4	1
A	get_error_string()	0	3	1
A	missed_dependence()	0	3	1
A	object_exported()	0	3	1
A	object_deleted()	0	3	1
A	invalid_property()	0	3	1
A	user_data()	0	3	1
A	object_purged()	0	3	1
A	object_is_locked()	0	3	1
A	object_imported()	0	3	1

<?php
/**
 * @author CONTENT CONTROL http://www.contentcontrol-berlin.de/
 * @copyright CONTENT CONTROL http://www.contentcontrol-berlin.de/
 * @license http://www.gnu.org/licenses/gpl.html GNU General Public License
 */
namespace midgard\portable\api\error;

use midgard\portable\storage\connection;
use midgard_connection;
use Exception as base_exception;

class exception extends base_exception
{
    const OK = 0;
    const ERROR = -1;
    const ACCESS_DENIED = -2;
    const NO_METADATA = -3;
    const NOT_OBJECT = -4;
    const NOT_EXISTS = -5;
    const INVALID_NAME = -6;
    const DUPLICATE = -7;
    const HAS_DEPENDANTS = -8;
    const RANGE = -9;
    const NOT_CONNECTED = -10;
    const SG_NOTFOUND = -11;
    const INVALID_OBJECT = -12;
    const QUOTA = -13;
    const INTERNAL = -14;
    const OBJECT_NAME_EXISTS = -15;
    const OBJECT_NO_STORAGE = -16;
    const OBJECT_NO_PARENT = -17;
    const INVALID_PROPERTY_VALUE = -18;
    const INVALID_PROPERTY = -19;
    const USER_DATA = -20;
    const OBJECT_DELETED = -21;
    const OBJECT_PURGED = -22;
    const OBJECT_EXPORTED = -23;
    const OBJECT_IMPORTED = -24;
    const MISSED_DEPENDENCE = -25;
    const TREE_IS_CIRCULAR = -26;
    const OBJECT_IS_LOCKED = -27;

    private static array $messages = [
        self::OK => "MGD_ERR_OK",
        self::ACCESS_DENIED => "Access Denied",
        self::NO_METADATA => "Metadata class not defined",
        self::NOT_OBJECT => "Not Midgard Object",
        self::NOT_EXISTS => "Object does not exist",
        self::INVALID_NAME => "Invalid characters in object's name",
        self::DUPLICATE => "Object already exists",
        self::HAS_DEPENDANTS => "Object has dependants",
        self::RANGE => "Date range error",
        self::NOT_CONNECTED => "Not connected to the Midgard database",
        self::SG_NOTFOUND => "Sitegroup not found",
        self::INVALID_OBJECT => "Object not registered as Midgard Object",
        self::QUOTA => "Quota limit reached",
        self::INTERNAL => "Critical internal error",
        self::OBJECT_NAME_EXISTS => "Object with this name exists in tree",
        self::OBJECT_NO_STORAGE => "Storage table not defined for object",
        self::OBJECT_NO_PARENT => "Parent object in tree not defined",
        self::INVALID_PROPERTY_VALUE => "Invalid property value",
        self::INVALID_PROPERTY => "Invalid property",
        self::OBJECT_DELETED => "Object deleted",
        self::OBJECT_PURGED => "Object purged",
        self::OBJECT_EXPORTED => "Object already exported",
        self::OBJECT_IMPORTED => "Object already imported",
        self::MISSED_DEPENDENCE => "Missed dependence for object",
        self::TREE_IS_CIRCULAR => "Circular reference found in object's tree",
        self::OBJECT_IS_LOCKED => "Object is locked",
    ];

    public function __construct($message = "Undefined error", $code = self::ERROR, ?base_exception $previous = null)
    {
        midgard_connection::get_instance()->set_error($code);
        midgard_connection::get_instance()->set_error_string($message);
        parent::__construct($message, $code, $previous);
    }

    public static function ok() : self
    {
        return new self(self::$messages[self::OK], self::OK);
    }

    public static function access_denied() : self
    {
        return new self(self::$messages[self::ACCESS_DENIED], self::ACCESS_DENIED);
    }

    public static function no_metadata() : self
    {
        return new self(self::$messages[self::NO_METADATA], self::NO_METADATA);
    }

    public static function not_object() : self
    {
        return new self(self::$messages[self::NOT_OBJECT], self::NOT_OBJECT);
    }

    public static function not_exists() : self
    {
        return new self(self::$messages[self::NOT_EXISTS], self::NOT_EXISTS);
    }

    public static function invalid_name() : self
    {
        return new self(self::$messages[self::INVALID_NAME], self::INVALID_NAME);
    }

    public static function duplicate() : self
    {
        return new self(self::$messages[self::DUPLICATE], self::DUPLICATE);
    }

    public static function has_dependants() : self
    {
        return new self(self::$messages[self::HAS_DEPENDANTS], self::HAS_DEPENDANTS);
    }

    public static function range() : self
    {
        return new self(self::$messages[self::RANGE], self::RANGE);
    }

    public static function not_connected() : self
    {
        return new self(self::$messages[self::NOT_CONNECTED], self::NOT_CONNECTED);
    }

    public static function sg_notfound() : self
    {
        return new self(self::$messages[self::SG_NOTFOUND], self::SG_NOTFOUND);
    }

    public static function invalid_object() : self
    {
        return new self(self::$messages[self::INVALID_OBJECT], self::INVALID_OBJECT);
    }

    public static function quota() : self
    {
        return new self(self::$messages[self::QUOTA], self::QUOTA);
    }

    public static function internal(base_exception $exception) : self
    {
        $message = self::$messages[self::INTERNAL];
        connection::log()->critical($message, ['exception' => $exception]);
        return new self($message . ': ' . $exception->getMessage(), self::INTERNAL, $exception);
    }

    public static function object_name_exists() : self
    {
        return new self(self::$messages[self::OBJECT_NAME_EXISTS], self::OBJECT_NAME_EXISTS);
    }

    public static function object_no_storage() : self
    {
        return new self(self::$messages[self::OBJECT_NO_STORAGE], self::OBJECT_NO_STORAGE);
    }

    public static function object_no_parent() : self
    {
        return new self(self::$messages[self::OBJECT_NO_PARENT], self::OBJECT_NO_PARENT);
    }

    public static function invalid_property_value(?string $message = null) : self
    {
        $message ??= self::$messages[self::INVALID_PROPERTY_VALUE];
        return new self($message, self::INVALID_PROPERTY_VALUE);
    }

    public static function invalid_property(string $property) : self
    {
        return new self(self::$messages[self::INVALID_PROPERTY] . ' "' . $property . '"', self::INVALID_PROPERTY);
    }

    public static function user_data(string $message = 'Unknown error') : self
    {
        return new self($message, self::USER_DATA);
    }

    public static function object_deleted() : self
    {
        return new self(self::$messages[self::OBJECT_DELETED], self::OBJECT_DELETED);
    }

    public static function object_purged() : self
    {
        return new self(self::$messages[self::OBJECT_PURGED], self::OBJECT_PURGED);
    }

    public static function object_exported() : self
    {
        return new self(self::$messages[self::OBJECT_EXPORTED], self::OBJECT_EXPORTED);
    }

    public static function object_imported() : self
    {
        return new self(self::$messages[self::OBJECT_IMPORTED], self::OBJECT_IMPORTED);
    }

    public static function missed_dependence() : self
    {
        return new self(self::$messages[self::MISSED_DEPENDENCE], self::MISSED_DEPENDENCE);
    }

    public static function tree_is_circular() : self
    {
        return new self(self::$messages[self::TREE_IS_CIRCULAR], self::TREE_IS_CIRCULAR);
    }

    public static function object_is_locked() : self
    {
        return new self(self::$messages[self::OBJECT_IS_LOCKED], self::OBJECT_IS_LOCKED);
    }

    public static function get_error_string(int $code) : string
    {
        return self::$messages[$code] ?? "Undefined error";
    }
}