Document.php

Go to the documentation of this file.

<?php

 
namespace Depage\XmlDb;
 
class Document implements Interfaces\DocumentWriterHost
{
    public const POS_GAP = Helpers\Positions::POS_GAP;
    public const POS_MIN_GAP = Helpers\Positions::POS_MIN_GAP;

    public const PATCH_MAX_CHANGE_RATIO = Patch\PatchPlanner::MAX_CHANGE_RATIO;
 
    protected $pdo;
    protected $cache;
    protected $dbNs;
 
    protected $tablePrefix;
    protected $tableDocs;
    protected $tableXml;
 
    protected $xmlDb;
    protected $docId;
 
    protected $idAttribute = 'id';
    protected $idDataAttribute = 'dataid';
 
    protected $freeElementIds = [];
    protected $doctypeHandlers = [];
 
    protected $entities = '';
    protected $namespaceString = '';
    protected $namespaces = [];
    protected $lastchange = '';
    protected $lastchangeUid = '';

    protected $docInfo = null;
    protected $docInfoLoaded = false;

    protected $positions = null;
    protected $subhashUpdater = null;
    protected $patchPlanner = null;
    protected $patchApplier = null;
    protected $writer = null;

    protected $subhashesDirty = false;

    protected $lastPatchStats = null;
    public function __construct($xmlDb, $docId)
    {
        $this->pdo = $xmlDb->pdo;
        $this->cache = $xmlDb->cache;
 
        $this->dbNs = new XmlNs('db', 'http://cms.depagecms.net/ns/database');
 
        $this->xmlDb = $xmlDb;
 
        $this->tablePrefix = $xmlDb->tablePrefix;
        $this->tableDocs = $xmlDb->tableDocs;
        $this->tableXml = $xmlDb->tableXml;
 
        $this->docId = $docId;
    }

    public function getDocId()
    {
        return $this->docId;
    }

    public function getXml($addIdAttribute = true)
    {
        $rootId = $this->getDocInfo()->rootid;
 
        if (is_null($rootId)) {
            throw new Exceptions\XmlDbException('Trying to get contents of empty document.');
        } else {
            $xml = $this->getSubdocByNodeId($rootId, $addIdAttribute);
        }
 
        return $xml;
    }

    public function getDocInfo()
    {
        if (!$this->docInfoLoaded) {
            $query = $this->pdo->prepare(
                "SELECT
                    docs.id AS id,
                    docs.name AS name,
                    docs.rootid AS rootid,
                    docs.type AS type,
                    docs.ns AS namespaces,
                    docs.lastchange AS lastchange,
                    docs.lastchange_uid AS lastchangeUid
                FROM {$this->tableDocs} AS docs
                WHERE docs.id = :doc_id
                LIMIT 1",
            );
            $query->execute([
                'doc_id' => $this->docId,
            ]);
 
            $info = $query->fetchObject();
 
            if ($info) {
                $info->lastchange = new \DateTime($info->lastchange);
                $info->lastrelease = $this->getHistory()->getLatestVersion()->lastsaved ?? false;
            }
 
            $this->docInfo = $info;
            $this->docInfoLoaded = true;
        }
 
        return $this->docInfo;
    }

    public function getDoctypeHandler()
    {
        if (!isset($this->doctypeHandlers[$this->docId])) {
            $className = $this->getDocInfo()->type;
 
            if (empty($className)) {
                $handler = new XmlDoctypes\Base($this->xmlDb, $this);
            } else {
                // don't instantiate handlers straight from the database
                // before validating them
                $className = '\\' . ltrim($className, '\\');
 
                if (!class_exists($className)) {
                    throw new Exceptions\XmlDbException("Doctype handler class \"$className\" does not exist");
                }
                if (!is_a($className, Interfaces\DoctypeInterface::class, true)) {
                    throw new Exceptions\XmlDbException('Doctype handler must implement DoctypeInterface');
                }
 
                $handler = new $className($this->xmlDb, $this);
            }
 
            if ($handler instanceof Interfaces\DoctypeInterface) {
                $this->doctypeHandlers[$this->docId] = $handler;
            } else {
                throw new Exceptions\XmlDbException('Doctype handler must implement DoctypeInterface');
            }
        }
 
        return $this->doctypeHandlers[$this->docId];
    }

