1443 lines
42 KiB
JavaScript
1443 lines
42 KiB
JavaScript
/*
|
|
***** BEGIN LICENSE BLOCK *****
|
|
|
|
Copyright © 2009 Center for History and New Media
|
|
George Mason University, Fairfax, Virginia, USA
|
|
http://zotero.org
|
|
|
|
This file is part of Zotero.
|
|
|
|
Zotero is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Affero General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
Zotero is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Affero General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Affero General Public License
|
|
along with Zotero. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
|
|
Based on nsChromeExtensionHandler example code by Ed Anuff at
|
|
http://kb.mozillazine.org/Dev_:_Extending_the_Chrome_Protocol
|
|
|
|
***** END LICENSE BLOCK *****
|
|
*/
|
|
|
|
const ZOTERO_SCHEME = "zotero";
|
|
const ZOTERO_PROTOCOL_CID = Components.ID("{9BC3D762-9038-486A-9D70-C997AF848A7C}");
|
|
const ZOTERO_PROTOCOL_CONTRACTID = "@mozilla.org/network/protocol;1?name=" + ZOTERO_SCHEME;
|
|
const ZOTERO_PROTOCOL_NAME = "Zotero Chrome Extension Protocol";
|
|
|
|
const Cc = Components.classes;
|
|
const Ci = Components.interfaces;
|
|
const Cr = Components.results;
|
|
|
|
Components.utils.import("resource://gre/modules/XPCOMUtils.jsm");
|
|
|
|
// Dummy chrome URL used to obtain a valid chrome channel
|
|
// This one was chosen at random and should be able to be substituted
|
|
// for any other well known chrome URL in the browser installation
|
|
const DUMMY_CHROME_URL = "chrome://mozapps/content/xpinstall/xpinstallConfirm.xul";
|
|
|
|
var Zotero = Components.classes["@zotero.org/Zotero;1"]
|
|
.getService(Components.interfaces.nsISupports)
|
|
.wrappedJSObject;
|
|
|
|
var ioService = Components.classes["@mozilla.org/network/io-service;1"]
|
|
.getService(Components.interfaces.nsIIOService);
|
|
|
|
function ZoteroProtocolHandler() {
|
|
this.wrappedJSObject = this;
|
|
this._principal = null;
|
|
this._extensions = {};
|
|
|
|
|
|
/**
|
|
* zotero://data/library/collection/ABCD1234/items?sort=itemType&direction=desc
|
|
* zotero://data/groups/12345/collection/ABCD1234/items?sort=title&direction=asc
|
|
*/
|
|
var DataExtension = {
|
|
loadAsChrome: false,
|
|
|
|
newChannel: function (uri) {
|
|
return new AsyncChannel(uri, function* () {
|
|
this.contentType = 'text/plain';
|
|
|
|
path = uri.spec.match(/zotero:\/\/[^/]+(.*)/)[1];
|
|
|
|
try {
|
|
return Zotero.Utilities.Internal.getAsyncInputStream(
|
|
Zotero.API.Data.getGenerator(path)
|
|
);
|
|
}
|
|
catch (e) {
|
|
if (e instanceof Zotero.Router.InvalidPathException) {
|
|
return "URL could not be parsed";
|
|
}
|
|
}
|
|
});
|
|
}
|
|
};
|
|
|
|
|
|
/*
|
|
* Report generation extension for Zotero protocol
|
|
*/
|
|
var ReportExtension = {
|
|
loadAsChrome: false,
|
|
|
|
newChannel: function (uri) {
|
|
return new AsyncChannel(uri, function* () {
|
|
var userLibraryID = Zotero.Libraries.userLibraryID;
|
|
|
|
var path = uri.path;
|
|
if (!path) {
|
|
return 'Invalid URL';
|
|
}
|
|
// Strip leading '/'
|
|
path = path.substr(1);
|
|
|
|
// Proxy CSS files
|
|
if (path.endsWith('.css')) {
|
|
var chromeURL = 'chrome://zotero/skin/report/' + path;
|
|
Zotero.debug(chromeURL);
|
|
var ios = Components.classes["@mozilla.org/network/io-service;1"]
|
|
.getService(Components.interfaces.nsIIOService);
|
|
let uri = ios.newURI(chromeURL, null, null);
|
|
var chromeReg = Components.classes["@mozilla.org/chrome/chrome-registry;1"]
|
|
.getService(Components.interfaces.nsIChromeRegistry);
|
|
return chromeReg.convertChromeURL(uri);
|
|
}
|
|
|
|
var params = {
|
|
objectType: 'item',
|
|
format: 'html',
|
|
sort: 'title'
|
|
};
|
|
var router = new Zotero.Router(params);
|
|
|
|
// Items within a collection or search
|
|
router.add('library/:scopeObject/:scopeObjectKey/items', function () {
|
|
params.libraryID = userLibraryID;
|
|
});
|
|
router.add('groups/:groupID/:scopeObject/:scopeObjectKey/items');
|
|
|
|
// All items
|
|
router.add('library/items/:objectKey', function () {
|
|
params.libraryID = userLibraryID;
|
|
});
|
|
router.add('groups/:groupID/items');
|
|
|
|
// Old-style URLs
|
|
router.add('collection/:id/html/report.html', function () {
|
|
params.scopeObject = 'collections';
|
|
var lkh = Zotero.Collections.parseLibraryKeyHash(params.id);
|
|
if (lkh) {
|
|
params.libraryID = lkh.libraryID || userLibraryID;
|
|
params.scopeObjectKey = lkh.key;
|
|
}
|
|
else {
|
|
params.scopeObjectID = params.id;
|
|
}
|
|
delete params.id;
|
|
});
|
|
router.add('search/:id/html/report.html', function () {
|
|
params.scopeObject = 'searches';
|
|
var lkh = Zotero.Searches.parseLibraryKeyHash(this.id);
|
|
if (lkh) {
|
|
params.libraryID = lkh.libraryID || userLibraryID;
|
|
params.scopeObjectKey = lkh.key;
|
|
}
|
|
else {
|
|
params.scopeObjectID = this.id;
|
|
}
|
|
delete params.id;
|
|
});
|
|
router.add('items/:ids/html/report.html', function () {
|
|
var ids = this.ids.split('-');
|
|
params.libraryID = ids[0].split('_')[0] || userLibraryID;
|
|
params.itemKey = ids.map(x => x.split('_')[1]);
|
|
delete params.ids;
|
|
});
|
|
|
|
var parsed = router.run(path);
|
|
if (!parsed) {
|
|
return "URL could not be parsed";
|
|
}
|
|
|
|
// TODO: support old URLs
|
|
// collection
|
|
// search
|
|
// items
|
|
// item
|
|
if (params.sort.indexOf('/') != -1) {
|
|
let parts = params.sort.split('/');
|
|
params.sort = parts[0];
|
|
params.direction = parts[1] == 'd' ? 'desc' : 'asc';
|
|
}
|
|
|
|
try {
|
|
Zotero.API.parseParams(params);
|
|
var results = yield Zotero.API.getResultsFromParams(params);
|
|
}
|
|
catch (e) {
|
|
Zotero.debug(e, 1);
|
|
return e.toString();
|
|
}
|
|
|
|
var mimeType, content = '';
|
|
var items = [];
|
|
var itemsHash = {}; // key = itemID, val = position in |items|
|
|
var searchItemIDs = new Set(); // All selected items
|
|
var searchParentIDs = new Set(); // Parents of selected child items
|
|
var searchChildIDs = new Set() // Selected chlid items
|
|
|
|
var includeAllChildItems = Zotero.Prefs.get('report.includeAllChildItems');
|
|
var combineChildItems = Zotero.Prefs.get('report.combineChildItems');
|
|
|
|
var unhandledParents = {};
|
|
for (var i=0; i<results.length; i++) {
|
|
// Don't add child items directly
|
|
// (instead mark their parents for inclusion below)
|
|
var parentItemID = results[i].parentItemID;
|
|
if (parentItemID) {
|
|
searchParentIDs.add(parentItemID);
|
|
searchChildIDs.add(results[i].id);
|
|
|
|
// Don't include all child items if any child
|
|
// items were selected
|
|
includeAllChildItems = false;
|
|
}
|
|
// If combining children or standalone note/attachment, add matching parents
|
|
else if (combineChildItems || !results[i].isRegularItem()
|
|
|| results[i].numChildren() == 0) {
|
|
itemsHash[results[i].id] = [items.length];
|
|
items.push(results[i].toJSON({ mode: 'full' }));
|
|
// Flag item as a search match
|
|
items[items.length - 1].reportSearchMatch = true;
|
|
}
|
|
else {
|
|
unhandledParents[i] = true;
|
|
}
|
|
searchItemIDs.add(results[i].id);
|
|
}
|
|
|
|
// If including all child items, add children of all matched
|
|
// parents to the child array
|
|
if (includeAllChildItems) {
|
|
for (let id of searchItemIDs) {
|
|
if (!searchChildIDs.has(id)) {
|
|
var children = [];
|
|
var item = yield Zotero.Items.getAsync(id);
|
|
if (!item.isRegularItem()) {
|
|
continue;
|
|
}
|
|
var func = function (ids) {
|
|
if (ids) {
|
|
for (var i=0; i<ids.length; i++) {
|
|
searchChildIDs.add(ids[i]);
|
|
}
|
|
}
|
|
};
|
|
func(item.getNotes());
|
|
func(item.getAttachments());
|
|
}
|
|
}
|
|
}
|
|
// If not including all children, add matching parents,
|
|
// in case they don't have any matching children below
|
|
else {
|
|
for (var i in unhandledParents) {
|
|
itemsHash[results[i].id] = [items.length];
|
|
items.push(results[i].toJSON({ mode: 'full' }));
|
|
// Flag item as a search match
|
|
items[items.length - 1].reportSearchMatch = true;
|
|
}
|
|
}
|
|
|
|
if (combineChildItems) {
|
|
// Add parents of matches if parents aren't matches themselves
|
|
for (let id of searchParentIDs) {
|
|
if (!searchItemIDs.has(id) && !itemsHash[id]) {
|
|
var item = yield Zotero.Items.getAsync(id);
|
|
itemsHash[id] = items.length;
|
|
items.push(item.toJSON({ mode: 'full' }));
|
|
}
|
|
}
|
|
|
|
// Add children to reportChildren property of parents
|
|
for (let id of searchChildIDs) {
|
|
let item = yield Zotero.Items.getAsync(id);
|
|
var parentID = item.parentID;
|
|
if (!items[itemsHash[parentID]].reportChildren) {
|
|
items[itemsHash[parentID]].reportChildren = {
|
|
notes: [],
|
|
attachments: []
|
|
};
|
|
}
|
|
if (item.isNote()) {
|
|
items[itemsHash[parentID]].reportChildren.notes.push(item.toJSON({ mode: 'full' }));
|
|
}
|
|
if (item.isAttachment()) {
|
|
items[itemsHash[parentID]].reportChildren.attachments.push(item.toJSON({ mode: 'full' }));
|
|
}
|
|
}
|
|
}
|
|
// If not combining children, add a parent/child pair
|
|
// for each matching child
|
|
else {
|
|
for (let id of searchChildIDs) {
|
|
var item = yield Zotero.Items.getAsync(id);
|
|
var parentID = item.parentID;
|
|
var parentItem = Zotero.Items.get(parentID);
|
|
|
|
if (!itemsHash[parentID]) {
|
|
// If parent is a search match and not yet added,
|
|
// add on its own
|
|
if (searchItemIDs.has(parentID)) {
|
|
itemsHash[parentID] = [items.length];
|
|
items.push(parentItem.toJSON({ mode: 'full' }));
|
|
items[items.length - 1].reportSearchMatch = true;
|
|
}
|
|
else {
|
|
itemsHash[parentID] = [];
|
|
}
|
|
}
|
|
|
|
// Now add parent and child
|
|
itemsHash[parentID].push(items.length);
|
|
items.push(parentItem.toJSON({ mode: 'full' }));
|
|
if (item.isNote()) {
|
|
items[items.length - 1].reportChildren = {
|
|
notes: [item.toJSON({ mode: 'full' })],
|
|
attachments: []
|
|
};
|
|
}
|
|
else if (item.isAttachment()) {
|
|
items[items.length - 1].reportChildren = {
|
|
notes: [],
|
|
attachments: [item.toJSON({ mode: 'full' })]
|
|
};
|
|
}
|
|
}
|
|
}
|
|
|
|
// Sort items
|
|
// TODO: restore multiple sort fields
|
|
var sorts = [{
|
|
field: params.sort,
|
|
order: params.direction != 'desc' ? 1 : -1
|
|
}];
|
|
|
|
|
|
var collation = Zotero.getLocaleCollation();
|
|
var compareFunction = function(a, b) {
|
|
var index = 0;
|
|
|
|
// Multidimensional sort
|
|
do {
|
|
// In combineChildItems, use note or attachment as item
|
|
if (!combineChildItems) {
|
|
if (a.reportChildren) {
|
|
if (a.reportChildren.notes.length) {
|
|
a = a.reportChildren.notes[0];
|
|
}
|
|
else {
|
|
a = a.reportChildren.attachments[0];
|
|
}
|
|
}
|
|
|
|
if (b.reportChildren) {
|
|
if (b.reportChildren.notes.length) {
|
|
b = b.reportChildren.notes[0];
|
|
}
|
|
else {
|
|
b = b.reportChildren.attachments[0];
|
|
}
|
|
}
|
|
}
|
|
|
|
var valA, valB;
|
|
|
|
if (sorts[index].field == 'title') {
|
|
// For notes, use content for 'title'
|
|
if (a.itemType == 'note') {
|
|
valA = a.note;
|
|
}
|
|
else {
|
|
valA = a.title;
|
|
}
|
|
|
|
if (b.itemType == 'note') {
|
|
valB = b.note;
|
|
}
|
|
else {
|
|
valB = b.title;
|
|
}
|
|
|
|
valA = Zotero.Items.getSortTitle(valA);
|
|
valB = Zotero.Items.getSortTitle(valB);
|
|
}
|
|
else if (sorts[index].field == 'date') {
|
|
var itemA = Zotero.Items.getByLibraryAndKey(params.libraryID, a.key);
|
|
var itemB = Zotero.Items.getByLibraryAndKey(params.libraryID, b.key);
|
|
valA = itemA.getField('date', true, true);
|
|
valB = itemB.getField('date', true, true);
|
|
}
|
|
// TEMP: This is an ugly hack to make creator sorting
|
|
// slightly less broken. To do this right, real creator
|
|
// sorting needs to be abstracted from itemTreeView.js.
|
|
else if (sorts[index].field == 'firstCreator') {
|
|
var itemA = Zotero.Items.getByLibraryAndKey(params.libraryID, a.key);
|
|
var itemB = Zotero.Items.getByLibraryAndKey(params.libraryID, b.key);
|
|
valA = itemA.getField('firstCreator');
|
|
valB = itemB.getField('firstCreator');
|
|
}
|
|
else {
|
|
valA = a[sorts[index].field];
|
|
valB = b[sorts[index].field];
|
|
}
|
|
|
|
// Put empty values last
|
|
if (!valA && valB) {
|
|
var cmp = 1;
|
|
}
|
|
else if (valA && !valB) {
|
|
var cmp = -1;
|
|
}
|
|
else {
|
|
var cmp = collation.compareString(0, valA, valB);
|
|
}
|
|
|
|
var result = 0;
|
|
if (cmp != 0) {
|
|
result = cmp * sorts[index].order;
|
|
}
|
|
index++;
|
|
}
|
|
while (result == 0 && sorts[index]);
|
|
|
|
return result;
|
|
};
|
|
|
|
items.sort(compareFunction);
|
|
for (var i in items) {
|
|
if (items[i].reportChildren) {
|
|
items[i].reportChildren.notes.sort(compareFunction);
|
|
items[i].reportChildren.attachments.sort(compareFunction);
|
|
}
|
|
}
|
|
|
|
// Pass off to the appropriate handler
|
|
switch (params.format) {
|
|
case 'rtf':
|
|
this.contentType = 'text/rtf';
|
|
return '';
|
|
|
|
case 'csv':
|
|
this.contentType = 'text/plain';
|
|
return '';
|
|
|
|
default:
|
|
this.contentType = 'text/html';
|
|
return Zotero.Utilities.Internal.getAsyncInputStream(
|
|
Zotero.Report.HTML.listGenerator(items, combineChildItems),
|
|
function () {
|
|
return '<span style="color: red; font-weight: bold">Error generating report</span>';
|
|
}
|
|
);
|
|
}
|
|
});
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Generate MIT SIMILE Timeline
|
|
*
|
|
* Query string key abbreviations: intervals = i
|
|
* dateType = t
|
|
* timelineDate = d
|
|
*
|
|
* interval abbreviations: day = d | month = m | year = y | decade = e | century = c | millennium = i
|
|
* dateType abbreviations: date = d | dateAdded = da | dateModified = dm
|
|
* timelineDate format: shortMonthName.day.year (year is positive for A.D. and negative for B.C.)
|
|
*
|
|
* Defaults: intervals = month, year, decade
|
|
* dateType = date
|
|
* timelineDate = today's date
|
|
*/
|
|
var TimelineExtension = {
|
|
loadAsChrome: true,
|
|
|
|
newChannel: function (uri) {
|
|
return new AsyncChannel(uri, function* () {
|
|
var userLibraryID = Zotero.Libraries.userLibraryID;
|
|
|
|
path = uri.spec.match(/zotero:\/\/[^/]+(.*)/)[1];
|
|
if (!path) {
|
|
this.contentType = 'text/html';
|
|
return 'Invalid URL';
|
|
}
|
|
|
|
var params = {};
|
|
var router = new Zotero.Router(params);
|
|
|
|
// HTML
|
|
router.add('library/:scopeObject/:scopeObjectKey', function () {
|
|
params.libraryID = userLibraryID;
|
|
params.controller = 'html';
|
|
});
|
|
router.add('groups/:groupID/:scopeObject/:scopeObjectKey', function () {
|
|
params.controller = 'html';
|
|
});
|
|
router.add('library', function () {
|
|
params.libraryID = userLibraryID;
|
|
params.controller = 'html';
|
|
});
|
|
router.add('groups/:groupID', function () {
|
|
params.controller = 'html';
|
|
});
|
|
|
|
// Data
|
|
router.add('data/library/:scopeObject/:scopeObjectKey', function () {
|
|
params.libraryID = userLibraryID;
|
|
params.controller = 'data';
|
|
});
|
|
router.add('data/groups/:groupID/:scopeObject/:scopeObjectKey', function () {
|
|
params.controller = 'data';
|
|
});
|
|
router.add('data/library', function () {
|
|
params.libraryID = userLibraryID;
|
|
params.controller = 'data';
|
|
});
|
|
router.add('data/groups/:groupID', function () {
|
|
params.controller = 'data';
|
|
});
|
|
|
|
// Old-style HTML URLs
|
|
router.add('collection/:id', function () {
|
|
params.controller = 'html';
|
|
params.scopeObject = 'collections';
|
|
var lkh = Zotero.Collections.parseLibraryKeyHash(params.id);
|
|
if (lkh) {
|
|
params.libraryID = lkh.libraryID || userLibraryID;
|
|
params.scopeObjectKey = lkh.key;
|
|
}
|
|
else {
|
|
params.scopeObjectID = params.id;
|
|
}
|
|
delete params.id;
|
|
});
|
|
router.add('search/:id', function () {
|
|
params.controller = 'html';
|
|
params.scopeObject = 'searches';
|
|
var lkh = Zotero.Searches.parseLibraryKeyHash(params.id);
|
|
if (lkh) {
|
|
params.libraryID = lkh.libraryID || userLibraryID;
|
|
params.scopeObjectKey = lkh.key;
|
|
}
|
|
else {
|
|
params.scopeObjectID = params.id;
|
|
}
|
|
delete params.id;
|
|
});
|
|
router.add('/', function () {
|
|
params.controller = 'html';
|
|
params.libraryID = userLibraryID;
|
|
});
|
|
|
|
var parsed = router.run(path);
|
|
if (!parsed) {
|
|
this.contentType = 'text/html';
|
|
return "URL could not be parsed";
|
|
}
|
|
if (params.groupID) {
|
|
params.libraryID = Zotero.Groups.getLibraryIDFromGroupID(params.groupID);
|
|
}
|
|
|
|
var intervals = params.i ? params.i : '';
|
|
var timelineDate = params.d ? params.d : '';
|
|
var dateType = params.t ? params.t : '';
|
|
|
|
// Get the collection or search object
|
|
var collection, search;
|
|
switch (params.scopeObject) {
|
|
case 'collections':
|
|
if (params.scopeObjectKey) {
|
|
collection = yield Zotero.Collections.getByLibraryAndKeyAsync(
|
|
params.libraryID, params.scopeObjectKey
|
|
);
|
|
}
|
|
else {
|
|
collection = yield Zotero.Collections.getAsync(params.scopeObjectID);
|
|
}
|
|
if (!collection) {
|
|
this.contentType = 'text/html';
|
|
return 'Invalid collection ID or key';
|
|
}
|
|
break;
|
|
|
|
case 'searches':
|
|
if (params.scopeObjectKey) {
|
|
var s = yield Zotero.Searches.getByLibraryAndKeyAsync(
|
|
params.libraryID, params.scopeObjectKey
|
|
);
|
|
}
|
|
else {
|
|
var s = yield Zotero.Searches.getAsync(params.scopeObjectID);
|
|
}
|
|
if (!s) {
|
|
return 'Invalid search ID or key';
|
|
}
|
|
|
|
// FIXME: Hack to exclude group libraries for now
|
|
var search = new Zotero.Search();
|
|
search.setScope(s);
|
|
var groups = Zotero.Groups.getAll();
|
|
for (let group of groups) {
|
|
search.addCondition('libraryID', 'isNot', group.libraryID);
|
|
}
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Create XML file
|
|
//
|
|
if (params.controller == 'data') {
|
|
switch (params.scopeObject) {
|
|
case 'collections':
|
|
var results = collection.getChildItems();
|
|
break;
|
|
|
|
case 'searches':
|
|
var ids = yield search.search();
|
|
var results = yield Zotero.Items.getAsync(ids);
|
|
break;
|
|
|
|
default:
|
|
if (params.scopeObject) {
|
|
return "Invalid scope object '" + params.scopeObject + "'";
|
|
}
|
|
|
|
let s = new Zotero.Search();
|
|
s.addCondition('libraryID', 'is', params.libraryID);
|
|
s.addCondition('noChildren', 'true');
|
|
var ids = yield s.search();
|
|
var results = yield Zotero.Items.getAsync(ids);
|
|
}
|
|
|
|
var items = [];
|
|
// Only include parent items
|
|
for (let i=0; i<results.length; i++) {
|
|
if (!results[i].parentItemID) {
|
|
items.push(results[i]);
|
|
}
|
|
}
|
|
|
|
var dateTypes = {
|
|
d: 'date',
|
|
da: 'dateAdded',
|
|
dm: 'dateModified'
|
|
};
|
|
|
|
//default dateType = date
|
|
if (!dateType || !dateTypes[dateType]) {
|
|
dateType = 'd';
|
|
}
|
|
|
|
this.contentType = 'application/xml';
|
|
return Zotero.Utilities.Internal.getAsyncInputStream(
|
|
Zotero.Timeline.generateXMLDetails(items, dateTypes[dateType])
|
|
);
|
|
}
|
|
|
|
//
|
|
// Generate main HTML page
|
|
//
|
|
content = Zotero.File.getContentsFromURL('chrome://zotero/skin/timeline/timeline.html');
|
|
this.contentType = 'text/html';
|
|
|
|
if(!timelineDate){
|
|
timelineDate=Date();
|
|
var dateParts=timelineDate.toString().split(' ');
|
|
timelineDate=dateParts[1]+'.'+dateParts[2]+'.'+dateParts[3];
|
|
}
|
|
if (!intervals || intervals.length < 3) {
|
|
intervals += "mye".substr(intervals.length);
|
|
}
|
|
|
|
var theIntervals = {
|
|
d: 'Timeline.DateTime.DAY',
|
|
m: 'Timeline.DateTime.MONTH',
|
|
y: 'Timeline.DateTime.YEAR',
|
|
e: 'Timeline.DateTime.DECADE',
|
|
c: 'Timeline.DateTime.CENTURY',
|
|
i: 'Timeline.DateTime.MILLENNIUM'
|
|
};
|
|
|
|
//sets the intervals of the timeline bands
|
|
var tempStr = '<body onload="onLoad(';
|
|
var a = (theIntervals[intervals[0]]) ? theIntervals[intervals[0]] : 'Timeline.DateTime.MONTH';
|
|
var b = (theIntervals[intervals[1]]) ? theIntervals[intervals[1]] : 'Timeline.DateTime.YEAR';
|
|
var c = (theIntervals[intervals[2]]) ? theIntervals[intervals[2]] : 'Timeline.DateTime.DECADE';
|
|
content = content.replace(tempStr, tempStr + a + ',' + b + ',' + c + ',\'' + timelineDate + '\'');
|
|
|
|
tempStr = 'document.write("<title>';
|
|
if (params.scopeObject == 'collections') {
|
|
content = content.replace(tempStr, tempStr + collection.name + ' - ');
|
|
}
|
|
else if (params.scopeObject == 'searches') {
|
|
content = content.replace(tempStr, tempStr + search.name + ' - ');
|
|
}
|
|
else {
|
|
content = content.replace(tempStr, tempStr + Zotero.getString('pane.collections.library') + ' - ');
|
|
}
|
|
|
|
tempStr = 'Timeline.loadXML("zotero://timeline/data/';
|
|
var d = '';
|
|
if (params.groupID) {
|
|
d += 'groups/' + params.groupID + '/';
|
|
}
|
|
else {
|
|
d += 'library/';
|
|
}
|
|
if (params.scopeObject) {
|
|
d += params.scopeObject + "/" + params.scopeObjectKey;
|
|
}
|
|
if (dateType) {
|
|
d += '?t=' + dateType;
|
|
}
|
|
return content.replace(tempStr, tempStr + d);
|
|
});
|
|
}
|
|
};
|
|
|
|
|
|
/*
|
|
zotero://attachment/[id]/
|
|
*/
|
|
var AttachmentExtension = {
|
|
loadAsChrome: false,
|
|
|
|
newChannel: function (uri) {
|
|
var self = this;
|
|
|
|
return new AsyncChannel(uri, function* () {
|
|
try {
|
|
var errorMsg;
|
|
var [id, fileName] = uri.path.substr(1).split('/');
|
|
|
|
if (parseInt(id) != id) {
|
|
// Proxy annotation icons
|
|
if (id.match(/^annotation.*\.(png|html|css|gif)$/)) {
|
|
var chromeURL = 'chrome://zotero/skin/' + id;
|
|
var ios = Components.classes["@mozilla.org/network/io-service;1"].
|
|
getService(Components.interfaces.nsIIOService);
|
|
let uri = ios.newURI(chromeURL, null, null);
|
|
var chromeReg = Components.classes["@mozilla.org/chrome/chrome-registry;1"]
|
|
.getService(Components.interfaces.nsIChromeRegistry);
|
|
var fileURI = chromeReg.convertChromeURL(uri);
|
|
}
|
|
else {
|
|
return self._errorChannel("Attachment id not an integer");
|
|
}
|
|
}
|
|
|
|
if (!fileURI) {
|
|
var item = yield Zotero.Items.getAsync(id);
|
|
if (!item) {
|
|
return self._errorChannel("Item not found");
|
|
}
|
|
var path = yield item.getFilePathAsync();
|
|
if (!path) {
|
|
return self._errorChannel("File not found");
|
|
}
|
|
if (fileName) {
|
|
Components.utils.import("resource://gre/modules/osfile.jsm");
|
|
path = OS.Path.join(OS.Path.dirname(path), fileName)
|
|
if (!(yield OS.File.exists(path))) {
|
|
return self._errorChannel("File not found");
|
|
}
|
|
}
|
|
}
|
|
|
|
//set originalURI so that it seems like we're serving from zotero:// protocol
|
|
//this is necessary to allow url() links to work from within css files
|
|
//otherwise they try to link to files on the file:// protocol, which is not allowed
|
|
this.originalURI = uri;
|
|
|
|
return Zotero.File.pathToFile(path);
|
|
}
|
|
catch (e) {
|
|
Zotero.debug(e);
|
|
throw (e);
|
|
}
|
|
});
|
|
},
|
|
|
|
|
|
_errorChannel: function (msg) {
|
|
this.status = Components.results.NS_ERROR_FAILURE;
|
|
this.contentType = 'text/plain';
|
|
return msg;
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* zotero://select/[type]/0_ABCD1234
|
|
* zotero://select/[type]/1234 (not consistent across synced machines)
|
|
*/
|
|
var SelectExtension = {
|
|
noContent: true,
|
|
|
|
doAction: Zotero.Promise.coroutine(function* (uri) {
|
|
var userLibraryID = Zotero.Libraries.userLibraryID;
|
|
|
|
var path = uri.path;
|
|
if (!path) {
|
|
return 'Invalid URL';
|
|
}
|
|
// Strip leading '/'
|
|
path = path.substr(1);
|
|
var mimeType, content = '';
|
|
|
|
var params = {
|
|
objectType: 'item'
|
|
};
|
|
var router = new Zotero.Router(params);
|
|
|
|
// Item within a collection or search
|
|
router.add('library/:scopeObject/:scopeObjectKey/items/:objectKey', function () {
|
|
params.libraryID = userLibraryID;
|
|
});
|
|
router.add('groups/:groupID/:scopeObject/:scopeObjectKey/items/:objectKey');
|
|
|
|
// All items
|
|
router.add('library/items/:objectKey', function () {
|
|
params.libraryID = userLibraryID;
|
|
});
|
|
router.add('groups/:groupID/items/:objectKey');
|
|
|
|
// Old-style URLs
|
|
router.add('items/:id', function () {
|
|
var lkh = Zotero.Items.parseLibraryKeyHash(params.id);
|
|
if (lkh) {
|
|
params.libraryID = lkh.libraryID || userLibraryID;
|
|
params.objectKey = lkh.key;
|
|
}
|
|
else {
|
|
params.objectID = params.id;
|
|
}
|
|
delete params.id;
|
|
});
|
|
router.run(path);
|
|
|
|
Zotero.API.parseParams(params);
|
|
var results = yield Zotero.API.getResultsFromParams(params);
|
|
|
|
if (!results.length) {
|
|
var msg = "Items not found";
|
|
Zotero.debug(msg, 2);
|
|
Components.utils.reportError(msg);
|
|
return;
|
|
}
|
|
|
|
var wm = Components.classes["@mozilla.org/appshell/window-mediator;1"]
|
|
.getService(Components.interfaces.nsIWindowMediator);
|
|
var win = wm.getMostRecentWindow("navigator:browser");
|
|
|
|
// TODO: Currently only able to select one item
|
|
return win.ZoteroPane.selectItem(results[0].id);
|
|
}),
|
|
|
|
newChannel: function (uri) {
|
|
this.doAction(uri);
|
|
}
|
|
};
|
|
|
|
/*
|
|
zotero://fullscreen
|
|
*/
|
|
var FullscreenExtension = {
|
|
loadAsChrome: false,
|
|
|
|
newChannel: function (uri) {
|
|
return new AsyncChannel(uri, function* () {
|
|
try {
|
|
var window = Components.classes["@mozilla.org/embedcomp/window-watcher;1"]
|
|
.getService(Components.interfaces.nsIWindowWatcher)
|
|
.openWindow(null, 'chrome://zotero/content/standalone/standalone.xul', '',
|
|
'chrome,centerscreen,resizable', null);
|
|
}
|
|
catch (e) {
|
|
Zotero.debug(e, 1);
|
|
throw e;
|
|
}
|
|
});
|
|
}
|
|
};
|
|
|
|
|
|
/*
|
|
zotero://debug/
|
|
*/
|
|
var DebugExtension = {
|
|
loadAsChrome: false,
|
|
|
|
newChannel: function (uri) {
|
|
return new AsyncChannel(uri, function* () {
|
|
this.contentType = "text/plain";
|
|
|
|
try {
|
|
return Zotero.Debug.get();
|
|
}
|
|
catch (e) {
|
|
Zotero.debug(e, 1);
|
|
throw e;
|
|
}
|
|
});
|
|
}
|
|
};
|
|
|
|
var ConnectorChannel = function(uri, data) {
|
|
var secMan = Components.classes["@mozilla.org/scriptsecuritymanager;1"]
|
|
.getService(Components.interfaces.nsIScriptSecurityManager);
|
|
var ioService = Components.classes["@mozilla.org/network/io-service;1"]
|
|
.getService(Components.interfaces.nsIIOService);
|
|
|
|
this.name = uri;
|
|
this.URI = ioService.newURI(uri, "UTF-8", null);
|
|
this.owner = (secMan.getCodebasePrincipal || secMan.getSimpleCodebasePrincipal)(this.URI);
|
|
this._isPending = true;
|
|
|
|
var converter = Components.classes["@mozilla.org/intl/scriptableunicodeconverter"].
|
|
createInstance(Components.interfaces.nsIScriptableUnicodeConverter);
|
|
converter.charset = "UTF-8";
|
|
this._stream = converter.convertToInputStream(data);
|
|
this.contentLength = this._stream.available();
|
|
}
|
|
|
|
ConnectorChannel.prototype.contentCharset = "UTF-8";
|
|
ConnectorChannel.prototype.contentType = "text/html";
|
|
ConnectorChannel.prototype.notificationCallbacks = null;
|
|
ConnectorChannel.prototype.securityInfo = null;
|
|
ConnectorChannel.prototype.status = 0;
|
|
ConnectorChannel.prototype.loadGroup = null;
|
|
ConnectorChannel.prototype.loadFlags = 393216;
|
|
|
|
ConnectorChannel.prototype.__defineGetter__("originalURI", function() { return this.URI });
|
|
ConnectorChannel.prototype.__defineSetter__("originalURI", function() { });
|
|
|
|
ConnectorChannel.prototype.asyncOpen = function(streamListener, context) {
|
|
if(this.loadGroup) this.loadGroup.addRequest(this, null);
|
|
streamListener.onStartRequest(this, context);
|
|
streamListener.onDataAvailable(this, context, this._stream, 0, this.contentLength);
|
|
streamListener.onStopRequest(this, context, this.status);
|
|
this._isPending = false;
|
|
if(this.loadGroup) this.loadGroup.removeRequest(this, null, 0);
|
|
}
|
|
|
|
ConnectorChannel.prototype.isPending = function() {
|
|
return this._isPending;
|
|
}
|
|
|
|
ConnectorChannel.prototype.cancel = function(status) {
|
|
this.status = status;
|
|
this._isPending = false;
|
|
if(this._stream) this._stream.close();
|
|
}
|
|
|
|
ConnectorChannel.prototype.suspend = function() {}
|
|
|
|
ConnectorChannel.prototype.resume = function() {}
|
|
|
|
ConnectorChannel.prototype.open = function() {
|
|
return this._stream;
|
|
}
|
|
|
|
ConnectorChannel.prototype.QueryInterface = function(iid) {
|
|
if (!iid.equals(Components.interfaces.nsIChannel) && !iid.equals(Components.interfaces.nsIRequest) &&
|
|
!iid.equals(Components.interfaces.nsISupports)) {
|
|
throw Components.results.NS_ERROR_NO_INTERFACE;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* zotero://connector/
|
|
*
|
|
* URI spoofing for transferring page data across boundaries
|
|
*/
|
|
var ConnectorExtension = new function() {
|
|
this.loadAsChrome = false;
|
|
|
|
this.newChannel = function(uri) {
|
|
var ioService = Components.classes["@mozilla.org/network/io-service;1"]
|
|
.getService(Components.interfaces.nsIIOService);
|
|
var secMan = Components.classes["@mozilla.org/scriptsecuritymanager;1"]
|
|
.getService(Components.interfaces.nsIScriptSecurityManager);
|
|
var Zotero = Components.classes["@zotero.org/Zotero;1"]
|
|
.getService(Components.interfaces.nsISupports)
|
|
.wrappedJSObject;
|
|
|
|
try {
|
|
var originalURI = uri.path;
|
|
originalURI = decodeURIComponent(originalURI.substr(originalURI.indexOf("/")+1));
|
|
if(!Zotero.Server.Connector.Data[originalURI]) {
|
|
return null;
|
|
} else {
|
|
return new ConnectorChannel(originalURI, Zotero.Server.Connector.Data[originalURI]);
|
|
}
|
|
} catch(e) {
|
|
Zotero.debug(e);
|
|
throw e;
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* Open a PDF at a given page (or try to)
|
|
*
|
|
* zotero://open-pdf/library/items/[itemKey]?page=[page]
|
|
* zotero://open-pdf/groups/[groupID]/items/[itemKey]?page=[page]
|
|
*
|
|
* Also supports ZotFile format:
|
|
* zotero://open-pdf/[libraryID]_[key]/[page]
|
|
*/
|
|
var OpenPDFExtension = {
|
|
noContent: true,
|
|
|
|
doAction: async function (uri) {
|
|
var userLibraryID = Zotero.Libraries.userLibraryID;
|
|
|
|
var uriPath = uri.path;
|
|
if (!uriPath) {
|
|
return 'Invalid URL';
|
|
}
|
|
// Strip leading '/'
|
|
uriPath = uriPath.substr(1);
|
|
var mimeType, content = '';
|
|
|
|
var params = {
|
|
objectType: 'item'
|
|
};
|
|
var router = new Zotero.Router(params);
|
|
|
|
// All items
|
|
router.add('library/items/:objectKey', function () {
|
|
params.libraryID = userLibraryID;
|
|
});
|
|
router.add('groups/:groupID/items/:objectKey');
|
|
|
|
// ZotFile URLs
|
|
router.add(':id/:page', function () {
|
|
var lkh = Zotero.Items.parseLibraryKeyHash(params.id);
|
|
if (!lkh) {
|
|
Zotero.warn(`Invalid URL ${url}`);
|
|
return;
|
|
}
|
|
params.libraryID = lkh.libraryID || userLibraryID;
|
|
params.objectKey = lkh.key;
|
|
delete params.id;
|
|
});
|
|
router.run(uriPath);
|
|
|
|
Zotero.API.parseParams(params);
|
|
var results = await Zotero.API.getResultsFromParams(params);
|
|
var page = params.page;
|
|
if (parseInt(page) != page) {
|
|
page = null;
|
|
}
|
|
|
|
if (!results.length) {
|
|
Zotero.warn(`No item found for ${uriPath}`);
|
|
return;
|
|
}
|
|
|
|
var item = results[0];
|
|
|
|
if (!item.isFileAttachment()) {
|
|
Zotero.warn(`Item for ${uriPath} is not a file attachment`);
|
|
return;
|
|
}
|
|
|
|
var path = await item.getFilePathAsync();
|
|
if (!path) {
|
|
Zotero.warn(`${path} not found`);
|
|
return;
|
|
}
|
|
|
|
if (!path.toLowerCase().endsWith('.pdf')
|
|
&& Zotero.MIME.sniffForMIMEType(await Zotero.File.getSample(path)) != 'application/pdf') {
|
|
Zotero.warn(`${path} is not a PDF`);
|
|
return;
|
|
}
|
|
|
|
// If no page number, just open normally
|
|
if (!page) {
|
|
let zp = Zotero.getActiveZoteroPane();
|
|
// TODO: Open pane if closed (macOS)
|
|
if (zp) {
|
|
zp.viewAttachment([item.id]);
|
|
}
|
|
return;
|
|
}
|
|
|
|
try {
|
|
var opened = Zotero.OpenPDF.openToPage(path, page);
|
|
}
|
|
catch (e) {
|
|
Zotero.logError(e);
|
|
}
|
|
// If something went wrong, just open PDF without page
|
|
if (!opened) {
|
|
let zp = Zotero.getActiveZoteroPane();
|
|
// TODO: Open pane if closed (macOS)
|
|
if (zp) {
|
|
zp.viewAttachment([item.id]);
|
|
}
|
|
return;
|
|
}
|
|
Zotero.Notifier.trigger('open', 'file', item.id);
|
|
},
|
|
|
|
|
|
newChannel: function (uri) {
|
|
this.doAction(uri);
|
|
}
|
|
};
|
|
|
|
this._extensions[ZOTERO_SCHEME + "://data"] = DataExtension;
|
|
this._extensions[ZOTERO_SCHEME + "://report"] = ReportExtension;
|
|
this._extensions[ZOTERO_SCHEME + "://timeline"] = TimelineExtension;
|
|
this._extensions[ZOTERO_SCHEME + "://attachment"] = AttachmentExtension;
|
|
this._extensions[ZOTERO_SCHEME + "://select"] = SelectExtension;
|
|
this._extensions[ZOTERO_SCHEME + "://fullscreen"] = FullscreenExtension;
|
|
this._extensions[ZOTERO_SCHEME + "://debug"] = DebugExtension;
|
|
this._extensions[ZOTERO_SCHEME + "://connector"] = ConnectorExtension;
|
|
this._extensions[ZOTERO_SCHEME + "://open-pdf"] = OpenPDFExtension;
|
|
}
|
|
|
|
|
|
/*
|
|
* Implements nsIProtocolHandler
|
|
*/
|
|
ZoteroProtocolHandler.prototype = {
|
|
scheme: ZOTERO_SCHEME,
|
|
|
|
defaultPort : -1,
|
|
|
|
protocolFlags :
|
|
Components.interfaces.nsIProtocolHandler.URI_NORELATIVE |
|
|
Components.interfaces.nsIProtocolHandler.URI_NOAUTH |
|
|
// DEBUG: This should be URI_IS_LOCAL_FILE, and MUST be if any
|
|
// extensions that modify data are added
|
|
// - https://www.zotero.org/trac/ticket/1156
|
|
//
|
|
Components.interfaces.nsIProtocolHandler.URI_IS_LOCAL_FILE,
|
|
//Components.interfaces.nsIProtocolHandler.URI_LOADABLE_BY_ANYONE,
|
|
|
|
allowPort : function(port, scheme) {
|
|
return false;
|
|
},
|
|
|
|
getExtension: function (uri) {
|
|
let uriString = uri;
|
|
if (uri instanceof Components.interfaces.nsIURI) {
|
|
uriString = uri.spec;
|
|
}
|
|
uriString = uriString.toLowerCase();
|
|
|
|
for (let extSpec in this._extensions) {
|
|
if (uriString.startsWith(extSpec)) {
|
|
return this._extensions[extSpec];
|
|
}
|
|
}
|
|
|
|
return false;
|
|
},
|
|
|
|
newURI : function(spec, charset, baseURI) {
|
|
var newURL = Components.classes["@mozilla.org/network/standard-url;1"]
|
|
.createInstance(Components.interfaces.nsIStandardURL);
|
|
newURL.init(1, -1, spec, charset, baseURI);
|
|
return newURL.QueryInterface(Components.interfaces.nsIURI);
|
|
},
|
|
|
|
newChannel : function(uri) {
|
|
var ioService = Components.classes["@mozilla.org/network/io-service;1"]
|
|
.getService(Components.interfaces.nsIIOService);
|
|
|
|
var chromeService = Components.classes["@mozilla.org/network/protocol;1?name=chrome"]
|
|
.getService(Components.interfaces.nsIProtocolHandler);
|
|
|
|
var newChannel = null;
|
|
|
|
try {
|
|
let ext = this.getExtension(uri);
|
|
|
|
if (!ext) {
|
|
// Return cancelled channel for unknown paths
|
|
//
|
|
// These can be in the form zotero://example.com/... -- maybe for "//example.com" URLs?
|
|
var chromeURI = chromeService.newURI(DUMMY_CHROME_URL, null, null);
|
|
var extChannel = chromeService.newChannel(chromeURI);
|
|
var chromeRequest = extChannel.QueryInterface(Components.interfaces.nsIRequest);
|
|
chromeRequest.cancel(0x804b0002); // BINDING_ABORTED
|
|
return extChannel;
|
|
}
|
|
|
|
if (!this._principal) {
|
|
if (ext.loadAsChrome) {
|
|
var chromeURI = chromeService.newURI(DUMMY_CHROME_URL, null, null);
|
|
var chromeChannel = chromeService.newChannel(chromeURI);
|
|
|
|
// Cache System Principal from chrome request
|
|
// so proxied pages load with chrome privileges
|
|
this._principal = chromeChannel.owner;
|
|
|
|
var chromeRequest = chromeChannel.QueryInterface(Components.interfaces.nsIRequest);
|
|
chromeRequest.cancel(0x804b0002); // BINDING_ABORTED
|
|
}
|
|
}
|
|
|
|
var extChannel = ext.newChannel(uri);
|
|
// Extension returned null, so cancel request
|
|
if (!extChannel) {
|
|
var chromeURI = chromeService.newURI(DUMMY_CHROME_URL, null, null);
|
|
var extChannel = chromeService.newChannel(chromeURI);
|
|
var chromeRequest = extChannel.QueryInterface(Components.interfaces.nsIRequest);
|
|
chromeRequest.cancel(0x804b0002); // BINDING_ABORTED
|
|
}
|
|
|
|
// Apply cached principal to extension channel
|
|
if (this._principal) {
|
|
extChannel.owner = this._principal;
|
|
}
|
|
|
|
if(!extChannel.originalURI) extChannel.originalURI = uri;
|
|
|
|
return extChannel;
|
|
}
|
|
catch (e) {
|
|
Components.utils.reportError(e);
|
|
Zotero.debug(e, 1);
|
|
throw Components.results.NS_ERROR_FAILURE;
|
|
}
|
|
|
|
return newChannel;
|
|
},
|
|
|
|
contractID: ZOTERO_PROTOCOL_CONTRACTID,
|
|
classDescription: ZOTERO_PROTOCOL_NAME,
|
|
classID: ZOTERO_PROTOCOL_CID,
|
|
QueryInterface: XPCOMUtils.generateQI([Components.interfaces.nsISupports,
|
|
Components.interfaces.nsIProtocolHandler])
|
|
};
|
|
|
|
|
|
/**
|
|
* nsIChannel implementation that takes a promise-yielding generator that returns a
|
|
* string, nsIAsyncInputStream, or file
|
|
*/
|
|
function AsyncChannel(uri, gen) {
|
|
this._generator = gen;
|
|
this._isPending = true;
|
|
|
|
// nsIRequest
|
|
this.name = uri;
|
|
this.loadFlags = 0;
|
|
this.loadGroup = null;
|
|
this.status = 0;
|
|
|
|
// nsIChannel
|
|
this.contentLength = -1;
|
|
this.contentType = "text/html";
|
|
this.contentCharset = "utf-8";
|
|
this.URI = uri;
|
|
this.originalURI = uri;
|
|
this.owner = null;
|
|
this.notificationCallbacks = null;
|
|
this.securityInfo = null;
|
|
}
|
|
|
|
AsyncChannel.prototype = {
|
|
asyncOpen: Zotero.Promise.coroutine(function* (streamListener, context) {
|
|
if (this.loadGroup) this.loadGroup.addRequest(this, null);
|
|
|
|
var channel = this;
|
|
|
|
var resolve;
|
|
var reject;
|
|
var promise = new Zotero.Promise(function () {
|
|
resolve = arguments[0];
|
|
reject = arguments[1];
|
|
});
|
|
|
|
var listenerWrapper = {
|
|
onStartRequest: function (request, context) {
|
|
//Zotero.debug("Starting request");
|
|
streamListener.onStartRequest(channel, context);
|
|
},
|
|
onDataAvailable: function (request, context, inputStream, offset, count) {
|
|
//Zotero.debug("onDataAvailable");
|
|
streamListener.onDataAvailable(channel, context, inputStream, offset, count);
|
|
},
|
|
onStopRequest: function (request, context, status) {
|
|
//Zotero.debug("Stopping request");
|
|
streamListener.onStopRequest(channel, context, status);
|
|
channel._isPending = false;
|
|
if (status == 0) {
|
|
resolve();
|
|
}
|
|
else {
|
|
reject(new Error("AsyncChannel request failed with status " + status));
|
|
}
|
|
}
|
|
};
|
|
|
|
//Zotero.debug("AsyncChannel's asyncOpen called");
|
|
var t = new Date;
|
|
|
|
// Proxy requests to other zotero:// URIs
|
|
let uri2 = this.URI.clone();
|
|
if (uri2.path.startsWith('/proxy/')) {
|
|
let re = new RegExp(uri2.scheme + '://' + uri2.host + '/proxy/([^/]+)(.*)');
|
|
let matches = uri2.spec.match(re);
|
|
uri2.spec = uri2.scheme + '://' + matches[1] + '/' + (matches[2] ? matches[2] : '');
|
|
var data = Zotero.File.getContentsFromURL(uri2.spec);
|
|
}
|
|
try {
|
|
if (!data) {
|
|
data = yield Zotero.spawn(channel._generator, channel)
|
|
}
|
|
if (typeof data == 'string') {
|
|
//Zotero.debug("AsyncChannel: Got string from generator");
|
|
|
|
listenerWrapper.onStartRequest(this, context);
|
|
|
|
let converter = Components.classes["@mozilla.org/intl/scriptableunicodeconverter"]
|
|
.createInstance(Components.interfaces.nsIScriptableUnicodeConverter);
|
|
converter.charset = "UTF-8";
|
|
let inputStream = converter.convertToInputStream(data);
|
|
listenerWrapper.onDataAvailable(this, context, inputStream, 0, inputStream.available());
|
|
|
|
listenerWrapper.onStopRequest(this, context, this.status);
|
|
}
|
|
// If an async input stream is given, pass the data asynchronously to the stream listener
|
|
else if (data instanceof Ci.nsIAsyncInputStream) {
|
|
//Zotero.debug("AsyncChannel: Got input stream from generator");
|
|
|
|
var pump = Cc["@mozilla.org/network/input-stream-pump;1"].createInstance(Ci.nsIInputStreamPump);
|
|
pump.init(data, -1, -1, 0, 0, true);
|
|
pump.asyncRead(listenerWrapper, context);
|
|
}
|
|
else if (data instanceof Ci.nsIFile || data instanceof Ci.nsIURI) {
|
|
if (data instanceof Ci.nsIFile) {
|
|
//Zotero.debug("AsyncChannel: Got file from generator");
|
|
data = ioService.newFileURI(data);
|
|
}
|
|
else {
|
|
//Zotero.debug("AsyncChannel: Got URI from generator");
|
|
}
|
|
|
|
let uri = data;
|
|
uri.QueryInterface(Ci.nsIURL);
|
|
this.contentType = Zotero.MIME.getMIMETypeFromExtension(uri.fileExtension);
|
|
if (!this.contentType) {
|
|
let sample = yield Zotero.File.getSample(data);
|
|
this.contentType = Zotero.MIME.getMIMETypeFromData(sample);
|
|
}
|
|
|
|
Components.utils.import("resource://gre/modules/NetUtil.jsm");
|
|
NetUtil.asyncFetch(data, function (inputStream, status) {
|
|
if (!Components.isSuccessCode(status)) {
|
|
reject();
|
|
return;
|
|
}
|
|
|
|
listenerWrapper.onStartRequest(channel, context);
|
|
try {
|
|
listenerWrapper.onDataAvailable(channel, context, inputStream, 0, inputStream.available());
|
|
}
|
|
catch (e) {
|
|
reject(e);
|
|
}
|
|
listenerWrapper.onStopRequest(channel, context, status);
|
|
});
|
|
}
|
|
else if (data === undefined) {
|
|
this.cancel(0x804b0002); // BINDING_ABORTED
|
|
}
|
|
else {
|
|
throw new Error("Invalid return type (" + typeof data + ") from generator passed to AsyncChannel");
|
|
}
|
|
|
|
if (this._isPending) {
|
|
//Zotero.debug("AsyncChannel request succeeded in " + (new Date - t) + " ms");
|
|
channel._isPending = false;
|
|
}
|
|
|
|
return promise;
|
|
} catch (e) {
|
|
Zotero.debug(e, 1);
|
|
if (channel._isPending) {
|
|
streamListener.onStopRequest(channel, context, Components.results.NS_ERROR_FAILURE);
|
|
channel._isPending = false;
|
|
}
|
|
throw e;
|
|
} finally {
|
|
if (channel.loadGroup) channel.loadGroup.removeRequest(channel, null, 0);
|
|
}
|
|
}),
|
|
|
|
// nsIRequest
|
|
isPending: function () {
|
|
return this._isPending;
|
|
},
|
|
|
|
cancel: function (status) {
|
|
Zotero.debug("Cancelling");
|
|
this.status = status;
|
|
this._isPending = false;
|
|
},
|
|
|
|
resume: function () {
|
|
Zotero.debug("Resuming");
|
|
},
|
|
|
|
suspend: function () {
|
|
Zotero.debug("Suspending");
|
|
},
|
|
|
|
// nsIWritablePropertyBag
|
|
setProperty: function (prop, val) {
|
|
this[prop] = val;
|
|
},
|
|
|
|
|
|
deleteProperty: function (prop) {
|
|
delete this[prop];
|
|
},
|
|
|
|
|
|
QueryInterface: function (iid) {
|
|
if (iid.equals(Components.interfaces.nsISupports)
|
|
|| iid.equals(Components.interfaces.nsIRequest)
|
|
|| iid.equals(Components.interfaces.nsIChannel)
|
|
// pdf.js wants this
|
|
|| iid.equals(Components.interfaces.nsIWritablePropertyBag)) {
|
|
return this;
|
|
}
|
|
throw Components.results.NS_ERROR_NO_INTERFACE;
|
|
}
|
|
};
|
|
|
|
|
|
var NSGetFactory = XPCOMUtils.generateNSGetFactory([ZoteroProtocolHandler]);
|