StorableObject.type.php

Go to the documentation of this file.

<?php
abstract class spunQ_StorableObject extends spunQ_DataObject {

    public static function insertMultiple(array $objects, spunQ_IDatabaseConnection $connection = NULL) {
        if (empty($objects)) {
            return NULL;
        }
        if ($connection === NULL) {
            $connection = db();
        }
        $type = reset($objects)->_getType();
        $memberNames = array_keys($type->getOwnMembersRecursive());
        foreach ($objects as $object) {
            foreach ($memberNames as $memberName) {
                $object->remoteValues[$memberName] = $object->$memberName;
            }
        }
        try {
            $connection->insert($objects, $type);
            foreach ($objects as $object) {
                # Members have been persisted.
                $object->locallyModifiedMembers = array();
            }
        } catch (Exception $e) {
            foreach ($objects as $object) {
                # Delete remote values cache, we cannot know what was
                # inserted into the database.
                $object->remoteValues = array();
            }
            throw $e;
        }
        return NULL;
    }

    public static function updateMultiple(array $objects) {
        if (spunQ::inMode(spunQ::MODE_DEVELOPMENT)) {
            $connection = NULL;
            foreach ($objects as $object) {
                if ($connection === NULL) {
                    $connection = $object->getConnection();
                } else {
                    if ($object->getConnection() !== $connection) {
                        throw new spunQ_InvalidArgumentError('UpdateOnDifferentConnections', __CLASS__, __FUNCTION__, 'objects');
                    }
                }
            }
        }
        # Currenlty, there is no speed improvement :)
        # There might be one in the future, though!
        foreach ($objects as $object) {
            $object->update();
        }
        return NULL;
    }

    public static function deleteMultiple(array $objects) {
        if (empty($objects)) {
            return NULL;
        }
        $typeToIds = array();
        if (spunQ::inMode(spunQ::MODE_DEVELOPMENT)) {
            $connection = NULL;
            foreach ($objects as $object) {
                # XXX: Changes here should be performed below, too
                $typeName = $object->_getType()->getName();
                if (!isset($typeToIds[$typeName])) {
                    $typeToIds[$typeName] = array();
                }
                $typeToIds[$typeName][] = $object->getId();
                if ($connection === NULL) {
                    $connection = $object->getConnection();
                } else {
                    if ($object->getConnection() !== $connection) {
                        throw new spunQ_InvalidArgumentError('DeleteOnDifferentConnections', __CLASS__, __FUNCTION__, 'objects');
                    }
                }
            }
        } else {
            foreach ($objects as $object) {
                # XXX: Changes here should be performed above, too
                $typeName = $object->_getType()->getName();
                if (!isset($typeToIds[$typeName])) {
                    $typeToIds[$typeName] = array();
                }
                $typeToIds[$typeName][] = $object->getId();
            }
        }
        $delete = new spunQ_DeleteQuery();
        $delete->addCondition('id IN {0}');
        foreach ($typeToIds as $type => $ids) {
            $delete->setType($type);
            $delete->execute(array($ids), reset($objects)->getConnection());
        }
        # We could have done that above, but for the sake of integrity, we're
        # only setting the ids to NULL if the query performed successfully.
        foreach ($objects as $object) {
            $object->id = NULL;
        }
        return NULL;
    }

    public static function sortByDisplayString($objects) {
        $objectNames = array();
        foreach($objects as $object) {
            if (!($object instanceof spunQ_StorableObject)) {
                sort($objects);
                return $objects;
            }
            $objectNames[] = $object->_getDisplayString();
        }
        asort($objectNames);
        $returnObjects = array();
        foreach($objectNames as $idx=>$name) {
            $returnObjects[] = $objects[$idx];
        }
        return $returnObjects;
    }

    protected static function loadInjectedMember($connection, spunQ_InjectedMember $injectedMember) {
        $memberName = $injectedMember->getName();
        $objects = array();
        foreach ($connection->getCachedObjects($injectedMember->getSource()->getType()) as $object) {
            if (!isset($object->remoteValues[$memberName])) {
                $objects[$object->getId()] = $object;
            }
        }
        $query = new spunQ_SelectQuery();
        $query->setType($injectedMember->getSource()->getOwningType()->getName());
        $query->addCondition($injectedMember->getSource()->getName() . ' IN {0}');
        $objectsToInjectings = array();
        foreach ($query->execute(array(array_keys($objects))) as $injectingObject) {
            $objectId = $injectingObject->_getMember($injectedMember->getSource()->getName())->getId();
            if (!isset($objectsToInjectings[$objectId])) {
                $objectsToInjectings[$objectId] = array();
            }
            $objectsToInjectings[$objectId][] = $injectingObject;
        }
        if ($injectedMember->getSource()->getOptions()->keyExists('unique')) {
            foreach ($objects as $objectId => $object) {
                $result = NULL;
                if (isset($objectsToInjectings[$objectId])) {
                    $result = reset($objectsToInjectings[$objectId]);
                }
                $object->remoteValues[$memberName] = $result;
                $object->$memberName = $result;
            }
        } else {
            foreach ($objects as $objectId => $object) {
                $result = array();
                if (isset($objectsToInjectings[$objectId])) {
                    $result = $objectsToInjectings[$objectId];
                }
                $object->remoteValues[$memberName] = $result;
                $object->$memberName = $result;
            }
        }
        return NULL;
    }

