+
+
\ No newline at end of file
diff --git a/src/app/views/artists/new.zmpl b/src/app/views/artists/new.zmpl
new file mode 100644
index 0000000..76457d0
--- /dev/null
+++ b/src/app/views/artists/new.zmpl
@@ -0,0 +1,3 @@
+
+ Content goes here
+
diff --git a/src/app/views/artists/patch.zmpl b/src/app/views/artists/patch.zmpl
new file mode 100644
index 0000000..76457d0
--- /dev/null
+++ b/src/app/views/artists/patch.zmpl
@@ -0,0 +1,3 @@
+
+ Content goes here
+
diff --git a/src/app/views/artists/post.zmpl b/src/app/views/artists/post.zmpl
new file mode 100644
index 0000000..76457d0
--- /dev/null
+++ b/src/app/views/artists/post.zmpl
@@ -0,0 +1,3 @@
+
+ Content goes here
+
diff --git a/src/app/views/artists/put.zmpl b/src/app/views/artists/put.zmpl
new file mode 100644
index 0000000..76457d0
--- /dev/null
+++ b/src/app/views/artists/put.zmpl
@@ -0,0 +1,3 @@
+
+
+
\ No newline at end of file
diff --git a/src/app/views/scrobbles/patch.zmpl b/src/app/views/scrobbles/patch.zmpl
new file mode 100644
index 0000000..76457d0
--- /dev/null
+++ b/src/app/views/scrobbles/patch.zmpl
@@ -0,0 +1,3 @@
+
+ Content goes here
+
diff --git a/src/app/views/scrobbles/post.zmpl b/src/app/views/scrobbles/post.zmpl
new file mode 100644
index 0000000..76457d0
--- /dev/null
+++ b/src/app/views/scrobbles/post.zmpl
@@ -0,0 +1,3 @@
+
+ Content goes here
+
diff --git a/src/app/views/scrobbles/put.zmpl b/src/app/views/scrobbles/put.zmpl
new file mode 100644
index 0000000..76457d0
--- /dev/null
+++ b/src/app/views/scrobbles/put.zmpl
@@ -0,0 +1,3 @@
+
+
+
\ No newline at end of file
diff --git a/src/app/views/songs/new.zmpl b/src/app/views/songs/new.zmpl
new file mode 100644
index 0000000..76457d0
--- /dev/null
+++ b/src/app/views/songs/new.zmpl
@@ -0,0 +1,3 @@
+
+ Content goes here
+
diff --git a/src/app/views/songs/patch.zmpl b/src/app/views/songs/patch.zmpl
new file mode 100644
index 0000000..76457d0
--- /dev/null
+++ b/src/app/views/songs/patch.zmpl
@@ -0,0 +1,3 @@
+
+ Content goes here
+
diff --git a/src/app/views/songs/post.zmpl b/src/app/views/songs/post.zmpl
new file mode 100644
index 0000000..76457d0
--- /dev/null
+++ b/src/app/views/songs/post.zmpl
@@ -0,0 +1,3 @@
+
+ Content goes here
+
diff --git a/src/app/views/songs/put.zmpl b/src/app/views/songs/put.zmpl
new file mode 100644
index 0000000..76457d0
--- /dev/null
+++ b/src/app/views/songs/put.zmpl
@@ -0,0 +1,3 @@
+
+ Content goes here
+
diff --git a/src/app/views/upload.zig b/src/app/views/upload.zig
index f712ba4..53f3b27 100644
--- a/src/app/views/upload.zig
+++ b/src/app/views/upload.zig
@@ -1,158 +1,135 @@
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);
- 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,
- });
+ 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;
- 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 scrobbles_view = try root.put("scrobbles", .array);
+ var job = try request.job("process_scrobbles");
+ var scrobbles_data = try job.params.put("scrobbles", .array);
- 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();
+ var skipped_tracks: u64 = 0;
+ var limited_tracks: u64 = 0;
- 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();
+ // 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_timestamp = earliest_date.instant().unixTimestamp();
- const latest_timestamp = latest_date.instant().unixTimestamp();
+ // 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;
+ }
- var view_params = try root.put("scrobbles", .array);
+ 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;
+ }
- 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);
+ // 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 username = if (params.getT(.string, "username")) |un| un else "VAOTM";
+ var value = try scrobbles_data.append(.object);
- 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 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)));
- }
+ // 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,
}
+ try job.schedule();
+ std.log.debug("Skipped {} tracks", .{skipped_tracks});
+ std.log.debug("Filtered {} tracks", .{limited_tracks});
}
- try job.schedule();
+
+ 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");
return request.render(.created);
}
-fn pair(a: u64, b: u64) u64 {
- return @divFloor((a +% b) *% (a +% b +% 1) +% b, 2);
+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);
}
diff --git a/src/app/views/upload/delete.zmpl b/src/app/views/upload/delete.zmpl
new file mode 100644
index 0000000..76457d0
--- /dev/null
+++ b/src/app/views/upload/delete.zmpl
@@ -0,0 +1,3 @@
+
+ Content goes here
+
diff --git a/src/app/views/upload/get.zmpl b/src/app/views/upload/get.zmpl
new file mode 100644
index 0000000..76457d0
--- /dev/null
+++ b/src/app/views/upload/get.zmpl
@@ -0,0 +1,3 @@
+