Add movie editor endpoints

pointers.go

@@ -0,0 +1,23 @@
+package starr
+
+// String returns a pointer to a string.
+func String(s string) *string {
+	return &s
+}
+
+// True returns a pointer to a true boolean.
+func True() *bool {
+	s := true
+	return &s
+}
+
+// False returns a pointer to a false boolean.
+func False() *bool {
+	s := false
+	return &s
+}
+
+// Int64 returns a pointer to the provided integer.
+func Int64(s int64) *int64 {
+	return &s
+}

radarr/movie.go

@@ -280,3 +280,21 @@ func (r *Radarr) LookupContext(ctx context.Context, term string) ([]*Movie, erro
 
 	return output, nil
 }
+
+// DeleteMovie removes a movie from the database. Setting deleteFiles true will delete all content for the movie.
+func (r *Radarr) DeleteMovie(movieID int64, deleteFiles, addImportExclusion bool) error {
+	return r.DeleteMovieContext(context.Background(), movieID, deleteFiles, addImportExclusion)
+}
+
+// DeleteMovieContext removes a movie from the database. Setting deleteFiles true will delete all content for the movie.
+func (r *Radarr) DeleteMovieContext(ctx context.Context, movieID int64, deleteFiles, addImportExclusion bool) error {
+	req := starr.Request{URI: path.Join(bpMovie, fmt.Sprint(movieID)), Query: make(url.Values)}
+	req.Query.Set("deleteFiles", fmt.Sprint(deleteFiles))
+	req.Query.Set("addImportExclusion", fmt.Sprint(addImportExclusion))
+
+	if err := r.DeleteAny(ctx, req); err != nil {
+		return fmt.Errorf("api.Delete(%s): %w", &req, err)
+	}
+
+	return nil
+}

radarr/movieeditor.go

@@ -0,0 +1,69 @@
+package radarr
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+
+	"golift.io/starr"
+)
+
+const bpMovieEditor = bpMovie + "/editor"
+
+// BulkEdit is the input for the bulk movie editor endpoint.
+// You may use starr.True(), starr.False(), starr.Int64(), and starr.String() to add data to the struct members.
+type BulkEdit struct {
+	MovieIDs            []int64 `json:"movieIds"`
+	Monitored           *bool   `json:"monitored,omitempty"`
+	QualityProfileID    *int64  `json:"qualityProfileId,omitempty"`
+	MinimumAvailability *string `json:"minimumAvailability,omitempty"` // tba
+	RootFolderPath      *string `json:"rootFolderPath,omitempty"`      // path
+	Tags                []int   `json:"tags,omitempty"`                // [0]
+	ApplyTags           *string `json:"applyTags,omitempty"`           // add
+	MoveFiles           *bool   `json:"moveFiles,omitempty"`
+	DeleteFiles         *bool   `json:"deleteFiles,omitempty"`        // delete only
+	AddImportExclusion  *bool   `json:"addImportExclusion,omitempty"` // delete only
+}
+
+// EditMovies allows bulk diting many movies at once.
+func (r *Radarr) EditMovies(editMovies *BulkEdit) ([]*Movie, error) {
+	return r.EditMoviesContext(context.Background(), editMovies)
+}
+
+// EditMoviesContext allows bulk diting many movies at once.
+func (r *Radarr) EditMoviesContext(ctx context.Context, editMovies *BulkEdit) ([]*Movie, error) {
+	var body bytes.Buffer
+	if err := json.NewEncoder(&body).Encode(editMovies); err != nil {
+		return nil, fmt.Errorf("json.Marshal(%s): %w", bpMovieEditor, err)
+	}
+
+	var output []*Movie
+
+	req := starr.Request{URI: bpMovieEditor, Body: &body}
+	if err := r.PutInto(ctx, req, &output); err != nil {
+		return nil, fmt.Errorf("api.Put(%s): %w", &req, err)
+	}
+
+	return output, nil
+}
+
+// DeleteMovies bulk deletes movies. Can also mark them as excluded, and delete their files.
+func (r *Radarr) DeleteMovies(deleteMovies *BulkEdit) error {
+	return r.DeleteMoviesContext(context.Background(), deleteMovies)
+}
+
+// DeleteDeleteMoviesContextMovies bulk deletes movies. Can also mark them as excluded, and delete their files.
+func (r *Radarr) DeleteMoviesContext(ctx context.Context, deleteMovies *BulkEdit) error {
+	var body bytes.Buffer
+	if err := json.NewEncoder(&body).Encode(deleteMovies); err != nil {
+		return fmt.Errorf("json.Marshal(%s): %w", bpMovieEditor, err)
+	}
+
+	req := starr.Request{URI: bpMovieEditor, Body: &body}
+	if err := r.DeleteAny(ctx, req); err != nil {
+		return fmt.Errorf("api.Delete(%s): %w", &req, err)
+	}
+
+	return nil
+}

radarr/movieeditor_test.go

@@ -0,0 +1,45 @@
+package radarr_test
+
+import (
+	"net/http"
+	"path"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"golift.io/starr"
+	"golift.io/starr/radarr"
+)
+
+func TestEditMovies(t *testing.T) {
+	t.Parallel()
+
+	tests := []*starr.TestMockData{
+		{
+			Name:           "200",
+			ExpectedPath:   path.Join("/", starr.API, radarr.APIver, "movie", "editor"),
+			ResponseStatus: http.StatusOK,
+			ResponseBody:   `[{"id": 7, "monitored": true},{"id": 3, "monitored": true}]`,
+			WithError:      nil,
+			WithRequest: &radarr.BulkEdit{
+				MovieIDs:    []int64{7, 3},
+				Monitored:   starr.True(),
+				DeleteFiles: starr.False(),
+			},
+			ExpectedRequest: `{"movieIds":[7,3],"monitored":true,"deleteFiles":false}` + "\n",
+			ExpectedMethod:  http.MethodPut,
+			WithResponse:    []*radarr.Movie{{ID: 7, Monitored: true}, {ID: 3, Monitored: true}},
+		},
+	}
+
+	for _, test := range tests {
+		test := test
+		t.Run(test.Name, func(t *testing.T) {
+			t.Parallel()
+			mockServer := test.GetMockServer(t)
+			client := radarr.New(starr.New("mockAPIkey", mockServer.URL, 0))
+			output, err := client.EditMovies(test.WithRequest.(*radarr.BulkEdit))
+			assert.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")
+		})
+	}
+}

test_methods.go

@@ -40,7 +40,7 @@ func (test *TestMockData) GetMockServer(t *testing.T) *httptest.Server {
 		assert.EqualValues(t, test.ExpectedPath, req.URL.String())
 		writer.WriteHeader(test.ResponseStatus)
 
-		assert.EqualValues(t, req.Method, test.ExpectedMethod)
+		assert.EqualValues(t, test.ExpectedMethod, req.Method)
 
 		body, err := io.ReadAll(req.Body)
 		assert.NoError(t, err)