public function testChangeItemTypeByLibraryAndKey()
{
$item = new Zotero_Item(2);
$item->libraryID = self::$config['userLibraryID'];
$item->save();
$key = $item->key;
$this->assertEquals(2, $item->itemTypeID);
$item = Zotero_Items::getByLibraryAndKey($item->libraryID, $item->key);
$item->itemTypeID = 3;
$item->save();
$this->assertEquals(3, $item->itemTypeID);
}
/**
* Converts a Zotero_Item object to a SimpleXMLElement item
*
* @param object $item Zotero_Item object
* @param array $data
* @return SimpleXMLElement Item data as SimpleXML element
*/
public static function convertItemToXML(Zotero_Item $item, $data = array())
{
$t = microtime(true);
// Check cache for all items except imported attachments,
// which don't have their versions updated when the client
// updates their file metadata
if (!$item->isImportedAttachment()) {
$cacheVersion = 1;
$cacheKey = "syncXMLItem_" . $item->libraryID . "/" . $item->id . "_" . $item->version . "_" . md5(json_encode($data)) . "_" . $cacheVersion . (isset(Z_CONFIG::$CACHE_VERSION_SYNC_XML_ITEM) ? "_" . Z_CONFIG::$CACHE_VERSION_SYNC_XML_ITEM : "");
$xmlstr = Z_Core::$MC->get($cacheKey);
} else {
$cacheKey = false;
$xmlstr = false;
}
if ($xmlstr) {
$xml = new SimpleXMLElement($xmlstr);
StatsD::timing("api.items.itemToSyncXML.cached", (microtime(true) - $t) * 1000);
StatsD::increment("memcached.items.itemToSyncXML.hit");
// Skip the cache every 10 times for now, to ensure cache sanity
if (Z_Core::probability(10)) {
//$xmlstr = $xml->saveXML();
} else {
Z_Core::debug("Using cached sync XML item");
return $xml;
}
}
$xml = new SimpleXMLElement('<item/>');
// Primary fields
foreach (self::$primaryFields as $field) {
switch ($field) {
case 'id':
case 'serverDateModified':
case 'version':
continue 2;
case 'itemTypeID':
$xmlField = 'itemType';
$xmlValue = Zotero_ItemTypes::getName($item->{$field});
break;
default:
$xmlField = $field;
$xmlValue = $item->{$field};
}
$xml[$xmlField] = $xmlValue;
}
// Item data
$itemTypeID = $item->itemTypeID;
$fieldIDs = $item->getUsedFields();
foreach ($fieldIDs as $fieldID) {
$val = $item->getField($fieldID);
if ($val == '') {
continue;
}
$f = $xml->addChild('field', htmlspecialchars($val));
$fieldName = Zotero_ItemFields::getName($fieldID);
// Special handling for renamed computerProgram 'version' field
if ($itemTypeID == 32 && $fieldName == 'versionNumber') {
$fieldName = 'version';
}
$f['name'] = htmlspecialchars($fieldName);
}
// Deleted item flag
if ($item->deleted) {
$xml['deleted'] = '1';
}
if ($item->isNote() || $item->isAttachment()) {
$sourceItemID = $item->getSource();
if ($sourceItemID) {
$sourceItem = Zotero_Items::get($item->libraryID, $sourceItemID);
if (!$sourceItem) {
throw new Exception("Source item {$sourceItemID} not found");
}
$xml['sourceItem'] = $sourceItem->key;
}
}
// Group modification info
$createdByUserID = null;
$lastModifiedByUserID = null;
switch (Zotero_Libraries::getType($item->libraryID)) {
case 'group':
$createdByUserID = $item->createdByUserID;
$lastModifiedByUserID = $item->lastModifiedByUserID;
break;
}
if ($createdByUserID) {
$xml['createdByUserID'] = $createdByUserID;
}
if ($lastModifiedByUserID) {
$xml['lastModifiedByUserID'] = $lastModifiedByUserID;
}
if ($item->isAttachment()) {
$xml['linkMode'] = $item->attachmentLinkMode;
$xml['mimeType'] = $item->attachmentMIMEType;
if ($item->attachmentCharset) {
$xml['charset'] = $item->attachmentCharset;
}
$storageModTime = $item->attachmentStorageModTime;
if ($storageModTime) {
$xml['storageModTime'] = $storageModTime;
}
$storageHash = $item->attachmentStorageHash;
if ($storageHash) {
$xml['storageHash'] = $storageHash;
}
// TODO: get from a constant
if ($item->attachmentLinkMode != 3) {
$xml->addChild('path', htmlspecialchars($item->attachmentPath));
}
}
// Note
if ($item->isNote() || $item->isAttachment()) {
// Get htmlspecialchars'ed note
$note = $item->getNote(false, true);
if ($note !== '') {
$xml->addChild('note', $note);
} else {
if ($item->isNote()) {
$xml->addChild('note', '');
}
}
}
// Creators
$creators = $item->getCreators();
if ($creators) {
foreach ($creators as $index => $creator) {
$c = $xml->addChild('creator');
$c['key'] = $creator['ref']->key;
$c['creatorType'] = htmlspecialchars(Zotero_CreatorTypes::getName($creator['creatorTypeID']));
$c['index'] = $index;
if (empty($data['updatedCreators']) || !in_array($creator['ref']->id, $data['updatedCreators'])) {
$cNode = dom_import_simplexml($c);
$creatorXML = Zotero_Creators::convertCreatorToXML($creator['ref'], $cNode->ownerDocument);
$cNode->appendChild($creatorXML);
}
}
}
// Related items
$relatedKeys = $item->relatedItems;
$keys = array();
foreach ($relatedKeys as $relatedKey) {
if (Zotero_Items::getByLibraryAndKey($item->libraryID, $relatedKey)) {
$keys[] = $relatedKey;
}
}
if ($keys) {
$xml->related = implode(' ', $keys);
}
if ($xmlstr) {
$uncached = $xml->saveXML();
if ($xmlstr != $uncached) {
error_log("Cached sync XML item does not match");
error_log(" Cached: " . $xmlstr);
error_log("Uncached: " . $uncached);
}
} else {
$xmlstr = $xml->saveXML();
if ($cacheKey) {
Z_Core::$MC->set($cacheKey, $xmlstr, 3600);
// 1 hour for now
}
StatsD::timing("api.items.itemToSyncXML.uncached", (microtime(true) - $t) * 1000);
StatsD::increment("memcached.items.itemToSyncXML.miss");
}
return $xml;
}
/**
* @param SimpleXMLElement $xml Data necessary for delete as SimpleXML element
* @return void
*/
public static function deleteFromXML(SimpleXMLElement $xml, $userID)
{
$parents = array();
foreach ($xml->children() as $obj) {
$libraryID = (int) $obj['libraryID'];
$key = (string) $obj['key'];
if ($userID && !Zotero_Libraries::userCanEdit($libraryID, $userID)) {
throw new Exception("Cannot edit " . self::$objectType . " in library {$libraryID}", Z_ERROR_LIBRARY_ACCESS_DENIED);
}
if ($obj->getName() == 'item') {
$item = Zotero_Items::getByLibraryAndKey($libraryID, $key);
if (!$item) {
continue;
}
if (!$item->getSource()) {
$parents[] = array('libraryID' => $libraryID, 'key' => $key);
continue;
}
}
self::delete($libraryID, $key);
}
foreach ($parents as $obj) {
self::delete($obj['libraryID'], $obj['key']);
}
}
/**
* Get the itemID of the source item for a note or file
**/
public function getSource() {
if (isset($this->sourceItem)) {
if (!$this->sourceItem) {
return false;
}
if (is_int($this->sourceItem)) {
return $this->sourceItem;
}
$sourceItem = Zotero_Items::getByLibraryAndKey($this->libraryID, $this->sourceItem);
if (!$sourceItem) {
throw new Exception("Source item $this->libraryID/$this->sourceItem for keyed source doesn't exist", Z_ERROR_ITEM_NOT_FOUND);
}
// Replace stored key with id
$this->sourceItem = $sourceItem->id;
return $sourceItem->id;
}
if (!$this->id) {
return false;
}
if ($this->isNote()) {
$Type = 'Note';
}
else if ($this->isAttachment()) {
$Type = 'Attachment';
}
else {
return false;
}
if ($this->cacheEnabled) {
$cacheVersion = 1;
$cacheKey = $this->getCacheKey("itemSource", $cacheVersion);
$sourceItemID = Z_Core::$MC->get($cacheKey);
}
else {
$sourceItemID = false;
}
if ($sourceItemID === false) {
$sql = "SELECT sourceItemID FROM item{$Type}s WHERE itemID=?";
$stmt = Zotero_DB::getStatement($sql, true, Zotero_Shards::getByLibraryID($this->libraryID));
$sourceItemID = Zotero_DB::valueQueryFromStatement($stmt, $this->id);
if ($this->cacheEnabled) {
Z_Core::$MC->set($cacheKey, $sourceItemID ? $sourceItemID : 0);
}
}
if (!$sourceItemID) {
$sourceItemID = false;
}
$this->sourceItem = $sourceItemID;
return $sourceItemID;
}
public function tags()
{
$this->allowMethods(array('GET'));
if (!$this->permissions->canAccess($this->objectLibraryID)) {
$this->e403();
}
$tags = array();
$totalResults = 0;
$name = $this->objectName;
$fixedValues = array();
// Set of tags matching name
if ($name && $this->subset != 'tags') {
$tagIDs = Zotero_Tags::getIDs($this->objectLibraryID, $name);
if (!$tagIDs) {
$this->e404();
}
$title = "Tags matching ‘" . $name . "’";
} else {
if ($this->scopeObject) {
// If id, redirect to key URL
if ($this->scopeObjectID) {
if (!in_array($this->scopeObject, array("collections", "items"))) {
$this->e400();
}
$className = 'Zotero_' . ucwords($this->scopeObject);
$obj = call_user_func(array($className, 'get'), $this->objectLibraryID, $this->scopeObjectID);
if (!$obj) {
$this->e404("Scope " . substr($this->scopeObject, 0, -1) . " not found");
}
$base = call_user_func(array('Zotero_API', 'get' . substr(ucwords($this->scopeObject), 0, -1) . 'URI'), $obj);
$qs = !empty($_SERVER['QUERY_STRING']) ? '?' . $_SERVER['QUERY_STRING'] : '';
header("Location: " . $base . "/tags" . $qs);
exit;
}
switch ($this->scopeObject) {
case 'collections':
$collection = Zotero_Collections::getByLibraryAndKey($this->objectLibraryID, $this->scopeObjectKey);
if (!$collection) {
$this->e404();
}
$title = "Tags in Collection ‘" . $collection->name . "’";
$counts = $collection->getTagItemCounts();
$tagIDs = array();
if ($counts) {
foreach ($counts as $tagID => $count) {
$tagIDs[] = $tagID;
$fixedValues[$tagID] = array('numItems' => $count);
}
}
break;
case 'items':
$item = Zotero_Items::getByLibraryAndKey($this->objectLibraryID, $this->scopeObjectKey);
if (!$item) {
$this->e404();
}
$title = "Tags of '" . $item->getDisplayTitle() . "'";
$tagIDs = $item->getTags(true);
break;
default:
throw new Exception("Invalid tags scope object '{$this->scopeObject}'");
}
} else {
$title = "Tags";
$results = Zotero_Tags::getAllAdvanced($this->objectLibraryID, $this->queryParams);
$tags = $results['objects'];
$totalResults = $results['total'];
}
}
if (!empty($tagIDs)) {
foreach ($tagIDs as $tagID) {
$tags[] = Zotero_Tags::get($this->objectLibraryID, $tagID);
}
// Fake sorting and limiting
$totalResults = sizeOf($tags);
$key = $this->queryParams['order'];
// 'title' order means 'name' for tags
if ($key == 'title') {
$key = 'name';
}
$dir = $this->queryParams['sort'];
$cmp = create_function('$a, $b', '$dir = "' . $dir . '" == "asc" ? 1 : -1;
if ($a->' . $key . ' == $b->' . $key . ') {
return 0;
}
else {
return ($a->' . $key . ' > $b->' . $key . ') ? $dir : ($dir * -1);}');
usort($tags, $cmp);
$tags = array_slice($tags, $this->queryParams['start'], $this->queryParams['limit']);
}
$this->responseXML = Zotero_Atom::createAtomFeed($this->getFeedNamePrefix($this->objectLibraryID) . $title, $this->uri, $tags, $totalResults, $this->queryParams, $this->apiVersion, $this->permissions, $fixedValues);
$this->end();
}
public static function indexFromXML(DOMElement $xml, $userID)
{
if ($xml->textContent === "") {
error_log("Skipping empty full-text content for item " . $xml->getAttribute('libraryID') . "/" . $xml->getAttribute('key'));
return;
}
$item = Zotero_Items::getByLibraryAndKey($xml->getAttribute('libraryID'), $xml->getAttribute('key'));
if (!$item) {
error_log("Item " . $xml->getAttribute('libraryID') . "/" . $xml->getAttribute('key') . " not found during full-text indexing");
return;
}
if (!Zotero_Libraries::userCanEdit($item->libraryID, $userID)) {
error_log("Skipping full-text content from user {$userID} for uneditable item " . $xml->getAttribute('libraryID') . "/" . $xml->getAttribute('key'));
return;
}
$stats = array();
foreach (self::$metadata as $prop) {
$val = $xml->getAttribute($prop);
$stats[$prop] = $val;
}
self::indexItem($item, $xml->textContent, $stats);
}
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;
}
}
public function itemContent()
{
$this->allowMethods(array('GET', 'PUT'));
// Check for general library access
if (!$this->permissions->canAccess($this->objectLibraryID)) {
$this->e403();
}
if (!$this->singleObject) {
$this->e404();
}
if ($this->isWriteMethod()) {
// Check for library write access
if (!$this->permissions->canWrite($this->objectLibraryID)) {
$this->e403("Write access denied");
}
Zotero_Libraries::updateVersionAndTimestamp($this->objectLibraryID);
}
$item = Zotero_Items::getByLibraryAndKey($this->objectLibraryID, $this->objectKey);
if (!$item) {
$this->e404();
}
// If no access to the note, don't show that it exists
if ($item->isNote() && !$this->permissions->canAccess($this->objectLibraryID, 'notes')) {
$this->e404();
}
if (!$item->isAttachment() || Zotero_Attachments::linkModeNumberToName($item->attachmentLinkMode) == 'LINKED_URL') {
$this->e404();
}
if ($this->isWriteMethod()) {
$this->libraryVersion = Zotero_Libraries::getUpdatedVersion($this->objectLibraryID);
if ($this->method == 'PUT') {
$this->requireContentType("application/json");
$json = json_decode($this->body, true);
if (!$json) {
$this->e400("PUT data is not valid JSON");
}
$stats = [];
foreach (Zotero_FullText::$metadata as $prop) {
if (isset($json[$prop])) {
$stats[$prop] = $json[$prop];
}
}
Zotero_FullText::indexItem($item, $json['content'], $stats);
$this->e204();
} else {
$this->e405();
}
}
$data = Zotero_FullText::getItemData($item->libraryID, $item->key);
if (!$data) {
$this->e404();
}
$this->libraryVersion = $data['version'];
$json = ["content" => $data['content']];
foreach (Zotero_FullText::$metadata as $prop) {
if (!empty($data[$prop])) {
$json[$prop] = $data[$prop];
}
}
echo Zotero_Utilities::formatJSON($json);
$this->end();
}
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 {
Z_Core::$MC->begin();
Zotero_DB::beginTransaction();
// Mark libraries as updated
$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);
}
// 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);
$addedLibraryIDs[] = $creatorObj->libraryID;
$creatorObj->save();
}
} 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 ($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
if ($xml->items) {
$childItems = array();
$relatedItemsStore = array();
// DOM
$keys = array();
$xmlElements = dom_import_simplexml($xml->items);
$xmlElements = $xmlElements->getElementsByTagName('item');
foreach ($xmlElements as $xmlElement) {
$key = $xmlElement->getAttribute('key');
if (isset($keys[$key])) {
throw new Exception("Item {$key} already processed");
}
$keys[$key] = true;
$missing = Zotero_Items::removeMissingRelatedItems($xmlElement);
$itemObj = Zotero_Items::convertXMLToItem($xmlElement);
if ($missing) {
$relatedItemsStore[$itemObj->libraryID . '_' . $itemObj->key] = $missing;
}
if (!$itemObj->getSourceKey()) {
try {
$itemObj->save($userID);
} catch (Exception $e) {
if (strpos($e->getMessage(), 'libraryIDs_do_not_match') !== false) {
throw new Exception($e->getMessage() . " (" . $itemObj->key . ")");
}
throw $e;
}
} else {
$childItems[] = $itemObj;
}
}
unset($keys);
unset($xml->items);
while ($childItem = array_shift($childItems)) {
$childItem->save($userID);
}
// Add back related items (which now exist)
foreach ($relatedItemsStore as $itemLibraryKey => $relset) {
$lk = explode('_', $itemLibraryKey);
$libraryID = $lk[0];
$key = $lk[1];
$item = Zotero_Items::getByLibraryAndKey($libraryID, $key);
foreach ($relset as $relKey) {
$relItem = Zotero_Items::getByLibraryAndKey($libraryID, $relKey);
$item->addRelatedItem($relItem->id);
}
$item->save();
}
unset($relatedItemsStore);
}
// 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);
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']->setChildItems($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();
}
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) {
$key = $xmlElement->getAttribute('key');
if (isset($keys[$key])) {
throw new Exception("Tag {$key} already processed");
}
$keys[$key] = true;
$tagObj = Zotero_Tags::convertXMLToTag($xmlElement);
$tagObj->save(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();
}
unset($keys);
unset($xml->relations);
}
// TODO: loop
if ($xml->deleted) {
// Delete collections
if ($xml->deleted->collections) {
Zotero_Collections::deleteFromXML($xml->deleted->collections);
}
// Delete items
if ($xml->deleted->items) {
Zotero_Items::deleteFromXML($xml->deleted->items);
}
// Delete creators
if ($xml->deleted->creators) {
Zotero_Creators::deleteFromXML($xml->deleted->creators);
}
// Delete saved searches
if ($xml->deleted->searches) {
Zotero_Searches::deleteFromXML($xml->deleted->searches);
}
// Delete tags
if ($xml->deleted->tags) {
Zotero_Tags::deleteFromXML($xml->deleted->tags);
}
// Delete tags
if ($xml->deleted->relations) {
Zotero_Relations::deleteFromXML($xml->deleted->relations);
}
}
self::removeUploadProcess($processID);
Zotero_DB::commit();
Z_Core::$MC->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) {
Z_Core::$MC->rollback();
Zotero_DB::rollback(true);
self::removeUploadProcess($processID);
throw $e;
}
}
/**
* @param SimpleXMLElement $xml Data necessary for delete as SimpleXML element
* @return void
*/
public static function deleteFromXML(SimpleXMLElement $xml)
{
$parents = array();
foreach ($xml->children() as $obj) {
$libraryID = (int) $obj['libraryID'];
$key = (string) $obj['key'];
if ($obj->getName() == 'item') {
$item = Zotero_Items::getByLibraryAndKey($libraryID, $key);
if (!$item) {
continue;
}
if (!$item->getSource()) {
$parents[] = array('libraryID' => $libraryID, 'key' => $key);
continue;
}
}
static::delete($libraryID, $key);
}
foreach ($parents as $obj) {
static::delete($obj['libraryID'], $obj['key']);
}
}
/**
* Temporarily remove and store related items that don't
* yet exist
*
* @param DOMElement $xmlElement
* @return array
*/
public static function removeMissingRelatedItems(DOMElement $xmlElement)
{
$missing = array();
$related = $xmlElement->getElementsByTagName('related')->item(0);
if ($related && $related->nodeValue) {
$relKeys = explode(' ', $related->nodeValue);
$exist = array();
$missing = array();
foreach ($relKeys as $key) {
$item = Zotero_Items::getByLibraryAndKey((int) $xmlElement->getAttribute('libraryID'), $key);
if ($item) {
$exist[] = $key;
} else {
$missing[] = $key;
}
}
$related->nodeValue = implode(' ', $exist);
}
return $missing;
}
/**
* Converts a DOMElement item to a Zotero_Tag object
*
* @param DOMElement $xml Tag data as DOMElement
* @param int $libraryID Library ID
* @return Zotero_Tag Zotero tag object
*/
public static function convertXMLToTag(DOMElement $xml)
{
$libraryID = (int) $xml->getAttribute('libraryID');
$tag = self::getByLibraryAndKey($libraryID, $xml->getAttribute('key'));
if (!$tag) {
$tag = new Zotero_Tag();
$tag->libraryID = $libraryID;
$tag->key = $xml->getAttribute('key');
}
$tag->name = $xml->getAttribute('name');
$type = (int) $xml->getAttribute('type');
$tag->type = $type ? $type : 0;
$tag->dateAdded = $xml->getAttribute('dateAdded');
$tag->dateModified = $xml->getAttribute('dateModified');
$itemKeys = $xml->getElementsByTagName('items');
if ($itemKeys->length) {
$itemKeys = explode(' ', $itemKeys->item(0)->nodeValue);
$itemIDs = array();
foreach ($itemKeys as $key) {
$item = Zotero_Items::getByLibraryAndKey($libraryID, $key);
if (!$item) {
// Return a specific error for a wrong-library tag issue that I can't reproduce
throw new Exception("Linked item {$key} of tag {$libraryID}/{$tag->key} not found", Z_ERROR_TAG_LINKED_ITEM_NOT_FOUND);
//throw new Exception("Linked item $key of tag $libraryID/$tag->key not found", Z_ERROR_ITEM_NOT_FOUND);
}
$itemIDs[] = $item->id;
}
$tag->setLinkedItems($itemIDs);
} else {
$tag->setLinkedItems(array());
}
return $tag;
}
public function getLinkedItems($asKeys = false)
{
if (!$this->linkedItemsLoaded) {
$this->loadLinkedItems();
}
if ($asKeys) {
return $this->linkedItems;
}
// In PHP 5.4 $this->libraryID can be used directly in the closure
$libraryID = $this->libraryID;
return array_map(function ($key) use($libraryID) {
return Zotero_Items::getByLibraryAndKey($libraryID, $this->linkedItems);
}, $this->linkedItems);
}
public function items()
{
// Check for general library access
if (!$this->permissions->canAccess($this->objectLibraryID)) {
$this->e403();
}
if ($this->isWriteMethod()) {
// Check for library write access
if (!$this->permissions->canWrite($this->objectLibraryID)) {
$this->e403("Write access denied");
}
// Make sure library hasn't been modified
if (!$this->singleObject) {
$libraryTimestampChecked = $this->checkLibraryIfUnmodifiedSinceVersion();
}
// We don't update the library version in file mode, because currently
// to avoid conflicts in the client the timestamp can't change
// when the client updates file metadata
if (!$this->fileMode) {
Zotero_Libraries::updateVersionAndTimestamp($this->objectLibraryID);
}
}
$itemIDs = array();
$itemKeys = array();
$results = array();
$title = "";
//
// Single item
//
if ($this->singleObject) {
if ($this->fileMode) {
if ($this->fileView) {
$this->allowMethods(array('HEAD', 'GET', 'POST'));
} else {
$this->allowMethods(array('HEAD', 'GET', 'PUT', 'POST', 'PATCH'));
}
} else {
$this->allowMethods(array('HEAD', 'GET', 'PUT', 'PATCH', 'DELETE'));
}
if (!$this->objectLibraryID || !Zotero_ID::isValidKey($this->objectKey)) {
$this->e404();
}
$item = Zotero_Items::getByLibraryAndKey($this->objectLibraryID, $this->objectKey);
if ($item) {
// If no access to the note, don't show that it exists
if ($item->isNote() && !$this->permissions->canAccess($this->objectLibraryID, 'notes')) {
$this->e404();
}
// Make sure URL libraryID matches item libraryID
if ($this->objectLibraryID != $item->libraryID) {
$this->e404("Item does not exist");
}
// File access mode
if ($this->fileMode) {
$this->_handleFileRequest($item);
}
if ($this->scopeObject) {
switch ($this->scopeObject) {
// Remove item from collection
case 'collections':
$this->allowMethods(array('DELETE'));
$collection = Zotero_Collections::getByLibraryAndKey($this->objectLibraryID, $this->scopeObjectKey);
if (!$collection) {
$this->e404("Collection not found");
}
if (!$collection->hasItem($item->id)) {
$this->e404("Item not found in collection");
}
$collection->removeItem($item->id);
$this->e204();
default:
$this->e400();
}
}
} else {
// Possibly temporary workaround to block unnecessary full syncs
if ($this->fileMode && $this->httpAuth && $this->method == 'POST') {
// If > 2 requests for missing file, trigger a full sync via 404
$cacheKey = "apiMissingFile_" . $this->objectLibraryID . "_" . $this->objectKey;
$set = Z_Core::$MC->get($cacheKey);
if (!$set) {
Z_Core::$MC->set($cacheKey, 1, 86400);
} else {
if ($set < 2) {
Z_Core::$MC->increment($cacheKey);
} else {
Z_Core::$MC->delete($cacheKey);
$this->e404("A file sync error occurred. Please sync again.");
}
}
$this->e500("A file sync error occurred. Please sync again.");
}
}
if ($this->isWriteMethod()) {
$item = $this->handleObjectWrite('item', $item ? $item : null);
if ($this->apiVersion < 2 && ($this->method == 'PUT' || $this->method == 'PATCH')) {
$this->queryParams['format'] = 'atom';
$this->queryParams['content'] = ['json'];
}
}
if (!$item) {
$this->e404("Item does not exist");
}
$this->libraryVersion = $item->version;
if ($this->method == 'HEAD') {
$this->end();
}
// Display item
switch ($this->queryParams['format']) {
case 'atom':
$this->responseXML = Zotero_Items::convertItemToAtom($item, $this->queryParams, $this->permissions);
break;
case 'bib':
echo Zotero_Cite::getBibliographyFromCitationServer(array($item), $this->queryParams);
break;
case 'csljson':
$json = Zotero_Cite::getJSONFromItems(array($item), true);
echo Zotero_Utilities::formatJSON($json);
break;
case 'json':
$json = $item->toResponseJSON($this->queryParams, $this->permissions);
echo Zotero_Utilities::formatJSON($json);
break;
default:
$export = Zotero_Translate::doExport(array($item), $this->queryParams['format']);
$this->queryParams['format'] = null;
header("Content-Type: " . $export['mimeType']);
echo $export['body'];
break;
}
} else {
$this->allowMethods(array('HEAD', 'GET', 'POST', 'DELETE'));
$this->libraryVersion = Zotero_Libraries::getUpdatedVersion($this->objectLibraryID);
$includeTrashed = $this->queryParams['includeTrashed'];
if ($this->scopeObject) {
$this->allowMethods(array('GET', 'POST'));
switch ($this->scopeObject) {
case 'collections':
// TEMP
if (Zotero_ID::isValidKey($this->scopeObjectKey)) {
$collection = Zotero_Collections::getByLibraryAndKey($this->objectLibraryID, $this->scopeObjectKey);
} else {
$collection = false;
}
if (!$collection) {
// If old collectionID, redirect
if ($this->method == 'GET' && Zotero_Utilities::isPosInt($this->scopeObjectKey)) {
$collection = Zotero_Collections::get($this->objectLibraryID, $this->scopeObjectKey);
if ($collection) {
$qs = !empty($_SERVER['QUERY_STRING']) ? '?' . $_SERVER['QUERY_STRING'] : '';
$base = Zotero_API::getCollectionURI($collection);
$this->redirect($base . "/items" . $qs, 301);
}
}
$this->e404("Collection not found");
}
// Add items to collection
if ($this->method == 'POST') {
$itemKeys = explode(' ', $this->body);
$itemIDs = array();
foreach ($itemKeys as $key) {
try {
$item = Zotero_Items::getByLibraryAndKey($this->objectLibraryID, $key);
} catch (Exception $e) {
if ($e->getCode() == Z_ERROR_OBJECT_LIBRARY_MISMATCH) {
$item = false;
} else {
throw $e;
}
}
if (!$item) {
throw new Exception("Item '{$key}' not found in library", Z_ERROR_INVALID_INPUT);
}
if ($item->getSource()) {
throw new Exception("Child items cannot be added to collections directly", Z_ERROR_INVALID_INPUT);
}
$itemIDs[] = $item->id;
}
$collection->addItems($itemIDs);
$this->e204();
}
if ($this->subset == 'top' || $this->apiVersion < 2) {
$title = "Top-Level Items in Collection ‘" . $collection->name . "’";
$itemIDs = $collection->getItems();
} else {
$title = "Items in Collection ‘" . $collection->name . "’";
$itemIDs = $collection->getItems(true);
}
break;
case 'tags':
if ($this->apiVersion >= 2) {
$this->e404();
}
$this->allowMethods(array('GET'));
$tagIDs = Zotero_Tags::getIDs($this->objectLibraryID, $this->scopeObjectName);
if (!$tagIDs) {
$this->e404("Tag not found");
}
foreach ($tagIDs as $tagID) {
$tag = new Zotero_Tag();
$tag->libraryID = $this->objectLibraryID;
$tag->id = $tagID;
// Use a real tag name, in case case differs
if (!$title) {
$title = "Items of Tag ‘" . $tag->name . "’";
}
$itemKeys = array_merge($itemKeys, $tag->getLinkedItems(true));
}
$itemKeys = array_unique($itemKeys);
break;
default:
$this->e404();
}
} else {
// Top-level items
if ($this->subset == 'top') {
$this->allowMethods(array('GET'));
$title = "Top-Level Items";
$results = Zotero_Items::search($this->objectLibraryID, true, $this->queryParams, $includeTrashed, $this->permissions);
} else {
if ($this->subset == 'trash') {
$this->allowMethods(array('GET'));
$title = "Deleted Items";
$this->queryParams['trashedItemsOnly'] = true;
$includeTrashed = true;
$results = Zotero_Items::search($this->objectLibraryID, false, $this->queryParams, $includeTrashed, $this->permissions);
} else {
if ($this->subset == 'children') {
$item = Zotero_Items::getByLibraryAndKey($this->objectLibraryID, $this->objectKey);
if (!$item) {
$this->e404("Item not found");
}
if ($item->isAttachment()) {
$this->e400("/children cannot be called on attachment items");
}
if ($item->isNote()) {
$this->e400("/children cannot be called on note items");
}
if ($item->getSource()) {
$this->e400("/children cannot be called on child items");
}
// Create new child items
if ($this->method == 'POST') {
if ($this->apiVersion >= 2) {
$this->allowMethods(array('GET'));
}
Zotero_DB::beginTransaction();
$obj = $this->jsonDecode($this->body);
$results = Zotero_Items::updateMultipleFromJSON($obj, $this->queryParams, $this->objectLibraryID, $this->userID, $this->permissions, $libraryTimestampChecked ? 0 : 1, $item);
Zotero_DB::commit();
if ($cacheKey = $this->getWriteTokenCacheKey()) {
Z_Core::$MC->set($cacheKey, true, $this->writeTokenCacheTime);
}
$uri = Zotero_API::getItemsURI($this->objectLibraryID);
$keys = array_merge(get_object_vars($results['success']), get_object_vars($results['unchanged']));
$queryString = "itemKey=" . urlencode(implode(",", $keys)) . "&format=atom&content=json&order=itemKeyList&sort=asc";
if ($this->apiKey) {
$queryString .= "&key=" . $this->apiKey;
}
$uri .= "?" . $queryString;
$this->queryParams = Zotero_API::parseQueryParams($queryString, $this->action, false);
$this->responseCode = 201;
$title = "Items";
$results = Zotero_Items::search($this->objectLibraryID, false, $this->queryParams, $includeTrashed, $this->permissions);
} else {
$title = "Child Items of ‘" . $item->getDisplayTitle() . "’";
$notes = $item->getNotes();
$attachments = $item->getAttachments();
$itemIDs = array_merge($notes, $attachments);
}
} else {
// Create new items
if ($this->method == 'POST') {
$this->queryParams['format'] = 'writereport';
$obj = $this->jsonDecode($this->body);
// Server-side translation
if (isset($obj->url)) {
if ($this->apiVersion == 1) {
Zotero_DB::beginTransaction();
}
$token = $this->getTranslationToken($obj);
$results = Zotero_Items::addFromURL($obj, $this->queryParams, $this->objectLibraryID, $this->userID, $this->permissions, $token);
if ($this->apiVersion == 1) {
Zotero_DB::commit();
}
// Multiple choices
if ($results instanceof stdClass) {
$this->queryParams['format'] = null;
header("Content-Type: application/json");
if ($this->queryParams['v'] >= 2) {
echo Zotero_Utilities::formatJSON(['url' => $obj->url, 'token' => $token, 'items' => $results->select]);
} else {
echo Zotero_Utilities::formatJSON($results->select);
}
$this->e300();
} else {
if (is_int($results)) {
switch ($results) {
case 501:
$this->e501("No translators found for URL");
break;
default:
$this->e500("Error translating URL");
}
} else {
if ($this->apiVersion == 1) {
$uri = Zotero_API::getItemsURI($this->objectLibraryID);
$keys = array_merge(get_object_vars($results['success']), get_object_vars($results['unchanged']));
$queryString = "itemKey=" . urlencode(implode(",", $keys)) . "&format=atom&content=json&order=itemKeyList&sort=asc";
if ($this->apiKey) {
$queryString .= "&key=" . $this->apiKey;
}
$uri .= "?" . $queryString;
$this->queryParams = Zotero_API::parseQueryParams($queryString, $this->action, false);
$this->responseCode = 201;
$title = "Items";
$results = Zotero_Items::search($this->objectLibraryID, false, $this->queryParams, $includeTrashed, $this->permissions);
}
}
}
// Otherwise return write status report
} else {
if ($this->apiVersion < 2) {
Zotero_DB::beginTransaction();
}
$results = Zotero_Items::updateMultipleFromJSON($obj, $this->queryParams, $this->objectLibraryID, $this->userID, $this->permissions, $libraryTimestampChecked ? 0 : 1, null);
if ($this->apiVersion < 2) {
Zotero_DB::commit();
$uri = Zotero_API::getItemsURI($this->objectLibraryID);
$keys = array_merge(get_object_vars($results['success']), get_object_vars($results['unchanged']));
$queryString = "itemKey=" . urlencode(implode(",", $keys)) . "&format=atom&content=json&order=itemKeyList&sort=asc";
if ($this->apiKey) {
$queryString .= "&key=" . $this->apiKey;
}
$uri .= "?" . $queryString;
$this->queryParams = Zotero_API::parseQueryParams($queryString, $this->action, false);
$this->responseCode = 201;
$title = "Items";
$results = Zotero_Items::search($this->objectLibraryID, false, $this->queryParams, $includeTrashed, $this->permissions);
}
}
if ($cacheKey = $this->getWriteTokenCacheKey()) {
Z_Core::$MC->set($cacheKey, true, $this->writeTokenCacheTime);
}
} else {
if ($this->method == 'DELETE') {
Zotero_DB::beginTransaction();
foreach ($this->queryParams['itemKey'] as $itemKey) {
Zotero_Items::delete($this->objectLibraryID, $itemKey);
}
Zotero_DB::commit();
$this->e204();
} else {
$title = "Items";
$results = Zotero_Items::search($this->objectLibraryID, false, $this->queryParams, $includeTrashed, $this->permissions);
}
}
}
}
}
}
if ($itemIDs || $itemKeys) {
if ($itemIDs) {
$this->queryParams['itemIDs'] = $itemIDs;
}
if ($itemKeys) {
$this->queryParams['itemKey'] = $itemKeys;
}
$results = Zotero_Items::search($this->objectLibraryID, false, $this->queryParams, $includeTrashed, $this->permissions);
}
if ($this->queryParams['format'] == 'bib') {
$maxBibItems = Zotero_API::MAX_BIBLIOGRAPHY_ITEMS;
if ($results['total'] > $maxBibItems) {
$this->e413("Cannot generate bibliography with more than {$maxBibItems} items");
}
}
$this->generateMultiResponse($results, $title);
}
$this->end();
}
public function tags()
{
$this->allowMethods(['HEAD', 'GET', 'DELETE']);
if (!$this->permissions->canAccess($this->objectLibraryID)) {
$this->e403();
}
if ($this->isWriteMethod()) {
// Check for library write access
if (!$this->permissions->canWrite($this->objectLibraryID)) {
$this->e403("Write access denied");
}
// Make sure library hasn't been modified
$this->checkLibraryIfUnmodifiedSinceVersion(true);
Zotero_Libraries::updateVersionAndTimestamp($this->objectLibraryID);
}
$tagIDs = array();
$results = array();
$name = $this->objectName;
$fixedValues = array();
$this->libraryVersion = Zotero_Libraries::getUpdatedVersion($this->objectLibraryID);
// Set of tags matching name
if ($name && $this->subset != 'tags') {
$this->allowMethods(array('GET'));
$tagIDs = Zotero_Tags::getIDs($this->objectLibraryID, $name);
if (!$tagIDs) {
$this->e404();
}
$title = "Tags matching ‘" . $name . "’";
} else {
$this->allowMethods(array('GET', 'DELETE'));
if ($this->scopeObject) {
$this->allowMethods(array('GET'));
switch ($this->scopeObject) {
case 'collections':
$collection = Zotero_Collections::getByLibraryAndKey($this->objectLibraryID, $this->scopeObjectKey);
if (!$collection) {
$this->e404();
}
$title = "Tags in Collection ‘" . $collection->name . "’";
$counts = $collection->getTagItemCounts();
$tagIDs = array();
if ($counts) {
foreach ($counts as $tagID => $count) {
$tagIDs[] = $tagID;
$fixedValues[$tagID] = array('numItems' => $count);
}
}
break;
case 'items':
$item = Zotero_Items::getByLibraryAndKey($this->objectLibraryID, $this->scopeObjectKey);
if (!$item) {
$this->e404();
}
$title = "Tags of '" . $item->getDisplayTitle() . "'";
$tagIDs = $item->getTags(true);
break;
default:
throw new Exception("Invalid tags scope object '{$this->scopeObject}'");
}
} else {
if ($this->method == 'DELETE') {
// Filter for specific tags with "?tag=foo || bar"
$tagNames = !empty($this->queryParams['tag']) ? explode(' || ', $this->queryParams['tag']) : array();
Zotero_DB::beginTransaction();
foreach ($tagNames as $tagName) {
$tagIDs = Zotero_Tags::getIDs($this->objectLibraryID, $tagName);
foreach ($tagIDs as $tagID) {
$tag = Zotero_Tags::get($this->objectLibraryID, $tagID, true);
Zotero_Tags::delete($this->objectLibraryID, $tag->key);
}
}
Zotero_DB::commit();
$this->e204();
} else {
$title = "Tags";
$results = Zotero_Tags::search($this->objectLibraryID, $this->queryParams);
}
}
}
if ($tagIDs) {
$this->queryParams['tagIDs'] = $tagIDs;
$results = Zotero_Tags::search($this->objectLibraryID, $this->queryParams);
}
$this->generateMultiResponse($results, $title, $fixedValues);
$this->end();
}
