public static function init($messageReceiver = null)
{
Zotero_Notifier::registerObserver(__CLASS__, ["library", "apikey-library"], "NotifierObserver");
// Send notifications to SNS by default
self::$messageReceivers[] = function ($topic, $message) {
$sns = Z_Core::$AWS->createSns();
$sns->publish(['TopicArn' => $topic, 'Message' => $message]);
};
}
public static function updateVersions($items, $userID = false)
{
$libraryShards = array();
$libraryIsGroup = array();
$shardItemIDs = array();
$shardGroupItemIDs = array();
$libraryItems = array();
foreach ($items as $item) {
$libraryID = $item->libraryID;
$itemID = $item->id;
// Index items by shard
if (isset($libraryShards[$libraryID])) {
$shardID = $libraryShards[$libraryID];
$shardItemIDs[$shardID][] = $itemID;
} else {
$shardID = Zotero_Shards::getByLibraryID($libraryID);
$libraryShards[$libraryID] = $shardID;
$shardItemIDs[$shardID] = array($itemID);
}
// Separate out group items by shard
if (!isset($libraryIsGroup[$libraryID])) {
$libraryIsGroup[$libraryID] = Zotero_Libraries::getType($libraryID) == 'group';
}
if ($libraryIsGroup[$libraryID]) {
if (isset($shardGroupItemIDs[$shardID])) {
$shardGroupItemIDs[$shardID][] = $itemID;
} else {
$shardGroupItemIDs[$shardID] = array($itemID);
}
}
// Index items by library
if (!isset($libraryItems[$libraryID])) {
$libraryItems[$libraryID] = array();
}
$libraryItems[$libraryID][] = $item;
}
Zotero_DB::beginTransaction();
foreach ($shardItemIDs as $shardID => $itemIDs) {
// Group item data
if ($userID && isset($shardGroupItemIDs[$shardID])) {
$sql = "UPDATE groupItems SET lastModifiedByUserID=? " . "WHERE itemID IN (" . implode(',', array_fill(0, sizeOf($shardGroupItemIDs[$shardID]), '?')) . ")";
Zotero_DB::query($sql, array_merge(array($userID), $shardGroupItemIDs[$shardID]), $shardID);
}
}
foreach ($libraryItems as $libraryID => $items) {
$itemIDs = array();
foreach ($items as $item) {
$itemIDs[] = $item->id;
}
$version = Zotero_Libraries::getUpdatedVersion($libraryID);
$sql = "UPDATE items SET version=? WHERE itemID IN " . "(" . implode(',', array_fill(0, sizeOf($itemIDs), '?')) . ")";
Zotero_DB::query($sql, array_merge(array($version), $itemIDs), $shardID);
}
Zotero_DB::commit();
foreach ($libraryItems as $libraryID => $items) {
foreach ($items as $item) {
$item->reload();
}
$libraryKeys = array_map(function ($item) use($libraryID) {
return $libraryID . "/" . $item->key;
}, $items);
Zotero_Notifier::trigger('modify', 'item', $libraryKeys);
}
}
public function save($userID=false) {
if (!$this->_libraryID) {
trigger_error("Library ID must be set before saving", E_USER_ERROR);
}
Zotero_Items::editCheck($this, $userID);
if (!$this->hasChanged()) {
Z_Core::debug("Item $this->id has not changed");
return false;
}
$this->cacheEnabled = false;
// Make sure there are no gaps in the creator indexes
$creators = $this->getCreators();
$lastPos = -1;
foreach ($creators as $pos=>$creator) {
if ($pos != $lastPos + 1) {
trigger_error("Creator index $pos out of sequence for item $this->id", E_USER_ERROR);
}
$lastPos++;
}
$shardID = Zotero_Shards::getByLibraryID($this->_libraryID);
$env = [];
Zotero_DB::beginTransaction();
try {
//
// New item, insert and return id
//
if (!$this->id || (empty($this->changed['version']) && !$this->exists())) {
Z_Core::debug('Saving data for new item to database');
$isNew = $env['isNew'] = true;
$sqlColumns = array();
$sqlValues = array();
//
// Primary fields
//
$itemID = $this->_id = $this->_id ? $this->_id : Zotero_ID::get('items');
$key = $this->_key = $this->_key ? $this->_key : Zotero_ID::getKey();
$sqlColumns = array(
'itemID',
'itemTypeID',
'libraryID',
'key',
'dateAdded',
'dateModified',
'serverDateModified',
'version'
);
$timestamp = Zotero_DB::getTransactionTimestamp();
$dateAdded = $this->_dateAdded ? $this->_dateAdded : $timestamp;
$dateModified = $this->_dateModified ? $this->_dateModified : $timestamp;
$version = Zotero_Libraries::getUpdatedVersion($this->_libraryID);
$sqlValues = array(
$itemID,
$this->_itemTypeID,
$this->_libraryID,
$key,
$dateAdded,
$dateModified,
$timestamp,
$version
);
$sql = 'INSERT INTO items (`' . implode('`, `', $sqlColumns) . '`) VALUES (';
// Insert placeholders for bind parameters
for ($i=0; $i<sizeOf($sqlValues); $i++) {
$sql .= '?, ';
}
$sql = substr($sql, 0, -2) . ')';
// Save basic data to items table
try {
$insertID = Zotero_DB::query($sql, $sqlValues, $shardID);
}
catch (Exception $e) {
if (strpos($e->getMessage(), "Incorrect datetime value") !== false) {
preg_match("/Incorrect datetime value: '([^']+)'/", $e->getMessage(), $matches);
throw new Exception("=Invalid date value '{$matches[1]}' for item $key", Z_ERROR_INVALID_INPUT);
}
throw $e;
}
if (!$this->_id) {
if (!$insertID) {
throw new Exception("Item id not available after INSERT");
}
$itemID = $insertID;
$this->_serverDateModified = $timestamp;
}
// Group item data
if (Zotero_Libraries::getType($this->_libraryID) == 'group' && $userID) {
$sql = "INSERT INTO groupItems VALUES (?, ?, ?)";
Zotero_DB::query($sql, array($itemID, $userID, $userID), $shardID);
}
//
// ItemData
//
if (!empty($this->changed['itemData'])) {
// Use manual bound parameters to speed things up
$origInsertSQL = "INSERT INTO itemData (itemID, fieldID, value) VALUES ";
$insertSQL = $origInsertSQL;
$insertParams = array();
$insertCounter = 0;
$maxInsertGroups = 40;
$max = Zotero_Items::$maxDataValueLength;
$fieldIDs = array_keys($this->changed['itemData']);
foreach ($fieldIDs as $fieldID) {
$value = $this->getField($fieldID, true, false, true);
if ($value == 'CURRENT_TIMESTAMP'
&& Zotero_ItemFields::getID('accessDate') == $fieldID) {
$value = Zotero_DB::getTransactionTimestamp();
}
// Check length
if (strlen($value) > $max) {
$fieldName = Zotero_ItemFields::getLocalizedString(
$this->_itemTypeID, $fieldID
);
$msg = "=$fieldName field value " .
"'" . mb_substr($value, 0, 50) . "...' too long";
if ($this->_key) {
$msg .= " for item '" . $this->_libraryID . "/" . $key . "'";
}
throw new Exception($msg, Z_ERROR_FIELD_TOO_LONG);
}
if ($insertCounter < $maxInsertGroups) {
$insertSQL .= "(?,?,?),";
$insertParams = array_merge(
$insertParams,
array($itemID, $fieldID, $value)
);
}
if ($insertCounter == $maxInsertGroups - 1) {
$insertSQL = substr($insertSQL, 0, -1);
$stmt = Zotero_DB::getStatement($insertSQL, true, $shardID);
Zotero_DB::queryFromStatement($stmt, $insertParams);
$insertSQL = $origInsertSQL;
$insertParams = array();
$insertCounter = -1;
}
$insertCounter++;
}
if ($insertCounter > 0 && $insertCounter < $maxInsertGroups) {
$insertSQL = substr($insertSQL, 0, -1);
$stmt = Zotero_DB::getStatement($insertSQL, true, $shardID);
Zotero_DB::queryFromStatement($stmt, $insertParams);
}
}
//
// Creators
//
if (!empty($this->changed['creators'])) {
$indexes = array_keys($this->changed['creators']);
// TODO: group queries
$sql = "INSERT INTO itemCreators
(itemID, creatorID, creatorTypeID, orderIndex) VALUES ";
$placeholders = array();
$sqlValues = array();
$cacheRows = array();
foreach ($indexes as $orderIndex) {
Z_Core::debug('Adding creator in position ' . $orderIndex, 4);
$creator = $this->getCreator($orderIndex);
if (!$creator) {
continue;
}
if ($creator['ref']->hasChanged()) {
Z_Core::debug("Auto-saving changed creator {$creator['ref']->id}");
try {
$creator['ref']->save();
}
catch (Exception $e) {
// TODO: Provide the item in question
/*if (strpos($e->getCode() == Z_ERROR_CREATOR_TOO_LONG)) {
$msg = $e->getMessage();
$msg = str_replace(
"with this name and shorten it.",
"with this name, or paste '$key' into the quick search bar "
. "in the Zotero toolbar, and shorten the name."
);
throw new Exception($msg, Z_ERROR_CREATOR_TOO_LONG);
}*/
throw $e;
}
}
$placeholders[] = "(?, ?, ?, ?)";
array_push(
$sqlValues,
$itemID,
$creator['ref']->id,
$creator['creatorTypeID'],
$orderIndex
);
$cacheRows[] = array(
'creatorID' => $creator['ref']->id,
'creatorTypeID' => $creator['creatorTypeID'],
'orderIndex' => $orderIndex
);
}
if ($sqlValues) {
$sql = $sql . implode(',', $placeholders);
Zotero_DB::query($sql, $sqlValues, $shardID);
}
}
// Deleted item
if (!empty($this->changed['deleted'])) {
$deleted = $this->getDeleted();
if ($deleted) {
$sql = "REPLACE INTO deletedItems (itemID) VALUES (?)";
}
else {
$sql = "DELETE FROM deletedItems WHERE itemID=?";
}
Zotero_DB::query($sql, $itemID, $shardID);
}
// Note
if ($this->isNote() || !empty($this->changed['note'])) {
if (!is_string($this->noteText)) {
$this->noteText = '';
}
// If we don't have a sanitized note, generate one
if (is_null($this->noteTextSanitized)) {
$noteTextSanitized = Zotero_Notes::sanitize($this->noteText);
// But if note is sanitized already, store empty string
if ($this->noteText === $noteTextSanitized) {
$this->noteTextSanitized = '';
}
else {
$this->noteTextSanitized = $noteTextSanitized;
}
}
$this->noteTitle = Zotero_Notes::noteToTitle(
$this->noteTextSanitized === '' ? $this->noteText : $this->noteTextSanitized
);
$sql = "INSERT INTO itemNotes
(itemID, sourceItemID, note, noteSanitized, title, hash)
VALUES (?,?,?,?,?,?)";
$parent = $this->isNote() ? $this->getSource() : null;
$hash = $this->noteText ? md5($this->noteText) : '';
$bindParams = array(
$itemID,
$parent ? $parent : null,
$this->noteText !== null ? $this->noteText : '',
$this->noteTextSanitized,
$this->noteTitle,
$hash
);
try {
Zotero_DB::query($sql, $bindParams, $shardID);
}
catch (Exception $e) {
if (strpos($e->getMessage(), "Incorrect string value") !== false) {
throw new Exception("=Invalid character in note '" . Zotero_Utilities::ellipsize($title, 70) . "'", Z_ERROR_INVALID_INPUT);
}
throw ($e);
}
Zotero_Notes::updateNoteCache($this->_libraryID, $itemID, $this->noteText);
Zotero_Notes::updateHash($this->_libraryID, $itemID, $hash);
}
// Attachment
if ($this->isAttachment()) {
$sql = "INSERT INTO itemAttachments
(itemID, sourceItemID, linkMode, mimeType, charsetID, path, storageModTime, storageHash)
VALUES (?,?,?,?,?,?,?,?)";
$parent = $this->getSource();
if ($parent) {
$parentItem = Zotero_Items::get($this->_libraryID, $parent);
if (!$parentItem) {
throw new Exception("Parent item $parent not found");
}
if ($parentItem->getSource()) {
$parentKey = $parentItem->key;
throw new Exception("=Parent item $parentKey cannot be a child attachment", Z_ERROR_INVALID_INPUT);
}
}
$linkMode = $this->attachmentLinkMode;
$charsetID = Zotero_CharacterSets::getID($this->attachmentCharset);
$path = $this->attachmentPath;
$storageModTime = $this->attachmentStorageModTime;
$storageHash = $this->attachmentStorageHash;
$bindParams = array(
$itemID,
$parent ? $parent : null,
$linkMode + 1,
$this->attachmentMIMEType,
$charsetID ? $charsetID : null,
$path ? $path : '',
$storageModTime ? $storageModTime : null,
$storageHash ? $storageHash : null
);
Zotero_DB::query($sql, $bindParams, $shardID);
}
// Sort fields
$sortTitle = Zotero_Items::getSortTitle($this->getDisplayTitle(true));
if (mb_substr($sortTitle, 0, 5) == mb_substr($this->getField('title', false, true), 0, 5)) {
$sortTitle = null;
}
$creatorSummary = $this->isRegularItem()
? mb_strcut($this->getCreatorSummary(true), 0, Zotero_Creators::$creatorSummarySortLength)
: '';
$sql = "INSERT INTO itemSortFields (itemID, sortTitle, creatorSummary) VALUES (?, ?, ?)";
Zotero_DB::query($sql, array($itemID, $sortTitle, $creatorSummary), $shardID);
//
// Source item id
//
if ($sourceItemID = $this->getSource()) {
$newSourceItem = Zotero_Items::get($this->_libraryID, $sourceItemID);
if (!$newSourceItem) {
throw new Exception("Cannot set source to invalid item");
}
switch (Zotero_ItemTypes::getName($this->_itemTypeID)) {
case 'note':
$newSourceItem->incrementNoteCount();
break;
case 'attachment':
$newSourceItem->incrementAttachmentCount();
break;
}
}
// Collections
if (!empty($this->changed['collections'])) {
foreach ($this->collections as $collectionKey) {
$collection = Zotero_Collections::getByLibraryAndKey($this->_libraryID, $collectionKey);
if (!$collection) {
throw new Exception("Collection with key '$collectionKey' not found", Z_ERROR_COLLECTION_NOT_FOUND);
}
$collection->addItem($itemID);
$collection->save();
}
}
// Tags
if (!empty($this->changed['tags'])) {
foreach ($this->tags as $tag) {
$tagID = Zotero_Tags::getID($this->libraryID, $tag->tag, $tag->type);
if ($tagID) {
$tagObj = Zotero_Tags::get($this->_libraryID, $tagID);
}
else {
$tagObj = new Zotero_Tag;
$tagObj->libraryID = $this->_libraryID;
$tagObj->name = $tag->tag;
$tagObj->type = (int) $tag->type ? $tag->type : 0;
}
$tagObj->addItem($this->_key);
$tagObj->save();
}
}
// Related items
if (!empty($this->changed['relations'])) {
$uri = Zotero_URI::getItemURI($this);
$sql = "INSERT IGNORE INTO relations "
. "(relationID, libraryID, `key`, subject, predicate, object) "
. "VALUES (?, ?, ?, ?, ?, ?)";
$insertStatement = Zotero_DB::getStatement($sql, false, $shardID);
foreach ($this->relations as $rel) {
$insertStatement->execute(
array(
Zotero_ID::get('relations'),
$this->_libraryID,
Zotero_Relations::makeKey($uri, $rel[0], $rel[1]),
$uri,
$rel[0],
$rel[1]
)
);
}
}
// Remove from delete log if it's there
$sql = "DELETE FROM syncDeleteLogKeys WHERE libraryID=? AND objectType='item' AND `key`=?";
Zotero_DB::query($sql, array($this->_libraryID, $key), $shardID);
}
//
// Existing item, update
//
else {
Z_Core::debug('Updating database with new item data for item '
. $this->_libraryID . '/' . $this->_key, 4);
$isNew = $env['isNew'] = false;
//
// Primary fields
//
$sql = "UPDATE items SET ";
$sqlValues = array();
$timestamp = Zotero_DB::getTransactionTimestamp();
$version = Zotero_Libraries::getUpdatedVersion($this->_libraryID);
$updateFields = array(
'itemTypeID',
'libraryID',
'key',
'dateAdded',
'dateModified'
);
if (!empty($this->changed['primaryData'])) {
foreach ($updateFields as $updateField) {
if (in_array($updateField, $this->changed['primaryData'])) {
$sql .= "`$updateField`=?, ";
$sqlValues[] = $this->{"_$updateField"};
}
}
}
$sql .= "serverDateModified=?, version=? WHERE itemID=?";
array_push(
$sqlValues,
$timestamp,
$version,
$this->_id
);
Zotero_DB::query($sql, $sqlValues, $shardID);
$this->_serverDateModified = $timestamp;
// Group item data
if (Zotero_Libraries::getType($this->_libraryID) == 'group' && $userID) {
$sql = "INSERT INTO groupItems VALUES (?, ?, ?)
ON DUPLICATE KEY UPDATE lastModifiedByUserID=?";
Zotero_DB::query($sql, array($this->_id, null, $userID, $userID), $shardID);
}
//
// ItemData
//
if (!empty($this->changed['itemData'])) {
$del = array();
$origReplaceSQL = "REPLACE INTO itemData (itemID, fieldID, value) VALUES ";
$replaceSQL = $origReplaceSQL;
$replaceParams = array();
$replaceCounter = 0;
$maxReplaceGroups = 40;
$max = Zotero_Items::$maxDataValueLength;
$fieldIDs = array_keys($this->changed['itemData']);
foreach ($fieldIDs as $fieldID) {
$value = $this->getField($fieldID, true, false, true);
// If field changed and is empty, mark row for deletion
if ($value === "") {
$del[] = $fieldID;
continue;
}
if ($value == 'CURRENT_TIMESTAMP'
&& Zotero_ItemFields::getID('accessDate') == $fieldID) {
$value = Zotero_DB::getTransactionTimestamp();
}
// Check length
if (strlen($value) > $max) {
$fieldName = Zotero_ItemFields::getLocalizedString(
$this->_itemTypeID, $fieldID
);
$msg = "=$fieldName field value " .
"'" . mb_substr($value, 0, 50) . "...' too long";
if ($this->_key) {
$msg .= " for item '" . $this->_libraryID
. "/" . $this->_key . "'";
}
throw new Exception($msg, Z_ERROR_FIELD_TOO_LONG);
}
if ($replaceCounter < $maxReplaceGroups) {
$replaceSQL .= "(?,?,?),";
$replaceParams = array_merge($replaceParams,
array($this->_id, $fieldID, $value)
);
}
if ($replaceCounter == $maxReplaceGroups - 1) {
$replaceSQL = substr($replaceSQL, 0, -1);
$stmt = Zotero_DB::getStatement($replaceSQL, true, $shardID);
Zotero_DB::queryFromStatement($stmt, $replaceParams);
$replaceSQL = $origReplaceSQL;
$replaceParams = array();
$replaceCounter = -1;
}
$replaceCounter++;
}
if ($replaceCounter > 0 && $replaceCounter < $maxReplaceGroups) {
$replaceSQL = substr($replaceSQL, 0, -1);
$stmt = Zotero_DB::getStatement($replaceSQL, true, $shardID);
Zotero_DB::queryFromStatement($stmt, $replaceParams);
}
// Update memcached with used fields
$fids = array();
foreach ($this->itemData as $fieldID=>$value) {
if ($value !== false && $value !== null) {
$fids[] = $fieldID;
}
}
// Delete blank fields
if ($del) {
$sql = 'DELETE from itemData WHERE itemID=? AND fieldID IN (';
$sqlParams = array($this->_id);
foreach ($del as $d) {
$sql .= '?, ';
$sqlParams[] = $d;
}
$sql = substr($sql, 0, -2) . ')';
Zotero_DB::query($sql, $sqlParams, $shardID);
}
}
//
// Creators
//
if (!empty($this->changed['creators'])) {
$indexes = array_keys($this->changed['creators']);
$sql = "INSERT INTO itemCreators
(itemID, creatorID, creatorTypeID, orderIndex) VALUES ";
$placeholders = array();
$sqlValues = array();
$cacheRows = array();
foreach ($indexes as $orderIndex) {
Z_Core::debug('Creator in position ' . $orderIndex . ' has changed', 4);
$creator = $this->getCreator($orderIndex);
$sql2 = 'DELETE FROM itemCreators WHERE itemID=? AND orderIndex=?';
Zotero_DB::query($sql2, array($this->_id, $orderIndex), $shardID);
if (!$creator) {
continue;
}
if ($creator['ref']->hasChanged()) {
Z_Core::debug("Auto-saving changed creator {$creator['ref']->id}");
$creator['ref']->save();
}
$placeholders[] = "(?, ?, ?, ?)";
array_push(
$sqlValues,
$this->_id,
$creator['ref']->id,
$creator['creatorTypeID'],
$orderIndex
);
}
if ($sqlValues) {
$sql = $sql . implode(',', $placeholders);
Zotero_DB::query($sql, $sqlValues, $shardID);
}
}
// Deleted item
if (!empty($this->changed['deleted'])) {
$deleted = $this->getDeleted();
if ($deleted) {
$sql = "REPLACE INTO deletedItems (itemID) VALUES (?)";
}
else {
$sql = "DELETE FROM deletedItems WHERE itemID=?";
}
Zotero_DB::query($sql, $this->_id, $shardID);
}
// In case this was previously a standalone item,
// delete from any collections it may have been in
if (!empty($this->changed['source']) && $this->getSource()) {
$sql = "DELETE FROM collectionItems WHERE itemID=?";
Zotero_DB::query($sql, $this->_id, $shardID);
}
//
// Note or attachment note
//
if (!empty($this->changed['note'])) {
// If we don't have a sanitized note, generate one
if (is_null($this->noteTextSanitized)) {
$noteTextSanitized = Zotero_Notes::sanitize($this->noteText);
// But if note is sanitized already, store empty string
if ($this->noteText == $noteTextSanitized) {
$this->noteTextSanitized = '';
}
else {
$this->noteTextSanitized = $noteTextSanitized;
}
}
$this->noteTitle = Zotero_Notes::noteToTitle(
$this->noteTextSanitized === '' ? $this->noteText : $this->noteTextSanitized
);
// Only record sourceItemID in itemNotes for notes
if ($this->isNote()) {
$sourceItemID = $this->getSource();
}
$sourceItemID = !empty($sourceItemID) ? $sourceItemID : null;
$hash = $this->noteText ? md5($this->noteText) : '';
$sql = "INSERT INTO itemNotes
(itemID, sourceItemID, note, noteSanitized, title, hash)
VALUES (?,?,?,?,?,?)
ON DUPLICATE KEY UPDATE sourceItemID=?, note=?, noteSanitized=?, title=?, hash=?";
$bindParams = array(
$this->_id,
$sourceItemID, $this->noteText, $this->noteTextSanitized, $this->noteTitle, $hash,
$sourceItemID, $this->noteText, $this->noteTextSanitized, $this->noteTitle, $hash
);
Zotero_DB::query($sql, $bindParams, $shardID);
Zotero_Notes::updateNoteCache($this->_libraryID, $this->_id, $this->noteText);
Zotero_Notes::updateHash($this->_libraryID, $this->_id, $hash);
// TODO: handle changed source?
}
// Attachment
if (!empty($this->changed['attachmentData'])) {
$sql = "INSERT INTO itemAttachments
(itemID, sourceItemID, linkMode, mimeType, charsetID, path, storageModTime, storageHash)
VALUES (?,?,?,?,?,?,?,?)
ON DUPLICATE KEY UPDATE
sourceItemID=VALUES(sourceItemID),
linkMode=VALUES(linkMode),
mimeType=VALUES(mimeType),
charsetID=VALUES(charsetID),
path=VALUES(path),
storageModTime=VALUES(storageModTime),
storageHash=VALUES(storageHash)";
$parent = $this->getSource();
if ($parent) {
$parentItem = Zotero_Items::get($this->_libraryID, $parent);
if (!$parentItem) {
throw new Exception("Parent item $parent not found");
}
if ($parentItem->getSource()) {
$parentKey = $parentItem->key;
throw new Exception("=Parent item $parentKey cannot be a child attachment", Z_ERROR_INVALID_INPUT);
}
}
$linkMode = $this->attachmentLinkMode;
$charsetID = Zotero_CharacterSets::getID($this->attachmentCharset);
$path = $this->attachmentPath;
$storageModTime = $this->attachmentStorageModTime;
$storageHash = $this->attachmentStorageHash;
$bindParams = array(
$this->_id,
$parent ? $parent : null,
$linkMode + 1,
$this->attachmentMIMEType,
$charsetID ? $charsetID : null,
$path ? $path : '',
$storageModTime ? $storageModTime : null,
$storageHash ? $storageHash : null
);
Zotero_DB::query($sql, $bindParams, $shardID);
}
// Sort fields
if (!empty($this->changed['primaryData']['itemTypeID'])
|| !empty($this->changed['itemData'])
|| !empty($this->changed['creators'])) {
$sql = "UPDATE itemSortFields SET sortTitle=?";
$params = array();
$sortTitle = Zotero_Items::getSortTitle($this->getDisplayTitle(true));
if (mb_substr($sortTitle, 0, 5) == mb_substr($this->getField('title', false, true), 0, 5)) {
$sortTitle = null;
}
$params[] = $sortTitle;
if (!empty($this->changed['creators'])) {
$creatorSummary = mb_strcut($this->getCreatorSummary(true), 0, Zotero_Creators::$creatorSummarySortLength);
$sql .= ", creatorSummary=?";
$params[] = $creatorSummary;
}
$sql .= " WHERE itemID=?";
$params[] = $this->_id;
Zotero_DB::query($sql, $params, $shardID);
}
//
// Source item id
//
if (!empty($this->changed['source'])) {
$type = Zotero_ItemTypes::getName($this->_itemTypeID);
$Type = ucwords($type);
// Update DB, if not a note or attachment we already changed above
if (empty($this->changed['attachmentData']) && (empty($this->changed['note']) || !$this->isNote())) {
$sql = "UPDATE item" . $Type . "s SET sourceItemID=? WHERE itemID=?";
$parent = $this->getSource();
$bindParams = array(
$parent ? $parent : null,
$this->_id
);
Zotero_DB::query($sql, $bindParams, $shardID);
}
}
if (false && !empty($this->changed['source'])) {
trigger_error("Unimplemented", E_USER_ERROR);
$newItem = Zotero_Items::get($this->_libraryID, $sourceItemID);
// FK check
if ($newItem) {
if ($sourceItemID) {
}
else {
trigger_error("Cannot set $type source to invalid item $sourceItemID", E_USER_ERROR);
}
}
$oldSourceItemID = $this->getSource();
if ($oldSourceItemID == $sourceItemID) {
Z_Core::debug("$Type source hasn't changed", 4);
}
else {
$oldItem = Zotero_Items::get($this->_libraryID, $oldSourceItemID);
if ($oldSourceItemID && $oldItem) {
}
else {
//$oldItemNotifierData = null;
Z_Core::debug("Old source item $oldSourceItemID didn't exist in setSource()", 2);
}
// If this was an independent item, remove from any collections where it
// existed previously and add source instead if there is one
if (!$oldSourceItemID) {
$sql = "SELECT collectionID FROM collectionItems WHERE itemID=?";
$changedCollections = Zotero_DB::query($sql, $itemID, $shardID);
if ($changedCollections) {
trigger_error("Unimplemented", E_USER_ERROR);
if ($sourceItemID) {
$sql = "UPDATE OR REPLACE collectionItems "
. "SET itemID=? WHERE itemID=?";
Zotero_DB::query($sql, array($sourceItemID, $this->_id), $shardID);
}
else {
$sql = "DELETE FROM collectionItems WHERE itemID=?";
Zotero_DB::query($sql, $this->_id, $shardID);
}
}
}
$sql = "UPDATE item{$Type}s SET sourceItemID=?
WHERE itemID=?";
$bindParams = array(
$sourceItemID ? $sourceItemID : null,
$itemID
);
Zotero_DB::query($sql, $bindParams, $shardID);
//Zotero.Notifier.trigger('modify', 'item', $this->_id, notifierData);
// Update the counts of the previous and new sources
if ($oldItem) {
/*
switch ($type) {
case 'note':
$oldItem->decrementNoteCount();
break;
case 'attachment':
$oldItem->decrementAttachmentCount();
break;
}
*/
//Zotero.Notifier.trigger('modify', 'item', oldSourceItemID, oldItemNotifierData);
}
if ($newItem) {
/*
switch ($type) {
case 'note':
$newItem->incrementNoteCount();
break;
case 'attachment':
$newItem->incrementAttachmentCount();
break;
}
*/
//Zotero.Notifier.trigger('modify', 'item', sourceItemID, newItemNotifierData);
}
}
}
// Collections
if (!empty($this->changed['collections'])) {
$oldCollections = $this->previousData['collections'];
$newCollections = $this->collections;
$toAdd = array_diff($newCollections, $oldCollections);
$toRemove = array_diff($oldCollections, $newCollections);
foreach ($toAdd as $collectionKey) {
$collection = Zotero_Collections::getByLibraryAndKey($this->_libraryID, $collectionKey);
if (!$collection) {
throw new Exception("Collection with key '$collectionKey' not found", Z_ERROR_COLLECTION_NOT_FOUND);
}
$collection->addItem($this->_id);
$collection->save();
}
foreach ($toRemove as $collectionKey) {
$collection = Zotero_Collections::getByLibraryAndKey($this->_libraryID, $collectionKey);
$collection->removeItem($this->_id);
$collection->save();
}
}
if (!empty($this->changed['tags'])) {
$oldTags = $this->previousData['tags'];
$newTags = $this->tags;
$toAdd = [];
$toRemove = [];
// Get new tags not in existing
for ($i=0, $len=sizeOf($newTags); $i<$len; $i++) {
if (!isset($newTags[$i]->type)) {
$newTags[$i]->type = 0;
}
$name = trim($newTags[$i]->tag);
$type = $newTags[$i]->type;
foreach ($oldTags as $tag) {
// Do a case-insensitive comparison, to match the client
if (strtolower($tag->name) == strtolower($name) && $tag->type == $type) {
continue 2;
}
}
$toAdd[] = $newTags[$i];
}
// Get existing tags not in new
for ($i=0, $len=sizeOf($oldTags); $i<$len; $i++) {
$name = $oldTags[$i]->name;
$type = $oldTags[$i]->type;
foreach ($newTags as $tag) {
if (strtolower($tag->tag) == strtolower($name) && $tag->type == $type) {
continue 2;
}
}
$toRemove[] = $oldTags[$i];
}
foreach ($toAdd as $tag) {
$name = $tag->tag;
$type = $tag->type;
$tagID = Zotero_Tags::getID($this->_libraryID, $name, $type, true);
if (!$tagID) {
$tag = new Zotero_Tag;
$tag->libraryID = $this->_libraryID;
$tag->name = $name;
$tag->type = $type;
$tagID = $tag->save();
}
$tag = Zotero_Tags::get($this->_libraryID, $tagID);
$tag->addItem($this->_key);
$tag->save();
}
foreach ($toRemove as $tag) {
$tag->removeItem($this->_key);
$tag->save();
}
}
// Related items
if (!empty($this->changed['relations'])) {
$removed = [];
$new = [];
$current = $this->relations;
// TEMP
// Convert old-style related items into relations
$sql = "SELECT `key` FROM itemRelated IR "
. "JOIN items I ON (IR.linkedItemID=I.itemID) "
. "WHERE IR.itemID=?";
$toMigrate = Zotero_DB::columnQuery($sql, $this->_id, $shardID);
if ($toMigrate) {
$prefix = Zotero_URI::getLibraryURI($this->_libraryID) . "/items/";
$new = array_map(function ($key) use ($prefix) {
return [
Zotero_Relations::$relatedItemPredicate,
$prefix . $key
];
}, $toMigrate);
$sql = "DELETE FROM itemRelated WHERE itemID=?";
Zotero_DB::query($sql, $this->_id, $shardID);
}
foreach ($this->previousData['relations'] as $rel) {
if (array_search($rel, $current) === false) {
$removed[] = $rel;
}
}
foreach ($current as $rel) {
if (array_search($rel, $this->previousData['relations']) !== false) {
continue;
}
$new[] = $rel;
}
$uri = Zotero_URI::getItemURI($this);
if ($removed) {
$sql = "DELETE FROM relations WHERE libraryID=? AND `key`=?";
$deleteStatement = Zotero_DB::getStatement($sql, false, $shardID);
foreach ($removed as $rel) {
$params = [
$this->_libraryID,
Zotero_Relations::makeKey($uri, $rel[0], $rel[1])
];
$deleteStatement->execute($params);
// TEMP
// For owl:sameAs, delete reverse as well, since the client
// can save that way
if ($rel[0] == Zotero_Relations::$linkedObjectPredicate) {
$params = [
$this->_libraryID,
Zotero_Relations::makeKey($rel[1], $rel[0], $uri)
];
$deleteStatement->execute($params);
}
}
}
if ($new) {
$sql = "INSERT IGNORE INTO relations "
. "(relationID, libraryID, `key`, subject, predicate, object) "
. "VALUES (?, ?, ?, ?, ?, ?)";
$insertStatement = Zotero_DB::getStatement($sql, false, $shardID);
foreach ($new as $rel) {
$insertStatement->execute(
array(
Zotero_ID::get('relations'),
$this->_libraryID,
Zotero_Relations::makeKey($uri, $rel[0], $rel[1]),
$uri,
$rel[0],
$rel[1]
)
);
// If adding a related item, the version on that item has to be
// updated as well (if it exists). Otherwise, requests for that
// item will return cached data without the new relation.
if ($rel[0] == Zotero_Relations::$relatedItemPredicate) {
$relatedItem = Zotero_URI::getURIItem($rel[1]);
if (!$relatedItem) {
Z_Core::debug("Related item " . $rel[1] . " does not exist "
. "for item " . $this->_libraryKey);
continue;
}
// If item has already changed, assume something else is taking
// care of saving it and don't do so now, to avoid endless loops
// with circular relations
if ($relatedItem->hasChanged()) {
continue;
}
$relatedItem->updateVersion($userID);
}
}
}
}
}
Zotero_DB::commit();
}
catch (Exception $e) {
Zotero_DB::rollback();
throw ($e);
}
$this->cacheEnabled = false;
$this->finalizeSave($env);
if ($isNew) {
Zotero_Notifier::trigger('add', 'item', $this->_libraryID . "/" . $this->_key);
return $this->_id;
}
Zotero_Notifier::trigger('modify', 'item', $this->_libraryID . "/" . $this->_key);
return true;
}
private static function processUploadInternal($userID, SimpleXMLElement $xml, $syncQueueID = null, $syncProcessID = null)
{
$userLibraryID = Zotero_Users::getLibraryIDFromUserID($userID);
$affectedLibraries = self::parseAffectedLibraries($xml->asXML());
// Relations-only uploads don't have affected libraries
if (!$affectedLibraries) {
$affectedLibraries = array(Zotero_Users::getLibraryIDFromUserID($userID));
}
$processID = self::addUploadProcess($userID, $affectedLibraries, $syncQueueID, $syncProcessID);
set_time_limit(5400);
$profile = false;
if ($profile) {
$shardID = Zotero_Shards::getByUserID($userID);
Zotero_DB::profileStart($shardID);
}
try {
Zotero_DB::beginTransaction();
// Mark libraries as updated
foreach ($affectedLibraries as $libraryID) {
Zotero_Libraries::updateVersion($libraryID);
}
$timestamp = Zotero_Libraries::updateTimestamps($affectedLibraries);
Zotero_DB::registerTransactionTimestamp($timestamp);
// Make sure no other upload sessions use this same timestamp
// for any of these libraries, since we return >= 1 as the next
// last sync time
if (!Zotero_Libraries::setTimestampLock($affectedLibraries, $timestamp)) {
throw new Exception("Library timestamp already used", Z_ERROR_LIBRARY_TIMESTAMP_ALREADY_USED);
}
$modifiedItems = array();
// Add/update creators
if ($xml->creators) {
// DOM
$keys = array();
$xmlElements = dom_import_simplexml($xml->creators);
$xmlElements = $xmlElements->getElementsByTagName('creator');
Zotero_DB::query("SET foreign_key_checks = 0");
try {
$addedLibraryIDs = array();
$addedCreatorDataHashes = array();
foreach ($xmlElements as $xmlElement) {
$key = $xmlElement->getAttribute('key');
if (isset($keys[$key])) {
throw new Exception("Creator {$key} already processed");
}
$keys[$key] = true;
$creatorObj = Zotero_Creators::convertXMLToCreator($xmlElement);
if (Zotero_Utilities::unicodeTrim($creatorObj->firstName) === '' && Zotero_Utilities::unicodeTrim($creatorObj->lastName) === '') {
continue;
}
$addedLibraryIDs[] = $creatorObj->libraryID;
$changed = $creatorObj->save($userID);
// If the creator changed, we need to update all linked items
if ($changed) {
$modifiedItems = array_merge($modifiedItems, $creatorObj->getLinkedItems());
}
}
} catch (Exception $e) {
Zotero_DB::query("SET foreign_key_checks = 1");
throw $e;
}
Zotero_DB::query("SET foreign_key_checks = 1");
unset($keys);
unset($xml->creators);
//
// Manual foreign key checks
//
// libraryID
foreach (array_unique($addedLibraryIDs) as $addedLibraryID) {
$shardID = Zotero_Shards::getByLibraryID($addedLibraryID);
$sql = "SELECT COUNT(*) FROM shardLibraries WHERE libraryID=?";
if (!Zotero_DB::valueQuery($sql, $addedLibraryID, $shardID)) {
throw new Exception("libraryID inserted into `creators` not found in `shardLibraries` ({$addedLibraryID}, {$shardID})");
}
}
}
// Add/update items
$savedItems = array();
if ($xml->items) {
$childItems = array();
// DOM
$xmlElements = dom_import_simplexml($xml->items);
$xmlElements = $xmlElements->getElementsByTagName('item');
foreach ($xmlElements as $xmlElement) {
$libraryID = (int) $xmlElement->getAttribute('libraryID');
$key = $xmlElement->getAttribute('key');
if (isset($savedItems[$libraryID . "/" . $key])) {
throw new Exception("Item {$libraryID}/{$key} already processed");
}
$itemObj = Zotero_Items::convertXMLToItem($xmlElement);
if (!$itemObj->getSourceKey()) {
try {
$modified = $itemObj->save($userID);
if ($modified) {
$savedItems[$libraryID . "/" . $key] = true;
}
} catch (Exception $e) {
if (strpos($e->getMessage(), 'libraryIDs_do_not_match') !== false) {
throw new Exception($e->getMessage() . " ({$key})");
}
throw $e;
}
} else {
$childItems[] = $itemObj;
}
}
unset($xml->items);
while ($childItem = array_shift($childItems)) {
$libraryID = $childItem->libraryID;
$key = $childItem->key;
if (isset($savedItems[$libraryID . "/" . $key])) {
throw new Exception("Item {$libraryID}/{$key} already processed");
}
$modified = $childItem->save($userID);
if ($modified) {
$savedItems[$libraryID . "/" . $key] = true;
}
}
}
// Add/update collections
if ($xml->collections) {
$collections = array();
$collectionSets = array();
// DOM
// Build an array of unsaved collection objects and the keys of child items
$keys = array();
$xmlElements = dom_import_simplexml($xml->collections);
$xmlElements = $xmlElements->getElementsByTagName('collection');
foreach ($xmlElements as $xmlElement) {
$key = $xmlElement->getAttribute('key');
if (isset($keys[$key])) {
throw new Exception("Collection {$key} already processed");
}
$keys[$key] = true;
$collectionObj = Zotero_Collections::convertXMLToCollection($xmlElement);
$xmlItems = $xmlElement->getElementsByTagName('items')->item(0);
// Fix an error if there's leading or trailing whitespace,
// which was possible in 2.0.3
if ($xmlItems) {
$xmlItems = trim($xmlItems->nodeValue);
}
$arr = array('obj' => $collectionObj, 'items' => $xmlItems ? explode(' ', $xmlItems) : array());
$collections[] = $collectionObj;
$collectionSets[] = $arr;
}
unset($keys);
unset($xml->collections);
self::saveCollections($collections, $userID);
unset($collections);
// Set child items
foreach ($collectionSets as $collection) {
// Child items
if (isset($collection['items'])) {
$ids = array();
foreach ($collection['items'] as $key) {
$item = Zotero_Items::getByLibraryAndKey($collection['obj']->libraryID, $key);
if (!$item) {
throw new Exception("Child item '{$key}' of collection {$collection['obj']->id} not found", Z_ERROR_ITEM_NOT_FOUND);
}
$ids[] = $item->id;
}
$collection['obj']->setItems($ids);
}
}
unset($collectionSets);
}
// Add/update saved searches
if ($xml->searches) {
$searches = array();
$keys = array();
foreach ($xml->searches->search as $xmlElement) {
$key = (string) $xmlElement['key'];
if (isset($keys[$key])) {
throw new Exception("Search {$key} already processed");
}
$keys[$key] = true;
$searchObj = Zotero_Searches::convertXMLToSearch($xmlElement);
$searchObj->save($userID);
}
unset($xml->searches);
}
// Add/update tags
if ($xml->tags) {
$keys = array();
// DOM
$xmlElements = dom_import_simplexml($xml->tags);
$xmlElements = $xmlElements->getElementsByTagName('tag');
foreach ($xmlElements as $xmlElement) {
// TEMP
$tagItems = $xmlElement->getElementsByTagName('items');
if ($tagItems->length && $tagItems->item(0)->nodeValue == "") {
error_log("Skipping tag with no linked items");
continue;
}
$libraryID = (int) $xmlElement->getAttribute('libraryID');
$key = $xmlElement->getAttribute('key');
$lk = $libraryID . "/" . $key;
if (isset($keys[$lk])) {
throw new Exception("Tag {$lk} already processed");
}
$keys[$lk] = true;
$itemKeysToUpdate = array();
$tagObj = Zotero_Tags::convertXMLToTag($xmlElement, $itemKeysToUpdate);
// We need to update removed items, added items, and,
// if the tag itself has changed, existing items
$modifiedItems = array_merge($modifiedItems, array_map(function ($key) use($libraryID) {
return $libraryID . "/" . $key;
}, $itemKeysToUpdate));
$tagObj->save($userID, true);
}
unset($keys);
unset($xml->tags);
}
// Add/update relations
if ($xml->relations) {
// DOM
$xmlElements = dom_import_simplexml($xml->relations);
$xmlElements = $xmlElements->getElementsByTagName('relation');
foreach ($xmlElements as $xmlElement) {
$relationObj = Zotero_Relations::convertXMLToRelation($xmlElement, $userLibraryID);
if ($relationObj->exists()) {
continue;
}
$relationObj->save($userID);
}
unset($keys);
unset($xml->relations);
}
// Add/update settings
if ($xml->settings) {
// DOM
$xmlElements = dom_import_simplexml($xml->settings);
$xmlElements = $xmlElements->getElementsByTagName('setting');
foreach ($xmlElements as $xmlElement) {
$settingObj = Zotero_Settings::convertXMLToSetting($xmlElement);
$settingObj->save($userID);
}
unset($xml->settings);
}
if ($xml->fulltexts) {
// DOM
$xmlElements = dom_import_simplexml($xml->fulltexts);
$xmlElements = $xmlElements->getElementsByTagName('fulltext');
foreach ($xmlElements as $xmlElement) {
Zotero_FullText::indexFromXML($xmlElement, $userID);
}
unset($xml->fulltexts);
}
// TODO: loop
if ($xml->deleted) {
// Delete collections
if ($xml->deleted->collections) {
Zotero_Collections::deleteFromXML($xml->deleted->collections, $userID);
}
// Delete items
if ($xml->deleted->items) {
Zotero_Items::deleteFromXML($xml->deleted->items, $userID);
}
// Delete creators
if ($xml->deleted->creators) {
Zotero_Creators::deleteFromXML($xml->deleted->creators, $userID);
}
// Delete saved searches
if ($xml->deleted->searches) {
Zotero_Searches::deleteFromXML($xml->deleted->searches, $userID);
}
// Delete tags
if ($xml->deleted->tags) {
$xmlElements = dom_import_simplexml($xml->deleted->tags);
$xmlElements = $xmlElements->getElementsByTagName('tag');
foreach ($xmlElements as $xmlElement) {
$libraryID = (int) $xmlElement->getAttribute('libraryID');
$key = $xmlElement->getAttribute('key');
$tagObj = Zotero_Tags::getByLibraryAndKey($libraryID, $key);
if (!$tagObj) {
continue;
}
// We need to update all items on the deleted tag
$modifiedItems = array_merge($modifiedItems, array_map(function ($key) use($libraryID) {
return $libraryID . "/" . $key;
}, $tagObj->getLinkedItems(true)));
}
Zotero_Tags::deleteFromXML($xml->deleted->tags, $userID);
}
// Delete relations
if ($xml->deleted->relations) {
Zotero_Relations::deleteFromXML($xml->deleted->relations, $userID);
}
// Delete relations
if ($xml->deleted->settings) {
Zotero_Settings::deleteFromXML($xml->deleted->settings, $userID);
}
}
$toUpdate = array();
foreach ($modifiedItems as $item) {
// libraryID/key string
if (is_string($item)) {
if (isset($savedItems[$item])) {
continue;
}
$savedItems[$item] = true;
list($libraryID, $key) = explode("/", $item);
$item = Zotero_Items::getByLibraryAndKey($libraryID, $key);
if (!$item) {
// Item was deleted
continue;
}
} else {
$lk = $item->libraryID . "/" . $item->key;
if (isset($savedItems[$lk])) {
continue;
}
$savedItems[$lk] = true;
}
$toUpdate[] = $item;
}
Zotero_Items::updateVersions($toUpdate, $userID);
unset($savedItems);
unset($modifiedItems);
try {
self::removeUploadProcess($processID);
} catch (Exception $e) {
if (strpos($e->getMessage(), 'MySQL server has gone away') !== false) {
// Reconnect
error_log("Reconnecting to MySQL master");
Zotero_DB::close();
self::removeUploadProcess($processID);
} else {
throw $e;
}
}
// Send notifications for changed libraries
foreach ($affectedLibraries as $libraryID) {
Zotero_Notifier::trigger('modify', 'library', $libraryID);
}
Zotero_DB::commit();
if ($profile) {
$shardID = Zotero_Shards::getByUserID($userID);
Zotero_DB::profileEnd($shardID);
}
// Return timestamp + 1, to keep the next /updated call
// (using >= timestamp) from returning this data
return $timestamp + 1;
} catch (Exception $e) {
Zotero_DB::rollback(true);
self::removeUploadProcess($processID);
throw $e;
}
}
protected function end()
{
if ($this->profile) {
Zotero_DB::profileEnd($this->objectLibraryID, true);
}
switch ($this->responseCode) {
case 200:
// Output a Content-Type header for the given format
//
// Note that this overrides any Content-Type set elsewhere. To force a content
// type elsewhere, clear $this->queryParams['format'] when calling header()
// manually.
//
// TODO: Check headers_list so that clearing the format parameter manually isn't
// necessary? Performance?
if (isset($this->queryParams['format'])) {
Zotero_API::outputContentType($this->queryParams['format']);
}
break;
case 301:
case 302:
case 303:
// Handled in $this->redirect()
break;
case 401:
header('WWW-Authenticate: Basic realm="Zotero API"');
header('HTTP/1.1 401 Unauthorized');
break;
// PHP completes these automatically
// PHP completes these automatically
case 201:
case 204:
case 300:
case 304:
case 400:
case 403:
case 404:
case 405:
case 409:
case 412:
case 413:
case 422:
case 500:
case 501:
case 503:
header("HTTP/1.1 " . $this->responseCode);
break;
case 428:
header("HTTP/1.1 428 Precondition Required");
break;
case 429:
header("HTTP/1.1 429 Too Many Requests");
break;
default:
throw new Exception("Unsupported response code " . $this->responseCode);
}
if (isset($this->libraryVersion)) {
if ($this->apiVersion >= 2) {
header("Last-Modified-Version: " . $this->libraryVersion);
}
// Send notification if library has changed
if ($this->isWriteMethod()) {
if ($this->libraryVersion > Zotero_Libraries::getOriginalVersion($this->objectLibraryID)) {
Zotero_Notifier::trigger('modify', 'library', $this->objectLibraryID);
}
}
}
if ($this->responseXML instanceof SimpleXMLElement) {
if (!$this->responseCode) {
$updated = (string) $this->responseXML->updated;
if ($updated) {
$updated = strtotime($updated);
$ifModifiedSince = isset($_SERVER['HTTP_IF_MODIFIED_SINCE']) ? $_SERVER['HTTP_IF_MODIFIED_SINCE'] : false;
$ifModifiedSince = strtotime($ifModifiedSince);
if ($ifModifiedSince >= $updated) {
header('HTTP/1.1 304 Not Modified');
exit;
}
$lastModified = substr(date('r', $updated), 0, -5) . "GMT";
header("Last-Modified: {$lastModified}");
}
}
$xmlstr = $this->responseXML->asXML();
// TEMP: Strip control characters
$xmlstr = Zotero_Utilities::cleanString($xmlstr, true);
$doc = new DOMDocument('1.0');
$doc->loadXML($xmlstr);
$doc->formatOutput = true;
echo $doc->saveXML();
}
$this->logRequestTime();
self::addHeaders();
echo ob_get_clean();
exit;
}
public static function clearAllData($libraryID)
{
if (empty($libraryID)) {
throw new Exception("libraryID not provided");
}
Zotero_DB::beginTransaction();
$tables = array('collections', 'creators', 'items', 'relations', 'savedSearches', 'tags', 'syncDeleteLogIDs', 'syncDeleteLogKeys', 'settings');
$shardID = Zotero_Shards::getByLibraryID($libraryID);
self::deleteCachedData($libraryID);
// Because of the foreign key constraint on the itemID, delete MySQL full-text rows
// first, and then clear from Elasticsearch below
Zotero_FullText::deleteByLibraryMySQL($libraryID);
foreach ($tables as $table) {
// Delete notes and attachments first (since they may be child items)
if ($table == 'items') {
$sql = "DELETE FROM {$table} WHERE libraryID=? AND itemTypeID IN (1,14)";
Zotero_DB::query($sql, $libraryID, $shardID);
}
$sql = "DELETE FROM {$table} WHERE libraryID=?";
Zotero_DB::query($sql, $libraryID, $shardID);
}
Zotero_FullText::deleteByLibrary($libraryID);
self::updateVersion($libraryID);
self::updateTimestamps($libraryID);
Zotero_Notifier::trigger("clear", "library", $libraryID);
Zotero_DB::commit();
}
public function testReset()
{
$event = "add";
$type = "item";
$mock = $this->getMock('stdClass', array('notify'));
$mock->expects($this->never())->method('notify');
$hash = Zotero_Notifier::registerObserver($mock, $type);
Zotero_Notifier::begin();
Zotero_Notifier::trigger($event, $type, "1/AAAAAAAA");
Zotero_Notifier::trigger($event, $type, "1/BBBBBBBB");
Zotero_Notifier::reset();
Zotero_Notifier::commit();
Zotero_Notifier::unregisterObserver($hash);
}
public function erase()
{
if (!$this->loaded) {
Z_Core::debug("Not deleting unloaded group {$this->id}");
return;
}
Zotero_DB::beginTransaction();
$userIDs = self::getUsers();
$this->logGroupLibraryRemoval();
Zotero_Libraries::deleteCachedData($this->libraryID);
Zotero_Libraries::clearAllData($this->libraryID);
$sql = "DELETE FROM shardLibraries WHERE libraryID=?";
$deleted = Zotero_DB::query($sql, $this->libraryID, Zotero_Shards::getByLibraryID($this->libraryID));
if (!$deleted) {
throw new Exception("Group not deleted");
}
$sql = "DELETE FROM libraries WHERE libraryID=?";
$deleted = Zotero_DB::query($sql, $this->libraryID);
if (!$deleted) {
throw new Exception("Group not deleted");
}
// Delete key permissions for this library, and then delete any keys
// that had no other permissions
$sql = "SELECT keyID FROM keyPermissions WHERE libraryID=?";
$keyIDs = Zotero_DB::columnQuery($sql, $this->libraryID);
if ($keyIDs) {
$sql = "DELETE FROM keyPermissions WHERE libraryID=?";
Zotero_DB::query($sql, $this->libraryID);
$sql = "DELETE K FROM `keys` K LEFT JOIN keyPermissions KP USING (keyID)\n\t\t\t\t\tWHERE keyID IN (" . implode(', ', array_fill(0, sizeOf($keyIDs), '?')) . ") AND KP.keyID IS NULL";
Zotero_DB::query($sql, $keyIDs);
}
// If group is locked by a sync, flag group for a timestamp update
// once the sync is done so that the uploading user gets the change
try {
foreach ($userIDs as $userID) {
if ($syncUploadQueueID = Zotero_Sync::getUploadQueueIDByUserID($userID)) {
Zotero_Sync::postWriteLog($syncUploadQueueID, 'group', $this->id, 'delete');
}
}
} catch (Exception $e) {
Z_Core::logError($e);
}
Zotero_Notifier::trigger('delete', 'library', $this->libraryID);
Zotero_DB::commit();
$this->erased = true;
}
public static function reset()
{
Z_Core::debug("Resetting Notifier event queue");
self::$locked = false;
self::$queue = array();
self::$inTransaction = false;
}
public function save()
{
if (!$this->loaded) {
Z_Core::debug("Not saving unloaded key {$this->id}");
return;
}
if (!$this->userID) {
throw new Exception("Cannot save key without userID");
}
if (!$this->name) {
throw new Exception("Cannot save key without name");
}
if (strlen($this->name) > 255) {
throw new Exception("Key name too long", Z_ERROR_KEY_NAME_TOO_LONG);
}
Zotero_DB::beginTransaction();
if (!$this->key) {
$isNew = true;
$this->key = Zotero_Keys::generate();
} else {
$isNew = false;
}
$fields = array('key', 'userID', 'name');
$sql = "INSERT INTO `keys` (keyID, `key`, userID, name) VALUES (?, ?, ?, ?)";
$params = array($this->id);
foreach ($fields as $field) {
$params[] = $this->{$field};
}
$sql .= " ON DUPLICATE KEY UPDATE ";
$q = array();
foreach ($fields as $field) {
$q[] = "`{$field}`=?";
$params[] = $this->{$field};
}
$sql .= implode(", ", $q);
$insertID = Zotero_DB::query($sql, $params);
if (!$this->id) {
if (!$insertID) {
throw new Exception("Key id not available after INSERT");
}
$this->id = $insertID;
}
if (!$insertID) {
$sql = "SELECT * FROM keyPermissions WHERE keyID=?";
$oldRows = Zotero_DB::query($sql, $this->id);
}
$oldPermissions = [];
$newPermissions = [];
$librariesToAdd = [];
$librariesToRemove = [];
// Massage rows into permissions format
if (!$isNew && isset($oldRows)) {
foreach ($oldRows as $row) {
$oldPermissions[$row['libraryID']][$row['permission']] = !!$row['granted'];
}
}
// Delete existing permissions
$sql = "DELETE FROM keyPermissions WHERE keyID=?";
Zotero_DB::query($sql, $this->id);
if (isset($this->changed['permissions'])) {
foreach ($this->changed['permissions'] as $libraryID => $p) {
foreach ($p as $permission => $changed) {
$enabled = $this->permissions[$libraryID][$permission];
if (!$enabled) {
continue;
}
$sql = "INSERT INTO keyPermissions VALUES (?, ?, ?, ?)";
// TODO: support negative permissions
Zotero_DB::query($sql, array($this->id, $libraryID, $permission, 1));
$newPermissions[$libraryID][$permission] = true;
}
}
}
$this->permissions = $newPermissions;
// Send notifications for added and removed API key – library pairs
if (!$isNew) {
$librariesToAdd = $this->permissionsDiff($oldPermissions, $newPermissions, $this->userID);
$librariesToRemove = $this->permissionsDiff($newPermissions, $oldPermissions, $this->userID);
if ($librariesToAdd) {
Zotero_Notifier::trigger('add', 'apikey-library', array_map(function ($libraryID) {
return $this->key . "-" . $libraryID;
}, array_unique($librariesToAdd)));
}
if ($librariesToRemove) {
Zotero_Notifier::trigger('remove', 'apikey-library', array_map(function ($libraryID) {
return $this->key . "-" . $libraryID;
}, array_unique($librariesToRemove)));
}
}
Zotero_DB::commit();
$this->load();
return $this->id;
}