    protected $id;

    protected $remoteValues = array();

    protected $locallyModifiedMembers = array();

    protected $connection = NULL;

    public function setId($id) {
        $this->id = $id;
        return $this;
    }

    public function getId() {
        return $this->id;
    }

    public function store() {
        if (!$this->getId()) {
            return $this->insert();
        } else {
            return $this->update();
        }
    }

    public function insert() {
        self::insertMultiple(array($this), $this->getConnection());
        return $this;
    }

    public function delete() {
        self::deleteMultiple(array($this), $this->getConnection());
        return $this;
    }

    public function update() {
        $performUpdate = false;
        $update = new spunQ_UpdateQuery();
        $update->setType($this->_type->getName());
        foreach ($this->_type->getOwnMembersRecursive() as $member) {
            if ($member->getName() === 'id') {
                continue;
            }
            $memberName = $member->getName();
            if (!isset($this->locallyModifiedMembers[$memberName])) {
                continue;
            }
            $performUpdate = true;
            $update->addValue($memberName, $this->$memberName);
            $this->remoteValues[$memberName] = $this->$memberName;
        }
        if (!$performUpdate) {
            return $this;
        }
        $this->locallyModifiedMembers = array();
        $update->setConditions(array('id={0}'));
        $update->execute(array($this->getId()), $this->getConnection());
        return $this;
    }

    public function assureExists() {
        if ($this->getId() == 0) {
            throw new spunQ_InvalidObjectException('ObjectHasNoId', $this->_getType()->getFullName());
        }
        throw new spunQ_Exception('Not implemented');
        return $this;
    }

    public function setConnection(spunQ_IDatabaseConnection $connection) {
        if ($this->connection !== NULL) {
            $this->connection->removeFromCache($this);
        }
        if ($this->getId() != NULL) {
            $connection->addToCache($this);
        }
        $this->connection = $connection;
        return $this;
    }

    public function getConnection() {
        if ($this->connection === NULL) {
            $this->setConnection(spunQ_db::getDefaultConnection());
        }
        return $this->connection;
    }

    public function handleSet($memberName, $arguments, $functionName) {
        $result = parent::handleSet($memberName, $arguments, $functionName);
        $this->locallyModifiedMembers[$memberName] = 1;
        return $result;
    }

    public function _loadRemoteValues(array $values, $checkValues = true) {
        # optimzation: removing the overhead of calling a function.
        # the next lines could be replaced by $myType = $this->_getType();
        if ($this->_type instanceof spunQ_Type) {
            $myType = $this->_type;
        } else {
            $myType = $this->_getType();
        }
        if ($checkValues && spunQ::inMode(spunQ::MODE_SPUNQ_DEVELOPMENT)) {
            foreach ($values as $memberName => $value) {
                $myType->getMember($memberName)->check($value);
            }
        }
        $this->remoteValues = $values + $this->remoteValues;
        $myMembers = $myType->getOwnMembersRecursive();
        foreach ($values as $memberName => $value) {
            if ($memberName !== '_type' && !isset($this->locallyModifiedMembers[$memberName]) && isset($myMembers[$memberName])) {
                $this->$memberName = $value;
            }
        }
        return $this;
    }

    public function _invalidateRemoteValues(array $memberNames) {
        foreach ($memberNames as $memberName) {
            unset($this->remoteValues[$memberName]);
        }
    }

    public function _getDisplayString() {
        if ($this->_getType()->memberExists('name')) {
            return $this->getName();
        }
        if ($this->_getType()->memberExists('title')) {
            return $this->getTitle();
        }
        if ($this->_getType()->memberExists('alias')) {
            return $this->getAlias();
        }
        if ($this->_getType()->memberExists('text')) {
            return $this->getText();
        }
        info(
            'There is neither a "name" nor a "title" member available for this object. ' .
            'Override the function "_getDisplayString()" in the class "' .
            $this->_getType()->getName() . '" if you want more than the id. '
        );
        return $this->getId();
    }

    public function _remoteValueLoaded($memberName) {
        return array_key_exists($memberName, $this->remoteValues);
    }

    public function referencingObjects($otherType, $otherMember, $order = NULL, $limit = NULL) {
        $selectQuery = $this->_createQueryForReferencingObjects($otherType, $otherMember, $order, $limit);
        $queryParams = array('object' => $this);
        return $selectQuery->execute($queryParams);
    }

