class.ActiveRecord.php

Go to the documentation of this file.

<?php
 
#[\AllowDynamicProperties]
abstract class ActiveRecord
{
    protected bool $ar_safe_read = true;
    protected string $connector_container_name = '';
    protected bool $is_new = true;
 
    public function getArConnector(): \arConnector
    {
        return arConnectorMap::get($this);
    }
 
    public function getArFieldList(): \arFieldList
    {
        return arFieldCache::get($this);
    }
 
    public static function returnDbTableName(): string
    {
        throw new arException(
            arException::UNKNONWN_EXCEPTION,
            'Implement getConnectorContainerName in your child-class'
        );
    }
 
    public function getConnectorContainerName(): string
    {
        // WILL BE ABSTRACT TO REPLACE returnDbTableName() IN NEXT VERSION
        if ($this->connector_container_name !== '' && $this->connector_container_name !== '0') {
            return $this->connector_container_name;
        }
 
        $ar = self::getCalledClass();
 
        return $ar::returnDbTableName();
    }
 
    public function setConnectorContainerName(string $connector_container_name): void
    {
        $this->connector_container_name = $connector_container_name;
    }
 
    public function getPrimaryFieldValue()
    {
        $primary_fieldname = arFieldCache::getPrimaryFieldName($this);
 
        return $this->{$primary_fieldname};
    }
 
    public function setPrimaryFieldValue($value): void
    {
        $primary_fieldname = arFieldCache::getPrimaryFieldName($this);
 
        $this->{$primary_fieldname} = $value;
    }
 
    public function __construct(mixed $primary_key = 0)
    {
        $arFieldList = arFieldCache::get($this);
 
        $primaryFieldName = $arFieldList->getPrimaryFieldName();
        $this->{$primaryFieldName} = $primary_key;
        if ($primary_key === 0) {
            return;
        }
        if ($primary_key === null) {
            return;
        }
        if ($primary_key === false) {
            return;
        }
        $this->read();
    }
 
    public function storeObjectToCache(): void
    {
        arObjectCache::store($this);
    }
 
    public function asStdClass(): \stdClass
    {
        $return = new stdClass();
        foreach ($this->getArFieldList()->getFields() as $arField) {
            $fieldname = $arField->getName();
            $return->{$fieldname} = $this->{$fieldname};
        }
 
        return $return;
    }
 
    public function asArray(): array
    {
        $return = [];
        foreach ($this->getArFieldList()->getFields() as $arField) {
            $fieldname = $arField->getName();
            $return[$fieldname] = $this->{$fieldname};
        }
 
        return $return;
    }
 
    public function buildFromArray(array $array): static
    {
        $class = static::class;
        $primary = $this->getArFieldList()->getPrimaryFieldName();
        $primary_value = $array[$primary];
        if ($primary_value && arObjectCache::isCached($class, $primary_value)) {
            return arObjectCache::get($class, $primary_value);
        }
        foreach ($array as $field_name => $value) {
            $waked = $this->wakeUp($field_name, $value);
            $this->{$field_name} = $waked ?? $value;
        }
        arObjectCache::store($this);
 
        return $this;
    }
 
    public function fixDateField($field_name, string $value)
    {
        if ($this->getArFieldList()->getFieldByName($field_name)->isDateField()) {
            return $this->getArConnector()->fixDate($value);
        }
 
        return $value;
    }
 
    public function sleep($field_name)
    {
        return null;
    }
 
    public function wakeUp($field_name, $field_value)
    {
        return null;
    }
 
    final public function getArrayForConnector(): array
    {
        $data = [];
        foreach ($this->getArFieldList()->getFields() as $arField) {
            $field_name = $arField->getName();
            $sleeped = $this->sleep($field_name);
            $var = $sleeped ?? ($this->{$field_name});
            $data[$field_name] = [$arField->getFieldType(), $var];
        }
 
        return $data;
    }
 
 
 
 
    //
    // Collector Modifications
    //
    protected static function getCalledClass(): \ActiveRecord
    {
        $class = static::class;
 
        return arCalledClassCache::get($class);
    }
 
    final public static function installDB(): bool
    {
        return self::getCalledClass()->installDatabase();
    }
 
    public function installConnector(): bool
    {
        return $this->installDatabase();
    }
 
    final public static function renameDBField(string $old_name, string $new_name): bool
    {
        return self::getCalledClass()->getArConnector()->renameField(self::getCalledClass(), $old_name, $new_name);
    }
 
    final public static function tableExists(): bool
    {
        return self::getCalledClass()->getArConnector()->checkTableExists(self::getCalledClass());
    }
 
    final public static function fieldExists(string $field_name): bool
    {
        return self::getCalledClass()->getArConnector()->checkFieldExists(self::getCalledClass(), $field_name);
    }
 
    final public static function removeDBField(string $field_name): bool
    {
        return self::getCalledClass()->getArConnector()->removeField(self::getCalledClass(), $field_name);
    }
 
