DAOUpdatesTrait.php

Go to the documentation of this file.

<?php
 
namespace Ubiquity\orm\traits;
 
use Ubiquity\controllers\Startup;
use Ubiquity\db\SqlUtils;
use Ubiquity\events\DAOEvents;
use Ubiquity\events\EventsManager;
use Ubiquity\log\Logger;
use Ubiquity\orm\OrmUtils;
use Ubiquity\orm\parser\ManyToManyParser;
use Ubiquity\orm\parser\Reflexion;
 
class DAOUpdatesTrait {
 
    public static function remove($instance): ?int {
        self::deleteAllChildren($instance);
        $className = \get_class($instance);
        $tableName = OrmUtils::getTableName($className);
        $keyAndValues = OrmUtils::getKeyFieldsAndValues($instance);
        return self::removeByKey_($className, $tableName, $keyAndValues);
    }
 
    private static function removeByKey_($className, $tableName, $keyAndValues): ?int {
        $db = self::getDb($className);
        $sql = 'DELETE FROM ' . $db->quote . $tableName . $db->quote . ' WHERE ' . SqlUtils::getWhere($keyAndValues);
        Logger::info('DAOUpdates', $sql, 'delete');
        $statement = $db->prepareStatement($sql);
        try {
            if ($statement->execute($keyAndValues)) {
                return $statement->rowCount();
            }
        } catch (\PDOException $e) {
            Logger::warn('DAOUpdates', $e->getMessage(), 'delete');
            return null;
        }
        return 0;
    }
 
    private static function remove_($db, $tableName, $where, $params) {
        $sql = 'DELETE FROM ' . $tableName . ' ' . SqlUtils::checkWhere($where);
        Logger::info('DAOUpdates', $sql, 'delete');
        $statement = $db->prepareStatement($sql);
        try {
            if ($statement->execute($params)) {
                return $statement->rowCount();
            }
        } catch (\PDOException $e) {
            Logger::warn('DAOUpdates', $e->getMessage(), 'delete');
            return false;
        }
    }
 
    public static function deleteAll($modelName, $where, $params = []) {
        $db = self::getDb($modelName);
        $quote = $db->quote;
        $tableName = OrmUtils::getTableName($modelName);
        return self::remove_($db, $quote . $tableName . $quote, $where, $params);
    }
 
    protected static function deleteManyToManyChildren(object $instance, string $memberName) {
        $modelName = \get_class($instance);
        $db = self::getDb($modelName);
        $manyParser = new ManyToManyParser($db, $instance, $memberName);
        $manyParser->init();
        $pkv = OrmUtils::getFirstKeyValue($instance);
        $quote = $db->quote;
        $tableName = $manyParser->getJoinTable();
        $fkManyField = $manyParser->getMyFkField();
        return self::remove_($db, $quote . $tableName . $quote, "$fkManyField= ?", [$pkv]);
    }
 
    protected static function deleteOneToManyChildren(object $instance, string $memberName) {
        $getter = 'get' . \ucfirst($memberName);
        $instances = $instance->{$getter}();
        foreach ($instances as $o) {
            self::remove($o);
        }
    }
 
 
    public static function deleteAllChildren(object $instance) {
        $classname = \get_class($instance);
        $oneToManyMembers = OrmUtils::getRemoveCascadeFields($classname);
        $i = 0;
        $count = \count($oneToManyMembers);
        while ($i < $count) {
            self::deleteOneToManyChildren($instance, $oneToManyMembers[$i]);
            $i++;
        }
 
        $manyToManyMembers = OrmUtils::getRemoveCascadeFields($classname, '#manyToMany');
        $j = 0;
        $count = \count($manyToManyMembers);
        while ($j < $count) {
            self::deleteManyToManyChildren($instance, $manyToManyMembers[$j]);
            $j++;
        }
        return $i + $j;
    }
 
    public static function updateAll(string $modelName, array $values, string $condition, array $params) {
        $db = self::getDb($modelName);
        $quote = $db->quote;
        $tableName = OrmUtils::getTableName($modelName);
 
        $allParams = \array_merge($values, $params);
 
        $sql = "UPDATE {$quote}{$tableName}{$quote} SET " . SqlUtils::getUpdateFieldsKeyAndParams($values) . SqlUtils::checkWhereParams($condition, $params);
        if (Logger::isActive()) {
            Logger::info("DAOUpdates", $sql, "updateAll");
            Logger::info("DAOUpdates", \json_encode($allParams), "All params");
        }
        $statement = $db->getUpdateStatement($sql);
        try {
            return $statement->execute($allParams);
        } catch (\Exception $e) {
            Logger::warn("DAOUpdates", $e->getMessage(), "updateAll");
        }
        return false;
    }
 
