StrafesNET/maps-service
4
Fork 4
Code Issues 14 Pull Requests Packages Projects Releases Wiki Activity

De-monolithificate Services #236

Merged
Quaternions merged 32 commits from dedup into staging 2025-07-17 03:18:01 +00:00
Conversation 0 Commits 32 Files Changed 25 +1403 -768
25 changed files with 1403 additions and 768 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
pkg/cmds/serve.go
View File

@@ -12,6 +12,7 @@ import (
internal "git.itzana.me/strafesnet/maps-service/pkg/internal"
"git.itzana.me/strafesnet/maps-service/pkg/roblox"
"git.itzana.me/strafesnet/maps-service/pkg/service"
"git.itzana.me/strafesnet/maps-service/pkg/service_inner"
"git.itzana.me/strafesnet/maps-service/pkg/service_internal"
"github.com/nats-io/nats.go"
log "github.com/sirupsen/logrus"
@@ -130,16 +131,20 @@ func serve(ctx *cli.Context) error {
if err != nil {
log.Fatal(err)
}
svc := &service.Service{
DB: db,
Nats: js,
Maps: maps.NewMapsServiceClient(conn),
Users: users.NewUsersServiceClient(conn),
Roblox: roblox.Client{
svc_inner := service_inner.NewService(
db,
js,
maps.NewMapsServiceClient(conn),
users.NewUsersServiceClient(conn),
)
svc_external := service.NewService(
&svc_inner,
roblox.Client{
HttpClient: http.DefaultClient,
ApiKey: ctx.String("rbx-api-key"),
},
}
)
conn, err = grpc.Dial(ctx.String("auth-rpc-host"), grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil {
@@ -149,17 +154,14 @@ func serve(ctx *cli.Context) error {
Client: auth.NewAuthServiceClient(conn),
}
srv, err := api.NewServer(svc, sec, api.WithPathPrefix("/v1"))
srv_external, err := api.NewServer(&svc_external, sec, api.WithPathPrefix("/v1"))
if err != nil {
log.WithError(err).Fatal("failed to initialize api server")
}
svc2 := &service_internal.Service{
DB: db,
Nats: js,
}
svc_internal := service_internal.NewService(&svc_inner)
srv2, err := internal.NewServer(svc2, internal.WithPathPrefix("/v1"))
srv_internal, err := internal.NewServer(&svc_internal, internal.WithPathPrefix("/v1"))
if err != nil {
log.WithError(err).Fatal("failed to initialize api server")
}
@@ -168,12 +170,12 @@ func serve(ctx *cli.Context) error {
// First server
go func(errChan chan error) {
errChan <- http.ListenAndServe(fmt.Sprintf(":%d", ctx.Int("port-internal")), srv2)
errChan <- http.ListenAndServe(fmt.Sprintf(":%d", ctx.Int("port-internal")), srv_internal)
}(errChan)
// Second server
go func(errChan chan error) {
errChan <- http.ListenAndServe(fmt.Sprintf(":%d", ctx.Int("port")), srv)
errChan <- http.ListenAndServe(fmt.Sprintf(":%d", ctx.Int("port")), srv_external)
}(errChan)
// Wait for the first error or completion of both tasks

334
pkg/service/mapfixes.go
View File

@@ -2,16 +2,15 @@ package service
import (
"context"
"encoding/json"
"errors"
"fmt"
"io"
"time"
"git.itzana.me/strafesnet/go-grpc/maps"
"git.itzana.me/strafesnet/maps-service/pkg/api"
"git.itzana.me/strafesnet/maps-service/pkg/datastore"
"git.itzana.me/strafesnet/maps-service/pkg/model"
"git.itzana.me/strafesnet/maps-service/pkg/service_inner"
)
var(
@@ -61,10 +60,11 @@ func (svc *Service) CreateMapfix(ctx context.Context, request *api.MapfixTrigger
// Check if user's mapfixes in the creation phase exceeds the limit
{
filter := datastore.Optional()
filter.Add("submitter", int64(userId))
filter.Add("status_id", CreationPhaseMapfixStatuses)
creation_mapfixes, err := svc.DB.Mapfixes().List(ctx, filter, model.Page{
filter := service_inner.NewMapfixFilter()
filter.SetSubmitter(userId)
filter.SetStatuses(CreationPhaseMapfixStatuses)
creation_mapfixes, err := svc.inner.ListMapfixes(ctx, filter, model.Page{
Number: 1,
Size: int32(CreationPhaseMapfixesLimit),
},datastore.ListSortDisabled)
@@ -79,11 +79,12 @@ func (svc *Service) CreateMapfix(ctx context.Context, request *api.MapfixTrigger
// Check if a mapfix targetting the same map exists in creation phase
{
filter := datastore.Optional()
filter.Add("submitter", int64(userId))
filter.Add("target_asset_id", request.TargetAssetID)
filter.Add("status_id", CreationPhaseMapfixStatuses)
active_mapfixes, err := svc.DB.Mapfixes().List(ctx, filter, model.Page{
filter := service_inner.NewMapfixFilter()
filter.SetSubmitter(userId)
filter.SetTargetAssetID(uint64(request.TargetAssetID))
filter.SetStatuses(CreationPhaseMapfixStatuses)
active_mapfixes, err := svc.inner.ListMapfixes(ctx, filter, model.Page{
Number: 1,
Size: 1,
},datastore.ListSortDisabled)
@@ -97,9 +98,7 @@ func (svc *Service) CreateMapfix(ctx context.Context, request *api.MapfixTrigger
// Check if TargetAssetID actually exists
{
_, err := svc.Maps.Get(ctx, &maps.IdMessage{
ID: request.TargetAssetID,
})
_, err := svc.inner.GetMap(ctx, request.TargetAssetID)
if err != nil {
// TODO: match specific does not exist grpc error
return nil, err
@@ -108,7 +107,7 @@ func (svc *Service) CreateMapfix(ctx context.Context, request *api.MapfixTrigger
// Check if too many operations have been created recently
{
count, err := svc.DB.Operations().CountSince(ctx,
count, err := svc.inner.CountOperationsSince(ctx,
int64(userId),
time.Now().Add(-CreateMapfixRecencyWindow),
)
@@ -121,7 +120,7 @@ func (svc *Service) CreateMapfix(ctx context.Context, request *api.MapfixTrigger
}
}
operation, err := svc.DB.Operations().Create(ctx, model.Operation{
operation, err := svc.inner.CreateOperation(ctx, model.Operation{
Owner: userId,
StatusID: model.OperationStatusCreated,
})
@@ -129,19 +128,12 @@ func (svc *Service) CreateMapfix(ctx context.Context, request *api.MapfixTrigger
return nil, err
}
create_request := model.CreateMapfixRequest{
OperationID: operation.ID,
ModelID: ModelID,
TargetAssetID: TargetAssetID,
Description: request.Description,
}
j, err := json.Marshal(create_request)
if err != nil {
return nil, err
}
_, err = svc.Nats.Publish("maptest.mapfixes.create", []byte(j))
err = svc.inner.NatsCreateMapfix(
operation.ID,
ModelID,
TargetAssetID,
request.Description,
)
if err != nil {
return nil, err
}
@@ -157,7 +149,7 @@ func (svc *Service) CreateMapfix(ctx context.Context, request *api.MapfixTrigger
//
// GET /mapfixes/{MapfixID}
func (svc *Service) GetMapfix(ctx context.Context, params api.GetMapfixParams) (*api.Mapfix, error) {
mapfix, err := svc.DB.Mapfixes().Get(ctx, params.MapfixID)
mapfix, err := svc.inner.GetMapfix(ctx, params.MapfixID)
if err != nil {
return nil, err
}
@@ -184,33 +176,34 @@ func (svc *Service) GetMapfix(ctx context.Context, params api.GetMapfixParams) (
//
// GET /mapfixes
func (svc *Service) ListMapfixes(ctx context.Context, params api.ListMapfixesParams) (*api.Mapfixes, error) {
filter := datastore.Optional()
filter := service_inner.NewMapfixFilter()
if params.DisplayName.IsSet(){
filter.Add("display_name", params.DisplayName.Value)
if display_name, display_name_ok := params.DisplayName.Get(); display_name_ok{
filter.SetDisplayName(display_name)
}
if params.Creator.IsSet(){
filter.Add("creator", params.Creator.Value)
if creator, creator_ok := params.Creator.Get(); creator_ok{
filter.SetCreator(creator)
}
if params.GameID.IsSet(){
filter.Add("game_id", params.GameID.Value)
if game_id, game_id_ok := params.GameID.Get(); game_id_ok{
filter.SetGameID(uint32(game_id))
}
if params.Submitter.IsSet(){
filter.Add("submitter", params.Submitter.Value)
if submitter, submitter_ok := params.Submitter.Get(); submitter_ok{
filter.SetSubmitter(uint64(submitter))
}
if params.AssetID.IsSet(){
filter.Add("asset_id", params.AssetID.Value)
if asset_id, asset_id_ok := params.AssetID.Get(); asset_id_ok{
filter.SetAssetID(uint64(asset_id))
}
if params.TargetAssetID.IsSet(){
filter.Add("target_asset_id", params.TargetAssetID.Value)
if target_asset_id, target_asset_id_ok := params.TargetAssetID.Get(); target_asset_id_ok{
filter.SetTargetAssetID(uint64(target_asset_id))
}
if params.StatusID.IsSet(){
filter.Add("status_id", params.StatusID.Value)
// TODO: make this a list of statuses
if status_id, status_id_ok := params.StatusID.Get(); status_id_ok{
filter.SetStatuses([]model.MapfixStatus{model.MapfixStatus(status_id)})
}
sort := datastore.ListSort(params.Sort.Or(int32(datastore.ListSortDisabled)))
total, items, err := svc.DB.Mapfixes().ListWithTotal(ctx, filter, model.Page{
total, items, err := svc.inner.ListMapfixesWithTotal(ctx, filter, model.Page{
Number: params.Page,
Size: params.Limit,
},sort)
@@ -261,9 +254,9 @@ func (svc *Service) SetMapfixCompleted(ctx context.Context, params api.SetMapfix
return ErrPermissionDeniedNeedRoleMaptest
}
pmap := datastore.Optional()
pmap.Add("completed", true)
return svc.DB.Mapfixes().Update(ctx, params.MapfixID, pmap)
update := service_inner.NewMapfixUpdate()
update.SetCompleted(true)
return svc.inner.UpdateMapfix(ctx, params.MapfixID, update)
}
// UpdateMapfixModel implements patchMapfixModel operation.
@@ -278,7 +271,7 @@ func (svc *Service) UpdateMapfixModel(ctx context.Context, params api.UpdateMapf
}
// read mapfix (this could be done with a transaction WHERE clause)
mapfix, err := svc.DB.Mapfixes().Get(ctx, params.MapfixID)
mapfix, err := svc.inner.GetMapfix(ctx, params.MapfixID)
if err != nil {
return err
}
@@ -300,12 +293,13 @@ func (svc *Service) UpdateMapfixModel(ctx context.Context, params api.UpdateMapf
NewModelVersion := uint64(params.ModelVersion)
// check if Status is ChangesRequested|Submitted|UnderConstruction
pmap := datastore.Optional()
pmap.Add("asset_id", NewModelID)
pmap.Add("asset_version", NewModelVersion)
update := service_inner.NewMapfixUpdate()
update.SetAssetID(NewModelID)
update.SetAssetVersion(NewModelVersion)
//always reset completed when model changes
pmap.Add("completed", false)
err = svc.DB.Mapfixes().IfStatusThenUpdate(ctx, params.MapfixID, []model.MapfixStatus{model.MapfixStatusChangesRequested, model.MapfixStatusSubmitted, model.MapfixStatusUnderConstruction}, pmap)
update.SetCompleted(false)
allow_statuses := []model.MapfixStatus{model.MapfixStatusChangesRequested, model.MapfixStatusSubmitted, model.MapfixStatusUnderConstruction}
err = svc.inner.UpdateMapfixIfStatus(ctx, params.MapfixID, allow_statuses, update)
if err != nil {
return err
}
@@ -317,7 +311,7 @@ func (svc *Service) UpdateMapfixModel(ctx context.Context, params api.UpdateMapf
NewModelVersion: NewModelVersion,
}
return svc.CreateAuditEventChangeModel(
return svc.inner.CreateAuditEventChangeModel(
ctx,
userId,
model.Resource{
@@ -355,9 +349,10 @@ func (svc *Service) ActionMapfixReject(ctx context.Context, params api.ActionMap
// transaction
target_status := model.MapfixStatusRejected
smap := datastore.Optional()
smap.Add("status_id", target_status)
err = svc.DB.Mapfixes().IfStatusThenUpdate(ctx, params.MapfixID, []model.MapfixStatus{model.MapfixStatusSubmitted}, smap)
update := service_inner.NewMapfixUpdate()
update.SetStatusID(target_status)
allow_statuses := []model.MapfixStatus{model.MapfixStatusSubmitted}
err = svc.inner.UpdateMapfixIfStatus(ctx, params.MapfixID, allow_statuses, update)
if err != nil {
return err
}
@@ -366,7 +361,7 @@ func (svc *Service) ActionMapfixReject(ctx context.Context, params api.ActionMap
TargetStatus: uint32(target_status),
}
return svc.CreateAuditEventAction(
return svc.inner.CreateAuditEventAction(
ctx,
userId,
model.Resource{
@@ -404,9 +399,10 @@ func (svc *Service) ActionMapfixRequestChanges(ctx context.Context, params api.A
// transaction
target_status := model.MapfixStatusChangesRequested
smap := datastore.Optional()
smap.Add("status_id", target_status)
err = svc.DB.Mapfixes().IfStatusThenUpdate(ctx, params.MapfixID, []model.MapfixStatus{model.MapfixStatusValidated, model.MapfixStatusAcceptedUnvalidated, model.MapfixStatusSubmitted}, smap)
update := service_inner.NewMapfixUpdate()
update.SetStatusID(target_status)
allow_statuses := []model.MapfixStatus{model.MapfixStatusValidated, model.MapfixStatusAcceptedUnvalidated, model.MapfixStatusSubmitted}
err = svc.inner.UpdateMapfixIfStatus(ctx, params.MapfixID, allow_statuses, update)
if err != nil {
return err
}
@@ -415,7 +411,7 @@ func (svc *Service) ActionMapfixRequestChanges(ctx context.Context, params api.A
TargetStatus: uint32(target_status),
}
return svc.CreateAuditEventAction(
return svc.inner.CreateAuditEventAction(
ctx,
userId,
model.Resource{
@@ -438,7 +434,7 @@ func (svc *Service) ActionMapfixRevoke(ctx context.Context, params api.ActionMap
}
// read mapfix (this could be done with a transaction WHERE clause)
mapfix, err := svc.DB.Mapfixes().Get(ctx, params.MapfixID)
mapfix, err := svc.inner.GetMapfix(ctx, params.MapfixID)
if err != nil {
return err
}
@@ -456,9 +452,10 @@ func (svc *Service) ActionMapfixRevoke(ctx context.Context, params api.ActionMap
// transaction
target_status := model.MapfixStatusUnderConstruction
smap := datastore.Optional()
smap.Add("status_id", target_status)
err = svc.DB.Mapfixes().IfStatusThenUpdate(ctx, params.MapfixID, []model.MapfixStatus{model.MapfixStatusSubmitted, model.MapfixStatusChangesRequested}, smap)
update := service_inner.NewMapfixUpdate()
update.SetStatusID(target_status)
allow_statuses := []model.MapfixStatus{model.MapfixStatusSubmitted, model.MapfixStatusChangesRequested}
err = svc.inner.UpdateMapfixIfStatus(ctx, params.MapfixID, allow_statuses, update)
if err != nil {
return err
}
@@ -467,7 +464,7 @@ func (svc *Service) ActionMapfixRevoke(ctx context.Context, params api.ActionMap
TargetStatus: uint32(target_status),
}
return svc.CreateAuditEventAction(
return svc.inner.CreateAuditEventAction(
ctx,
userId,
model.Resource{
@@ -490,7 +487,7 @@ func (svc *Service) ActionMapfixTriggerSubmit(ctx context.Context, params api.Ac
}
// read mapfix (this could be done with a transaction WHERE clause)
mapfix, err := svc.DB.Mapfixes().Get(ctx, params.MapfixID)
mapfix, err := svc.inner.GetMapfix(ctx, params.MapfixID)
if err != nil {
return err
}
@@ -508,25 +505,19 @@ func (svc *Service) ActionMapfixTriggerSubmit(ctx context.Context, params api.Ac
// transaction
target_status := model.MapfixStatusSubmitting
smap := datastore.Optional()
smap.Add("status_id", target_status)
err = svc.DB.Mapfixes().IfStatusThenUpdate(ctx, params.MapfixID, []model.MapfixStatus{model.MapfixStatusUnderConstruction, model.MapfixStatusChangesRequested}, smap)
update := service_inner.NewMapfixUpdate()
update.SetStatusID(target_status)
allow_statuses := []model.MapfixStatus{model.MapfixStatusUnderConstruction, model.MapfixStatusChangesRequested}
err = svc.inner.UpdateMapfixIfStatus(ctx, params.MapfixID, allow_statuses, update)
if err != nil {
return err
}
validate_request := model.CheckMapfixRequest{
MapfixID: mapfix.ID,
ModelID: mapfix.AssetID,
SkipChecks: false,
}
j, err := json.Marshal(validate_request)
if err != nil {
return err
}
_, err = svc.Nats.Publish("maptest.mapfixes.check", []byte(j))
err = svc.inner.NatsCheckMapfix(
mapfix.ID,
mapfix.AssetID,
false,
)
if err != nil {
return err
}
@@ -535,7 +526,7 @@ func (svc *Service) ActionMapfixTriggerSubmit(ctx context.Context, params api.Ac
TargetStatus: uint32(target_status),
}
return svc.CreateAuditEventAction(
return svc.inner.CreateAuditEventAction(
ctx,
userId,
model.Resource{
@@ -558,7 +549,7 @@ func (svc *Service) ActionMapfixTriggerSubmitUnchecked(ctx context.Context, para
}
// read mapfix (this could be done with a transaction WHERE clause)
mapfix, err := svc.DB.Mapfixes().Get(ctx, params.MapfixID)
mapfix, err := svc.inner.GetMapfix(ctx, params.MapfixID)
if err != nil {
return err
}
@@ -585,25 +576,19 @@ func (svc *Service) ActionMapfixTriggerSubmitUnchecked(ctx context.Context, para
// transaction
target_status := model.MapfixStatusSubmitting
smap := datastore.Optional()
smap.Add("status_id", target_status)
err = svc.DB.Mapfixes().IfStatusThenUpdate(ctx, params.MapfixID, []model.MapfixStatus{model.MapfixStatusChangesRequested}, smap)
update := service_inner.NewMapfixUpdate()
update.SetStatusID(target_status)
allow_statuses := []model.MapfixStatus{model.MapfixStatusChangesRequested}
err = svc.inner.UpdateMapfixIfStatus(ctx, params.MapfixID, allow_statuses, update)
if err != nil {
return err
}
validate_request := model.CheckMapfixRequest{
MapfixID: mapfix.ID,
ModelID: mapfix.AssetID,
SkipChecks: true,
}
j, err := json.Marshal(validate_request)
if err != nil {
return err
}
_, err = svc.Nats.Publish("maptest.mapfixes.check", []byte(j))
err = svc.inner.NatsCheckMapfix(
mapfix.ID,
mapfix.AssetID,
true,
)
if err != nil {
return err
}
@@ -612,7 +597,7 @@ func (svc *Service) ActionMapfixTriggerSubmitUnchecked(ctx context.Context, para
TargetStatus: uint32(target_status),
}
return svc.CreateAuditEventAction(
return svc.inner.CreateAuditEventAction(
ctx,
userId,
model.Resource{
@@ -640,7 +625,7 @@ func (svc *Service) ActionMapfixResetSubmitting(ctx context.Context, params api.
}
// check when mapfix was updated
mapfix, err := svc.DB.Mapfixes().Get(ctx, params.MapfixID)
mapfix, err := svc.inner.GetMapfix(ctx, params.MapfixID)
if err != nil {
return err
}
@@ -657,9 +642,10 @@ func (svc *Service) ActionMapfixResetSubmitting(ctx context.Context, params api.
// transaction
target_status := model.MapfixStatusUnderConstruction
smap := datastore.Optional()
smap.Add("status_id", target_status)
err = svc.DB.Mapfixes().IfStatusThenUpdate(ctx, params.MapfixID, []model.MapfixStatus{model.MapfixStatusSubmitting}, smap)
update := service_inner.NewMapfixUpdate()
update.SetStatusID(target_status)
allow_statuses := []model.MapfixStatus{model.MapfixStatusSubmitting}
err = svc.inner.UpdateMapfixIfStatus(ctx, params.MapfixID, allow_statuses, update)
if err != nil {
return err
}
@@ -668,7 +654,7 @@ func (svc *Service) ActionMapfixResetSubmitting(ctx context.Context, params api.
TargetStatus: uint32(target_status),
}
return svc.CreateAuditEventAction(
return svc.inner.CreateAuditEventAction(
ctx,
userId,
model.Resource{
@@ -706,27 +692,21 @@ func (svc *Service) ActionMapfixTriggerUpload(ctx context.Context, params api.Ac
// transaction
target_status := model.MapfixStatusUploading
smap := datastore.Optional()
smap.Add("status_id", target_status)
mapfix, err := svc.DB.Mapfixes().IfStatusThenUpdateAndGet(ctx, params.MapfixID, []model.MapfixStatus{model.MapfixStatusValidated}, smap)
update := service_inner.NewMapfixUpdate()
update.SetStatusID(target_status)
allow_statuses := []model.MapfixStatus{model.MapfixStatusValidated}
mapfix, err := svc.inner.UpdateAndGetMapfixIfStatus(ctx, params.MapfixID, allow_statuses, update)
if err != nil {
return err
}
// this is a map fix
upload_fix_request := model.UploadMapfixRequest{
MapfixID: mapfix.ID,
ModelID: mapfix.ValidatedAssetID,
ModelVersion: mapfix.ValidatedAssetVersion,
TargetAssetID: mapfix.TargetAssetID,
}
j, err := json.Marshal(upload_fix_request)
if err != nil {
return err
}
_, err = svc.Nats.Publish("maptest.mapfixes.upload", []byte(j))
err = svc.inner.NatsUploadMapfix(
mapfix.ID,
mapfix.ValidatedAssetID,
mapfix.ValidatedAssetVersion,
mapfix.TargetAssetID,
)
if err != nil {
return err
}
@@ -735,7 +715,7 @@ func (svc *Service) ActionMapfixTriggerUpload(ctx context.Context, params api.Ac
TargetStatus: uint32(target_status),
}
return svc.CreateAuditEventAction(
return svc.inner.CreateAuditEventAction(
ctx,
userId,
model.Resource{
@@ -772,7 +752,7 @@ func (svc *Service) ActionMapfixValidated(ctx context.Context, params api.Action
}
// check when mapfix was updated
mapfix, err := svc.DB.Mapfixes().Get(ctx, params.MapfixID)
mapfix, err := svc.inner.GetMapfix(ctx, params.MapfixID)
if err != nil {
return err
}
@@ -783,9 +763,10 @@ func (svc *Service) ActionMapfixValidated(ctx context.Context, params api.Action
// transaction
target_status := model.MapfixStatusValidated
smap := datastore.Optional()
smap.Add("status_id", target_status)
err = svc.DB.Mapfixes().IfStatusThenUpdate(ctx, params.MapfixID, []model.MapfixStatus{model.MapfixStatusUploading}, smap)
update := service_inner.NewMapfixUpdate()
update.SetStatusID(target_status)
allow_statuses := []model.MapfixStatus{model.MapfixStatusUploading}
err = svc.inner.UpdateMapfixIfStatus(ctx, params.MapfixID, allow_statuses, update)
if err != nil {
return err
}
@@ -794,7 +775,7 @@ func (svc *Service) ActionMapfixValidated(ctx context.Context, params api.Action
TargetStatus: uint32(target_status),
}
return svc.CreateAuditEventAction(
return svc.inner.CreateAuditEventAction(
ctx,
userId,
model.Resource{
@@ -826,7 +807,7 @@ func (svc *Service) ActionMapfixTriggerValidate(ctx context.Context, params api.
}
// read mapfix (this could be done with a transaction WHERE clause)
mapfix, err := svc.DB.Mapfixes().Get(ctx, params.MapfixID)
mapfix, err := svc.inner.GetMapfix(ctx, params.MapfixID)
if err != nil {
return err
}
@@ -844,10 +825,10 @@ func (svc *Service) ActionMapfixTriggerValidate(ctx context.Context, params api.
// Check if an active mapfix with the same target asset id exists
if mapfix.TargetAssetID != 0 {
filter := datastore.Optional()
filter.Add("target_asset_id", mapfix.TargetAssetID)
filter.Add("status_id", ActiveAcceptedMapfixStatuses)
active_mapfixes, err := svc.DB.Mapfixes().List(ctx, filter, model.Page{
filter := service_inner.NewMapfixFilter()
filter.SetTargetAssetID(mapfix.TargetAssetID)
filter.SetStatuses(ActiveAcceptedMapfixStatuses)
active_mapfixes, err := svc.inner.ListMapfixes(ctx, filter, model.Page{
Number: 1,
Size: 1,
},datastore.ListSortDisabled)
@@ -861,31 +842,20 @@ func (svc *Service) ActionMapfixTriggerValidate(ctx context.Context, params api.
// transaction
target_status := model.MapfixStatusValidating
smap := datastore.Optional()
smap.Add("status_id", target_status)
mapfix, err = svc.DB.Mapfixes().IfStatusThenUpdateAndGet(ctx, params.MapfixID, []model.MapfixStatus{model.MapfixStatusSubmitted}, smap)
update := service_inner.NewMapfixUpdate()
update.SetStatusID(target_status)
allow_statuses := []model.MapfixStatus{model.MapfixStatusSubmitted}
mapfix, err = svc.inner.UpdateAndGetMapfixIfStatus(ctx, params.MapfixID, allow_statuses, update)
if err != nil {
return err
}
validate_request := model.ValidateMapfixRequest{
MapfixID: mapfix.ID,
ModelID: mapfix.AssetID,
ModelVersion: mapfix.AssetVersion,
ValidatedModelID: nil,
}
// sentinel values because we're not using rust
if mapfix.ValidatedAssetID != 0 {
validate_request.ValidatedModelID = &mapfix.ValidatedAssetID
}
j, err := json.Marshal(validate_request)
if err != nil {
return err
}
_, err = svc.Nats.Publish("maptest.mapfixes.validate", []byte(j))
err = svc.inner.NatsValidateMapfix(
mapfix.ID,
mapfix.AssetID,
mapfix.AssetVersion,
mapfix.ValidatedAssetID,
)
if err != nil {
return err
}
@@ -894,7 +864,7 @@ func (svc *Service) ActionMapfixTriggerValidate(ctx context.Context, params api.
TargetStatus: uint32(target_status),
}
return svc.CreateAuditEventAction(
return svc.inner.CreateAuditEventAction(
ctx,
userId,
model.Resource{
@@ -932,31 +902,20 @@ func (svc *Service) ActionMapfixRetryValidate(ctx context.Context, params api.Ac
// transaction
target_status := model.MapfixStatusValidating
smap := datastore.Optional()
smap.Add("status_id", target_status)
mapfix, err := svc.DB.Mapfixes().IfStatusThenUpdateAndGet(ctx, params.MapfixID, []model.MapfixStatus{model.MapfixStatusAcceptedUnvalidated}, smap)
update := service_inner.NewMapfixUpdate()
update.SetStatusID(target_status)
allow_statuses := []model.MapfixStatus{model.MapfixStatusAcceptedUnvalidated}
mapfix, err := svc.inner.UpdateAndGetMapfixIfStatus(ctx, params.MapfixID, allow_statuses, update)
if err != nil {
return err
}
validate_request := model.ValidateMapfixRequest{
MapfixID: mapfix.ID,
ModelID: mapfix.AssetID,
ModelVersion: mapfix.AssetVersion,
ValidatedModelID: nil,
}
// sentinel values because we're not using rust
if mapfix.ValidatedAssetID != 0 {
validate_request.ValidatedModelID = &mapfix.ValidatedAssetID
}
j, err := json.Marshal(validate_request)
if err != nil {
return err
}
_, err = svc.Nats.Publish("maptest.mapfixes.validate", []byte(j))
err = svc.inner.NatsValidateMapfix(
mapfix.ID,
mapfix.AssetID,
mapfix.AssetVersion,
mapfix.ValidatedAssetID,
)
if err != nil {
return err
}
@@ -965,7 +924,7 @@ func (svc *Service) ActionMapfixRetryValidate(ctx context.Context, params api.Ac
TargetStatus: uint32(target_status),
}
return svc.CreateAuditEventAction(
return svc.inner.CreateAuditEventAction(
ctx,
userId,
model.Resource{
@@ -1002,7 +961,7 @@ func (svc *Service) ActionMapfixAccepted(ctx context.Context, params api.ActionM
}
// check when mapfix was updated
mapfix, err := svc.DB.Mapfixes().Get(ctx, params.MapfixID)
mapfix, err := svc.inner.GetMapfix(ctx, params.MapfixID)
if err != nil {
return err
}
@@ -1013,9 +972,10 @@ func (svc *Service) ActionMapfixAccepted(ctx context.Context, params api.ActionM
// transaction
target_status := model.MapfixStatusAcceptedUnvalidated
smap := datastore.Optional()
smap.Add("status_id", target_status)
err = svc.DB.Mapfixes().IfStatusThenUpdate(ctx, params.MapfixID, []model.MapfixStatus{model.MapfixStatusValidating}, smap)
update := service_inner.NewMapfixUpdate()
update.SetStatusID(target_status)
allow_statuses := []model.MapfixStatus{model.MapfixStatusValidating}
err = svc.inner.UpdateMapfixIfStatus(ctx, params.MapfixID, allow_statuses, update)
if err != nil {
return err
}
@@ -1024,7 +984,7 @@ func (svc *Service) ActionMapfixAccepted(ctx context.Context, params api.ActionM
TargetStatus: uint32(target_status),
}
return svc.CreateAuditEventAction(
return svc.inner.CreateAuditEventAction(
ctx,
userId,
model.Resource{
@@ -1058,7 +1018,7 @@ func (svc *Service) CreateMapfixAuditComment(ctx context.Context, req api.Create
if !has_role {
// Submitter has special permission to comment on their mapfix
mapfix, err := svc.DB.Mapfixes().Get(ctx, params.MapfixID)
mapfix, err := svc.inner.GetMapfix(ctx, params.MapfixID)
if err != nil {
return err
}
@@ -1077,7 +1037,7 @@ func (svc *Service) CreateMapfixAuditComment(ctx context.Context, req api.Create
Comment: string(data),
}
return svc.CreateAuditEventComment(
return svc.inner.CreateAuditEventComment(
ctx,
userId,
model.Resource{
@@ -1094,7 +1054,7 @@ func (svc *Service) CreateMapfixAuditComment(ctx context.Context, req api.Create
//
// GET /mapfixes/{MapfixID}/audit-events
func (svc *Service) ListMapfixAuditEvents(ctx context.Context, params api.ListMapfixAuditEventsParams) ([]api.AuditEvent, error) {
return svc.ListAuditEvents(
return svc.inner.ListAuditEvents(
ctx,
model.Resource{
ID: params.MapfixID,

41
pkg/service/maps.go
View File

@@ -4,9 +4,10 @@ import (
"context"
"strings"
"git.itzana.me/strafesnet/go-grpc/maps"
"git.itzana.me/strafesnet/maps-service/pkg/api"
"git.itzana.me/strafesnet/maps-service/pkg/model"
"git.itzana.me/strafesnet/maps-service/pkg/roblox"
"git.itzana.me/strafesnet/maps-service/pkg/service_inner"
)
// ListMaps implements listMaps operation.
@@ -15,37 +16,37 @@ import (
//
// GET /maps
func (svc *Service) ListMaps(ctx context.Context, params api.ListMapsParams) ([]api.Map, error) {
filter := maps.MapFilter{}
filter := service_inner.NewMapFilter()
if params.DisplayName.IsSet(){
filter.DisplayName = &params.DisplayName.Value
if display_name, display_name_ok := params.DisplayName.Get(); display_name_ok{
filter.SetDisplayName(display_name)
}
if params.Creator.IsSet(){
filter.Creator = &params.Creator.Value
if creator, creator_ok := params.Creator.Get(); creator_ok{
filter.SetCreator(creator)
}
if params.GameID.IsSet(){
filter.GameID = &params.GameID.Value
if game_id, game_id_ok := params.GameID.Get(); game_id_ok{
filter.SetGameID(game_id)
}
mapList, err := svc.Maps.List(ctx, &maps.ListRequest{
Filter: &filter,
Page: &maps.Pagination{
items, err := svc.inner.ListMaps(ctx,
filter,
model.Page{
Size: params.Limit,
Number: params.Page,
},
})
)
if err != nil {
return nil, err
}
var resp []api.Map
for _, item := range mapList.Maps {
for _, item := range items {
resp = append(resp, api.Map{
ID: item.ID,
DisplayName: item.DisplayName,
Creator: item.Creator,
GameID: item.GameID,
Date: item.Date,
Date: item.Date.Unix(),
})
}
@@ -58,9 +59,7 @@ func (svc *Service) ListMaps(ctx context.Context, params api.ListMapsParams) ([]
//
// GET /maps/{MapID}
func (svc *Service) GetMap(ctx context.Context, params api.GetMapParams) (*api.Map, error) {
mapResponse, err := svc.Maps.Get(ctx, &maps.IdMessage{
ID: params.MapID,
})
mapResponse, err := svc.inner.GetMap(ctx, params.MapID)
if err != nil {
return nil, err
}
@@ -70,7 +69,7 @@ func (svc *Service) GetMap(ctx context.Context, params api.GetMapParams) (*api.M
DisplayName: mapResponse.DisplayName,
Creator: mapResponse.Creator,
GameID: mapResponse.GameID,
Date: mapResponse.Date,
Date: mapResponse.Date.Unix(),
}, nil
}
@@ -96,14 +95,12 @@ func (svc *Service) GetMapAssetLocation(ctx context.Context, params api.GetMapAs
// Ensure map exists in the db!
// This could otherwise be used to access any asset
_, err = svc.Maps.Get(ctx, &maps.IdMessage{
ID: params.MapID,
})
_, err = svc.inner.GetMap(ctx, params.MapID)
if err != nil {
return ok, err
}
info, err := svc.Roblox.GetAssetLocation(roblox.GetAssetLatestRequest{
info, err := svc.roblox.GetAssetLocation(roblox.GetAssetLatestRequest{
AssetID: uint64(params.MapID),
})
if err != nil{

2
pkg/service/operations.go
View File

@@ -19,7 +19,7 @@ func (svc *Service) GetOperation(ctx context.Context, params api.GetOperationPar
// You must be the operation owner to read it
operation, err := svc.DB.Operations().Get(ctx, params.OperationID)
operation, err := svc.inner.GetOperation(ctx, params.OperationID)
if err != nil {
return nil, err
}

76
pkg/service/script_policy.go
View File

@@ -4,8 +4,8 @@ import (
"context"
"git.itzana.me/strafesnet/maps-service/pkg/api"
"git.itzana.me/strafesnet/maps-service/pkg/datastore"
"git.itzana.me/strafesnet/maps-service/pkg/model"
"git.itzana.me/strafesnet/maps-service/pkg/service_inner"
)
// CreateScriptPolicy implements createScriptPolicy operation.
@@ -14,27 +14,19 @@ import (
//
// POST /script-policy
func (svc *Service) CreateScriptPolicy(ctx context.Context, req *api.ScriptPolicyCreate) (*api.ScriptPolicyID, error) {
userInfo, ok := ctx.Value("UserInfo").(UserInfoHandle)
if !ok {
return nil, ErrUserInfo
}
has_role, err := userInfo.HasRoleScriptWrite()
err := CheckHasRoleScriptWrite(ctx)
if err != nil {
return nil, err
}
if !has_role {
return nil, ErrPermissionDenied
}
from_script, err := svc.DB.Scripts().Get(ctx, req.FromScriptID)
from_script, err := svc.inner.GetScript(ctx, req.FromScriptID)
if err != nil {
return nil, err
}
// the existence of ToScriptID does not need to be validated because it's checked by a foreign key constraint.
script, err := svc.DB.ScriptPolicy().Create(ctx, model.ScriptPolicy{
script, err := svc.inner.CreateScriptPolicy(ctx, model.ScriptPolicy{
ID: 0,
FromScriptHash: from_script.Hash,
ToScriptID: req.ToScriptID,
@@ -56,23 +48,24 @@ func (svc *Service) CreateScriptPolicy(ctx context.Context, req *api.ScriptPolic
//
// GET /script-policy
func (svc *Service) ListScriptPolicy(ctx context.Context, params api.ListScriptPolicyParams) ([]api.ScriptPolicy, error) {
filter := datastore.Optional()
filter := service_inner.NewScriptPolicyFilter()
if params.FromScriptHash.IsSet(){
hash, err := model.HashParse(params.FromScriptHash.Value)
if hash_hex, ok := params.FromScriptHash.Get(); ok{
hash_parsed, err := model.HashParse(hash_hex)
if err != nil {
return nil, err
}
filter.Add("from_script_hash", int64(hash)) // No type safety!
filter.SetFromScriptHash(int64(hash_parsed))
}
if params.ToScriptID.IsSet(){
filter.Add("to_script_id", params.ToScriptID.Value)
if to_script_id, to_script_id_ok := params.ToScriptID.Get(); to_script_id_ok{
filter.SetToScriptID(to_script_id)
}
if params.Policy.IsSet(){
filter.Add("policy", params.Policy.Value)
if policy, policy_ok := params.Policy.Get(); policy_ok{
filter.SetPolicy(policy)
}
items, err := svc.DB.ScriptPolicy().List(ctx, filter, model.Page{
items, err := svc.inner.ListScriptPolicies(ctx, filter, model.Page{
Number: params.Page,
Size: params.Limit,
})
@@ -99,20 +92,12 @@ func (svc *Service) ListScriptPolicy(ctx context.Context, params api.ListScriptP
//
// DELETE /script-policy/{ScriptPolicyID}
func (svc *Service) DeleteScriptPolicy(ctx context.Context, params api.DeleteScriptPolicyParams) error {
userInfo, ok := ctx.Value("UserInfo").(UserInfoHandle)
if !ok {
return ErrUserInfo
}
has_role, err := userInfo.HasRoleScriptWrite()
err := CheckHasRoleScriptWrite(ctx)
if err != nil {
return err
}
if !has_role {
return ErrPermissionDenied
}
return svc.DB.ScriptPolicy().Delete(ctx, params.ScriptPolicyID)
return svc.inner.DeleteScriptPolicy(ctx, params.ScriptPolicyID)
}
// GetScriptPolicy implements getScriptPolicy operation.
@@ -121,7 +106,7 @@ func (svc *Service) DeleteScriptPolicy(ctx context.Context, params api.DeleteScr
//
// GET /script-policy/{ScriptPolicyID}
func (svc *Service) GetScriptPolicy(ctx context.Context, params api.GetScriptPolicyParams) (*api.ScriptPolicy, error) {
policy, err := svc.DB.ScriptPolicy().Get(ctx, params.ScriptPolicyID)
policy, err := svc.inner.GetScriptPolicy(ctx, params.ScriptPolicyID)
if err != nil {
return nil, err
}
@@ -140,32 +125,25 @@ func (svc *Service) GetScriptPolicy(ctx context.Context, params api.GetScriptPol
//
// POST /script-policy/{ScriptPolicyID}
func (svc *Service) UpdateScriptPolicy(ctx context.Context, req *api.ScriptPolicyUpdate, params api.UpdateScriptPolicyParams) error {
userInfo, ok := ctx.Value("UserInfo").(UserInfoHandle)
if !ok {
return ErrUserInfo
}
has_role, err := userInfo.HasRoleScriptWrite()
err := CheckHasRoleScriptWrite(ctx)
if err != nil {
return err
}
if !has_role {
return ErrPermissionDenied
}
pmap := datastore.Optional()
filter := service_inner.NewScriptPolicyFilter()
if from_script_id, ok := req.FromScriptID.Get(); ok {
from_script, err := svc.DB.Scripts().Get(ctx, from_script_id)
from_script, err := svc.inner.GetScript(ctx, from_script_id)
if err != nil {
return err
}
pmap.Add("from_script_hash", from_script.Hash)
filter.SetFromScriptHash(from_script.Hash)
}
if to_script_id, ok := req.ToScriptID.Get(); ok {
pmap.Add("to_script_id", to_script_id)
if to_script_id, to_script_id_ok := req.ToScriptID.Get(); to_script_id_ok{
filter.SetToScriptID(to_script_id)
}
if policy, ok := req.Policy.Get(); ok {
pmap.Add("policy", policy)
if policy, policy_ok := req.Policy.Get(); policy_ok{
filter.SetPolicy(policy)
}
return svc.DB.ScriptPolicy().Update(ctx, req.ID, pmap)
return svc.inner.UpdateScriptPolicy(ctx, req.ID, filter)
}

111
pkg/service/scripts.go
View File

@@ -4,30 +4,39 @@ import (
"context"
"git.itzana.me/strafesnet/maps-service/pkg/api"
"git.itzana.me/strafesnet/maps-service/pkg/datastore"
"git.itzana.me/strafesnet/maps-service/pkg/model"
"git.itzana.me/strafesnet/maps-service/pkg/service_inner"
)
func CheckHasRoleScriptWrite(ctx context.Context) error {
userInfo, ok := ctx.Value("UserInfo").(UserInfoHandle)
if !ok {
return ErrUserInfo
}
has_role, err := userInfo.HasRoleScriptWrite()
if err != nil {
return err
}
if !has_role {
return ErrPermissionDeniedNeedRoleScriptWrite
}
return nil
}
// CreateScript implements createScript operation.
//
// Create a new script.
//
// POST /scripts
func (svc *Service) CreateScript(ctx context.Context, req *api.ScriptCreate) (*api.ScriptID, error) {
userInfo, ok := ctx.Value("UserInfo").(UserInfoHandle)
if !ok {
return nil, ErrUserInfo
}
has_role, err := userInfo.HasRoleScriptWrite()
err := CheckHasRoleScriptWrite(ctx)
if err != nil {
return nil, err
}
if !has_role {
return nil, ErrPermissionDenied
}
script, err := svc.DB.Scripts().Create(ctx, model.Script{
script, err := svc.inner.CreateScript(ctx, model.Script{
ID: 0,
Name: req.Name,
Hash: int64(model.HashSource(req.Source)),
@@ -50,29 +59,30 @@ func (svc *Service) CreateScript(ctx context.Context, req *api.ScriptCreate) (*a
//
// GET /scripts
func (svc *Service) ListScripts(ctx context.Context, params api.ListScriptsParams) ([]api.Script, error) {
filter := datastore.Optional()
filter := service_inner.NewScriptFilter()
if params.Hash.IsSet(){
hash, err := model.HashParse(params.Hash.Value)
if hash_hex, ok := params.Hash.Get(); ok{
hash_parsed, err := model.HashParse(hash_hex)
if err != nil {
return nil, err
}
filter.Add("hash", int64(hash)) // No type safety!
filter.SetHash(int64(hash_parsed))
}
if params.Name.IsSet(){
filter.Add("name", params.Name.Value)
if name, name_ok := params.Name.Get(); name_ok{
filter.SetName(name)
}
if params.Source.IsSet(){
filter.Add("source", params.Source.Value)
if source, source_ok := params.Source.Get(); source_ok{
filter.SetSource(source)
}
if params.ResourceType.IsSet(){
filter.Add("resource_type", params.ResourceType.Value)
if resource_type, resource_type_ok := params.ResourceType.Get(); resource_type_ok{
filter.SetResourceType(resource_type)
}
if params.ResourceID.IsSet(){
filter.Add("resource_id", params.ResourceID.Value)
if resource_id, resource_id_ok := params.ResourceID.Get(); resource_id_ok{
filter.SetResourceID(resource_id)
}
items, err := svc.DB.Scripts().List(ctx, filter, model.Page{
items, err := svc.inner.ListScripts(ctx, filter, model.Page{
Number: params.Page,
Size: params.Limit,
})
@@ -101,20 +111,12 @@ func (svc *Service) ListScripts(ctx context.Context, params api.ListScriptsParam
//
// DELETE /scripts/{ScriptID}
func (svc *Service) DeleteScript(ctx context.Context, params api.DeleteScriptParams) error {
userInfo, ok := ctx.Value("UserInfo").(UserInfoHandle)
if !ok {
return ErrUserInfo
}
has_role, err := userInfo.HasRoleScriptWrite()
err := CheckHasRoleScriptWrite(ctx)
if err != nil {
return err
}
if !has_role {
return ErrPermissionDenied
}
return svc.DB.Scripts().Delete(ctx, params.ScriptID)
return svc.inner.DeleteScript(ctx, params.ScriptID)
}
// GetScript implements getScript operation.
@@ -123,7 +125,7 @@ func (svc *Service) DeleteScript(ctx context.Context, params api.DeleteScriptPar
//
// GET /scripts/{ScriptID}
func (svc *Service) GetScript(ctx context.Context, params api.GetScriptParams) (*api.Script, error) {
script, err := svc.DB.Scripts().Get(ctx, params.ScriptID)
script, err := svc.inner.GetScript(ctx, params.ScriptID)
if err != nil {
return nil, err
}
@@ -144,32 +146,25 @@ func (svc *Service) GetScript(ctx context.Context, params api.GetScriptParams) (
//
// PATCH /scripts/{ScriptID}
func (svc *Service) UpdateScript(ctx context.Context, req *api.ScriptUpdate, params api.UpdateScriptParams) error {
userInfo, ok := ctx.Value("UserInfo").(UserInfoHandle)
if !ok {
return ErrUserInfo
}
has_role, err := userInfo.HasRoleScriptWrite()
err := CheckHasRoleScriptWrite(ctx)
if err != nil {
return err
}
if !has_role {
return ErrPermissionDenied
filter := service_inner.NewScriptFilter()
if name, name_ok := req.Name.Get(); name_ok{
filter.SetName(name)
}
if source, source_ok := req.Source.Get(); source_ok{
filter.SetSource(source)
filter.SetHash(int64(model.HashSource(source)))
}
if resource_type, resource_type_ok := req.ResourceType.Get(); resource_type_ok{
filter.SetResourceType(resource_type)
}
if resource_id, resource_id_ok := req.ResourceID.Get(); resource_id_ok{
filter.SetResourceID(resource_id)
}
pmap := datastore.Optional()
if Name, ok := req.Name.Get(); ok {
pmap.Add("name", Name)
}
if source, ok := req.Source.Get(); ok {
pmap.Add("source", source)
pmap.Add("hash", int64(model.HashSource(source))) // No type safety!
}
if ResourceType, ok := req.ResourceType.Get(); ok {
pmap.Add("resource_type", ResourceType)
}
if ResourceID, ok := req.ResourceID.Get(); ok {
pmap.Add("resource_id", ResourceID)
}
return svc.DB.Scripts().Update(ctx, req.ID, pmap)
return svc.inner.UpdateScript(ctx, req.ID, filter)
}

21
pkg/service/service.go
View File

@@ -5,12 +5,10 @@ import (
"errors"
"fmt"
"git.itzana.me/strafesnet/go-grpc/maps"
"git.itzana.me/strafesnet/go-grpc/users"
"git.itzana.me/strafesnet/maps-service/pkg/api"
"git.itzana.me/strafesnet/maps-service/pkg/datastore"
"git.itzana.me/strafesnet/maps-service/pkg/roblox"
"github.com/nats-io/nats.go"
"git.itzana.me/strafesnet/maps-service/pkg/service_inner"
)
var (
@@ -32,11 +30,18 @@ var (
)
type Service struct {
DB datastore.Datastore
Nats nats.JetStreamContext
Maps maps.MapsServiceClient
Users users.UsersServiceClient
Roblox roblox.Client
inner *service_inner.Service
roblox roblox.Client
}
func NewService(
inner *service_inner.Service,
roblox roblox.Client,
) Service {
return Service{
inner: inner,
roblox: roblox,
}
}
// NewError creates *ErrorStatusCode from error returned by handler.

363
pkg/service/submissions.go
View File

@@ -2,16 +2,15 @@ package service
import (
"context"
"encoding/json"
"errors"
"fmt"
"io"
"time"
"git.itzana.me/strafesnet/go-grpc/maps"
"git.itzana.me/strafesnet/maps-service/pkg/api"
"git.itzana.me/strafesnet/maps-service/pkg/datastore"
"git.itzana.me/strafesnet/maps-service/pkg/model"
"git.itzana.me/strafesnet/maps-service/pkg/service_inner"
)
var(
@@ -62,10 +61,10 @@ func (svc *Service) CreateSubmission(ctx context.Context, request *api.Submissio
// Check if user's submissions in the creation phase exceeds the limit
{
filter := datastore.Optional()
filter.Add("submitter", int64(userId))
filter.Add("status_id", CreationPhaseSubmissionStatuses)
creation_submissions, err := svc.DB.Submissions().List(ctx, filter, model.Page{
filter := service_inner.NewSubmissionFilter()
filter.SetSubmitter(userId)
filter.SetStatuses(CreationPhaseSubmissionStatuses)
creation_submissions, err := svc.inner.ListSubmissions(ctx, filter, model.Page{
Number: 1,
Size: int32(CreationPhaseSubmissionsLimit),
},datastore.ListSortDisabled)
@@ -80,7 +79,7 @@ func (svc *Service) CreateSubmission(ctx context.Context, request *api.Submissio
// Check if too many operations have been created recently
{
count, err := svc.DB.Operations().CountSince(ctx,
count, err := svc.inner.CountOperationsSince(ctx,
int64(userId),
time.Now().Add(-CreateSubmissionRecencyWindow),
)
@@ -93,7 +92,7 @@ func (svc *Service) CreateSubmission(ctx context.Context, request *api.Submissio
}
}
operation, err := svc.DB.Operations().Create(ctx, model.Operation{
operation, err := svc.inner.CreateOperation(ctx, model.Operation{
Owner: userId,
StatusID: model.OperationStatusCreated,
})
@@ -101,22 +100,15 @@ func (svc *Service) CreateSubmission(ctx context.Context, request *api.Submissio
return nil, err
}
create_request := model.CreateSubmissionRequest{
OperationID: operation.ID,
ModelID: ModelID,
DisplayName: request.DisplayName,
Creator: request.Creator,
GameID: uint32(request.GameID),
Status: uint32(model.SubmissionStatusUnderConstruction),
Roles: uint32(RolesEmpty),
}
j, err := json.Marshal(create_request)
if err != nil {
return nil, err
}
_, err = svc.Nats.Publish("maptest.submissions.create", []byte(j))
err = svc.inner.NatsCreateSubmission(
operation.ID,
ModelID,
request.DisplayName,
request.Creator,
uint32(request.GameID),
uint32(model.SubmissionStatusUnderConstruction),
uint32(RolesEmpty),
)
if err != nil {
return nil, err
}
@@ -156,7 +148,7 @@ func (svc *Service) CreateSubmissionAdmin(ctx context.Context, request *api.Subm
// Check if too many operations have been created recently
{
count, err := svc.DB.Operations().CountSince(ctx,
count, err := svc.inner.CountOperationsSince(ctx,
int64(userId),
time.Now().Add(-CreateSubmissionRecencyWindow),
)
@@ -169,7 +161,7 @@ func (svc *Service) CreateSubmissionAdmin(ctx context.Context, request *api.Subm
}
}
operation, err := svc.DB.Operations().Create(ctx, model.Operation{
operation, err := svc.inner.CreateOperation(ctx, model.Operation{
Owner: userId,
StatusID: model.OperationStatusCreated,
})
@@ -177,22 +169,15 @@ func (svc *Service) CreateSubmissionAdmin(ctx context.Context, request *api.Subm
return nil, err
}
create_request := model.CreateSubmissionRequest{
OperationID: operation.ID,
ModelID: ModelID,
DisplayName: request.DisplayName,
Creator: request.Creator,
GameID: uint32(request.GameID),
Status: uint32(model.SubmissionStatusChangesRequested),
Roles: uint32(roles),
}
j, err := json.Marshal(create_request)
if err != nil {
return nil, err
}
_, err = svc.Nats.Publish("maptest.submissions.create", []byte(j))
err = svc.inner.NatsCreateSubmission(
operation.ID,
ModelID,
request.DisplayName,
request.Creator,
uint32(request.GameID),
uint32(model.SubmissionStatusChangesRequested),
uint32(roles),
)
if err != nil {
return nil, err
}
@@ -208,7 +193,7 @@ func (svc *Service) CreateSubmissionAdmin(ctx context.Context, request *api.Subm
//
// GET /submissions/{SubmissionID}
func (svc *Service) GetSubmission(ctx context.Context, params api.GetSubmissionParams) (*api.Submission, error) {
submission, err := svc.DB.Submissions().Get(ctx, params.SubmissionID)
submission, err := svc.inner.GetSubmission(ctx, params.SubmissionID)
if err != nil {
return nil, err
}
@@ -234,33 +219,33 @@ func (svc *Service) GetSubmission(ctx context.Context, params api.GetSubmissionP
//
// GET /submissions
func (svc *Service) ListSubmissions(ctx context.Context, params api.ListSubmissionsParams) (*api.Submissions, error) {
filter := datastore.Optional()
filter := service_inner.NewSubmissionFilter()
if params.DisplayName.IsSet(){
filter.Add("display_name", params.DisplayName.Value)
if display_name, display_name_ok := params.DisplayName.Get(); display_name_ok{
filter.SetDisplayName(display_name)
}
if params.Creator.IsSet(){
filter.Add("creator", params.Creator.Value)
if creator, creator_ok := params.Creator.Get(); creator_ok{
filter.SetCreator(creator)
}
if params.GameID.IsSet(){
filter.Add("game_id", params.GameID.Value)
if game_id, game_id_ok := params.GameID.Get(); game_id_ok{
filter.SetGameID(uint32(game_id))
}
if params.Submitter.IsSet(){
filter.Add("submitter", params.Submitter.Value)
if submitter, submitter_ok := params.Submitter.Get(); submitter_ok{
filter.SetSubmitter(uint64(submitter))
}
if params.AssetID.IsSet(){
filter.Add("asset_id", params.AssetID.Value)
if asset_id, asset_id_ok := params.AssetID.Get(); asset_id_ok{
filter.SetAssetID(uint64(asset_id))
}
if params.UploadedAssetID.IsSet(){
filter.Add("uploaded_asset_id", params.UploadedAssetID.Value)
if uploaded_asset_id, uploaded_asset_id_ok := params.UploadedAssetID.Get(); uploaded_asset_id_ok{
filter.SetUploadedAssetID(uint64(uploaded_asset_id))
}
if params.StatusID.IsSet(){
filter.Add("status_id", params.StatusID.Value)
if status_id, status_id_ok := params.StatusID.Get(); status_id_ok{
filter.SetStatuses([]model.SubmissionStatus{model.SubmissionStatus(status_id)})
}
sort := datastore.ListSort(params.Sort.Or(int32(datastore.ListSortDisabled)))
total, items, err := svc.DB.Submissions().ListWithTotal(ctx, filter, model.Page{
total, items, err := svc.inner.ListSubmissionsWithTotal(ctx, filter, model.Page{
Number: params.Page,
Size: params.Limit,
},sort)
@@ -310,9 +295,9 @@ func (svc *Service) SetSubmissionCompleted(ctx context.Context, params api.SetSu
return ErrPermissionDeniedNeedRoleMaptest
}
pmap := datastore.Optional()
pmap.Add("completed", true)
return svc.DB.Submissions().Update(ctx, params.SubmissionID, pmap)
update := service_inner.NewSubmissionUpdate()
update.SetCompleted(true)
return svc.inner.UpdateSubmission(ctx, params.SubmissionID, update)
}
// UpdateSubmissionModel implements patchSubmissionModel operation.
@@ -327,7 +312,7 @@ func (svc *Service) UpdateSubmissionModel(ctx context.Context, params api.Update
}
// read submission (this could be done with a transaction WHERE clause)
submission, err := svc.DB.Submissions().Get(ctx, params.SubmissionID)
submission, err := svc.inner.GetSubmission(ctx, params.SubmissionID)
if err != nil {
return err
}
@@ -349,12 +334,12 @@ func (svc *Service) UpdateSubmissionModel(ctx context.Context, params api.Update
NewModelVersion := uint64(params.ModelVersion)
// check if Status is ChangesRequested|Submitted|UnderConstruction
pmap := datastore.Optional()
pmap.Add("asset_id", NewModelID)
pmap.Add("asset_version", NewModelVersion)
update := service_inner.NewSubmissionUpdate()
update.SetAssetID(NewModelID)
update.SetAssetVersion(NewModelVersion)
//always reset completed when model changes
pmap.Add("completed", false)
err = svc.DB.Submissions().IfStatusThenUpdate(ctx, params.SubmissionID, []model.SubmissionStatus{model.SubmissionStatusChangesRequested, model.SubmissionStatusUnderConstruction}, pmap)
update.SetCompleted(false)
err = svc.inner.UpdateSubmissionIfStatus(ctx, params.SubmissionID, []model.SubmissionStatus{model.SubmissionStatusChangesRequested, model.SubmissionStatusUnderConstruction}, update)
if err != nil {
return err
}
@@ -366,7 +351,7 @@ func (svc *Service) UpdateSubmissionModel(ctx context.Context, params api.Update
NewModelVersion: NewModelVersion,
}
return svc.CreateAuditEventChangeModel(
return svc.inner.CreateAuditEventChangeModel(
ctx,
userId,
model.Resource{
@@ -404,9 +389,10 @@ func (svc *Service) ActionSubmissionReject(ctx context.Context, params api.Actio
// transaction
target_status := model.SubmissionStatusRejected
smap := datastore.Optional()
smap.Add("status_id", target_status)
err = svc.DB.Submissions().IfStatusThenUpdate(ctx, params.SubmissionID, []model.SubmissionStatus{model.SubmissionStatusSubmitted}, smap)
update := service_inner.NewSubmissionUpdate()
update.SetStatusID(target_status)
allowed_statuses := []model.SubmissionStatus{model.SubmissionStatusSubmitted}
err = svc.inner.UpdateSubmissionIfStatus(ctx, params.SubmissionID, allowed_statuses, update)
if err != nil {
return err
}
@@ -415,7 +401,7 @@ func (svc *Service) ActionSubmissionReject(ctx context.Context, params api.Actio
TargetStatus: uint32(target_status),
}
return svc.CreateAuditEventAction(
return svc.inner.CreateAuditEventAction(
ctx,
userId,
model.Resource{
@@ -453,9 +439,10 @@ func (svc *Service) ActionSubmissionRequestChanges(ctx context.Context, params a
// transaction
target_status := model.SubmissionStatusChangesRequested
smap := datastore.Optional()
smap.Add("status_id", target_status)
err = svc.DB.Submissions().IfStatusThenUpdate(ctx, params.SubmissionID, []model.SubmissionStatus{model.SubmissionStatusValidated, model.SubmissionStatusAcceptedUnvalidated, model.SubmissionStatusSubmitted}, smap)
update := service_inner.NewSubmissionUpdate()
update.SetStatusID(target_status)
allowed_statuses := []model.SubmissionStatus{model.SubmissionStatusValidated, model.SubmissionStatusAcceptedUnvalidated, model.SubmissionStatusSubmitted}
err = svc.inner.UpdateSubmissionIfStatus(ctx, params.SubmissionID, allowed_statuses, update)
if err != nil {
return err
}
@@ -464,7 +451,7 @@ func (svc *Service) ActionSubmissionRequestChanges(ctx context.Context, params a
TargetStatus: uint32(target_status),
}
return svc.CreateAuditEventAction(
return svc.inner.CreateAuditEventAction(
ctx,
userId,
model.Resource{
@@ -487,7 +474,7 @@ func (svc *Service) ActionSubmissionRevoke(ctx context.Context, params api.Actio
}
// read submission (this could be done with a transaction WHERE clause)
submission, err := svc.DB.Submissions().Get(ctx, params.SubmissionID)
submission, err := svc.inner.GetSubmission(ctx, params.SubmissionID)
if err != nil {
return err
}
@@ -505,9 +492,10 @@ func (svc *Service) ActionSubmissionRevoke(ctx context.Context, params api.Actio
// transaction
target_status := model.SubmissionStatusUnderConstruction
smap := datastore.Optional()
smap.Add("status_id", target_status)
err = svc.DB.Submissions().IfStatusThenUpdate(ctx, params.SubmissionID, []model.SubmissionStatus{model.SubmissionStatusSubmitted, model.SubmissionStatusChangesRequested}, smap)
update := service_inner.NewSubmissionUpdate()
update.SetStatusID(target_status)
allowed_statuses := []model.SubmissionStatus{model.SubmissionStatusSubmitted, model.SubmissionStatusChangesRequested}
err = svc.inner.UpdateSubmissionIfStatus(ctx, params.SubmissionID, allowed_statuses, update)
if err != nil {
return err
}
@@ -516,7 +504,7 @@ func (svc *Service) ActionSubmissionRevoke(ctx context.Context, params api.Actio
TargetStatus: uint32(target_status),
}
return svc.CreateAuditEventAction(
return svc.inner.CreateAuditEventAction(
ctx,
userId,
model.Resource{
@@ -539,7 +527,7 @@ func (svc *Service) ActionSubmissionTriggerSubmit(ctx context.Context, params ap
}
// read submission (this could be done with a transaction WHERE clause)
submission, err := svc.DB.Submissions().Get(ctx, params.SubmissionID)
submission, err := svc.inner.GetSubmission(ctx, params.SubmissionID)
if err != nil {
return err
}
@@ -565,25 +553,19 @@ func (svc *Service) ActionSubmissionTriggerSubmit(ctx context.Context, params ap
// transaction
target_status := model.SubmissionStatusSubmitting
smap := datastore.Optional()
smap.Add("status_id", target_status)
err = svc.DB.Submissions().IfStatusThenUpdate(ctx, params.SubmissionID, []model.SubmissionStatus{model.SubmissionStatusUnderConstruction, model.SubmissionStatusChangesRequested}, smap)
update := service_inner.NewSubmissionUpdate()
update.SetStatusID(target_status)
allowed_statuses := []model.SubmissionStatus{model.SubmissionStatusUnderConstruction, model.SubmissionStatusChangesRequested}
err = svc.inner.UpdateSubmissionIfStatus(ctx, params.SubmissionID, allowed_statuses, update)
if err != nil {
return err
}
validate_request := model.CheckSubmissionRequest{
SubmissionID: submission.ID,
ModelID: submission.AssetID,
SkipChecks: false,
}
j, err := json.Marshal(validate_request)
if err != nil {
return err
}
_, err = svc.Nats.Publish("maptest.submissions.check", []byte(j))
err = svc.inner.NatsCheckSubmission(
submission.ID,
submission.AssetID,
false,
)
if err != nil {
return err
}
@@ -592,7 +574,7 @@ func (svc *Service) ActionSubmissionTriggerSubmit(ctx context.Context, params ap
TargetStatus: uint32(target_status),
}
return svc.CreateAuditEventAction(
return svc.inner.CreateAuditEventAction(
ctx,
userId,
model.Resource{
@@ -615,7 +597,7 @@ func (svc *Service) ActionSubmissionTriggerSubmitUnchecked(ctx context.Context,
}
// read submission (this could be done with a transaction WHERE clause)
submission, err := svc.DB.Submissions().Get(ctx, params.SubmissionID)
submission, err := svc.inner.GetSubmission(ctx, params.SubmissionID)
if err != nil {
return err
}
@@ -642,25 +624,19 @@ func (svc *Service) ActionSubmissionTriggerSubmitUnchecked(ctx context.Context,
// transaction
target_status := model.SubmissionStatusSubmitting
smap := datastore.Optional()
smap.Add("status_id", target_status)
err = svc.DB.Submissions().IfStatusThenUpdate(ctx, params.SubmissionID, []model.SubmissionStatus{model.SubmissionStatusChangesRequested}, smap)
update := service_inner.NewSubmissionUpdate()
update.SetStatusID(target_status)
allowed_statuses := []model.SubmissionStatus{model.SubmissionStatusChangesRequested}
err = svc.inner.UpdateSubmissionIfStatus(ctx, params.SubmissionID, allowed_statuses, update)
if err != nil {
return err
}
validate_request := model.CheckSubmissionRequest{
SubmissionID: submission.ID,
ModelID: submission.AssetID,
SkipChecks: true,
}
j, err := json.Marshal(validate_request)
if err != nil {
return err
}
_, err = svc.Nats.Publish("maptest.submissions.check", []byte(j))
err = svc.inner.NatsCheckSubmission(
submission.ID,
submission.AssetID,
true,
)
if err != nil {
return err
}
@@ -669,7 +645,7 @@ func (svc *Service) ActionSubmissionTriggerSubmitUnchecked(ctx context.Context,
TargetStatus: uint32(target_status),
}
return svc.CreateAuditEventAction(
return svc.inner.CreateAuditEventAction(
ctx,
userId,
model.Resource{
@@ -697,7 +673,7 @@ func (svc *Service) ActionSubmissionResetSubmitting(ctx context.Context, params
}
// check when submission was updated
submission, err := svc.DB.Submissions().Get(ctx, params.SubmissionID)
submission, err := svc.inner.GetSubmission(ctx, params.SubmissionID)
if err != nil {
return err
}
@@ -714,9 +690,10 @@ func (svc *Service) ActionSubmissionResetSubmitting(ctx context.Context, params
// transaction
target_status := model.SubmissionStatusUnderConstruction
smap := datastore.Optional()
smap.Add("status_id", target_status)
err = svc.DB.Submissions().IfStatusThenUpdate(ctx, params.SubmissionID, []model.SubmissionStatus{model.SubmissionStatusSubmitting}, smap)
update := service_inner.NewSubmissionUpdate()
update.SetStatusID(target_status)
allowed_statuses := []model.SubmissionStatus{model.SubmissionStatusSubmitting}
err = svc.inner.UpdateSubmissionIfStatus(ctx, params.SubmissionID, allowed_statuses, update)
if err != nil {
return err
}
@@ -725,7 +702,7 @@ func (svc *Service) ActionSubmissionResetSubmitting(ctx context.Context, params
TargetStatus: uint32(target_status),
}
return svc.CreateAuditEventAction(
return svc.inner.CreateAuditEventAction(
ctx,
userId,
model.Resource{
@@ -763,9 +740,10 @@ func (svc *Service) ActionSubmissionTriggerUpload(ctx context.Context, params ap
// transaction
target_status := model.SubmissionStatusUploading
smap := datastore.Optional()
smap.Add("status_id", target_status)
submission, err := svc.DB.Submissions().IfStatusThenUpdateAndGet(ctx, params.SubmissionID, []model.SubmissionStatus{model.SubmissionStatusValidated}, smap)
update := service_inner.NewSubmissionUpdate()
update.SetStatusID(target_status)
allowed_statuses := []model.SubmissionStatus{model.SubmissionStatusValidated}
submission, err := svc.inner.UpdateAndGetSubmissionIfStatus(ctx, params.SubmissionID, allowed_statuses, update)
if err != nil {
return err
}
@@ -773,20 +751,13 @@ func (svc *Service) ActionSubmissionTriggerUpload(ctx context.Context, params ap
// sentinel value because we are not using rust
if submission.UploadedAssetID == 0 {
// this is a new map
upload_new_request := model.UploadSubmissionRequest{
SubmissionID: submission.ID,
ModelID: submission.ValidatedAssetID,
ModelVersion: submission.ValidatedAssetVersion,
// upload as displayname, whatever
ModelName: submission.DisplayName,
}
j, err := json.Marshal(upload_new_request)
if err != nil {
return err
}
_, err = svc.Nats.Publish("maptest.submissions.upload", []byte(j))
err = svc.inner.NatsUploadSubmission(
submission.ID,
submission.ValidatedAssetID,
submission.ValidatedAssetVersion,
// upload ModelName as displayname, whatever
submission.DisplayName,
)
if err != nil {
return err
}
@@ -799,7 +770,7 @@ func (svc *Service) ActionSubmissionTriggerUpload(ctx context.Context, params ap
TargetStatus: uint32(target_status),
}
return svc.CreateAuditEventAction(
return svc.inner.CreateAuditEventAction(
ctx,
userId,
model.Resource{
@@ -836,7 +807,7 @@ func (svc *Service) ActionSubmissionValidated(ctx context.Context, params api.Ac
}
// check when submission was updated
submission, err := svc.DB.Submissions().Get(ctx, params.SubmissionID)
submission, err := svc.inner.GetSubmission(ctx, params.SubmissionID)
if err != nil {
return err
}
@@ -847,9 +818,10 @@ func (svc *Service) ActionSubmissionValidated(ctx context.Context, params api.Ac
// transaction
target_status := model.SubmissionStatusValidated
smap := datastore.Optional()
smap.Add("status_id", target_status)
err = svc.DB.Submissions().IfStatusThenUpdate(ctx, params.SubmissionID, []model.SubmissionStatus{model.SubmissionStatusUploading}, smap)
update := service_inner.NewSubmissionUpdate()
update.SetStatusID(target_status)
allowed_statuses := []model.SubmissionStatus{model.SubmissionStatusUploading}
err = svc.inner.UpdateSubmissionIfStatus(ctx, params.SubmissionID, allowed_statuses, update)
if err != nil {
return err
}
@@ -858,7 +830,7 @@ func (svc *Service) ActionSubmissionValidated(ctx context.Context, params api.Ac
TargetStatus: uint32(target_status),
}
return svc.CreateAuditEventAction(
return svc.inner.CreateAuditEventAction(
ctx,
userId,
model.Resource{
@@ -890,7 +862,7 @@ func (svc *Service) ActionSubmissionTriggerValidate(ctx context.Context, params
}
// read submission (this could be done with a transaction WHERE clause)
submission, err := svc.DB.Submissions().Get(ctx, params.SubmissionID)
submission, err := svc.inner.GetSubmission(ctx, params.SubmissionID)
if err != nil {
return err
}
@@ -908,31 +880,20 @@ func (svc *Service) ActionSubmissionTriggerValidate(ctx context.Context, params
// transaction
target_status := model.SubmissionStatusValidating
smap := datastore.Optional()
smap.Add("status_id", target_status)
submission, err = svc.DB.Submissions().IfStatusThenUpdateAndGet(ctx, params.SubmissionID, []model.SubmissionStatus{model.SubmissionStatusSubmitted}, smap)
update := service_inner.NewSubmissionUpdate()
update.SetStatusID(target_status)
allowed_statuses := []model.SubmissionStatus{model.SubmissionStatusSubmitted}
submission, err = svc.inner.UpdateAndGetSubmissionIfStatus(ctx, params.SubmissionID, allowed_statuses, update)
if err != nil {
return err
}
validate_request := model.ValidateSubmissionRequest{
SubmissionID: submission.ID,
ModelID: submission.AssetID,
ModelVersion: submission.AssetVersion,
ValidatedModelID: nil,
}
// sentinel values because we're not using rust
if submission.ValidatedAssetID != 0 {
validate_request.ValidatedModelID = &submission.ValidatedAssetID
}
j, err := json.Marshal(validate_request)
if err != nil {
return err
}
_, err = svc.Nats.Publish("maptest.submissions.validate", []byte(j))
err = svc.inner.NatsValidateSubmission(
submission.ID,
submission.AssetID,
submission.AssetVersion,
submission.ValidatedAssetID,
)
if err != nil {
return err
}
@@ -941,7 +902,7 @@ func (svc *Service) ActionSubmissionTriggerValidate(ctx context.Context, params
TargetStatus: uint32(target_status),
}
return svc.CreateAuditEventAction(
return svc.inner.CreateAuditEventAction(
ctx,
userId,
model.Resource{
@@ -979,31 +940,20 @@ func (svc *Service) ActionSubmissionRetryValidate(ctx context.Context, params ap
// transaction
target_status := model.SubmissionStatusValidating
smap := datastore.Optional()
smap.Add("status_id", target_status)
submission, err := svc.DB.Submissions().IfStatusThenUpdateAndGet(ctx, params.SubmissionID, []model.SubmissionStatus{model.SubmissionStatusAcceptedUnvalidated}, smap)
update := service_inner.NewSubmissionUpdate()
update.SetStatusID(target_status)
allowed_statuses := []model.SubmissionStatus{model.SubmissionStatusAcceptedUnvalidated}
submission, err := svc.inner.UpdateAndGetSubmissionIfStatus(ctx, params.SubmissionID, allowed_statuses, update)
if err != nil {
return err
}
validate_request := model.ValidateSubmissionRequest{
SubmissionID: submission.ID,
ModelID: submission.AssetID,
ModelVersion: submission.AssetVersion,
ValidatedModelID: nil,
}
// sentinel values because we're not using rust
if submission.ValidatedAssetID != 0 {
validate_request.ValidatedModelID = &submission.ValidatedAssetID
}
j, err := json.Marshal(validate_request)
if err != nil {
return err
}
_, err = svc.Nats.Publish("maptest.submissions.validate", []byte(j))
err = svc.inner.NatsValidateSubmission(
submission.ID,
submission.AssetID,
submission.AssetVersion,
submission.ValidatedAssetID,
)
if err != nil {
return err
}
@@ -1012,7 +962,7 @@ func (svc *Service) ActionSubmissionRetryValidate(ctx context.Context, params ap
TargetStatus: uint32(target_status),
}
return svc.CreateAuditEventAction(
return svc.inner.CreateAuditEventAction(
ctx,
userId,
model.Resource{
@@ -1049,7 +999,7 @@ func (svc *Service) ActionSubmissionAccepted(ctx context.Context, params api.Act
}
// check when submission was updated
submission, err := svc.DB.Submissions().Get(ctx, params.SubmissionID)
submission, err := svc.inner.GetSubmission(ctx, params.SubmissionID)
if err != nil {
return err
}
@@ -1060,9 +1010,10 @@ func (svc *Service) ActionSubmissionAccepted(ctx context.Context, params api.Act
// transaction
target_status := model.SubmissionStatusAcceptedUnvalidated
smap := datastore.Optional()
smap.Add("status_id", target_status)
err = svc.DB.Submissions().IfStatusThenUpdate(ctx, params.SubmissionID, []model.SubmissionStatus{model.SubmissionStatusValidating}, smap)
update := service_inner.NewSubmissionUpdate()
update.SetStatusID(target_status)
allowed_statuses := []model.SubmissionStatus{model.SubmissionStatusValidating}
err = svc.inner.UpdateSubmissionIfStatus(ctx, params.SubmissionID, allowed_statuses, update)
if err != nil {
return err
}
@@ -1071,7 +1022,7 @@ func (svc *Service) ActionSubmissionAccepted(ctx context.Context, params api.Act
TargetStatus: uint32(target_status),
}
return svc.CreateAuditEventAction(
return svc.inner.CreateAuditEventAction(
ctx,
userId,
model.Resource{
@@ -1108,7 +1059,7 @@ func (svc *Service) ReleaseSubmissions(ctx context.Context, request []api.Releas
}
// fetch submissions
submissions, err := svc.DB.Submissions().GetList(ctx, idList)
submissions, err := svc.inner.GetSubmissionList(ctx, idList)
if err != nil {
return err
}
@@ -1127,21 +1078,21 @@ func (svc *Service) ReleaseSubmissions(ctx context.Context, request []api.Releas
date := request[i].Date.Unix()
var GameID = int32(submission.GameID)
// create each map with go-grpc
_, err := svc.Maps.Create(ctx, &maps.MapRequest{
_, err := svc.inner.CreateMap(ctx, model.Map{
ID: int64(submission.UploadedAssetID),
DisplayName: &submission.DisplayName,
Creator: &submission.Creator,
GameID: &GameID,
Date: &date,
DisplayName: submission.DisplayName,
Creator: submission.Creator,
GameID: GameID,
Date: time.Unix(date, 0),
})
if err != nil {
return err
}
// update each status to Released
smap := datastore.Optional()
smap.Add("status_id", model.SubmissionStatusReleased)
err = svc.DB.Submissions().IfStatusThenUpdate(ctx, submission.ID, []model.SubmissionStatus{model.SubmissionStatusUploaded}, smap)
update := service_inner.NewSubmissionUpdate()
update.SetStatusID(model.SubmissionStatusReleased)
err = svc.inner.UpdateSubmissionIfStatus(ctx, submission.ID, []model.SubmissionStatus{model.SubmissionStatusUploaded}, update)
if err != nil {
return err
}
@@ -1173,7 +1124,7 @@ func (svc *Service) CreateSubmissionAuditComment(ctx context.Context, req api.Cr
if !has_role {
// Submitter has special permission to comment on their submission
submission, err := svc.DB.Submissions().Get(ctx, params.SubmissionID)
submission, err := svc.inner.GetSubmission(ctx, params.SubmissionID)
if err != nil {
return err
}
@@ -1192,7 +1143,7 @@ func (svc *Service) CreateSubmissionAuditComment(ctx context.Context, req api.Cr
Comment: string(data),
}
return svc.CreateAuditEventComment(
return svc.inner.CreateAuditEventComment(
ctx,
userId,
model.Resource{
@@ -1209,7 +1160,7 @@ func (svc *Service) CreateSubmissionAuditComment(ctx context.Context, req api.Cr
//
// GET /submissions/{SubmissionID}/audit-events
func (svc *Service) ListSubmissionAuditEvents(ctx context.Context, params api.ListSubmissionAuditEventsParams) ([]api.AuditEvent, error) {
return svc.ListAuditEvents(
return svc.inner.ListAuditEvents(
ctx,
model.Resource{
ID: params.SubmissionID,

76
pkg/service/audit_events.go → pkg/service_inner/audit_events.go
View File

@@ -1,4 +1,4 @@
package service
package service_inner
import (
"context"
@@ -16,7 +16,7 @@ func (svc *Service) ListAuditEvents(ctx context.Context, resource model.Resource
filter.Add("resource_type", resource.Type)
filter.Add("resource_id", resource.ID)
items, err := svc.DB.AuditEvents().List(ctx, filter, page)
items, err := svc.db.AuditEvents().List(ctx, filter, page)
if err != nil {
return nil, err
}
@@ -32,7 +32,7 @@ func (svc *Service) ListAuditEvents(ctx context.Context, resource model.Resource
idList.ID = append(idList.ID, userId)
}
userList, err := svc.Users.GetList(ctx, &idList)
userList, err := svc.users.GetList(ctx, &idList)
if err != nil {
return nil, err
}
@@ -74,7 +74,7 @@ func (svc *Service) CreateAuditEventAction(ctx context.Context, userId uint64, r
return err
}
_, err = svc.DB.AuditEvents().Create(ctx, model.AuditEvent{
_, err = svc.db.AuditEvents().Create(ctx, model.AuditEvent{
ID: 0,
User: userId,
ResourceType: resource.Type,
@@ -95,7 +95,7 @@ func (svc *Service) CreateAuditEventComment(ctx context.Context, userId uint64,
return err
}
_, err = svc.DB.AuditEvents().Create(ctx, model.AuditEvent{
_, err = svc.db.AuditEvents().Create(ctx, model.AuditEvent{
ID: 0,
User: userId,
ResourceType: resource.Type,
@@ -116,7 +116,7 @@ func (svc *Service) CreateAuditEventChangeModel(ctx context.Context, userId uint
return err
}
_, err = svc.DB.AuditEvents().Create(ctx, model.AuditEvent{
_, err = svc.db.AuditEvents().Create(ctx, model.AuditEvent{
ID: 0,
User: userId,
ResourceType: resource.Type,
@@ -130,3 +130,67 @@ func (svc *Service) CreateAuditEventChangeModel(ctx context.Context, userId uint
return nil
}
func (svc *Service) CreateAuditEventChangeValidatedModel(ctx context.Context, userId uint64, resource model.Resource, event_data model.AuditEventDataChangeValidatedModel) error {
EventData, err := json.Marshal(event_data)
if err != nil {
return err
}
_, err = svc.db.AuditEvents().Create(ctx, model.AuditEvent{
ID: 0,
User: userId,
ResourceType: resource.Type,
ResourceID: resource.ID,
EventType: model.AuditEventTypeChangeValidatedModel,
EventData: EventData,
})
if err != nil {
return err
}
return nil
}
func (svc *Service) CreateAuditEventError(ctx context.Context, userId uint64, resource model.Resource, event_data model.AuditEventDataError) error {
EventData, err := json.Marshal(event_data)
if err != nil {
return err
}
_, err = svc.db.AuditEvents().Create(ctx, model.AuditEvent{
ID: 0,
User: userId,
ResourceType: resource.Type,
ResourceID: resource.ID,
EventType: model.AuditEventTypeError,
EventData: EventData,
})
if err != nil {
return err
}
return nil
}
func (svc *Service) CreateAuditEventCheckList(ctx context.Context, userId uint64, resource model.Resource, event_data model.AuditEventDataCheckList) error {
EventData, err := json.Marshal(event_data)
if err != nil {
return err
}
_, err = svc.db.AuditEvents().Create(ctx, model.AuditEvent{
ID: 0,
User: userId,
ResourceType: resource.Type,
ResourceID: resource.ID,
EventType: model.AuditEventTypeCheckList,
EventData: EventData,
})
if err != nil {
return err
}
return nil
}

116
pkg/service_inner/mapfixes.go Normal file
View File

@@ -0,0 +1,116 @@
package service_inner
import (
"context"
"git.itzana.me/strafesnet/maps-service/pkg/datastore"
"git.itzana.me/strafesnet/maps-service/pkg/model"
)
type MapfixUpdate datastore.OptionalMap
func NewMapfixUpdate() MapfixUpdate {
update := datastore.Optional()
return MapfixUpdate(update)
}
func (update MapfixUpdate) SetDisplayName(display_name string) {
datastore.OptionalMap(update).Add("display_name", display_name)
}
func (update MapfixUpdate) SetCreator(creator string) {
datastore.OptionalMap(update).Add("creator", creator)
}
func (update MapfixUpdate) SetGameID(game_id uint32) {
datastore.OptionalMap(update).Add("game_id", game_id)
}
func (update MapfixUpdate) SetSubmitter(submitter uint64) {
datastore.OptionalMap(update).Add("submitter", submitter)
}
func (update MapfixUpdate) SetAssetID(asset_id uint64) {
datastore.OptionalMap(update).Add("asset_id", asset_id)
}
func (update MapfixUpdate) SetAssetVersion(asset_version uint64) {
datastore.OptionalMap(update).Add("asset_version", asset_version)
}
func (update MapfixUpdate) SetValidatedAssetID(validated_asset_id uint64) {
datastore.OptionalMap(update).Add("validated_asset_id", validated_asset_id)
}
func (update MapfixUpdate) SetValidatedAssetVersion(validated_asset_version uint64) {
datastore.OptionalMap(update).Add("validated_asset_version", validated_asset_version)
}
func (update MapfixUpdate) SetCompleted(completed bool) {
datastore.OptionalMap(update).Add("completed", completed)
}
func (update MapfixUpdate) SetTargetAssetID(target_asset_id uint64) {
datastore.OptionalMap(update).Add("target_asset_id", target_asset_id)
}
func (update MapfixUpdate) SetStatusID(status_id model.MapfixStatus) {
datastore.OptionalMap(update).Add("status_id", status_id)
}
func (update MapfixUpdate) SetDescription(description string) {
datastore.OptionalMap(update).Add("description", description)
}
type MapfixFilter datastore.OptionalMap
func NewMapfixFilter(
) MapfixFilter {
filter := datastore.Optional()
return MapfixFilter(filter)
}
func (update MapfixFilter) SetDisplayName(display_name string) {
datastore.OptionalMap(update).Add("display_name", display_name)
}
func (update MapfixFilter) SetCreator(creator string) {
datastore.OptionalMap(update).Add("creator", creator)
}
func (update MapfixFilter) SetGameID(game_id uint32) {
datastore.OptionalMap(update).Add("game_id", game_id)
}
func (update MapfixFilter) SetSubmitter(submitter uint64) {
datastore.OptionalMap(update).Add("submitter", submitter)
}
func (update MapfixFilter) SetAssetID(asset_id uint64) {
datastore.OptionalMap(update).Add("asset_id", asset_id)
}
func (update MapfixFilter) SetAssetVersion(asset_version uint64) {
datastore.OptionalMap(update).Add("asset_version", asset_version)
}
func (update MapfixFilter) SetTargetAssetID(target_asset_id uint64) {
datastore.OptionalMap(update).Add("target_asset_id", target_asset_id)
}
func (update MapfixFilter) SetStatuses(statuses []model.MapfixStatus) {
datastore.OptionalMap(update).Add("status_id", statuses)
}
func (svc *Service) CreateMapfix(ctx context.Context, script model.Mapfix) (model.Mapfix, error) {
return svc.db.Mapfixes().Create(ctx, script)
}
func (svc *Service) ListMapfixes(ctx context.Context, filter MapfixFilter, page model.Page, sort datastore.ListSort) ([]model.Mapfix, error) {
return svc.db.Mapfixes().List(ctx, datastore.OptionalMap(filter), page, sort)
}
func (svc *Service) ListMapfixesWithTotal(ctx context.Context, filter MapfixFilter, page model.Page, sort datastore.ListSort) (int64, []model.Mapfix, error) {
return svc.db.Mapfixes().ListWithTotal(ctx, datastore.OptionalMap(filter), page, sort)
}
func (svc *Service) DeleteMapfix(ctx context.Context, id int64) error {
return svc.db.Mapfixes().Delete(ctx, id)
}
func (svc *Service) GetMapfix(ctx context.Context, id int64) (model.Mapfix, error) {
return svc.db.Mapfixes().Get(ctx, id)
}
func (svc *Service) UpdateMapfix(ctx context.Context, id int64, pmap MapfixUpdate) error {
return svc.db.Mapfixes().Update(ctx, id, datastore.OptionalMap(pmap))
}
func (svc *Service) UpdateMapfixIfStatus(ctx context.Context, id int64, statuses []model.MapfixStatus, pmap MapfixUpdate) error {
return svc.db.Mapfixes().IfStatusThenUpdate(ctx, id, statuses, datastore.OptionalMap(pmap))
}
func (svc *Service) UpdateAndGetMapfixIfStatus(ctx context.Context, id int64, statuses []model.MapfixStatus, pmap MapfixUpdate) (model.Mapfix, error) {
return svc.db.Mapfixes().IfStatusThenUpdateAndGet(ctx, id, statuses, datastore.OptionalMap(pmap))
}

116
pkg/service_inner/maps.go Normal file
View File

@@ -0,0 +1,116 @@
package service_inner
import (
"context"
"time"
"git.itzana.me/strafesnet/go-grpc/maps"
"git.itzana.me/strafesnet/maps-service/pkg/model"
)
// Optional map used to update an object
type MapUpdate maps.MapRequest
func NewMapUpdate(id int64) *MapUpdate {
item := MapUpdate{
ID: id,
}
return &item
}
func (update *MapUpdate) SetDisplayName(display_name string) {
update.DisplayName = &display_name
}
func (update *MapUpdate) SetCreator(creator string) {
update.Creator = &creator
}
func (update *MapUpdate) SetGameID(game_id int32) {
update.GameID = &game_id
}
func (update *MapUpdate) SetDate(date int64) {
update.Date = &date
}
// Optional map used to find matching objects
type MapFilter maps.MapFilter
func NewMapFilter() *MapFilter {
item := MapFilter{}
return &item
}
func (filter *MapFilter) SetDisplayName(display_name string) {
filter.DisplayName = &display_name
}
func (filter *MapFilter) SetCreator(creator string) {
filter.Creator = &creator
}
func (filter *MapFilter) SetGameID(game_id int32) {
filter.GameID = &game_id
}
func (svc *Service) CreateMap(ctx context.Context, item model.Map) (int64, error) {
date := item.Date.Unix()
id_message, err := svc.maps.Create(ctx, &maps.MapRequest{
ID: item.ID,
DisplayName: &item.DisplayName,
Creator: &item.Creator,
GameID: &item.GameID,
Date: &date,
})
if err != nil {
return 0, err
}
return id_message.ID, nil
}
func (svc *Service) ListMaps(ctx context.Context, filter *MapFilter, page model.Page) ([]model.Map, error) {
page_request := maps.Pagination{
Size: page.Size,
Number: page.Number,
}
request := maps.ListRequest{
Filter: (*maps.MapFilter)(filter),
Page: &page_request,
}
items, err := svc.maps.List(ctx, &request)
if err != nil {
return nil, err
}
resp := make([]model.Map, len(items.Maps))
for i, item := range items.Maps {
resp[i].ID = item.ID
resp[i].DisplayName = item.DisplayName
resp[i].Creator = item.Creator
resp[i].GameID = item.GameID
resp[i].Date = time.Unix(item.Date, 0)
}
return resp, nil
}
func (svc *Service) DeleteMap(ctx context.Context, id int64) error {
_, err := svc.maps.Delete(ctx, &maps.IdMessage{ID: id})
return err
}
func (svc *Service) GetMap(ctx context.Context, id int64) (*model.Map, error) {
item, err := svc.maps.Get(ctx, &maps.IdMessage{ID: id})
if err != nil {
return nil, err
}
return &model.Map{
ID: item.ID,
DisplayName: item.DisplayName,
Creator: item.Creator,
GameID: item.GameID,
Date: time.Unix(item.Date, 0),
}, nil
}
func (svc *Service) UpdateMap(ctx context.Context, pmap *MapUpdate) error {
_, err := svc.maps.Update(ctx, (*maps.MapRequest)(pmap))
return err
}

114
pkg/service_inner/nats_mapfix.go Normal file
View File

@@ -0,0 +1,114 @@
package service_inner
import (
"encoding/json"
"git.itzana.me/strafesnet/maps-service/pkg/model"
)
func (svc *Service) NatsCreateMapfix(
OperationID int32,
ModelID uint64,
TargetAssetID uint64,
Description string,
) error {
create_request := model.CreateMapfixRequest{
OperationID: OperationID,
ModelID: ModelID,
TargetAssetID: TargetAssetID,
Description: Description,
}
j, err := json.Marshal(create_request)
if err != nil {
return err
}
_, err = svc.nats.Publish("maptest.mapfixes.create", []byte(j))
if err != nil {
return err
}
return nil
}
func (svc *Service) NatsCheckMapfix(
MapfixID int64,
ModelID uint64,
SkipChecks bool,
) error {
validate_request := model.CheckMapfixRequest{
MapfixID: MapfixID,
ModelID: ModelID,
SkipChecks: SkipChecks,
}
j, err := json.Marshal(validate_request)
if err != nil {
return err
}
_, err = svc.nats.Publish("maptest.mapfixes.check", []byte(j))
if err != nil {
return err
}
return nil
}
func (svc *Service) NatsUploadMapfix(
MapfixID int64,
ModelID uint64,
ModelVersion uint64,
TargetAssetID uint64,
) error {
upload_fix_request := model.UploadMapfixRequest{
MapfixID: MapfixID,
ModelID: ModelID,
ModelVersion: ModelVersion,
TargetAssetID: TargetAssetID,
}
j, err := json.Marshal(upload_fix_request)
if err != nil {
return err
}
_, err = svc.nats.Publish("maptest.mapfixes.upload", []byte(j))
if err != nil {
return err
}
return nil
}
func (svc *Service) NatsValidateMapfix(
MapfixID int64,
ModelID uint64,
ModelVersion uint64,
ValidatedAssetID uint64,
) error {
validate_request := model.ValidateMapfixRequest{
MapfixID: MapfixID,
ModelID: ModelID,
ModelVersion: ModelVersion,
ValidatedModelID: nil,
}
// sentinel values because we're not using rust
if ValidatedAssetID != 0 {
validate_request.ValidatedModelID = &ValidatedAssetID
}
j, err := json.Marshal(validate_request)
if err != nil {
return err
}
_, err = svc.nats.Publish("maptest.mapfixes.validate", []byte(j))
if err != nil {
return err
}
return nil
}

120
pkg/service_inner/nats_submission.go Normal file
View File

@@ -0,0 +1,120 @@
package service_inner
import (
"encoding/json"
"git.itzana.me/strafesnet/maps-service/pkg/model"
)
func (svc *Service) NatsCreateSubmission(
OperationID int32,
ModelID uint64,
DisplayName string,
Creator string,
GameID uint32,
Status uint32,
Roles uint32,
) error {
create_request := model.CreateSubmissionRequest{
OperationID: OperationID,
ModelID: ModelID,
DisplayName: DisplayName,
Creator: Creator,
GameID: GameID,
Status: Status,
Roles: Roles,
}
j, err := json.Marshal(create_request)
if err != nil {
return err
}
_, err = svc.nats.Publish("maptest.submissions.create", []byte(j))
if err != nil {
return err
}
return nil
}
func (svc *Service) NatsCheckSubmission(
SubmissionID int64,
ModelID uint64,
SkipChecks bool,
) error {
validate_request := model.CheckSubmissionRequest{
SubmissionID: SubmissionID,
ModelID: ModelID,
SkipChecks: SkipChecks,
}
j, err := json.Marshal(validate_request)
if err != nil {
return err
}
_, err = svc.nats.Publish("maptest.submissions.check", []byte(j))
if err != nil {
return err
}
return nil
}
func (svc *Service) NatsUploadSubmission(
SubmissionID int64,
ModelID uint64,
ModelVersion uint64,
ModelName string,
) error {
upload_new_request := model.UploadSubmissionRequest{
SubmissionID: SubmissionID,
ModelID: ModelID,
ModelVersion: ModelVersion,
ModelName: ModelName,
}
j, err := json.Marshal(upload_new_request)
if err != nil {
return err
}
_, err = svc.nats.Publish("maptest.submissions.upload", []byte(j))
if err != nil {
return err
}
return nil
}
func (svc *Service) NatsValidateSubmission(
SubmissionID int64,
ModelID uint64,
ModelVersion uint64,
ValidatedModelID uint64,
) error {
validate_request := model.ValidateSubmissionRequest{
SubmissionID: SubmissionID,
ModelID: ModelID,
ModelVersion: ModelVersion,
ValidatedModelID: nil,
}
// sentinel values because we're not using rust
if ValidatedModelID != 0 {
validate_request.ValidatedModelID = &ValidatedModelID
}
j, err := json.Marshal(validate_request)
if err != nil {
return err
}
_, err = svc.nats.Publish("maptest.submissions.validate", []byte(j))
if err != nil {
return err
}
return nil
}

55
pkg/service_inner/operations.go Normal file
View File

@@ -0,0 +1,55 @@
package service_inner
import (
"context"
"time"
"git.itzana.me/strafesnet/maps-service/pkg/datastore"
"git.itzana.me/strafesnet/maps-service/pkg/model"
)
type OperationFailParams datastore.OptionalMap
func NewOperationFailParams(
status_message string,
) OperationFailParams {
filter := datastore.Optional()
filter.Add("status_id", model.OperationStatusFailed)
filter.Add("status_message", status_message)
return OperationFailParams(filter)
}
type OperationCompleteParams datastore.OptionalMap
func NewOperationCompleteParams(
path string,
) OperationCompleteParams {
filter := datastore.Optional()
filter.Add("status_id", model.OperationStatusCompleted)
filter.Add("path", path)
return OperationCompleteParams(filter)
}
func (svc *Service) CreateOperation(ctx context.Context, operation model.Operation) (model.Operation, error) {
return svc.db.Operations().Create(ctx, operation)
}
func (svc *Service) CountOperationsSince(ctx context.Context, owner int64, since time.Time) (int64, error) {
return svc.db.Operations().CountSince(ctx, owner, since)
}
func (svc *Service) DeleteOperation(ctx context.Context, id int32) error {
return svc.db.Operations().Delete(ctx, id)
}
func (svc *Service) GetOperation(ctx context.Context, id int32) (model.Operation, error) {
return svc.db.Operations().Get(ctx, id)
}
func (svc *Service) FailOperation(ctx context.Context, id int32, params OperationFailParams) error {
return svc.db.Operations().Update(ctx, id, datastore.OptionalMap(params))
}
func (svc *Service) CompleteOperation(ctx context.Context, id int32, params OperationCompleteParams) error {
return svc.db.Operations().Update(ctx, id, datastore.OptionalMap(params))
}

45
pkg/service_inner/script_policy.go Normal file
View File

@@ -0,0 +1,45 @@
package service_inner
import (
"context"
"git.itzana.me/strafesnet/maps-service/pkg/datastore"
"git.itzana.me/strafesnet/maps-service/pkg/model"
)
type ScriptPolicyFilter datastore.OptionalMap
func NewScriptPolicyFilter() ScriptPolicyFilter {
filter := datastore.Optional()
return ScriptPolicyFilter(filter)
}
func (filter ScriptPolicyFilter) SetFromScriptHash(from_script_hash int64) {
// Finally, type safety!
datastore.OptionalMap(filter).Add("from_script_hash", from_script_hash)
}
func (filter ScriptPolicyFilter) SetToScriptID(to_script_id int64) {
datastore.OptionalMap(filter).Add("to_script_id", to_script_id)
}
func (filter ScriptPolicyFilter) SetPolicy(policy int32) {
datastore.OptionalMap(filter).Add("policy", policy)
}
func (svc *Service) CreateScriptPolicy(ctx context.Context, script model.ScriptPolicy) (model.ScriptPolicy, error) {
return svc.db.ScriptPolicy().Create(ctx, script)
}
func (svc *Service) ListScriptPolicies(ctx context.Context, filter ScriptPolicyFilter, page model.Page) ([]model.ScriptPolicy, error) {
return svc.db.ScriptPolicy().List(ctx, datastore.OptionalMap(filter), page)
}
func (svc *Service) DeleteScriptPolicy(ctx context.Context, id int64) error {
return svc.db.ScriptPolicy().Delete(ctx, id)
}
func (svc *Service) GetScriptPolicy(ctx context.Context, id int64) (model.ScriptPolicy, error) {
return svc.db.ScriptPolicy().Get(ctx, id)
}
func (svc *Service) UpdateScriptPolicy(ctx context.Context, id int64, pmap ScriptPolicyFilter) error {
return svc.db.ScriptPolicy().Update(ctx, id, datastore.OptionalMap(pmap))
}

50
pkg/service_inner/scripts.go Normal file
View File

@@ -0,0 +1,50 @@
package service_inner
import (
"context"
"git.itzana.me/strafesnet/maps-service/pkg/datastore"
"git.itzana.me/strafesnet/maps-service/pkg/model"
)
type ScriptFilter datastore.OptionalMap
func NewScriptFilter() ScriptFilter {
filter := datastore.Optional()
return ScriptFilter(filter)
}
func (filter ScriptFilter) SetName(name string) {
datastore.OptionalMap(filter).Add("name", name)
}
func (filter ScriptFilter) SetSource(source string) {
datastore.OptionalMap(filter).Add("source", source)
}
func (filter ScriptFilter) SetHash(hash int64) {
datastore.OptionalMap(filter).Add("hash", hash)
}
func (filter ScriptFilter) SetResourceType(resource_type int32) {
datastore.OptionalMap(filter).Add("resource_type", resource_type)
}
func (filter ScriptFilter) SetResourceID(resource_id int64) {
datastore.OptionalMap(filter).Add("resource_id", resource_id)
}
func (svc *Service) CreateScript(ctx context.Context, script model.Script) (model.Script, error) {
return svc.db.Scripts().Create(ctx, script)
}
func (svc *Service) ListScripts(ctx context.Context, filter ScriptFilter, page model.Page) ([]model.Script, error) {
return svc.db.Scripts().List(ctx, datastore.OptionalMap(filter), page)
}
func (svc *Service) DeleteScript(ctx context.Context, id int64) error {
return svc.db.Scripts().Delete(ctx, id)
}
func (svc *Service) GetScript(ctx context.Context, id int64) (model.Script, error) {
return svc.db.Scripts().Get(ctx, id)
}
func (svc *Service) UpdateScript(ctx context.Context, id int64, pmap ScriptFilter) error {
return svc.db.Scripts().Update(ctx, id, datastore.OptionalMap(pmap))
}

29
pkg/service_inner/service.go Normal file
View File

@@ -0,0 +1,29 @@
package service_inner
import (
"git.itzana.me/strafesnet/go-grpc/maps"
"git.itzana.me/strafesnet/go-grpc/users"
"git.itzana.me/strafesnet/maps-service/pkg/datastore"
"github.com/nats-io/nats.go"
)
type Service struct {
db datastore.Datastore
nats nats.JetStreamContext
maps maps.MapsServiceClient
users users.UsersServiceClient
}
func NewService(
db datastore.Datastore,
nats nats.JetStreamContext,
maps maps.MapsServiceClient,
users users.UsersServiceClient,
) Service {
return Service{
db: db,
nats: nats,
maps: maps,
users: users,
}
}

120
pkg/service_inner/submissions.go Normal file
View File

@@ -0,0 +1,120 @@
package service_inner
import (
"context"
"git.itzana.me/strafesnet/maps-service/pkg/datastore"
"git.itzana.me/strafesnet/maps-service/pkg/model"
)
type SubmissionUpdate datastore.OptionalMap
func NewSubmissionUpdate() SubmissionUpdate {
update := datastore.Optional()
return SubmissionUpdate(update)
}
func (update SubmissionUpdate) SetDisplayName(display_name string) {
datastore.OptionalMap(update).Add("display_name", display_name)
}
func (update SubmissionUpdate) SetCreator(creator string) {
datastore.OptionalMap(update).Add("creator", creator)
}
func (update SubmissionUpdate) SetGameID(game_id uint32) {
datastore.OptionalMap(update).Add("game_id", game_id)
}
func (update SubmissionUpdate) SetSubmitter(submitter uint64) {
datastore.OptionalMap(update).Add("submitter", submitter)
}
func (update SubmissionUpdate) SetAssetID(asset_id uint64) {
datastore.OptionalMap(update).Add("asset_id", asset_id)
}
func (update SubmissionUpdate) SetAssetVersion(asset_version uint64) {
datastore.OptionalMap(update).Add("asset_version", asset_version)
}
func (update SubmissionUpdate) SetValidatedAssetID(validated_asset_id uint64) {
datastore.OptionalMap(update).Add("validated_asset_id", validated_asset_id)
}
func (update SubmissionUpdate) SetValidatedAssetVersion(validated_asset_version uint64) {
datastore.OptionalMap(update).Add("validated_asset_version", validated_asset_version)
}
func (update SubmissionUpdate) SetCompleted(completed bool) {
datastore.OptionalMap(update).Add("completed", completed)
}
func (update SubmissionUpdate) SetUploadedAssetID(uploaded_asset_id uint64) {
datastore.OptionalMap(update).Add("uploaded_asset_id", uploaded_asset_id)
}
func (update SubmissionUpdate) SetStatusID(status_id model.SubmissionStatus) {
datastore.OptionalMap(update).Add("status_id", status_id)
}
func (update SubmissionUpdate) SetDescription(description string) {
datastore.OptionalMap(update).Add("description", description)
}
type SubmissionFilter datastore.OptionalMap
func NewSubmissionFilter(
) SubmissionFilter {
filter := datastore.Optional()
return SubmissionFilter(filter)
}
func (update SubmissionFilter) SetDisplayName(display_name string) {
datastore.OptionalMap(update).Add("display_name", display_name)
}
func (update SubmissionFilter) SetCreator(creator string) {
datastore.OptionalMap(update).Add("creator", creator)
}
func (update SubmissionFilter) SetGameID(game_id uint32) {
datastore.OptionalMap(update).Add("game_id", game_id)
}
func (update SubmissionFilter) SetSubmitter(submitter uint64) {
datastore.OptionalMap(update).Add("submitter", submitter)
}
func (update SubmissionFilter) SetAssetID(asset_id uint64) {
datastore.OptionalMap(update).Add("asset_id", asset_id)
}
func (update SubmissionFilter) SetAssetVersion(asset_version uint64) {
datastore.OptionalMap(update).Add("asset_version", asset_version)
}
func (update SubmissionFilter) SetUploadedAssetID(uploaded_asset_id uint64) {
datastore.OptionalMap(update).Add("uploaded_asset_id", uploaded_asset_id)
}
func (update SubmissionFilter) SetStatuses(statuses []model.SubmissionStatus) {
datastore.OptionalMap(update).Add("status_id", statuses)
}
func (svc *Service) CreateSubmission(ctx context.Context, script model.Submission) (model.Submission, error) {
return svc.db.Submissions().Create(ctx, script)
}
func (svc *Service) ListSubmissions(ctx context.Context, filter SubmissionFilter, page model.Page, sort datastore.ListSort) ([]model.Submission, error) {
return svc.db.Submissions().List(ctx, datastore.OptionalMap(filter), page, sort)
}
func (svc *Service) ListSubmissionsWithTotal(ctx context.Context, filter SubmissionFilter, page model.Page, sort datastore.ListSort) (int64, []model.Submission, error) {
return svc.db.Submissions().ListWithTotal(ctx, datastore.OptionalMap(filter), page, sort)
}
func (svc *Service) DeleteSubmission(ctx context.Context, id int64) error {
return svc.db.Submissions().Delete(ctx, id)
}
func (svc *Service) GetSubmission(ctx context.Context, id int64) (model.Submission, error) {
return svc.db.Submissions().Get(ctx, id)
}
func (svc *Service) GetSubmissionList(ctx context.Context, ids []int64) ([]model.Submission, error) {
return svc.db.Submissions().GetList(ctx, ids)
}
func (svc *Service) UpdateSubmission(ctx context.Context, id int64, pmap SubmissionUpdate) error {
return svc.db.Submissions().Update(ctx, id, datastore.OptionalMap(pmap))
}
func (svc *Service) UpdateSubmissionIfStatus(ctx context.Context, id int64, statuses []model.SubmissionStatus, pmap SubmissionUpdate) error {
return svc.db.Submissions().IfStatusThenUpdate(ctx, id, statuses, datastore.OptionalMap(pmap))
}
func (svc *Service) UpdateAndGetSubmissionIfStatus(ctx context.Context, id int64, statuses []model.SubmissionStatus, pmap SubmissionUpdate) (model.Submission, error) {
return svc.db.Submissions().IfStatusThenUpdateAndGet(ctx, id, statuses, datastore.OptionalMap(pmap))
}

92
pkg/service_internal/audit_events.go
View File

@@ -1,92 +0,0 @@
package service_internal
import (
"context"
"encoding/json"
"git.itzana.me/strafesnet/maps-service/pkg/model"
)
func (svc *Service) CreateAuditEventAction(ctx context.Context, userId uint64, resource model.Resource, event_data model.AuditEventDataAction) error {
EventData, err := json.Marshal(event_data)
if err != nil {
return err
}
_, err = svc.DB.AuditEvents().Create(ctx, model.AuditEvent{
ID: 0,
User: userId,
ResourceType: resource.Type,
ResourceID: resource.ID,
EventType: model.AuditEventTypeAction,
EventData: EventData,
})
if err != nil {
return err
}
return nil
}
func (svc *Service) CreateAuditEventChangeValidatedModel(ctx context.Context, userId uint64, resource model.Resource, event_data model.AuditEventDataChangeValidatedModel) error {
EventData, err := json.Marshal(event_data)
if err != nil {
return err
}
_, err = svc.DB.AuditEvents().Create(ctx, model.AuditEvent{
ID: 0,
User: userId,
ResourceType: resource.Type,
ResourceID: resource.ID,
EventType: model.AuditEventTypeChangeValidatedModel,
EventData: EventData,
})
if err != nil {
return err
}
return nil
}
func (svc *Service) CreateAuditEventError(ctx context.Context, userId uint64, resource model.Resource, event_data model.AuditEventDataError) error {
EventData, err := json.Marshal(event_data)
if err != nil {
return err
}
_, err = svc.DB.AuditEvents().Create(ctx, model.AuditEvent{
ID: 0,
User: userId,
ResourceType: resource.Type,
ResourceID: resource.ID,
EventType: model.AuditEventTypeError,
EventData: EventData,
})
if err != nil {
return err
}
return nil
}
func (svc *Service) CreateAuditEventCheckList(ctx context.Context, userId uint64, resource model.Resource, event_data model.AuditEventDataCheckList) error {
EventData, err := json.Marshal(event_data)
if err != nil {
return err
}
_, err = svc.DB.AuditEvents().Create(ctx, model.AuditEvent{
ID: 0,
User: userId,
ResourceType: resource.Type,
ResourceID: resource.ID,
EventType: model.AuditEventTypeCheckList,
EventData: EventData,
})
if err != nil {
return err
}
return nil
}

84
pkg/service_internal/mapfixes.go
View File

@@ -8,6 +8,7 @@ import (
"git.itzana.me/strafesnet/maps-service/pkg/datastore"
internal "git.itzana.me/strafesnet/maps-service/pkg/internal"
"git.itzana.me/strafesnet/maps-service/pkg/model"
"git.itzana.me/strafesnet/maps-service/pkg/service_inner"
)
var(
@@ -38,12 +39,12 @@ func (svc *Service) UpdateMapfixValidatedModel(ctx context.Context, params inter
ValidatedModelVersion := uint64(params.ValidatedModelVersion)
// check if Status is ChangesRequested|Submitted|UnderConstruction
pmap := datastore.Optional()
pmap.Add("validated_asset_id", ValidatedModelID)
pmap.Add("validated_asset_version", ValidatedModelVersion)
update := service_inner.NewMapfixUpdate()
update.SetValidatedAssetID(ValidatedModelID)
update.SetValidatedAssetVersion(ValidatedModelVersion)
// DO NOT reset completed when validated model is updated
// pmap.Add("completed", false)
err := svc.DB.Mapfixes().IfStatusThenUpdate(ctx, params.MapfixID, []model.MapfixStatus{model.MapfixStatusValidating}, pmap)
// update.Add("completed", false)
err := svc.inner.UpdateMapfixIfStatus(ctx, params.MapfixID, []model.MapfixStatus{model.MapfixStatusValidating}, update)
if err != nil {
return err
}
@@ -53,7 +54,7 @@ func (svc *Service) UpdateMapfixValidatedModel(ctx context.Context, params inter
ValidatedModelVersion: ValidatedModelVersion,
}
return svc.CreateAuditEventChangeValidatedModel(
return svc.inner.CreateAuditEventChangeValidatedModel(
ctx,
ValidtorUserID,
model.Resource{
@@ -72,13 +73,14 @@ func (svc *Service) UpdateMapfixValidatedModel(ctx context.Context, params inter
func (svc *Service) ActionMapfixSubmitted(ctx context.Context, params internal.ActionMapfixSubmittedParams) error {
// transaction
target_status := model.MapfixStatusSubmitted
smap := datastore.Optional()
smap.Add("status_id", target_status)
smap.Add("asset_version", params.ModelVersion)
smap.Add("display_name", params.DisplayName)
smap.Add("creator", params.Creator)
smap.Add("game_id", params.GameID)
err := svc.DB.Mapfixes().IfStatusThenUpdate(ctx, params.MapfixID, []model.MapfixStatus{model.MapfixStatusSubmitting}, smap)
update := service_inner.NewMapfixUpdate()
update.SetStatusID(target_status)
update.SetAssetVersion(uint64(params.ModelVersion))
update.SetDisplayName(params.DisplayName)
update.SetCreator(params.Creator)
update.SetGameID(uint32(params.GameID))
allow_statuses := []model.MapfixStatus{model.MapfixStatusSubmitting}
err := svc.inner.UpdateMapfixIfStatus(ctx, params.MapfixID, allow_statuses, update)
if err != nil {
return err
}
@@ -87,7 +89,7 @@ func (svc *Service) ActionMapfixSubmitted(ctx context.Context, params internal.A
TargetStatus: uint32(target_status),
}
return svc.CreateAuditEventAction(
return svc.inner.CreateAuditEventAction(
ctx,
ValidtorUserID,
model.Resource{
@@ -106,9 +108,9 @@ func (svc *Service) ActionMapfixSubmitted(ctx context.Context, params internal.A
func (svc *Service) ActionMapfixRequestChanges(ctx context.Context, params internal.ActionMapfixRequestChangesParams) error {
// transaction
target_status := model.MapfixStatusChangesRequested
smap := datastore.Optional()
smap.Add("status_id", target_status)
err := svc.DB.Mapfixes().IfStatusThenUpdate(ctx, params.MapfixID, []model.MapfixStatus{model.MapfixStatusSubmitting}, smap)
update := service_inner.NewMapfixUpdate()
update.SetStatusID(target_status)
err := svc.inner.UpdateMapfixIfStatus(ctx, params.MapfixID, []model.MapfixStatus{model.MapfixStatusSubmitting}, update)
if err != nil {
return err
}
@@ -117,7 +119,7 @@ func (svc *Service) ActionMapfixRequestChanges(ctx context.Context, params inter
TargetStatus: uint32(target_status),
}
return svc.CreateAuditEventAction(
return svc.inner.CreateAuditEventAction(
ctx,
ValidtorUserID,
model.Resource{
@@ -135,9 +137,9 @@ func (svc *Service) ActionMapfixRequestChanges(ctx context.Context, params inter
// POST /mapfixes/{MapfixID}/status/validator-validated
func (svc *Service) ActionMapfixValidated(ctx context.Context, params internal.ActionMapfixValidatedParams) error {
// transaction
smap := datastore.Optional()
smap.Add("status_id", model.MapfixStatusValidated)
return svc.DB.Mapfixes().IfStatusThenUpdate(ctx, params.MapfixID, []model.MapfixStatus{model.MapfixStatusValidating}, smap)
update := service_inner.NewMapfixUpdate()
update.SetStatusID(model.MapfixStatusValidated)
return svc.inner.UpdateMapfixIfStatus(ctx, params.MapfixID, []model.MapfixStatus{model.MapfixStatusValidating}, update)
}
// ActionMapfixAccepted implements actionMapfixAccepted operation.
@@ -148,9 +150,9 @@ func (svc *Service) ActionMapfixValidated(ctx context.Context, params internal.A
func (svc *Service) ActionMapfixAccepted(ctx context.Context, params internal.ActionMapfixAcceptedParams) error {
// transaction
target_status := model.MapfixStatusAcceptedUnvalidated
smap := datastore.Optional()
smap.Add("status_id", target_status)
err := svc.DB.Mapfixes().IfStatusThenUpdate(ctx, params.MapfixID, []model.MapfixStatus{model.MapfixStatusValidating}, smap)
update := service_inner.NewMapfixUpdate()
update.SetStatusID(target_status)
err := svc.inner.UpdateMapfixIfStatus(ctx, params.MapfixID, []model.MapfixStatus{model.MapfixStatusValidating}, update)
if err != nil {
return err
}
@@ -160,7 +162,7 @@ func (svc *Service) ActionMapfixAccepted(ctx context.Context, params internal.Ac
TargetStatus: uint32(target_status),
}
return svc.CreateAuditEventAction(
return svc.inner.CreateAuditEventAction(
ctx,
ValidtorUserID,
model.Resource{
@@ -179,9 +181,9 @@ func (svc *Service) ActionMapfixAccepted(ctx context.Context, params internal.Ac
func (svc *Service) ActionMapfixUploaded(ctx context.Context, params internal.ActionMapfixUploadedParams) error {
// transaction
target_status := model.MapfixStatusUploaded
smap := datastore.Optional()
smap.Add("status_id", target_status)
err := svc.DB.Mapfixes().IfStatusThenUpdate(ctx, params.MapfixID, []model.MapfixStatus{model.MapfixStatusUploading}, smap)
update := service_inner.NewMapfixUpdate()
update.SetStatusID(target_status)
err := svc.inner.UpdateMapfixIfStatus(ctx, params.MapfixID, []model.MapfixStatus{model.MapfixStatusUploading}, update)
if err != nil {
return err
}
@@ -190,7 +192,7 @@ func (svc *Service) ActionMapfixUploaded(ctx context.Context, params internal.Ac
TargetStatus: uint32(target_status),
}
return svc.CreateAuditEventAction(
return svc.inner.CreateAuditEventAction(
ctx,
ValidtorUserID,
model.Resource{
@@ -211,7 +213,7 @@ func (svc *Service) CreateMapfixAuditError(ctx context.Context, params internal.
Error: params.ErrorMessage,
}
return svc.CreateAuditEventError(
return svc.inner.CreateAuditEventError(
ctx,
ValidtorUserID,
model.Resource{
@@ -241,7 +243,7 @@ func (svc *Service) CreateMapfixAuditCheckList(ctx context.Context, check_list i
CheckList: check_list2,
}
return svc.CreateAuditEventCheckList(
return svc.inner.CreateAuditEventCheckList(
ctx,
ValidtorUserID,
model.Resource{
@@ -270,11 +272,11 @@ func (svc *Service) CreateMapfix(ctx context.Context, request *internal.MapfixCr
// Check if an active mapfix with the same asset id exists
{
filter := datastore.Optional()
filter.Add("asset_id", request.AssetID)
filter.Add("asset_version", request.AssetVersion)
filter.Add("status_id", ActiveMapfixStatuses)
active_mapfixes, err := svc.DB.Mapfixes().List(ctx, filter, model.Page{
filter := service_inner.NewMapfixFilter()
filter.SetAssetID(AssetID)
filter.SetAssetVersion(AssetVersion)
filter.SetStatuses(ActiveMapfixStatuses)
active_mapfixes, err := svc.inner.ListMapfixes(ctx, filter, model.Page{
Number: 1,
Size: 1,
},datastore.ListSortDisabled)
@@ -286,7 +288,7 @@ func (svc *Service) CreateMapfix(ctx context.Context, request *internal.MapfixCr
}
}
operation, err := svc.DB.Operations().Get(ctx, request.OperationID)
operation, err := svc.inner.GetOperation(ctx, request.OperationID)
if err != nil {
return nil, err
}
@@ -297,7 +299,7 @@ func (svc *Service) CreateMapfix(ctx context.Context, request *internal.MapfixCr
return nil, ErrNotAssetOwner
}
mapfix, err := svc.DB.Mapfixes().Create(ctx, model.Mapfix{
mapfix, err := svc.inner.CreateMapfix(ctx, model.Mapfix{
ID: 0,
DisplayName: request.DisplayName,
Creator: request.Creator,
@@ -315,10 +317,8 @@ func (svc *Service) CreateMapfix(ctx context.Context, request *internal.MapfixCr
}
// mark the operation as completed and provide the path
pmap := datastore.Optional()
pmap.Add("status_id", model.OperationStatusCompleted)
pmap.Add("path", fmt.Sprintf("/mapfixes/%d", mapfix.ID))
err = svc.DB.Operations().Update(ctx, request.OperationID, pmap)
params := service_inner.NewOperationCompleteParams(fmt.Sprintf("/mapfixes/%d", mapfix.ID))
err = svc.inner.CompleteOperation(ctx, request.OperationID, params)
if err != nil {
return nil, err
}

11
pkg/service_internal/operations.go
View File

@@ -3,9 +3,8 @@ package service_internal
import (
"context"
"git.itzana.me/strafesnet/maps-service/pkg/datastore"
internal "git.itzana.me/strafesnet/maps-service/pkg/internal"
"git.itzana.me/strafesnet/maps-service/pkg/model"
"git.itzana.me/strafesnet/maps-service/pkg/service_inner"
)
// ActionOperationFailed implements actionOperationFailed operation.
@@ -14,8 +13,8 @@ import (
//
// POST /operations/{OperationID}/status/operation-failed
func (svc *Service) ActionOperationFailed(ctx context.Context, params internal.ActionOperationFailedParams) (error) {
pmap := datastore.Optional()
pmap.Add("status_id", model.OperationStatusFailed)
pmap.Add("status_message", params.StatusMessage)
return svc.DB.Operations().Update(ctx, params.OperationID, pmap)
fail_params := service_inner.NewOperationFailParams(
params.StatusMessage,
)
return svc.inner.FailOperation(ctx, params.OperationID, fail_params)
}

24
pkg/service_internal/script_policy.go
View File

@@ -3,9 +3,9 @@ package service_internal
import (
"context"
"git.itzana.me/strafesnet/maps-service/pkg/datastore"
api "git.itzana.me/strafesnet/maps-service/pkg/internal"
"git.itzana.me/strafesnet/maps-service/pkg/model"
"git.itzana.me/strafesnet/maps-service/pkg/service_inner"
)
// CreateScriptPolicy implements createScriptPolicy operation.
@@ -14,14 +14,14 @@ import (
//
// POST /script-policy
func (svc *Service) CreateScriptPolicy(ctx context.Context, req *api.ScriptPolicyCreate) (*api.ScriptPolicyID, error) {
from_script, err := svc.DB.Scripts().Get(ctx, req.FromScriptID)
from_script, err := svc.inner.GetScript(ctx, req.FromScriptID)
if err != nil {
return nil, err
}
// the existence of ToScriptID does not need to be validated because it's checked by a foreign key constraint.
script, err := svc.DB.ScriptPolicy().Create(ctx, model.ScriptPolicy{
script, err := svc.inner.CreateScriptPolicy(ctx, model.ScriptPolicy{
ID: 0,
FromScriptHash: from_script.Hash,
ToScriptID: req.ToScriptID,
@@ -42,23 +42,23 @@ func (svc *Service) CreateScriptPolicy(ctx context.Context, req *api.ScriptPolic
//
// GET /script-policy
func (svc *Service) ListScriptPolicy(ctx context.Context, params api.ListScriptPolicyParams) ([]api.ScriptPolicy, error) {
filter := datastore.Optional()
filter := service_inner.NewScriptPolicyFilter()
if params.FromScriptHash.IsSet(){
hash, err := model.HashParse(params.FromScriptHash.Value)
if hash_hex, ok := params.FromScriptHash.Get(); ok{
hash_parsed, err := model.HashParse(hash_hex)
if err != nil {
return nil, err
}
filter.Add("from_script_hash", int64(hash)) // No type safety!
filter.SetFromScriptHash(int64(hash_parsed))
}
if params.ToScriptID.IsSet(){
filter.Add("to_script_id", params.ToScriptID.Value)
if to_script_id, to_script_id_ok := params.ToScriptID.Get(); to_script_id_ok{
filter.SetToScriptID(to_script_id)
}
if params.Policy.IsSet(){
filter.Add("policy", params.Policy.Value)
if policy, policy_ok := params.Policy.Get(); policy_ok{
filter.SetPolicy(policy)
}
items, err := svc.DB.ScriptPolicy().List(ctx, filter, model.Page{
items, err := svc.inner.ListScriptPolicies(ctx, filter, model.Page{
Number: params.Page,
Size: params.Limit,
})

33
pkg/service_internal/scripts.go
View File

@@ -3,9 +3,9 @@ package service_internal
import (
"context"
"git.itzana.me/strafesnet/maps-service/pkg/datastore"
api "git.itzana.me/strafesnet/maps-service/pkg/internal"
"git.itzana.me/strafesnet/maps-service/pkg/model"
"git.itzana.me/strafesnet/maps-service/pkg/service_inner"
)
// CreateScript implements createScript operation.
@@ -14,7 +14,7 @@ import (
//
// POST /scripts
func (svc *Service) CreateScript(ctx context.Context, req *api.ScriptCreate) (*api.ScriptID, error) {
script, err := svc.DB.Scripts().Create(ctx, model.Script{
script, err := svc.inner.CreateScript(ctx, model.Script{
ID: 0,
Name: req.Name,
Hash: int64(model.HashSource(req.Source)),
@@ -37,29 +37,28 @@ func (svc *Service) CreateScript(ctx context.Context, req *api.ScriptCreate) (*a
//
// GET /scripts
func (svc *Service) ListScripts(ctx context.Context, params api.ListScriptsParams) ([]api.Script, error) {
filter := datastore.Optional()
if params.Hash.IsSet(){
hash, err := model.HashParse(params.Hash.Value)
filter := service_inner.NewScriptFilter()
if hash_hex, ok := params.Hash.Get(); ok{
hash_parsed, err := model.HashParse(hash_hex)
if err != nil {
return nil, err
}
filter.Add("hash", int64(hash)) // No type safety!
filter.SetHash(int64(hash_parsed))
}
if params.Name.IsSet(){
filter.Add("name", params.Name.Value)
if name, name_ok := params.Name.Get(); name_ok{
filter.SetName(name)
}
if params.Source.IsSet(){
filter.Add("source", params.Source.Value)
if source, source_ok := params.Source.Get(); source_ok{
filter.SetSource(source)
}
if params.ResourceType.IsSet(){
filter.Add("resource_type", params.ResourceType.Value)
if resource_type, resource_type_ok := params.ResourceType.Get(); resource_type_ok{
filter.SetResourceType(resource_type)
}
if params.ResourceID.IsSet(){
filter.Add("resource_id", params.ResourceID.Value)
if resource_id, resource_id_ok := params.ResourceID.Get(); resource_id_ok{
filter.SetResourceID(resource_id)
}
items, err := svc.DB.Scripts().List(ctx, filter, model.Page{
items, err := svc.inner.ListScripts(ctx, filter, model.Page{
Number: params.Page,
Size: params.Limit,
})
@@ -88,7 +87,7 @@ func (svc *Service) ListScripts(ctx context.Context, params api.ListScriptsParam
//
// GET /scripts/{ScriptID}
func (svc *Service) GetScript(ctx context.Context, params api.GetScriptParams) (*api.Script, error) {
script, err := svc.DB.Scripts().Get(ctx, params.ScriptID)
script, err := svc.inner.GetScript(ctx, params.ScriptID)
if err != nil {
return nil, err
}

13
pkg/service_internal/service_internal.go
View File

@@ -7,7 +7,7 @@ import (
"git.itzana.me/strafesnet/maps-service/pkg/datastore"
internal "git.itzana.me/strafesnet/maps-service/pkg/internal"
"github.com/nats-io/nats.go"
"git.itzana.me/strafesnet/maps-service/pkg/service_inner"
)
const (
@@ -19,8 +19,15 @@ var (
)
type Service struct {
DB datastore.Datastore
Nats nats.JetStreamContext
inner *service_inner.Service
}
func NewService(
inner *service_inner.Service,
) Service {
return Service{
inner: inner,
}
}
// yay duplicate code

93
pkg/service_internal/submissions.go
View File

@@ -9,6 +9,7 @@ import (
internal "git.itzana.me/strafesnet/maps-service/pkg/internal"
"git.itzana.me/strafesnet/maps-service/pkg/model"
"git.itzana.me/strafesnet/maps-service/pkg/service"
"git.itzana.me/strafesnet/maps-service/pkg/service_inner"
)
var(
@@ -38,12 +39,13 @@ func (svc *Service) UpdateSubmissionValidatedModel(ctx context.Context, params i
ValidatedModelVersion := uint64(params.ValidatedModelVersion)
// check if Status is ChangesRequested|Submitted|UnderConstruction
pmap := datastore.Optional()
pmap.Add("validated_asset_id", ValidatedModelID)
pmap.Add("validated_asset_version", ValidatedModelVersion)
update := service_inner.NewSubmissionUpdate()
update.SetValidatedAssetID(ValidatedModelID)
update.SetValidatedAssetVersion(ValidatedModelVersion)
// DO NOT reset completed when validated model is updated
// pmap.Add("completed", false)
err := svc.DB.Submissions().IfStatusThenUpdate(ctx, params.SubmissionID, []model.SubmissionStatus{model.SubmissionStatusValidating}, pmap)
// update.Add("completed", false)
allowed_statuses := []model.SubmissionStatus{model.SubmissionStatusValidating}
err := svc.inner.UpdateSubmissionIfStatus(ctx, params.SubmissionID, allowed_statuses, update)
if err != nil {
return err
}
@@ -53,7 +55,7 @@ func (svc *Service) UpdateSubmissionValidatedModel(ctx context.Context, params i
ValidatedModelVersion: ValidatedModelVersion,
}
return svc.CreateAuditEventChangeValidatedModel(
return svc.inner.CreateAuditEventChangeValidatedModel(
ctx,
ValidtorUserID,
model.Resource{
@@ -72,13 +74,14 @@ func (svc *Service) UpdateSubmissionValidatedModel(ctx context.Context, params i
func (svc *Service) ActionSubmissionSubmitted(ctx context.Context, params internal.ActionSubmissionSubmittedParams) error {
// transaction
target_status := model.SubmissionStatusSubmitted
smap := datastore.Optional()
smap.Add("status_id", target_status)
smap.Add("asset_version", params.ModelVersion)
smap.Add("display_name", params.DisplayName)
smap.Add("creator", params.Creator)
smap.Add("game_id", params.GameID)
err := svc.DB.Submissions().IfStatusThenUpdate(ctx, params.SubmissionID, []model.SubmissionStatus{model.SubmissionStatusSubmitting}, smap)
update := service_inner.NewSubmissionUpdate()
update.SetStatusID(target_status)
update.SetAssetVersion(uint64(params.ModelVersion))
update.SetDisplayName(params.DisplayName)
update.SetCreator(params.Creator)
update.SetGameID(uint32(params.GameID))
allowed_statuses := []model.SubmissionStatus{model.SubmissionStatusSubmitting}
err := svc.inner.UpdateSubmissionIfStatus(ctx, params.SubmissionID, allowed_statuses, update)
if err != nil {
return err
}
@@ -87,7 +90,7 @@ func (svc *Service) ActionSubmissionSubmitted(ctx context.Context, params intern
TargetStatus: uint32(target_status),
}
return svc.CreateAuditEventAction(
return svc.inner.CreateAuditEventAction(
ctx,
ValidtorUserID,
model.Resource{
@@ -106,9 +109,10 @@ func (svc *Service) ActionSubmissionSubmitted(ctx context.Context, params intern
func (svc *Service) ActionSubmissionRequestChanges(ctx context.Context, params internal.ActionSubmissionRequestChangesParams) error {
// transaction
target_status := model.SubmissionStatusChangesRequested
smap := datastore.Optional()
smap.Add("status_id", target_status)
err := svc.DB.Submissions().IfStatusThenUpdate(ctx, params.SubmissionID, []model.SubmissionStatus{model.SubmissionStatusSubmitting}, smap)
update := service_inner.NewSubmissionUpdate()
update.SetStatusID(target_status)
allowed_statuses :=[]model.SubmissionStatus{model.SubmissionStatusSubmitting}
err := svc.inner.UpdateSubmissionIfStatus(ctx, params.SubmissionID, allowed_statuses, update)
if err != nil {
return err
}
@@ -118,7 +122,7 @@ func (svc *Service) ActionSubmissionRequestChanges(ctx context.Context, params i
TargetStatus: uint32(target_status),
}
return svc.CreateAuditEventAction(
return svc.inner.CreateAuditEventAction(
ctx,
ValidtorUserID,
model.Resource{
@@ -137,9 +141,10 @@ func (svc *Service) ActionSubmissionRequestChanges(ctx context.Context, params i
func (svc *Service) ActionSubmissionValidated(ctx context.Context, params internal.ActionSubmissionValidatedParams) error {
// transaction
target_status := model.SubmissionStatusValidated
smap := datastore.Optional()
smap.Add("status_id", target_status)
err := svc.DB.Submissions().IfStatusThenUpdate(ctx, params.SubmissionID, []model.SubmissionStatus{model.SubmissionStatusValidating}, smap)
update := service_inner.NewSubmissionUpdate()
update.SetStatusID(target_status)
allowed_statuses :=[]model.SubmissionStatus{model.SubmissionStatusValidating}
err := svc.inner.UpdateSubmissionIfStatus(ctx, params.SubmissionID, allowed_statuses, update)
if err != nil {
return err
}
@@ -148,7 +153,7 @@ func (svc *Service) ActionSubmissionValidated(ctx context.Context, params intern
TargetStatus: uint32(target_status),
}
return svc.CreateAuditEventAction(
return svc.inner.CreateAuditEventAction(
ctx,
ValidtorUserID,
model.Resource{
@@ -167,9 +172,10 @@ func (svc *Service) ActionSubmissionValidated(ctx context.Context, params intern
func (svc *Service) ActionSubmissionAccepted(ctx context.Context, params internal.ActionSubmissionAcceptedParams) error {
// transaction
target_status := model.SubmissionStatusAcceptedUnvalidated
smap := datastore.Optional()
smap.Add("status_id", target_status)
err := svc.DB.Submissions().IfStatusThenUpdate(ctx, params.SubmissionID, []model.SubmissionStatus{model.SubmissionStatusValidating}, smap)
update := service_inner.NewSubmissionUpdate()
update.SetStatusID(target_status)
allowed_statuses :=[]model.SubmissionStatus{model.SubmissionStatusValidating}
err := svc.inner.UpdateSubmissionIfStatus(ctx, params.SubmissionID, allowed_statuses, update)
if err != nil {
return err
}
@@ -179,7 +185,7 @@ func (svc *Service) ActionSubmissionAccepted(ctx context.Context, params interna
TargetStatus: uint32(target_status),
}
return svc.CreateAuditEventAction(
return svc.inner.CreateAuditEventAction(
ctx,
ValidtorUserID,
model.Resource{
@@ -198,10 +204,11 @@ func (svc *Service) ActionSubmissionAccepted(ctx context.Context, params interna
func (svc *Service) ActionSubmissionUploaded(ctx context.Context, params internal.ActionSubmissionUploadedParams) error {
// transaction
target_status := model.SubmissionStatusUploaded
smap := datastore.Optional()
smap.Add("status_id", target_status)
smap.Add("uploaded_asset_id", params.UploadedAssetID)
err := svc.DB.Submissions().IfStatusThenUpdate(ctx, params.SubmissionID, []model.SubmissionStatus{model.SubmissionStatusUploading}, smap)
update := service_inner.NewSubmissionUpdate()
update.SetStatusID(target_status)
update.SetUploadedAssetID(uint64(params.UploadedAssetID))
allowed_statuses :=[]model.SubmissionStatus{model.SubmissionStatusUploading}
err := svc.inner.UpdateSubmissionIfStatus(ctx, params.SubmissionID, allowed_statuses, update)
if err != nil {
return err
}
@@ -210,7 +217,7 @@ func (svc *Service) ActionSubmissionUploaded(ctx context.Context, params interna
TargetStatus: uint32(target_status),
}
return svc.CreateAuditEventAction(
return svc.inner.CreateAuditEventAction(
ctx,
ValidtorUserID,
model.Resource{
@@ -231,7 +238,7 @@ func (svc *Service) CreateSubmissionAuditError(ctx context.Context, params inter
Error: params.ErrorMessage,
}
return svc.CreateAuditEventError(
return svc.inner.CreateAuditEventError(
ctx,
ValidtorUserID,
model.Resource{
@@ -261,7 +268,7 @@ func (svc *Service) CreateSubmissionAuditCheckList(ctx context.Context, check_li
CheckList: check_list2,
}
return svc.CreateAuditEventCheckList(
return svc.inner.CreateAuditEventCheckList(
ctx,
ValidtorUserID,
model.Resource{
@@ -290,11 +297,11 @@ func (svc *Service) CreateSubmission(ctx context.Context, request *internal.Subm
// Check if an active submission with the same asset id exists
{
filter := datastore.Optional()
filter.Add("asset_id", request.AssetID)
filter.Add("asset_version", request.AssetVersion)
filter.Add("status_id", ActiveSubmissionStatuses)
active_submissions, err := svc.DB.Submissions().List(ctx, filter, model.Page{
filter := service_inner.NewSubmissionFilter()
filter.SetAssetID(AssetID)
filter.SetAssetVersion(AssetVersion)
filter.SetStatuses(ActiveSubmissionStatuses)
active_submissions, err := svc.inner.ListSubmissions(ctx, filter, model.Page{
Number: 1,
Size: 1,
},datastore.ListSortDisabled)
@@ -306,7 +313,7 @@ func (svc *Service) CreateSubmission(ctx context.Context, request *internal.Subm
}
}
operation, err := svc.DB.Operations().Get(ctx, request.OperationID)
operation, err := svc.inner.GetOperation(ctx, request.OperationID)
if err != nil {
return nil, err
}
@@ -320,7 +327,7 @@ func (svc *Service) CreateSubmission(ctx context.Context, request *internal.Subm
return nil, ErrNotAssetOwner
}
submission, err := svc.DB.Submissions().Create(ctx, model.Submission{
submission, err := svc.inner.CreateSubmission(ctx, model.Submission{
ID: 0,
DisplayName: request.DisplayName,
Creator: request.Creator,
@@ -336,10 +343,8 @@ func (svc *Service) CreateSubmission(ctx context.Context, request *internal.Subm
}
// mark the operation as completed and provide the path
pmap := datastore.Optional()
pmap.Add("status_id", model.OperationStatusCompleted)
pmap.Add("path", fmt.Sprintf("/submissions/%d", submission.ID))
err = svc.DB.Operations().Update(ctx, request.OperationID, pmap)
params := service_inner.NewOperationCompleteParams(fmt.Sprintf("/submissions/%d", submission.ID))
err = svc.inner.CompleteOperation(ctx, request.OperationID, params)
if err != nil {
return nil, err
}