maps-service/pkg/validator_controller/submissions.go

package validator_controller

import (
	"context"
	"errors"
	"fmt"

	"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"
)

var(
	// prevent two mapfixes with same asset id
	ActiveSubmissionStatuses = []model.SubmissionStatus{
		model.SubmissionStatusUploading,
		model.SubmissionStatusValidated,
		model.SubmissionStatusValidating,
		model.SubmissionStatusAcceptedUnvalidated,
		model.SubmissionStatusChangesRequested,
		model.SubmissionStatusSubmitted,
		model.SubmissionStatusUnderConstruction,
	}
)

var(
	ErrActiveSubmissionSameAssetID = errors.New("There is an active submission with the same AssetID")
)

// UpdateSubmissionValidatedModel implements patchSubmissionModel operation.
//
// Update model following role restrictions.
//
// POST /submissions/{SubmissionID}/validated-model
func (svc *Controller) UpdateSubmissionValidatedModel(ctx context.Context, params internal.UpdateSubmissionValidatedModelParams) error {
	ValidatedModelID := uint64(params.ValidatedModelID)
	ValidatedModelVersion := uint64(params.ValidatedModelVersion)

	// check if Status is ChangesRequested|Submitted|UnderConstruction
	update := service.NewSubmissionUpdate()
	update.SetValidatedAssetID(ValidatedModelID)
	update.SetValidatedAssetVersion(ValidatedModelVersion)
	// DO NOT reset completed when validated model is updated
	// 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
	}

	event_data := model.AuditEventDataChangeValidatedModel{
		ValidatedModelID: ValidatedModelID,
		ValidatedModelVersion: ValidatedModelVersion,
	}

	return svc.inner.CreateAuditEventChangeValidatedModel(
		ctx,
		ValidtorUserID,
		model.Resource{
			ID: params.SubmissionID,
			Type: model.ResourceSubmission,
		},
		event_data,
	)
}

// ActionSubmissionSubmitted invokes actionSubmissionSubmitted operation.
//
// Role Validator changes status from Submitting -> Submitted.
//
// POST /submissions/{SubmissionID}/status/validator-submitted
func (svc *Controller) ActionSubmissionSubmitted(ctx context.Context, params internal.ActionSubmissionSubmittedParams) error {
	// transaction
	target_status := model.SubmissionStatusSubmitted
	update := service.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
	}

	event_data := model.AuditEventDataAction{
		TargetStatus: uint32(target_status),
	}

	return svc.inner.CreateAuditEventAction(
		ctx,
		ValidtorUserID,
		model.Resource{
			ID: params.SubmissionID,
			Type: model.ResourceSubmission,
		},
		event_data,
	)
}

// ActionSubmissionRequestChanges implements actionSubmissionRequestChanges operation.
//
// (Internal endpoint) Role Validator changes status from Submitting -> RequestChanges.
//
// POST /submissions/{SubmissionID}/status/validator-request-changes
func (svc *Controller) ActionSubmissionRequestChanges(ctx context.Context, params internal.ActionSubmissionRequestChangesParams) error {
	// transaction
	target_status := model.SubmissionStatusChangesRequested
	update := service.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
	}

	// push an action audit event
	event_data := model.AuditEventDataAction{
		TargetStatus: uint32(target_status),
	}

	return svc.inner.CreateAuditEventAction(
		ctx,
		ValidtorUserID,
		model.Resource{
			ID: params.SubmissionID,
			Type: model.ResourceSubmission,
		},
		event_data,
	)
}

// ActionSubmissionValidate invokes actionSubmissionValidate operation.
//
// Role Validator changes status from Validating -> Validated.
//
// POST /submissions/{SubmissionID}/status/validator-validated
func (svc *Controller) ActionSubmissionValidated(ctx context.Context, params internal.ActionSubmissionValidatedParams) error {
	// transaction
	target_status := model.SubmissionStatusValidated
	update := service.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
	}

	event_data := model.AuditEventDataAction{
		TargetStatus: uint32(target_status),
	}

	return svc.inner.CreateAuditEventAction(
		ctx,
		ValidtorUserID,
		model.Resource{
			ID: params.SubmissionID,
			Type: model.ResourceSubmission,
		},
		event_data,
	)
}

// ActionSubmissionAccepted implements actionSubmissionAccepted operation.
//
// (Internal endpoint) Role Validator changes status from Validating -> Accepted.
//
// POST /submissions/{SubmissionID}/status/validator-failed
func (svc *Controller) ActionSubmissionAccepted(ctx context.Context, params internal.ActionSubmissionAcceptedParams) error {
	// transaction
	target_status := model.SubmissionStatusAcceptedUnvalidated
	update := service.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
	}

	// push an action audit event
	event_data := model.AuditEventDataAction{
		TargetStatus: uint32(target_status),
	}

	return svc.inner.CreateAuditEventAction(
		ctx,
		ValidtorUserID,
		model.Resource{
			ID: params.SubmissionID,
			Type: model.ResourceSubmission,
		},
		event_data,
	)
}

