CSEC_PUBLIC/catalyst
1
0
Fork 0
mirror of https://github.com/SecurityBrewery/catalyst.git synced 2025-12-06 15:22:47 +01:00
Code Issues Packages Projects Releases Wiki Activity

Improve bus (#3)

Browse Source 
* Improve bus
* Add ticket log
This commit is contained in:
Jonas Plum
2021-12-27 19:08:07 +01:00
committed by GitHub
parent 1fade14ba5
commit b5dd0cfacd
50 changed files with 756 additions and 456 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
service/artifact.go
View File

@@ -10,25 +10,29 @@ import (
"github.com/SecurityBrewery/catalyst/generated/restapi/operations/tickets"
)
func (s *Service) RunArtifact(ctx context.Context, params *tickets.RunArtifactParams) *api.Response {
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 response(nil, err)
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}}
return response(nil, s.bus.PublishJob(jobID, params.Automation, params.Name, &models.Context{Artifact: artifact}, origin))
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 {
return response(s.database.EnrichArtifact(ctx, params.ID, params.Name, params.Data))
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 {
return response(s.database.ArtifactUpdate(ctx, params.ID, params.Name, params.Artifact))
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 {
return response(s.database.ArtifactGet(ctx, params.ID, params.Name))
i, err := s.database.ArtifactGet(ctx, params.ID, params.Name)
return s.response(ctx, "GetArtifact", nil, i, err)
}

23
service/automation.go
View File

@@ -2,27 +2,40 @@ package service
import (
"context"
"fmt"
"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"
)
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 {
return response(s.database.AutomationCreate(ctx, params.Automation))
i, err := s.database.AutomationCreate(ctx, params.Automation)
return s.response(ctx, "CreateAutomation", automationID(i.ID), i, err)
}
func (s *Service) GetAutomation(ctx context.Context, params *automations.GetAutomationParams) *api.Response {
return response(s.database.AutomationGet(ctx, params.ID))
i, err := s.database.AutomationGet(ctx, params.ID)
return s.response(ctx, "GetAutomation", nil, i, err)
}
func (s *Service) UpdateAutomation(ctx context.Context, params *automations.UpdateAutomationParams) *api.Response {
return response(s.database.AutomationUpdate(ctx, params.ID, params.Automation))
i, err := s.database.AutomationUpdate(ctx, params.ID, params.Automation)
return s.response(ctx, "UpdateAutomation", automationID(i.ID), i, err)
}
func (s *Service) DeleteAutomation(ctx context.Context, params *automations.DeleteAutomationParams) *api.Response {
return response(nil, s.database.AutomationDelete(ctx, params.ID))
err := s.database.AutomationDelete(ctx, params.ID)
return s.response(ctx, "DeleteAutomation", automationID(params.ID), nil, err)
}
func (s *Service) ListAutomations(ctx context.Context) *api.Response {
return response(s.database.AutomationList(ctx))
i, err := s.database.AutomationList(ctx)
return s.response(ctx, "ListAutomations", nil, i, err)
}

22
service/job.go
View File

@@ -2,28 +2,38 @@ package service
import (
"context"
"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/jobs"
)
func (s *Service) RunJob(_ context.Context, params *jobs.RunJobParams) *api.Response {
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{}
jobID := uuid.NewString()
return response(nil, s.bus.PublishJob(jobID, params.Job.Automation, params.Job.Payload, msgContext, params.Job.Origin))
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))
}
func (s *Service) GetJob(ctx context.Context, params *jobs.GetJobParams) *api.Response {
return response(s.database.JobGet(ctx, params.ID))
i, err := s.database.JobGet(ctx, params.ID)
return s.response(ctx, "GetJob", nil, i, err)
}
func (s *Service) ListJobs(ctx context.Context) *api.Response {
return response(s.database.JobList(ctx))
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 {
return response(s.database.JobUpdate(ctx, params.ID, params.Job))
i, err := s.database.JobUpdate(ctx, params.ID, params.Job)
return s.response(ctx, "UpdateJob", jobID(i.ID), i, err)
}

3
service/log.go
View File

@@ -10,5 +10,6 @@ import (
func (s *Service) GetLogs(ctx context.Context, params *logs.GetLogsParams) *api.Response {
id, _ := url.QueryUnescape(params.Reference)
return response(s.database.LogList(ctx, id))
i, err := s.database.LogList(ctx, id)
return s.response(ctx, "GetLogs", nil, i, err)
}

23
service/playbook.go
View File

@@ -5,35 +5,46 @@ import (
"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"
)
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 {
return response(s.database.PlaybookCreate(ctx, params.Playbook))
i, err := s.database.PlaybookCreate(ctx, params.Playbook)
return s.response(ctx, "CreatePlaybook", playbookID(i.ID), i, err)
}
func (s *Service) GetPlaybook(ctx context.Context, params *playbooks.GetPlaybookParams) *api.Response {
return response(s.database.PlaybookGet(ctx, params.ID))
i, err := s.database.PlaybookGet(ctx, params.ID)
return s.response(ctx, "GetPlaybook", nil, i, err)
}
func (s *Service) UpdatePlaybook(ctx context.Context, params *playbooks.UpdatePlaybookParams) *api.Response {
if err := validate(params.Playbook, models.PlaybookTemplateFormSchema); err != nil {
return response(nil, err)
return s.response(ctx, "UpdatePlaybook", nil, nil, err)
}
return response(s.database.PlaybookUpdate(ctx, params.ID, params.Playbook))
i, err := s.database.PlaybookUpdate(ctx, params.ID, params.Playbook)
return s.response(ctx, "UpdatePlaybook", playbookID(i.ID), i, err)
}
func (s *Service) DeletePlaybook(ctx context.Context, params *playbooks.DeletePlaybookParams) *api.Response {
return response(nil, s.database.PlaybookDelete(ctx, params.ID))
err := s.database.PlaybookDelete(ctx, params.ID)
return s.response(ctx, "DeletePlaybook", playbookID(params.ID), nil, err)
}
func (s *Service) ListPlaybooks(ctx context.Context) *api.Response {
return response(s.database.PlaybookList(ctx))
i, err := s.database.PlaybookList(ctx)
return s.response(ctx, "ListPlaybooks", nil, i, err)
}
func validate(e interface{}, schema *gojsonschema.Schema) error {

15
service/service.go
View File

@@ -1,6 +1,7 @@
package service
import (
"context"
"errors"
"log"
"net/http"
@@ -10,6 +11,7 @@ import (
"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/storage"
@@ -30,11 +32,22 @@ func (s *Service) Healthy() bool {
return true
}
func response(v interface{}, err error) *api.Response {
func (s *Service) response(ctx context.Context, function string, ids []driver.DocumentID, v interface{}, err error) *api.Response {
if err != nil {
log.Println(err)
return &api.Response{Code: httpStatus(err), Body: gin.H{"error": err.Error()}}
}
if ids != nil {
userID := "unknown"
user, ok := busdb.UserFromContext(ctx)
if ok {
userID = user.ID
}
go s.bus.PublishRequest(userID, function, ids)
}
if v == nil {
return &api.Response{Code: http.StatusNoContent, Body: v}
}

3
service/statistics.go
View File

@@ -7,5 +7,6 @@ import (
)
func (s *Service) GetStatistics(ctx context.Context) *api.Response {
return response(s.database.Statistics(ctx))
i, err := s.database.Statistics(ctx)
return s.response(ctx, "GetStatistics", nil, i, err)
}

3
service/task.go
View File

@@ -7,5 +7,6 @@ import (
)
func (s *Service) ListTasks(ctx context.Context) *api.Response {
return response(s.database.TaskList(ctx))
i, err := s.database.TaskList(ctx)
return s.response(ctx, "ListTasks", nil, i, err)
}

23
service/template.go
View File

@@ -2,27 +2,40 @@ package service
import (
"context"
"fmt"
"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"
)
func templateID(s string) []driver.DocumentID {
return []driver.DocumentID{driver.DocumentID(fmt.Sprintf("%s/%s", database.TemplateCollectionName, s))}
}
func (s *Service) CreateTemplate(ctx context.Context, params *templates.CreateTemplateParams) *api.Response {
return response(s.database.TemplateCreate(ctx, params.Template))
i, err := s.database.TemplateCreate(ctx, params.Template)
return s.response(ctx, "CreateTemplate", templateID(i.ID), i, err)
}
func (s *Service) GetTemplate(ctx context.Context, params *templates.GetTemplateParams) *api.Response {
return response(s.database.TemplateGet(ctx, params.ID))
i, err := s.database.TemplateGet(ctx, params.ID)
return s.response(ctx, "GetTemplate", nil, i, err)
}
func (s *Service) UpdateTemplate(ctx context.Context, params *templates.UpdateTemplateParams) *api.Response {
return response(s.database.TemplateUpdate(ctx, params.ID, params.Template))
i, err := s.database.TemplateUpdate(ctx, params.ID, params.Template)
return s.response(ctx, "UpdateTemplate", templateID(i.ID), i, err)
}
func (s *Service) DeleteTemplate(ctx context.Context, params *templates.DeleteTemplateParams) *api.Response {
return response(nil, s.database.TemplateDelete(ctx, params.ID))
err := s.database.TemplateDelete(ctx, params.ID)
return s.response(ctx, "DeleteTemplate", templateID(params.ID), nil, err)
}
func (s *Service) ListTemplates(ctx context.Context) *api.Response {
return response(s.database.TemplateList(ctx))
i, err := s.database.TemplateList(ctx)
return s.response(ctx, "ListTemplates", nil, i, err)
}

37
service/ticket.go
View File

@@ -4,39 +4,56 @@ import (
"context"
"fmt"
"github.com/arangodb/go-driver"
"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"
)
func ticketID(id int64) []driver.DocumentID {
return []driver.DocumentID{driver.DocumentID(fmt.Sprintf("%s/%d", database.TicketCollectionName, id))}
}
func ticketIDs(ticketResponses []*models.TicketResponse) []driver.DocumentID {
var ids []driver.DocumentID
for _, ticketResponse := range ticketResponses {
ids = append(ids, ticketID(ticketResponse.ID)...)
}
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 response(createdTickets[0], err)
return s.response(ctx, "CreateTicket", ticketIDs(createdTickets), createdTickets[0], err)
}
return response(nil, err)
return s.response(ctx, "CreateTicket", ticketIDs(createdTickets), nil, err)
}
func (s *Service) CreateTicketBatch(ctx context.Context, params *tickets.CreateTicketBatchParams) *api.Response {
_, err := s.database.TicketBatchCreate(ctx, params.Ticket)
return response(nil, err)
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 {
return response(s.database.TicketGet(ctx, params.ID))
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 {
return response(s.database.TicketUpdate(ctx, params.ID, params.Ticket))
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 response(nil, err)
return s.response(ctx, "DeleteTicket", ticketID(params.ID), nil, err)
}
_ = s.storage.DeleteBucket(fmt.Sprint(params.ID))
return response(nil, nil)
return s.response(ctx, "DeleteTicket", ticketID(params.ID), nil, nil)
}
func (s *Service) ListTickets(ctx context.Context, params *tickets.ListTicketsParams) *api.Response {
@@ -48,5 +65,7 @@ func (s *Service) ListTickets(ctx context.Context, params *tickets.ListTicketsPa
if params.Type != nil && *params.Type != "" {
t = *params.Type
}
return response(s.database.TicketList(ctx, t, q, params.Sort, params.Desc, *params.Offset, *params.Count))
ticketList, err := s.database.TicketList(ctx, t, q, params.Sort, params.Desc, *params.Offset, *params.Count)
return s.response(ctx, "ListTickets", nil, ticketList, err)
}

46
service/ticket_field.go
View File

@@ -8,67 +8,81 @@ import (
)
func (s *Service) AddArtifact(ctx context.Context, params *tickets.AddArtifactParams) *api.Response {
return response(s.database.AddArtifact(ctx, params.ID, params.Artifact))
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 {
return response(s.database.RemoveArtifact(ctx, params.ID, params.Name))
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 {
return response(s.database.SetTemplate(ctx, params.ID, params.Schema))
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 {
return response(s.database.AddComment(ctx, params.ID, params.Comment))
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 {
return response(s.database.RemoveComment(ctx, params.ID, params.CommentID))
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 response(nil, err)
return s.response(ctx, "LinkTicket", ticketID(params.ID), nil, err)
}
return s.GetTicket(ctx, &tickets.GetTicketParams{ID: params.ID})
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 response(nil, err)
return s.response(ctx, "UnlinkTicket", ticketID(params.ID), nil, err)
}
return s.GetTicket(ctx, &tickets.GetTicketParams{ID: params.ID})
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 {
return response(s.database.SetReferences(ctx, params.ID, params.References))
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 {
return response(s.database.LinkFiles(ctx, params.ID, params.Files))
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 {
return response(s.database.AddTicketPlaybook(ctx, params.ID, params.Playbook))
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 {
return response(s.database.RemoveTicketPlaybook(ctx, params.ID, params.PlaybookID))
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 {
return response(s.database.TaskComplete(ctx, params.ID, params.PlaybookID, params.TaskID, params.Data))
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 {
return response(s.database.TaskUpdate(ctx, params.ID, params.PlaybookID, params.TaskID, params.Task))
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 {
return response(nil, s.database.TaskRun(ctx, params.ID, params.PlaybookID, params.TaskID))
err := s.database.TaskRun(ctx, params.ID, params.PlaybookID, params.TaskID)
return s.response(ctx, "RunTask", ticketID(params.ID), nil, err)
}

23
service/tickettype.go
View File

@@ -2,27 +2,40 @@ package service
import (
"context"
"fmt"
"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"
)
func ticketTypeID(id string) []driver.DocumentID {
return []driver.DocumentID{driver.DocumentID(fmt.Sprintf("%s/%s", database.TicketTypeCollectionName, id))}
}
func (s *Service) CreateTicketType(ctx context.Context, params *tickettypes.CreateTicketTypeParams) *api.Response {
return response(s.database.TicketTypeCreate(ctx, params.Tickettype))
ticketType, err := s.database.TicketTypeCreate(ctx, params.Tickettype)
return s.response(ctx, "CreateTicketType", ticketTypeID(ticketType.ID), ticketType, err)
}
func (s *Service) GetTicketType(ctx context.Context, params *tickettypes.GetTicketTypeParams) *api.Response {
return response(s.database.TicketTypeGet(ctx, params.ID))
ticketType, err := s.database.TicketTypeGet(ctx, params.ID)
return s.response(ctx, "GetTicketType", nil, ticketType, err)
}
func (s *Service) UpdateTicketType(ctx context.Context, params *tickettypes.UpdateTicketTypeParams) *api.Response {
return response(s.database.TicketTypeUpdate(ctx, params.ID, params.Tickettype))
ticketType, err := s.database.TicketTypeUpdate(ctx, params.ID, params.Tickettype)
return s.response(ctx, "UpdateTicketType", ticketTypeID(ticketType.ID), ticketType, err)
}
func (s *Service) DeleteTicketType(ctx context.Context, params *tickettypes.DeleteTicketTypeParams) *api.Response {
return response(nil, s.database.TicketTypeDelete(ctx, params.ID))
err := s.database.TicketTypeDelete(ctx, params.ID)
return s.response(ctx, "DeleteTicketType", ticketTypeID(params.ID), nil, err)
}
func (s *Service) ListTicketTypes(ctx context.Context) *api.Response {
return response(s.database.TicketTypeList(ctx))
ticketTypes, err := s.database.TicketTypeList(ctx)
return s.response(ctx, "ListTicketTypes", nil, ticketTypes, err)
}

8
service/uisettings.go
View File

@@ -14,24 +14,24 @@ import (
func (s *Service) GetSettings(ctx context.Context) *api.Response {
user, ok := busdb.UserFromContext(ctx)
if !ok {
return response(nil, errors.New("no user in context"))
return s.response(ctx, "GetSettings", nil, nil, errors.New("no user in context"))
}
setting, err := s.database.UserDataGet(ctx, user.ID)
if err != nil {
return response(nil, err)
return s.response(ctx, "GetSettings", nil, nil, err)
}
settings := mergeSettings(s.settings, setting)
ticketTypeList, err := s.database.TicketTypeList(ctx)
if err != nil {
return response(nil, err)
return s.response(ctx, "GetSettings", nil, nil, err)
}
settings.TicketTypes = ticketTypeList
return response(settings, nil)
return s.response(ctx, "GetSettings", nil, settings, nil)
}
func mergeSettings(globalSettings *models.Settings, user *models.UserDataResponse) *models.Settings {

27
service/user.go
View File

@@ -3,36 +3,49 @@ package service
import (
"context"
"errors"
"fmt"
"github.com/arangodb/go-driver"
"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"
)
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 {
return response(s.database.UserGet(ctx, params.ID))
i, err := s.database.UserGet(ctx, params.ID)
return s.response(ctx, "GetUser", nil, i, err)
}
func (s *Service) ListUsers(ctx context.Context) *api.Response {
return response(s.database.UserList(ctx))
i, err := s.database.UserList(ctx)
return s.response(ctx, "ListUsers", nil, i, err)
}
func (s *Service) CreateUser(ctx context.Context, params *users.CreateUserParams) *api.Response {
return response(s.database.UserCreate(ctx, params.User))
i, err := s.database.UserCreate(ctx, params.User)
return s.response(ctx, "CreateUser", userID(i.ID), i, err)
}
func (s *Service) DeleteUser(ctx context.Context, params *users.DeleteUserParams) *api.Response {
return response(nil, s.database.UserDelete(ctx, params.ID))
err := s.database.UserDelete(ctx, params.ID)
return s.response(ctx, "DeleteUser", userID(params.ID), nil, err)
}
func (s *Service) CurrentUser(ctx context.Context) *api.Response {
user, ok := busdb.UserFromContext(ctx)
if !ok {
return response(nil, errors.New("no user in context"))
return s.response(ctx, "CurrentUser", nil, nil, errors.New("no user in context"))
}
return response(user, nil)
return s.response(ctx, "CurrentUser", nil, user, nil)
}
func (s *Service) UpdateUser(ctx context.Context, params *users.UpdateUserParams) *api.Response {
return response(s.database.UserUpdate(ctx, params.ID, params.User))
i, err := s.database.UserUpdate(ctx, params.ID, params.User)
return s.response(ctx, "UpdateUser", userID(i.ID), i, err)
}

27
service/userdata.go
View File

@@ -3,37 +3,50 @@ package service
import (
"context"
"errors"
"fmt"
"github.com/arangodb/go-driver"
"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"
)
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 {
return response(s.database.UserDataGet(ctx, params.ID))
userData, err := s.database.UserDataGet(ctx, params.ID)
return s.response(ctx, "GetUserData", nil, userData, err)
}
func (s *Service) ListUserData(ctx context.Context) *api.Response {
return response(s.database.UserDataList(ctx))
userData, err := s.database.UserDataList(ctx)
return s.response(ctx, "ListUserData", nil, userData, err)
}
func (s *Service) UpdateUserData(ctx context.Context, params *userdata.UpdateUserDataParams) *api.Response {
return response(s.database.UserDataUpdate(ctx, params.ID, params.Userdata))
userData, err := s.database.UserDataUpdate(ctx, params.ID, params.Userdata)
return s.response(ctx, "UpdateUserData", userdataID(userData.ID), userData, err)
}
func (s *Service) CurrentUserData(ctx context.Context) *api.Response {
user, ok := busdb.UserFromContext(ctx)
if !ok {
return response(nil, errors.New("no user in context"))
return s.response(ctx, "CurrentUserData", userdataID(user.ID), nil, errors.New("no user in context"))
}
return s.GetUserData(ctx, &userdata.GetUserDataParams{ID: user.ID})
userData, err := s.database.UserDataGet(ctx, user.ID)
return s.response(ctx, "GetUserData", nil, userData, err)
}
func (s *Service) UpdateCurrentUserData(ctx context.Context, params *userdata.UpdateCurrentUserDataParams) *api.Response {
user, ok := busdb.UserFromContext(ctx)
if !ok {
return response(nil, errors.New("no user in context"))
return s.response(ctx, "UpdateCurrentUserData", userdataID(user.ID), nil, errors.New("no user in context"))
}
return response(s.database.UserDataUpdate(ctx, user.ID, params.Userdata))
userData, err := s.database.UserDataUpdate(ctx, user.ID, params.Userdata)
return s.response(ctx, "UpdateCurrentUserData", userdataID(user.ID), userData, err)
}