    public function getPermissions()
    {
        return $this->getDoctypeHandler()->getPermissions();
    }

    public function getNamespacesAndEntities()
    {
        $query = $this->pdo->prepare(
            "SELECT docs.entities AS entities, docs.ns AS namespaces
            FROM {$this->tableDocs} AS docs
            WHERE docs.id = :doc_id",
        );
        $query->execute([
            'doc_id' => $this->docId,
        ]);
 
        return $query->fetchObject();
    }

    public function getHistory()
    {
        return new DocumentHistory($this->pdo, $this->tablePrefix, $this);
    }

    protected function positions()
    {
        if (is_null($this->positions)) {
            $this->positions = new Helpers\Positions($this->pdo, $this->tableXml, $this->docId, self::SAVE_BATCH_SIZE);
        }
 
        return $this->positions;
    }

    protected function writer()
    {
        if (is_null($this->writer)) {
            $this->writer = new Helpers\DocumentWriter(
                pdo: $this->pdo,
                table: $this->tableXml,
                docId: $this->docId,
                dbNs: $this->dbNs,
                idAttribute: $this->idAttribute,
                positions: $this->positions(),
                host: $this
            );
        }
 
        return $this->writer;
    }

    public function isReleased()
    {
        $info = $this->getDocInfo();
 
        if (!empty($info->lastrelease) && $info->lastchange->getTimestamp() <= $info->lastrelease->getTimestamp()) {
            return true;
        }
 
        return false;
    }

    public function isPublished()
    {
        $info = $this->getDocInfo();
 
        return !empty($info->lastrelease);
    }

    public function getNodeId($node)
    {
        return $node->nodeType == XML_ELEMENT_NODE
            ? $node->getAttributeNS($this->dbNs->uri, $this->idAttribute)
            : null;
    }

    public function getNodeDataId($node)
    {
        return $node->nodeType == XML_ELEMENT_NODE
            ? $node->getAttributeNS($this->dbNs->uri, $this->idDataAttribute)
            : null;
    }
 
    protected function getNodeAttributeById($id, $attribute)
    {
        $query = $this->pdo->prepare(
            "SELECT xml.$attribute AS $attribute
            FROM {$this->tableXml} AS xml
            WHERE xml.id = :id AND xml.id_doc = :doc_id",
        );
        $query->execute([
            'id' => $id,
            'doc_id' => $this->docId,
        ]);
 
        return ($result = $query->fetchObject()) ? $result->$attribute : false;
    }

    public function getNodeNameById($id)
    {
        return $this->getNodeAttributeById($id, 'name');
    }

    public function getParentIdById($id)
    {
        return $this->getNodeAttributeById($id, 'id_parent');
    }

    public function getIndexById($id)
    {
        return $this->positions()->indexById($id);
    }

    protected function rebalancePositions($parentId, $order = null)
    {
        $this->positions()->rebalance($parentId, $order);
    }

    public function getNodeIdsByXpath($xpath)
    {
        $identifier = Helpers\CacheKey::forDocument($this->tableDocs, $this->docId) . 'xpath_' . sha1($xpath);
        $fetchedIds = $this->cache->get($identifier);
 
        if ($fetchedIds === false) {
            $fetchedIds = $this->xmlDb->getNodeIdsByXpath($xpath, $this->docId);
 
            $this->cache->set($identifier, $fetchedIds);
        }
        return $fetchedIds;
    }