// ActionSubmissionUploaded implements actionSubmissionUploaded operation.
//
// (Internal endpoint) Role Validator changes status from Uploading -> Uploaded.
//
// POST /submissions/{SubmissionID}/status/validator-uploaded
func (svc *Controller) ActionSubmissionUploaded(ctx context.Context, params internal.ActionSubmissionUploadedParams) error {
	// transaction
	target_status := model.SubmissionStatusUploaded
	update := service.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
	}

	event_data := model.AuditEventDataAction{
		TargetStatus: uint32(target_status),
	}

	return svc.inner.CreateAuditEventAction(
		ctx,
		ValidtorUserID,
		model.Resource{
			ID: params.SubmissionID,
			Type: model.ResourceSubmission,
		},
		event_data,
	)
}

// CreateSubmissionAuditError implements createSubmissionAuditError operation.
//
// Post an error to the audit log
//
// POST /submissions/{SubmissionID}/error
func (svc *Controller) CreateSubmissionAuditError(ctx context.Context, params internal.CreateSubmissionAuditErrorParams) (error) {
	event_data := model.AuditEventDataError{
		Error: params.ErrorMessage,
	}

	return svc.inner.CreateAuditEventError(
		ctx,
		ValidtorUserID,
		model.Resource{
			ID: params.SubmissionID,
			Type: model.ResourceSubmission,
		},
		event_data,
	)
}

// CreateSubmissionAuditCheckList implements createSubmissionAuditCheckList operation.
//
// Post a checklist to the audit log
//
// POST /submissions/{SubmissionID}/checklist
func (svc *Controller) CreateSubmissionAuditCheckList(ctx context.Context, check_list internal.CheckList, params internal.CreateSubmissionAuditCheckListParams) (error) {
	check_list2 := make([]model.Check, len(check_list))
	for i, check := range check_list {
		check_list2[i] = model.Check{
			Name:    check.Name,
			Summary: check.Summary,
			Passed:  check.Passed,
		}
	}

	event_data := model.AuditEventDataCheckList{
		CheckList: check_list2,
	}

	return svc.inner.CreateAuditEventCheckList(
		ctx,
		ValidtorUserID,
		model.Resource{
			ID: params.SubmissionID,
			Type: model.ResourceSubmission,
		},
		event_data,
	)
}

// POST /submissions
func (svc *Controller) CreateSubmission(ctx context.Context, request *internal.SubmissionCreate) (*internal.SubmissionID, error) {
	// sanitization
	if request.GameID<0||
	request.AssetOwner<0||
	request.AssetID<0||
	request.AssetVersion<0{
		return nil, ErrNegativeID
	}
	var GameID=uint32(request.GameID);
	var Submitter=uint64(request.AssetOwner);
	var AssetID=uint64(request.AssetID);
	var AssetVersion=uint64(request.AssetVersion);
	var Status=model.SubmissionStatus(request.Status);
	var roles=model.Roles(request.Roles);

	// Check if an active submission with the same asset id exists
	{
		filter := service.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)
		if err != nil {
			return nil, err
		}
		if len(active_submissions) != 0{
			return nil, ErrActiveSubmissionSameAssetID
		}
	}

	operation, err := svc.inner.GetOperation(ctx, request.OperationID)
	if err != nil {
		return nil, err
	}

	// check if user owns asset
	is_submitter := operation.Owner == Submitter
	// check if user is map admin
	has_submission_review := roles & model.RolesSubmissionReview == model.RolesSubmissionReview
	// if neither, u not allowed
	if !is_submitter && !has_submission_review {
		return nil, ErrNotAssetOwner
	}

	submission, err := svc.inner.CreateSubmission(ctx, model.Submission{
		ID:            0,
		DisplayName:   request.DisplayName,
		Creator:       request.Creator,
		GameID:        GameID,
		Submitter:     Submitter,
		AssetID:       AssetID,
		AssetVersion:  AssetVersion,
		Completed:     false,
		StatusID:      Status,
	})
	if err != nil {
		return nil, err
	}

	// mark the operation as completed and provide the path
	params := service.NewOperationCompleteParams(fmt.Sprintf("/submissions/%d", submission.ID))
	err = svc.inner.CompleteOperation(ctx, request.OperationID, params)
	if err != nil {
		return nil, err
	}

	return &internal.SubmissionID{
		SubmissionID: submission.ID,
	}, nil
}