ColumnAbstract::setDeletedBy() - Code Metrics - Inspection of "upgrade scrutinizer to 8.3" - zemit-cms/core - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — master ( 507036...762659 )

by Julien

created 2024-10-31 18:21 UTC

ColumnAbstract::setDeletedBy() A

↳ Parent: ColumnAbstract

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	1
c	1
b	0
f	0
nc	1
nop	1
dl	0
loc	3
ccs	2
cts	2
cp	1
crap	1
rs	10

<?php
/**
 * This file is part of the Zemit Framework.
 *
 * (c) Zemit Team <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE.txt
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace Zemit\Models\Abstracts;

use Phalcon\Db\RawValue;
use Zemit\Filter\Validation;
use Zemit\Models\AbstractModel;
use Zemit\Models\Data;
use Zemit\Models\Workspace;
use Zemit\Models\Table;
use Zemit\Models\Record;
use Zemit\Models\User;
use Zemit\Models\Abstracts\Interfaces\ColumnAbstractInterface;

/**
 * Class ColumnAbstract
 *
 * This class defines a Column abstract model that extends the AbstractModel class and implements the ColumnAbstractInterface.
 * It provides properties and methods for managing Column data.
 * 
 * @property Data[] $datalist
 * @property Data[] $DataList
 * @method Data[] getDataList(?array $params = null)
 *
 * @property Workspace[] $dataworkspacelist
 * @property Workspace[] $DataWorkspaceList
 * @method Workspace[] getDataWorkspaceList(?array $params = null)
 *
 * @property Table[] $datatablelist
 * @property Table[] $DataTableList
 * @method Table[] getDataTableList(?array $params = null)
 *
 * @property Record[] $datarecordlist
 * @property Record[] $DataRecordList
 * @method Record[] getDataRecordList(?array $params = null)
 *
 * @property Workspace $workspaceentity
 * @property Workspace $WorkspaceEntity
 * @method Workspace getWorkspaceEntity(?array $params = null)
 *
 * @property Table $tableentity
 * @property Table $TableEntity
 * @method Table getTableEntity(?array $params = null)
 *
 * @property User $createdbyentity
 * @property User $CreatedByEntity
 * @method User getCreatedByEntity(?array $params = null)
 *
 * @property User $createdasentity
 * @property User $CreatedAsEntity
 * @method User getCreatedAsEntity(?array $params = null)
 *
 * @property User $updatedbyentity
 * @property User $UpdatedByEntity
 * @method User getUpdatedByEntity(?array $params = null)
 *
 * @property User $updatedasentity
 * @property User $UpdatedAsEntity
 * @method User getUpdatedAsEntity(?array $params = null)
 *
 * @property User $deletedasentity
 * @property User $DeletedAsEntity
 * @method User getDeletedAsEntity(?array $params = null)
 *
 * @property User $deletedbyentity
 * @property User $DeletedByEntity
 * @method User getDeletedByEntity(?array $params = null)
 *
 * @property User $restoredbyentity
 * @property User $RestoredByEntity
 * @method User getRestoredByEntity(?array $params = null)
 */
abstract class ColumnAbstract extends AbstractModel implements ColumnAbstractInterface
{
    /**
     * Column: id
     * Attributes: First | Primary | NotNull | Numeric | Unsigned | AutoIncrement
     * @var mixed
     */
    public mixed $id = null;
        
    /**
     * Column: uuid
     * Attributes: NotNull | Size(36) | Type(5)
     * @var mixed
     */
    public mixed $uuid = null;
        
    /**
     * Column: workspace_id
     * Attributes: NotNull | Numeric | Unsigned
     * @var mixed
     */
    public mixed $workspaceId = null;
        
    /**
     * Column: table_id
     * Attributes: NotNull | Numeric | Unsigned
     * @var mixed
     */
    public mixed $tableId = null;
        
    /**
     * Column: name
     * Attributes: NotNull | Size(60) | Type(2)
     * @var mixed
     */
    public mixed $name = null;
        
    /**
     * Column: description
     * Attributes: Size(120) | Type(2)
     * @var mixed
     */
    public mixed $description = null;
        
    /**
     * Column: type
     * Attributes: NotNull | Size('text','number') | Type(18)
     * @var mixed
     */
    public mixed $type = 'text';
        
    /**
     * Column: validation_regex
     * Attributes: Size(1000) | Type(2)
     * @var mixed
     */
    public mixed $validationRegex = null;
        
    /**
     * Column: deleted
     * Attributes: NotNull | Numeric | Unsigned | Type(26)
     * @var mixed
     */
    public mixed $deleted = 0;
        
    /**
     * Column: created_at
     * Attributes: NotNull | Type(4)
     * @var mixed
     */
    public mixed $createdAt = null;
        
    /**
     * Column: created_by
     * Attributes: Numeric | Unsigned
     * @var mixed
     */
    public mixed $createdBy = null;
        
    /**
     * Column: created_as
     * Attributes: Numeric | Unsigned
     * @var mixed
     */
    public mixed $createdAs = null;
        
    /**
     * Column: updated_at
     * Attributes: Type(4)
     * @var mixed
     */
    public mixed $updatedAt = null;
        
    /**
     * Column: updated_by
     * Attributes: Numeric | Unsigned
     * @var mixed
     */
    public mixed $updatedBy = null;
        
    /**
     * Column: updated_as
     * Attributes: Numeric | Unsigned
     * @var mixed
     */
    public mixed $updatedAs = null;
        
    /**
     * Column: deleted_at
     * Attributes: Type(4)
     * @var mixed
     */
    public mixed $deletedAt = null;
        
