OliveTin/service/internal/api/apiActions.go

package api

import (
	"strconv"
	"strings"
	"time"

	log "github.com/sirupsen/logrus"

	apiv1 "github.com/OliveTin/OliveTin/gen/olivetin/api/v1"
	acl "github.com/OliveTin/OliveTin/internal/acl"
	authpublic "github.com/OliveTin/OliveTin/internal/auth/authpublic"
	config "github.com/OliveTin/OliveTin/internal/config"
	entities "github.com/OliveTin/OliveTin/internal/entities"
	executor "github.com/OliveTin/OliveTin/internal/executor"
	"github.com/OliveTin/OliveTin/internal/tpl"
)

type bindingActiveState struct {
	hasRunning bool
	hasQueued  bool
}

type DashboardRenderRequest struct {
	AuthenticatedUser   *authpublic.AuthenticatedUser
	cfg                 *config.Config
	ex                  *executor.Executor
	activeBindingStates map[string]bindingActiveState
	EntityType          string
	EntityKey           string
}

func activeBindingID(entry *executor.InternalLogEntry) string {
	if entry == nil || entry.ExecutionFinished {
		return ""
	}
	return entry.GetBindingId()
}

func applyEntryToBindingState(state bindingActiveState, entry *executor.InternalLogEntry) bindingActiveState {
	if entry.ExecutionStarted {
		state.hasRunning = true
	} else {
		state.hasQueued = true
	}
	return state
}

func buildActiveBindingStates(active []*executor.InternalLogEntry) map[string]bindingActiveState {
	states := make(map[string]bindingActiveState)

	for _, entry := range active {
		bindingID := activeBindingID(entry)
		if bindingID == "" {
			continue
		}
		states[bindingID] = applyEntryToBindingState(states[bindingID], entry)
	}

	return states
}

func populateActiveBindingStates(rr *DashboardRenderRequest) {
	if rr == nil || rr.ex == nil || rr.activeBindingStates != nil {
		return
	}

	rr.activeBindingStates = buildActiveBindingStates(rr.ex.GetActiveExecutionsACL(rr.cfg, rr.AuthenticatedUser))
}

func (rr *DashboardRenderRequest) findAction(title string) *apiv1.Action {
	return rr.findActionForEntity(title, nil)
}

func bindingMatchesTitleAndEntity(binding *executor.ActionBinding, title string, entity *entities.Entity) bool {
	return binding != nil && binding.Action != nil && binding.Action.Title == title && matchesEntity(binding, entity)
}

func (rr *DashboardRenderRequest) findActionForEntity(title string, entity *entities.Entity) *apiv1.Action {
	rr.ex.MapActionBindingsLock.RLock()
	defer rr.ex.MapActionBindingsLock.RUnlock()

	for _, binding := range rr.ex.MapActionBindings {
		if action := rr.actionFromMatchingBinding(title, entity, binding); action != nil {
			return action
		}
	}

	return nil
}

func (rr *DashboardRenderRequest) actionFromMatchingBinding(title string, entity *entities.Entity, binding *executor.ActionBinding) *apiv1.Action {
	if !bindingMatchesTitleAndEntity(binding, title, entity) {
		return nil
	}

	if !rr.canViewBindingForDashboard(binding) {
		return nil
	}

	return buildAction(binding, rr)
}

func (rr *DashboardRenderRequest) canViewBindingForDashboard(binding *executor.ActionBinding) bool {
	if binding == nil || binding.Action == nil {
		return false
	}

	if !acl.IsAllowedView(rr.cfg, rr.AuthenticatedUser, binding.Action) {
		return false
	}

	if binding.Action.Entity == "" {
		return true
	}

	return acl.IsAllowedViewEntityType(rr.cfg, rr.AuthenticatedUser, entityFileForType(rr.cfg, binding.Action.Entity))
}

func matchesEntity(binding *executor.ActionBinding, entity *entities.Entity) bool {
	if entity == nil {
		return binding.Entity == nil
	}

	return binding.Entity != nil && binding.Entity.UniqueKey == entity.UniqueKey
}

func buildEffectivePolicy(policy *config.ConfigurationPolicy) *apiv1.EffectivePolicy {
	ret := &apiv1.EffectivePolicy{
		ShowDiagnostics:   policy.ShowDiagnostics,
		ShowLogList:       policy.ShowLogList,
		ShowVersionNumber: policy.ShowVersionNumber,
	}

	return ret
}

func evaluateEnabledExpression(action *config.Action, entity *entities.Entity) bool {
	if action.EnabledExpression == "" {
		return true
	}

	result := tpl.ParseTemplateOfActionBeforeExec(action.EnabledExpression, entity)
	result = strings.TrimSpace(result)

	if result == "" {
		return false
	}

	if isTemplateError(result, action) {
		return false
	}

	return evaluateResultValue(result)
}

func isTemplateError(result string, action *config.Action) bool {
	if !strings.HasPrefix(result, "tpl ") || !strings.Contains(result, "error") {
		return false
	}

	log.WithFields(log.Fields{
		"actionTitle":       action.Title,
		"enabledExpression": action.EnabledExpression,
		"result":            result,
	}).Warn("enabledExpression template evaluation failed, treating as disabled")
	return true
}

func evaluateResultValue(result string) bool {
	if strings.EqualFold(result, "true") {
		return true
	}

	if num, err := strconv.Atoi(result); err == nil {
		return num != 0
	}

	return false
}