    final protected function installDatabase(): bool
    {
        if (!self::tableExists()) {
            $fields = [];
            foreach ($this->getArFieldList()->getFields() as $arField) {
                $fields[$arField->getName()] = $arField->getAttributesForConnector();
            }
 
            return $this->getArConnector()->installDatabase($this, $fields);
        }
 
        return $this->getArConnector()->updateDatabase($this);
    }
 
    final public static function updateDB(): bool
    {
        if (!self::tableExists()) {
            self::getCalledClass()->installDatabase();
 
            return true;
        }
 
        return self::getCalledClass()->getArConnector()->updateDatabase(self::getCalledClass());
    }
 
    final public static function resetDB(): bool
    {
        return self::getCalledClass()->getArConnector()->resetDatabase(self::getCalledClass());
    }
 
    final public static function truncateDB(): void
    {
        self::getCalledClass()->getArConnector()->truncateDatabase(self::getCalledClass());
    }
 
    final public static function flushDB(): void
    {
        self::truncateDB();
    }
 
    //
    // CRUD
    //
    public function store(): void
    {
        $primary_fieldname = arFieldCache::getPrimaryFieldName($this);
        $primary_value = $this->getPrimaryFieldValue();
 
        if (!self::where([$primary_fieldname => $primary_value])->hasSets()) {
            $this->create();
        } else {
            $this->update();
        }
    }
 
    public function save(): void
    {
        $this->store();
    }
 
    public function create(): void
    {
        if ($this->getArFieldList()->getPrimaryField()->getSequence()) {
            $primary_fieldname = arFieldCache::getPrimaryFieldName($this);
            $this->{$primary_fieldname} = $this->getArConnector()->nextID($this);
        }
 
        $this->getArConnector()->create($this);
        arObjectCache::store($this);
    }
 
    public function copy(int $new_id = 0): self
    {
        if (self::where([$this->getArFieldList()->getPrimaryFieldName() => $new_id])->hasSets()) {
            throw new arException(arException::COPY_DESTINATION_ID_EXISTS);
        }
        $new_obj = clone($this);
        $new_obj->setPrimaryFieldValue($new_id);
 
        return $new_obj;
    }
 
    public function afterObjectLoad(): void
    {
    }
 
    public function read(): void
    {
        $records = $this->getArConnector()->read($this);
        if ($this->ar_safe_read && is_array($records) && $records === []) {
            throw new arException(arException::RECORD_NOT_FOUND, $this->getPrimaryFieldValue());
        }
        if (!$this->ar_safe_read && is_array($records) && $records === []) {
            $this->is_new = true;
        }
        $records = is_array($records) ? $records : [];
        foreach ($records as $record) {
            foreach (array_keys($this->getArrayForConnector()) as $k) {
                $waked = $this->wakeUp($k, $record->{$k} ?? null);
                $this->{$k} = $waked ?? $record->{$k} ?? null;
            }
            arObjectCache::store($this);
        }
    }
 
    public function update(): void
    {
        $this->getArConnector()->update($this);
        arObjectCache::store($this);
    }
 
    public function delete(): void
    {
        $this->getArConnector()->delete($this);
        arObjectCache::purge($this);
    }
 
 
 
    //
    // Collection
    //
    public static function preloadObjects(): array
    {
        return self::get();
    }
 
    public static function additionalParams(array $additional_params): \ActiveRecordList
    {
        $activeRecordList = new ActiveRecordList(self::getCalledClass());
        $activeRecordList->additionalParams($additional_params);
 
        return $activeRecordList;
    }
 
    public static function find($primary_key, array $add_constructor_args = []): ?\ActiveRecord
    {
        try {
            $class_name = static::class;
            if (!arObjectCache::isCached($class_name, $primary_key)) {
                $obj = arFactory::getInstance($class_name, $primary_key, $add_constructor_args);
                $obj->storeObjectToCache();
 
                return $obj;
            }
        } catch (arException) {
            return null;
        }
 
        try {
            $obj = arObjectCache::get($class_name, $primary_key);
        } catch (arException) {
            return null;
        }
 
        return $obj;
    }
 
    public static function findOrFail($primary_key, array $add_constructor_args = []): \ActiveRecord
    {
        $obj = self::find($primary_key, $add_constructor_args);
        if (is_null($obj)) {
            throw new arException(arException::RECORD_NOT_FOUND);
        }
 
        return $obj;
    }
 
    public static function findOrGetInstance($primary_key, array $add_constructor_args = []): \ActiveRecord
    {
        $obj = self::find($primary_key, $add_constructor_args);
        if ($obj !== null) {
            return $obj;
        }
 
        $class_name = static::class;
        $obj = arFactory::getInstance($class_name, 0, $add_constructor_args);
        $obj->setPrimaryFieldValue($primary_key);
        $obj->is_new = true;
        $obj->storeObjectToCache();
 
        return $obj;
    }
 
    public static function where($where, $operator = null): \ActiveRecordList
    {
        $activeRecordList = new ActiveRecordList(self::getCalledClass());
        $activeRecordList->where($where, $operator);
 
        return $activeRecordList;
    }
 