    /**
     * Column: deleted_as
     * Attributes: Numeric | Unsigned
     * @var mixed
     */
    public mixed $deletedAs = null;
        
    /**
     * Column: deleted_by
     * Attributes: Numeric | Unsigned
     * @var mixed
     */
    public mixed $deletedBy = null;
        
    /**
     * Column: restored_at
     * Attributes: Type(4)
     * @var mixed
     */
    public mixed $restoredAt = null;
        
    /**
     * Column: restored_by
     * Attributes: Numeric | Unsigned
     * @var mixed
     */
    public mixed $restoredBy = null;
    
    /**
     * Returns the value of field id
     * Column: id
     * Attributes: First | Primary | NotNull | Numeric | Unsigned | AutoIncrement
     * @return mixed
     */
    public function getId(): mixed
    {
        return $this->id;
    }
    
    /**
     * Sets the value of field id
     * Column: id 
     * Attributes: First | Primary | NotNull | Numeric | Unsigned | AutoIncrement
     * @param mixed $id
     * @return void
     */
    public function setId(mixed $id): void
    {
        $this->id = $id;
    }
    
    /**
     * Returns the value of field uuid
     * Column: uuid
     * Attributes: NotNull | Size(36) | Type(5)
     * @return mixed
     */
    public function getUuid(): mixed
    {
        return $this->uuid;
    }
    
    /**
     * Sets the value of field uuid
     * Column: uuid 
     * Attributes: NotNull | Size(36) | Type(5)
     * @param mixed $uuid
     * @return void
     */
    public function setUuid(mixed $uuid): void
    {
        $this->uuid = $uuid;
    }
    
    /**
     * Returns the value of field workspaceId
     * Column: workspace_id
     * Attributes: NotNull | Numeric | Unsigned
     * @return mixed
     */
    public function getWorkspaceId(): mixed
    {
        return $this->workspaceId;
    }
    
    /**
     * Sets the value of field workspaceId
     * Column: workspace_id 
     * Attributes: NotNull | Numeric | Unsigned
     * @param mixed $workspaceId
     * @return void
     */
    public function setWorkspaceId(mixed $workspaceId): void
    {
        $this->workspaceId = $workspaceId;
    }
    
    /**
     * Returns the value of field tableId
     * Column: table_id
     * Attributes: NotNull | Numeric | Unsigned
     * @return mixed
     */
    public function getTableId(): mixed
    {
        return $this->tableId;
    }
    
    /**
     * Sets the value of field tableId
     * Column: table_id 
     * Attributes: NotNull | Numeric | Unsigned
     * @param mixed $tableId
     * @return void
     */
    public function setTableId(mixed $tableId): void
    {
        $this->tableId = $tableId;
    }
    
    /**
     * Returns the value of field name
     * Column: name
     * Attributes: NotNull | Size(60) | Type(2)
     * @return mixed
     */
    public function getName(): mixed
    {
        return $this->name;
    }
    
    /**
     * Sets the value of field name
     * Column: name 
     * Attributes: NotNull | Size(60) | Type(2)
     * @param mixed $name
     * @return void
     */
    public function setName(mixed $name): void
    {
        $this->name = $name;
    }
    
    /**
     * Returns the value of field description
     * Column: description
     * Attributes: Size(120) | Type(2)
     * @return mixed
     */
    public function getDescription(): mixed
    {
        return $this->description;
    }
    
    /**
     * Sets the value of field description
     * Column: description 
     * Attributes: Size(120) | Type(2)
     * @param mixed $description
     * @return void
     */
    public function setDescription(mixed $description): void
    {
        $this->description = $description;
    }
    
    /**
     * Returns the value of field type
     * Column: type
     * Attributes: NotNull | Size('text','number') | Type(18)
     * @return mixed
     */
    public function getType(): mixed
    {
        return $this->type;
    }
    
    /**
     * Sets the value of field type
     * Column: type 
     * Attributes: NotNull | Size('text','number') | Type(18)
     * @param mixed $type
     * @return void
     */
    public function setType(mixed $type): void
    {
        $this->type = $type;
    }
    
    /**
     * Returns the value of field validationRegex
     * Column: validation_regex
     * Attributes: Size(1000) | Type(2)
     * @return mixed
     */
    public function getValidationRegex(): mixed
    {
        return $this->validationRegex;
    }
    
    /**
     * Sets the value of field validationRegex
     * Column: validation_regex 
     * Attributes: Size(1000) | Type(2)
     * @param mixed $validationRegex
     * @return void
     */
    public function setValidationRegex(mixed $validationRegex): void
    {
        $this->validationRegex = $validationRegex;
    }
    
    /**
     * Returns the value of field deleted
     * Column: deleted
     * Attributes: NotNull | Numeric | Unsigned | Type(26)
     * @return mixed
     */
    public function getDeleted(): mixed
    {
        return $this->deleted;
    }
    
    /**
     * Sets the value of field deleted
     * Column: deleted 
     * Attributes: NotNull | Numeric | Unsigned | Type(26)
     * @param mixed $deleted
     * @return void
     */
    public function setDeleted(mixed $deleted): void
    {
        $this->deleted = $deleted;
    }
    
    /**
     * Returns the value of field createdAt
     * Column: created_at
     * Attributes: NotNull | Type(4)
     * @return mixed
     */
    public function getCreatedAt(): mixed
    {
        return $this->createdAt;
    }
    
    /**
     * Sets the value of field createdAt
     * Column: created_at 
     * Attributes: NotNull | Type(4)
     * @param mixed $createdAt
     * @return void
     */
    public function setCreatedAt(mixed $createdAt): void
    {
        $this->createdAt = $createdAt;
    }
    