    public function referencingObjectIds($otherType, $otherMember, $order = NULL, $limit = NULL) {
        $selectQuery = $this->_createQueryForReferencingObjects($otherType, $otherMember, $order, $limit);
        $selectQuery->setProperties(array('id'));
        $selectQuery->setReturnType(spunQ_SelectQuery::RETURN_SINGLE_PROPERTY);
        $queryParams = array('object' => $this);
        return $selectQuery->execute($queryParams);
    }

    public function countReferencingObjects($otherType, $otherMember) {
        $selectQuery = $this->_createQueryForReferencingObjects($otherType, $otherMember);
        $queryParams = array('object' => $this);
        return $selectQuery->count($queryParams);
    }

    protected function loadMember($memberName) {
        if (array_key_exists($memberName, $this->remoteValues)) {
            # Member already loaded.
            return $this;
        }
        if ($this->getId() == 0) {
            # Object has no id, member cannot be loaded.
            return $this;
        }
        $missingMembers = array_diff_key($this->_getType()->getOwnMembersRecursive(), $this->remoteValues);
        # The array addition is there to move the $memberName element to the
        # first position in the parameter to loadOnDemand.
        $this->getConnection()->loadOnDemand($this, array_keys(array($memberName => 1) + $missingMembers));
        return $this;
    }

    protected function handleGet($memberName, $arguments, $functionName) {
        if (isset($this->locallyModifiedMembers[$memberName]) || array_key_exists($memberName, $this->remoteValues)) {
            # This value was already set, treat it as any other variable.
            return parent::handleGet($memberName, $arguments, $functionName);
        }
        $myType = $this->_getType();
        $injected = $myType->getInjectedMembersRecursive();
        if (isset($injected[$memberName])) {
            $injectedMember = $injected[$memberName];
            # injected member
            if ($this->getId() != 0) {
                self::loadInjectedMember($this->getConnection(), $injectedMember);
                $result = $this->remoteValues[$memberName];
            } else {
                if ($injectedMember->getSource()->getOptions()->keyExists('unique')) {
                    $result = NULL;
                } else {
                    $result = array();
                }
            }
            return $result;
        }
        $this->loadMember($memberName);
        $result = parent::handleGet($memberName, $arguments, $functionName);
        if ($myType->getMember($memberName)->getOptions()->keyExists('mappedBy')) {
            # Do not cache this mapped value
            unset($this->remoteValues[$memberName]);
        }
        return $result;
    }

    protected function handleAdd($memberName, $arguments, $functionName) {
        if (property_exists($this, $memberName)) {
            $this->loadMember($memberName);
            $this->locallyModifiedMembers[$memberName] = 1;
        }
        $memberNamePlural = spunQ_Grammar::pluralize($memberName);
        if (property_exists($this, $memberNamePlural)) {
            $this->loadMember($memberNamePlural);
            $this->locallyModifiedMembers[$memberNamePlural] = 1;
        }
        return parent::handleAdd($memberName, $arguments, $functionName);
    }

    protected function handleRemove($memberName, $arguments, $functionName) {
        if (property_exists($this, $memberName)) {
            $this->loadMember($memberName);
            $this->locallyModifiedMembers[$memberName] = 1;
        }
        $memberNamePlural = spunQ_Grammar::pluralize($memberName);
        if (property_exists($this, $memberNamePlural)) {
            $this->loadMember($memberNamePlural);
            $this->locallyModifiedMembers[$memberNamePlural] = 1;
        }
        return parent::handleRemove($memberName, $arguments, $functionName);
    }

    protected function handleGetUntranslated($memberName, $arguments, $functionName) {
        if (property_exists($this, $memberName)) {
            $this->loadMember($memberName);
        }
        return parent::handleGetUntranslated($memberName, $arguments, $functionName);
    }

    protected function handleGetFromArray($memberName, $arguments, $functionName) {
        if (property_exists($this, $memberName)) {
            $this->loadMember($memberName);
        }
        return parent::handleGetFromArray($memberName, $arguments, $functionName);
    }

    private function _createQueryForReferencingObjects($otherType, $otherMember, $order = NULL, $limit = NULL, $justCount = false) {
        $selectQuery = new spunQ_SelectQuery();
        $selectQuery->setType($otherType);
        if ($limit !== NULL) {
            $selectQuery->setLimit($limit);
        }
        if ($order !== NULL) {
            if (is_array($order)) {
                $selectQuery->setOrder($order);
            } else {
                $selectQuery->addOrder($order);
            }
        }
        $member = spunQ_Type::getByName($otherType)->getMember($otherMember);
        if ($member->getType() instanceof spunQ_UserType) {
            $selectQuery->addCondition($otherMember . ' = {object}');
        } elseif ($member->getType() instanceof spunQ_ArrayType) {
            $selectQuery->addCondition($otherMember .'._value = {object}');
        } else {
            throw new spunQ_Exception('not implemented yet.');
        }
        return $selectQuery;
    }

}

---