add UBool unit type to attributes, and converter for common boolean stting specifications

the converter looks for common booleanish strings like 'yes' , 'off'  'disabled' 'True' etc, and converts them to 'true' or 'false' . these are then string-compared to the values the check returns for these attributes.

use the Ubool attribute type on check_tasksched attributes: enabled, has_run and hidden. it is not used anywhere else

Author: inqrphl

pkg/snclient/check_tasksched.go

@@ -60,18 +60,18 @@ func (l *CheckTasksched) Build() *CheckData {
 			{name: "application", description: "Name of the application that the task is associated with"},
 			{name: "comment", description: "Comment or description for the work item"},
 			{name: "creator", description: "Creator of the work item"},
-			{name: "enabled", description: "Flag whether this job is enabled (true/false)"},
+			{name: "enabled", description: "Flag whether this job is enabled (true/false)", unit: UBool},
 			{name: "exit_code", description: "The last jobs exit code"},
 			{name: "exit_string", description: "The last jobs exit code as string"},
 			{name: "folder", description: "Task folder"},
 			{name: "uri", description: "Fully qualified path to the task, includes folder and the task title"},
 			{name: "uri_clean", description: "Remove the leading backslash from the URI, only for tasks directly saved at root and not for ones saved inside folders."},
-			{name: "has_run", description: "True if this task has ever been executed"},
+			{name: "has_run", description: "True if this task has ever been executed", unit: UBool},
 			{name: "max_run_time", description: "Maximum length of time the task can run", unit: UDuration},
 			{name: "most_recent_run_time", description: "Most recent time the work item began running", unit: UDate},
 			{name: "priority", description: "Task priority"},
 			{name: "title", description: "Task title"},
-			{name: "hidden", description: "Indicates that the task will not be visible in the UI (true/false)"},
+			{name: "hidden", description: "Indicates that the task will not be visible in the UI (true/false)", unit: UBool},
 			{name: "missed_runs", description: "Number of times the registered task has missed a scheduled run"},
 			{name: "task_status", description: "Task status as string"},
 			{name: "next_run_time", description: "Time when the registered task is next scheduled to run", unit: UDate},

pkg/snclient/checkdata.go

@@ -82,6 +82,7 @@ const (
 	UDate
 	UTimestamp
 	UPercent
+	UBool
 )
 
 type CheckAttribute struct {

pkg/snclient/condition.go

@@ -16,6 +16,10 @@ import (
 )
 
 var (
+	// ^ and $ are used to capture the whole string
+	// (\-?\d+\.\d+|\-?\d+) -> capture group one, two options separated by | first is a decimal with dot , second is a direct number
+	// \s* -> any number of whitespace between the second group
+	// (\D+) -> capture group two, one or more non-digit characters
 	reConditionValueUnit = regexp.MustCompile(`^(\-?\d+\.\d+|\-?\d+)\s*(\D+)$`)
 	reCuddleKeyword      = regexp.MustCompile(`^([A-Za-z_]+)([!=><~]+)(.*)$`)
 	reCuddleOperator     = regexp.MustCompile(`^([!=><~]+)(.*?)$`)
@@ -819,10 +823,25 @@ func (c *Condition) expandDateKeyword(str string) bool {
 func (c *Condition) expandUnitByType(str string) error {
 	// valid units might be "today", "thisweek", "thismonth", "thisyear" and ":utc" variants
 	unit := c.getUnit(c.keyword)
-	if unit == UDate || unit == UTimestamp {
+
+	switch unit {
+	case UDate, UTimestamp:
 		if done := c.expandDateKeyword(str); done {
 			return nil
 		}
+	case UBool:
+		// boolean units are not in the form of '<number> <unit>'
+		// need to handle them before regex condition checks.
+		newVal, oldVal, err := utils.ParseAndReplaceBoolAttributes(str)
+		if err != nil {
+			return fmt.Errorf("invalid boolean value: %s", err.Error())
+		}
+		c.original = oldVal
+		c.value = newVal
+		c.unit = ""
+
+		return nil
+	default:
 	}
 
 	match := reConditionValueUnit.FindStringSubmatch(str)
@@ -868,6 +887,8 @@ func (c *Condition) expandUnitByType(str string) error {
 		c.unit = "s"
 
 		return nil
+	case UBool:
+		return nil // handled before the regex check
 	case UPercent:
 		return nil
 	case UNone:

pkg/utils/utils.go

@@ -81,6 +81,65 @@ func ExpandDuration(val string) (res float64, err error) {
 	return 0, fmt.Errorf("expandDuration: cannot parse duration, unknown format in %s", val)
 }
 
+var truthyValues = []string{"1", "true", "enabled", "yes", "y", "on", "t"}
+var falseyValues = []string{"0", "false", "disabled", "no", "n", "off", "f"}
+
+var (
+	truthyRegex, truthyReplacements = replacePatterns(truthyValues, "true")
+	falseyRegex, falseyReplacements = replacePatterns(falseyValues, "false")
+)
+
+// replacePatterns builds a regex that matches any of the given words as whole words,
+// and returns the pattern and a replacement map (lowercase match → replacement).
+func replacePatterns(words []string, replacement string) (regex *regexp.Regexp, replacements map[string]string) {
+	escaped := make([]string, len(words))
+	replacementMap := make(map[string]string)
+	for i, word := range words {
+		lowercase := strings.ToLower(word)
+		escaped[i] = regexp.QuoteMeta(lowercase)
+		replacementMap[lowercase] = replacement
+	}
+	pattern := `\b(` + strings.Join(escaped, "|") + `)\b`
+
+	return regexp.MustCompile(pattern), replacementMap
+}
+
+// ParseAndReplaceBoolAttributes replaces all known truthy/falsey tokens in val
+// with "true"/"false" (case‑insensitive whole‑word match).
+// Returns the modified string, the original string, and an error if any
+// unrecognized boolean‑like token is found (optional).
+func ParseAndReplaceBoolAttributes(val string) (newVal, oldVal string, err error) {
+	oldVal = val
+	foundValues := 0
+
+	newVal = truthyRegex.ReplaceAllStringFunc(val, func(match string) string {
+		if replacement, ok := truthyReplacements[strings.ToLower(match)]; ok {
+			foundValues++
+
+			return replacement
+		}
+
+		return ""
+	})
+
+	newVal = falseyRegex.ReplaceAllStringFunc(newVal, func(match string) string {
+		if replacement, ok := falseyReplacements[strings.ToLower(match)]; ok {
+			foundValues++
+
+			return replacement
+		}
+
+		return ""
+	})
+
+	if foundValues == 0 {
+		err = fmt.Errorf("ParseAndReplaceBoolAttributes: did not find any truthy or falsely values in boolean attribute value: '%s' , lowercase needs to be one of falsely: '%s' or truthy: '%s' values",
+			val, strings.Join(falseyValues, " "), strings.Join(truthyValues, " "))
+	}
+
+	return newVal, oldVal, err
+}
+
 // returns time/duration in target unit with given precision
 func TimeUnitF(num uint64, targetUnit string, precision int) float64 {
 	for _, factor := range TimeFactors {