    /**
     * Returns the value of field createdBy
     * Column: created_by
     * Attributes: Numeric | Unsigned
     * @return mixed
     */
    public function getCreatedBy(): mixed
    {
        return $this->createdBy;
    }
    
    /**
     * Sets the value of field createdBy
     * Column: created_by 
     * Attributes: Numeric | Unsigned
     * @param mixed $createdBy
     * @return void
     */
    public function setCreatedBy(mixed $createdBy): void
    {
        $this->createdBy = $createdBy;
    }
    
    /**
     * Returns the value of field createdAs
     * Column: created_as
     * Attributes: Numeric | Unsigned
     * @return mixed
     */
    public function getCreatedAs(): mixed
    {
        return $this->createdAs;
    }
    
    /**
     * Sets the value of field createdAs
     * Column: created_as 
     * Attributes: Numeric | Unsigned
     * @param mixed $createdAs
     * @return void
     */
    public function setCreatedAs(mixed $createdAs): void
    {
        $this->createdAs = $createdAs;
    }
    
    /**
     * Returns the value of field updatedAt
     * Column: updated_at
     * Attributes: Type(4)
     * @return mixed
     */
    public function getUpdatedAt(): mixed
    {
        return $this->updatedAt;
    }
    
    /**
     * Sets the value of field updatedAt
     * Column: updated_at 
     * Attributes: Type(4)
     * @param mixed $updatedAt
     * @return void
     */
    public function setUpdatedAt(mixed $updatedAt): void
    {
        $this->updatedAt = $updatedAt;
    }
    
    /**
     * Returns the value of field updatedBy
     * Column: updated_by
     * Attributes: Numeric | Unsigned
     * @return mixed
     */
    public function getUpdatedBy(): mixed
    {
        return $this->updatedBy;
    }
    
    /**
     * Sets the value of field updatedBy
     * Column: updated_by 
     * Attributes: Numeric | Unsigned
     * @param mixed $updatedBy
     * @return void
     */
    public function setUpdatedBy(mixed $updatedBy): void
    {
        $this->updatedBy = $updatedBy;
    }
    
    /**
     * Returns the value of field updatedAs
     * Column: updated_as
     * Attributes: Numeric | Unsigned
     * @return mixed
     */
    public function getUpdatedAs(): mixed
    {
        return $this->updatedAs;
    }
    
    /**
     * Sets the value of field updatedAs
     * Column: updated_as 
     * Attributes: Numeric | Unsigned
     * @param mixed $updatedAs
     * @return void
     */
    public function setUpdatedAs(mixed $updatedAs): void
    {
        $this->updatedAs = $updatedAs;
    }
    
    /**
     * Returns the value of field deletedAt
     * Column: deleted_at
     * Attributes: Type(4)
     * @return mixed
     */
    public function getDeletedAt(): mixed
    {
        return $this->deletedAt;
    }
    
    /**
     * Sets the value of field deletedAt
     * Column: deleted_at 
     * Attributes: Type(4)
     * @param mixed $deletedAt
     * @return void
     */
    public function setDeletedAt(mixed $deletedAt): void
    {
        $this->deletedAt = $deletedAt;
    }
    
    /**
     * Returns the value of field deletedAs
     * Column: deleted_as
     * Attributes: Numeric | Unsigned
     * @return mixed
     */
    public function getDeletedAs(): mixed
    {
        return $this->deletedAs;
    }
    
    /**
     * Sets the value of field deletedAs
     * Column: deleted_as 
     * Attributes: Numeric | Unsigned
     * @param mixed $deletedAs
     * @return void
     */
    public function setDeletedAs(mixed $deletedAs): void
    {
        $this->deletedAs = $deletedAs;
    }
    
    /**
     * Returns the value of field deletedBy
     * Column: deleted_by
     * Attributes: Numeric | Unsigned
     * @return mixed
     */
    public function getDeletedBy(): mixed
    {
        return $this->deletedBy;
    }
    
    /**
     * Sets the value of field deletedBy
     * Column: deleted_by 
     * Attributes: Numeric | Unsigned
     * @param mixed $deletedBy
     * @return void
     */
    public function setDeletedBy(mixed $deletedBy): void
    {
        $this->deletedBy = $deletedBy;
    }
    
    /**
     * Returns the value of field restoredAt
     * Column: restored_at
     * Attributes: Type(4)
     * @return mixed
     */
    public function getRestoredAt(): mixed
    {
        return $this->restoredAt;
    }
    
    /**
     * Sets the value of field restoredAt
     * Column: restored_at 
     * Attributes: Type(4)
     * @param mixed $restoredAt
     * @return void
     */
    public function setRestoredAt(mixed $restoredAt): void
    {
        $this->restoredAt = $restoredAt;
    }
    
    /**
     * Returns the value of field restoredBy
     * Column: restored_by
     * Attributes: Numeric | Unsigned
     * @return mixed
     */
    public function getRestoredBy(): mixed
    {
        return $this->restoredBy;
    }
    
    /**
     * Sets the value of field restoredBy
     * Column: restored_by 
     * Attributes: Numeric | Unsigned
     * @param mixed $restoredBy
     * @return void
     */
    public function setRestoredBy(mixed $restoredBy): void
    {
        $this->restoredBy = $restoredBy;
    }

