func resourceAlibabacloudCmsMetricRuleTemplateUpdate()

in alibabacloudstack/resource_apsarastack_cms_metric_rule_template.go [335:473]
135 lines of code
35 McCabe index (conditional complexity)

func resourceAlibabacloudCmsMetricRuleTemplateUpdate(d *schema.ResourceData, meta interface{}) error {
	client := meta.(*connectivity.AlibabacloudStackClient)
	d.Partial(true)
	update := false

	if v, ok := d.GetOk("enable"); ok && v.(bool) {
		request := client.NewCommonRequest("POST", "cms", "2019-01-01", "ApplyMetricRuleTemplate", "")
		request.QueryParams["TemplateId"] = "[]"
		request.QueryParams["TemplateIds"] = d.Id()
		request.QueryParams["GroupId"] = client.ResourceGroup
		request.QueryParams["Overwrite"] = fmt.Sprintf("%t", d.Get("overwrite").(bool))
		if v, ok := d.GetOk("apply_mode"); ok {
			request.QueryParams["ApplyMode"] = v.(string)
		}
		if v, ok := d.GetOk("enable_end_time"); ok {
			request.QueryParams["EnableEndTime"] = v.(string)
		}
		if v, ok := d.GetOk("enable_start_time"); ok {
			request.QueryParams["EnableStartTime"] = v.(string)
		}
		if v, ok := d.GetOk("notify_level"); ok {
			request.QueryParams["NotifyLevel"] = v.(string)
		}
		if v, ok := d.GetOk("silence_time"); ok {
			request.QueryParams["SilenceTime"] = fmt.Sprint(v)
		}
		if v, ok := d.GetOk("webhook"); ok {
			request.QueryParams["Webhook"] = v.(string)
		}

		raw, err := client.WithCmsClient(func(cmsClient *cms.Client) (interface{}, error) {
			return cmsClient.ProcessCommonRequest(request)
		})
		addDebug(request.GetActionName(), raw, request, request.QueryParams)
		if err != nil {
			errmsg := ""
			if response, ok := raw.(*responses.BaseResponse); ok {
				errmsg = errmsgs.GetBaseResponseErrorMessage(response)
			}
			return errmsgs.WrapErrorf(err, errmsgs.RequestV1ErrorMsg, "ApplyMetricRuleTemplate", request.GetActionName(), errmsgs.AlibabacloudStackSdkGoERROR, errmsg)
		}
		bresponse, _ := raw.(*responses.CommonResponse)
		resource := make(map[string]interface{})
		err = json.Unmarshal(bresponse.GetHttpContentBytes(), &resource)
		if err != nil {
			return errmsgs.WrapErrorf(err, errmsgs.DataDefaultErrorMsg, "ApplyMetricRuleTemplate", request.GetActionName(), errmsgs.AlibabacloudStackSdkGoERROR)
		}
		if resource["Code"].(float64) != 200 {
			return errmsgs.WrapError(fmt.Errorf("ApplyMetricRuleTemplate Error: %v", resource))
		}
		d.Set("group_id", client.ResourceGroup)
	}

	update = false
	modifyMetricRuleTemplateReq := cms.CreateModifyMetricRuleTemplateRequest()
	client.InitRpcRequest(*modifyMetricRuleTemplateReq.RpcRequest)

	if v, ok := d.GetOk("rest_version"); ok {
		rest_version, _ := strconv.Atoi(v.(string))
		modifyMetricRuleTemplateReq.RestVersion = requests.NewInteger(rest_version)
	}
	if !d.IsNewResource() && d.HasChange("alert_templates") {
		update = true
		if v, ok := d.GetOk("alert_templates"); ok {
			alertTemplatesMaps := make([]cms.ModifyMetricRuleTemplateAlertTemplates, 0)
			for _, alertTemplates := range v.(*schema.Set).List() {
				alertTemplatesArg := alertTemplates.(map[string]interface{})
				if escalationsMaps, ok := alertTemplatesArg["escalations"]; ok {
					for _, escalationsArg := range escalationsMaps.(*schema.Set).List() {
						alertTemplate := cms.ModifyMetricRuleTemplateAlertTemplates{}
						alertTemplate.Category = alertTemplatesArg["category"].(string)
						alertTemplate.MetricName = alertTemplatesArg["metric_name"].(string)
						alertTemplate.Namespace = alertTemplatesArg["namespace"].(string)
						alertTemplate.RuleName = alertTemplatesArg["rule_name"].(string)
						alertTemplate.Webhook = alertTemplatesArg["webhook"].(string)
						if criticalMaps, ok := escalationsArg.(map[string]interface{})["critical"]; ok {
							for _, criticalMap := range criticalMaps.(*schema.Set).List() {
								criticalArg := criticalMap.(map[string]interface{})
								alertTemplate.EscalationsCriticalComparisonOperator = criticalArg["comparison_operator"].(string)
								alertTemplate.EscalationsCriticalStatistics = criticalArg["statistics"].(string)
								alertTemplate.EscalationsCriticalThreshold = criticalArg["threshold"].(string)
								alertTemplate.EscalationsCriticalTimes = criticalArg["times"].(string)
							}
						}
						if infoMaps, ok := escalationsArg.(map[string]interface{})["info"]; ok {
							for _, infoMap := range infoMaps.(*schema.Set).List() {
								infoArg := infoMap.(map[string]interface{})
								alertTemplate.EscalationsInfoComparisonOperator = infoArg["comparison_operator"].(string)
								alertTemplate.EscalationsInfoStatistics = infoArg["statistics"].(string)
								alertTemplate.EscalationsInfoThreshold = infoArg["threshold"].(string)
								alertTemplate.EscalationsInfoTimes = infoArg["times"].(string)
							}
						}
						if warnMaps, ok := escalationsArg.(map[string]interface{})["warn"]; ok {
							for _, warnMap := range warnMaps.(*schema.Set).List() {
								warnArg := warnMap.(map[string]interface{})
								alertTemplate.EscalationsWarnComparisonOperator = warnArg["comparison_operator"].(string)
								alertTemplate.EscalationsWarnStatistics = warnArg["statistics"].(string)
								alertTemplate.EscalationsWarnThreshold = warnArg["threshold"].(string)
								alertTemplate.EscalationsWarnTimes = warnArg["times"].(string)
							}
						}
						alertTemplatesMaps = append(alertTemplatesMaps, alertTemplate)
					}
				}
			}
			modifyMetricRuleTemplateReq.AlertTemplates = &alertTemplatesMaps
		}
	}
	if !d.IsNewResource() && d.HasChange("description") {
		update = true
		if v, ok := d.GetOk("description"); ok {
			modifyMetricRuleTemplateReq.Description = v.(string)
		}
	}
	if !d.IsNewResource() && d.HasChange("metric_rule_template_name") {
		update = true
		modifyMetricRuleTemplateReq.Name = d.Get("metric_rule_template_name").(string)
	}
	if update {
		raw, err := client.WithCmsClient(func(cmsClient *cms.Client) (interface{}, error) {
			return cmsClient.ModifyMetricRuleTemplate(modifyMetricRuleTemplateReq)
		})
		addDebug(modifyMetricRuleTemplateReq.GetActionName(), raw, modifyMetricRuleTemplateReq, modifyMetricRuleTemplateReq.QueryParams)
		if err != nil {
			errmsg := ""
			if response, ok := raw.(*responses.BaseResponse); ok {
				errmsg = errmsgs.GetBaseResponseErrorMessage(response)
			}
			return errmsgs.WrapErrorf(err, errmsgs.RequestV1ErrorMsg, "ApplyMetricRuleTemplate", modifyMetricRuleTemplateReq.GetActionName(), errmsgs.AlibabacloudStackSdkGoERROR, errmsg)
		}
		response, _ := raw.(*cms.ModifyMetricRuleTemplateResponse)
		if response.Code != 200 {
			return errmsgs.WrapError(fmt.Errorf("%s", response.Message))
		}
	}
	d.Partial(false)
	return nil
}