initial commit

commands/api.js

@@ -0,0 +1,12 @@
+import { callApi } from "../lib/lastfm.js"
+
+const api = (username, method, args, options) => {
+    callApi(method, {
+        username: username,
+        ...JSON.parse(args)
+    }).then((data) => {
+        console.log(data)
+    })
+}
+
+export default api

commands/process.js

@@ -0,0 +1,115 @@
+import { loadAllData, mkSubDir, saveData } from "../lib/dataStore.js"
+
+const process = async (username, options) => {
+    let data = {}
+    let processed = {
+        tracks: {},
+        listenTime: {
+            track: {},
+            album: {},
+            artist: {},
+            sortedTracks: [],
+            sortedAlbums: [],
+            sortedArtists: []
+        }
+    }
+    if (options.tracks) {
+        data.tracks = loadAllData(username, 'tracks')
+
+        // track-only data
+        for (let page in data.tracks) {
+            console.log(page, data.tracks[page])
+            if (!data.tracks[page].toptracks) continue;
+            let currentPage = data.tracks[page].toptracks.track
+            // console.log(currentPage)
+            for (let track of currentPage) {
+                console.log('processing track', track.name)
+                processed.tracks[track.mbid] = {
+                    playcount: track.playcount,
+                    name: track.name,
+                    artist: track.artist.name
+                }
+                if (track.duration && parseInt(track.duration)) {
+                    console.log('track has duration', track.duration)
+                    let listenTime = parseInt(track.duration) * parseInt(track.playcount)
+                    console.log('track listen time is', listenTime)
+                    processed.listenTime.track[track.mbid] = {
+                        seconds: listenTime,
+                        minutes: listenTime / 60
+                    }
+
+                    console.log(track.mbid, processed.listenTime.track[track.mbid])
+                    let key = ''
+                    if (track.artist.mbid) { key = track.artist.mbid }
+                    else { key = 'N-' + track.artist.name }
+
+                    if (!processed.listenTime.artist[key]) {
+                        processed.listenTime.artist[key] = {
+                            seconds: listenTime,
+                            minutes: listenTime / 60,
+                            name: track.artist.name
+                        }
+                    }
+                    else {
+                        processed.listenTime.artist[key].seconds += listenTime
+                        processed.listenTime.artist[key].minutes =
+                            processed.listenTime.artist[key].seconds / 60
+                    }
+                }
+                else {
+                    processed.listenTime.track[track.mbid] = {
+                        playcount: track.playcount
+                    }
+                }
+            }
+        }
+
+        for (let track in processed.listenTime.tracks) {
+            processed.listenTime.sortedTracks.push({
+                mbid: track,
+                ...processed.listenTime.track[track]
+            })
+        }
+
+        processed.listenTime.sortedTracks.sort(
+            (a, b) => {
+                return b.seconds - a.seconds
+            }
+        )
+
+        for (let artist in processed.listenTime.artist) {
+            processed.listenTime.sortedArtists.push(
+                {
+                    mbid: artist,
+                    ...processed.listenTime.artist[artist]
+                }
+            )
+        }
+
+        processed.listenTime.sortedArtists.sort(
+            (a, b) => {
+                return b.seconds - a.seconds
+            }
+        )
+    }
+    if (options.albums) {
+        data.albums = loadAllData(username, 'albums')
+        for (let page in data.albums) {
+            let currentPage = data.albums[page].topalbums.album
+        }
+    }
+
+    if (options.artists) {
+        data.artists = loadAllData(username, 'artists')
+        for (let page in data.artists) {
+            let currentPage = data.artists[page].topartists.artist
+        }
+    }
+    console.log('saving processed data')
+    mkSubDir(username, 'processed')
+    saveData(username, 'processed/gross', processed)
+    saveData(username, 'processed/tracks', processed.tracks)
+    saveData(username, 'processed/listenTime', processed.listenTime)
+}
+
+export default process

commands/retrieve.js

@@ -0,0 +1,105 @@
+import { callApi } from '../lib/lastfm.js'
+import { hasData, mkSubDir, saveData } from '../lib/dataStore.js'
+
+function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+
+const retrieve = async (username, options) => {
+    callApi("user.getinfo", { user: username }).then((data) => {
+        saveData(username, "basic_info", data)
+    })
+    if (!options.basic) {
+        await retrieveTracks(username, options)
+        await retrieveAlbums(username, options)
+        await retrieveArtists(username, options)
+    }
+}
+
+const retrieveTracks = async (username, options) => {
+    let period = '12month'
+    if (options.full) {
+        period = 'overall'
+    }
+    let pages = 0;
+    mkSubDir(username, 'tracks')
+    if (hasData(username, "tracks/tracks-1")) {
+        console.log('already have tracks');
+        return;
+    }
+    console.log('downloading page 1 of ???')
+    let data = await callApi("user.getTopTracks", {
+        user: username
+    })
+    pages = data.toptracks['@attr'].totalPages
+    saveData(username, "tracks/tracks-1", data)
+    for (let i = 2; i <= pages; i++) {
+        await sleep(500)
+        console.log(`downloading page ${i} of ${pages}`)
+        let data = await callApi("user.getTopTracks", {
+            user: username,
+            page: i
+        })
+        saveData(username, `tracks/tracks-${i}`, data)
+    }
+}
+
+const retrieveAlbums = async (username, options) => {
+    let period = '12month'
+    if (options.full) {
+        period = 'overall'
+    }
+    let pages = 0;
+    mkSubDir(username, 'albums')
+    if (hasData(username, "albums/albums-1")) {
+        console.log('already have albums');
+        return;
+    }
+    console.log('downloading page 1 of ???')
+    let data = await callApi("user.getTopAlbums", {
+        user: username
+    })
+    pages = data.topalbums['@attr'].totalPages
+    saveData(username, "albums/albums-1", data)
+    for (let i = 2; i <= pages; i++) {
+        await sleep(500)
+        console.log(`downloading page ${i} of ${pages}`)
+        let data = await callApi("user.getTopAlbums", {
+            user: username,
+            page: i
+        })
+        saveData(username, `albums/albums-${i}`, data)
+    }
+}
+
+const retrieveArtists = async (username, options) => {
+    let period = '12month'
+    if (options.full) {
+        period = 'overall'
+    }
+    let pages = 0;
+    mkSubDir(username, 'artists')
+    if (hasData(username, "artists/artists-1")) {
+        console.log('already have artists');
+        return;
+    }
+    console.log('downloading page 1 of ???')
+    let data = await callApi("user.getTopArtists", {
+        user: username
+    })
+    pages = data.topartists['@attr'].totalPages
+    saveData(username, "artists/artists-1", data)
+    for (let i = 2; i <= pages; i++) {
+        await sleep(500)
+        console.log(`downloading page ${i} of ${pages}`)
+        let data = await callApi("user.getTopArtists", {
+            user: username,
+            page: i
+        })
+        saveData(username, `artists/artists-${i}`, data)
+    }
+}
+
+export default retrieve