    /**
     * Adds the default relationships to the model.
     * @return void
     */
    public function addDefaultRelationships(): void
    {
        $this->hasMany('id', Data::class, 'columnId', ['alias' => 'DataList']);

        $this->hasManyToMany(
            'id',
            Data::class,
            'columnId',
            'workspaceId',
            Workspace::class,
            'id',
            ['alias' => 'DataWorkspaceList']
        );

        $this->hasManyToMany(
            'id',
            Data::class,
            'columnId',
            'tableId',
            Table::class,
            'id',
            ['alias' => 'DataTableList']
        );

        $this->hasManyToMany(
            'id',
            Data::class,
            'columnId',
            'recordId',
            Record::class,
            'id',
            ['alias' => 'DataRecordList']
        );

        $this->belongsTo('workspaceId', Workspace::class, 'id', ['alias' => 'WorkspaceEntity']);

        $this->belongsTo('tableId', Table::class, 'id', ['alias' => 'TableEntity']);

        $this->belongsTo('createdBy', User::class, 'id', ['alias' => 'CreatedByEntity']);

        $this->belongsTo('createdAs', User::class, 'id', ['alias' => 'CreatedAsEntity']);

        $this->belongsTo('updatedBy', User::class, 'id', ['alias' => 'UpdatedByEntity']);

        $this->belongsTo('updatedAs', User::class, 'id', ['alias' => 'UpdatedAsEntity']);

        $this->belongsTo('deletedAs', User::class, 'id', ['alias' => 'DeletedAsEntity']);

        $this->belongsTo('deletedBy', User::class, 'id', ['alias' => 'DeletedByEntity']);

        $this->belongsTo('restoredBy', User::class, 'id', ['alias' => 'RestoredByEntity']);
    }
    
    /**
     * Adds the default validations to the model.
     * @param Validation|null $validator
     * @return Validation
     */
    public function addDefaultValidations(?Validation $validator = null): Validation
    {
        $validator ??= new Validation();
    
        $this->addUnsignedIntValidation($validator, 'id', true);
        $this->addStringLengthValidation($validator, 'uuid', 0, 36, false);
        $this->addUnsignedIntValidation($validator, 'workspaceId', false);
        $this->addUnsignedIntValidation($validator, 'tableId', false);
        $this->addStringLengthValidation($validator, 'name', 0, 60, false);
        $this->addStringLengthValidation($validator, 'description', 0, 120, true);
        $this->addInclusionInValidation($validator, 'type', ['text','number'], false);
        $this->addStringLengthValidation($validator, 'validationRegex', 0, 1000, true);
        $this->addUnsignedIntValidation($validator, 'deleted', false);
        $this->addDateTimeValidation($validator, 'createdAt', false);
        $this->addUnsignedIntValidation($validator, 'createdBy', true);
        $this->addUnsignedIntValidation($validator, 'createdAs', true);
        $this->addDateTimeValidation($validator, 'updatedAt', true);
        $this->addUnsignedIntValidation($validator, 'updatedBy', true);
        $this->addUnsignedIntValidation($validator, 'updatedAs', true);
        $this->addDateTimeValidation($validator, 'deletedAt', true);
        $this->addUnsignedIntValidation($validator, 'deletedAs', true);
        $this->addUnsignedIntValidation($validator, 'deletedBy', true);
        $this->addDateTimeValidation($validator, 'restoredAt', true);
        $this->addUnsignedIntValidation($validator, 'restoredBy', true);
        
        return $validator;
    }

        
    /**
     * Returns an array that maps the column names of the database
     * table to the corresponding property names of the model.
     * 
     * @returns array The array mapping the column names to the property names
     */
    public function columnMap(): array
    {
        return [
            'id' => 'id',
            'uuid' => 'uuid',
            'workspace_id' => 'workspaceId',
            'table_id' => 'tableId',
            'name' => 'name',
            'description' => 'description',
            'type' => 'type',
            'validation_regex' => 'validationRegex',
            'deleted' => 'deleted',
            'created_at' => 'createdAt',
            'created_by' => 'createdBy',
            'created_as' => 'createdAs',
            'updated_at' => 'updatedAt',
            'updated_by' => 'updatedBy',
            'updated_as' => 'updatedAs',
            'deleted_at' => 'deletedAt',
            'deleted_as' => 'deletedAs',
            'deleted_by' => 'deletedBy',
            'restored_at' => 'restoredAt',
            'restored_by' => 'restoredBy',
        ];
    }
}


