services/mp3tunes/Mp3tunesWorkers.cpp

0001 /****************************************************************************************
0002  * Copyright (c) 2007,2008 Casey Link <unnamedrambler@gmail.com>                        *
0003  *                                                                                      *
0004  * This program is free software; you can redistribute it and/or modify it under        *
0005  * the terms of the GNU General Public License as published by the Free Software        *
0006  * Foundation; either version 2 of the License, or (at your option) any later           *
0007  * version.                                                                             *
0008  *                                                                                      *
0009  * This program is distributed in the hope that it will be useful, but WITHOUT ANY      *
0010  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A      *
0011  * PARTICULAR PURPOSE. See the GNU General Public License for more details.             *
0012  *                                                                                      *
0013  * You should have received a copy of the GNU General Public License along with         *
0014  * this program.  If not, see <http://www.gnu.org/licenses/>.                           *
0015  ****************************************************************************************/
0016
0017 #include "Mp3tunesWorkers.h"
0018
0019 #include "core/logger/Logger.h"
0020 #include "core/support/Components.h"
0021 #include "core/support/Debug.h"
0022 #include "Mp3tunesMeta.h"
0023
0024 #include <KLocalizedString>
0025 #include <QStringList>
0026
0027 Mp3tunesLoginWorker::Mp3tunesLoginWorker( Mp3tunesLocker* locker,
0028                                           const QString & username,
0029                                           const QString & password )
0030     : QObject()
0031     , ThreadWeaver::Job()
0032     , m_locker( locker )
0033     , m_sessionId()
0034     , m_username( username )
0035     , m_password( password )
0036 {
0037     connect( this, &Mp3tunesLoginWorker::done, this, &Mp3tunesLoginWorker::completeJob );
0038 }
0039
0040 Mp3tunesLoginWorker::~Mp3tunesLoginWorker()
0041 {
0042 }
0043
0044 void Mp3tunesLoginWorker::run(ThreadWeaver::JobPointer self, ThreadWeaver::Thread *thread)
0045 {
0046     Q_UNUSED(self);
0047     Q_UNUSED(thread);
0048     DEBUG_BLOCK
0049     if(m_locker != 0) {
0050         debug() << "Calling Locker login..";
0051         m_sessionId = m_locker->login(m_username, m_password);
0052         debug() << "Login Complete. SessionId = " << m_sessionId;
0053     } else {
0054         debug() << "Locker is NULL";
0055     }
0056 }
0057 void Mp3tunesLoginWorker::defaultBegin(const ThreadWeaver::JobPointer& self, ThreadWeaver::Thread *thread)
0058 {
0059     Q_EMIT started(self);
0060     ThreadWeaver::Job::defaultBegin(self, thread);
0061 }
0062
0063 void Mp3tunesLoginWorker::defaultEnd(const ThreadWeaver::JobPointer& self, ThreadWeaver::Thread *thread)
0064 {
0065     ThreadWeaver::Job::defaultEnd(self, thread);
0066     if (!self->success()) {
0067         Q_EMIT failed(self);
0068     }
0069     Q_EMIT done(self);
0070 }
0071
0072 void Mp3tunesLoginWorker::completeJob()
0073 {
0074     DEBUG_BLOCK
0075     debug() << "Login Job complete";
0076     emit( finishedLogin( m_sessionId ) );
0077     deleteLater();
0078 }
0079 /* ARTIST FETCHER */
0080 Mp3tunesArtistFetcher::Mp3tunesArtistFetcher( Mp3tunesLocker * locker )
0081 {
0082     connect( this, &Mp3tunesArtistFetcher::done, this, &Mp3tunesArtistFetcher::completeJob );
0083     m_locker = locker;
0084 }
0085
0086 Mp3tunesArtistFetcher::~Mp3tunesArtistFetcher()
0087 {
0088 }
0089
0090 void Mp3tunesArtistFetcher::run(ThreadWeaver::JobPointer self, ThreadWeaver::Thread *thread)
0091 {
0092     Q_UNUSED(self);
0093     Q_UNUSED(thread);
0094     DEBUG_BLOCK
0095     if(m_locker != 0) {
0096         debug() << "Artist Fetch Start";
0097         QList<Mp3tunesLockerArtist> list = m_locker->artists();
0098         debug() << "Artist Fetch End. Total artists: " << list.count();
0099         m_artists = list;
0100     } else {
0101         debug() << "Locker is NULL";
0102     }
0103 }
0104
0105 void Mp3tunesArtistFetcher::completeJob()
0106 {
0107     emit( artistsFetched( m_artists ) );
0108     deleteLater();
0109 }
0110
0111 void Mp3tunesArtistFetcher::defaultBegin(const ThreadWeaver::JobPointer& self, ThreadWeaver::Thread *thread)
0112 {
0113     Q_EMIT started(self);
0114     ThreadWeaver::Job::defaultBegin(self, thread);
0115 }
0116
0117 void Mp3tunesArtistFetcher::defaultEnd(const ThreadWeaver::JobPointer& self, ThreadWeaver::Thread *thread)
0118 {
0119     ThreadWeaver::Job::defaultEnd(self, thread);
0120     if (!self->success()) {
0121         Q_EMIT failed(self);
0122     }
0123     Q_EMIT done(self);
0124 }
0125
0126 /*  ALBUM w/ Artist Id FETCHER */
0127 Mp3tunesAlbumWithArtistIdFetcher::Mp3tunesAlbumWithArtistIdFetcher( Mp3tunesLocker * locker, int artistId )
0128 {
0129     connect( this, &Mp3tunesAlbumWithArtistIdFetcher::done, this, &Mp3tunesAlbumWithArtistIdFetcher::completeJob );
0130     m_locker = locker;
0131     m_artistId = artistId;
0132 }
0133
0134 Mp3tunesAlbumWithArtistIdFetcher::~Mp3tunesAlbumWithArtistIdFetcher()
0135 {
0136 }
0137
0138 void Mp3tunesAlbumWithArtistIdFetcher::run(ThreadWeaver::JobPointer self, ThreadWeaver::Thread *thread)
0139 {
0140     Q_UNUSED(self);
0141     Q_UNUSED(thread);
0142
0143     DEBUG_BLOCK
0144     if(m_locker != 0) {
0145         debug() << "Album Fetch Start";
0146         QList<Mp3tunesLockerAlbum> list = m_locker->albumsWithArtistId( m_artistId );
0147         debug() << "Album Fetch End. Total albums: " << list.count();
0148         m_albums = list;
0149     } else {
0150                 debug() << "Locker is NULL";
0151     }
0152 }
0153
0154 void Mp3tunesAlbumWithArtistIdFetcher::completeJob()
0155 {
0156     emit( albumsFetched( m_albums ) );
0157     deleteLater();
0158 }
0159
0160 void Mp3tunesAlbumWithArtistIdFetcher::defaultBegin(const ThreadWeaver::JobPointer& self, ThreadWeaver::Thread *thread)
0161 {
0162     Q_EMIT started(self);
0163     ThreadWeaver::Job::defaultBegin(self, thread);
0164 }
0165
0166 void Mp3tunesAlbumWithArtistIdFetcher::defaultEnd(const ThreadWeaver::JobPointer& self, ThreadWeaver::Thread *thread)
0167 {
0168     ThreadWeaver::Job::defaultEnd(self, thread);
0169     if (!self->success()) {
0170         Q_EMIT failed(self);
0171     }
0172     Q_EMIT done(self);
0173 }
0174
0175 /*  TRACK w/ albumId FETCHER */
0176 Mp3tunesTrackWithAlbumIdFetcher::Mp3tunesTrackWithAlbumIdFetcher( Mp3tunesLocker * locker, int albumId )
0177 {
0178     DEBUG_BLOCK
0179     connect( this, &Mp3tunesTrackWithAlbumIdFetcher::done, this, &Mp3tunesTrackWithAlbumIdFetcher::completeJob );
0180     m_locker = locker;
0181     debug() << "Constructor albumId: " << albumId;
0182     m_albumId = albumId;
0183 }
0184
0185 Mp3tunesTrackWithAlbumIdFetcher::~Mp3tunesTrackWithAlbumIdFetcher()
0186 {
0187 }
0188
0189 void Mp3tunesTrackWithAlbumIdFetcher::run(ThreadWeaver::JobPointer self, ThreadWeaver::Thread *thread)
0190 {
0191     Q_UNUSED(self);
0192     Q_UNUSED(thread);
0193
0194     DEBUG_BLOCK
0195     if(m_locker != 0) {
0196         debug() << "Track Fetch Start for album " << m_albumId;
0197         QList<Mp3tunesLockerTrack> list = m_locker->tracksWithAlbumId( m_albumId );
0198         debug() << "Track Fetch End. Total tracks: " << list.count();
0199         m_tracks = list;
0200     } else {
0201             debug() << "Locker is NULL";
0202     }
0203 }
0204
0205 void Mp3tunesTrackWithAlbumIdFetcher::completeJob()
0206 {
0207     DEBUG_BLOCK
0208     emit( tracksFetched( m_tracks ) );
0209     deleteLater();
0210 }
0211
0212 void Mp3tunesTrackWithAlbumIdFetcher::defaultBegin(const ThreadWeaver::JobPointer& self, ThreadWeaver::Thread *thread)
0213 {
0214     Q_EMIT started(self);
0215     ThreadWeaver::Job::defaultBegin(self, thread);
0216 }
0217
0218 void Mp3tunesTrackWithAlbumIdFetcher::defaultEnd(const ThreadWeaver::JobPointer& self, ThreadWeaver::Thread *thread)
0219 {
0220     ThreadWeaver::Job::defaultEnd(self, thread);
0221     if (!self->success()) {
0222         Q_EMIT failed(self);
0223     }
0224     Q_EMIT done(self);
0225 }
0226
0227 /*  TRACK w/ artistId FETCHER */
0228 Mp3tunesTrackWithArtistIdFetcher::Mp3tunesTrackWithArtistIdFetcher( Mp3tunesLocker * locker, int artistId )
0229 {
0230     DEBUG_BLOCK
0231     connect( this, &Mp3tunesTrackWithArtistIdFetcher::done, this, &Mp3tunesTrackWithArtistIdFetcher::completeJob );
0232     m_locker = locker;
0233     debug() << "Constructor artistId: " << artistId;
0234     m_artistId = artistId;
0235 }
0236
0237 Mp3tunesTrackWithArtistIdFetcher::~Mp3tunesTrackWithArtistIdFetcher()
0238 {
0239 }
0240
0241 void Mp3tunesTrackWithArtistIdFetcher::run(ThreadWeaver::JobPointer self, ThreadWeaver::Thread *thread)
0242 {
0243     Q_UNUSED(self);
0244     Q_UNUSED(thread);
0245     DEBUG_BLOCK
0246     if(m_locker != 0) {
0247         debug() << "Track Fetch Start for artist " << m_artistId;
0248         QList<Mp3tunesLockerTrack> list = m_locker->tracksWithArtistId( m_artistId );
0249         debug() << "Track Fetch End. Total tracks: " << list.count();
0250         m_tracks = list;
0251     } else {
0252         debug() << "Locker is NULL";
0253     }
0254 }
0255
0256 void Mp3tunesTrackWithArtistIdFetcher::completeJob()
0257 {
0258     DEBUG_BLOCK
0259     emit( tracksFetched( m_tracks ) );
0260     deleteLater();
0261 }
0262
0263 void Mp3tunesTrackWithArtistIdFetcher::defaultBegin(const ThreadWeaver::JobPointer& self, ThreadWeaver::Thread *thread)
0264 {
0265     Q_EMIT started(self);
0266     ThreadWeaver::Job::defaultBegin(self, thread);
0267 }
0268
0269 void Mp3tunesTrackWithArtistIdFetcher::defaultEnd(const ThreadWeaver::JobPointer& self, ThreadWeaver::Thread *thread)
0270 {
0271     ThreadWeaver::Job::defaultEnd(self, thread);
0272     if (!self->success()) {
0273         Q_EMIT failed(self);
0274     }
0275     Q_EMIT done(self);
0276 }
0277
0278 /*  SEARCH MONKEY */
0279 Mp3tunesSearchMonkey::Mp3tunesSearchMonkey( Mp3tunesLocker * locker, QString query, int searchFor )
0280 {
0281     DEBUG_BLOCK
0282     connect( this, &Mp3tunesSearchMonkey::done, this, &Mp3tunesSearchMonkey::completeJob );
0283     m_locker = locker;
0284     m_searchFor = searchFor;
0285     m_query = query;
0286 }
0287
0288 Mp3tunesSearchMonkey::~Mp3tunesSearchMonkey()
0289 {}
0290
0291 void Mp3tunesSearchMonkey::run(ThreadWeaver::JobPointer self, ThreadWeaver::Thread *thread)
0292 {
0293     Q_UNUSED(self);
0294     Q_UNUSED(thread);
0295     DEBUG_BLOCK
0296     if(m_locker != 0) {
0297         Mp3tunesSearchResult container;
0298         debug() << "Searching query: " << m_query << "    bitmask: " << m_searchFor;
0299         container.searchFor = (Mp3tunesSearchResult::SearchType) m_searchFor;
0300         if( !m_locker->search(container, m_query) )
0301         {
0302             //TODO proper error handling
0303             debug() << "!!!Search Failed query: " << m_query << "    bitmask: " << m_searchFor;
0304         }
0305         m_result = container;
0306     } else {
0307         debug() << "Locker is NULL";
0308     }
0309 }
0310
0311 void Mp3tunesSearchMonkey::completeJob()
0312 {
0313     DEBUG_BLOCK
0314     emit( searchArtistComplete( m_result.artistList ) );
0315     emit( searchAlbumComplete( m_result.albumList ) );
0316     emit( searchTrackComplete( m_result.trackList ) );
0317     deleteLater();
0318 }
0319 void Mp3tunesSearchMonkey::defaultBegin(const ThreadWeaver::JobPointer& self, ThreadWeaver::Thread *thread)
0320
0321 {
0322     Q_EMIT started(self);
0323     ThreadWeaver::Job::defaultBegin(self, thread);
0324 }
0325
0326 void Mp3tunesSearchMonkey::defaultEnd(const ThreadWeaver::JobPointer& self, ThreadWeaver::Thread *thread)
0327 {
0328     ThreadWeaver::Job::defaultEnd(self, thread);
0329     if (!self->success()) {
0330         Q_EMIT failed(self);
0331     }
0332     Q_EMIT done(self);
0333 }
0334
0335 /*  SIMPLE UPLOADER */
0336 Mp3tunesSimpleUploader:: Mp3tunesSimpleUploader( Mp3tunesLocker * locker, const QStringList &tracklist )
0337 {
0338     DEBUG_BLOCK
0339     connect( this, &Mp3tunesSimpleUploader::done, this, &Mp3tunesSimpleUploader::completeJob );
0340
0341     m_locker = locker;
0342     m_tracklist = tracklist;
0343
0344     Amarok::Logger::newProgressOperation( this, i18n( "Upload to MP3tunes Initiated" ), m_tracklist.count() );
0345     //TODO: port to Amarok::Logger signals
0346 //    connect( this, SIGNAL(incrementProgress()), The::statusBar(), SLOT(incrementProgress()), Qt::QueuedConnection );
0347 }
0348
0349 Mp3tunesSimpleUploader::~Mp3tunesSimpleUploader()
0350 {
0351     Q_EMIT endProgressOperation( this );
0352 }
0353
0354 void Mp3tunesSimpleUploader::run(ThreadWeaver::JobPointer self, ThreadWeaver::Thread *thread)
0355 {
0356     Q_UNUSED(self);
0357     Q_UNUSED(thread);
0358     DEBUG_BLOCK
0359     if(m_locker == 0)
0360         return;
0361     if(m_tracklist.count() == 0)
0362     {
0363         debug() << "Track list was empty.";
0364         return;
0365     }
0366
0367     debug() << "Starting upload of " << m_tracklist.count() << " tracks.";
0368     int progress = 1;
0369     foreach(const QString &track, m_tracklist) {
0370         QString msg = i18n( "Uploading Track %1/%2", progress, m_tracklist.count() );
0371         debug() << msg;
0372         //TODO: port to Amarok::Logger signals
0373 //        Amarok::Components::logger()->setProgressStatus( this, msg );
0374         emit ( incrementProgress() );
0375         debug() << "Uploading: " << track;
0376
0377         bool result = false;
0378         if( track.startsWith( "http" ) )
0379         {
0380             debug() << "Remote file.";
0381             result = m_locker->lockerLoad( track );
0382         } else {
0383             debug() << "Local file.";
0384             result = m_locker->uploadTrack( track );
0385         }
0386
0387         if(result) {
0388             debug() << "Uploaded Succeeded.";
0389         } else {
0390             debug() << "Uploaded Failed.";
0391             debug() << "Error msg: " << m_locker->errorMessage();
0392         }
0393         progress++;
0394     }
0395     debug() << "Upload loop complete";
0396 }
0397
0398 void Mp3tunesSimpleUploader::completeJob()
0399 {
0400     DEBUG_BLOCK
0401     emit( uploadComplete() );
0402     deleteLater();
0403 }
0404
0405 void Mp3tunesSimpleUploader::defaultBegin(const ThreadWeaver::JobPointer& self, ThreadWeaver::Thread *thread)
0406 {
0407     Q_EMIT started(self);
0408     ThreadWeaver::Job::defaultBegin(self, thread);
0409 }
0410
0411 void Mp3tunesSimpleUploader::defaultEnd(const ThreadWeaver::JobPointer& self, ThreadWeaver::Thread *thread)
0412 {
0413     ThreadWeaver::Job::defaultEnd(self, thread);
0414     if (!self->success()) {
0415         Q_EMIT failed(self);
0416     }
0417     Q_EMIT done(self);
0418 }
0419
0420 /*  TRACK from filekey FETCHER */
0421 Mp3tunesTrackFromFileKeyFetcher::Mp3tunesTrackFromFileKeyFetcher( Mp3tunesLocker * locker, QString filekey )
0422 {
0423     DEBUG_BLOCK
0424     connect( this, &Mp3tunesTrackFromFileKeyFetcher::done, this, &Mp3tunesTrackFromFileKeyFetcher::completeJob );
0425     m_locker = locker;
0426     debug() << "Constructor filekey: " << filekey;
0427     m_filekey = filekey;
0428 }
0429
0430 Mp3tunesTrackFromFileKeyFetcher::~Mp3tunesTrackFromFileKeyFetcher()
0431 {
0432 }
0433
0434 void Mp3tunesTrackFromFileKeyFetcher::run(ThreadWeaver::JobPointer self, ThreadWeaver::Thread *thread)
0435 {
0436     Q_UNUSED(self);
0437     Q_UNUSED(thread);
0438     DEBUG_BLOCK
0439     if(m_locker != 0) {
0440         debug() << "Track Fetch from filekey " << m_filekey;
0441         Mp3tunesLockerTrack track =  m_locker->trackWithFileKey( m_filekey );
0442         debug() << "Track Fetch from filekey End.";
0443         m_track = track;
0444     } else {
0445         debug() << "Locker is NULL";
0446     }
0447 }
0448
0449 void Mp3tunesTrackFromFileKeyFetcher::completeJob()
0450 {
0451     DEBUG_BLOCK
0452     emit( trackFetched( m_track ) );
0453     deleteLater();
0454 }
0455
0456 void Mp3tunesTrackFromFileKeyFetcher::defaultBegin(const ThreadWeaver::JobPointer& self, ThreadWeaver::Thread *thread)
0457 {
0458     Q_EMIT started(self);
0459     ThreadWeaver::Job::defaultBegin(self, thread);
0460 }
0461
0462 void Mp3tunesTrackFromFileKeyFetcher::defaultEnd(const ThreadWeaver::JobPointer& self, ThreadWeaver::Thread *thread)
0463 {
0464     ThreadWeaver::Job::defaultEnd(self, thread);
0465     if (!self->success()) {
0466         Q_EMIT failed(self);
0467     }
0468     Q_EMIT done(self);
0469 }