    public function getSubdocByNodeId($id, $addIdAttribute = true)
    {
        $identifier = Helpers\CacheKey::forDocument($this->tableDocs, $this->docId) . "{$id}.xml";
        $xmlDoc = new \Depage\Xml\Document();
 
        if ($xmlStr = $this->cache->get($identifier)) {
            // read from cache
            $xmlDoc->loadXML($xmlStr);
        } else {
            // read from database
            $this->inTransaction(function () use ($id, &$xmlDoc) {
                $query = null;
 
                try {
                    $query = $this->pdo->prepare(
                        "SELECT
                            docs.entities AS entities,
                            docs.ns AS namespaces,
                            docs.lastchange AS lastchange,
                            docs.lastchange_uid AS lastchangeUid
                        FROM {$this->tableDocs} AS docs
                        WHERE docs.id = :doc_id",
                    );
                    $query->execute([
                        'doc_id' => $this->docId,
                    ]);
                    $result = $query->fetchObject();
 
                    $this->entities = $result->entities;
                    $this->namespaceString = $result->namespaces;
                    $this->namespaces = $this->extractNamespaces($this->namespaceString);
                    $this->namespaces[$this->dbNs->ns] = $this->dbNs;
                    $this->lastchange = $result->lastchange;
                    $this->lastchangeUid = $result->lastchangeUid;
 
                    $query = $this->pdo->prepare(
                        Helpers\TreeSql::descendants($this->tableXml, "id = :id AND id_doc = :doc_id", self::SORTKEY_PAD) . "
                        SELECT lvl, xml.* FROM tree JOIN {$this->tableXml} AS xml ON tree.id = xml.id ORDER BY sortkey;",
                        \Depage\Db\Pdo::unbuffered(),
                    );
                    $query->execute([
                        'doc_id' => $this->docId,
                        'id' => $id,
                    ]);
                    $row = $query->fetchObject();
 
                    //get ROOT-NODE
                    if (!($row && $row->type == 'ELEMENT_NODE')) {
                        throw new Exceptions\XmlDbException('This node is no ELEMENT_NODE or node does not exist' . " {$this->docId}/{$id}");
                    }
 
                    $this->addChildnodesByQuery($query, $row, $xmlDoc);
                } catch (\Throwable $e) {
                    // the tree query may be an unbuffered result, it has to be
                    // closed before any other statement can run on the connection
                    if (isset($query)) {
                        $query->closeCursor();
                    }
 
                    throw $e;
                }
            }, false);
 
            $dth = $this->getDoctypeHandler();
            if ($dth->testDocument($xmlDoc)) { // test whether the document was altered
                $this->saveNode($xmlDoc);
            }
 
            // add xml to xml-cache
            if (is_object($xmlDoc) && $xmlDoc->documentElement != null) {
                $this->cache->set($identifier, $xmlDoc->saveXML());
            }
        }
 
        if (is_a($xmlDoc, 'DOMDocument') && $xmlDoc->documentElement != null && !$addIdAttribute) {
            $this->removeIdAttr($xmlDoc);
        }
 
        return $xmlDoc;
    }

    public function getSubdocByXpath($xpath, $addIdAttribute = true)
    {
        $subdoc = false;
        $ids = $this->getNodeIdsByXpath($xpath);
 
        if (isset($ids[0])) {
            $subdoc = $this->getSubdocByNodeId($ids[0], $addIdAttribute);
        }
 
        return $subdoc;
    }

    public function getAttribute($nodeId, $attrName)
    {
        $attributes = $this->getAttributes($nodeId);
 
        return (isset($attributes[$attrName])) ? $attributes[$attrName] : false;
    }

    public function getAttributes($nodeId)
    {
        $attributes = [];
 
        $query = $this->pdo->prepare(
            "SELECT xml.value
            FROM {$this->tableXml} AS xml
            WHERE xml.id = :node_id AND xml.type='ELEMENT_NODE' AND xml.id_doc = :doc_id",
        );
        $query->execute([
            'node_id' => $nodeId,
            'doc_id' => $this->docId,
        ]);
 
        if ($result = $query->fetchObject()) {
            $attributes = self::parseAttributeString($result->value);
        }
 
        return $attributes;
    }

    public static function parseAttributeString($value)
    {
        $attributes = [];
 
        $matches = preg_split('/(="|"$|" )/', (string) $value);
        $matches = array_chunk($matches, 2);
        foreach ($matches as $match) {
            $name = trim($match[0]);
            if ($name != '') {
                $attributes[$name] = htmlspecialchars_decode($match[1] ?? '');
            }
        }
 
        return $attributes;
    }

    public function buildNode($name, $attributes)
    {
        //@todo dont build node directly but get from templates according to document type
        $docInfo = $this->getNamespacesAndEntities($this->docId);
        $xml = "<$name {$docInfo->namespaces}";
        foreach ($attributes as $attr => $value) {
            $xml .= " $attr=\"$value\"";
        }
        $xml .= '/>';
 
        $doc = new \Depage\Xml\Document();
        $doc->loadXML($xml);
 
        return $doc->documentElement;
    }

    public function removeIdAttr($node)
    {
        self::removeNodeAttr($node, $this->dbNs, $this->idAttribute);
    }

