func resourceRuleRead()

in internal/kibana/alerting.go [461:591]
116 lines of code
29 McCabe index (conditional complexity)

func resourceRuleRead(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
	client, diags := clients.NewApiClientFromSDKResource(d, meta)
	if diags.HasError() {
		return diags
	}
	compId, diags := clients.CompositeIdFromStr(d.Id())
	if diags.HasError() {
		return diags
	}
	id := compId.ResourceId
	spaceId := compId.ClusterId

	rule, diags := kibana.GetAlertingRule(ctx, client, id, spaceId)
	if rule == nil && diags == nil {
		d.SetId("")
		return diags
	}
	if diags.HasError() {
		return diags
	}

	// set the fields
	if err := d.Set("rule_id", rule.RuleID); err != nil {
		return diag.FromErr(err)
	}
	if err := d.Set("space_id", rule.SpaceID); err != nil {
		return diag.FromErr(err)
	}
	if err := d.Set("name", rule.Name); err != nil {
		return diag.FromErr(err)
	}
	if err := d.Set("consumer", rule.Consumer); err != nil {
		return diag.FromErr(err)
	}
	if err := d.Set("notify_when", rule.NotifyWhen); err != nil {
		return diag.FromErr(err)
	}
	if err := d.Set("rule_type_id", rule.RuleTypeID); err != nil {
		return diag.FromErr(err)
	}
	if err := d.Set("interval", rule.Schedule.Interval); err != nil {
		return diag.FromErr(err)
	}
	if err := d.Set("enabled", rule.Enabled); err != nil {
		return diag.FromErr(err)
	}
	if err := d.Set("tags", rule.Tags); err != nil {
		return diag.FromErr(err)
	}
	if err := d.Set("throttle", rule.Throttle); err != nil {
		return diag.FromErr(err)
	}
	if err := d.Set("scheduled_task_id", rule.ScheduledTaskID); err != nil {
		return diag.FromErr(err)
	}
	if err := d.Set("last_execution_status", rule.ExecutionStatus.Status); err != nil {
		return diag.FromErr(err)
	}
	if rule.ExecutionStatus.LastExecutionDate != nil {
		if err := d.Set("last_execution_date", rule.ExecutionStatus.LastExecutionDate.Format("2006-01-02 15:04:05.999 -0700 MST")); err != nil {
			return diag.FromErr(err)
		}
	}

	params, err := json.Marshal(rule.Params)
	if err != nil {
		return diag.FromErr(err)
	}
	if err := d.Set("params", string(params)); err != nil {
		return diag.FromErr(err)
	}

	actions := []interface{}{}
	for _, action := range rule.Actions {
		params, err := json.Marshal(action.Params)
		if err != nil {
			return diag.FromErr(err)
		}

		frequency := []interface{}{}

		if action.Frequency != nil {
			frequency = append(frequency, map[string]interface{}{
				"summary":     action.Frequency.Summary,
				"notify_when": action.Frequency.NotifyWhen,
				"throttle":    action.Frequency.Throttle,
			})
		} else {
			frequency = nil
		}

		alerts_filter := []interface{}{}

		if action.AlertsFilter != nil {
			filter := map[string]interface{}{}

			if action.AlertsFilter.Timeframe != nil {
				timeframe := []interface{}{}
				timeframe = append(timeframe, map[string]interface{}{
					"days":        action.AlertsFilter.Timeframe.Days,
					"timezone":    action.AlertsFilter.Timeframe.Timezone,
					"hours_start": action.AlertsFilter.Timeframe.HoursStart,
					"hours_end":   action.AlertsFilter.Timeframe.HoursEnd,
				})
				filter["timeframe"] = timeframe
			}

			if action.AlertsFilter.Kql != nil {
				filter["kql"] = action.AlertsFilter.Kql
			}

			alerts_filter = append(alerts_filter, filter)
		} else {
			alerts_filter = nil
		}

		actions = append(actions, map[string]interface{}{
			"group":         action.Group,
			"id":            action.ID,
			"params":        string(params),
			"frequency":     frequency,
			"alerts_filter": alerts_filter,
		})
	}

	if err := d.Set("actions", actions); err != nil {
		return diag.FromErr(err)
	}

	return diags
}