maps-service/pkg/web_api/scripts.go

package web_api

import (
	"context"

	"git.itzana.me/strafesnet/maps-service/pkg/api"
	"git.itzana.me/strafesnet/maps-service/pkg/model"
	"git.itzana.me/strafesnet/maps-service/pkg/service"
)

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) {
	err := CheckHasRoleScriptWrite(ctx)
	if err != nil {
		return nil, err
	}

	hash := int64(model.HashSource(req.Source))

	// Check if a script with this hash already exists
	filter := service.NewScriptFilter()
	filter.SetHash(hash)
	existingScripts, err := svc.inner.ListScripts(ctx, filter, model.Page{Number: 1, Size: 1})
	if err != nil {
		return nil, err
	}

	// If script with this hash exists, return existing script ID
	if len(existingScripts) > 0 {
		return &api.ScriptID{
			ScriptID: existingScripts[0].ID,
		}, nil
	}

	// Create new script
	script, err := svc.inner.CreateScript(ctx, model.Script{
		ID:           0,
		Name:         req.Name,
		Hash:         hash,
		Source:       req.Source,
		ResourceType: model.ResourceType(req.ResourceType),
		ResourceID:   req.ResourceID.Or(0),
	})
	if err != nil {
		return nil, err
	}

	return &api.ScriptID{
		ScriptID: script.ID,
	}, nil
}

// ListScripts implements listScripts operation.
//
// Get list of scripts.
//
// GET /scripts
func (svc *Service) ListScripts(ctx context.Context, params api.ListScriptsParams) ([]api.Script, error) {
	filter := service.NewScriptFilter()

	if hash_hex, ok := params.Hash.Get(); ok{
		hash_parsed, err := model.HashParse(hash_hex)
		if err != nil {
			return nil, err
		}
		filter.SetHash(int64(hash_parsed))
	}
	if name, name_ok := params.Name.Get(); name_ok{
		filter.SetName(name)
	}
	if source, source_ok := params.Source.Get(); source_ok{
		filter.SetSource(source)
	}
	if resource_type, resource_type_ok := params.ResourceType.Get(); resource_type_ok{
		filter.SetResourceType(resource_type)
	}
	if resource_id, resource_id_ok := params.ResourceID.Get(); resource_id_ok{
		filter.SetResourceID(resource_id)
	}


	items, err := svc.inner.ListScripts(ctx, filter, model.Page{
		Number: params.Page,
		Size:   params.Limit,
	})
	if err != nil {
		return nil, err
	}

	var resp []api.Script
	for _, item := range items {
		resp = append(resp, api.Script{
			ID:           item.ID,
			Name:         item.Name,
			Hash:         model.HashFormat(uint64(item.Hash)),
			Source:       item.Source,
			ResourceType: int32(item.ResourceType),
			ResourceID:   item.ResourceID,
		})
	}

	return resp, nil
}

// DeleteScript implements deleteScript operation.
//
// Delete the specified script by ID.
//
// DELETE /scripts/{ScriptID}
func (svc *Service) DeleteScript(ctx context.Context, params api.DeleteScriptParams) error {
	err := CheckHasRoleScriptWrite(ctx)
	if err != nil {
		return err
	}

	return svc.inner.DeleteScript(ctx, params.ScriptID)
}

// GetScript implements getScript operation.
//
// Get the specified script by ID.
//
// GET /scripts/{ScriptID}
func (svc *Service) GetScript(ctx context.Context, params api.GetScriptParams) (*api.Script, error) {
	script, err := svc.inner.GetScript(ctx, params.ScriptID)
	if err != nil {
		return nil, err
	}

	return &api.Script{
		ID:           script.ID,
		Name:         script.Name,
		Hash:         model.HashFormat(uint64(script.Hash)),
		Source:       script.Source,
		ResourceType: int32(script.ResourceType),
		ResourceID:   script.ResourceID,
	}, nil
}

// UpdateScript implements updateScript operation.
//
// Update the specified script by ID.
//
// PATCH /scripts/{ScriptID}
func (svc *Service) UpdateScript(ctx context.Context, req *api.ScriptUpdate, params api.UpdateScriptParams) error {
	err := CheckHasRoleScriptWrite(ctx)
	if err != nil {
		return err
	}

	filter := service.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)
	}

	return svc.inner.UpdateScript(ctx, req.ID, filter)
}