    public function clearDoc()
    {
        $info = $this->getDocInfo();
 
        $this->inTransaction(function () use ($info) {
            if ($info) {
                $this->pdo->exec("SET FOREIGN_KEY_CHECKS=0;");
 
                try {
                    $query = $this->pdo->prepare(
                        "DELETE FROM {$this->tableXml}
                        WHERE
                            id_doc = :id",
                    );
                    $query->execute([
                        'id' => $info->id,
                    ]);
                } finally {
                    // keep foreign key checks enabled even if the
                    // delete failed, they are session scoped
                    $this->pdo->exec("SET FOREIGN_KEY_CHECKS=1;");
                }
            }
        });
 
        return $info;
    }

    public function save(\DomDocument $xml)
    {
        return $this->inTransaction(function () use ($xml) {
            $docInfo = $this->clearDoc();
 
            $namespaces = $this->getNamespaceString($xml);
 
            // @TODO get document and entities or set html_entities as standard as long as php does not inherit the entites() function
            $docInfo->rootid = $this->saveNodePrivate($xml);
            $query = $this->pdo->prepare(
                "UPDATE {$this->tableDocs}
                SET
                    rootid = :rootid,
                    ns = :ns,
                    entities=''
                WHERE id = :doc_id",
            );
 
            $query->execute([
                'rootid' => $docInfo->rootid,
                'ns' => $namespaces,
                'doc_id' => $docInfo->id,
            ]);
 
            return $docInfo->id;
        });
    }

    public function savePatch(\DomDocument $xml)
    {
        $docInfo = $this->getDocInfo();
        $plan = null;
 
        if ($docInfo) {
            $plan = $this->planPatch($xml, $docInfo);
        }
 
        if (is_null($plan)) {
            $this->lastPatchStats = ['fallback' => true];
 
            return $this->save($xml);
        }
 
        $this->inTransaction(function () use ($plan, $xml) {
            $query = $this->pdo->prepare(
                "UPDATE {$this->tableDocs}
                SET
                    ns = :ns,
                    entities = ''
                WHERE id = :doc_id",
            );
            $query->execute([
                'ns' => $this->getNamespaceString($xml),
                'doc_id' => $this->docId,
            ]);
 
            $this->applyPatch($plan);
 
            $this->updateLastChange();
        });
 
        $this->lastPatchStats = $plan['stats'] + ['fallback' => false];
 
        return $docInfo->id;
    }

    public function getLastPatchStats()
    {
        return $this->lastPatchStats;
    }

    protected function planPatch(\DomDocument $xml, $docInfo)
    {
        $root = $xml->documentElement;
        $rootId = is_null($root) ? '' : $this->getNodeId($root);
 
        if (empty($rootId) || (int) $rootId !== (int) $docInfo->rootid) {
            // new document or the root node was replaced
            return null;
        }
 
        return $this->planNodePatch($xml);
    }

    protected function planNodePatch($node, $checkRoot = false)
    {
        // run the subtree through the same pipeline save() uses, this
        // also applies the doctype whitespace handling
        $nodeArray = [];
        $this->getNodeArrayForSaving($nodeArray, $node);
 
        if (is_null($this->patchPlanner)) {
            $this->patchPlanner = new Patch\PatchPlanner($this->pdo, $this->tableXml, $this->docId, $this->dbNs, $this->idAttribute);
        }
 
        return $this->patchPlanner->plan($nodeArray, $checkRoot);
    }

    protected function applyPatch($plan)
    {
        if (is_null($this->patchApplier)) {
            $this->patchApplier = new Patch\PatchApplier($this->pdo, $this->tableXml, $this->docId, $this->positions(), $this->writer());
        }
 
        $this->patchApplier->apply($plan);
    }

    protected function getNamespaceString($xml)
    {
        $xpath = new \DOMXPath($xml);
 
        $namespaces = '';
        foreach ($xpath->query('namespace::*') as $node) {
            if ($node->nodeName == 'xmlns:xml') {
                continue;
            }
            $namespaces .= " " . $node->nodeName . "=\"" . htmlspecialchars($node->nodeValue) . "\"";
        }
 
        return $namespaces;
    }

    public function deleteNode($nodeId)
    {
        $dth = $this->getDoctypeHandler();
 
        if (!$dth->isAllowedDelete($nodeId)) {
            return false;
        }
 
        return $this->inTransaction(function () use ($nodeId) {
            $success = $this->writer()->deleteNode($nodeId);
 
            $this->updateLastChange();
 
            return $success;
        });
    }

