feat(generator): add

.dockerignore

@@ -5,3 +5,4 @@ node_modules/
 .gitignore
 Dockerfile
 README.md
+screenshots/

README.md

@@ -45,10 +45,10 @@ A web application to help organize and automate your Spotify playlists.
   An overview of your history.
   It will show any track that you listened to or was played in a jam that you were a part of.
 
-  A track is only counted as played after you listened to it for at least 20 seconds, however
-  due to the internal workings of the application it can be up to 40 seconds before a track is considered played.
+  Sortifyr will track all the data is needs in the background however it can not access any past data.
+  In the settings page you can find instructions how you can upload all your historic Spotify data.
 
-  In the settings page you can upload all your historic Spotify data.
+  It's highly recommended to do so.
 
   ![Track history](./screenshots/track_history.png)
 </details>

cmd/api/main.go

@@ -4,9 +4,11 @@ import (
 	"fmt"
 
 	"github.com/topvennie/sortifyr/internal/database/repository"
+	"github.com/topvennie/sortifyr/internal/generator"
 	"github.com/topvennie/sortifyr/internal/server"
 	"github.com/topvennie/sortifyr/internal/server/service"
-	"github.com/topvennie/sortifyr/internal/spotify"
+	"github.com/topvennie/sortifyr/internal/spotifyapi"
+	"github.com/topvennie/sortifyr/internal/spotifysync"
 	"github.com/topvennie/sortifyr/internal/task"
 	"github.com/topvennie/sortifyr/pkg/config"
 	"github.com/topvennie/sortifyr/pkg/db"
@@ -48,8 +50,16 @@ func main() {
 		zap.S().Fatalf("Failed to init the task package %v", err)
 	}
 
-	if err := spotify.Init(*repo); err != nil {
-		zap.S().Fatalf("Failed to init the spotify package %v", err)
+	if err := spotifyapi.Init(); err != nil {
+		zap.S().Fatalf("Failed to init the spotify api package %v", err)
+	}
+
+	if err := spotifysync.Init(*repo); err != nil {
+		zap.S().Fatalf("Failed to init the spotify sync package %v", err)
+	}
+
+	if err := generator.Init(*repo); err != nil {
+		zap.S().Fatalf("Failed to init the generator package %v", err)
 	}
 
 	api := server.New(*service, db.Pool())

db/migrations/20251230104421_alter_history_add_skipped.sql

@@ -0,0 +1,17 @@
+-- +goose Up
+-- +goose StatementBegin
+ALTER TABLE history
+ADD COLUMN skipped BOOLEAN;
+
+ALTER TABLE tracks
+ADD COLUMN duration_ms INTEGER;
+-- +goose StatementEnd
+
+-- +goose Down
+-- +goose StatementBegin
+ALTER TABLE tracks
+DROP COLUMN duration_ms;
+
+ALTER TABLE history
+DROP COLUMN skipped;
+-- +goose StatementEnd

db/migrations/20251231183248_add_generator_table.sql

@@ -0,0 +1,27 @@
+-- +goose Up
+-- +goose StatementBegin
+CREATE TABLE generators (
+  id SERIAL PRIMARY KEY,
+  user_id INTEGER NOT NULL REFERENCES users (id) ON DELETE CASCADE,
+  name TEXT NOT NULL,
+  description TEXT,
+  playlist_id INTEGER REFERENCES playlists (id),
+  interval BIGINT,
+  spotify_outdated BOOLEAN NOT NULL,
+  parameters JSONB,
+  updated_at TIMESTAMPTZ NOT NULL
+);
+
+CREATE TABLE generator_tracks (
+  id SERIAL PRIMARY KEY,
+  generator_id INTEGER NOT NULL REFERENCES generators (id) ON DELETE CASCADE,
+  track_id INTEGER NOT NULL REFERENCES tracks (id) ON DELETE CASCADE
+);
+-- +goose StatementEnd
+
+-- +goose Down
+-- +goose StatementBegin
+DROP TABLE generator_tracks;
+
+DROP TABLE generators;
+-- +goose StatementEnd

db/queries/generator.sql

@@ -0,0 +1,40 @@
+-- name: GeneratorGet :one
+SELECT *
+FROM generators
+WHERE id = $1;
+
+-- name: GeneratorGetAll :many
+SELECT sqlc.embed(g), sqlc.embed(u)
+FROM generators g
+LEFT JOIN users u ON u.id = g.user_id;
+
+-- name: GeneratorGetByUserPopulated :many
+SELECT
+  sqlc.embed(g),
+  COALESCE(json_agg(t.*) FILTER (WHERE t.id IS NOT NULL), '[]')::jsonb AS tracks
+FROM generators g
+LEFT JOIN generator_tracks gt ON gt.generator_id = g.id
+LEFT JOIN tracks t ON t.id = gt.track_id
+WHERE g.user_id = $1
+GROUP BY g.id;
+
+-- name: GeneratorCreate :one
+INSERT INTO generators (user_id, name, description, playlist_id, interval, spotify_outdated, parameters, updated_at)
+VALUES ($1, $2, $3, $4, $5, $6, $7, NOW())
+RETURNING id;
+
+-- name: GeneratorUpdate :exec
+UPDATE generators
+SET 
+  name = coalesce(sqlc.narg('name'), name),
+  description = coalesce(sqlc.narg('description'), description),
+  playlist_id = sqlc.narg('playlist_id'),
+  interval = coalesce(sqlc.narg('interval'), interval),
+  spotify_outdated = coalesce(sqlc.narg('spotify_outdated'), spotify_outdated),
+  parameters = coalesce(sqlc.narg('parameters'), parameters),
+  updated_at = NOW()
+WHERE id = $1;
+
+-- name: GeneratorDelete :exec
+DELETE FROM generators
+WHERE id = $1;

db/queries/generator_track.sql

@@ -0,0 +1,10 @@
+-- name: GeneratorTrackCreateBatch :exec
+INSERT INTO generator_tracks (generator_id, track_id)
+VALUES (
+  UNNEST($1::int[]),
+  UNNEST($2::int[])
+);
+
+-- name: GeneratorTrackDeleteByGenerator :exec
+DELETE FROM generator_tracks
+WHERE generator_id = $1;

db/queries/history.sql

@@ -1,34 +1,62 @@
--- name: HistoryGetLatestByUser :one
-SELECT *
-FROM history
-WHERE user_id = $1
-ORDER BY played_at DESC
+-- name: HistoryGetPreviousPopulated :one
+SELECT sqlc.embed(h), sqlc.embed(t)
+FROM history h
+LEFT JOIN tracks t ON t.id = h.track_id
+WHERE h.played_at < $1 AND h.user_id = $2
+ORDER BY h.played_at DESC
 LIMIT 1;
 
--- name: HistoryGetPopulatedFiltered :many
-SELECT sqlc.embed(h), sqlc.embed(t)
+-- name: HistoryGetPopulatedFilteredPaginated :many
+SELECT sqlc.embed(h), sqlc.embed(t), count(*) FILTER (WHERE h.user_id = $1::int AND (h.skipped = $7::boolean OR NOT @filter_play_count)) OVER  (PARTITION BY h.track_id) AS play_count
 FROM history h
 LEFT JOIN tracks t ON t.id = h.track_id
 WHERE 
   h.user_id = $1::int AND
   (h.played_at >= $4::timestamptz OR NOT @filter_start) AND 
-  (h.played_at <= $5::timestamptz OR NOT @filter_end)
+  (h.played_at <= $5::timestamptz OR NOT @filter_end) AND
+  (h.skipped = $6::boolean OR NOT @filter_skipped)
 ORDER BY h.played_at DESC
 LIMIT $2 OFFSET $3;
+
+-- name: HistoryGetPopulatedFiltered :many
+SELECT sqlc.embed(h), sqlc.embed(t)
+FROM history h
+LEFT JOIN tracks t ON t.id = h.track_id
+WHERE 
+  h.user_id = $1::int AND
+  (h.played_at >= $2::timestamptz OR NOT @filter_start) AND 
+  (h.played_at <= $3::timestamptz OR NOT @filter_end) AND
+  (h.skipped = $4::boolean OR NOT @filter_skipped)
+ORDER BY h.played_at DESC;
+
+-- name: HistoryGetSkippedNullPopulated :many
+SELECT sqlc.embed(h), sqlc.embed(t)
+FROM history h
+LEFT JOIN tracks t ON t.id = h.track_id
+WHERE h.skipped IS NULL AND h.user_id = $1
+ORDER BY played_at ASC;
 
 -- name: HistoryCreate :one
-INSERT INTO history (user_id, track_id, played_at, album_id, artist_id, playlist_id, show_id)
-VALUES ($1, $2, $3, $4, $5, $6, $7)
+INSERT INTO history (user_id, track_id, played_at, album_id, artist_id, playlist_id, show_id, skipped)
+VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
 RETURNING id;
 
 -- name: HistoryCreateBatch :exec
-INSERT INTO history (user_id, track_id, played_at)
+INSERT INTO history (user_id, track_id, played_at, skipped)
 VALUES (
   UNNEST($1::int[]),
   UNNEST($2::int[]),
-  UNNEST($3::timestamptz[])
+  UNNEST($3::timestamptz[]),
+  UNNEST($4::boolean[])
 );
 
+-- name: HistoryUpdate :exec
+UPDATE history
+SET 
+  played_at = coalesce(sqlc.narg('played_at'), played_at),
+  skipped = coalesce(sqlc.narg('skipped'), skipped)
+WHERE id = $1;
+
 -- name: HistoryDeleteUserOlder :exec
 DELETE FROM history
 WHERE user_id = $1 AND played_at < $2;

db/queries/playlist.sql

@@ -15,7 +15,6 @@ LEFT JOIN playlist_users pu ON pu.playlist_id = p.id
 WHERE pu.user_id = $1 AND pu.deleted_at IS NULL
 ORDER BY p.name;
 
-
 -- name: PlaylistGetByUserWithOwner :many
 SELECT sqlc.embed(p), sqlc.embed(u)
 FROM playlists p

db/queries/playlist_track.sql

@@ -1,3 +1,8 @@
+-- name: PlaylistTrackGetByPlaylistIds :many
+SELECT *
+FROM playlist_tracks
+WHERE playlist_id = ANY($1::int[]);
+
 -- name: PlaylistTrackCreate :one
 INSERT INTO playlist_tracks (playlist_id, track_id)
 VALUES ($1, $2)

db/queries/track.sql

@@ -2,6 +2,11 @@
 SELECT *
 FROM tracks;
 
+-- name: TrackGetAllById :many
+SELECT *
+FROM tracks
+WHERE id = ANY($1::int[]);
+
 -- name: TrackGetBySpotify :one
 SELECT *
 FROM tracks
@@ -23,6 +28,13 @@ FROM tracks t
 LEFT JOIN playlist_tracks pt ON pt.track_id = t.id
 WHERE pt.playlist_id = $1 AND pt.deleted_at IS NULL;
 
+-- name: TrackGetByGenerator :many
+SELECT t.*
+FROM tracks t
+LEFT JOIN generator_tracks gt ON gt.track_id = t.id
+WHERE gt.generator_id = $1
+ORDER BY t.name;
+
 -- name: TrackGetCreatedFilteredPopulated :many
 SELECT sqlc.embed(t), sqlc.embed(pt), sqlc.embed(p), sqlc.embed(u)
 FROM tracks t
@@ -51,16 +63,16 @@ WHERE
 ORDER BY pt.deleted_at DESC
 LIMIT $1 OFFSET $2;
 
-
 -- name: TrackCreate :one
-INSERT INTO tracks (spotify_id, name, popularity)
-VALUES ($1, $2, $3)
+INSERT INTO tracks (spotify_id, name, popularity, duration_ms)
+VALUES ($1, $2, $3, $4)
 RETURNING id;
 
 -- name: TrackUpdate :exec
 UPDATE tracks
 SET
   name = coalesce(sqlc.narg('name'), name),
   popularity = coalesce(sqlc.narg('popularity'), popularity),
+  duration_ms = coalesce(sqlc.narg('duration_ms'), duration_ms),
   updated_at = NOW()
 WHERE id = $1;

internal/database/model/generator.go

@@ -0,0 +1,83 @@
+package model
+
+import (
+	"encoding/json"
+	"time"
+
+	"github.com/topvennie/sortifyr/pkg/sqlc"
+)
+
+type GeneratorPreset string
+
+const (
+	GeneratorPresetTop    GeneratorPreset = "top"
+	GeneratorPresetOldTop GeneratorPreset = "old_top"
+)
+
+// We need json tags because the params are saved as jsonb
+
+type GeneratorWindow struct {
+	Start         time.Time     `json:"start"`
+	End           time.Time     `json:"end"`
+	MinPlays      int           `json:"min_plays"`
+	BurstInterval time.Duration `json:"burst_interval"`
+}
+
+type GeneratorPresetTopParams struct {
+	Window GeneratorWindow `json:"window"`
+}
+
+type GeneratorPresetOldTopParams struct {
+	PeakWindow   GeneratorWindow `json:"peak_window"`
+	RecentWindow GeneratorWindow `json:"recent_window"`
+}
+
+type GeneratorParams struct {
+	TrackAmount         int   `json:"track_amount"`
+	ExcludedPlaylistIDs []int `json:"excluded_playlist_ids"`
+	ExcludedTrackIDs    []int `json:"excluded_track_ids"`
+
+	Preset GeneratorPreset `json:"preset"`
+
+	ParamsTop    *GeneratorPresetTopParams    `json:"params_top,omitzero"`
+	ParamsOldTop *GeneratorPresetOldTopParams `json:"params_old_top,omitzero"`
+}
+
+type Generator struct {
+	ID              int
+	UserID          int
+	Name            string
+	Description     string
+	PlaylistID      int
+	Interval        time.Duration
+	SpotifyOutdated bool
+	Params          GeneratorParams
+	UpdatedAt       time.Time
+
+	// Non db fields
+	User   User
+	Tracks []Track
+}
+
+func GeneratorModel(g sqlc.Generator) *Generator {
+	params := GeneratorParams{}
+	_ = json.Unmarshal(g.Parameters, &params) // nolint:errcheck // Data controlled by us, it'll be fine, ...right?
+
+	return &Generator{
+		ID:              int(g.ID),
+		UserID:          int(g.UserID),
+		Name:            g.Name,
+		Description:     fromString(g.Description),
+		PlaylistID:      fromInt(g.PlaylistID),
+		Interval:        fromDuration(g.Interval),
+		SpotifyOutdated: g.SpotifyOutdated,
+		Params:          params,
+		UpdatedAt:       g.UpdatedAt.Time,
+	}
+}
+
+type GeneratorTrack struct {
+	ID          int
+	GeneratorID int
+	TrackID     int
+}