iTunes: Share common import logic between XML and macOS

CMakeLists.txt

@@ -749,6 +749,7 @@ add_library(mixxx-lib STATIC EXCLUDE_FROM_ALL
   src/library/export/trackexportworker.cpp
   src/library/externaltrackcollection.cpp
   src/library/hiddentablemodel.cpp
+  src/library/itunes/itunesdao.cpp
   src/library/itunes/itunesfeature.cpp
   src/library/itunes/itunesxmlimporter.cpp
   src/library/library_prefs.cpp

src/library/itunes/itunesdao.cpp

@@ -0,0 +1,153 @@
+#include "library/itunes/itunesdao.h"
+
+#include <QSqlQuery>
+
+#include "library/itunes/ituneslocalhosttoken.h"
+#include "library/itunes/itunespathmapping.h"
+#include "library/queryutil.h"
+
+void ITunesDAO::initialize(const QSqlDatabase& database) {
+    m_insertTrackQuery = QSqlQuery(database);
+    m_insertPlaylistQuery = QSqlQuery(database);
+    m_insertPlaylistTrackQuery = QSqlQuery(database);
+    m_applyPathMappingQuery = QSqlQuery(database);
+
+    m_insertTrackQuery.prepare(
+            "INSERT INTO itunes_library (id, artist, title, album, "
+            "album_artist, genre, grouping, year, duration, "
+            "location, rating, comment, tracknumber, bpm, bitrate) "
+            "VALUES (:id, :artist, :title, :album, :album_artist, "
+            ":genre, :grouping, :year, :duration, :location, "
+            ":rating, :comment, :tracknumber, :bpm, :bitrate)");
+
+    m_insertPlaylistQuery.prepare("INSERT INTO itunes_playlists (id, name) VALUES (:id, :name)");
+
+    m_insertPlaylistTrackQuery.prepare(
+            "INSERT INTO itunes_playlist_tracks (playlist_id, track_id, "
+            "position) VALUES (:playlist_id, :track_id, :position)");
+
+    m_applyPathMappingQuery.prepare(
+            "UPDATE itunes_library SET location = replace( location, "
+            ":itunes_path, :mixxx_path )");
+}
+
+bool ITunesDAO::importTrack(const ITunesTrack& track) {
+    QSqlQuery& query = m_insertTrackQuery;
+
+    query.bindValue(":id", track.id);
+    query.bindValue(":artist", track.artist);
+    query.bindValue(":title", track.title);
+    query.bindValue(":album", track.album);
+    query.bindValue(":album_artist", track.albumArtist);
+    query.bindValue(":genre", track.genre);
+    query.bindValue(":grouping", track.grouping);
+    query.bindValue(":year", track.year > 0 ? QVariant(track.year) : QVariant());
+    query.bindValue(":duration", track.duration);
+    query.bindValue(":location", track.location);
+    query.bindValue(":rating", track.rating);
+    query.bindValue(":comment", track.comment);
+    query.bindValue(":tracknumber",
+            track.trackNumber > 0 ? QVariant(track.trackNumber) : QVariant());
+    query.bindValue(":bpm", track.bpm);
+    query.bindValue(":bitrate", track.bitrate);
+
+    if (!query.exec()) {
+        LOG_FAILED_QUERY(query);
+        return false;
+    }
+
+    return true;
+}
+
+bool ITunesDAO::importPlaylist(const ITunesPlaylist& playlist) {
+    QString uniqueName = uniquifyPlaylistName(playlist.name);
+    QSqlQuery& query = m_insertPlaylistQuery;
+
+    query.bindValue(":id", playlist.id);
+    query.bindValue(":name", uniqueName);
+
+    if (!query.exec()) {
+        LOG_FAILED_QUERY(query);
+        return false;
+    }
+
+    m_playlistNameById[playlist.id] = uniqueName;
+
+    return true;
+}
+
+bool ITunesDAO::importPlaylistRelation(int parentId, int childId) {
+    m_playlistIdsByParentId.insert({parentId, childId});
+    return true;
+}
+
+bool ITunesDAO::importPlaylistTrack(int playlistId, int trackId, int position) {
+    QSqlQuery& query = m_insertPlaylistTrackQuery;
+
+    query.bindValue(":playlist_id", playlistId);
+    query.bindValue(":track_id", trackId);
+    query.bindValue(":position", position);
+
+    if (!query.exec()) {
+        LOG_FAILED_QUERY(query);
+        return false;
+    }
+
+    return true;
+}
+
+bool ITunesDAO::applyPathMapping(const ITunesPathMapping& pathMapping) {
+    QSqlQuery& query = m_insertPlaylistTrackQuery;
+
+    query.bindValue(":itunes_path",
+            QString(pathMapping.dbITunesRoot).replace(kiTunesLocalhostToken, ""));
+    query.bindValue(":mixxx_path", pathMapping.mixxxITunesRoot);
+
+    if (!query.exec()) {
+        LOG_FAILED_QUERY(query);
+        return false;
+    }
+
+    return true;
+}
+
+void ITunesDAO::appendPlaylistTree(TreeItem& item, int playlistId) {
+    auto childsRange = m_playlistIdsByParentId.equal_range(playlistId);
+    std::for_each(childsRange.first,
+            childsRange.second,
+            [this, &item](auto childEntry) {
+                int childId = childEntry.second;
+                QString childName = m_playlistNameById[childId];
+                TreeItem* child = item.appendChild(childName);
+                appendPlaylistTree(*child, childId);
+            });
+}
+
+QString ITunesDAO::uniquifyPlaylistName(QString name) {
+    // iTunes permits users to have multiple playlists with the same name,
+    // our data model (both the database schema and the tree items) however
+    // require unique names since they identify the playlist via this name.
+    // We therefore keep track of duplicates and append a suffix
+    // accordingly. E.g. if the user has three playlists named 'House' in
+    // their library, the playlists would get named (in this order):
+    //
+    //     House
+    //     House #2
+    //     House #3
+    //
+
+    // Avoid empty playlist names
+    if (name.isEmpty()) {
+        name = "(empty)";
+    }
+
+    auto existing = m_playlistDuplicatesByName.find(name);
+    if (existing != m_playlistDuplicatesByName.end()) {
+        m_playlistDuplicatesByName[name] += 1;
+        return QString("%1 #%2").arg(name).arg(
+                m_playlistDuplicatesByName[name] + 1);
+    } else {
+        m_playlistDuplicatesByName[name] = 0;
+        return name;
+    }
+}

src/library/itunes/itunesdao.h

@@ -0,0 +1,66 @@
+#pragma once
+
+#include <QHash>
+#include <QSqlDatabase>
+#include <QSqlQuery>
+#include <QString>
+#include <map>
+
+#include "library/dao/dao.h"
+#include "library/itunes/itunespathmapping.h"
+#include "library/treeitem.h"
+
+const int kRootITunesPlaylistId = -1;
+
+struct ITunesTrack {
+    int id;
+    QString artist;
+    QString title;
+    QString album;
+    QString albumArtist;
+    QString genre;
+    QString grouping;
+    int year;
+    int duration;
+    QString location;
+    int rating;
+    QString comment;
+    int trackNumber;
+    int bpm;
+    int bitrate;
+};
+
+struct ITunesPlaylist {
+    int id;
+    QString name;
+};
+
+/// A wrapper around the iTunes database tables. Keeps track of the
+/// playlist tree, deals with duplicate disambiguation and can export
+/// the tree afterwards.
+class ITunesDAO : public DAO {
+  public:
+    ~ITunesDAO() override = default;
+
+    void initialize(const QSqlDatabase& database) override;
+
+    bool importTrack(const ITunesTrack& track);
+    bool importPlaylist(const ITunesPlaylist& playlist);
+    bool importPlaylistRelation(int parentId, int childId);
+    bool importPlaylistTrack(int playlistId, int trackId, int position);
+    bool applyPathMapping(const ITunesPathMapping& pathMapping);
+
+    void appendPlaylistTree(TreeItem& item, int playlistId = kRootITunesPlaylistId);
+
+  private:
+    QHash<QString, int> m_playlistDuplicatesByName;
+    QHash<int, QString> m_playlistNameById;
+    std::multimap<int, int> m_playlistIdsByParentId;
+
+    QSqlQuery m_insertTrackQuery;
+    QSqlQuery m_insertPlaylistQuery;
+    QSqlQuery m_insertPlaylistTrackQuery;
+    QSqlQuery m_applyPathMappingQuery;
+
+    QString uniquifyPlaylistName(QString name);
+};

src/library/itunes/itunesfeature.cpp

@@ -15,6 +15,7 @@
 #include "library/baseexternaltrackmodel.h"
 #include "library/basetrackcache.h"
 #include "library/dao/settingsdao.h"
+#include "library/itunes/itunesdao.h"
 #include "library/itunes/itunesimporter.h"
 #include "library/itunes/ituneslocalhosttoken.h"
 #include "library/itunes/itunesxmlimporter.h"
@@ -306,15 +307,15 @@ QString ITunesFeature::getiTunesMusicPath() {
     return musicFolder;
 }
 
-std::unique_ptr<ITunesImporter> ITunesFeature::makeImporter() {
+std::unique_ptr<ITunesImporter> ITunesFeature::makeImporter(ITunesDAO& dao) {
 #ifdef __MACOS_ITUNES_LIBRARY__
     if (isMacOSImporterUsed()) {
         qDebug() << "Using ITunesMacOSImporter to read default iTunes library";
-        return std::make_unique<ITunesMacOSImporter>(this, m_database, m_cancelImport);
+        return std::make_unique<ITunesMacOSImporter>(this, m_cancelImport, dao);
     }
 #endif
     qDebug() << "Using ITunesXMLImporter to read iTunes library from " << m_dbfile;
-    return std::make_unique<ITunesXMLImporter>(this, m_dbfile, m_database, m_cancelImport);
+    return std::make_unique<ITunesXMLImporter>(this, m_dbfile, m_cancelImport, dao);
 }
 
 // This method is executed in a separate thread
@@ -328,7 +329,10 @@ TreeItem* ITunesFeature::importLibrary() {
 
     ScopedTransaction transaction(m_database);
 
-    std::unique_ptr<ITunesImporter> importer = makeImporter();
+    ITunesDAO dao;
+    dao.initialize(m_database);
+
+    std::unique_ptr<ITunesImporter> importer = makeImporter(dao);
     ITunesImport iTunesImport = importer->importLibrary();
 
     // Even if an error occurred, commit the transaction. The file may have been

src/library/itunes/itunesfeature.h

@@ -9,6 +9,7 @@
 #include <atomic>
 
 #include "library/baseexternallibraryfeature.h"
+#include "library/itunes/itunesdao.h"
 #include "library/itunes/itunesimporter.h"
 #include "library/trackcollection.h"
 #include "library/treeitem.h"
@@ -42,7 +43,7 @@ class ITunesFeature : public BaseExternalLibraryFeature {
     std::unique_ptr<BaseSqlTableModel> createPlaylistModelForPlaylist(
             const QString& playlist) override;
     static QString getiTunesMusicPath();
-    std::unique_ptr<ITunesImporter> makeImporter();
+    std::unique_ptr<ITunesImporter> makeImporter(ITunesDAO& dao);
     // returns the invisible rootItem for the sidebar model
     TreeItem* importLibrary();
     void guessMusicLibraryMountpoint(QXmlStreamReader& xml);

src/library/itunes/itunesmacosimporter.h

@@ -4,6 +4,7 @@
 #include <QString>
 #include <atomic>
 
+#include "library/itunes/itunesdao.h"
 #include "library/itunes/itunesimporter.h"
 #include "library/libraryfeature.h"
 
@@ -12,16 +13,17 @@
 class ITunesMacOSImporter : public ITunesImporter {
   public:
     ITunesMacOSImporter(LibraryFeature* parentFeature,
-            const QSqlDatabase& database,
-            const std::atomic<bool>& cancelImport);
+            const std::atomic<bool>& cancelImport,
+            ITunesDAO& dao);
 
     ITunesImport importLibrary() override;
 
   private:
     LibraryFeature* m_parentFeature;
+    const std::atomic<bool>& m_cancelImport;
     // The values behind these references are owned by the parent `ITunesFeature`,
+    // (note that the DAO internally contains a database reference),
     // thus there is an implicit contract here that this `ITunesMacOSImporter` cannot
     // outlive the feature (which should not happen anyway, since importers are short-lived).
-    const QSqlDatabase& m_database;
-    const std::atomic<bool>& m_cancelImport;
+    ITunesDAO& m_dao;
 };