    public function saveNode($node)
    {
        return $this->inTransaction(
            fn() => $this->saveNodePrivate($node)
        );
    }

    public function saveNodePatch($node)
    {
        $plan = $this->planNodePatch($node, true);
 
        if (is_null($plan)) {
            $this->lastPatchStats = ['fallback' => true];
 
            return (int) $this->saveNode($node);
        }
 
        $this->inTransaction(function () use ($plan) {
            $this->applyPatch($plan);
 
            $this->updateLastChange();
        });
 
        $this->lastPatchStats = $plan['stats'] + ['fallback' => false];
 
        return $plan['root_id'];
    }

    public function addNode(\DomNode $node, $targetId, $targetIndex = -1, $extras = [])
    {
        $dth = $this->getDoctypeHandler();
 
        if (!$dth->isAllowedAdd($node, $targetId)) {
            return false;
        }
 
        $dth->onAddNode($node, $targetId, $targetIndex, $extras);
 
        return $this->inTransaction(
            fn() => $this->saveNodeIn($node, $targetId, $targetIndex, true)
        );
    }

    public function addNodeByName($name, $targetId, $targetIndex, $extras = [])
    {
        $dth = $this->getDoctypeHandler();
        $newNodes = $dth->getNewNodeFor($name);
 
        if (!$newNodes) {
            return false;
        }
 
        // collect the element nodes the handler offers first: a node the
        // doctype handler does not allow must not leave the ones added
        // before it in the document
        $nodes = [];
        foreach ($newNodes as $node) {
            if ($node->nodeType != \XML_ELEMENT_NODE) {
                continue;
            }
 
            if (!$dth->isAllowedAdd($node, $targetId)) {
                return false;
            }
 
            $nodes[] = $node;
        }
 
        // the position of the first node is resolved once and the others
        // are added behind it; adding all of them at the same position
        // would add them in the reverse of the order the handler returns
        // them in. this is read before the adds open their own
        // transactions, the doctype handler hooks of addNode have to run
        // outside of a transaction
        $targetIndex = $this->positions()->normalizeIndex($targetId, $targetIndex);
 
        $success = false;
        foreach ($nodes as $index => $node) {
            $added = $this->addNode($node, $targetId, $targetIndex + $index, $extras);
 
            if ($added === false) {
                break;
            }
 
            $success = $added;
        }
 
        return $success;
    }

    public function replaceNode($node, $idToReplace)
    {
        return $this->inTransaction(function () use ($node, $idToReplace) {
            $targetId = $this->getParentIdById($idToReplace);
            $targetIndex = $this->getIndexById($idToReplace);
 
            $this->writer()->deleteNode($idToReplace);
 
            $changedIds = [];
            $changedIds[] = $this->saveNodeIn($node, $targetId, $targetIndex, true);
            $changedIds[] = $targetId;
 
            return $changedIds;
        });
    }

    public function duplicateNode($nodeId, $recursive = false)
    {
        // get parent and position for new node
        $targetId = $this->getParentIdById($nodeId);
        $targetIndex = $this->getIndexById($nodeId) + 1;
        $dth = $this->getDoctypeHandler();
 
        if (!$dth->isAllowedMove($nodeId, $targetId)) {
            return false;
        }
 
        $xmlDoc = $this->getSubdocByNodeId($nodeId, false);
 
        $this->clearCache();
 
        $copyId = $this->inTransaction(
            fn() => $this->saveNodeIn($xmlDoc, $targetId, $targetIndex, $recursive)
        );
 
        $dth->onCopyNode($nodeId, $copyId);
 
        return $copyId;
    }

    public function moveNode($nodeId, $targetId, $targetIndex)
    {
        return $this->moveNodeChecked($nodeId, $targetId, fn() => $targetIndex);
    }

    public function moveNodeIn($nodeId, $targetId)
    {
        return $this->moveNodeChecked($nodeId, $targetId, fn() => -1);
    }

    public function moveNodeBefore($nodeId, $targetId)
    {
        $targetParentId = $this->getParentIdById($targetId);
 
        return $this->moveNodeChecked(
            $nodeId,
            $targetParentId,
            fn() => $this->indexToMoveTo($nodeId, $targetId)
        );
    }

