Merge lp:~shetyeakash/mixxx/bulk_operations into lp:mixxx/1.10

[RJ Skerry-Ryan]

Akash has added fixes to our DAOs that let you add tracks to playlists, crates, and the main library in bulk. This helps speed up bulk operations in the GUI like adding many tracks to a playlist or crate.

[RJ Skerry-Ryan (rryan)]

I've massaged your branch a little bit to fix some style issues (4-spaces instead of tabs, variable naming, etc.) but it looks good to me otherwise. Thanks Akash!

review: Approve

=== modified file 'mixxx/src/library/cratetablemodel.cpp'
--- mixxx/src/library/cratetablemodel.cpp	2012-05-04 03:00:08 +0000
+++ mixxx/src/library/cratetablemodel.cpp	2012-05-04 05:15:32 +0000
@@ -66,6 +66,7 @@
 bool CrateTableModel::addTrack(const QModelIndex& index, QString location) {
     // If a track is dropped but it isn't in the library, then add it because
     // the user probably dropped a file from outside Mixxx into this playlist.
+	qDebug()<<"CrateTableModel's addTrack called";
     QFileInfo fileInfo(location);
 
     TrackDAO& trackDao = m_pTrackCollection->getTrackDAO();
@@ -89,6 +90,31 @@
     }
 }
 
+//Returns the number of unsuccessful track additions
+//Violates the convention of passing QModelIndexes which aren't used though.
+int CrateTableModel::addTracks(const QModelIndex& index, QList <QString> locations) {
+	int trackAddFails = 0;
+	//prepare the list of QFileInfo's
+	QList <QFileInfo> fileInfoList;
+	QString fileLocation;
+	foreach(fileLocation, locations) {
+		qDebug()<<"Location "<< fileLocation;
+		QFileInfo fileInfo(fileLocation);
+		fileInfoList.append(fileInfo);
+	}
+	TrackDAO& trackDao = m_pTrackCollection->getTrackDAO();
+	QList <int> trackIDs;
+	trackIDs = trackDao.addTracks(fileInfoList, true); // returns ids of tracks in QList
+	//Assuming from trackdao implementation that -1 is returned on add fail
+	trackAddFails = trackIDs.removeAll(-1);
+	//add these trackIDs to the crate in bulk
+	//returns number of unsucessful crate additions
+	int crateAddFails = m_pTrackCollection->getCrateDAO().addTracksToCrate(trackIDs, m_iCrateId);
+	//prompting the errors on console due to unsucessful crate additions are not done
+	select();//doing a select on the model
+	return crateAddFails;//return no of tracks failed to add to crate.
+}
+
 TrackPointer CrateTableModel::getTrack(const QModelIndex& index) const {
     int trackId = getTrackId(index);
     return m_pTrackCollection->getTrackDAO().getTrack(trackId);

=== modified file 'mixxx/src/library/cratetablemodel.h'
--- mixxx/src/library/cratetablemodel.h	2011-11-27 06:59:02 +0000
+++ mixxx/src/library/cratetablemodel.h	2012-05-04 05:15:32 +0000
@@ -30,6 +30,7 @@
     virtual void removeTrack(const QModelIndex& index);
     virtual void removeTracks(const QModelIndexList& indices);
     virtual bool addTrack(const QModelIndex& index, QString location);
+	virtual int addTracks(const QModelIndex& index, QList <QString> locations);
     virtual void moveTrack(const QModelIndex& sourceIndex,
                            const QModelIndex& destIndex);
     TrackModel::CapabilitiesFlags getCapabilities() const;

=== modified file 'mixxx/src/library/dao/cratedao.cpp'
--- mixxx/src/library/dao/cratedao.cpp	2012-03-14 04:49:35 +0000
+++ mixxx/src/library/dao/cratedao.cpp	2012-05-04 05:15:32 +0000
@@ -197,6 +197,38 @@
     return true;
 }
 
