transmission/web/javascript/torrent.js

616 lines
16 KiB
JavaScript

/**
* Copyright © Mnemosyne LLC
*
* This file is licensed under the GPLv2.
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
*/
function Torrent(data) {
this.initialize(data);
};
/***
****
**** Constants
****
***/
// Torrent.fields.status
Torrent._StatusStopped = 0;
Torrent._StatusCheckWait = 1;
Torrent._StatusCheck = 2;
Torrent._StatusDownloadWait = 3;
Torrent._StatusDownload = 4;
Torrent._StatusSeedWait = 5;
Torrent._StatusSeed = 6;
// Torrent.fields.seedRatioMode
Torrent._RatioUseGlobal = 0;
Torrent._RatioUseLocal = 1;
Torrent._RatioUnlimited = 2;
// Torrent.fields.error
Torrent._ErrNone = 0;
Torrent._ErrTrackerWarning = 1;
Torrent._ErrTrackerError = 2;
Torrent._ErrLocalError = 3;
// TrackerStats' announceState
Torrent._TrackerInactive = 0;
Torrent._TrackerWaiting = 1;
Torrent._TrackerQueued = 2;
Torrent._TrackerActive = 3;
Torrent.Fields = {};
// commonly used fields which only need to be loaded once,
// either on startup or when a magnet finishes downloading its metadata
// finishes downloading its metadata
Torrent.Fields.Metadata = [
'addedDate',
'name',
'totalSize'
];
// commonly used fields which need to be periodically refreshed
Torrent.Fields.Stats = [
'error',
'errorString',
'eta',
'isFinished',
'isStalled',
'leftUntilDone',
'metadataPercentComplete',
'peersConnected',
'peersGettingFromUs',
'peersSendingToUs',
'percentDone',
'queuePosition',
'rateDownload',
'rateUpload',
'recheckProgress',
'seedRatioMode',
'seedRatioLimit',
'sizeWhenDone',
'status',
'trackers',
'downloadDir',
'uploadedEver',
'uploadRatio',
'webseedsSendingToUs'
];
// fields used by the inspector which only need to be loaded once
Torrent.Fields.InfoExtra = [
'comment',
'creator',
'dateCreated',
'files',
'hashString',
'isPrivate',
'pieceCount',
'pieceSize'
];
// fields used in the inspector which need to be periodically refreshed
Torrent.Fields.StatsExtra = [
'activityDate',
'corruptEver',
'desiredAvailable',
'downloadedEver',
'fileStats',
'haveUnchecked',
'haveValid',
'peers',
'startDate',
'trackerStats'
];
/***
****
**** Methods
****
***/
Torrent.prototype = {
initialize: function (data) {
this.fields = {};
this.fieldObservers = {};
this.refresh(data);
},
notifyOnFieldChange: function (field, callback) {
this.fieldObservers[field] = this.fieldObservers[field] || [];
this.fieldObservers[field].push(callback);
},
setField: function (o, name, value) {
var i, observer;
if (o[name] === value) {
return false;
};
if (o == this.fields && this.fieldObservers[name] && this.fieldObservers[name].length) {
for (i = 0; observer = this.fieldObservers[name][i]; ++i) {
observer.call(this, value, o[name], name);
};
};
o[name] = value;
return true;
},
// fields.files is an array of unions of RPC's "files" and "fileStats" objects.
updateFiles: function (files) {
var changed = false;
var myfiles = this.fields.files || [];
var keys = ['length', 'name', 'bytesCompleted', 'wanted', 'priority'];
var i, f, j, key, myfile;
for (i = 0; f = files[i]; ++i) {
myfile = myfiles[i] || {};
for (j = 0; key = keys[j]; ++j) {
if (key in f) {
changed |= this.setField(myfile, key, f[key]);
};
};
myfiles[i] = myfile;
}
this.fields.files = myfiles;
return changed;
},
collateTrackers: function (trackers) {
var i, t, announces = [];
for (i = 0; t = trackers[i]; ++i) {
announces.push(t.announce.toLowerCase());
};
return announces.join('\t');
},
refreshFields: function (data) {
var key;
var changed = false;
for (key in data) {
switch (key) {
case 'files':
case 'fileStats': // merge files and fileStats together
changed |= this.updateFiles(data[key]);
break;
case 'trackerStats': // 'trackerStats' is a superset of 'trackers'...
changed |= this.setField(this.fields, 'trackers', data[key]);
break;
case 'trackers': // ...so only save 'trackers' if we don't have it already
if (!(key in this.fields)) {
changed |= this.setField(this.fields, key, data[key]);
};
break;
default:
changed |= this.setField(this.fields, key, data[key]);
};
};
return changed;
},
refresh: function (data) {
if (this.refreshFields(data)) {
$(this).trigger('dataChanged', this);
};
},
/****
*****
****/
// simple accessors
getComment: function () {
return this.fields.comment;
},
getCreator: function () {
return this.fields.creator;
},
getDateAdded: function () {
return this.fields.addedDate;
},
getDateCreated: function () {
return this.fields.dateCreated;
},
getDesiredAvailable: function () {
return this.fields.desiredAvailable;
},
getDownloadDir: function () {
return this.fields.downloadDir;
},
getDownloadSpeed: function () {
return this.fields.rateDownload;
},
getDownloadedEver: function () {
return this.fields.downloadedEver;
},
getError: function () {
return this.fields.error;
},
getErrorString: function () {
return this.fields.errorString;
},
getETA: function () {
return this.fields.eta;
},
getFailedEver: function (i) {
return this.fields.corruptEver;
},
getFile: function (i) {
return this.fields.files[i];
},
getFileCount: function () {
return this.fields.files ? this.fields.files.length : 0;
},
getHashString: function () {
return this.fields.hashString;
},
getHave: function () {
return this.getHaveValid() + this.getHaveUnchecked()
},
getHaveUnchecked: function () {
return this.fields.haveUnchecked;
},
getHaveValid: function () {
return this.fields.haveValid;
},
getId: function () {
return this.fields.id;
},
getLastActivity: function () {
return this.fields.activityDate;
},
getLeftUntilDone: function () {
return this.fields.leftUntilDone;
},
getMetadataPercentComplete: function () {
return this.fields.metadataPercentComplete;
},
getName: function () {
return this.fields.name || 'Unknown';
},
getPeers: function () {
return this.fields.peers;
},
getPeersConnected: function () {
return this.fields.peersConnected;
},
getPeersGettingFromUs: function () {
return this.fields.peersGettingFromUs;
},
getPeersSendingToUs: function () {
return this.fields.peersSendingToUs;
},
getPieceCount: function () {
return this.fields.pieceCount;
},
getPieceSize: function () {
return this.fields.pieceSize;
},
getPrivateFlag: function () {
return this.fields.isPrivate;
},
getQueuePosition: function () {
return this.fields.queuePosition;
},
getRecheckProgress: function () {
return this.fields.recheckProgress;
},
getSeedRatioLimit: function () {
return this.fields.seedRatioLimit;
},
getSeedRatioMode: function () {
return this.fields.seedRatioMode;
},
getSizeWhenDone: function () {
return this.fields.sizeWhenDone;
},
getStartDate: function () {
return this.fields.startDate;
},
getStatus: function () {
return this.fields.status;
},
getTotalSize: function () {
return this.fields.totalSize;
},
getTrackers: function () {
return this.fields.trackers;
},
getUploadSpeed: function () {
return this.fields.rateUpload;
},
getUploadRatio: function () {
return this.fields.uploadRatio;
},
getUploadedEver: function () {
return this.fields.uploadedEver;
},
getWebseedsSendingToUs: function () {
return this.fields.webseedsSendingToUs;
},
isFinished: function () {
return this.fields.isFinished;
},
// derived accessors
hasExtraInfo: function () {
return 'hashString' in this.fields;
},
isSeeding: function () {
return this.getStatus() === Torrent._StatusSeed;
},
isStopped: function () {
return this.getStatus() === Torrent._StatusStopped;
},
isChecking: function () {
return this.getStatus() === Torrent._StatusCheck;
},
isDownloading: function () {
return this.getStatus() === Torrent._StatusDownload;
},
isQueued: function () {
return this.getStatus() === Torrent._StatusDownloadWait || this.getStatus() === Torrent._StatusSeedWait;
},
isDone: function () {
return this.getLeftUntilDone() < 1;
},
needsMetaData: function () {
return this.getMetadataPercentComplete() < 1;
},
getActivity: function () {
return this.getDownloadSpeed() + this.getUploadSpeed();
},
getPercentDoneStr: function () {
return Transmission.fmt.percentString(100 * this.getPercentDone());
},
getPercentDone: function () {
return this.fields.percentDone;
},
getStateString: function () {
switch (this.getStatus()) {
case Torrent._StatusStopped:
return this.isFinished() ? 'Seeding complete' : 'Paused';
case Torrent._StatusCheckWait:
return 'Queued for verification';
case Torrent._StatusCheck:
return 'Verifying local data';
case Torrent._StatusDownloadWait:
return 'Queued for download';
case Torrent._StatusDownload:
return 'Downloading';
case Torrent._StatusSeedWait:
return 'Queued for seeding';
case Torrent._StatusSeed:
return 'Seeding';
case null:
case undefined:
return 'Unknown';
default:
return 'Error';
}
},
seedRatioLimit: function (controller) {
switch (this.getSeedRatioMode()) {
case Torrent._RatioUseGlobal:
return controller.seedRatioLimit();
case Torrent._RatioUseLocal:
return this.getSeedRatioLimit();
default:
return -1;
}
},
getErrorMessage: function () {
var str = this.getErrorString();
switch (this.getError()) {
case Torrent._ErrTrackerWarning:
return 'Tracker returned a warning: ' + str;
case Torrent._ErrTrackerError:
return 'Tracker returned an error: ' + str;
case Torrent._ErrLocalError:
return 'Error: ' + str;
default:
return null;
}
},
getCollatedName: function () {
var f = this.fields;
if (!f.collatedName && f.name) {
f.collatedName = f.name.toLowerCase();
};
return f.collatedName || '';
},
getCollatedTrackers: function () {
var f = this.fields;
if (!f.collatedTrackers && f.trackers) {
f.collatedTrackers = this.collateTrackers(f.trackers);
};
return f.collatedTrackers || '';
},
/****
*****
****/
testState: function (state) {
var s = this.getStatus();
switch (state) {
case Prefs._FilterActive:
return this.getPeersGettingFromUs() > 0 || this.getPeersSendingToUs() > 0 || this.getWebseedsSendingToUs() > 0 || this.isChecking();
case Prefs._FilterSeeding:
return (s === Torrent._StatusSeed) || (s === Torrent._StatusSeedWait);
case Prefs._FilterDownloading:
return (s === Torrent._StatusDownload) || (s === Torrent._StatusDownloadWait);
case Prefs._FilterPaused:
return this.isStopped();
case Prefs._FilterFinished:
return this.isFinished();
default:
return true;
}
},
/**
* @param filter one of Prefs._Filter*
* @param search substring to look for, or null
* @return true if it passes the test, false if it fails
*/
test: function (state, search, tracker) {
// flter by state...
var pass = this.testState(state);
// maybe filter by text...
if (pass && search && search.length) {
pass = this.getCollatedName().indexOf(search.toLowerCase()) !== -1;
};
// maybe filter by tracker...
if (pass && tracker && tracker.length) {
pass = this.getCollatedTrackers().indexOf(tracker) !== -1;
};
return pass;
}
};
/***
****
**** SORTING
****
***/
Torrent.compareById = function (ta, tb) {
return ta.getId() - tb.getId();
};
Torrent.compareByName = function (ta, tb) {
return ta.getCollatedName().localeCompare(tb.getCollatedName()) || Torrent.compareById(ta, tb);
};
Torrent.compareByQueue = function (ta, tb) {
return ta.getQueuePosition() - tb.getQueuePosition();
};
Torrent.compareByAge = function (ta, tb) {
var a = ta.getDateAdded();
var b = tb.getDateAdded();
return (b - a) || Torrent.compareByQueue(ta, tb);
};
Torrent.compareByState = function (ta, tb) {
var a = ta.getStatus();
var b = tb.getStatus();
return (b - a) || Torrent.compareByQueue(ta, tb);
};
Torrent.compareByActivity = function (ta, tb) {
var a = ta.getActivity();
var b = tb.getActivity();
return (b - a) || Torrent.compareByState(ta, tb);
};
Torrent.compareByRatio = function (ta, tb) {
var a = ta.getUploadRatio();
var b = tb.getUploadRatio();
if (a < b) {
return 1;
};
if (a > b) {
return -1;
};
return Torrent.compareByState(ta, tb);
};
Torrent.compareByProgress = function (ta, tb) {
var a = ta.getPercentDone();
var b = tb.getPercentDone();
return (a - b) || Torrent.compareByRatio(ta, tb);
};
Torrent.compareBySize = function (ta, tb) {
var a = ta.getTotalSize();
var b = tb.getTotalSize();
return (a - b) || Torrent.compareByName(ta, tb);
};
Torrent.compareTorrents = function (a, b, sortMethod, sortDirection) {
var i;
switch (sortMethod) {
case Prefs._SortByActivity:
i = Torrent.compareByActivity(a, b);
break;
case Prefs._SortByAge:
i = Torrent.compareByAge(a, b);
break;
case Prefs._SortByQueue:
i = Torrent.compareByQueue(a, b);
break;
case Prefs._SortByProgress:
i = Torrent.compareByProgress(a, b);
break;
case Prefs._SortBySize:
i = Torrent.compareBySize(a, b);
break;
case Prefs._SortByState:
i = Torrent.compareByState(a, b);
break;
case Prefs._SortByRatio:
i = Torrent.compareByRatio(a, b);
break;
default:
i = Torrent.compareByName(a, b);
break;
};
if (sortDirection === Prefs._SortDescending) {
i = -i;
};
return i;
};
/**
* @param torrents an array of Torrent objects
* @param sortMethod one of Prefs._SortBy*
* @param sortDirection Prefs._SortAscending or Prefs._SortDescending
*/
Torrent.sortTorrents = function (torrents, sortMethod, sortDirection) {
switch (sortMethod) {
case Prefs._SortByActivity:
torrents.sort(this.compareByActivity);
break;
case Prefs._SortByAge:
torrents.sort(this.compareByAge);
break;
case Prefs._SortByQueue:
torrents.sort(this.compareByQueue);
break;
case Prefs._SortByProgress:
torrents.sort(this.compareByProgress);
break;
case Prefs._SortBySize:
torrents.sort(this.compareBySize);
break;
case Prefs._SortByState:
torrents.sort(this.compareByState);
break;
case Prefs._SortByRatio:
torrents.sort(this.compareByRatio);
break;
default:
torrents.sort(this.compareByName);
break;
};
if (sortDirection === Prefs._SortDescending) {
torrents.reverse();
};
return torrents;
};