-
Content goes here
+@zig {
+ const ColumnChoices = []const enum{song, album, artist, artistlist, scrobbles, date};
+ const columns: ColumnChoices = &.{.song, .artistlist, .album, .date};
+}
+
+
+
+
+
+
+@partial partials/header
+
+
{{.song.song_name}}
+
+
+
+
{{.song.scrobbles}} scrobbles ({{.song.rank}} place)
+ @partial partials/firstlast_listens(firstlast: .firstlast)
+
Yearly Performance
+ @partial partials/timescale(range: .yearly)
+
Scrobbles
+ @partial partials/newtable(T: ColumnChoices, table_data: .scrobbles, columns: columns)
+
+
+
Rating
+
+
+
+
\ No newline at end of file
diff --git a/src/app/views/songs/index.zmpl b/src/app/views/songs/index.zmpl
index a0a1128..862b753 100644
--- a/src/app/views/songs/index.zmpl
+++ b/src/app/views/songs/index.zmpl
@@ -1,40 +1,17 @@
+@zig {
+ const ColumnChoices = []const enum{song, album, artist, artistlist, scrobbles, date};
+ const columns: ColumnChoices = &.{.song, .album, .artistlist, .scrobbles};
+}
+
-
+ @if (! $.htmx)
@partial partials/header
Songs
-
-
-
-Name
-Artists(s)
-Scrobbles
-
-
-
-@for (.songs) |song| {
-
- {{song.name}}
- @for (song.get("artist_info").?) |ai| {
- {{ai.name}}
- }
-
- {{song.scrobbles}}
-
-}
-
-
-
-
+ @end
+@partial partials/newtable(T: ColumnChoices, table_data: .songs, columns: columns)
\ No newline at end of file
diff --git a/src/app/views/songs/new.zmpl b/src/app/views/songs/new.zmpl
deleted file mode 100644
index 76457d0..0000000
--- a/src/app/views/songs/new.zmpl
+++ /dev/null
@@ -1,3 +0,0 @@
-
- Content goes here
-
diff --git a/src/app/views/songs/patch.zmpl b/src/app/views/songs/patch.zmpl
deleted file mode 100644
index 76457d0..0000000
--- a/src/app/views/songs/patch.zmpl
+++ /dev/null
@@ -1,3 +0,0 @@
-
- Content goes here
-
diff --git a/src/app/views/songs/post.zmpl b/src/app/views/songs/post.zmpl
deleted file mode 100644
index 76457d0..0000000
--- a/src/app/views/songs/post.zmpl
+++ /dev/null
@@ -1,3 +0,0 @@
-
- Content goes here
-
diff --git a/src/app/views/songs/put.zmpl b/src/app/views/songs/put.zmpl
deleted file mode 100644
index 76457d0..0000000
--- a/src/app/views/songs/put.zmpl
+++ /dev/null
@@ -1,3 +0,0 @@
-
- Content goes here
-
diff --git a/src/app/views/upload.zig b/src/app/views/upload.zig
index 53f3b27..f712ba4 100644
--- a/src/app/views/upload.zig
+++ b/src/app/views/upload.zig
@@ -1,135 +1,158 @@
const std = @import("std");
const jetzig = @import("jetzig");
const jetquery = @import("jetzig").jetquery;
-const ScrobbleTypes = @import("../../types.zig");
const zeit = @import("zeit");
+const rules = @import("../../apply_rule.zig");
+const Data = @import("../../types.zig");
+const Utils = @import("../../date_fmt.zig");
+const Client = std.http.Client;
pub fn index(request: *jetzig.Request, data: *jetzig.Data) !jetzig.View {
_ = data;
return request.render(.ok);
}
-pub fn get(id: []const u8, request: *jetzig.Request, data: *jetzig.Data) !jetzig.View {
- _ = data;
- _ = id;
- return request.render(.ok);
-}
-
pub fn post(request: *jetzig.Request) !jetzig.View {
var root = try request.data(.object);
- if (try request.file("upload")) |file| {
- const params = try request.params();
- const source = try std.fmt.parseInt(u8, params.get("t").?.string.value, 10); // This param is required in HTML
- const before_limiter: bool = if (params.get("bbool")) |_| true else false;
- const after_limiter: bool = if (params.get("abool")) |_| true else false;
+ const params = try request.params();
+ const rule_file = try (std.fs.cwd().openFile("rules.json", .{ .mode = .read_only }) catch |err| switch (err) {
+ error.FileNotFound => std.fs.cwd().createFile("rules.json", .{ .read = true }),
+ else => err,
+ });
- var scrobbles_view = try root.put("scrobbles", .array);
- var job = try request.job("process_scrobbles");
- var scrobbles_data = try job.params.put("scrobbles", .array);
+ defer rule_file.close();
+ const rule_file_content = try rule_file.readToEndAlloc(request.allocator, 16_000_000);
+ const rule_list = std.json.parseFromSliceLeaky([]Data.Rule, request.allocator, rule_file_content, .{}) catch null;
+ var job = try request.job("process_scrobbles2");
+ const source = params.getT(.integer, "t").?; // This param is required in HTML
- var skipped_tracks: u64 = 0;
- var limited_tracks: u64 = 0;
+ const latest_date = if (params.getT(.boolean, "adv-opt")) |_| blk: {
+ const date = params.getT(.string, "latest-date").?;
+ break :blk try zeit.Time.fromISO8601(date);
+ } else (try zeit.instant(.{ .source = .now })).time();
- // The only difference between a LastFM scrobble and a Spotify scrobble is the format.
- // I've made a branches for each, because doing it all in one made the readability terrible,
- // and formatting the date in particular was challenging. I could probably pull out the
- // actual appending at some point, since that's the same process for each, but I'm not
- // sure how to do that yet.
- switch (source) {
- 0 => {
- const content: ScrobbleTypes.LastFM = try std.json.parseFromSliceLeaky(ScrobbleTypes.LastFM, request.allocator, file.content, .{});
- const before_limiting_date = if (before_limiter and params.get("b") != null) (try zeit.instant(.{ .source = .{ .iso8601 = params.get("b").?.string.value } })).unixTimestamp() * 1000 else 0;
- const after_limiting_date = if (after_limiter and params.get("a") != null) (try zeit.instant(.{ .source = .{ .iso8601 = params.get("a").?.string.value } })).unixTimestamp() * 1000 else 9_223_372_036_854_775_807;
- appends: for (content.scrobbles) |scrobble| {
- // We can short-circuit on the limiter bools
- if ((before_limiter or after_limiter) and (scrobble.date > before_limiting_date or scrobble.date < after_limiting_date)) continue :appends;
- var value = try scrobbles_data.append(.object);
+ const earliest_date = if (params.getT(.boolean, "adv-opt")) |_| blk: {
+ const date = params.getT(.string, "earliest-date").?;
+ break :blk try zeit.Time.fromISO8601(date);
+ } else (try zeit.instant(.{ .source = .{ .unix_timestamp = 0 } })).time();
- // This is so unnecessary, probably useful once I start doing Spotify integration though
- inline for (std.meta.fields(ScrobbleTypes.LastFMScrobble)) |f| {
- try value.put(f.name, @as(f.type, @field(scrobble, f.name)));
- }
- // Note sure why this works for ZMPL, but not for jobs.
- try scrobbles_view.append(scrobble);
- }
- },
- 1 => {
- const content: []ScrobbleTypes.SpotifyScrobble = try std.json.parseFromSliceLeaky([]ScrobbleTypes.SpotifyScrobble, request.allocator, file.content, .{});
- const before_limiting_date: zeit.Time = if (before_limiter) (try zeit.Time.fromISO8601(params.get("b").?.string.value)) else (try zeit.instant(.{})).time();
- const after_limiting_date: zeit.Time = if (after_limiter) (try zeit.Time.fromISO8601(params.get("a").?.string.value)) else (try zeit.instant(.{ .source = .{ .unix_nano = 0 } })).time();
- appends: for (content) |scrobble| {
- // A LastFM Scrobble occurs when half a song has been played
- // or the song plays for 4 minutes, whichever happens first.
- // Spotify considers a song played if it plays for 30 seconds.
- // Ideally, I would go with the LastFM convention, but Spotify
- // history data only gives us so much information. I'm okay
- // with the 30 second convention, but eventually I would prefer
- // to get the song length from MusicBrainz and check if it meets
- // the requirement. Until then, if it goes 30 seconds, or the
- // reason_end field reads "trackdone", then it counts as a Scrobble.
- // May consider giving user control to the minimum millisecond requirement.
- if (scrobble.ms_played < 30_000 and (scrobble.reason_end == null or !std.mem.eql(u8, scrobble.reason_end.?, "trackdone"))) {
- skipped_tracks += 1;
- continue :appends;
- }
- // In the case where the artist is null, but there's other metadata, I could
- // probably let the user edit it in themselves, although I'm not sure if that
- // situation happens.
- if (scrobble.master_metadata_album_artist_name == null or scrobble.master_metadata_track_name == null) {
- skipped_tracks += 1;
- continue :appends;
- }
+ const earliest_timestamp = earliest_date.instant().unixTimestamp();
+ const latest_timestamp = latest_date.instant().unixTimestamp();
- const iso_ts = try zeit.Time.fromISO8601(scrobble.ts);
- if ((before_limiter or after_limiter) and (iso_ts.after(before_limiting_date) or iso_ts.before(after_limiting_date))) {
- limited_tracks += 1;
- continue :appends;
- }
+ var view_params = try root.put("scrobbles", .array);
- // Turn SpotifyScrobble into a LastFM scrobble
- const formatted_scrobble: ScrobbleTypes.LastFMScrobble = .{ .track = scrobble.master_metadata_track_name.?, .album = scrobble.master_metadata_album_album_name.?, .artist = scrobble.master_metadata_album_artist_name.?, .date = (try zeit.instant(.{ .source = .{ .iso8601 = scrobble.ts } })).unixTimestamp() * 1000 };
+ const imported_scrobbles = switch (source) {
+ 0, 1 => (try std.json.parseFromSliceLeaky(Data.ScrobbleArray, request.allocator, if (try request.file("upload")) |file| file.content else unreachable, .{ .ignore_unknown_fields = true })).scrobbles,
+ 2 => blk: {
+ const user_agent: []const u8 = "Zuletzt/0.0.1";
+ var client = Client{ .allocator = request.allocator };
+ var lastfm_response_buffer = std.ArrayList(u8).init(request.allocator);
+ var scrobble_buffer = std.ArrayList(Data.Scrobble).init(request.allocator);
- var value = try scrobbles_data.append(.object);
+ const username = if (params.getT(.string, "username")) |un| un else "VAOTM";
- // This is so unnecessary, probably useful once I start doing Spotify integration though
- inline for (std.meta.fields(ScrobbleTypes.LastFMScrobble)) |f| {
- try value.put(f.name, @as(f.type, @field(formatted_scrobble, f.name)));
- }
- // Note sure why this works for ZMPL, but not for jobs.
- try scrobbles_view.append(formatted_scrobble);
- }
- },
- else => unreachable,
+ const mp_query: []const u8 = try std.fmt.allocPrint(request.allocator, "https://ws.audioscrobbler.com/2.0/?method=user.getrecenttracks&user={s}&api_key=b0c410a48a6078a651e0832699e3cd41&from={}&to={}&page={}&limit=1000&format=json", .{ username, earliest_timestamp, latest_timestamp, 0 });
+ const mp_r = try client.fetch(.{ .response_storage = .{ .dynamic = &lastfm_response_buffer }, .location = .{ .url = mp_query }, .method = .GET, .headers = .{ .user_agent = .{ .override = user_agent } } });
+ std.log.debug("Max page query: {}", .{mp_r});
+ const parsed_mp_response = try std.json.parseFromSliceLeaky(Data.LastFMWeb, request.allocator, (try lastfm_response_buffer.toOwnedSlice()), .{ .ignore_unknown_fields = true });
+
+ var page: usize = 1;
+ const max_pages: usize = try std.fmt.parseInt(usize, parsed_mp_response.recenttracks.@"@attr".totalPages, 10);
+
+ while (true) : (page += 1) {
+ if (page > max_pages) break;
+ const query: []const u8 = try std.fmt.allocPrint(request.allocator, "https://ws.audioscrobbler.com/2.0/?method=user.getrecenttracks&user={s}&api_key=b0c410a48a6078a651e0832699e3cd41&from={}&to={}&page={}&limit=1000&format=json", .{ username, earliest_timestamp, latest_timestamp, page });
+ const r = try client.fetch(.{ .response_storage = .{ .dynamic = &lastfm_response_buffer }, .location = .{ .url = query }, .method = .GET, .headers = .{ .user_agent = .{ .override = user_agent } } });
+ std.log.debug("{}: {}", .{ page, r });
+ const response_string = try lastfm_response_buffer.toOwnedSlice();
+ const parsed_lastfm_response = try std.json.parseFromSliceLeaky(Data.ScrobbleArray, request.allocator, response_string, .{ .ignore_unknown_fields = true });
+ try scrobble_buffer.appendSlice(parsed_lastfm_response.scrobbles);
+ }
+
+ break :blk scrobble_buffer.items;
+ },
+ else => unreachable,
+ };
+
+ var artists = try job.params.put("artists", .object);
+ var albums = try job.params.put("albums", .object);
+ var tracks = try job.params.put("tracks", .object);
+ var artistalbums = try job.params.put("artistalbums", .object);
+ var albumsongs = try job.params.put("albumsongs", .object);
+ var albumsongsartists = try job.params.put("albumsongsartists", .object);
+
+ for (imported_scrobbles) |scrobble| {
+ if (scrobble.date > latest_timestamp * 1_000_000 or scrobble.date < earliest_timestamp * 1_000_000) continue;
+ const complete_scrobble = if (rule_list) |rl| try rules.applyScrobbleRule(request.allocator, scrobble, rl) else scrobble;
+
+ const row = try Utils.scrobbleToRow(request.allocator, complete_scrobble);
+
+ try view_params.append(row);
+ var stored_artist_hashes = std.ArrayList(u64).init(request.allocator);
+
+ var album_hash_string = std.ArrayList(u8).init(request.allocator);
+ for (complete_scrobble.artists_album) |artist| {
+ try album_hash_string.appendSlice(artist);
+ const artist_hash = std.hash.Fnv1a_64.hash(artist);
+ try stored_artist_hashes.append(artist_hash);
+ const signed_hash_string = try std.fmt.allocPrint(request.allocator, "{}", .{@as(i64, @bitCast(artist_hash))});
+ if (artists.get(signed_hash_string) == null) try artists.put(signed_hash_string, artist);
}
- try job.schedule();
- std.log.debug("Skipped {} tracks", .{skipped_tracks});
- std.log.debug("Filtered {} tracks", .{limited_tracks});
- }
- var upload_table = try root.put("upload_table", .array);
- try upload_table.append("Track");
- try upload_table.append("Artist");
- try upload_table.append("Album");
- try upload_table.append("Date");
+ try album_hash_string.appendSlice(complete_scrobble.album);
+ const album_hash = std.hash.Fnv1a_64.hash(album_hash_string.items);
+ const signed_album_hash_string = try std.fmt.allocPrint(request.allocator, "{}", .{@as(i64, @bitCast(album_hash))});
+ if (albums.get(signed_album_hash_string) == null) try albums.put(signed_album_hash_string, complete_scrobble.album);
+
+ for (stored_artist_hashes.items) |artist_hash| {
+ const artistalbum_hash = pair(artist_hash, album_hash);
+ const signed_artistalbums_hash_string = try std.fmt.allocPrint(request.allocator, "{}", .{@as(i64, @bitCast(artistalbum_hash))});
+ if (tracks.get(signed_artistalbums_hash_string) == null) {
+ var artistalbum = try artistalbums.put(signed_artistalbums_hash_string, .object);
+ try artistalbum.put("artist", @as(i64, @bitCast(artist_hash)));
+ try artistalbum.put("album", @as(i64, @bitCast(album_hash)));
+ }
+ }
+
+ var track_hash_string = std.ArrayList(u8).init(request.allocator);
+ try track_hash_string.appendSlice(complete_scrobble.album);
+ try track_hash_string.appendSlice(complete_scrobble.track);
+ const track_hash = std.hash.Fnv1a_64.hash(track_hash_string.items);
+ const signed_track_hash_string = try std.fmt.allocPrint(request.allocator, "{}", .{@as(i64, @bitCast(track_hash))});
+ if (tracks.get(signed_track_hash_string) == null) try tracks.put(signed_track_hash_string, complete_scrobble.track);
+
+ const albumsong_hash = pair(album_hash, track_hash);
+ const signed_albumsong_hash_string = try std.fmt.allocPrint(request.allocator, "{}", .{@as(i64, @bitCast(albumsong_hash))});
+ if (albumsongs.get(signed_albumsong_hash_string)) |albumsong| {
+ var albumsong_scrobbles = albumsong.get("scrobbles");
+ try albumsong_scrobbles.?.append(complete_scrobble.date);
+ } else {
+ var albumsong = try albumsongs.put(signed_albumsong_hash_string, .object);
+ try albumsong.put("album", @as(i64, @bitCast(album_hash)));
+ try albumsong.put("song", @as(i64, @bitCast(track_hash)));
+ var albumsong_scrobbles = try albumsong.put("scrobbles", .array);
+ try albumsong_scrobbles.append(complete_scrobble.date);
+ }
+
+ for (complete_scrobble.artists_track) |artist| {
+ const artist_hash = std.hash.Fnv1a_64.hash(artist);
+ const signed_artist_hash_string = try std.fmt.allocPrint(request.allocator, "{}", .{@as(i64, @bitCast(artist_hash))});
+ if (artists.get(signed_artist_hash_string) == null) try artists.put(signed_artist_hash_string, artist);
+ const albumsongsartist_hash = pair(albumsong_hash, artist_hash);
+ const signed_albumsongsartist_hash_string = try std.fmt.allocPrint(request.allocator, "{}", .{albumsongsartist_hash});
+ if (albumsongsartists.get(signed_albumsongsartist_hash_string) == null) {
+ var albumsongartist = try albumsongsartists.put(signed_albumsongsartist_hash_string, .object);
+ try albumsongartist.put("albumsong", @as(i64, @bitCast(albumsong_hash)));
+ try albumsongartist.put("artist", @as(i64, @bitCast(artist_hash)));
+ }
+ }
+ }
+ try job.schedule();
return request.render(.created);
}
-pub fn put(id: []const u8, request: *jetzig.Request, data: *jetzig.Data) !jetzig.View {
- _ = data;
- _ = id;
- return request.render(.ok);
-}
-
-pub fn patch(id: []const u8, request: *jetzig.Request, data: *jetzig.Data) !jetzig.View {
- _ = data;
- _ = id;
- return request.render(.ok);
-}
-
-pub fn delete(id: []const u8, request: *jetzig.Request, data: *jetzig.Data) !jetzig.View {
- _ = data;
- _ = id;
- return request.render(.ok);
+fn pair(a: u64, b: u64) u64 {
+ return @divFloor((a +% b) *% (a +% b +% 1) +% b, 2);
}
diff --git a/src/app/views/upload/delete.zmpl b/src/app/views/upload/delete.zmpl
deleted file mode 100644
index 76457d0..0000000
--- a/src/app/views/upload/delete.zmpl
+++ /dev/null
@@ -1,3 +0,0 @@
-
- Content goes here
-
diff --git a/src/app/views/upload/get.zmpl b/src/app/views/upload/get.zmpl
deleted file mode 100644
index 76457d0..0000000
--- a/src/app/views/upload/get.zmpl
+++ /dev/null
@@ -1,3 +0,0 @@
-
- Content goes here
-
diff --git a/src/app/views/upload/index.zmpl b/src/app/views/upload/index.zmpl
index 9043a5b..420e08c 100644
--- a/src/app/views/upload/index.zmpl
+++ b/src/app/views/upload/index.zmpl
@@ -9,13 +9,18 @@