+//This method takes a list of track ids to be added to crate and returns # failed track additions
+int CrateDAO::addTracksToCrate(QList <int> trackIdList, int crateId) {
+	int crateAddFails = 0;
+	QSqlQuery query(m_database);
+	//the transaction begins
+	m_database.transaction();
+	for(int i = 0; i<trackIdList.size(); i++) {
+		query.prepare("INSERT INTO " CRATE_TRACKS_TABLE "(crate_id, track_id) VALUES (:crate_id, :track_id)");
+		query.bindValue(":crate_id", crateId);
+		query.bindValue(":track_id", (int) trackIdList.at(i));
+		if(!query.exec()) {
+			LOG_FAILED_QUERY(query);
+			//query failed so increment the # of failed additions to crate
+			crateAddFails++;
+			//we must emit only those trackID that were added
+			//So we need to remove the failed ones
+			trackIdList.removeAt(i);
+		}
+	}
+	//Finished adding tracks to database, commit transaction
+	m_database.commit();
+	int trackId;
+	//Emitting the trackAdded signals for each trackID outside the transaction
+	foreach(trackId, trackIdList) {
+		emit(trackAdded(crateId, trackId));
+	}
+	//Crate has been changed
+	emit(changed(crateId));
+	//return the number of crate additions that have failed
+	return crateAddFails;
+}
+
 void CrateDAO::removeTrackFromCrates(int trackId) {
     QSqlQuery query(m_database);
     QString queryString = QString("DELETE FROM %1 WHERE %2 = %3")

=== modified file 'mixxx/src/library/dao/cratedao.h'
--- mixxx/src/library/dao/cratedao.h	2011-10-21 00:42:23 +0000
+++ mixxx/src/library/dao/cratedao.h	2012-05-04 05:15:32 +0000
@@ -38,6 +38,7 @@
     QString crateName(int crateId);
     unsigned int crateSize(int crateId);
     bool addTrackToCrate(int trackId, int crateId);
+	int addTracksToCrate(QList <int> trackIdList, int crateId);
     void removeTrackFromCrates(int trackId);
     bool removeTrackFromCrate(int trackId, int crateId);
 

=== modified file 'mixxx/src/library/dao/playlistdao.cpp'
--- mixxx/src/library/dao/playlistdao.cpp	2011-10-21 00:42:23 +0000
+++ mixxx/src/library/dao/playlistdao.cpp	2012-05-04 05:15:32 +0000
@@ -396,6 +396,51 @@
     emit(changed(playlistId));
 }
 
+//Takes a list of trackIDs to be inserted into a given playlist
+void PlaylistDAO::insertTracksIntoPlaylist(QList <int> trackIDs, int playlistId, int position) {
+	if (playlistId < 0 || position < 0 ) {
+		return;
+	}
+	m_database.transaction();
+
+    int trackID = -1;
+    foreach (trackID, trackIDs) {
+        if (!(trackID < 0)) {
+            //move all tracks in playlist up by 1
+            //Any reason why a prepared statement isn't used here ??
+            QString queryString = QString("UPDATE PlaylistTracks SET position=position+1 "
+                                            "WHERE position>=%1 AND"
+                                            "playlist_id=%2").arg(position).arg(playlistId);
+            QSqlQuery query(m_database);
+            if (!query.exec(queryString)) {
+                LOG_FAILED_QUERY(query);
+            }
+
+            //Insert the track at the given position
+            query.prepare("INSERT INTO PlaylistTracks (playlist_id, track_id, position)"
+                            "VALUES (:playlist_id, :track_id, :position)");
+            query.bindValue(":playlist_id", playlistId);
+            query.bindValue(":track_id", trackID);
+            query.bindValue(":position", position);
+        
+            if (!query.exec()) {
+                LOG_FAILED_QUERY(query);
+            }
+        }
+    }
+    
+    m_database.commit();
+    //all failed tracks are with trackID -1
+    trackIDs.removeAll(-1);
+    
+    foreach (trackID, trackIDs) {
+        // The emitted position isn't actually the real position of the track
+        emit(trackAdded(playlistId, trackID, position));
+    }
+    emit(changed(playlistId));
+    
+}
+
 void PlaylistDAO::addToAutoDJQueue(int playlistId) {
     //qDebug() << "Adding tracks from playlist " << playlistId << " to the Auto-DJ Queue";
 

=== modified file 'mixxx/src/library/dao/playlistdao.h'
--- mixxx/src/library/dao/playlistdao.h	2011-10-21 00:42:23 +0000
+++ mixxx/src/library/dao/playlistdao.h	2012-05-04 05:15:32 +0000
@@ -52,6 +52,8 @@
     void removeTrackFromPlaylist(int playlistId, int position);
     /** Insert a track into a specific position in a playlist */
     void insertTrackIntoPlaylist(int trackId, int playlistId, int position);
+	/** Inserts a list of tracks into playlist*/
+	void insertTracksIntoPlaylist(QList <int> trackID, int playlistId, int position);
     /** Add a playlist to the Auto-DJ Queue */
     void addToAutoDJQueue(int playlistId);
   signals:

=== modified file 'mixxx/src/library/dao/trackdao.cpp'
--- mixxx/src/library/dao/trackdao.cpp	2012-04-24 22:07:26 +0000
+++ mixxx/src/library/dao/trackdao.cpp	2012-05-04 05:15:32 +0000
@@ -454,6 +454,27 @@
     return trackId;
 }
 
