resume, nocrash

.gitignore

@@ -1 +1,2 @@
 **/*.sw*
+/jellyfin-user-clone

go.mod

@@ -4,16 +4,23 @@ go 1.23.0
 
 toolchain go1.23.9
 
-require modernc.org/sqlite v1.37.1
+require (
+	github.com/glebarez/sqlite v1.11.0
+	github.com/google/uuid v1.6.0
+	modernc.org/sqlite v1.37.1 // indirect
+)
 
 require (
 	github.com/dustin/go-humanize v1.0.1 // indirect
-	github.com/google/uuid v1.6.0 // indirect
+	github.com/glebarez/go-sqlite v1.21.2 // indirect
+	github.com/jinzhu/inflection v1.0.0 // indirect
+	github.com/jinzhu/now v1.1.5 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/ncruces/go-strftime v0.1.9 // indirect
 	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
 	golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0 // indirect
 	golang.org/x/sys v0.33.0 // indirect
+	gorm.io/gorm v1.25.7 // indirect
 	modernc.org/libc v1.65.7 // indirect
 	modernc.org/mathutil v1.7.1 // indirect
 	modernc.org/memory v1.11.0 // indirect

go.sum

@@ -1,9 +1,17 @@
 github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
 github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
+github.com/glebarez/go-sqlite v1.21.2 h1:3a6LFC4sKahUunAmynQKLZceZCOzUthkRkEAl9gAXWo=
+github.com/glebarez/go-sqlite v1.21.2/go.mod h1:sfxdZyhQjTM2Wry3gVYWaW072Ri1WMdWJi0k6+3382k=
+github.com/glebarez/sqlite v1.11.0 h1:wSG0irqzP6VurnMEpFGer5Li19RpIRi2qvQz++w0GMw=
+github.com/glebarez/sqlite v1.11.0/go.mod h1:h8/o8j5wiAsqSPoWELDUdJXhjAhsVliSn7bWZjOhrgQ=
 github.com/google/pprof v0.0.0-20250317173921-a4b03ec1a45e h1:ijClszYn+mADRFY17kjQEVQ1XRhq2/JR1M3sGqeJoxs=
 github.com/google/pprof v0.0.0-20250317173921-a4b03ec1a45e/go.mod h1:boTsfXsheKC2y+lKOCMpSfarhxDeIzfZG1jqGcPl3cA=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E=
+github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc=
+github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ=
+github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/ncruces/go-strftime v0.1.9 h1:bY0MQC28UADQmHmaF5dgpLmImcShSi2kHU9XLdhx/f4=
@@ -21,6 +29,8 @@ golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
 golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
 golang.org/x/tools v0.33.0 h1:4qz2S3zmRxbGIhDIAgjxvFutSvH5EfnsYrRBj0UI0bc=
 golang.org/x/tools v0.33.0/go.mod h1:CIJMaWEY88juyUfo7UbgPqbC8rU2OqfAV1h2Qp0oMYI=
+gorm.io/gorm v1.25.7 h1:VsD6acwRjz2zFxGO50gPO6AkNs7KKnvfzUjHQhZDz/A=
+gorm.io/gorm v1.25.7/go.mod h1:hbnx/Oo0ChWMn1BIhpy1oYozzpM15i4YPuHDmfYtwg8=
 modernc.org/cc/v4 v4.26.1 h1:+X5NtzVBn0KgsBCBe+xkDC7twLb/jNVj9FPgiwSQO3s=
 modernc.org/cc/v4 v4.26.1/go.mod h1:uVtb5OGqUKpoLWhqwNQo/8LwvoiEBLvZXIQ/SmO6mL0=
 modernc.org/ccgo/v4 v4.28.0 h1:rjznn6WWehKq7dG4JtLRKxb52Ecv8OUGah8+Z/SfpNU=

main.go

@@ -1,170 +1,265 @@
 package main
 
 import (
-	"database/sql"
+	"bytes"
+	"context"
+	"encoding/json"
 	"fmt"
 	"io"
-	"io/ioutil"
 	"log"
+	"net/http"
 	"os"
-	"path"
-	"slices"
-	"strings"
-
-	_ "modernc.org/sqlite"
-)
-
-const (
-	jellyDB   = "jellyfin.db"
-	libraryDB = "library.db"
+	"os/signal"
+	"syscall"
+	"time"
 )
 
 func main() {
-	data := os.Args[1]
-	fromU := os.Args[2]
-	toU := os.Args[3]
-	_ = toU
+	ctx, can := signal.NotifyContext(context.Background(), syscall.SIGINT)
+	defer can()
 
-	workd, err := ioutil.TempDir(os.TempDir(), "jellyfin-user-clone.*")
+	jellyFrom, err := NewJelly(ctx, "squeaky2x3", "aFJKcZ4fUuN9FZ", "5c1de748f61145a085f272aea527c759", "213abf9acbe84d9fb9c3b06bbe1eec3b")
 	if err != nil {
-		panic(err)
+		log.Fatal(err)
 	}
+	log.Printf("from %+v", jellyFrom)
 
-	{
-		if err := cp(path.Join(data, jellyDB), path.Join(workd, jellyDB)); err != nil {
-			panic(err)
-		} else if err := cp(path.Join(data, libraryDB), path.Join(workd, libraryDB)); err != nil {
-			panic(err)
-		}
-	}
-
-	jellyfinDB, err := sql.Open("sqlite", path.Join(workd, jellyDB))
+	jellyTo, err := NewJelly(ctx, "belly", "qBentOcpHMUjhD", "497b212a22e34b54be091055edbe264d", "b71b931108ba4323b75b675871a7738f")
 	if err != nil {
-		panic(err)
+		log.Fatal(err)
 	}
-	defer jellyfinDB.Close()
+	log.Printf("to   %+v", jellyTo)
 
-	fromUUID, err := SelectOne[string](jellyfinDB, `SELECT Id FROM Users WHERE Username = $1`, fromU)
+	folders, err := jellyFrom.VirtualFolders(ctx)
 	if err != nil {
-		panic(err)
+		log.Fatal(err)
 	}
-	fromID, err := SelectOne[int](jellyfinDB, `SELECT InternalId FROM Users WHERE Id = $1`, fromUUID)
-	if err != nil {
-		panic(err)
-	}
-	log.Println(fromU, fromUUID, fromID)
+	for len(folders) > 0 {
+		folder := folders[0]
+		folders = folders[1:]
 
-	if n, err := SelectOne[int](jellyfinDB, `SELECT COUNT(*) FROM Users WHERE Username = $1`, toU); err != nil {
-		panic(err)
-	} else if n == 1 {
-	} else if err := Exec(jellyfinDB, `INSERT INTO Users () SELECT * FROM Users WHERE Id = $1`, fromUUID); err != nil {
-		panic(err)
-	}
-
-	panic("not impl get toU, toUUID")
-
-	tables, err := Tables(jellyfinDB)
-	if err != nil {
-		panic(err)
-	}
-
-	for _, table := range tables {
-		columns, err := Columns(jellyfinDB, table)
+		items, err := jellyFrom.ListFolder(ctx, folder)
 		if err != nil {
-			panic(err)
-		}
-		log.Println(table, columns)
-
-		userColumns := slices.DeleteFunc(slices.Clone(columns), func(s string) bool {
-			return !slices.Contains([]string{
-				"user",
-				"userid",
-			}, strings.ToLower(s))
-		})
-		if len(userColumns) == 0 {
-			continue
+			log.Fatal(err)
 		}
 
-		for _, column := range userColumns {
-			if n, err := SelectOne[int](jellyfinDB, fmt.Sprintf(`SELECT COUNT(*) FROM %q WHERE %q = $1`, table, column), fromID); err != nil {
-				panic(err)
-			} else if n > 0 {
-				notThisColumn := strings.Join(slices.DeleteFunc(slices.Clone(columns), func(s string) bool { return s == column }), ", ")
-				if err := Exec(jellyfinDB, fmt.Sprintf(`INSERT INTO %q (%q, %s) SELECT $2, %s FROM %q WHERE %q = $1`, table, column, notThisColumn, notThisColumn, table, column), fromID, toID); err != nil {
-					panic(err)
-				}
-			} else if n, err := SelectOne[int](jellyfinDB, fmt.Sprintf(`SELECT COUNT(*) FROM %q WHERE %q = $1`, table, column), fromUUID); err != nil {
-				panic(err)
-			} else if n > 0 {
-				panic("not impl: col is uuid")
+		for _, item := range items {
+			if item.IsFolder {
+				folders = append([]FolderItem{item}, folders...)
+			} else if userData, err := jellyFrom.UserDataOf(ctx, item); err != nil {
+				log.Fatal(err)
+			} else if userData.PlayCount == 0 && userData.PlaybackPositionTicks == 0 {
+			} else if userDataB, err := jellyTo.UserDataOf(ctx, item); err != nil {
+				log.Fatal(err)
+			} else if userDataB == userData.Plus(userDataB) {
+				log.Printf("skipping noop %+v", userData)
+			} else if err := jellyTo.SetUserData(ctx, userData.Plus(userDataB)); err != nil {
+				log.Fatalf("failed to set user data of %+v: %v", userData, err)
 			}
 		}
-
-		log.Println(table, userColumns)
-		panic("not impl")
 	}
 }
 
-func cp(from, to string) error {
-	fromF, err := os.Open(from)
-	if err != nil {
-		return err
-	}
-	defer fromF.Close()
-
-	toF, err := os.Create(to)
-	if err != nil {
-		return err
-	}
-	defer toF.Close()
-
-	_, err = io.Copy(toF, fromF)
-	return err
+type Jelly struct {
+	u           string
+	apitoken    string
+	accesstoken string
 }
 
-func Tables(db *sql.DB) ([]string, error) {
-	return Select[string](jellyfinDB, `SELECT name FROM sqlite_schema WHERE type = 'table' AND name NOT LIKE 'sqlite_%'`)
-}
+func NewJelly(ctx context.Context, u, p, apitoken, optAccessToken string) (Jelly, error) {
+	jelly := Jelly{u: u, apitoken: apitoken, accesstoken: optAccessToken}
 
-func Columns(db *sql.DB, table string) ([]string, error) {
-	return Select[string](jellyfinDB, `SELECT name FROM PRAGMA_TABLE_INFO($1)`, table)
-}
-
-func Exec(db *sql.DB, q string, args ...any) error {
-	_, err := db.Exec(q, args...)
-	return err
-}
-
-func SelectOne[T any](db *sql.DB, q string, args ...any) (T, error) {
-	var some T
-
-	results, err := Select[T](db, q, args...)
-	if err != nil {
-		return some, err
+	if optAccessToken != "" {
+	} else if accessToken, err := jelly.Login(ctx, p); err != nil {
+		return Jelly{}, err
+	} else {
+		jelly.accesstoken = accessToken
 	}
 
-	if len(results) != 1 {
-		return some, fmt.Errorf("expected 1 result but got %d (%+v)", len(results), results)
-	}
-
-	return results[0], nil
+	return jelly, nil
 }
 
-func Select[T any](db *sql.DB, q string, args ...any) ([]T, error) {
-	rows, err := db.Query(q, args...)
+type FolderItem struct {
+	Name     string
+	Id       string
+	IsFolder bool
+	Parent   *FolderItem
+}
+
+func (jelly Jelly) ListFolder(ctx context.Context, folder FolderItem) ([]FolderItem, error) {
+	resp, err := jelly.do(ctx, http.MethodGet, fmt.Sprintf("/Items?parentId=%s", folder.Id), nil)
 	if err != nil {
 		return nil, err
 	}
-	defer rows.Close()
-
-	results := []T{}
-	for rows.Next() {
-		var some T
-		if err := rows.Scan(&some); err != nil {
-			return nil, err
+	a := resp.(map[string]any)["Items"].([]any)
+	result := make([]FolderItem, len(a))
+	for i := range a {
+		m := a[i].(map[string]any)
+		name, _ := m["Name"].(string)
+		id, _ := m["Id"].(string)
+		isFolder, _ := m["IsFolder"].(bool)
+		result[i] = FolderItem{
+			Name:     name,
+			Id:       id,
+			IsFolder: isFolder,
+			Parent:   &folder,
 		}
-		results = append(results, some)
+	}
+	return result, nil
+}
+
+// get+set item via /UserItems/{itemId}/UserData
+
+type UserData struct {
+	IsFavorite            bool
+	ItemId                string
+	Key                   string
+	PlayCount             float64
+	PlaybackPositionTicks float64
+	Played                bool
+	FolderItem            FolderItem `json:",omitempty"`
+}
+
+func (this UserData) Plus(that UserData) UserData {
+	this.IsFavorite = this.IsFavorite || that.IsFavorite
+	//this.ItemId
+	//this.Key
+	if this.PlayCount < that.PlayCount {
+		this.PlayCount = that.PlayCount
+	}
+	if this.PlaybackPositionTicks < that.PlaybackPositionTicks {
+		this.PlaybackPositionTicks = that.PlaybackPositionTicks
+	}
+	this.Played = this.Played || that.Played
+	return this
+}
+
+func (jelly Jelly) SetUserData(ctx context.Context, userData UserData) error {
+	fi := userData.FolderItem
+	if os.Getenv("DRY_RUN") != "false" {
+		b, _ := json.Marshal(userData)
+		log.Printf("SET %s", b)
+		return nil
+	}
+	userData.FolderItem = FolderItem{}
+	b, _ := json.Marshal(userData)
+	log.Printf("SET %s", b)
+	_, err := jelly.do(ctx, http.MethodPost, "/UserItems/"+fi.Id+"/UserData", userData)
+	return err
+}
+
+func (jelly Jelly) UserDataOf(ctx context.Context, folderItem FolderItem) (UserData, error) {
+	resp, err := jelly.do(ctx, http.MethodGet, "/UserItems/"+folderItem.Id+"/UserData", nil)
+	if err != nil {
+		return UserData{}, err
+	}
+	return UserData{
+		IsFavorite:            resp.(map[string]any)["IsFavorite"].(bool),
+		ItemId:                resp.(map[string]any)["ItemId"].(string),
+		Key:                   resp.(map[string]any)["Key"].(string),
+		PlayCount:             resp.(map[string]any)["PlayCount"].(float64),
+		PlaybackPositionTicks: resp.(map[string]any)["PlaybackPositionTicks"].(float64),
+		Played:                resp.(map[string]any)["Played"].(bool),
+		FolderItem:            folderItem,
+	}, nil
+}
+
+func (jelly Jelly) VirtualFolders(ctx context.Context) ([]FolderItem, error) {
+	resp, err := jelly.do(ctx, http.MethodGet, "/Library/VirtualFolders", nil)
+	if err != nil {
+		return nil, err
 	}
 
-	return results, rows.Err()
+	a := resp.([]any)
+	result := make([]FolderItem, len(a))
+	for i, v := range a {
+		m := v.(map[string]any)
+		result[i] = FolderItem{
+			Id:       m["ItemId"].(string),
+			Name:     m["Name"].(string),
+			IsFolder: true,
+		}
+	}
+	return result, nil
+}
+
+func (jelly Jelly) Login(ctx context.Context, p string) (string, error) {
+	resp, err := jelly.post(ctx, "/Users/AuthenticateByName", map[string]string{
+		"Username": jelly.u,
+		"Pw":       p,
+	}, "Authorization", jelly._authHeader(jelly.apitoken))
+	if err != nil {
+		return "", err
+	}
+
+	m, _ := resp.(map[string]any)
+	if m == nil {
+		return "", fmt.Errorf("no map response")
+	}
+	token, _ := m["AccessToken"]
+	if token == nil {
+		return "", fmt.Errorf("no .AccessToken response")
+	}
+	s, _ := token.(string)
+	return s, nil
+}
+
+func (jelly Jelly) post(ctx context.Context, path string, body any, headers ...string) (any, error) {
+	return jelly.do(ctx, http.MethodPost, path, body, headers...)
+}
+
+func (jelly Jelly) do(ctx context.Context, method, path string, body any, headers ...string) (any, error) {
+	resp, err := jelly._do(ctx, method, path, body, headers...)
+	if err != nil {
+		return nil, err
+	}
+	var result any
+	err = json.NewDecoder(resp.Body).Decode(&result)
+	return result, err
+}
+
+func (jelly Jelly) _do(ctx context.Context, method, path string, body any, headers ...string) (*http.Response, error) {
+	t := http.Transport{
+		DisableKeepAlives: true,
+	}
+	c := http.Client{
+		Timeout:   time.Minute,
+		Transport: &t,
+	}
+
+	b, _ := json.Marshal(body)
+	req, err := http.NewRequest(method, fmt.Sprintf("https://jellyfin.home.blapointe.com%s", path), bytes.NewReader(b))
+	if err != nil {
+		return nil, err
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Authorization", jelly.authHeader())
+	req = req.WithContext(ctx)
+	for i := 0; i+1 < len(headers); i += 2 {
+		req.Header.Set(headers[i], headers[i+1])
+	}
+
+	resp, err := c.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	b, _ = io.ReadAll(resp.Body)
+	resp.Body = io.NopCloser(bytes.NewReader(b))
+
+	if resp.StatusCode >= 400 {
+		return nil, fmt.Errorf("(%d) %s", resp.StatusCode, b)
+	}
+
+	return resp, nil
+}
+
+func (jelly Jelly) authHeader() string {
+	return jelly._authHeader(jelly.accesstoken)
+}
+
+func (jelly Jelly) _authHeader(token string) string {
+	return fmt.Sprintf("MediaBrowser Token=%q, Client=%q, Version=%q, DeviceId=%q, Device=%q", token, "client", "version", "deviceId"+jelly.u, "device")
 }