func getDefaultArgumentValue(cfgArg config.ActionArgument, entity *entities.Entity) string {
	defaultValue := cfgArg.Default

	if defaultValue != "" {
		defaultValue = tpl.ParseTemplateOfActionBeforeExec(defaultValue, entity)
	}

	return defaultValue
}

func formatRateLimitExpiry(expiryUnix int64) string {
	if expiryUnix <= 0 {
		return ""
	}
	return time.Unix(expiryUnix, 0).Format("2006-01-02 15:04:05")
}

func actionFromBinding(actionBinding *executor.ActionBinding) (*executor.ActionBinding, *config.Action) {
	if actionBinding == nil || actionBinding.Action == nil {
		return nil, nil
	}
	return actionBinding, actionBinding.Action
}

func applyActiveBindingStateToAction(btn *apiv1.Action, bindingID string, states map[string]bindingActiveState) {
	if states == nil {
		return
	}
	state, ok := states[bindingID]
	if !ok {
		return
	}
	btn.HasRunningInstance = state.hasRunning
	btn.HasQueuedInstance = state.hasQueued
}

func buildActionArguments(action *config.Action, entity *entities.Entity, rr *DashboardRenderRequest) []*apiv1.ActionArgument {
	args := make([]*apiv1.ActionArgument, 0, len(action.Arguments))
	for _, cfgArg := range action.Arguments {
		args = append(args, &apiv1.ActionArgument{
			Name:                  cfgArg.Name,
			Title:                 cfgArg.Title,
			Type:                  cfgArg.Type,
			Description:           cfgArg.Description,
			DefaultValue:          getDefaultArgumentValue(cfgArg, entity),
			Choices:               buildChoices(cfgArg, rr),
			Suggestions:           cfgArg.Suggestions,
			SuggestionsBrowserKey: cfgArg.SuggestionsBrowserKey,
		})
	}
	return args
}

func buildAction(actionBinding *executor.ActionBinding, rr *DashboardRenderRequest) *apiv1.Action {
	binding, action := actionFromBinding(actionBinding)
	if binding == nil {
		return nil
	}

	btn := apiv1.Action{
		BindingId:                binding.ID,
		Title:                    tpl.ParseTemplateOfActionBeforeExec(action.Title, binding.Entity),
		Icon:                     tpl.ParseTemplateOfActionBeforeExec(action.Icon, binding.Entity),
		CanExec:                  acl.IsAllowedExec(rr.cfg, rr.AuthenticatedUser, action) && evaluateEnabledExpression(action, binding.Entity),
		PopupOnStart:             action.OnClick,
		Order:                    int32(binding.ConfigOrder),
		Timeout:                  int32(action.Timeout),
		DatetimeRateLimitExpires: formatRateLimitExpiry(rr.ex.GetTimeUntilAvailable(binding)),
		Justification:            action.Justification,
	}

	applyActiveBindingStateToAction(&btn, binding.ID, rr.activeBindingStates)
	applyActionExecTriggers(&btn, action)
	btn.Arguments = buildActionArguments(action, binding.Entity, rr)
	btn.Groups = buildActionGroups(action, rr.cfg)

	return &btn
}

func buildActionGroups(action *config.Action, cfg *config.Config) []*apiv1.ActionGroupMembership {
	if action == nil || len(action.Groups) == 0 {
		return nil
	}

	groups := make([]*apiv1.ActionGroupMembership, 0, len(action.Groups))

	for _, name := range action.Groups {
		groups = append(groups, actionGroupMembershipFromConfig(name, cfg))
	}

	return groups
}

func actionGroupMembershipFromConfig(name string, cfg *config.Config) *apiv1.ActionGroupMembership {
	membership := &apiv1.ActionGroupMembership{Name: name}

	group, found := cfg.ActionGroups[name]
	if !found || group == nil || group.MaxConcurrent < 1 {
		return membership
	}

	membership.MaxConcurrent = int32(group.MaxConcurrent)
	membership.QueueSize = int32(group.QueueSize)

	return membership
}

func buildChoices(arg config.ActionArgument, rr *DashboardRenderRequest) []*apiv1.ActionArgumentChoice {
	if arg.Entity == "" {
		return buildChoicesSimple(arg.Choices)
	}

	if len(arg.Choices) != 1 {
		return []*apiv1.ActionArgumentChoice{}
	}

	return buildChoicesEntity(arg.Choices[0], arg.Entity, rr)
}

func buildChoicesEntity(firstChoice config.ActionArgumentChoice, entityTitle string, rr *DashboardRenderRequest) []*apiv1.ActionArgumentChoice {
	if rr == nil || !acl.IsAllowedViewEntityType(rr.cfg, rr.AuthenticatedUser, entityFileForType(rr.cfg, entityTitle)) {
		return []*apiv1.ActionArgumentChoice{}
	}

	ret := []*apiv1.ActionArgumentChoice{}

	for _, ent := range entities.GetEntityInstancesOrdered(entityTitle) {
		ret = append(ret, &apiv1.ActionArgumentChoice{
			Value: tpl.ParseTemplateOfActionBeforeExec(firstChoice.Value, ent),
			Title: tpl.ParseTemplateOfActionBeforeExec(firstChoice.Title, ent),
		})
	}

	return ret
}

func buildChoicesSimple(choices []config.ActionArgumentChoice) []*apiv1.ActionArgumentChoice {
	ret := []*apiv1.ActionArgumentChoice{}

	for _, cfgChoice := range choices {
		pbChoice := apiv1.ActionArgumentChoice{
			Value: cfgChoice.Value,
			Title: cfgChoice.Title,
		}

		ret = append(ret, &pbChoice)
	}

	return ret
}