    public function moveNodeAfter($nodeId, $targetId)
    {
        $targetParentId = $this->getParentIdById($targetId);
 
        return $this->moveNodeChecked(
            $nodeId,
            $targetParentId,
            fn() => $this->indexToMoveTo($nodeId, $targetId) + 1
        );
    }

    private function indexToMoveTo($nodeId, $targetId, $offset = 0)
    {
        $targetIndex = (int) $this->getIndexById($targetId);
        $nodeIndex = $this->getIndexById($nodeId);
 
        if (
            $nodeIndex !== false
            && $this->getParentIdById($nodeId) == $this->getParentIdById($targetId)
            && $nodeIndex < $targetIndex
        ) {
            $targetIndex--;
        }
 
        return max(0, $targetIndex + $offset);
    }
    protected function moveNodeChecked($nodeId, $targetId, callable $getIndex)
    {
        $dth = $this->getDoctypeHandler();
 
        if (
            $nodeId !== $targetId
            && $dth->isAllowedMove($nodeId, $targetId)
        ) {
            $parentId = $this->inTransaction(
                fn() => $this->writer()->moveNode($nodeId, $targetId, $getIndex())
            );
 
            $dth->onMoveNode($nodeId, $parentId);
 
            return $parentId;
        }
 
        return false;
    }

    public function copyNode($nodeId, $targetId, $targetIndex)
    {
        return $this->copyNodeChecked($nodeId, $targetId, fn() => $targetIndex);
    }

    public function copyNodeIn($nodeId, $targetId)
    {
        return $this->copyNodeChecked($nodeId, $targetId, fn() => -1);
    }

    public function copyNodeBefore($nodeId, $targetId)
    {
        return $this->copyNodeChecked(
            $nodeId,
            $this->getParentIdById($targetId),
            fn() => $this->getIndexById($targetId)
        );
    }

    public function copyNodeAfter($nodeId, $targetId)
    {
        return $this->copyNodeChecked(
            $nodeId,
            $this->getParentIdById($targetId),
            fn() => $this->getIndexById($targetId) + 1
        );
    }

    protected function copyNodeChecked($nodeId, $targetId, callable $getIndex)
    {
        $dth = $this->getDoctypeHandler();
 
        if ($dth->isAllowedCopy($nodeId, $targetId)) {
            $copyId = $this->inTransaction(
                fn() => $this->writer()->copyNode($nodeId, $targetId, $getIndex())
            );
 
            $dth->onCopyNode($nodeId, $copyId);
 
            return $copyId;
        }
 
        return false;
    }

    public function setAttribute($nodeId, $attrName, $attrValue)
    {
        return $this->inTransaction(function () use ($nodeId, $attrName, $attrValue) {
            $attributes = $this->getAttributes($nodeId);
 
            if (
                (
                    isset($attributes[$attrName])
                    && $attributes[$attrName] !== htmlspecialchars($attrValue)
                )
                || !isset($attributes[$attrName])
            ) {
                $dth = $this->getDoctypeHandler();
 
                $dth->onSetAttribute($nodeId, $attrName, $attributes[$attrName] ?? null, $attrValue);
 
                $attributes[$attrName] = $attrValue;
 
                return $this->writer()->saveAttributes($nodeId, $attributes);
            }
 
            return false;
        });
    }

    public function removeAttribute($nodeId, $attrName)
    {
        return $this->inTransaction(function () use ($nodeId, $attrName) {
            $attributes = $this->getAttributes($nodeId);
 
            if (isset($attributes[$attrName])) {
                unset($attributes[$attrName]);
 
                return $this->writer()->saveAttributes($nodeId, $attributes);
            }
 
            return false;
        });
    }

    public static function removeNodeAttr($node, $dbNs, $attribute)
    {
        if ($node->nodeType == XML_ELEMENT_NODE || $node->nodeType == XML_DOCUMENT_NODE) {
            [$xml, $node] = \Depage\Xml\Document::getDocAndNode($node);
 
            $xpath = new \DOMXPath($xml);
            $xpath->registerNamespace($dbNs->ns, $dbNs->uri);
            $xpResult = $xpath->query(".//@{$dbNs->ns}:{$attribute}", $node);
 
            foreach ($xpResult as $node) {
                $node->parentNode->removeAttributeNode($node);
            }
        }
    }