    public static function innerjoinAR(
        ActiveRecord $activeRecord,
        $on_this,
        string $on_external,
        array $fields = ['*'],
        string $operator = '=',
        bool $both_external = false
    ): \ActiveRecordList {
        return self::innerjoin(
            $activeRecord->getConnectorContainerName(),
            $on_this,
            $on_external,
            $fields,
            $operator,
            $both_external
        );
    }
 
    public static function innerjoin(
        string $tablename,
        $on_this,
        string $on_external,
        array $fields = ['*'],
        string $operator = '=',
        bool $both_external = false
    ): \ActiveRecordList {
        $activeRecordList = new ActiveRecordList(self::getCalledClass());
 
        return $activeRecordList->innerjoin($tablename, $on_this, $on_external, $fields, $operator, $both_external);
    }
 
    public static function leftjoin(
        string $tablename,
        $on_this,
        string $on_external,
        array $fields = ['*'],
        string $operator = '=',
        bool $both_external = false
    ): \ActiveRecordList {
        $activeRecordList = new ActiveRecordList(self::getCalledClass());
 
        return $activeRecordList->leftjoin($tablename, $on_this, $on_external, $fields, $operator, $both_external);
    }
 
    public static function orderBy(string $orderBy, string $orderDirection = 'ASC'): \ActiveRecordList
    {
        $activeRecordList = new ActiveRecordList(self::getCalledClass());
        $activeRecordList->orderBy($orderBy, $orderDirection);
 
        return $activeRecordList;
    }
 
    public static function dateFormat(string $date_format = 'd.m.Y - H:i:s'): \ActiveRecordList
    {
        $activeRecordList = new ActiveRecordList(self::getCalledClass());
        $activeRecordList->dateFormat($date_format);
 
        return $activeRecordList;
    }
 
    public static function limit(int $start, int $end): \ActiveRecordList
    {
        $activeRecordList = new ActiveRecordList(self::getCalledClass());
        $activeRecordList->limit($start, $end);
 
        return $activeRecordList;
    }
 
    public static function affectedRows(): int
    {
        $activeRecordList = new ActiveRecordList(self::getCalledClass());
 
        return $activeRecordList->affectedRows();
    }
 
    public static function count(): int
    {
        return self::affectedRows();
    }
 
    public static function get(): array
    {
        $activeRecordList = new ActiveRecordList(self::getCalledClass());
 
        return $activeRecordList->get();
    }
 
    public static function debug(): \ActiveRecordList
    {
        $activeRecordList = new ActiveRecordList(self::getCalledClass());
 
        return $activeRecordList->debug();
    }
 
    public static function first(): ?\ActiveRecord
    {
        $activeRecordList = new ActiveRecordList(self::getCalledClass());
 
        return $activeRecordList->first();
    }
 
    public static function getCollection(): \ActiveRecordList
    {
        return new ActiveRecordList(self::getCalledClass());
        ;
    }
 
    public static function last(): ?\ActiveRecord
    {
        $activeRecordList = new ActiveRecordList(self::getCalledClass());
 
        return $activeRecordList->last();
    }
 
    public static function getFirstFromLastQuery(): ?\ActiveRecord
    {
        $activeRecordList = new ActiveRecordList(self::getCalledClass());
 
        return $activeRecordList->getFirstFromLastQuery();
    }
 
    public static function connector(arConnector $arConnector): \ActiveRecordList
    {
        $activeRecordList = new ActiveRecordList(self::getCalledClass());
 
        return $activeRecordList->connector($arConnector);
    }
 
    public static function raw(bool $set_raw = true): \ActiveRecordList
    {
        $activeRecordList = new ActiveRecordList(self::getCalledClass());
 
        return $activeRecordList->raw($set_raw);
    }
 
    public static function getArray(?string $key = null, string|array|null $values = null): array
    {
        $activeRecordList = new ActiveRecordList(self::getCalledClass());
 
        return $activeRecordList->getArray($key, $values);
    }
 
    //
    // Magic Methods & Helpers
    //
    public function __call($name, $arguments)
    {
        // Getter
        if (preg_match("/get([a-zA-Z]*)/u", (string) $name, $matches) && (is_countable($arguments) ? count(
            $arguments
        ) : 0) === 0) {
            return $this->{self::fromCamelCase($matches[1])};
        }
        // Setter
        if (!preg_match("/set([a-zA-Z]*)/u", (string) $name, $matches)) {
            return null;
        }
        if (count($arguments) !== 1) {
            return null;
        }
        $this->{self::fromCamelCase($matches[1])} = $arguments[0];
        return null;
    }
 
    public static function _toCamelCase(string $str, bool $capitalise_first_char = false): ?string
    {
        if ($capitalise_first_char) {
            $str[0] = strtoupper($str[0]);
        }
 
        return preg_replace_callback('/_([a-z])/', fn($c): string => strtoupper($c[1]), $str);
    }
 
    protected static function fromCamelCase(string $str): ?string
    {
        $str[0] = strtolower($str[0]);
 
        return preg_replace_callback('/([A-Z])/', fn($c): string => "_" . strtolower($c[1]), $str);
    }
}