Change code generator (#4)

* Change code generator
* Remove gin

service/artifact.go

@@ -1,38 +0,0 @@
-package service
-
-import (
-	"context"
-
-	"github.com/google/uuid"
-
-	"github.com/SecurityBrewery/catalyst/generated/models"
-	"github.com/SecurityBrewery/catalyst/generated/restapi/api"
-	"github.com/SecurityBrewery/catalyst/generated/restapi/operations/tickets"
-)
-
-func (s *Service) RunArtifact(ctx context.Context, params *tickets.RunArtifactParams) (r *api.Response) {
-	artifact, err := s.database.ArtifactGet(ctx, params.ID, params.Name)
-	if err != nil {
-		return s.response(ctx, "RunArtifact", ticketID(params.ID), nil, err)
-	}
-
-	jobID := uuid.NewString()
-	origin := &models.Origin{ArtifactOrigin: &models.ArtifactOrigin{TicketId: params.ID, Artifact: params.Name}}
-	err = s.bus.PublishJob(jobID, params.Automation, params.Name, &models.Context{Artifact: artifact}, origin)
-	return s.response(ctx, "RunArtifact", ticketID(params.ID), nil, err)
-}
-
-func (s *Service) EnrichArtifact(ctx context.Context, params *tickets.EnrichArtifactParams) *api.Response {
-	i, err := s.database.EnrichArtifact(ctx, params.ID, params.Name, params.Data)
-	return s.response(ctx, "EnrichArtifact", ticketID(params.ID), i, err)
-}
-
-func (s *Service) SetArtifact(ctx context.Context, params *tickets.SetArtifactParams) *api.Response {
-	i, err := s.database.ArtifactUpdate(ctx, params.ID, params.Name, params.Artifact)
-	return s.response(ctx, "SetArtifact", ticketID(params.ID), i, err)
-}
-
-func (s *Service) GetArtifact(ctx context.Context, params *tickets.GetArtifactParams) *api.Response {
-	i, err := s.database.ArtifactGet(ctx, params.ID, params.Name)
-	return s.response(ctx, "GetArtifact", nil, i, err)
-}

service/automation.go

@@ -7,35 +7,39 @@ import (
 	"github.com/arangodb/go-driver"
 
 	"github.com/SecurityBrewery/catalyst/database"
-	"github.com/SecurityBrewery/catalyst/generated/restapi/api"
-	"github.com/SecurityBrewery/catalyst/generated/restapi/operations/automations"
+	"github.com/SecurityBrewery/catalyst/generated/model"
 )
 
+func automationResponseID(automation *model.AutomationResponse) []driver.DocumentID {
+	if automation == nil {
+		return nil
+	}
+	return automationID(automation.ID)
+}
+
 func automationID(id string) []driver.DocumentID {
 	return []driver.DocumentID{driver.DocumentID(fmt.Sprintf("%s/%s", database.AutomationCollectionName, id))}
 }
 
-func (s *Service) CreateAutomation(ctx context.Context, params *automations.CreateAutomationParams) *api.Response {
-	i, err := s.database.AutomationCreate(ctx, params.Automation)
-	return s.response(ctx, "CreateAutomation", automationID(i.ID), i, err)
+func (s *Service) ListAutomations(ctx context.Context) ([]*model.AutomationResponse, error) {
+	return s.database.AutomationList(ctx)
 }
 
-func (s *Service) GetAutomation(ctx context.Context, params *automations.GetAutomationParams) *api.Response {
-	i, err := s.database.AutomationGet(ctx, params.ID)
-	return s.response(ctx, "GetAutomation", nil, i, err)
+func (s *Service) CreateAutomation(ctx context.Context, form *model.AutomationForm) (doc *model.AutomationResponse, err error) {
+	defer s.publishRequest(ctx, err, "CreateAutomation", automationResponseID(doc))
+	return s.database.AutomationCreate(ctx, form)
 }
 
-func (s *Service) UpdateAutomation(ctx context.Context, params *automations.UpdateAutomationParams) *api.Response {
-	i, err := s.database.AutomationUpdate(ctx, params.ID, params.Automation)
-	return s.response(ctx, "UpdateAutomation", automationID(i.ID), i, err)
+func (s *Service) GetAutomation(ctx context.Context, id string) (*model.AutomationResponse, error) {
+	return s.database.AutomationGet(ctx, id)
 }
 
-func (s *Service) DeleteAutomation(ctx context.Context, params *automations.DeleteAutomationParams) *api.Response {
-	err := s.database.AutomationDelete(ctx, params.ID)
-	return s.response(ctx, "DeleteAutomation", automationID(params.ID), nil, err)
+func (s *Service) UpdateAutomation(ctx context.Context, id string, form *model.AutomationForm) (doc *model.AutomationResponse, err error) {
+	defer s.publishRequest(ctx, err, "UpdateAutomation", automationResponseID(doc))
+	return s.database.AutomationUpdate(ctx, id, form)
 }
 
-func (s *Service) ListAutomations(ctx context.Context) *api.Response {
-	i, err := s.database.AutomationList(ctx)
-	return s.response(ctx, "ListAutomations", nil, i, err)
+func (s *Service) DeleteAutomation(ctx context.Context, id string) (err error) {
+	defer s.publishRequest(ctx, err, "DeleteAutomation", automationID(id))
+	return s.database.AutomationDelete(ctx, id)
 }

service/job.go

@@ -8,32 +8,37 @@ import (
 	"github.com/google/uuid"
 
 	"github.com/SecurityBrewery/catalyst/database"
-	"github.com/SecurityBrewery/catalyst/generated/models"
-	"github.com/SecurityBrewery/catalyst/generated/restapi/api"
-	"github.com/SecurityBrewery/catalyst/generated/restapi/operations/jobs"
+	"github.com/SecurityBrewery/catalyst/generated/model"
 )
 
+func jobResponseID(job *model.JobResponse) []driver.DocumentID {
+	if job == nil {
+		return nil
+	}
+	return jobID(job.ID)
+}
+
 func jobID(id string) []driver.DocumentID {
 	return []driver.DocumentID{driver.DocumentID(fmt.Sprintf("%s/%s", database.JobCollectionName, id))}
 }
 
-func (s *Service) RunJob(ctx context.Context, params *jobs.RunJobParams) *api.Response {
-	msgContext := &models.Context{}
+func (s *Service) ListJobs(ctx context.Context) ([]*model.JobResponse, error) {
+	return s.database.JobList(ctx)
+}
+
+func (s *Service) RunJob(ctx context.Context, form *model.JobForm) (err error) {
+	msgContext := &model.Context{}
 	newJobID := uuid.NewString()
-	return s.response(ctx, "RunJob", jobID(newJobID), nil, s.bus.PublishJob(newJobID, params.Job.Automation, params.Job.Payload, msgContext, params.Job.Origin))
+
+	defer s.publishRequest(ctx, err, "RunJob", jobID(newJobID))
+	return s.bus.PublishJob(newJobID, form.Automation, form.Payload, msgContext, form.Origin)
 }
 
-func (s *Service) GetJob(ctx context.Context, params *jobs.GetJobParams) *api.Response {
-	i, err := s.database.JobGet(ctx, params.ID)
-	return s.response(ctx, "GetJob", nil, i, err)
+func (s *Service) GetJob(ctx context.Context, id string) (*model.JobResponse, error) {
+	return s.database.JobGet(ctx, id)
 }
 
-func (s *Service) ListJobs(ctx context.Context) *api.Response {
-	i, err := s.database.JobList(ctx)
-	return s.response(ctx, "ListJobs", nil, i, err)
-}
-
-func (s *Service) UpdateJob(ctx context.Context, params *jobs.UpdateJobParams) *api.Response {
-	i, err := s.database.JobUpdate(ctx, params.ID, params.Job)
-	return s.response(ctx, "UpdateJob", jobID(i.ID), i, err)
+func (s *Service) UpdateJob(ctx context.Context, id string, job *model.Job) (doc *model.JobResponse, err error) {
+	defer s.publishRequest(ctx, err, "UpdateJob", jobResponseID(doc))
+	return s.database.JobUpdate(ctx, id, job)
 }

service/log.go

@@ -4,12 +4,10 @@ import (
 	"context"
 	"net/url"
 
-	"github.com/SecurityBrewery/catalyst/generated/restapi/api"
-	"github.com/SecurityBrewery/catalyst/generated/restapi/operations/logs"
+	"github.com/SecurityBrewery/catalyst/generated/model"
 )
 
-func (s *Service) GetLogs(ctx context.Context, params *logs.GetLogsParams) *api.Response {
-	id, _ := url.QueryUnescape(params.Reference)
-	i, err := s.database.LogList(ctx, id)
-	return s.response(ctx, "GetLogs", nil, i, err)
+func (s *Service) GetLogs(ctx context.Context, reference string) ([]*model.LogEntry, error) {
+	id, _ := url.QueryUnescape(reference)
+	return s.database.LogList(ctx, id)
 }

service/playbook.go

@@ -3,62 +3,43 @@ package service
 import (
 	"context"
 	"fmt"
-	"strings"
 
 	"github.com/arangodb/go-driver"
-	"github.com/xeipuuv/gojsonschema"
 
 	"github.com/SecurityBrewery/catalyst/database"
-	"github.com/SecurityBrewery/catalyst/generated/models"
-	"github.com/SecurityBrewery/catalyst/generated/restapi/api"
-	"github.com/SecurityBrewery/catalyst/generated/restapi/operations/playbooks"
+	"github.com/SecurityBrewery/catalyst/generated/model"
 )
 
+func playbookResponseID(playbook *model.PlaybookTemplateResponse) []driver.DocumentID {
+	if playbook == nil {
+		return nil
+	}
+	return playbookID(playbook.ID)
+}
+
 func playbookID(id string) []driver.DocumentID {
 	return []driver.DocumentID{driver.DocumentID(fmt.Sprintf("%s/%s", database.PlaybookCollectionName, id))}
 }
 
-func (s *Service) CreatePlaybook(ctx context.Context, params *playbooks.CreatePlaybookParams) *api.Response {
-	i, err := s.database.PlaybookCreate(ctx, params.Playbook)
-	return s.response(ctx, "CreatePlaybook", playbookID(i.ID), i, err)
+func (s *Service) ListPlaybooks(ctx context.Context) ([]*model.PlaybookTemplateResponse, error) {
+	return s.database.PlaybookList(ctx)
 }
 
-func (s *Service) GetPlaybook(ctx context.Context, params *playbooks.GetPlaybookParams) *api.Response {
-	i, err := s.database.PlaybookGet(ctx, params.ID)
-	return s.response(ctx, "GetPlaybook", nil, i, err)
+func (s *Service) CreatePlaybook(ctx context.Context, form *model.PlaybookTemplateForm) (doc *model.PlaybookTemplateResponse, err error) {
+	defer s.publishRequest(ctx, err, "CreatePlaybook", playbookResponseID(doc))
+	return s.database.PlaybookCreate(ctx, form)
 }
 
-func (s *Service) UpdatePlaybook(ctx context.Context, params *playbooks.UpdatePlaybookParams) *api.Response {
-	if err := validate(params.Playbook, models.PlaybookTemplateFormSchema); err != nil {
-		return s.response(ctx, "UpdatePlaybook", nil, nil, err)
-	}
-
-	i, err := s.database.PlaybookUpdate(ctx, params.ID, params.Playbook)
-	return s.response(ctx, "UpdatePlaybook", playbookID(i.ID), i, err)
+func (s *Service) GetPlaybook(ctx context.Context, id string) (*model.PlaybookTemplateResponse, error) {
+	return s.database.PlaybookGet(ctx, id)
 }
 
-func (s *Service) DeletePlaybook(ctx context.Context, params *playbooks.DeletePlaybookParams) *api.Response {
-	err := s.database.PlaybookDelete(ctx, params.ID)
-	return s.response(ctx, "DeletePlaybook", playbookID(params.ID), nil, err)
+func (s *Service) UpdatePlaybook(ctx context.Context, id string, form *model.PlaybookTemplateForm) (doc *model.PlaybookTemplateResponse, err error) {
+	defer s.publishRequest(ctx, err, "UpdatePlaybook", playbookResponseID(doc))
+	return s.database.PlaybookUpdate(ctx, id, form)
 }
 
-func (s *Service) ListPlaybooks(ctx context.Context) *api.Response {
-	i, err := s.database.PlaybookList(ctx)
-	return s.response(ctx, "ListPlaybooks", nil, i, err)
-}
-
-func validate(e interface{}, schema *gojsonschema.Schema) error {
-	res, err := schema.Validate(gojsonschema.NewGoLoader(e))
-	if err != nil {
-		return err
-	}
-
-	if len(res.Errors()) > 0 {
-		var l []string
-		for _, e := range res.Errors() {
-			l = append(l, e.String())
-		}
-		return fmt.Errorf("validation failed: %v", strings.Join(l, ", "))
-	}
-	return nil
+func (s *Service) DeletePlaybook(ctx context.Context, id string) (err error) {
+	defer s.publishRequest(ctx, err, "DeletePlaybook", playbookID(id))
+	return s.database.PlaybookDelete(ctx, id)
 }

service/service.go

@@ -2,42 +2,31 @@ package service
 
 import (
 	"context"
-	"errors"
-	"log"
-	"net/http"
 
 	"github.com/arangodb/go-driver"
-	"github.com/gin-gonic/gin"
 
 	"github.com/SecurityBrewery/catalyst/bus"
 	"github.com/SecurityBrewery/catalyst/database"
 	"github.com/SecurityBrewery/catalyst/database/busdb"
-	"github.com/SecurityBrewery/catalyst/generated/models"
-	"github.com/SecurityBrewery/catalyst/generated/restapi/api"
+	"github.com/SecurityBrewery/catalyst/generated/model"
 	"github.com/SecurityBrewery/catalyst/storage"
 )
 
 type Service struct {
 	bus      *bus.Bus
 	database *database.Database
-	settings *models.Settings
+	settings *model.Settings
 	storage  *storage.Storage
 }
 
-func New(bus *bus.Bus, database *database.Database, storage *storage.Storage, settings *models.Settings) (*Service, error) {
+func New(bus *bus.Bus, database *database.Database, storage *storage.Storage, settings *model.Settings) (*Service, error) {
 	return &Service{database: database, bus: bus, settings: settings, storage: storage}, nil
 }
 
-func (s *Service) Healthy() bool {
-	return true
-}
-
-func (s *Service) response(ctx context.Context, function string, ids []driver.DocumentID, v interface{}, err error) *api.Response {
+func (s *Service) publishRequest(ctx context.Context, err error, function string, ids []driver.DocumentID) {
 	if err != nil {
-		log.Println(err)
-		return &api.Response{Code: httpStatus(err), Body: gin.H{"error": err.Error()}}
+		return
 	}
-
 	if ids != nil {
 		userID := "unknown"
 		user, ok := busdb.UserFromContext(ctx)
@@ -47,18 +36,4 @@ func (s *Service) response(ctx context.Context, function string, ids []driver.Do
 
 		go s.bus.PublishRequest(userID, function, ids)
 	}
-
-	if v == nil {
-		return &api.Response{Code: http.StatusNoContent, Body: v}
-	}
-	return &api.Response{Code: http.StatusOK, Body: v}
-}
-
-func httpStatus(err error) int {
-	ae := driver.ArangoError{}
-	if errors.As(err, &ae) {
-		return ae.Code
-	}
-
-	return http.StatusInternalServerError
 }

service/statistics.go

@@ -3,10 +3,9 @@ package service
 import (
 	"context"
 
-	"github.com/SecurityBrewery/catalyst/generated/restapi/api"
+	"github.com/SecurityBrewery/catalyst/generated/model"
 )
 
-func (s *Service) GetStatistics(ctx context.Context) *api.Response {
-	i, err := s.database.Statistics(ctx)
-	return s.response(ctx, "GetStatistics", nil, i, err)
+func (s *Service) GetStatistics(ctx context.Context) (*model.Statistics, error) {
+	return s.database.Statistics(ctx)
 }

service/task.go

@@ -3,10 +3,9 @@ package service
 import (
 	"context"
 
-	"github.com/SecurityBrewery/catalyst/generated/restapi/api"
+	"github.com/SecurityBrewery/catalyst/generated/model"
 )
 
-func (s *Service) ListTasks(ctx context.Context) *api.Response {
-	i, err := s.database.TaskList(ctx)
-	return s.response(ctx, "ListTasks", nil, i, err)
+func (s *Service) ListTasks(ctx context.Context) ([]*model.TaskWithContext, error) {
+	return s.database.TaskList(ctx)
 }

service/template.go

@@ -7,35 +7,39 @@ import (
 	"github.com/arangodb/go-driver"
 
 	"github.com/SecurityBrewery/catalyst/database"
-	"github.com/SecurityBrewery/catalyst/generated/restapi/api"
-	"github.com/SecurityBrewery/catalyst/generated/restapi/operations/templates"
+	"github.com/SecurityBrewery/catalyst/generated/model"
 )
 
-func templateID(s string) []driver.DocumentID {
-	return []driver.DocumentID{driver.DocumentID(fmt.Sprintf("%s/%s", database.TemplateCollectionName, s))}
+func templateResponseID(template *model.TicketTemplateResponse) []driver.DocumentID {
+	if template == nil {
+		return nil
+	}
+	return templateID(template.ID)
 }
 
-func (s *Service) CreateTemplate(ctx context.Context, params *templates.CreateTemplateParams) *api.Response {
-	i, err := s.database.TemplateCreate(ctx, params.Template)
-	return s.response(ctx, "CreateTemplate", templateID(i.ID), i, err)
+func templateID(id string) []driver.DocumentID {
+	return []driver.DocumentID{driver.DocumentID(fmt.Sprintf("%s/%s", database.TemplateCollectionName, id))}
 }
 
-func (s *Service) GetTemplate(ctx context.Context, params *templates.GetTemplateParams) *api.Response {
-	i, err := s.database.TemplateGet(ctx, params.ID)
-	return s.response(ctx, "GetTemplate", nil, i, err)
+func (s *Service) ListTemplates(ctx context.Context) ([]*model.TicketTemplateResponse, error) {
+	return s.database.TemplateList(ctx)
 }
 
-func (s *Service) UpdateTemplate(ctx context.Context, params *templates.UpdateTemplateParams) *api.Response {
-	i, err := s.database.TemplateUpdate(ctx, params.ID, params.Template)
-	return s.response(ctx, "UpdateTemplate", templateID(i.ID), i, err)
+func (s *Service) CreateTemplate(ctx context.Context, form *model.TicketTemplateForm) (doc *model.TicketTemplateResponse, err error) {
+	defer s.publishRequest(ctx, err, "CreateTemplate", templateResponseID(doc))
+	return s.database.TemplateCreate(ctx, form)
 }
 
-func (s *Service) DeleteTemplate(ctx context.Context, params *templates.DeleteTemplateParams) *api.Response {
-	err := s.database.TemplateDelete(ctx, params.ID)
-	return s.response(ctx, "DeleteTemplate", templateID(params.ID), nil, err)
+func (s *Service) GetTemplate(ctx context.Context, id string) (*model.TicketTemplateResponse, error) {
+	return s.database.TemplateGet(ctx, id)
 }
 
-func (s *Service) ListTemplates(ctx context.Context) *api.Response {
-	i, err := s.database.TemplateList(ctx)
-	return s.response(ctx, "ListTemplates", nil, i, err)
+func (s *Service) UpdateTemplate(ctx context.Context, id string, form *model.TicketTemplateForm) (doc *model.TicketTemplateResponse, err error) {
+	defer s.publishRequest(ctx, err, "UpdateTemplate", templateResponseID(doc))
+	return s.database.TemplateUpdate(ctx, id, form)
+}
+
+func (s *Service) DeleteTemplate(ctx context.Context, id string) (err error) {
+	defer s.publishRequest(ctx, err, "DeleteTemplate", templateID(id))
+	return s.database.TemplateDelete(ctx, id)
 }

service/ticket.go

@@ -5,18 +5,25 @@ import (
 	"fmt"
 
 	"github.com/arangodb/go-driver"
+	"github.com/google/uuid"
 
 	"github.com/SecurityBrewery/catalyst/database"
-	"github.com/SecurityBrewery/catalyst/generated/models"
-	"github.com/SecurityBrewery/catalyst/generated/restapi/api"
-	"github.com/SecurityBrewery/catalyst/generated/restapi/operations/tickets"
+	"github.com/SecurityBrewery/catalyst/generated/model"
 )
 
-func ticketID(id int64) []driver.DocumentID {
-	return []driver.DocumentID{driver.DocumentID(fmt.Sprintf("%s/%d", database.TicketCollectionName, id))}
+func ticketWithTicketsID(ticketResponse *model.TicketWithTickets) []driver.DocumentID {
+	if ticketResponse == nil {
+		return nil
+	}
+	return ticketID(ticketResponse.ID)
 }
 
-func ticketIDs(ticketResponses []*models.TicketResponse) []driver.DocumentID {
+func ticketID(ticketID int64) []driver.DocumentID {
+	id := fmt.Sprintf("%s/%d", database.TicketCollectionName, ticketID)
+	return []driver.DocumentID{driver.DocumentID(id)}
+}
+
+func ticketIDs(ticketResponses []*model.TicketResponse) []driver.DocumentID {
 	var ids []driver.DocumentID
 	for _, ticketResponse := range ticketResponses {
 		ids = append(ids, ticketID(ticketResponse.ID)...)
@@ -24,48 +31,161 @@ func ticketIDs(ticketResponses []*models.TicketResponse) []driver.DocumentID {
 	return ids
 }
 
-func (s *Service) CreateTicket(ctx context.Context, params *tickets.CreateTicketParams) *api.Response {
-	createdTickets, err := s.database.TicketBatchCreate(ctx, []*models.TicketForm{params.Ticket})
-	if len(createdTickets) > 0 {
-		return s.response(ctx, "CreateTicket", ticketIDs(createdTickets), createdTickets[0], err)
-	}
-	return s.response(ctx, "CreateTicket", ticketIDs(createdTickets), nil, err)
-}
-
-func (s *Service) CreateTicketBatch(ctx context.Context, params *tickets.CreateTicketBatchParams) *api.Response {
-	ticketBatch, err := s.database.TicketBatchCreate(ctx, params.Ticket)
-	return s.response(ctx, "CreateTicketBatch", ticketIDs(ticketBatch), nil, err)
-}
-
-func (s *Service) GetTicket(ctx context.Context, params *tickets.GetTicketParams) *api.Response {
-	ticket, err := s.database.TicketGet(ctx, params.ID)
-	return s.response(ctx, "GetTicket", nil, ticket, err)
-}
-
-func (s *Service) UpdateTicket(ctx context.Context, params *tickets.UpdateTicketParams) *api.Response {
-	ticket, err := s.database.TicketUpdate(ctx, params.ID, params.Ticket)
-	return s.response(ctx, "UpdateTicket", ticketID(ticket.ID), ticket, err)
-}
-
-func (s *Service) DeleteTicket(ctx context.Context, params *tickets.DeleteTicketParams) *api.Response {
-	if err := s.database.TicketDelete(ctx, params.ID); err != nil {
-		return s.response(ctx, "DeleteTicket", ticketID(params.ID), nil, err)
-	}
-
-	_ = s.storage.DeleteBucket(fmt.Sprint(params.ID))
-	return s.response(ctx, "DeleteTicket", ticketID(params.ID), nil, nil)
-}
-
-func (s *Service) ListTickets(ctx context.Context, params *tickets.ListTicketsParams) *api.Response {
+func (s *Service) ListTickets(ctx context.Context, s3 *string, i *int, i2 *int, strings []string, bools []bool, s2 *string) (*model.TicketList, error) {
 	q := ""
-	if params.Query != nil && *params.Query != "" {
-		q = *params.Query
+	if s2 != nil && *s2 != "" {
+		q = *s2
 	}
 	t := ""
-	if params.Type != nil && *params.Type != "" {
-		t = *params.Type
+	if s3 != nil && *s3 != "" {
+		t = *s3
 	}
 
-	ticketList, err := s.database.TicketList(ctx, t, q, params.Sort, params.Desc, *params.Offset, *params.Count)
-	return s.response(ctx, "ListTickets", nil, ticketList, err)
+	offset := int64(0)
+	if i != nil {
+		offset = int64(*i)
+	}
+
+	count := int64(25)
+	if i2 != nil {
+		count = int64(*i2)
+	}
+
+	return s.database.TicketList(ctx, t, q, strings, bools, offset, count)
+}
+
+func (s *Service) CreateTicket(ctx context.Context, form *model.TicketForm) (doc *model.TicketResponse, err error) {
+	createdTickets, err := s.database.TicketBatchCreate(ctx, []*model.TicketForm{form})
+	defer s.publishRequest(ctx, err, "CreateTicket", ticketIDs(createdTickets))
+	if len(createdTickets) > 0 {
+		return createdTickets[0], err
+	}
+	return nil, err
+}
+
+func (s *Service) CreateTicketBatch(ctx context.Context, forms []*model.TicketForm) error {
+	createdTickets, err := s.database.TicketBatchCreate(ctx, forms)
+	defer s.publishRequest(ctx, err, "CreateTicket", ticketIDs(createdTickets))
+	return err
+}
+
+func (s *Service) GetTicket(ctx context.Context, i int64) (*model.TicketWithTickets, error) {
+	return s.database.TicketGet(ctx, i)
+}
+
+func (s *Service) UpdateTicket(ctx context.Context, i int64, ticket *model.Ticket) (doc *model.TicketWithTickets, err error) {
+	defer s.publishRequest(ctx, err, "UpdateTicket", ticketWithTicketsID(doc))
+	return s.database.TicketUpdate(ctx, i, ticket)
+}
+
+func (s *Service) DeleteTicket(ctx context.Context, i int64) (err error) {
+	defer s.publishRequest(ctx, err, "DeleteTicket", ticketID(i))
+	return s.database.TicketDelete(ctx, i)
+}
+
+func (s *Service) AddArtifact(ctx context.Context, i int64, artifact *model.Artifact) (doc *model.TicketWithTickets, err error) {
+	defer s.publishRequest(ctx, err, "AddArtifact", ticketWithTicketsID(doc))
+	return s.database.AddArtifact(ctx, i, artifact)
+}
+
+func (s *Service) GetArtifact(ctx context.Context, i int64, s2 string) (*model.Artifact, error) {
+	return s.database.ArtifactGet(ctx, i, s2)
+}
+
+func (s *Service) SetArtifact(ctx context.Context, i int64, s2 string, artifact *model.Artifact) (doc *model.TicketWithTickets, err error) {
+	defer s.publishRequest(ctx, err, "SetArtifact", ticketWithTicketsID(doc))
+	return s.database.ArtifactUpdate(ctx, i, s2, artifact)
+}
+
+func (s *Service) RemoveArtifact(ctx context.Context, i int64, s2 string) (doc *model.TicketWithTickets, err error) {
+	defer s.publishRequest(ctx, err, "RemoveArtifact", ticketWithTicketsID(doc))
+	return s.database.RemoveArtifact(ctx, i, s2)
+}
+
+func (s *Service) EnrichArtifact(ctx context.Context, i int64, s2 string, form *model.EnrichmentForm) (doc *model.TicketWithTickets, err error) {
+	defer s.publishRequest(ctx, err, "EnrichArtifact", ticketWithTicketsID(doc))
+	return s.database.EnrichArtifact(ctx, i, s2, form)
+}
+
+func (s *Service) RunArtifact(ctx context.Context, id int64, name string, automation string) error {
+	artifact, err := s.database.ArtifactGet(ctx, id, name)
+	if err != nil {
+		return err
+	}
+
+	defer s.publishRequest(ctx, err, "RunArtifact", ticketID(id))
+
+	jobID := uuid.NewString()
+	origin := &model.Origin{ArtifactOrigin: &model.ArtifactOrigin{TicketId: id, Artifact: name}}
+	return s.bus.PublishJob(jobID, automation, name, &model.Context{Artifact: artifact}, origin)
+}
+
+func (s *Service) AddComment(ctx context.Context, i int64, form *model.CommentForm) (doc *model.TicketWithTickets, err error) {
+	defer s.publishRequest(ctx, err, "AddComment", ticketWithTicketsID(doc))
+	return s.database.AddComment(ctx, i, form)
+}
+
+func (s *Service) RemoveComment(ctx context.Context, i int64, i2 int) (doc *model.TicketWithTickets, err error) {
+	defer s.publishRequest(ctx, err, "RemoveComment", ticketWithTicketsID(doc))
+	return s.database.RemoveComment(ctx, i, int64(i2))
+}
+
+func (s *Service) LinkFiles(ctx context.Context, i int64, files []*model.File) (doc *model.TicketWithTickets, err error) {
+	defer s.publishRequest(ctx, err, "LinkFiles", ticketWithTicketsID(doc))
+	return s.database.LinkFiles(ctx, i, files)
+}
+
+func (s *Service) AddTicketPlaybook(ctx context.Context, i int64, form *model.PlaybookTemplateForm) (doc *model.TicketWithTickets, err error) {
+	defer s.publishRequest(ctx, err, "AddTicketPlaybook", ticketWithTicketsID(doc))
+	return s.database.AddTicketPlaybook(ctx, i, form)
+}
+
+func (s *Service) RemoveTicketPlaybook(ctx context.Context, i int64, s2 string) (doc *model.TicketWithTickets, err error) {
+	defer s.publishRequest(ctx, err, "RemoveTicketPlaybook", ticketWithTicketsID(doc))
+	return s.database.RemoveTicketPlaybook(ctx, i, s2)
+}
+
+func (s *Service) SetTask(ctx context.Context, i int64, s3 string, s2 string, task *model.Task) (doc *model.TicketWithTickets, err error) {
+	defer s.publishRequest(ctx, err, "SetTask", ticketWithTicketsID(doc))
+	return s.database.TaskUpdate(ctx, i, s3, s2, task)
+}
+
+func (s *Service) CompleteTask(ctx context.Context, i int64, s3 string, s2 string, m map[string]interface{}) (doc *model.TicketWithTickets, err error) {
+	defer s.publishRequest(ctx, err, "CompleteTask", ticketWithTicketsID(doc))
+	return s.database.TaskComplete(ctx, i, s3, s2, m)
+}
+
+func (s *Service) RunTask(ctx context.Context, i int64, s3 string, s2 string) (err error) {
+	defer s.publishRequest(ctx, err, "RunTask", ticketID(i))
+	return s.database.TaskRun(ctx, i, s3, s2)
+}
+
+func (s *Service) SetReferences(ctx context.Context, i int64, references []*model.Reference) (doc *model.TicketWithTickets, err error) {
+	defer s.publishRequest(ctx, err, "SetReferences", ticketID(i))
+	return s.database.SetReferences(ctx, i, references)
+}
+
+func (s *Service) SetSchema(ctx context.Context, i int64, s2 string) (doc *model.TicketWithTickets, err error) {
+	defer s.publishRequest(ctx, err, "SetSchema", ticketID(i))
+	return s.database.SetTemplate(ctx, i, s2)
+}
+
+func (s *Service) LinkTicket(ctx context.Context, i int64, i2 int64) (*model.TicketWithTickets, error) {
+	err := s.database.RelatedCreate(ctx, i, i2)
+	if err != nil {
+		return nil, err
+	}
+	defer s.publishRequest(ctx, err, "LinkTicket", ticketID(i))
+
+	return s.GetTicket(ctx, i)
+}
+
+func (s *Service) UnlinkTicket(ctx context.Context, i int64, i2 int64) (*model.TicketWithTickets, error) {
+	err := s.database.RelatedRemove(ctx, i, i2)
+	if err != nil {
+		return nil, err
+	}
+	defer s.publishRequest(ctx, err, "UnlinkTicket", ticketID(i))
+
+	return s.GetTicket(ctx, i)
 }

service/ticket_field.go

@@ -1,88 +0,0 @@
-package service
-
-import (
-	"context"
-
-	"github.com/SecurityBrewery/catalyst/generated/restapi/api"
-	"github.com/SecurityBrewery/catalyst/generated/restapi/operations/tickets"
-)
-
-func (s *Service) AddArtifact(ctx context.Context, params *tickets.AddArtifactParams) *api.Response {
-	i, err := s.database.AddArtifact(ctx, params.ID, params.Artifact)
-	return s.response(ctx, "AddArtifact", ticketID(params.ID), i, err)
-}
-
-func (s *Service) RemoveArtifact(ctx context.Context, params *tickets.RemoveArtifactParams) *api.Response {
-	i, err := s.database.RemoveArtifact(ctx, params.ID, params.Name)
-	return s.response(ctx, "RemoveArtifact", ticketID(params.ID), i, err)
-}
-
-func (s *Service) SetSchema(ctx context.Context, params *tickets.SetSchemaParams) *api.Response {
-	i, err := s.database.SetTemplate(ctx, params.ID, params.Schema)
-	return s.response(ctx, "SetSchema", ticketID(params.ID), i, err)
-}
-
-func (s *Service) AddComment(ctx context.Context, params *tickets.AddCommentParams) *api.Response {
-	i, err := s.database.AddComment(ctx, params.ID, params.Comment)
-	return s.response(ctx, "AddComment", ticketID(params.ID), i, err)
-}
-
-func (s *Service) RemoveComment(ctx context.Context, params *tickets.RemoveCommentParams) *api.Response {
-	i, err := s.database.RemoveComment(ctx, params.ID, params.CommentID)
-	return s.response(ctx, "RemoveComment", ticketID(params.ID), i, err)
-}
-
-func (s *Service) LinkTicket(ctx context.Context, params *tickets.LinkTicketParams) *api.Response {
-	err := s.database.RelatedCreate(ctx, params.ID, params.LinkedID)
-	if err != nil {
-		return s.response(ctx, "LinkTicket", ticketID(params.ID), nil, err)
-	}
-
-	i, err := s.database.TicketGet(ctx, params.ID)
-	return s.response(ctx, "LinkTicket", ticketID(params.ID), i, err)
-}
-
-func (s *Service) UnlinkTicket(ctx context.Context, params *tickets.UnlinkTicketParams) *api.Response {
-	err := s.database.RelatedRemove(ctx, params.ID, params.LinkedID)
-	if err != nil {
-		return s.response(ctx, "UnlinkTicket", ticketID(params.ID), nil, err)
-	}
-
-	i, err := s.database.TicketGet(ctx, params.ID)
-	return s.response(ctx, "UnlinkTicket", ticketID(params.ID), i, err)
-}
-
-func (s Service) SetReferences(ctx context.Context, params *tickets.SetReferencesParams) *api.Response {
-	i, err := s.database.SetReferences(ctx, params.ID, params.References)
-	return s.response(ctx, "SetReferences", ticketID(params.ID), i, err)
-}
-
-func (s Service) LinkFiles(ctx context.Context, params *tickets.LinkFilesParams) *api.Response {
-	i, err := s.database.LinkFiles(ctx, params.ID, params.Files)
-	return s.response(ctx, "LinkFiles", ticketID(params.ID), i, err)
-}
-
-func (s Service) AddTicketPlaybook(ctx context.Context, params *tickets.AddTicketPlaybookParams) *api.Response {
-	i, err := s.database.AddTicketPlaybook(ctx, params.ID, params.Playbook)
-	return s.response(ctx, "AddTicketPlaybook", ticketID(params.ID), i, err)
-}
-
-func (s Service) RemoveTicketPlaybook(ctx context.Context, params *tickets.RemoveTicketPlaybookParams) *api.Response {
-	i, err := s.database.RemoveTicketPlaybook(ctx, params.ID, params.PlaybookID)
-	return s.response(ctx, "RemoveTicketPlaybook", ticketID(params.ID), i, err)
-}
-
-func (s Service) CompleteTask(ctx context.Context, params *tickets.CompleteTaskParams) *api.Response {
-	i, err := s.database.TaskComplete(ctx, params.ID, params.PlaybookID, params.TaskID, params.Data)
-	return s.response(ctx, "CompleteTask", ticketID(params.ID), i, err)
-}
-
-func (s Service) SetTask(ctx context.Context, params *tickets.SetTaskParams) *api.Response {
-	i, err := s.database.TaskUpdate(ctx, params.ID, params.PlaybookID, params.TaskID, params.Task)
-	return s.response(ctx, "SetTask", ticketID(params.ID), i, err)
-}
-
-func (s *Service) RunTask(ctx context.Context, params *tickets.RunTaskParams) *api.Response {
-	err := s.database.TaskRun(ctx, params.ID, params.PlaybookID, params.TaskID)
-	return s.response(ctx, "RunTask", ticketID(params.ID), nil, err)
-}

service/tickettype.go

@@ -7,35 +7,39 @@ import (
 	"github.com/arangodb/go-driver"
 
 	"github.com/SecurityBrewery/catalyst/database"
-	"github.com/SecurityBrewery/catalyst/generated/restapi/api"
-	"github.com/SecurityBrewery/catalyst/generated/restapi/operations/tickettypes"
+	"github.com/SecurityBrewery/catalyst/generated/model"
 )
 
+func ticketTypeResponseID(ticketType *model.TicketTypeResponse) []driver.DocumentID {
+	if ticketType == nil {
+		return nil
+	}
+	return userDataID(ticketType.ID)
+}
+
 func ticketTypeID(id string) []driver.DocumentID {
-	return []driver.DocumentID{driver.DocumentID(fmt.Sprintf("%s/%s", database.TicketTypeCollectionName, id))}
+	return []driver.DocumentID{driver.DocumentID(fmt.Sprintf("%s/%s", database.UserDataCollectionName, id))}
 }
 
-func (s *Service) CreateTicketType(ctx context.Context, params *tickettypes.CreateTicketTypeParams) *api.Response {
-	ticketType, err := s.database.TicketTypeCreate(ctx, params.Tickettype)
-	return s.response(ctx, "CreateTicketType", ticketTypeID(ticketType.ID), ticketType, err)
+func (s *Service) ListTicketTypes(ctx context.Context) ([]*model.TicketTypeResponse, error) {
+	return s.database.TicketTypeList(ctx)
 }
 
-func (s *Service) GetTicketType(ctx context.Context, params *tickettypes.GetTicketTypeParams) *api.Response {
-	ticketType, err := s.database.TicketTypeGet(ctx, params.ID)
-	return s.response(ctx, "GetTicketType", nil, ticketType, err)
+func (s *Service) CreateTicketType(ctx context.Context, form *model.TicketTypeForm) (doc *model.TicketTypeResponse, err error) {
+	defer s.publishRequest(ctx, err, "CreateTicketType", ticketTypeResponseID(doc))
+	return s.database.TicketTypeCreate(ctx, form)
 }
 
-func (s *Service) UpdateTicketType(ctx context.Context, params *tickettypes.UpdateTicketTypeParams) *api.Response {
-	ticketType, err := s.database.TicketTypeUpdate(ctx, params.ID, params.Tickettype)
-	return s.response(ctx, "UpdateTicketType", ticketTypeID(ticketType.ID), ticketType, err)
+func (s *Service) GetTicketType(ctx context.Context, id string) (*model.TicketTypeResponse, error) {
+	return s.database.TicketTypeGet(ctx, id)
 }
 
-func (s *Service) DeleteTicketType(ctx context.Context, params *tickettypes.DeleteTicketTypeParams) *api.Response {
-	err := s.database.TicketTypeDelete(ctx, params.ID)
-	return s.response(ctx, "DeleteTicketType", ticketTypeID(params.ID), nil, err)
+func (s *Service) UpdateTicketType(ctx context.Context, id string, form *model.TicketTypeForm) (doc *model.TicketTypeResponse, err error) {
+	defer s.publishRequest(ctx, err, "UpdateTicketType", ticketTypeResponseID(doc))
+	return s.database.TicketTypeUpdate(ctx, id, form)
 }
 
-func (s *Service) ListTicketTypes(ctx context.Context) *api.Response {
-	ticketTypes, err := s.database.TicketTypeList(ctx)
-	return s.response(ctx, "ListTicketTypes", nil, ticketTypes, err)
+func (s *Service) DeleteTicketType(ctx context.Context, id string) (err error) {
+	defer s.publishRequest(ctx, err, "DeleteTicketType", ticketTypeID(id))
+	return s.database.TicketTypeDelete(ctx, id)
 }

service/uisettings.go

@@ -6,35 +6,34 @@ import (
 	"sort"
 
 	"github.com/SecurityBrewery/catalyst/database/busdb"
-	"github.com/SecurityBrewery/catalyst/generated/models"
-	"github.com/SecurityBrewery/catalyst/generated/restapi/api"
+	"github.com/SecurityBrewery/catalyst/generated/model"
 	"github.com/SecurityBrewery/catalyst/role"
 )
 
-func (s *Service) GetSettings(ctx context.Context) *api.Response {
+func (s *Service) GetSettings(ctx context.Context) (*model.Settings, error) {
 	user, ok := busdb.UserFromContext(ctx)
 	if !ok {
-		return s.response(ctx, "GetSettings", nil, nil, errors.New("no user in context"))
+		return nil, errors.New("no user in context")
 	}
 
 	setting, err := s.database.UserDataGet(ctx, user.ID)
 	if err != nil {
-		return s.response(ctx, "GetSettings", nil, nil, err)
+		return nil, err
 	}
 
 	settings := mergeSettings(s.settings, setting)
 
 	ticketTypeList, err := s.database.TicketTypeList(ctx)
 	if err != nil {
-		return s.response(ctx, "GetSettings", nil, nil, err)
+		return nil, err
 	}
 
 	settings.TicketTypes = ticketTypeList
 
-	return s.response(ctx, "GetSettings", nil, settings, nil)
+	return settings, nil
 }
 
-func mergeSettings(globalSettings *models.Settings, user *models.UserDataResponse) *models.Settings {
+func mergeSettings(globalSettings *model.Settings, user *model.UserDataResponse) *model.Settings {
 	if user.Timeformat != nil {
 		globalSettings.Timeformat = *user.Timeformat
 	}

service/user.go

@@ -9,43 +9,55 @@ import (
 
 	"github.com/SecurityBrewery/catalyst/database"
 	"github.com/SecurityBrewery/catalyst/database/busdb"
-	"github.com/SecurityBrewery/catalyst/generated/restapi/api"
-	"github.com/SecurityBrewery/catalyst/generated/restapi/operations/users"
+	"github.com/SecurityBrewery/catalyst/generated/model"
 )
 
+func newUserResponseID(user *model.NewUserResponse) []driver.DocumentID {
+	if user == nil {
+		return nil
+	}
+	return userID(user.ID)
+}
+
+func userResponseID(user *model.UserResponse) []driver.DocumentID {
+	if user == nil {
+		return nil
+	}
+	return userID(user.ID)
+}
+
 func userID(id string) []driver.DocumentID {
 	return []driver.DocumentID{driver.DocumentID(fmt.Sprintf("%s/%s", database.UserCollectionName, id))}
 }
 
-func (s *Service) GetUser(ctx context.Context, params *users.GetUserParams) *api.Response {
-	i, err := s.database.UserGet(ctx, params.ID)
-	return s.response(ctx, "GetUser", nil, i, err)
+func (s *Service) ListUsers(ctx context.Context) ([]*model.UserResponse, error) {
+	return s.database.UserList(ctx)
 }
 
-func (s *Service) ListUsers(ctx context.Context) *api.Response {
-	i, err := s.database.UserList(ctx)
-	return s.response(ctx, "ListUsers", nil, i, err)
+func (s *Service) CreateUser(ctx context.Context, form *model.UserForm) (doc *model.NewUserResponse, err error) {
+	defer s.publishRequest(ctx, err, "CreateUser", newUserResponseID(doc))
+	return s.database.UserCreate(ctx, form)
 }
 
-func (s *Service) CreateUser(ctx context.Context, params *users.CreateUserParams) *api.Response {
-	i, err := s.database.UserCreate(ctx, params.User)
-	return s.response(ctx, "CreateUser", userID(i.ID), i, err)
+func (s *Service) GetUser(ctx context.Context, s2 string) (*model.UserResponse, error) {
+	return s.database.UserGet(ctx, s2)
 }
 
-func (s *Service) DeleteUser(ctx context.Context, params *users.DeleteUserParams) *api.Response {
-	err := s.database.UserDelete(ctx, params.ID)
-	return s.response(ctx, "DeleteUser", userID(params.ID), nil, err)
+func (s *Service) UpdateUser(ctx context.Context, s2 string, form *model.UserForm) (doc *model.UserResponse, err error) {
+	defer s.publishRequest(ctx, err, "UpdateUser", userID(s2))
+	return s.database.UserUpdate(ctx, s2, form)
 }
 
-func (s *Service) CurrentUser(ctx context.Context) *api.Response {
+func (s *Service) DeleteUser(ctx context.Context, s2 string) (err error) {
+	defer s.publishRequest(ctx, err, "DeleteUser", userID(s2))
+	return s.database.UserDelete(ctx, s2)
+}
+
+func (s *Service) CurrentUser(ctx context.Context) (*model.UserResponse, error) {
 	user, ok := busdb.UserFromContext(ctx)
 	if !ok {
-		return s.response(ctx, "CurrentUser", nil, nil, errors.New("no user in context"))
+		return nil, errors.New("no user in context")
 	}
-	return s.response(ctx, "CurrentUser", nil, user, nil)
-}
-
-func (s *Service) UpdateUser(ctx context.Context, params *users.UpdateUserParams) *api.Response {
-	i, err := s.database.UserUpdate(ctx, params.ID, params.User)
-	return s.response(ctx, "UpdateUser", userID(i.ID), i, err)
+	s.publishRequest(ctx, nil, "CurrentUser", userResponseID(user))
+	return user, nil
 }

service/userdata.go

@@ -9,44 +9,48 @@ import (
 
 	"github.com/SecurityBrewery/catalyst/database"
 	"github.com/SecurityBrewery/catalyst/database/busdb"
-	"github.com/SecurityBrewery/catalyst/generated/restapi/api"
-	"github.com/SecurityBrewery/catalyst/generated/restapi/operations/userdata"
+	"github.com/SecurityBrewery/catalyst/generated/model"
 )
 
-func userdataID(id string) []driver.DocumentID {
+func userDataResponseID(userData *model.UserDataResponse) []driver.DocumentID {
+	if userData == nil {
+		return nil
+	}
+	return userDataID(userData.ID)
+}
+
+func userDataID(id string) []driver.DocumentID {
 	return []driver.DocumentID{driver.DocumentID(fmt.Sprintf("%s/%s", database.UserDataCollectionName, id))}
 }
 
-func (s *Service) GetUserData(ctx context.Context, params *userdata.GetUserDataParams) *api.Response {
-	userData, err := s.database.UserDataGet(ctx, params.ID)
-	return s.response(ctx, "GetUserData", nil, userData, err)
+func (s *Service) ListUserData(ctx context.Context) (doc []*model.UserDataResponse, err error) {
+	return s.database.UserDataList(ctx)
 }
 
-func (s *Service) ListUserData(ctx context.Context) *api.Response {
-	userData, err := s.database.UserDataList(ctx)
-	return s.response(ctx, "ListUserData", nil, userData, err)
+func (s *Service) GetUserData(ctx context.Context, id string) (*model.UserDataResponse, error) {
+	return s.database.UserDataGet(ctx, id)
 }
 
-func (s *Service) UpdateUserData(ctx context.Context, params *userdata.UpdateUserDataParams) *api.Response {
-	userData, err := s.database.UserDataUpdate(ctx, params.ID, params.Userdata)
-	return s.response(ctx, "UpdateUserData", userdataID(userData.ID), userData, err)
+func (s *Service) UpdateUserData(ctx context.Context, id string, data *model.UserData) (doc *model.UserDataResponse, err error) {
+	defer s.publishRequest(ctx, err, "CreateUser", userDataResponseID(doc))
+	return s.database.UserDataUpdate(ctx, id, data)
 }
 
-func (s *Service) CurrentUserData(ctx context.Context) *api.Response {
+func (s *Service) CurrentUserData(ctx context.Context) (doc *model.UserDataResponse, err error) {
 	user, ok := busdb.UserFromContext(ctx)
 	if !ok {
-		return s.response(ctx, "CurrentUserData", userdataID(user.ID), nil, errors.New("no user in context"))
+		return nil, errors.New("no user in context")
 	}
-	userData, err := s.database.UserDataGet(ctx, user.ID)
-	return s.response(ctx, "GetUserData", nil, userData, err)
+
+	return s.database.UserDataGet(ctx, user.ID)
 }
 
-func (s *Service) UpdateCurrentUserData(ctx context.Context, params *userdata.UpdateCurrentUserDataParams) *api.Response {
+func (s *Service) UpdateCurrentUserData(ctx context.Context, data *model.UserData) (doc *model.UserDataResponse, err error) {
 	user, ok := busdb.UserFromContext(ctx)
 	if !ok {
-		return s.response(ctx, "UpdateCurrentUserData", userdataID(user.ID), nil, errors.New("no user in context"))
+		return nil, errors.New("no user in context")
 	}
 
-	userData, err := s.database.UserDataUpdate(ctx, user.ID, params.Userdata)
-	return s.response(ctx, "UpdateCurrentUserData", userdataID(user.ID), userData, err)
+	defer s.publishRequest(ctx, err, "UpdateCurrentUserData", userDataResponseID(doc))
+	return s.database.UserDataUpdate(ctx, user.ID, data)
 }