    public function hashDomNode($node)
    {
        $doc = new \DOMDocument();
        $doc->formatOutput = false;
 
        [$d, $node] = \Depage\Xml\Document::getDocAndNode($node);
        $rootNode = $doc->importNode($node, true);
        $doc->appendChild($rootNode);
 
        self::removeIdAttr($rootNode);
        self::removeNodeAttr($rootNode, $this->dbNs, 'lastchange');
        self::removeNodeAttr($rootNode, $this->dbNs, 'lastchangeUid');
        self::removeNodeAttr($rootNode, $this->dbNs, 'docid');
        self::removeNodeAttr($rootNode, $this->dbNs, 'released');
 
        return hash("sha256", $doc->saveXML());
    }

    protected function getFreeNodeIds($preference = [])
    {
        $this->freeElementIds = $this->writer()->getFreeNodeIds($preference);
    }

    protected function addChildnodesByQuery($query, $row, $parentNode)
    {
        $doc = $parentNode->ownerDocument ?? $parentNode;
 
        do {
            //get ELMEMENT_NODE
            if ($row->type == 'ELEMENT_NODE') {
                //create node
                if ($ns = $this->getNamespace($row->name)) {
                    $node = $doc->createElementNS($ns->uri, $row->name);
                } else {
                    $node = $doc->createElement($row->name);
                }
                $parentNode->appendChild($node);
 
                if ($row->lvl == 0) {
                    foreach ($this->namespaces as $n) {
                        $node->setAttributeNS('http://www.w3.org/2000/xmlns/', "xmlns:{$n->ns}", $n->uri);
                    }
 
                    //add lastchange-data
                    $node->setAttributeNS($this->dbNs->uri, "{$this->dbNs->ns}:lastchange", $this->lastchange);
                    $node->setAttributeNS($this->dbNs->uri, "{$this->dbNs->ns}:lastchangeUid", $this->lastchangeUid ?? '');
                }
 
                //add attributes to node
                foreach (self::parseAttributeString($row->value) as $attrName => $attrValue) {
                    if ($ns = $this->getNamespace($attrName)) {
                        $node->setAttributeNS($ns->uri, $attrName, $attrValue);
                    } else {
                        $node->setAttribute($attrName, $attrValue);
                    }
                }
 
                //add id_attribute to node
                $node->setAttributeNS($this->dbNs->uri, "{$this->dbNs->ns}:{$this->idAttribute}", $row->id);
 
                //get TEXT_NODES
            } elseif ($row->type == 'TEXT_NODE') {
                $node = $doc->createTextNode(strtr($row->value, "\r", " "));
                $parentNode->appendChild($node);
                //get CDATA_SECTION
            } elseif ($row->type == 'CDATA_SECTION_NODE') {
                // @todo CDATA not implemented yet
                //get COMMENT_NODE
            } elseif ($row->type == 'COMMENT_NODE') {
                $node = $doc->createComment($row->value);
                $parentNode->appendChild($node);
                //get PROCESSING_INSTRUCTION
            } elseif ($row->type == 'PI_NODE') {
                $node = $doc->createProcessingInstruction($row->name, $row->value);
                $parentNode->appendChild($node);
                //get ENTITY_REF Node
            } elseif ($row->type == 'ENTITY_REF_NODE') {
                // @todo ENTITY_REF_NODE not implemented yet
            }
 
            $lastRow = $row;
            $row = $query->fetchObject();
 
            if ($lastRow->type == 'ELEMENT_NODE') {
                if ($row && $lastRow->lvl < $row->lvl) {
                    //add child_nodes
                    $row = $this->addChildnodesByQuery($query, $row, $node);
                }
            }
            if (!$row || $lastRow->lvl > $row->lvl) {
                return $row;
            }
        } while ($row);
 
        return $row;
    }

    protected function getAppendIndex($targetId)
    {
        return $this->positions()->appendIndex($targetId);
    }

    protected function getNamespace($name)
    {
        $parts = explode(":", $name, 2);
 
        if (!isset($parts[1])) {
            return false;
        }
 
        return $this->namespaces[$parts[0]];
    }
    protected function extractNamespaces($str)
    {
        $namespaces = [];
        $pName = '([a-zA-Z0-9]*)';
        $pAttr = '([^"]*)';
        preg_match_all("/xmlns:$pName=\"$pAttr\"/", $str, $nsElements, PREG_SET_ORDER);
 
        foreach ($nsElements as $nsElement) {
            $namespaces[$nsElement[1]] = new XmlNs($nsElement[1], $nsElement[2]);
        }
 
        return $namespaces;
    }
 