    public static function delete($modelName, $ids) {
        $tableName = OrmUtils::getTableName($modelName);
        $db = self::getDb($modelName);
        $pk = OrmUtils::getFirstKey($modelName);
        if (!\is_array($ids)) {
            $ids = [$ids];
        }
        $quote = $db->quote;
        $count = \count($ids);
        $r = $quote . $pk . $quote . "= ?";
        return self::remove_($db, $quote . $tableName . $quote, \str_repeat("$r OR", $count - 1) . $r, $ids);
    }
 
    public static function deleteById($modelName, $id) {
        $tableName = OrmUtils::getTableName($modelName);
        if (!\is_array($id)) {
            $id = [OrmUtils::getFirstKey($modelName) => $id];
        }
        return self::removeByKey_($modelName, $tableName, $id);
    }
 
    public static function insert($instance, $insertMany = false) {
        EventsManager::trigger('dao.before.insert', $instance);
        $className = \get_class($instance);
        $db = self::getDb($className);
        $quote = $db->quote;
        $tableName = OrmUtils::getTableName($className);
        $keyAndValues = Reflexion::getPropertiesAndValues($instance);
        $keyAndValues = \array_merge($keyAndValues, OrmUtils::getManyToOneMembersAndValues($instance));
        $pk = OrmUtils::getFirstKey($className);
        $pkVal = $keyAndValues [$pk] ?? null;
        if (($pkVal) == null) {
            unset ($keyAndValues [$pk]);
        }
        $sql = "INSERT INTO {$quote}{$tableName}{$quote} (" . SqlUtils::getInsertFields($keyAndValues) . ') VALUES(' . SqlUtils::getInsertFieldsValues($keyAndValues) . ')';
        if (Logger::isActive()) {
            Logger::info('DAOUpdates', $sql, 'insert');
            Logger::info('DAOUpdates', \json_encode($keyAndValues), 'Key and values');
        }
 
        $statement = $db->getUpdateStatement($sql);
        try {
            $result = $statement->execute($keyAndValues);
            if ($result) {
                if ($pkVal == null) {
                    $lastId = $db->lastInserId("{$tableName}_{$pk}_seq");
                    if ($lastId != 0) {
                        $propKey = OrmUtils::getFirstPropKey($className);
                        $propKey->setValue($instance, $lastId);
                        $pkVal = $lastId;
                    }
                }
                $instance->_rest = $keyAndValues;
                $instance->_rest [$pk] = $pkVal;
 
                if ($insertMany) {
                    self::insertOrUpdateAllManyToMany($instance);
                }
            }
            EventsManager::trigger(DAOEvents::AFTER_INSERT, $instance, $result);
            return $result;
        } catch (\Exception $e) {
            Logger::warn('DAOUpdates', $e->getMessage(), 'insert');
            if (Startup::$config ['debug']) {
                throw $e;
            }
        }
        return false;
    }
 
    public static function insertOrUpdateAllManyToMany($instance) {
        $members = OrmUtils::getAnnotationInfo(get_class($instance), '#manyToMany');
        if ($members !== false) {
            $members = \array_keys($members);
            foreach ($members as $member) {
                self::insertOrUpdateManyToMany($instance, $member);
            }
        }
    }
 
    public static function insertOrUpdateManyToMany($instance, $member) {
        $db = self::getDb(\get_class($instance));
        $parser = new ManyToManyParser ($db, $instance, $member);
        if ($parser->init()) {
            $quote = $db->quote;
            $myField = $parser->getMyFkField();
            $field = $parser->getFkField();
            $sql = "INSERT INTO {$quote}" . $parser->getJoinTable() . "{$quote}({$quote}" . $myField . "{$quote},{$quote}" . $field . "{$quote}) VALUES (:" . $myField . ",:" . $field . ");";
            $memberAccessor = 'get' . \ucfirst($member);
            $memberValues = $instance->$memberAccessor ();
            $myKey = $parser->getMyPk();
            $myAccessorId = 'get' . \ucfirst($myKey);
            $accessorId = 'get' . \ucfirst($parser->getPk());
            $id = $instance->$myAccessorId ();
            if (!\is_null($memberValues)) {
                $db->execute("DELETE FROM {$quote}" . $parser->getJoinTable() . "{$quote} WHERE {$quote}{$myField}{$quote}='{$id}'");
                $statement = $db->prepareStatement($sql);
                foreach ($memberValues as $targetInstance) {
                    $foreignId = $targetInstance->$accessorId ();
                    $foreignInstances = self::getAll($parser->getTargetEntity(), $quote . $parser->getPk() . $quote . "='{$foreignId}'");
                    if (!OrmUtils::exists($targetInstance, $parser->getPk(), $foreignInstances)) {
                        self::insert($targetInstance, false);
                        $foreignId = $targetInstance->$accessorId ();
                        Logger::info('DAOUpdates', "Insertion d'une instance de " . get_class($instance), 'InsertMany');
                    }
                    $db->bindValueFromStatement($statement, $myField, $id);
                    $db->bindValueFromStatement($statement, $field, $foreignId);
                    $statement->execute();
                    Logger::info('DAOUpdates', "Insertion des valeurs dans la table association '" . $parser->getJoinTable() . "'", 'InsertMany');
                }
            }
        }
    }
 
