func()

in pkg/inspection/form/textform.go [155:249]
85 lines of code
19 McCabe index (conditional complexity)

func (b *TextFormTaskBuilder[T]) Build(labelOpts ...common_task.LabelOpt) common_task.Task[T] {
	return common_task.NewTask(b.id, b.dependencies, func(ctx context.Context) (T, error) {
		m := khictx.MustGetValue(ctx, inspection_task_contextkey.InspectionRunMetadata)
		req := khictx.MustGetValue(ctx, inspection_task_contextkey.InspectionTaskInput)
		taskMode := khictx.MustGetValue(ctx, inspection_task_contextkey.InspectionTaskMode)
		globalSharedMap := khictx.MustGetValue(ctx, inspection_task_contextkey.GlobalSharedMap)

		previousValueStoreKey := typedmap.NewTypedKey[[]string](fmt.Sprintf("text-form-pv-%s", b.id))
		prevValue := typedmap.GetOrDefault(globalSharedMap, previousValueStoreKey, []string{})

		readonly, err := b.readonlyProvider(ctx)
		if err != nil {
			return *new(T), fmt.Errorf("allowEdit provider for task `%s` returned an error\n%v", b.id, err)
		}
		field := form_metadata.TextParameterFormField{}
		field.Readonly = readonly

		// Compute the default value of the form
		var currentValue string
		defaultValue, err := b.defaultValue(ctx, prevValue)
		if err != nil {
			return *new(T), fmt.Errorf("default value generator for task `%s` returned an error\n%v", b.id, err)
		}
		field.Default = defaultValue
		currentValue = defaultValue
		if valueRaw, exist := req[b.id.ReferenceIDString()]; exist && !readonly {
			valueString, isString := valueRaw.(string)
			if !isString {
				return *new(T), fmt.Errorf("request parameter `%s` was not given in string in task %s", b.id, b.id)
			}
			currentValue = valueString
		}

		field.Type = form_metadata.Text
		field.HintType = form_metadata.Info

		b.SetupBaseFormField(&field.ParameterFormFieldBase)

		suggestions, err := b.suggestionsProvider(ctx, currentValue, prevValue)
		if err != nil {
			return *new(T), fmt.Errorf("suggesion provider for task `%s` returned an error\n%v", b.id, err)
		}
		field.Suggestions = suggestions

		validationErr, err := b.validator(ctx, currentValue)
		if err != nil {
			return *new(T), fmt.Errorf("validator for task `%s` returned an unrecovable error\n%v", b.id, err)
		}
		if validationErr != "" {
			// When the given string is invalid, it should be the default value.
			currentValue, err = b.defaultValue(ctx, prevValue)
			if err != nil {
				return *new(T), fmt.Errorf("default value generator for task `%s` returned an error\n%v", b.id, err)
			}
		}
		if validationErr != "" && taskMode == inspection_task_interface.TaskModeRun {
			return *new(T), fmt.Errorf("validator for task `%s` returned a validation error. But this task was executed as a Run mode not in DryRun. All validations must be resolved before running.\n%v", b.id, validationErr)
		}

		convertedValue, err := b.converter(ctx, currentValue)
		if err != nil {
			return *new(T), fmt.Errorf("failed to convert the value `%s` to the dedicated value in task %s\n%v", currentValue, b.id, err)
		}
		if validationErr != "" {
			field.HintType = form_metadata.Error
			field.Hint = validationErr
		} else {
			hint, hintType, err := b.hintGenerator(ctx, currentValue, convertedValue)
			if err != nil {
				return *new(T), fmt.Errorf("failed to generate a hint for task %s\n%v", b.id, err)
			}
			if hint == "" {
				hintType = form_metadata.None
			}
			field.Hint = hint
			field.HintType = hintType
			if taskMode == inspection_task_interface.TaskModeRun {
				newValueHistory := append([]string{currentValue}, prevValue...)
				typedmap.Set(globalSharedMap, previousValueStoreKey, newValueHistory)
			}
		}
		formFields, found := typedmap.Get(m, form_metadata.FormFieldSetMetadataKey)
		if !found {
			return *new(T), fmt.Errorf("form field set was not found in the metadata set")
		}
		err = formFields.SetField(field)
		if err != nil {
			return *new(T), fmt.Errorf("failed to configure the form metadata in task `%s`\n%v", b.id, err)
		}
		return convertedValue, nil
	}, append(labelOpts, label.NewFormTaskLabelOpt(
		b.label,
		b.description,
	))...)
}