    protected function saveNodePrivate($node)
    {
        return $this->writer()->saveNodePrivate($node);
    }

    protected function saveNodeIn($node, $targetId, $targetIndex, $incChildren)
    {
        return $this->writer()->saveNodeIn($node, $targetId, $targetIndex, $incChildren);
    }

    protected function getNodeArrayForSaving(&$nodeArray, $node, $parentIndex = null, $pos = 0, $stripwhitespace = true)
    {
        return $this->writer()->getNodeArrayForSaving($nodeArray, $node, $parentIndex, $pos, $stripwhitespace);
    }

    protected function saveNodeToDb($node, $id, $targetId, $targetIndex, $setPosition = false)
    {
        return $this->writer()->saveNodeToDb($node, $id, $targetId, $targetIndex, $setPosition);
    }

    protected function inTransaction(callable $work, bool $altering = true)
    {
        if ($altering) {
            $this->beginTransactionAltering();
        } else {
            $this->beginTransactionNonAltering();
        }
 
        try {
            $result = $work();
        } catch (\Throwable $e) {
            $this->rollBackTransaction();
 
            throw $e;
        }
 
        $this->endTransaction();
 
        return $result;
    }

    public function beginTransactionAltering()
    {
        return $this->xmlDb->beginTransactionAltering();
    }

    public function beginTransactionNonAltering()
    {
        return $this->xmlDb->beginTransactionNonAltering();
    }

    public function endTransaction()
    {
        if ($this->subhashesDirty && $this->xmlDb->transactions == 1) {
            // last open transaction level; the subhashes still have to be
            // written before the actual commit runs to stay atomic
            $this->subhashesDirty = false;
            $this->refreshSubhashes();
        }
 
        $altered = $this->xmlDb->endTransaction();
 
        if ($altered) {
            $this->clearDocInfoCache();
            $this->clearCache();
            $this->getDoctypeHandler()->onDocumentChange();
        }
 
        return $altered;
    }

    public function rollBackTransaction()
    {
        // the document may have changed before the rollback, reload the
        // doc info instead of handing out information about rolled back
        // changes
        $this->docInfoLoaded = false;
 
        return $this->xmlDb->rollBackTransaction();
    }

    public function clearDocInfoCache()
    {
        $this->docInfoLoaded = false;
    }

    public function updateLastChange($timestamp = null, $uid = null)
    {
        $this->subhashesDirty = true;
 
        // the document row changes, the memoized info is stale
        $this->docInfoLoaded = false;
 
        $query = $this->pdo->prepare(
            "UPDATE {$this->tableDocs}
            SET
                lastchange=:timestamp,
                lastchange_uid=IFNULL(:user_id, lastchange_uid)
            WHERE
                id=:doc_id;",
        );
 
        if (empty($timestamp)) {
            $timestamp = time();
        } elseif (is_string($timestamp)) {
            $timestamp = strtotime($timestamp);
        }
 
        if (!empty($uid)) {
            $userId = $uid;
        } elseif (!empty($this->xmlDb->options['userId'])) {
            $userId = $this->xmlDb->options['userId'];
        } else {
            $userId = null;
        }
 
        $params = [
            'doc_id' => $this->getDocId(),
            'timestamp' => date('Y-m-d H:i:s', $timestamp),
            'user_id' => $userId,
        ];
 
        return ($query->execute($params)) ? $timestamp : false;
    }

    protected function refreshSubhashes()
    {
        if (is_null($this->subhashUpdater)) {
            $this->subhashUpdater = new Helpers\SubhashUpdater($this->pdo, $this->tableXml, $this->docId, self::SORTKEY_PAD, self::SAVE_BATCH_SIZE);
        }
 
        $this->subhashUpdater->refresh();
    }

    public function clearCache()
    {
        if (!is_null($this->docId)) {
            $this->cache->delete(Helpers\CacheKey::forDocument($this->tableDocs, $this->docId));
        }
    }
}
 
/* vim:set ft=php sw=4 sts=4 fdm=marker et : */