    public static function update($instance, $updateMany = false) {
        EventsManager::trigger('dao.before.update', $instance);
        $className = \get_class($instance);
        $db = self::getDb($className);
        $quote = $db->quote;
        $tableName = OrmUtils::getTableName($className);
        $ColumnskeyAndValues = \array_merge(Reflexion::getPropertiesAndValues($instance), OrmUtils::getManyToOneMembersAndValues($instance));
        $keyFieldsAndValues = $instance->_pkv ?? OrmUtils::getKeyFieldsAndValues($instance, '___');
        $allParameterValues = $ColumnskeyAndValues + $keyFieldsAndValues;
        $sql = "UPDATE {$quote}{$tableName}{$quote} SET " . SqlUtils::getUpdateFieldsKeyAndParams($ColumnskeyAndValues) . ' WHERE ' . SqlUtils::getWherePK($keyFieldsAndValues);
        if (Logger::isActive()) {
            Logger::info("DAOUpdates", $sql, "update");
            Logger::info("DAOUpdates", \json_encode($allParameterValues), "Key and values");
        }
        $statement = $db->getUpdateStatement($sql);
        try {
            $result = $statement->execute($allParameterValues);
            if ($updateMany && $result) {
                self::insertOrUpdateAllManyToMany($instance);
            }
            EventsManager::trigger(DAOEvents::AFTER_UPDATE, $instance, $result);
            $instance->_rest = \array_merge($instance->_rest, $ColumnskeyAndValues);
            return $result;
        } catch (\Exception $e) {
            Logger::warn("DAOUpdates", $e->getMessage(), "update");
        }
        return false;
    }
 
    public static function updateGroup($instances, $updateMany = false) {
        if (\count($instances) > 0) {
            $instance = \current($instances);
            $className = \get_class($instance);
            $db = self::getDb($className);
            $quote = $db->quote;
            $tableName = OrmUtils::getTableName($className);
            $ColumnskeyAndValues = \array_merge(Reflexion::getPropertiesAndValues($instance), OrmUtils::getManyToOneMembersAndValues($instance));
            $keyFieldsAndValues = OrmUtils::getKeyFieldsAndValues($instance);
            $sql = "UPDATE {$quote}{$tableName}{$quote} SET " . SqlUtils::getUpdateFieldsKeyAndParams($ColumnskeyAndValues) . ' WHERE ' . SqlUtils::getWhere($keyFieldsAndValues);
 
            $statement = $db->getUpdateStatement($sql);
            try {
                $db->beginTransaction();
                foreach ($instances as $instance) {
                    EventsManager::trigger('dao.before.update', $instance);
                    $ColumnskeyAndValues = \array_merge(Reflexion::getPropertiesAndValues($instance), OrmUtils::getManyToOneMembersAndValues($instance));
                    $result = $statement->execute($ColumnskeyAndValues);
                    if ($updateMany && $result) {
                        self::insertOrUpdateAllManyToMany($instance);
                    }
                    EventsManager::trigger(DAOEvents::AFTER_UPDATE, $instance, $result);
                    $instance->_rest = \array_merge($instance->_rest, $ColumnskeyAndValues);
                    if (Logger::isActive()) {
                        Logger::info("DAOUpdates", $sql, "update");
                        Logger::info("DAOUpdates", json_encode($ColumnskeyAndValues), "Key and values");
                    }
                }
                $db->commit();
                return true;
            } catch (\Exception $e) {
                Logger::warn("DAOUpdates", $e->getMessage(), "update");
                $db->rollBack();
            }
        }
        return false;
    }
 
    public static function save($instance, $updateMany = false) {
        if (isset ($instance->_rest)) {
            return self::update($instance, $updateMany);
        }
        return self::insert($instance, $updateMany);
    }
}