+QList <int> TrackDAO::addTracks(QList <QFileInfo> fileInfoList, bool unremove) {
+    //returns the list with trackIDs of the added tracks
+	QList <int> trackIDs;
+	QList <TrackInfoObject *> pTrackList;
+	QFileInfo fileInfo;
+	//create the list of TrackInfoObjects from the fileInfoList  
+	foreach(fileInfo, fileInfoList) {
+		TrackInfoObject * pTrack = new TrackInfoObject(fileInfo);
+		pTrackList.append(pTrack);
+	}
+	//calling addTracks with the list of tracks to be added
+	addTracks(pTrackList, unremove);
+	TrackInfoObject * pTrack;
+	foreach(pTrack, pTrackList){
+		int trackID = pTrack->getId();
+		trackIDs.append(trackID);
+		delete pTrack;
+	}
+	return trackIDs;
+}
+
 int TrackDAO::addTrack(QString absoluteFilePath, bool unremove)
 {
     QFileInfo fileInfo(absoluteFilePath);

=== modified file 'mixxx/src/library/dao/trackdao.h'
--- mixxx/src/library/dao/trackdao.h	2012-04-24 21:43:49 +0000
+++ mixxx/src/library/dao/trackdao.h	2012-05-04 05:15:32 +0000
@@ -74,6 +74,7 @@
     int addTrack(QString absoluteFilePath, bool unremove);
     int addTrack(QFileInfo& fileInfo, bool unremove);
     void addTracks(QList<TrackInfoObject*> tracksToAdd, bool unremove);
+	QList <int> addTracks(QList <QFileInfo> fileInfoList, bool unremove);
     void removeTrack(int id);
     void removeTracks(QList<int> ids);
     void unremoveTrack(int trackId);

=== modified file 'mixxx/src/library/librarytablemodel.cpp'
--- mixxx/src/library/librarytablemodel.cpp	2012-05-04 03:00:08 +0000
+++ mixxx/src/library/librarytablemodel.cpp	2012-05-04 05:15:32 +0000
@@ -64,6 +64,23 @@
     return false;
 }
 
+//Takes a list of locations and add the tracks to the library, returns the number of failed additions.
+int LibraryTableModel::addTracks(const QModelIndex& index, QList <QString> locations) {
+	int trackAddFails = 0;
+	//Prepare the list of QFileInfo's
+	QList <QFileInfo> fileInfoList;
+	QString fileLocation;
+	foreach (fileLocation, locations) {
+		QFileInfo fileInfo(fileLocation);
+		fileInfoList.append(fileInfo);
+	}
+	QList <int> trackIDs;
+	trackIDs = m_trackDao.addTracks(fileInfoList, true); //returns the ids of tracks in a QList
+	//Assuming from the trackdao implementation that -1 is returned on an add fail
+	trackAddFails = trackIDs.removeAll(-1);
+	return trackAddFails;
+}
+
 TrackPointer LibraryTableModel::getTrack(const QModelIndex& index) const {
     int trackId = getTrackId(index);
     return m_trackDao.getTrack(trackId);

=== modified file 'mixxx/src/library/librarytablemodel.h'
--- mixxx/src/library/librarytablemodel.h	2011-09-25 08:08:35 +0000
+++ mixxx/src/library/librarytablemodel.h	2012-05-04 05:15:32 +0000
@@ -24,6 +24,7 @@
     virtual void removeTrack(const QModelIndex& index);
     virtual void removeTracks(const QModelIndexList& indices);
     virtual bool addTrack(const QModelIndex& index, QString location);
+	virtual int addTracks(const QModelIndex& index, QList <QString> locations);
     virtual void moveTrack(const QModelIndex& sourceIndex,
                            const QModelIndex& destIndex);
 

=== modified file 'mixxx/src/library/playlisttablemodel.cpp'
--- mixxx/src/library/playlisttablemodel.cpp	2012-05-04 03:00:08 +0000
+++ mixxx/src/library/playlisttablemodel.cpp	2012-05-04 05:15:32 +0000
@@ -94,6 +94,41 @@
     return true;
 }
 
