1195 lines
30 KiB
Go
1195 lines
30 KiB
Go
package web_api
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"time"
|
|
|
|
"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"
|
|
)
|
|
|
|
var(
|
|
CreationPhaseMapfixesLimit = 20
|
|
CreationPhaseMapfixStatuses = []model.MapfixStatus{
|
|
model.MapfixStatusChangesRequested,
|
|
model.MapfixStatusSubmitted,
|
|
model.MapfixStatusUnderConstruction,
|
|
}
|
|
// limit mapfixes in the pipeline to one per target map
|
|
ActiveAcceptedMapfixStatuses = []model.MapfixStatus{
|
|
model.MapfixStatusReleasing,
|
|
model.MapfixStatusUploaded,
|
|
model.MapfixStatusUploading,
|
|
model.MapfixStatusValidated,
|
|
model.MapfixStatusValidating,
|
|
model.MapfixStatusAcceptedUnvalidated,
|
|
}
|
|
// Allow 5 mapfixes every 10 minutes
|
|
CreateMapfixRateLimit int64 = 5
|
|
CreateMapfixRecencyWindow = time.Second*600
|
|
)
|
|
|
|
var (
|
|
ErrCreationPhaseMapfixesLimit = errors.New("Active mapfixes limited to 20")
|
|
ErrActiveMapfixSameTargetAssetID = errors.New("There is an active mapfix for this map already")
|
|
ErrAcceptOwnMapfix = fmt.Errorf("%w: You cannot accept your own mapfix as the submitter", ErrPermissionDenied)
|
|
ErrCreateMapfixRateLimit = errors.New("You must not create more than 5 mapfixes every 10 minutes")
|
|
)
|
|
|
|
// POST /mapfixes
|
|
func (svc *Service) CreateMapfix(ctx context.Context, request *api.MapfixTriggerCreate) (*api.OperationID, error) {
|
|
// sanitization
|
|
if request.AssetID<0 || request.TargetAssetID<0{
|
|
return nil, ErrNegativeID
|
|
}
|
|
var ModelID=uint64(request.AssetID);
|
|
var TargetAssetID=uint64(request.TargetAssetID);
|
|
|
|
userInfo, ok := ctx.Value("UserInfo").(UserInfoHandle)
|
|
if !ok {
|
|
return nil, ErrUserInfo
|
|
}
|
|
|
|
userId, err := userInfo.GetUserID()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Check if user's mapfixes in the creation phase exceeds the limit
|
|
{
|
|
filter := service.NewMapfixFilter()
|
|
filter.SetSubmitter(userId)
|
|
filter.SetStatuses(CreationPhaseMapfixStatuses)
|
|
|
|
creation_mapfixes, err := svc.inner.ListMapfixes(ctx, filter, model.Page{
|
|
Number: 1,
|
|
Size: int32(CreationPhaseMapfixesLimit),
|
|
},datastore.ListSortDisabled)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if CreationPhaseMapfixesLimit <= len(creation_mapfixes) {
|
|
return nil, ErrCreationPhaseMapfixesLimit
|
|
}
|
|
}
|
|
|
|
// Check if a mapfix targetting the same map exists in creation phase
|
|
{
|
|
filter := service.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)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if len(active_mapfixes) != 0{
|
|
return nil, ErrActiveMapfixSameTargetAssetID
|
|
}
|
|
}
|
|
|
|
// Check if TargetAssetID actually exists
|
|
{
|
|
_, err := svc.inner.GetMap(ctx, request.TargetAssetID)
|
|
if err != nil {
|
|
// TODO: match specific does not exist grpc error
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
// Check if too many operations have been created recently
|
|
{
|
|
count, err := svc.inner.CountOperationsSince(ctx,
|
|
int64(userId),
|
|
time.Now().Add(-CreateMapfixRecencyWindow),
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if CreateMapfixRateLimit < count {
|
|
return nil, ErrCreateMapfixRateLimit
|
|
}
|
|
}
|
|
|
|
operation, err := svc.inner.CreateOperation(ctx, model.Operation{
|
|
Owner: userId,
|
|
StatusID: model.OperationStatusCreated,
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
err = svc.inner.NatsCreateMapfix(
|
|
operation.ID,
|
|
ModelID,
|
|
TargetAssetID,
|
|
request.Description,
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &api.OperationID{
|
|
OperationID: operation.ID,
|
|
}, nil
|
|
}
|
|
|
|
// GetMapfix implements getMapfix operation.
|
|
//
|
|
// Retrieve map with ID.
|
|
//
|
|
// GET /mapfixes/{MapfixID}
|
|
func (svc *Service) GetMapfix(ctx context.Context, params api.GetMapfixParams) (*api.Mapfix, error) {
|
|
mapfix, err := svc.inner.GetMapfix(ctx, params.MapfixID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &api.Mapfix{
|
|
ID: mapfix.ID,
|
|
DisplayName: mapfix.DisplayName,
|
|
Creator: mapfix.Creator,
|
|
GameID: int32(mapfix.GameID),
|
|
CreatedAt: mapfix.CreatedAt.Unix(),
|
|
UpdatedAt: mapfix.UpdatedAt.Unix(),
|
|
Submitter: int64(mapfix.Submitter),
|
|
AssetID: int64(mapfix.AssetID),
|
|
AssetVersion: int64(mapfix.AssetVersion),
|
|
Completed: mapfix.Completed,
|
|
TargetAssetID: int64(mapfix.TargetAssetID),
|
|
StatusID: int32(mapfix.StatusID),
|
|
Description: mapfix.Description,
|
|
}, nil
|
|
}
|
|
|
|
// ListMapfixes implements listMapfixes operation.
|
|
//
|
|
// Get list of mapfixes.
|
|
//
|
|
// GET /mapfixes
|
|
func (svc *Service) ListMapfixes(ctx context.Context, params api.ListMapfixesParams) (*api.Mapfixes, error) {
|
|
filter := service.NewMapfixFilter()
|
|
|
|
if display_name, display_name_ok := params.DisplayName.Get(); display_name_ok{
|
|
filter.SetDisplayName(display_name)
|
|
}
|
|
if creator, creator_ok := params.Creator.Get(); creator_ok{
|
|
filter.SetCreator(creator)
|
|
}
|
|
if game_id, game_id_ok := params.GameID.Get(); game_id_ok{
|
|
filter.SetGameID(uint32(game_id))
|
|
}
|
|
if submitter, submitter_ok := params.Submitter.Get(); submitter_ok{
|
|
filter.SetSubmitter(uint64(submitter))
|
|
}
|
|
if asset_id, asset_id_ok := params.AssetID.Get(); asset_id_ok{
|
|
filter.SetAssetID(uint64(asset_id))
|
|
}
|
|
if asset_version, asset_version_ok := params.AssetVersion.Get(); asset_version_ok{
|
|
filter.SetAssetVersion(uint64(asset_version))
|
|
}
|
|
if target_asset_id, target_asset_id_ok := params.TargetAssetID.Get(); target_asset_id_ok{
|
|
filter.SetTargetAssetID(uint64(target_asset_id))
|
|
}
|
|
// 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.inner.ListMapfixesWithTotal(ctx, filter, model.Page{
|
|
Number: params.Page,
|
|
Size: params.Limit,
|
|
},sort)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var resp api.Mapfixes
|
|
resp.Total=total
|
|
for _, item := range items {
|
|
resp.Mapfixes = append(resp.Mapfixes, api.Mapfix{
|
|
ID: item.ID,
|
|
DisplayName: item.DisplayName,
|
|
Creator: item.Creator,
|
|
GameID: int32(item.GameID),
|
|
CreatedAt: item.CreatedAt.Unix(),
|
|
UpdatedAt: item.UpdatedAt.Unix(),
|
|
Submitter: int64(item.Submitter),
|
|
AssetID: int64(item.AssetID),
|
|
AssetVersion: int64(item.AssetVersion),
|
|
Completed: item.Completed,
|
|
TargetAssetID: int64(item.TargetAssetID),
|
|
StatusID: int32(item.StatusID),
|
|
Description: item.Description,
|
|
})
|
|
}
|
|
|
|
return &resp, nil
|
|
}
|
|
|
|
// PatchMapfixCompleted implements patchMapfixCompleted operation.
|
|
//
|
|
// Retrieve map with ID.
|
|
//
|
|
// POST /mapfixes/{MapfixID}/completed
|
|
func (svc *Service) SetMapfixCompleted(ctx context.Context, params api.SetMapfixCompletedParams) error {
|
|
userInfo, ok := ctx.Value("UserInfo").(UserInfoHandle)
|
|
if !ok {
|
|
return ErrUserInfo
|
|
}
|
|
|
|
has_role, err := userInfo.HasRoleMaptest()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
// check if caller has MaptestGame role (request must originate from a maptest roblox game)
|
|
if !has_role {
|
|
return ErrPermissionDeniedNeedRoleMaptest
|
|
}
|
|
|
|
update := service.NewMapfixUpdate()
|
|
update.SetCompleted(true)
|
|
return svc.inner.UpdateMapfix(ctx, params.MapfixID, update)
|
|
}
|
|
|
|
// UpdateMapfixModel implements patchMapfixModel operation.
|
|
//
|
|
// Update model following role restrictions.
|
|
//
|
|
// POST /mapfixes/{MapfixID}/model
|
|
func (svc *Service) UpdateMapfixModel(ctx context.Context, params api.UpdateMapfixModelParams) error {
|
|
userInfo, ok := ctx.Value("UserInfo").(UserInfoHandle)
|
|
if !ok {
|
|
return ErrUserInfo
|
|
}
|
|
|
|
// read mapfix (this could be done with a transaction WHERE clause)
|
|
mapfix, err := svc.inner.GetMapfix(ctx, params.MapfixID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
userId, err := userInfo.GetUserID()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// check if caller is the submitter
|
|
has_role := userId == mapfix.Submitter
|
|
if !has_role {
|
|
return ErrPermissionDeniedNotSubmitter
|
|
}
|
|
|
|
OldModelID := mapfix.AssetID
|
|
OldModelVersion := mapfix.AssetVersion
|
|
NewModelID := uint64(params.ModelID)
|
|
NewModelVersion := uint64(params.ModelVersion)
|
|
|
|
// check if Status is ChangesRequested|Submitted|UnderConstruction
|
|
update := service.NewMapfixUpdate()
|
|
update.SetAssetID(NewModelID)
|
|
update.SetAssetVersion(NewModelVersion)
|
|
//always reset completed when model changes
|
|
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
|
|
}
|
|
|
|
event_data := model.AuditEventDataChangeModel{
|
|
OldModelID: OldModelID,
|
|
OldModelVersion: OldModelVersion,
|
|
NewModelID: NewModelID,
|
|
NewModelVersion: NewModelVersion,
|
|
}
|
|
|
|
return svc.inner.CreateAuditEventChangeModel(
|
|
ctx,
|
|
userId,
|
|
model.Resource{
|
|
ID: params.MapfixID,
|
|
Type: model.ResourceMapfix,
|
|
},
|
|
event_data,
|
|
)
|
|
}
|
|
|
|
// ActionMapfixReject invokes actionMapfixReject operation.
|
|
//
|
|
// Role Reviewer changes status from Submitted -> Rejected.
|
|
//
|
|
// POST /mapfixes/{MapfixID}/status/reject
|
|
func (svc *Service) ActionMapfixReject(ctx context.Context, params api.ActionMapfixRejectParams) error {
|
|
userInfo, ok := ctx.Value("UserInfo").(UserInfoHandle)
|
|
if !ok {
|
|
return ErrUserInfo
|
|
}
|
|
|
|
has_role, err := userInfo.HasRoleMapfixReview()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
// check if caller has required role
|
|
if !has_role {
|
|
return ErrPermissionDeniedNeedRoleMapfixReview
|
|
}
|
|
|
|
userId, err := userInfo.GetUserID()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// transaction
|
|
target_status := model.MapfixStatusRejected
|
|
update := service.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
|
|
}
|
|
|
|
event_data := model.AuditEventDataAction{
|
|
TargetStatus: uint32(target_status),
|
|
}
|
|
|
|
return svc.inner.CreateAuditEventAction(
|
|
ctx,
|
|
userId,
|
|
model.Resource{
|
|
ID: params.MapfixID,
|
|
Type: model.ResourceMapfix,
|
|
},
|
|
event_data,
|
|
)
|
|
}
|
|
|
|
// ActionMapfixRequestChanges invokes actionMapfixRequestChanges operation.
|
|
//
|
|
// Role Reviewer changes status from Validated|Accepted|Submitted -> ChangesRequested.
|
|
//
|
|
// POST /mapfixes/{MapfixID}/status/request-changes
|
|
func (svc *Service) ActionMapfixRequestChanges(ctx context.Context, params api.ActionMapfixRequestChangesParams) error {
|
|
userInfo, ok := ctx.Value("UserInfo").(UserInfoHandle)
|
|
if !ok {
|
|
return ErrUserInfo
|
|
}
|
|
|
|
has_role, err := userInfo.HasRoleMapfixReview()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
// check if caller has required role
|
|
if !has_role {
|
|
return ErrPermissionDeniedNeedRoleMapfixReview
|
|
}
|
|
|
|
userId, err := userInfo.GetUserID()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// transaction
|
|
target_status := model.MapfixStatusChangesRequested
|
|
update := service.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
|
|
}
|
|
|
|
event_data := model.AuditEventDataAction{
|
|
TargetStatus: uint32(target_status),
|
|
}
|
|
|
|
return svc.inner.CreateAuditEventAction(
|
|
ctx,
|
|
userId,
|
|
model.Resource{
|
|
ID: params.MapfixID,
|
|
Type: model.ResourceMapfix,
|
|
},
|
|
event_data,
|
|
)
|
|
}
|
|
|
|
// ActionMapfixRevoke invokes actionMapfixRevoke operation.
|
|
//
|
|
// Role Submitter changes status from Submitted|ChangesRequested -> UnderConstruction.
|
|
//
|
|
// POST /mapfixes/{MapfixID}/status/revoke
|
|
func (svc *Service) ActionMapfixRevoke(ctx context.Context, params api.ActionMapfixRevokeParams) error {
|
|
userInfo, ok := ctx.Value("UserInfo").(UserInfoHandle)
|
|
if !ok {
|
|
return ErrUserInfo
|
|
}
|
|
|
|
// read mapfix (this could be done with a transaction WHERE clause)
|
|
mapfix, err := svc.inner.GetMapfix(ctx, params.MapfixID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
userId, err := userInfo.GetUserID()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// check if caller is the submitter
|
|
has_role := userId == mapfix.Submitter
|
|
if !has_role {
|
|
return ErrPermissionDeniedNotSubmitter
|
|
}
|
|
|
|
// transaction
|
|
target_status := model.MapfixStatusUnderConstruction
|
|
update := service.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
|
|
}
|
|
|
|
event_data := model.AuditEventDataAction{
|
|
TargetStatus: uint32(target_status),
|
|
}
|
|
|
|
return svc.inner.CreateAuditEventAction(
|
|
ctx,
|
|
userId,
|
|
model.Resource{
|
|
ID: params.MapfixID,
|
|
Type: model.ResourceMapfix,
|
|
},
|
|
event_data,
|
|
)
|
|
}
|
|
|
|
// ActionMapfixTriggerSubmit invokes actionMapfixTriggerSubmit operation.
|
|
//
|
|
// Role Submitter changes status from UnderConstruction|ChangesRequested -> Submitting.
|
|
//
|
|
// POST /mapfixes/{MapfixID}/status/trigger-submit
|
|
func (svc *Service) ActionMapfixTriggerSubmit(ctx context.Context, params api.ActionMapfixTriggerSubmitParams) error {
|
|
userInfo, ok := ctx.Value("UserInfo").(UserInfoHandle)
|
|
if !ok {
|
|
return ErrUserInfo
|
|
}
|
|
|
|
// read mapfix (this could be done with a transaction WHERE clause)
|
|
mapfix, err := svc.inner.GetMapfix(ctx, params.MapfixID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
userId, err := userInfo.GetUserID()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// check if caller is the submitter
|
|
has_role := userId == mapfix.Submitter
|
|
if !has_role {
|
|
return ErrPermissionDeniedNotSubmitter
|
|
}
|
|
|
|
// transaction
|
|
target_status := model.MapfixStatusSubmitting
|
|
update := service.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
|
|
}
|
|
|
|
err = svc.inner.NatsCheckMapfix(
|
|
mapfix.ID,
|
|
mapfix.AssetID,
|
|
false,
|
|
)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
event_data := model.AuditEventDataAction{
|
|
TargetStatus: uint32(target_status),
|
|
}
|
|
|
|
return svc.inner.CreateAuditEventAction(
|
|
ctx,
|
|
userId,
|
|
model.Resource{
|
|
ID: params.MapfixID,
|
|
Type: model.ResourceMapfix,
|
|
},
|
|
event_data,
|
|
)
|
|
}
|
|
|
|
// ActionMapfixTriggerSubmitUnchecked invokes actionMapfixTriggerSubmitUnchecked operation.
|
|
//
|
|
// Role Reviewer changes status from ChangesRequested -> Submitting.
|
|
//
|
|
// POST /mapfixes/{MapfixID}/status/trigger-submit-unchecked
|
|
func (svc *Service) ActionMapfixTriggerSubmitUnchecked(ctx context.Context, params api.ActionMapfixTriggerSubmitUncheckedParams) error {
|
|
userInfo, ok := ctx.Value("UserInfo").(UserInfoHandle)
|
|
if !ok {
|
|
return ErrUserInfo
|
|
}
|
|
|
|
// read mapfix (this could be done with a transaction WHERE clause)
|
|
mapfix, err := svc.inner.GetMapfix(ctx, params.MapfixID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
userId, err := userInfo.GetUserID()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// check if caller is the submitter
|
|
is_submitter := userId == mapfix.Submitter
|
|
if is_submitter {
|
|
return ErrAcceptOwnMapfix
|
|
}
|
|
|
|
has_mapfix_review, err := userInfo.HasRoleMapfixReview()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if !has_mapfix_review {
|
|
return ErrPermissionDeniedNeedRoleMapfixReview
|
|
}
|
|
|
|
// transaction
|
|
target_status := model.MapfixStatusSubmitting
|
|
update := service.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
|
|
}
|
|
|
|
err = svc.inner.NatsCheckMapfix(
|
|
mapfix.ID,
|
|
mapfix.AssetID,
|
|
true,
|
|
)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
event_data := model.AuditEventDataAction{
|
|
TargetStatus: uint32(target_status),
|
|
}
|
|
|
|
return svc.inner.CreateAuditEventAction(
|
|
ctx,
|
|
userId,
|
|
model.Resource{
|
|
ID: params.MapfixID,
|
|
Type: model.ResourceMapfix,
|
|
},
|
|
event_data,
|
|
)
|
|
}
|
|
|
|
// ActionMapfixResetSubmitting implements actionMapfixResetSubmitting operation.
|
|
//
|
|
// Role MapfixReview changes status from Submitting -> UnderConstruction.
|
|
//
|
|
// POST /mapfixes/{MapfixID}/status/reset-submitting
|
|
func (svc *Service) ActionMapfixResetSubmitting(ctx context.Context, params api.ActionMapfixResetSubmittingParams) error {
|
|
userInfo, ok := ctx.Value("UserInfo").(UserInfoHandle)
|
|
if !ok {
|
|
return ErrUserInfo
|
|
}
|
|
|
|
userId, err := userInfo.GetUserID()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// check when mapfix was updated
|
|
mapfix, err := svc.inner.GetMapfix(ctx, params.MapfixID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if time.Now().Before(mapfix.UpdatedAt.Add(time.Second*10)) {
|
|
// the last time the mapfix was updated must be longer than 10 seconds ago
|
|
return ErrDelayReset
|
|
}
|
|
|
|
// check if caller has required role
|
|
has_role := userId == mapfix.Submitter
|
|
if !has_role {
|
|
return ErrPermissionDeniedNotSubmitter
|
|
}
|
|
|
|
// transaction
|
|
target_status := model.MapfixStatusUnderConstruction
|
|
update := service.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
|
|
}
|
|
|
|
event_data := model.AuditEventDataAction{
|
|
TargetStatus: uint32(target_status),
|
|
}
|
|
|
|
return svc.inner.CreateAuditEventAction(
|
|
ctx,
|
|
userId,
|
|
model.Resource{
|
|
ID: params.MapfixID,
|
|
Type: model.ResourceMapfix,
|
|
},
|
|
event_data,
|
|
)
|
|
}
|
|
|
|
// ActionMapfixTriggerUpload invokes actionMapfixTriggerUpload operation.
|
|
//
|
|
// Role Admin changes status from Validated -> Uploading.
|
|
//
|
|
// POST /mapfixes/{MapfixID}/status/trigger-upload
|
|
func (svc *Service) ActionMapfixTriggerUpload(ctx context.Context, params api.ActionMapfixTriggerUploadParams) error {
|
|
userInfo, ok := ctx.Value("UserInfo").(UserInfoHandle)
|
|
if !ok {
|
|
return ErrUserInfo
|
|
}
|
|
|
|
has_role, err := userInfo.HasRoleMapfixUpload()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
// check if caller has required role
|
|
if !has_role {
|
|
return ErrPermissionDeniedNeedRoleMapfixUpload
|
|
}
|
|
|
|
userId, err := userInfo.GetUserID()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// transaction
|
|
target_status := model.MapfixStatusUploading
|
|
update := service.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
|
|
err = svc.inner.NatsUploadMapfix(
|
|
mapfix.ID,
|
|
mapfix.ValidatedAssetID,
|
|
mapfix.ValidatedAssetVersion,
|
|
mapfix.TargetAssetID,
|
|
)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
event_data := model.AuditEventDataAction{
|
|
TargetStatus: uint32(target_status),
|
|
}
|
|
|
|
return svc.inner.CreateAuditEventAction(
|
|
ctx,
|
|
userId,
|
|
model.Resource{
|
|
ID: params.MapfixID,
|
|
Type: model.ResourceMapfix,
|
|
},
|
|
event_data,
|
|
)
|
|
}
|
|
|
|
// ActionMapfixValidate invokes actionMapfixValidate operation.
|
|
//
|
|
// Role MapfixRelease changes status from Uploading -> Validated.
|
|
//
|
|
// POST /mapfixes/{MapfixID}/status/reset-uploading
|
|
func (svc *Service) ActionMapfixValidated(ctx context.Context, params api.ActionMapfixValidatedParams) error {
|
|
userInfo, ok := ctx.Value("UserInfo").(UserInfoHandle)
|
|
if !ok {
|
|
return ErrUserInfo
|
|
}
|
|
|
|
has_role, err := userInfo.HasRoleMapfixUpload()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
// check if caller has required role
|
|
if !has_role {
|
|
return ErrPermissionDeniedNeedRoleMapfixUpload
|
|
}
|
|
|
|
userId, err := userInfo.GetUserID()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// check when mapfix was updated
|
|
mapfix, err := svc.inner.GetMapfix(ctx, params.MapfixID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if time.Now().Before(mapfix.UpdatedAt.Add(time.Second*10)) {
|
|
// the last time the mapfix was updated must be longer than 10 seconds ago
|
|
return ErrDelayReset
|
|
}
|
|
|
|
// transaction
|
|
target_status := model.MapfixStatusValidated
|
|
update := service.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
|
|
}
|
|
|
|
event_data := model.AuditEventDataAction{
|
|
TargetStatus: uint32(target_status),
|
|
}
|
|
|
|
return svc.inner.CreateAuditEventAction(
|
|
ctx,
|
|
userId,
|
|
model.Resource{
|
|
ID: params.MapfixID,
|
|
Type: model.ResourceMapfix,
|
|
},
|
|
event_data,
|
|
)
|
|
}
|
|
|
|
// ActionMapfixTriggerRelease invokes actionMapfixTriggerRelease operation.
|
|
//
|
|
// Role MapfixUpload changes status from Uploaded -> Releasing.
|
|
//
|
|
// POST /mapfixes/{MapfixID}/status/trigger-release
|
|
func (svc *Service) ActionMapfixTriggerRelease(ctx context.Context, params api.ActionMapfixTriggerReleaseParams) error {
|
|
userInfo, ok := ctx.Value("UserInfo").(UserInfoHandle)
|
|
if !ok {
|
|
return ErrUserInfo
|
|
}
|
|
|
|
has_role, err := userInfo.HasRoleMapfixUpload()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
// check if caller has required role
|
|
if !has_role {
|
|
return ErrPermissionDeniedNeedRoleMapfixUpload
|
|
}
|
|
|
|
userId, err := userInfo.GetUserID()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// transaction
|
|
target_status := model.MapfixStatusReleasing
|
|
update := service.NewMapfixUpdate()
|
|
update.SetStatusID(target_status)
|
|
allow_statuses := []model.MapfixStatus{model.MapfixStatusUploaded}
|
|
mapfix, err := svc.inner.UpdateAndGetMapfixIfStatus(ctx, params.MapfixID, allow_statuses, update)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// this is a map fix
|
|
err = svc.inner.NatsReleaseMapfix(
|
|
mapfix.ID,
|
|
mapfix.ValidatedAssetID,
|
|
mapfix.ValidatedAssetVersion,
|
|
mapfix.TargetAssetID,
|
|
)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
event_data := model.AuditEventDataAction{
|
|
TargetStatus: uint32(target_status),
|
|
}
|
|
|
|
return svc.inner.CreateAuditEventAction(
|
|
ctx,
|
|
userId,
|
|
model.Resource{
|
|
ID: params.MapfixID,
|
|
Type: model.ResourceMapfix,
|
|
},
|
|
event_data,
|
|
)
|
|
}
|
|
|
|
// ActionMapfixUploaded invokes actionMapfixUploaded operation.
|
|
//
|
|
// Role MapfixUpload manually resets releasing softlock and changes status from Releasing -> Uploaded.
|
|
//
|
|
// POST /mapfixes/{MapfixID}/status/reset-releasing
|
|
func (svc *Service) ActionMapfixUploaded(ctx context.Context, params api.ActionMapfixUploadedParams) error {
|
|
userInfo, ok := ctx.Value("UserInfo").(UserInfoHandle)
|
|
if !ok {
|
|
return ErrUserInfo
|
|
}
|
|
|
|
has_role, err := userInfo.HasRoleMapfixUpload()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
// check if caller has required role
|
|
if !has_role {
|
|
return ErrPermissionDeniedNeedRoleMapfixUpload
|
|
}
|
|
|
|
userId, err := userInfo.GetUserID()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// check when mapfix was updated
|
|
mapfix, err := svc.inner.GetMapfix(ctx, params.MapfixID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if time.Now().Before(mapfix.UpdatedAt.Add(time.Second*10)) {
|
|
// the last time the mapfix was updated must be longer than 10 seconds ago
|
|
return ErrDelayReset
|
|
}
|
|
|
|
// transaction
|
|
target_status := model.MapfixStatusUploaded
|
|
update := service.NewMapfixUpdate()
|
|
update.SetStatusID(target_status)
|
|
allow_statuses := []model.MapfixStatus{model.MapfixStatusReleasing}
|
|
err = svc.inner.UpdateMapfixIfStatus(ctx, params.MapfixID, allow_statuses, update)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
event_data := model.AuditEventDataAction{
|
|
TargetStatus: uint32(target_status),
|
|
}
|
|
|
|
return svc.inner.CreateAuditEventAction(
|
|
ctx,
|
|
userId,
|
|
model.Resource{
|
|
ID: params.MapfixID,
|
|
Type: model.ResourceMapfix,
|
|
},
|
|
event_data,
|
|
)
|
|
}
|
|
|
|
// ActionMapfixTriggerValidate invokes actionMapfixTriggerValidate operation.
|
|
//
|
|
// Role Reviewer triggers validation and changes status from Submitted -> Validating.
|
|
//
|
|
// POST /mapfixes/{MapfixID}/status/trigger-validate
|
|
func (svc *Service) ActionMapfixTriggerValidate(ctx context.Context, params api.ActionMapfixTriggerValidateParams) error {
|
|
userInfo, ok := ctx.Value("UserInfo").(UserInfoHandle)
|
|
if !ok {
|
|
return ErrUserInfo
|
|
}
|
|
|
|
has_role, err := userInfo.HasRoleMapfixReview()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
// check if caller has required role
|
|
if !has_role {
|
|
return ErrPermissionDeniedNeedRoleMapfixReview
|
|
}
|
|
|
|
// read mapfix (this could be done with a transaction WHERE clause)
|
|
mapfix, err := svc.inner.GetMapfix(ctx, params.MapfixID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
userId, err := userInfo.GetUserID()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// check if caller is NOT the submitter
|
|
has_role = userId == mapfix.Submitter
|
|
if has_role {
|
|
return ErrAcceptOwnMapfix
|
|
}
|
|
|
|
// Check if an active mapfix with the same target asset id exists
|
|
if mapfix.TargetAssetID != 0 {
|
|
filter := service.NewMapfixFilter()
|
|
filter.SetTargetAssetID(mapfix.TargetAssetID)
|
|
filter.SetStatuses(ActiveAcceptedMapfixStatuses)
|
|
active_mapfixes, err := svc.inner.ListMapfixes(ctx, filter, model.Page{
|
|
Number: 1,
|
|
Size: 1,
|
|
},datastore.ListSortDisabled)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if len(active_mapfixes) != 0{
|
|
return ErrActiveMapfixSameTargetAssetID
|
|
}
|
|
}
|
|
|
|
// transaction
|
|
target_status := model.MapfixStatusValidating
|
|
update := service.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
|
|
}
|
|
|
|
err = svc.inner.NatsValidateMapfix(
|
|
mapfix.ID,
|
|
mapfix.AssetID,
|
|
mapfix.AssetVersion,
|
|
mapfix.ValidatedAssetID,
|
|
)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
event_data := model.AuditEventDataAction{
|
|
TargetStatus: uint32(target_status),
|
|
}
|
|
|
|
return svc.inner.CreateAuditEventAction(
|
|
ctx,
|
|
userId,
|
|
model.Resource{
|
|
ID: params.MapfixID,
|
|
Type: model.ResourceMapfix,
|
|
},
|
|
event_data,
|
|
)
|
|
}
|
|
|
|
// ActionMapfixRetryValidate invokes actionMapfixRetryValidate operation.
|
|
//
|
|
// Role Reviewer re-runs validation and changes status from Accepted -> Validating.
|
|
//
|
|
// POST /mapfixes/{MapfixID}/status/retry-validate
|
|
func (svc *Service) ActionMapfixRetryValidate(ctx context.Context, params api.ActionMapfixRetryValidateParams) error {
|
|
userInfo, ok := ctx.Value("UserInfo").(UserInfoHandle)
|
|
if !ok {
|
|
return ErrUserInfo
|
|
}
|
|
|
|
has_role, err := userInfo.HasRoleMapfixReview()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
// check if caller has required role
|
|
if !has_role {
|
|
return ErrPermissionDeniedNeedRoleMapfixReview
|
|
}
|
|
|
|
userId, err := userInfo.GetUserID()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// transaction
|
|
target_status := model.MapfixStatusValidating
|
|
update := service.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
|
|
}
|
|
|
|
err = svc.inner.NatsValidateMapfix(
|
|
mapfix.ID,
|
|
mapfix.AssetID,
|
|
mapfix.AssetVersion,
|
|
mapfix.ValidatedAssetID,
|
|
)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
event_data := model.AuditEventDataAction{
|
|
TargetStatus: uint32(target_status),
|
|
}
|
|
|
|
return svc.inner.CreateAuditEventAction(
|
|
ctx,
|
|
userId,
|
|
model.Resource{
|
|
ID: params.MapfixID,
|
|
Type: model.ResourceMapfix,
|
|
},
|
|
event_data,
|
|
)
|
|
}
|
|
|
|
// ActionMapfixAccepted implements actionMapfixAccepted operation.
|
|
//
|
|
// Role MapfixReview changes status from Validating -> Accepted.
|
|
//
|
|
// POST /mapfixes/{MapfixID}/status/reset-validating
|
|
func (svc *Service) ActionMapfixAccepted(ctx context.Context, params api.ActionMapfixAcceptedParams) error {
|
|
userInfo, ok := ctx.Value("UserInfo").(UserInfoHandle)
|
|
if !ok {
|
|
return ErrUserInfo
|
|
}
|
|
|
|
has_role, err := userInfo.HasRoleMapfixReview()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
// check if caller has required role
|
|
if !has_role {
|
|
return ErrPermissionDeniedNeedRoleMapfixReview
|
|
}
|
|
|
|
userId, err := userInfo.GetUserID()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// check when mapfix was updated
|
|
mapfix, err := svc.inner.GetMapfix(ctx, params.MapfixID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if time.Now().Before(mapfix.UpdatedAt.Add(time.Second*10)) {
|
|
// the last time the mapfix was updated must be longer than 10 seconds ago
|
|
return ErrDelayReset
|
|
}
|
|
|
|
// transaction
|
|
target_status := model.MapfixStatusAcceptedUnvalidated
|
|
update := service.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
|
|
}
|
|
|
|
event_data := model.AuditEventDataAction{
|
|
TargetStatus: uint32(target_status),
|
|
}
|
|
|
|
return svc.inner.CreateAuditEventAction(
|
|
ctx,
|
|
userId,
|
|
model.Resource{
|
|
ID: params.MapfixID,
|
|
Type: model.ResourceMapfix,
|
|
},
|
|
event_data,
|
|
)
|
|
}
|
|
|
|
// CreateMapfixAuditComment implements createMapfixAuditComment operation.
|
|
//
|
|
// Post a comment to the audit log
|
|
//
|
|
// POST /mapfixes/{MapfixID}/comment
|
|
func (svc *Service) CreateMapfixAuditComment(ctx context.Context, req api.CreateMapfixAuditCommentReq, params api.CreateMapfixAuditCommentParams) (error) {
|
|
userInfo, ok := ctx.Value("UserInfo").(UserInfoHandle)
|
|
if !ok {
|
|
return ErrUserInfo
|
|
}
|
|
|
|
has_role, err := userInfo.HasRoleMapfixReview()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
userId, err := userInfo.GetUserID()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if !has_role {
|
|
// Submitter has special permission to comment on their mapfix
|
|
mapfix, err := svc.inner.GetMapfix(ctx, params.MapfixID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if mapfix.Submitter != userId {
|
|
return ErrPermissionDeniedNeedRoleMapfixReview
|
|
}
|
|
}
|
|
|
|
data, err := io.ReadAll(req)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
event_data := model.AuditEventDataComment{
|
|
Comment: string(data),
|
|
}
|
|
|
|
return svc.inner.CreateAuditEventComment(
|
|
ctx,
|
|
userId,
|
|
model.Resource{
|
|
ID: params.MapfixID,
|
|
Type: model.ResourceMapfix,
|
|
},
|
|
event_data,
|
|
)
|
|
}
|
|
|
|
// ListMapfixAuditEvents invokes listMapfixAuditEvents operation.
|
|
//
|
|
// Retrieve a list of audit events.
|
|
//
|
|
// GET /mapfixes/{MapfixID}/audit-events
|
|
func (svc *Service) ListMapfixAuditEvents(ctx context.Context, params api.ListMapfixAuditEventsParams) ([]api.AuditEvent, error) {
|
|
return svc.inner.ListAuditEvents(
|
|
ctx,
|
|
model.Resource{
|
|
ID: params.MapfixID,
|
|
Type: model.ResourceMapfix,
|
|
},
|
|
model.Page{
|
|
Number: params.Page,
|
|
Size: params.Limit,
|
|
},
|
|
)
|
|
}
|