1		<?php
2		/**
3		* This file is part of the Zemit Framework.
4		*
5		* (c) Zemit Team <[email protected]>
6		*
7		* For the full copyright and license information, please view the LICENSE.txt
8		* file that was distributed with this source code.
9		*/
10
11		declare(strict_types=1);
12
13		namespace Zemit\Models\Abstracts;
14
15		use Phalcon\Db\RawValue;
16		use Zemit\Filter\Validation;
17		use Zemit\Models\AbstractModel;
18		use Zemit\Models\Data;
19		use Zemit\Models\Workspace;
20		use Zemit\Models\Table;
21		use Zemit\Models\Record;
22		use Zemit\Models\User;
23		use Zemit\Models\Abstracts\Interfaces\ColumnAbstractInterface;
24
25		/**
26		* Class ColumnAbstract
27		*
28		* This class defines a Column abstract model that extends the AbstractModel class and implements the ColumnAbstractInterface.
29		* It provides properties and methods for managing Column data.
30		*
31		* @property Data[] $datalist
32		* @property Data[] $DataList
33		* @method Data[] getDataList(?array $params = null)
34		*
35		* @property Workspace[] $dataworkspacelist
36		* @property Workspace[] $DataWorkspaceList
37		* @method Workspace[] getDataWorkspaceList(?array $params = null)
38		*
39		* @property Table[] $datatablelist
40		* @property Table[] $DataTableList
41		* @method Table[] getDataTableList(?array $params = null)
42		*
43		* @property Record[] $datarecordlist
44		* @property Record[] $DataRecordList
45		* @method Record[] getDataRecordList(?array $params = null)
46		*
47		* @property Workspace $workspaceentity
48		* @property Workspace $WorkspaceEntity
49		* @method Workspace getWorkspaceEntity(?array $params = null)
50		*
51		* @property Table $tableentity
52		* @property Table $TableEntity
53		* @method Table getTableEntity(?array $params = null)
54		*
55		* @property User $createdbyentity
56		* @property User $CreatedByEntity
57		* @method User getCreatedByEntity(?array $params = null)
58		*
59		* @property User $createdasentity
60		* @property User $CreatedAsEntity
61		* @method User getCreatedAsEntity(?array $params = null)
62		*
63		* @property User $updatedbyentity
64		* @property User $UpdatedByEntity
65		* @method User getUpdatedByEntity(?array $params = null)
66		*
67		* @property User $updatedasentity
68		* @property User $UpdatedAsEntity
69		* @method User getUpdatedAsEntity(?array $params = null)
70		*
71		* @property User $deletedasentity
72		* @property User $DeletedAsEntity
73		* @method User getDeletedAsEntity(?array $params = null)
74		*
75		* @property User $deletedbyentity
76		* @property User $DeletedByEntity
77		* @method User getDeletedByEntity(?array $params = null)
78		*
79		* @property User $restoredbyentity
80		* @property User $RestoredByEntity
81		* @method User getRestoredByEntity(?array $params = null)
82		*/
83		abstract class ColumnAbstract extends AbstractModel implements ColumnAbstractInterface
84		{
85		/**
86		* Column: id
87		* Attributes: First \| Primary \| NotNull \| Numeric \| Unsigned \| AutoIncrement
88		* @var mixed
89		*/
90		public mixed $id = null;
91
92		/**
93		* Column: uuid
94		* Attributes: NotNull \| Size(36) \| Type(5)
95		* @var mixed
96		*/
97		public mixed $uuid = null;
98
99		/**
100		* Column: workspace_id
101		* Attributes: NotNull \| Numeric \| Unsigned
102		* @var mixed
103		*/
104		public mixed $workspaceId = null;
105
106		/**
107		* Column: table_id
108		* Attributes: NotNull \| Numeric \| Unsigned
109		* @var mixed
110		*/
111		public mixed $tableId = null;
112
113		/**
114		* Column: name
115		* Attributes: NotNull \| Size(60) \| Type(2)
116		* @var mixed
117		*/
118		public mixed $name = null;
119
120		/**
121		* Column: description
122		* Attributes: Size(120) \| Type(2)
123		* @var mixed
124		*/
125		public mixed $description = null;
126
127		/**
128		* Column: type
129		* Attributes: NotNull \| Size('text','number') \| Type(18)
130		* @var mixed
131		*/
132		public mixed $type = 'text';
133
134		/**
135		* Column: validation_regex
136		* Attributes: Size(1000) \| Type(2)
137		* @var mixed
138		*/
139		public mixed $validationRegex = null;
140
141		/**
142		* Column: deleted
143		* Attributes: NotNull \| Numeric \| Unsigned \| Type(26)
144		* @var mixed
145		*/
146		public mixed $deleted = 0;
147
148		/**
149		* Column: created_at
150		* Attributes: NotNull \| Type(4)
151		* @var mixed
152		*/
153		public mixed $createdAt = null;
154
155		/**
156		* Column: created_by
157		* Attributes: Numeric \| Unsigned
158		* @var mixed
159		*/
160		public mixed $createdBy = null;
161
162		/**
163		* Column: created_as
164		* Attributes: Numeric \| Unsigned
165		* @var mixed
166		*/
167		public mixed $createdAs = null;
168
169		/**
170		* Column: updated_at
171		* Attributes: Type(4)
172		* @var mixed
173		*/
174		public mixed $updatedAt = null;
175
176		/**
177		* Column: updated_by
178		* Attributes: Numeric \| Unsigned
179		* @var mixed
180		*/
181		public mixed $updatedBy = null;
182
183		/**
184		* Column: updated_as
185		* Attributes: Numeric \| Unsigned
186		* @var mixed
187		*/
188		public mixed $updatedAs = null;
189
190		/**
191		* Column: deleted_at
192		* Attributes: Type(4)
193		* @var mixed
194		*/
195		public mixed $deletedAt = null;
196
197		/**
198		* Column: deleted_as
199		* Attributes: Numeric \| Unsigned
200		* @var mixed
201		*/
202		public mixed $deletedAs = null;
203
204		/**
205		* Column: deleted_by
206		* Attributes: Numeric \| Unsigned
207		* @var mixed
208		*/
209		public mixed $deletedBy = null;
210
211		/**
212		* Column: restored_at
213		* Attributes: Type(4)
214		* @var mixed
215		*/
216		public mixed $restoredAt = null;
217
218		/**
219		* Column: restored_by
220		* Attributes: Numeric \| Unsigned
221		* @var mixed
222		*/
223		public mixed $restoredBy = null;
224
225		/**
226		* Returns the value of field id
227		* Column: id
228		* Attributes: First \| Primary \| NotNull \| Numeric \| Unsigned \| AutoIncrement
229		* @return mixed
230		*/
231	2	public function getId(): mixed
232		{
233	2	return $this->id;
234		}
235
236		/**
237		* Sets the value of field id
238		* Column: id
239		* Attributes: First \| Primary \| NotNull \| Numeric \| Unsigned \| AutoIncrement
240		* @param mixed $id
241		* @return void
242		*/
243	1	public function setId(mixed $id): void
244		{
245	1	$this->id = $id;
246		}
247
248		/**
249		* Returns the value of field uuid
250		* Column: uuid
251		* Attributes: NotNull \| Size(36) \| Type(5)
252		* @return mixed
253		*/
254	2	public function getUuid(): mixed
255		{
256	2	return $this->uuid;
257		}
258
259		/**
260		* Sets the value of field uuid
261		* Column: uuid
262		* Attributes: NotNull \| Size(36) \| Type(5)
263		* @param mixed $uuid
264		* @return void
265		*/
266	1	public function setUuid(mixed $uuid): void
267		{
268	1	$this->uuid = $uuid;
269		}
270
271		/**
272		* Returns the value of field workspaceId
273		* Column: workspace_id
274		* Attributes: NotNull \| Numeric \| Unsigned
275		* @return mixed
276		*/
277	2	public function getWorkspaceId(): mixed
278		{
279	2	return $this->workspaceId;
280		}
281
282		/**
283		* Sets the value of field workspaceId
284		* Column: workspace_id
285		* Attributes: NotNull \| Numeric \| Unsigned
286		* @param mixed $workspaceId
287		* @return void
288		*/
289	1	public function setWorkspaceId(mixed $workspaceId): void
290		{
291	1	$this->workspaceId = $workspaceId;
292		}
293
294		/**
295		* Returns the value of field tableId
296		* Column: table_id
297		* Attributes: NotNull \| Numeric \| Unsigned
298		* @return mixed
299		*/
300	2	public function getTableId(): mixed
301		{
302	2	return $this->tableId;
303		}
304
305		/**
306		* Sets the value of field tableId
307		* Column: table_id
308		* Attributes: NotNull \| Numeric \| Unsigned
309		* @param mixed $tableId
310		* @return void
311		*/
312	1	public function setTableId(mixed $tableId): void
313		{
314	1	$this->tableId = $tableId;
315		}
316
317		/**
318		* Returns the value of field name
319		* Column: name
320		* Attributes: NotNull \| Size(60) \| Type(2)
321		* @return mixed
322		*/
323	2	public function getName(): mixed
324		{
325	2	return $this->name;
326		}
327
328		/**
329		* Sets the value of field name
330		* Column: name
331		* Attributes: NotNull \| Size(60) \| Type(2)
332		* @param mixed $name
333		* @return void
334		*/
335	1	public function setName(mixed $name): void
336		{
337	1	$this->name = $name;
338		}
339
340		/**
341		* Returns the value of field description
342		* Column: description
343		* Attributes: Size(120) \| Type(2)
344		* @return mixed
345		*/
346	2	public function getDescription(): mixed
347		{
348	2	return $this->description;
349		}
350
351		/**
352		* Sets the value of field description
353		* Column: description
354		* Attributes: Size(120) \| Type(2)
355		* @param mixed $description
356		* @return void
357		*/
358	1	public function setDescription(mixed $description): void
359		{
360	1	$this->description = $description;
361		}
362
363		/**
364		* Returns the value of field type
365		* Column: type
366		* Attributes: NotNull \| Size('text','number') \| Type(18)
367		* @return mixed
368		*/
369	2	public function getType(): mixed
370		{
371	2	return $this->type;
372		}
373
374		/**
375		* Sets the value of field type
376		* Column: type
377		* Attributes: NotNull \| Size('text','number') \| Type(18)
378		* @param mixed $type
379		* @return void
380		*/
381	1	public function setType(mixed $type): void
382		{
383	1	$this->type = $type;
384		}
385
386		/**
387		* Returns the value of field validationRegex
388		* Column: validation_regex
389		* Attributes: Size(1000) \| Type(2)
390		* @return mixed
391		*/
392	2	public function getValidationRegex(): mixed
393		{
394	2	return $this->validationRegex;
395		}
396
397		/**
398		* Sets the value of field validationRegex
399		* Column: validation_regex
400		* Attributes: Size(1000) \| Type(2)
401		* @param mixed $validationRegex
402		* @return void
403		*/
404	1	public function setValidationRegex(mixed $validationRegex): void
405		{
406	1	$this->validationRegex = $validationRegex;
407		}
408
409		/**
410		* Returns the value of field deleted
411		* Column: deleted
412		* Attributes: NotNull \| Numeric \| Unsigned \| Type(26)
413		* @return mixed
414		*/
415	2	public function getDeleted(): mixed
416		{
417	2	return $this->deleted;
418		}
419
420		/**
421		* Sets the value of field deleted
422		* Column: deleted
423		* Attributes: NotNull \| Numeric \| Unsigned \| Type(26)
424		* @param mixed $deleted
425		* @return void
426		*/
427	1	public function setDeleted(mixed $deleted): void
428		{
429	1	$this->deleted = $deleted;
430		}
431
432		/**
433		* Returns the value of field createdAt
434		* Column: created_at
435		* Attributes: NotNull \| Type(4)
436		* @return mixed
437		*/
438	2	public function getCreatedAt(): mixed
439		{
440	2	return $this->createdAt;
441		}
442
443		/**
444		* Sets the value of field createdAt
445		* Column: created_at
446		* Attributes: NotNull \| Type(4)
447		* @param mixed $createdAt
448		* @return void
449		*/
450	1	public function setCreatedAt(mixed $createdAt): void
451		{
452	1	$this->createdAt = $createdAt;
453		}
454
455		/**
456		* Returns the value of field createdBy
457		* Column: created_by
458		* Attributes: Numeric \| Unsigned
459		* @return mixed
460		*/
461	2	public function getCreatedBy(): mixed
462		{
463	2	return $this->createdBy;
464		}
465
466		/**
467		* Sets the value of field createdBy
468		* Column: created_by
469		* Attributes: Numeric \| Unsigned
470		* @param mixed $createdBy
471		* @return void
472		*/
473	1	public function setCreatedBy(mixed $createdBy): void
474		{
475	1	$this->createdBy = $createdBy;
476		}
477
478		/**
479		* Returns the value of field createdAs
480		* Column: created_as
481		* Attributes: Numeric \| Unsigned
482		* @return mixed
483		*/
484	2	public function getCreatedAs(): mixed
485		{
486	2	return $this->createdAs;
487		}
488
489		/**
490		* Sets the value of field createdAs
491		* Column: created_as
492		* Attributes: Numeric \| Unsigned
493		* @param mixed $createdAs
494		* @return void
495		*/
496	1	public function setCreatedAs(mixed $createdAs): void
497		{
498	1	$this->createdAs = $createdAs;
499		}
500
501		/**
502		* Returns the value of field updatedAt
503		* Column: updated_at
504		* Attributes: Type(4)
505		* @return mixed
506		*/
507	2	public function getUpdatedAt(): mixed
508		{
509	2	return $this->updatedAt;
510		}
511
512		/**
513		* Sets the value of field updatedAt
514		* Column: updated_at
515		* Attributes: Type(4)
516		* @param mixed $updatedAt
517		* @return void
518		*/
519	1	public function setUpdatedAt(mixed $updatedAt): void
520		{
521	1	$this->updatedAt = $updatedAt;
522		}
523
524		/**
525		* Returns the value of field updatedBy
526		* Column: updated_by
527		* Attributes: Numeric \| Unsigned
528		* @return mixed
529		*/
530	2	public function getUpdatedBy(): mixed
531		{
532	2	return $this->updatedBy;
533		}
534
535		/**
536		* Sets the value of field updatedBy
537		* Column: updated_by
538		* Attributes: Numeric \| Unsigned
539		* @param mixed $updatedBy
540		* @return void
541		*/
542	1	public function setUpdatedBy(mixed $updatedBy): void
543		{
544	1	$this->updatedBy = $updatedBy;
545		}
546
547		/**
548		* Returns the value of field updatedAs
549		* Column: updated_as
550		* Attributes: Numeric \| Unsigned
551		* @return mixed
552		*/
553	2	public function getUpdatedAs(): mixed
554		{
555	2	return $this->updatedAs;
556		}
557
558		/**
559		* Sets the value of field updatedAs
560		* Column: updated_as
561		* Attributes: Numeric \| Unsigned
562		* @param mixed $updatedAs
563		* @return void
564		*/
565	1	public function setUpdatedAs(mixed $updatedAs): void
566		{
567	1	$this->updatedAs = $updatedAs;
568		}
569
570		/**
571		* Returns the value of field deletedAt
572		* Column: deleted_at
573		* Attributes: Type(4)
574		* @return mixed
575		*/
576	2	public function getDeletedAt(): mixed
577		{
578	2	return $this->deletedAt;
579		}
580
581		/**
582		* Sets the value of field deletedAt
583		* Column: deleted_at
584		* Attributes: Type(4)
585		* @param mixed $deletedAt
586		* @return void
587		*/
588	1	public function setDeletedAt(mixed $deletedAt): void
589		{
590	1	$this->deletedAt = $deletedAt;
591		}
592
593		/**
594		* Returns the value of field deletedAs
595		* Column: deleted_as
596		* Attributes: Numeric \| Unsigned
597		* @return mixed
598		*/
599	2	public function getDeletedAs(): mixed
600		{
601	2	return $this->deletedAs;
602		}
603
604		/**
605		* Sets the value of field deletedAs
606		* Column: deleted_as
607		* Attributes: Numeric \| Unsigned
608		* @param mixed $deletedAs
609		* @return void
610		*/
611	1	public function setDeletedAs(mixed $deletedAs): void
612		{
613	1	$this->deletedAs = $deletedAs;
614		}
615
616		/**
617		* Returns the value of field deletedBy
618		* Column: deleted_by
619		* Attributes: Numeric \| Unsigned
620		* @return mixed
621		*/
622	2	public function getDeletedBy(): mixed
623		{
624	2	return $this->deletedBy;
625		}
626
627		/**
628		* Sets the value of field deletedBy
629		* Column: deleted_by
630		* Attributes: Numeric \| Unsigned
631		* @param mixed $deletedBy
632		* @return void
633		*/
634	1	public function setDeletedBy(mixed $deletedBy): void
635		{
636	1	$this->deletedBy = $deletedBy;
637		}
638
639		/**
640		* Returns the value of field restoredAt
641		* Column: restored_at
642		* Attributes: Type(4)
643		* @return mixed
644		*/
645	2	public function getRestoredAt(): mixed
646		{
647	2	return $this->restoredAt;
648		}
649
650		/**
651		* Sets the value of field restoredAt
652		* Column: restored_at
653		* Attributes: Type(4)
654		* @param mixed $restoredAt
655		* @return void
656		*/
657	1	public function setRestoredAt(mixed $restoredAt): void
658		{
659	1	$this->restoredAt = $restoredAt;
660		}
661
662		/**
663		* Returns the value of field restoredBy
664		* Column: restored_by
665		* Attributes: Numeric \| Unsigned
666		* @return mixed
667		*/
668	2	public function getRestoredBy(): mixed
669		{
670	2	return $this->restoredBy;
671		}
672
673		/**
674		* Sets the value of field restoredBy
675		* Column: restored_by
676		* Attributes: Numeric \| Unsigned
677		* @param mixed $restoredBy
678		* @return void
679		*/
680	1	public function setRestoredBy(mixed $restoredBy): void
681		{
682	1	$this->restoredBy = $restoredBy;
683		}
684
685		/**
686		* Adds the default relationships to the model.
687		* @return void
688		*/
689	1	public function addDefaultRelationships(): void
690		{
691	1	$this->hasMany('id', Data::class, 'columnId', ['alias' => 'DataList']);
692
693	1	$this->hasManyToMany(
694	1	'id',
695	1	Data::class,
696	1	'columnId',
697	1	'workspaceId',
698	1	Workspace::class,
699	1	'id',
700	1	['alias' => 'DataWorkspaceList']
701	1	);
702
703	1	$this->hasManyToMany(
704	1	'id',
705	1	Data::class,
706	1	'columnId',
707	1	'tableId',
708	1	Table::class,
709	1	'id',
710	1	['alias' => 'DataTableList']
711	1	);
712
713	1	$this->hasManyToMany(
714	1	'id',
715	1	Data::class,
716	1	'columnId',
717	1	'recordId',
718	1	Record::class,
719	1	'id',
720	1	['alias' => 'DataRecordList']
721	1	);
722
723	1	$this->belongsTo('workspaceId', Workspace::class, 'id', ['alias' => 'WorkspaceEntity']);
724
725	1	$this->belongsTo('tableId', Table::class, 'id', ['alias' => 'TableEntity']);
726
727	1	$this->belongsTo('createdBy', User::class, 'id', ['alias' => 'CreatedByEntity']);
728
729	1	$this->belongsTo('createdAs', User::class, 'id', ['alias' => 'CreatedAsEntity']);
730
731	1	$this->belongsTo('updatedBy', User::class, 'id', ['alias' => 'UpdatedByEntity']);
732
733	1	$this->belongsTo('updatedAs', User::class, 'id', ['alias' => 'UpdatedAsEntity']);
734
735	1	$this->belongsTo('deletedAs', User::class, 'id', ['alias' => 'DeletedAsEntity']);
736
737	1	$this->belongsTo('deletedBy', User::class, 'id', ['alias' => 'DeletedByEntity']);
738
739	1	$this->belongsTo('restoredBy', User::class, 'id', ['alias' => 'RestoredByEntity']);
740		}
741
742		/**
743		* Adds the default validations to the model.
744		* @param Validation\|null $validator
745		* @return Validation
746		*/
747		public function addDefaultValidations(?Validation $validator = null): Validation
748		{
749		$validator ??= new Validation();
750
751		$this->addUnsignedIntValidation($validator, 'id', true);
752		$this->addStringLengthValidation($validator, 'uuid', 0, 36, false);
753		$this->addUnsignedIntValidation($validator, 'workspaceId', false);
754		$this->addUnsignedIntValidation($validator, 'tableId', false);
755		$this->addStringLengthValidation($validator, 'name', 0, 60, false);
756		$this->addStringLengthValidation($validator, 'description', 0, 120, true);
757		$this->addInclusionInValidation($validator, 'type', ['text','number'], false);
758		$this->addStringLengthValidation($validator, 'validationRegex', 0, 1000, true);
759		$this->addUnsignedIntValidation($validator, 'deleted', false);
760		$this->addDateTimeValidation($validator, 'createdAt', false);
761		$this->addUnsignedIntValidation($validator, 'createdBy', true);
762		$this->addUnsignedIntValidation($validator, 'createdAs', true);
763		$this->addDateTimeValidation($validator, 'updatedAt', true);
764		$this->addUnsignedIntValidation($validator, 'updatedBy', true);
765		$this->addUnsignedIntValidation($validator, 'updatedAs', true);
766		$this->addDateTimeValidation($validator, 'deletedAt', true);
767		$this->addUnsignedIntValidation($validator, 'deletedAs', true);
768		$this->addUnsignedIntValidation($validator, 'deletedBy', true);
769		$this->addDateTimeValidation($validator, 'restoredAt', true);
770		$this->addUnsignedIntValidation($validator, 'restoredBy', true);
771
772		return $validator;
773		}
774
775
776		/**
777		* Returns an array that maps the column names of the database
778		* table to the corresponding property names of the model.
779		*
780		* @returns array The array mapping the column names to the property names
781		*/
782	1	public function columnMap(): array
783		{
784	1	return [
785	1	'id' => 'id',
786	1	'uuid' => 'uuid',
787	1	'workspace_id' => 'workspaceId',
788	1	'table_id' => 'tableId',
789	1	'name' => 'name',
790	1	'description' => 'description',
791	1	'type' => 'type',
792	1	'validation_regex' => 'validationRegex',
793	1	'deleted' => 'deleted',
794	1	'created_at' => 'createdAt',
795	1	'created_by' => 'createdBy',
796	1	'created_as' => 'createdAs',
797	1	'updated_at' => 'updatedAt',
798	1	'updated_by' => 'updatedBy',
799	1	'updated_as' => 'updatedAs',
800	1	'deleted_at' => 'deletedAt',
801	1	'deleted_as' => 'deletedAs',
802	1	'deleted_by' => 'deletedBy',
803	1	'restored_at' => 'restoredAt',
804	1	'restored_by' => 'restoredBy',
805	1	];
806		}
807		}
808

zemit-cms / core

Push — master ( 507036...762659 )

ColumnAbstract::setDeletedBy() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like