Lidarr manual import + go/lint updates (#188)

* lidarr manual import

* bump go, fix linter

* fix types for duration in audio/book tracks

* improve marshaller, add tests

Author: davidnewhall

.github/workflows/codetests.yml

@@ -49,7 +49,7 @@ jobs:
       - name: golangci-lint
         uses: golangci/golangci-lint-action@v9
         with:
-          version: v2.3
+          version: v2.9
   # Runs golangci-lint on linux against linux and windows.
   golangci-linux:
     strategy:
@@ -67,4 +67,4 @@ jobs:
       - name: golangci-lint
         uses: golangci/golangci-lint-action@v9
         with:
-          version: v2.3
+          version: v2.9

.golangci.yml

@@ -9,6 +9,10 @@ linters:
     - tagliatelle
     - noinlineerr
     - wsl
+    # fix these
+    - modernize
+    - perfsprint
+    - godoclint
   settings:
     wsl_v5:
       allow-first-in-block: true

go.mod

@@ -1,6 +1,8 @@
 module golift.io/starr
 
-go 1.24.0
+go 1.25.7
+
+toolchain go1.26.0
 
 require golang.org/x/net v0.49.0 // publicsuffix, cookiejar.
 

helpers.go

@@ -59,6 +59,7 @@ func ClientWithDebug(timeout time.Duration, verifySSL bool, logConfig debuglog.C
 }
 
 // Itoa converts an int64 to a string.
+//
 // Deprecated: Use starr.Str() instead.
 func Itoa(v int64) string {
 	return Str(v)
@@ -101,12 +102,14 @@ func False() *bool {
 }
 
 // String returns a pointer to a string.
+//
 // Deprecated: Use Ptr() function instead.
 func String(s string) *string {
 	return &s
 }
 
 // Int64 returns a pointer to the provided integer.
+//
 // Deprecated: Use Ptr() function instead.
 func Int64(s int64) *int64 {
 	return &s

lidarr/command.go

@@ -23,24 +23,46 @@ type CommandRequest struct {
 	ArtistID int64    `json:"artistId,omitempty"`
 }
 
+// ManualImportFile is one file in a ManualImport command request.
+type ManualImportFile struct {
+	Path                    string         `json:"path"`
+	ArtistID                int64          `json:"artistId"`
+	AlbumID                 int64          `json:"albumId"`
+	AlbumReleaseID          int64          `json:"albumReleaseId"`
+	TrackIDs                []int64        `json:"trackIds"`
+	Quality                 *starr.Quality `json:"quality"`
+	IndexerFlags            int            `json:"indexerFlags"`
+	DownloadID              string         `json:"downloadId"`
+	DisableReleaseSwitching bool           `json:"disableReleaseSwitching"`
+}
+
+// ManualImportCommandRequest is the body for the ManualImport command (POST /api/v1/command).
+// It triggers Lidarr to import the listed files.
+type ManualImportCommandRequest struct {
+	Name                 string              `json:"name"` // "ManualImport"
+	Files                []*ManualImportFile `json:"files"`
+	ImportMode           string              `json:"importMode"` // "auto"
+	ReplaceExistingFiles bool                `json:"replaceExistingFiles"`
+}
+
 // CommandResponse comes from the /api/v1/command endpoint.
 type CommandResponse struct {
-	ID                  int64                  `json:"id"`
-	Name                string                 `json:"name"`
-	CommandName         string                 `json:"commandName"`
-	Message             string                 `json:"message,omitempty"`
-	Priority            string                 `json:"priority"`
-	Status              string                 `json:"status"`
-	Queued              time.Time              `json:"queued"`
-	Started             time.Time              `json:"started,omitempty"`
-	Ended               time.Time              `json:"ended,omitempty"`
-	StateChangeTime     time.Time              `json:"stateChangeTime,omitempty"`
-	LastExecutionTime   time.Time              `json:"lastExecutionTime,omitempty"`
-	Duration            string                 `json:"duration,omitempty"`
-	Trigger             string                 `json:"trigger"`
-	SendUpdatesToClient bool                   `json:"sendUpdatesToClient"`
-	UpdateScheduledTask bool                   `json:"updateScheduledTask"`
-	Body                map[string]interface{} `json:"body"`
+	ID                  int64          `json:"id"`
+	Name                string         `json:"name"`
+	CommandName         string         `json:"commandName"`
+	Message             string         `json:"message,omitempty"`
+	Priority            string         `json:"priority"`
+	Status              string         `json:"status"`
+	Queued              time.Time      `json:"queued"`
+	Started             time.Time      `json:"started,omitempty"`
+	Ended               time.Time      `json:"ended,omitempty"`
+	StateChangeTime     time.Time      `json:"stateChangeTime,omitempty"`
+	LastExecutionTime   time.Time      `json:"lastExecutionTime,omitempty"`
+	Duration            string         `json:"duration,omitempty"`
+	Trigger             string         `json:"trigger"`
+	SendUpdatesToClient bool           `json:"sendUpdatesToClient"`
+	UpdateScheduledTask bool           `json:"updateScheduledTask"`
+	Body                map[string]any `json:"body"`
 }
 
 // GetCommands returns all available Lidarr commands.
@@ -106,3 +128,39 @@ func (l *Lidarr) GetCommandStatusContext(ctx context.Context, commandID int64) (
 
 	return &output, nil
 }
+
+// SendManualImportCommand sends the ManualImport command to import the given files (e.g. after FLAC+CUE split).
+func (l *Lidarr) SendManualImportCommand(cmd *ManualImportCommandRequest) (*CommandResponse, error) {
+	return l.SendManualImportCommandContext(context.Background(), cmd)
+}
+
+// SendManualImportCommandContext sends the ManualImport command to import the given files.
+func (l *Lidarr) SendManualImportCommandContext(
+	ctx context.Context, cmd *ManualImportCommandRequest,
+) (*CommandResponse, error) {
+	var output CommandResponse
+
+	if cmd == nil || len(cmd.Files) == 0 {
+		return &output, nil
+	}
+
+	if cmd.Name == "" {
+		cmd.Name = "ManualImport"
+	}
+
+	if cmd.ImportMode == "" {
+		cmd.ImportMode = "auto"
+	}
+
+	var buf bytes.Buffer
+	if err := json.NewEncoder(&buf).Encode(cmd); err != nil {
+		return nil, fmt.Errorf("json.Marshal(%s): %w", bpCommand, err)
+	}
+
+	req := starr.Request{URI: bpCommand, Body: &buf}
+	if err := l.PostInto(ctx, req, &output); err != nil {
+		return nil, fmt.Errorf("api.Post(%s): %w", &req, err)
+	}
+
+	return &output, nil
+}

lidarr/command_test.go

@@ -1,6 +1,9 @@
 package lidarr_test
 
 import (
+	"bytes"
+	"context"
+	"encoding/json"
 	"net/http"
 	"path"
 	"testing"
@@ -146,3 +149,91 @@ func TestSendCommand(t *testing.T) {
 		})
 	}
 }
+
+func TestSendManualImportCommandContext(t *testing.T) {
+	t.Parallel()
+
+	somedate := time.Now().Add(-36 * time.Hour).Round(time.Millisecond).UTC()
+	datejson, _ := somedate.MarshalJSON()
+
+	manualImportReq := &lidarr.ManualImportCommandRequest{
+		Name:                 "ManualImport",
+		ImportMode:           "auto",
+		ReplaceExistingFiles: true,
+		Files: []*lidarr.ManualImportFile{{
+			Path:                    "/music/artist/album/01-track.flac",
+			ArtistID:                329,
+			AlbumID:                 2826,
+			AlbumReleaseID:          11727,
+			TrackIDs:                []int64{220502},
+			Quality:                 &starr.Quality{Quality: &starr.BaseQuality{ID: 21, Name: "FLAC 24bit"}, Revision: &starr.QualityRevision{Version: 1, Real: 0, IsRepack: false}},
+			IndexerFlags:            0,
+			DownloadID:              "b709f04aab654403bff7357c532c681a",
+			DisableReleaseSwitching: false,
+		}},
+	}
+	expectedBodyBuf := new(bytes.Buffer)
+	require.NoError(t, json.NewEncoder(expectedBodyBuf).Encode(manualImportReq))
+	expectedBody := expectedBodyBuf.String()
+
+	tests := []*starrtest.MockData{
+		{
+			Name:           "200",
+			ExpectedPath:   path.Join("/", starr.API, lidarr.APIver, "command"),
+			ResponseStatus: http.StatusOK,
+			ResponseBody: `{"id":99,"name":"ManualImport","commandName":"ManualImport","message":` +
+				`"","priority":"normal","status":"queued","queued":` + string(datejson) +
+				`,"started":` + string(datejson) + `,"ended":` + string(datejson) +
+				`,"stateChangeTime":` + string(datejson) + `,"lastExecutionTime":` + string(datejson) +
+				`,"duration":"","trigger":"manual","sendUpdatesToClient":true,"updateScheduledTask":false,"body":null}`,
+			WithError:       nil,
+			WithRequest:     manualImportReq,
+			ExpectedRequest: expectedBody,
+			ExpectedMethod:  "POST",
+			WithResponse: &lidarr.CommandResponse{
+				ID:                  99,
+				Name:                "ManualImport",
+				CommandName:         "ManualImport",
+				Message:             "",
+				Priority:            "normal",
+				Status:              "queued",
+				Queued:              somedate,
+				Started:             somedate,
+				Ended:               somedate,
+				StateChangeTime:     somedate,
+				LastExecutionTime:   somedate,
+				Duration:            "",
+				Trigger:             "manual",
+				SendUpdatesToClient: true,
+				UpdateScheduledTask: false,
+				Body:                nil,
+			},
+		},
+		{
+			Name:            "404",
+			ExpectedPath:    path.Join("/", starr.API, lidarr.APIver, "command"),
+			ResponseStatus:  http.StatusNotFound,
+			ResponseBody:    `{"message": "NotFound"}`,
+			WithError:       &starr.ReqError{Code: http.StatusNotFound},
+			WithRequest:     manualImportReq,
+			ExpectedRequest: expectedBody,
+			ExpectedMethod:  "POST",
+			WithResponse:    (*lidarr.CommandResponse)(nil),
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.Name, func(t *testing.T) {
+			t.Parallel()
+			mockServer := test.GetMockServer(t)
+			client := lidarr.New(starr.New("mockAPIkey", mockServer.URL, 0))
+			req := test.WithRequest.(*lidarr.ManualImportCommandRequest)
+			// Shallow copy so in-place mutation (Name/ImportMode defaults) doesn't affect other tests
+			reqCopy := *req
+			reqCopy.Files = req.Files
+			output, err := client.SendManualImportCommandContext(context.Background(), &reqCopy)
+			require.ErrorIs(t, err, test.WithError, "error is not the same as expected")
+			assert.EqualValues(t, test.WithResponse, output, "response is not the same as expected")
+		})
+	}
+}

lidarr/manualimport.go

@@ -69,26 +69,88 @@ type ManualImportParams struct {
 	FilterExistingFiles  bool
 }
 
-// ManualImport initiates a manual import (GET).
-func (l *Lidarr) ManualImport(params *ManualImportParams) (*ManualImportOutput, error) {
+// ManualImport returns the list of files available for manual import in the given folder (GET).
+// The Lidarr API returns an array of manual import items.
+func (l *Lidarr) ManualImport(params *ManualImportParams) ([]*ManualImportOutput, error) {
 	return l.ManualImportContext(context.Background(), params)
 }
 
-// ManualImportContext initiates a manual import (GET).
-func (l *Lidarr) ManualImportContext(ctx context.Context, params *ManualImportParams) (*ManualImportOutput, error) {
+// ManualImportContext returns the list of files available for manual import in the given folder (GET).
+func (l *Lidarr) ManualImportContext(ctx context.Context, params *ManualImportParams) ([]*ManualImportOutput, error) {
 	req := starr.Request{URI: bpManualImport, Query: make(url.Values)}
 	req.Query.Add("folder", params.Folder)
 	req.Query.Add("downloadId", params.DownloadID)
 	req.Query.Add("artistId", starr.Str(params.ArtistID))
 	req.Query.Add("replaceExistingFiles", starr.Str(params.ReplaceExistingFiles))
 	req.Query.Add("filterExistingFiles", starr.Str(params.FilterExistingFiles))
 
-	var output ManualImportOutput
+	var output []*ManualImportOutput
 	if err := l.GetInto(ctx, req, &output); err != nil {
 		return nil, fmt.Errorf("api.Get(%s): %w", &req, err)
 	}
 
-	return &output, nil
+	return output, nil
+}
+
+// ManualImportCommandFromOutputs builds a ManualImportCommandRequest from the GET manualimport response.
+// Use with SendManualImportCommand to trigger import of the listed files (e.g. after FLAC+CUE split).
+func ManualImportCommandFromOutputs(outputs []*ManualImportOutput, replaceExisting bool) *ManualImportCommandRequest {
+	if len(outputs) == 0 {
+		return nil
+	}
+
+	files := make([]*ManualImportFile, 0, len(outputs))
+
+	for _, output := range outputs {
+		if output == nil {
+			continue
+		}
+
+		artistID := int64(0)
+		if output.Artist != nil {
+			artistID = output.Artist.ID
+		}
+
+		albumID := int64(0)
+		if output.Album != nil {
+			albumID = output.Album.ID
+		}
+
+		trackIDs := make([]int64, 0, len(output.Tracks))
+		for _, t := range output.Tracks {
+			if t != nil {
+				trackIDs = append(trackIDs, t.ID)
+			}
+		}
+
+		quality := output.Quality
+		if quality == nil {
+			quality = &starr.Quality{}
+		}
+
+		files = append(files, &ManualImportFile{
+			Path:                    output.Path,
+			ArtistID:                artistID,
+			AlbumID:                 albumID,
+			AlbumReleaseID:          output.AlbumReleaseID,
+			TrackIDs:                trackIDs,
+			Quality:                 quality,
+			IndexerFlags:            0,
+			DownloadID:              output.DownloadID,
+			DisableReleaseSwitching: output.DisableReleaseSwitching,
+		})
+	}
+
+	if len(files) == 0 {
+		return nil
+	}
+
+	return &ManualImportCommandRequest{
+		Name:                 "ManualImport",
+		Files:                files,
+		ImportMode:           "auto",
+		ReplaceExistingFiles: replaceExisting,
+	}
 }
 
 // ManualImportReprocess reprocesses a manual import (POST).