+//Adding multiple tracks at once to a playlist, returns # of failed additions
+int PlaylistTableModel::addTracks(const QModelIndex& index, QList <QString> locations) {
+	int trackAddFails = 0;
+	const int positionColumn = fieldIndex(PLAYLISTTRACKSTABLE_POSITION);
+	int position = index.sibling(index.row(), positionColumn).data().toInt();
+	
+	//Handle weird cases like a drag and drop to an invalid index
+	if (position <= 0) {
+		position = rowCount() + 1;
+	}
+
+	//Prepare a list of QFileInfos
+	QList <QFileInfo> fileInfoList;
+	QString fileLocation;
+	foreach (fileLocation, locations) {
+		qDebug()<<"Location"<< fileLocation;
+		QFileInfo fileInfo(fileLocation);
+		fileInfoList.append(fileInfo);
+	}
+
+	//Use the addTracks of TrackDAO which returns a QList with trackIds
+	QList <int> trackIDs;
+	trackIDs = m_trackDao.addTracks(fileInfoList, true);
+	
+	//Assuming from the TrackDAO implementation of addTrack which returns -1 for add fails
+	trackAddFails = trackIDs.removeAll(-1);
+	//trackAddFails are # of tracks that couldn't be added to library
+	
+	//Unlike the way addTrack is implemented in CrateTableModel here it does not worry about failing to add track to playlist?
+	m_playlistDao.insertTracksIntoPlaylist(trackIDs, m_iPlaylistId, position);
+	select();
+
+	return trackAddFails;
+}
+
 TrackPointer PlaylistTableModel::getTrack(const QModelIndex& index) const {
     //FIXME: use position instead of location for playlist tracks?
 

=== modified file 'mixxx/src/library/playlisttablemodel.h'
--- mixxx/src/library/playlisttablemodel.h	2011-11-30 05:27:44 +0000
+++ mixxx/src/library/playlisttablemodel.h	2012-05-04 05:15:32 +0000
@@ -30,6 +30,7 @@
     virtual void removeTrack(const QModelIndex& index);
     virtual void removeTracks(const QModelIndexList& indices);
     virtual bool addTrack(const QModelIndex& index, QString location);
+	virtual int addTracks(const QModelIndex& index, QList <QString> locations);
     virtual void moveTrack(const QModelIndex& sourceIndex, const QModelIndex& destIndex);
     virtual void shuffleTracks(const QModelIndex& currentIndex);
 

=== modified file 'mixxx/src/library/trackmodel.h'
--- mixxx/src/library/trackmodel.h	2012-05-04 03:00:08 +0000
+++ mixxx/src/library/trackmodel.h	2012-05-04 05:15:32 +0000
@@ -74,6 +74,11 @@
         Q_UNUSED(location);
         return false;
     }
+	virtual int addTracks(const QModelIndex& index, QList <QString> locations) {
+		Q_UNUSED(index);
+		Q_UNUSED(locations);
+		return -1;
+	}
     virtual void moveTrack(const QModelIndex& sourceIndex,
                            const QModelIndex& destIndex) {
         Q_UNUSED(sourceIndex);

=== modified file 'mixxx/src/widget/wtracktableview.cpp'
--- mixxx/src/widget/wtracktableview.cpp	2012-05-04 03:00:08 +0000
+++ mixxx/src/widget/wtracktableview.cpp	2012-05-04 05:15:32 +0000
@@ -708,7 +708,7 @@
 
             }
         }
-        else
+        else//Drag and drop inside Mixxx is only for few rows, bulks happen here
         {
             //Reset the selected tracks (if you had any tracks highlighted, it
             //clears them)
@@ -741,13 +741,25 @@
                 }
 
                 //Add all the dropped URLs/tracks to the track model (playlist/crate)
-                foreach (url, urls)
-                {
-                    QFileInfo file(url.toLocalFile());
-                    if (!trackModel->addTrack(destIndex, file.absoluteFilePath()))
-                        numNewRows--; //# of rows to select must be decremented if we skipped some tracks
-                }
-
+				if(urls.size() > 1) {//if many items are being dropped
+					//prepare the list of QFileInfos
+					QList <QString> fileLocationList;
+                	foreach(url, urls) {
+						QString file(url.toLocalFile());
+						fileLocationList.append(file);
+					}
+					//calling the addTracks returns number of failed additions
+					int failedAdds = trackModel->addTracks(destIndex, fileLocationList);
+					//Decrement # of rows to select if some were skipped
+					numNewRows = numNewRows - failedAdds;
+				}
+				else {
+					QFileInfo file(url.toLocalFile());
+					if(!trackModel->addTrack(destIndex, file.absoluteFilePath())) {
+						numNewRows--;
+					}
+	
+				}	
                 //Create the selection, but only if the track model supports reordering.
                 //(eg. crates don't support reordering/indexes)
                 if (modelHasCapabilities(TrackModel::TRACKMODELCAPS_REORDER)) {
@@ -767,6 +779,7 @@
     } else {
         event->ignore();
     }
+	qDebug()<<"Track drop of wtracktavleview occured";
 }
 
 TrackModel* WTrackTableView::getTrackModel() {