transmission/web/javascript/torrent.js

412 lines
13 KiB
JavaScript
Raw Normal View History

/*
* Copyright © Dave Perrett and Malcolm Jarvis
* This code is licensed under the GPL version 2.
* For details, see http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
*
* Class Torrent
*/
function Torrent( controller, data) {
this.initialize( controller, data);
}
// Constants
Torrent._StatusStopped = 0; /* torrent is stopped */
Torrent._StatusCheckWait = 1; /* waiting in queue to check files */
Torrent._StatusCheck = 2; /* checking files */
Torrent._StatusDownloadWait = 3; /* queued to download */
Torrent._StatusDownload = 4; /* downloading */
Torrent._StatusSeedWait = 5; /* queeud to seed */
Torrent._StatusSeed = 6; /* seeding */
Torrent._InfiniteTimeRemaining = 215784000; // 999 Hours - may as well be infinite
Torrent._RatioUseGlobal = 0;
Torrent._RatioUseLocal = 1;
Torrent._RatioUnlimited = 2;
Torrent._ErrNone = 0;
Torrent._ErrTrackerWarning = 1;
Torrent._ErrTrackerError = 2;
Torrent._ErrLocalError = 3;
Torrent._TrackerInactive = 0;
Torrent._TrackerWaiting = 1;
Torrent._TrackerQueued = 2;
Torrent._TrackerActive = 3;
Torrent._StaticFields = [ 'hashString', 'id' ]
Torrent._MetaDataFields = [ 'addedDate', 'comment', 'creator', 'dateCreated',
'isPrivate', 'name', 'totalSize', 'pieceCount', 'pieceSize' ]
Torrent._DynamicFields = [ 'downloadedEver', 'error', 'errorString', 'eta',
'haveUnchecked', 'haveValid', 'leftUntilDone', 'metadataPercentComplete',
'peers', 'peersConnected', 'peersGettingFromUs', 'peersSendingToUs',
'queuePosition', 'rateDownload', 'rateUpload', 'recheckProgress',
'sizeWhenDone', 'status', 'trackerStats', 'desiredAvailable',
'uploadedEver', 'uploadRatio', 'seedRatioLimit', 'seedRatioMode',
'downloadDir', 'isFinished' ]
Torrent.prototype =
{
initMetaData: function( data ) {
this._date = data.addedDate;
this._comment = data.comment;
this._creator = data.creator;
this._creator_date = data.dateCreated;
this._is_private = data.isPrivate;
this._name = data.name;
this._name_lc = this._name.toLowerCase( );
this._size = data.totalSize;
this._pieceCount = data.pieceCount;
this._pieceSize = data.pieceSize;
if( data.files ) {
for( var i=0, row; row=data.files[i]; ++i ) {
this._file_model[i] = {
'index': i,
'torrent': this,
'length': row.length,
'name': row.name
};
}
}
},
/*
* Constructor
*/
initialize: function( controller, data) {
2009-05-22 22:45:09 +00:00
this._id = data.id;
this._hashString = data.hashString;
this._sizeWhenDone = data.sizeWhenDone;
this._trackerStats = this.buildTrackerStats(data.trackerStats);
this._file_model = [ ];
this.initMetaData( data );
2009-05-22 22:45:09 +00:00
// Update all the labels etc
this.refresh(data);
},
2010-06-21 13:14:33 +00:00
buildTrackerStats: function(trackerStats) {
result = [];
for( var i=0, tracker; tracker=trackerStats[i]; ++i ) {
tier = result[tracker.tier] || [];
tier[tier.length] = {
'host': tracker.host,
'announce': tracker.announce,
'hasAnnounced': tracker.hasAnnounced,
'lastAnnounceTime': tracker.lastAnnounceTime,
'lastAnnounceSucceeded': tracker.lastAnnounceSucceeded,
'lastAnnounceResult': tracker.lastAnnounceResult,
'lastAnnouncePeerCount': tracker.lastAnnouncePeerCount,
'announceState': tracker.announceState,
'nextAnnounceTime': tracker.nextAnnounceTime,
'isBackup': tracker.isBackup,
'hasScraped': tracker.hasScraped,
'lastScrapeTime': tracker.lastScrapeTime,
'lastScrapeSucceeded': tracker.lastScrapeSucceeded,
'lastScrapeResult': tracker.lastScrapeResult,
'seederCount': tracker.seederCount,
'leecherCount': tracker.leecherCount,
'downloadCount': tracker.downloadCount
};
result[tracker.tier] = tier;
}
return result;
},
/*--------------------------------------------
*
* S E T T E R S / G E T T E R S
*
*--------------------------------------------*/
2010-06-21 13:14:33 +00:00
activity: function() { return this.downloadSpeed() + this.uploadSpeed(); },
comment: function() { return this._comment; },
completed: function() { return this._completed; },
creator: function() { return this._creator; },
dateAdded: function() { return this._date; },
downloadSpeed: function() { return this._download_speed; },
downloadTotal: function() { return this._download_total; },
hash: function() { return this._hashString; },
id: function() { return this._id; },
2010-06-17 04:38:03 +00:00
isActiveFilter: function() { return this.peersGettingFromUs() > 0
|| this.peersSendingToUs() > 0
|| this.webseedsSendingToUs() > 0
|| this.state() == Torrent._StatusCheck; },
isStopped: function() { return this.state() === Torrent._StatusStopped; },
isActive: function() { return this.state() != Torrent._StatusStopped; },
isDownloading: function() { return this.state() == Torrent._StatusDownload; },
isFinished: function() { return this._isFinishedSeeding; },
isDone: function() { return this._leftUntilDone < 1; },
isSeeding: function() { return this.state() == Torrent._StatusSeed; },
name: function() { return this._name; },
queuePosition: function() { return this._queue_position; },
webseedsSendingToUs: function() { return this._webseeds_sending_to_us; },
peersSendingToUs: function() { return this._peers_sending_to_us; },
peersGettingFromUs: function() { return this._peers_getting_from_us; },
needsMetaData: function(){ return this._metadataPercentComplete < 1 },
getPercentDone: function() {
if( !this._sizeWhenDone ) return 1.0;
if( !this._leftUntilDone ) return 1.0;
return ( this._sizeWhenDone - this._leftUntilDone ) / this._sizeWhenDone;
},
getPercentDoneStr: function() {
return Transmission.fmt.percentString( 100 * this.getPercentDone() );
},
size: function() { return this._size; },
state: function() { return this._state; },
stateStr: function() {
switch( this.state() ) {
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';
default: return 'error';
}
},
trackerStats: function() { return this._trackerStats; },
uploadSpeed: function() { return this._upload_speed; },
uploadTotal: function() { return this._upload_total; },
seedRatioLimit: function(controller){
switch( this._seed_ratio_mode ) {
case Torrent._RatioUseGlobal: return controller.seedRatioLimit();
case Torrent._RatioUseLocal: return this._seed_ratio_limit;
default: return -1;
}
},
getErrorMessage: function() {
if( this._error == Torrent._ErrTrackerWarning )
return 'Tracker returned a warning: ' + this._error_string;
if( this._error == Torrent._ErrTrackerError )
return 'Tracker returned an error: ' + this._error_string;
if( this._error == Torrent._ErrLocalError )
return 'Error: ' + this._error_string;
return null;
},
2010-06-21 13:14:33 +00:00
2009-05-25 13:31:03 +00:00
/*--------------------------------------------
*
* I N T E R F A C E F U N C T I O N S
*
2009-05-25 13:31:03 +00:00
*--------------------------------------------*/
2010-06-21 13:14:33 +00:00
fireDataChanged: function()
2009-05-25 13:31:03 +00:00
{
$(this).trigger('dataChanged',[]);
2009-05-25 13:31:03 +00:00
},
refreshMetaData: function(data)
2009-05-25 13:31:03 +00:00
{
this.initMetaData( data );
this.fireDataChanged();
},
2010-06-21 13:14:33 +00:00
refresh: function(data)
{
if( this.needsMetaData() && ( data.metadataPercentComplete >= 1 ) )
transmission.refreshMetaData( [ this._id ] );
this._completed = data.haveUnchecked + data.haveValid;
this._verified = data.haveValid;
this._leftUntilDone = data.leftUntilDone;
this._download_total = data.downloadedEver;
this._upload_total = data.uploadedEver;
this._upload_ratio = data.uploadRatio;
this._seed_ratio_limit = data.seedRatioLimit;
this._seed_ratio_mode = data.seedRatioMode;
this._download_speed = data.rateDownload;
this._upload_speed = data.rateUpload;
2010-06-17 04:40:06 +00:00
this._peers = data.peers;
this._peers_connected = data.peersConnected;
this._peers_getting_from_us = data.peersGettingFromUs;
this._peers_sending_to_us = data.peersSendingToUs;
this._queue_position = data.queuePosition;
this._webseeds_sending_to_us = data.webseedsSendingToUs;
this._sizeWhenDone = data.sizeWhenDone;
this._recheckProgress = data.recheckProgress;
this._error = data.error;
this._error_string = data.errorString;
this._eta = data.eta;
this._trackerStats = this.buildTrackerStats(data.trackerStats);
this._state = data.status;
this._download_dir = data.downloadDir;
this._metadataPercentComplete = data.metadataPercentComplete;
this._isFinishedSeeding = data.isFinished;
this._desiredAvailable = data.desiredAvailable;
if (data.fileStats)
this.refreshFileModel( data );
this.fireDataChanged();
},
refreshFileModel: function(data) {
for( var i=0; i<data.fileStats.length; ++i ) {
var src = data.fileStats[i];
var tgt = this._file_model[i];
if( !tgt )
tgt = this._file_model[i] = { };
tgt.wanted = src.wanted;
tgt.priority = src.priority;
tgt.bytesCompleted = src.bytesCompleted;
2009-05-22 22:45:09 +00:00
}
},
/**
* @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( filter, search )
{
var pass = false;
var s = this.state( );
2010-06-21 13:14:33 +00:00
switch( filter )
{
2010-06-17 04:38:03 +00:00
case Prefs._FilterActive:
pass = this.isActiveFilter();
break;
case Prefs._FilterSeeding:
pass = ( s == Torrent._StatusSeed ) || ( s == Torrent._StatusSeedWait );
break;
case Prefs._FilterDownloading:
pass = ( s == Torrent._StatusDownload ) || ( s == Torrent._StatusDownloadWait );
break;
case Prefs._FilterPaused:
pass = !this.isActive();
break;
case Prefs._FilterFinished:
pass = this.isFinished();
break;
default:
pass = true;
break;
}
2010-06-21 13:14:33 +00:00
if( !pass )
return false;
2010-06-21 13:14:33 +00:00
if( !search || !search.length )
return pass;
2010-06-21 13:14:33 +00:00
return this._name_lc.indexOf( search.toLowerCase() ) !== -1;
}
};
/** Helper function for Torrent.sortTorrents(). */
Torrent.compareById = function( a, b ) {
return a.id() - b.id();
};
/** Helper function for sortTorrents(). */
Torrent.compareByName = function( a, b ) {
var i = a._name_lc.compareTo( b._name_lc );
if( i )
return i;
return Torrent.compareById( a, b );
};
/** Helper function for sortTorrents(). */
Torrent.compareByQueue = function( a, b )
{
return a.queuePosition( ) - b.queuePosition();
};
/** Helper function for sortTorrents(). */
Torrent.compareByAge = function( a, b )
{
var a_age = a.dateAdded();
var b_age = b.dateAdded();
if( a_age != b_age )
return a_age - b_age;
return Torrent.compareByQueue( a, b );
};
/** Helper function for sortTorrents(). */
Torrent.compareByState = function( a, b )
{
var a_state = a.state( );
var b_state = b.state( );
if( a_state != b_state )
return b_state - a_state;
return Torrent.compareByQueue( a, b );
};
/** Helper function for sortTorrents(). */
Torrent.compareByActivity = function( a, b )
{
var a_activity = a.activity( );
var b_activity = b.activity( );
if( a_activity != b_activity )
return a_activity - b_activity;
return Torrent.compareByState( a, b );
};
/** Helper function for sortTorrents(). */
Torrent.compareByRatio = function( a, b ) {
var a_ratio = Math.ratio( a._upload_total, a._download_total );
var b_ratio = Math.ratio( b._upload_total, b._download_total );
if( a_ratio != b_ratio )
return a_ratio - b_ratio;
return Torrent.compareByState( a, b );
};
Torrent.compareByProgress = function( a, b ) {
if( a.getPercentDone() !== b.getPercentDone() )
return a.getPercentDone() - b.getPercentDone();
return Torrent.compareByRatio( a, b );
};
/**
* @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._SortByState:
torrents.sort( this.compareByState );
break;
case Prefs._SortByName:
torrents.sort( this.compareByName );
break;
case Prefs._SortByRatio:
torrents.sort( this.compareByRatio );
break;
default:
console.warn( "unknown sort method: " + sortMethod );
break;
}
2010-06-21 13:14:33 +00:00
if( sortDirection === Prefs._SortDescending )
torrents.reverse( );
2010-06-21 13:14:33 +00:00
return torrents;
};