feat: Add suport for list/get/run/stop/create/update/delete task

nexus3/nexus.go

@@ -7,6 +7,7 @@ import (
 	"github.com/datadrivers/go-nexus-client/nexus3/pkg/readonly"
 	"github.com/datadrivers/go-nexus-client/nexus3/pkg/repository"
 	"github.com/datadrivers/go-nexus-client/nexus3/pkg/security"
+	"github.com/datadrivers/go-nexus-client/nexus3/pkg/task"
 )
 
 const (
@@ -27,6 +28,7 @@ type NexusClient struct {
 	CleanupPolicy *cleanup.CleanupPolicyService
 	Security      *security.SecurityService
 	Script        *ScriptService
+	Task          *task.TaskService
 	ReadOnly      *readonly.ReadOnlyService
 	MailConfig    *MailConfigService
 }
@@ -42,6 +44,7 @@ func NewClient(config client.Config) *NexusClient {
 		CleanupPolicy: cleanup.NewCleanupPolicyService(client),
 		Security:      security.NewSecurityService(client),
 		Script:        NewScriptService(client),
+		Task:          task.NewTaskService(client),
 		ReadOnly:      readonly.NewReadOnlyService(client),
 		MailConfig:    NewMailConfigService(client),
 	}

nexus3/pkg/cleanup/service.go

@@ -3,11 +3,10 @@ package cleanup
 import (
 	"encoding/json"
 	"fmt"
-	"net/http"
-
 	"github.com/datadrivers/go-nexus-client/nexus3/pkg/client"
 	"github.com/datadrivers/go-nexus-client/nexus3/pkg/tools"
 	"github.com/datadrivers/go-nexus-client/nexus3/schema/cleanuppolicies"
+	"net/http"
 )
 
 const (
@@ -20,21 +19,24 @@ func NewCleanupPolicyService(c *client.Client) *CleanupPolicyService {
 	return &CleanupPolicyService{Client: c}
 }
 
-func (s *CleanupPolicyService) Create(policy *cleanuppolicies.CleanupPolicy) error {
+func (s *CleanupPolicyService) Create(policy *cleanuppolicies.CleanupPolicy) (*cleanuppolicies.CleanupPolicy, error) {
 	data, err := tools.JsonMarshalInterfaceToIOReader(policy)
 	if err != nil {
-		return err
+		return nil, err
 	}
 	body, resp, err := s.Client.Post(cleanupAPIEndpoint, data)
 	if err != nil {
-		return err
+		return nil, err
 	}
 	if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusCreated {
-		return fmt.Errorf("could not create cleanup policy '%s': HTTP: %d, %s", policy.Name, resp.StatusCode, string(body))
+		return nil, fmt.Errorf("could not create cleanup policy '%s': HTTP: %d, %s", policy.Name, resp.StatusCode, string(body))
 	}
-	return nil
+	createdPolicy := &cleanuppolicies.CleanupPolicy{}
+	if err := json.Unmarshal(body, createdPolicy); err != nil {
+		return nil, fmt.Errorf("could not unmarshal created cleanup policy: %v", err)
+	}
+	return createdPolicy, nil
 }
-
 func (s *CleanupPolicyService) Get(name string) (*cleanuppolicies.CleanupPolicy, error) {
 
 	body, resp, err := s.Client.Get(fmt.Sprintf("%s/%s", cleanupAPIEndpoint, name), nil)
@@ -46,7 +48,7 @@ func (s *CleanupPolicyService) Get(name string) (*cleanuppolicies.CleanupPolicy,
 	}
 	policy := &cleanuppolicies.CleanupPolicy{}
 	if err := json.Unmarshal(body, policy); err != nil {
-		return nil, fmt.Errorf("could not unmarshal repository: %v", err)
+		return nil, fmt.Errorf("could not unmarshal CleanupPolicy: %v", err)
 	}
 
 	return policy, nil

nexus3/pkg/task/service.go

@@ -0,0 +1,151 @@
+package task
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"github.com/datadrivers/go-nexus-client/nexus3/pkg/tools"
+	"github.com/datadrivers/go-nexus-client/nexus3/schema"
+	"net/http"
+	"net/url"
+
+	"github.com/datadrivers/go-nexus-client/nexus3/pkg/client"
+	"github.com/datadrivers/go-nexus-client/nexus3/schema/task"
+)
+
+const (
+	taskAPIEndpoint = client.BasePath + "v1/tasks"
+)
+
+var (
+	ErrTaskNotRunning = errors.New("task is not currently running")
+)
+
+type TaskService client.Service
+
+func NewTaskService(c *client.Client) *TaskService {
+	return &TaskService{Client: c}
+}
+
+func (s *TaskService) ListTasks(taskType *string, continuationToken *string) ([]task.Task, *string, error) {
+	q := url.Values{}
+	if taskType != nil {
+		q.Set("type", *taskType)
+	}
+	if continuationToken != nil {
+		q.Set("continuationToken", *continuationToken)
+	}
+
+	body, resp, err := s.Client.Get(fmt.Sprintf("%s?%s", taskAPIEndpoint, q.Encode()), nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, nil, fmt.Errorf("could not list task: HTTP: %d, %s", resp.StatusCode, string(body))
+	}
+
+	var result schema.PaginationResult[task.Task]
+	if err := json.Unmarshal(body, &result); err != nil {
+		return nil, nil, fmt.Errorf("could not unmarshal tasks: %v", err)
+	}
+
+	return result.Items, result.ContinuationToken, nil
+}
+
+func (s *TaskService) GetTask(id string) (*task.Task, error) {
+	body, resp, err := s.Client.Get(fmt.Sprintf("%s/%s", taskAPIEndpoint, id), nil)
+	if err != nil {
+		return nil, err
+	}
+	switch resp.StatusCode {
+	case http.StatusOK:
+		var t task.Task
+		if err := json.Unmarshal(body, &t); err != nil {
+			return nil, fmt.Errorf("could not unmarshal task: %v", err)
+		}
+		return &t, nil
+	case http.StatusNotFound:
+		return nil, nil
+	default:
+		return nil, fmt.Errorf("could not get task '%s': HTTP: %d, %s", id, resp.StatusCode, string(body))
+	}
+}
+
+func (s *TaskService) RunTask(id string) error {
+	body, resp, err := s.Client.Post(fmt.Sprintf("%s/%s/run", taskAPIEndpoint, id), nil)
+	if err != nil {
+		return err
+	}
+	if resp.StatusCode != http.StatusNoContent {
+		return fmt.Errorf("could not run task '%s': HTTP: %d, %s", id, resp.StatusCode, string(body))
+	}
+	return nil
+}
+
+func (s *TaskService) StopTask(id string) error {
+	body, resp, err := s.Client.Post(fmt.Sprintf("%s/%s/stop", taskAPIEndpoint, id), nil)
+	if err != nil {
+		return err
+	}
+	switch resp.StatusCode {
+	case http.StatusNoContent:
+		return nil
+	case http.StatusConflict:
+		return ErrTaskNotRunning
+	default:
+		return fmt.Errorf("could not stop task '%s': HTTP: %d, %s", id, resp.StatusCode, string(body))
+	}
+}
+
+func (s *TaskService) CreateTask(newTask *task.TaskCreateStruct) (*task.Task, error) {
+	ioReader, err := tools.JsonMarshalInterfaceToIOReader(newTask)
+	if err != nil {
+		return nil, err
+	}
+	body, resp, err := s.Client.Post(taskAPIEndpoint, ioReader)
+	if err != nil {
+		return nil, err
+	}
+
+	if resp.StatusCode != http.StatusCreated {
+		return nil, fmt.Errorf("could not create task: HTTP: %d, %s", resp.StatusCode, string(body))
+	}
+
+	var createdTask task.Task
+	if err := json.Unmarshal(body, &createdTask); err != nil {
+		return nil, fmt.Errorf("could not unmarshal created task: %v", err)
+	}
+
+	return &createdTask, nil
+}
+
+func (s *TaskService) UpdateTask(id string, updatedTask *task.TaskCreateStruct) error {
+	ioReader, err := tools.JsonMarshalInterfaceToIOReader(updatedTask)
+	if err != nil {
+		return err
+	}
+
+	body, resp, err := s.Client.Put(fmt.Sprintf("%s/%s", taskAPIEndpoint, id), ioReader)
+	if err != nil {
+		return err
+	}
+
+	if resp.StatusCode != http.StatusNoContent {
+		return fmt.Errorf("could not update task '%s': HTTP: %d, %s", id, resp.StatusCode, string(body))
+	}
+	return nil
+}
+
+func (s *TaskService) DeleteTask(id string) error {
+	body, resp, err := s.Client.Delete(fmt.Sprintf("%s/%s", taskAPIEndpoint, id))
+	if err != nil {
+		return err
+	}
+
+	if resp.StatusCode != http.StatusNoContent {
+		return fmt.Errorf("could not delete task '%s': HTTP: %d, %s", id, resp.StatusCode, string(body))
+	}
+
+	return nil
+}