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,155 @@
+#include "library/itunes/itunesdao.h"
+
+#include <QObject>
+#include <QSqlQuery>
+#include <gsl/pointers>
+
+#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(gsl::not_null<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 = QObject::tr("(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,70 @@
+#pragma once
+
+#include <QHash>
+#include <QSqlDatabase>
+#include <QSqlQuery>
+#include <QString>
+#include <gsl/pointers>
+#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;
+
+    virtual bool importTrack(const ITunesTrack& track);
+    virtual bool importPlaylist(const ITunesPlaylist& playlist);
+    virtual bool importPlaylistRelation(int parentId, int childId);
+    virtual bool importPlaylistTrack(int playlistId, int trackId, int position);
+    virtual bool applyPathMapping(const ITunesPathMapping& pathMapping);
+
+    virtual void appendPlaylistTree(gsl::not_null<TreeItem*> item,
+            int playlistId = kRootITunesPlaylistId);
+
+  private:
+    QHash<QString, int> m_playlistDuplicatesByName;
+    QHash<int, QString> m_playlistNameById;
+    std::multimap<int, int> m_playlistIdsByParentId;
+
+    // Note that these queries reference the database, which is expected
+    // to outlive the DAO.
+    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"
@@ -307,14 +308,16 @@ QString ITunesFeature::getiTunesMusicPath() {
 }
 
 std::unique_ptr<ITunesImporter> ITunesFeature::makeImporter() {
+    std::unique_ptr<ITunesDAO> dao = std::make_unique<ITunesDAO>();
+    dao->initialize(m_database);
 #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, std::move(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, std::move(dao));
 }
 
 // This method is executed in a separate thread

src/library/itunes/itunesmacosimporter.h

@@ -3,7 +3,9 @@
 #include <QSqlDatabase>
 #include <QString>
 #include <atomic>
+#include <memory>
 
+#include "library/itunes/itunesdao.h"
 #include "library/itunes/itunesimporter.h"
 #include "library/libraryfeature.h"
 
@@ -12,8 +14,8 @@
 class ITunesMacOSImporter : public ITunesImporter {
   public:
     ITunesMacOSImporter(LibraryFeature* parentFeature,
-            const QSqlDatabase& database,
-            const std::atomic<bool>& cancelImport);
+            const std::atomic<bool>& cancelImport,
+            std::unique_ptr<ITunesDAO> dao);
 
     ITunesImport importLibrary() override;
 
@@ -22,6 +24,6 @@ class ITunesMacOSImporter : public ITunesImporter {
     // The values behind these references are owned by the parent `ITunesFeature`,
     // 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;
+    std::unique_ptr<ITunesDAO> m_dao;
 };