energylink/pkg/services/sqlstore/alerting.go

package sqlstore

import (
	"fmt"
	"github.com/go-xorm/xorm"
	"github.com/grafana/grafana/pkg/bus"
	m "github.com/grafana/grafana/pkg/models"
	"time"
)

func init() {
	bus.AddHandler("sql", SaveAlerts)
}

func DeleteAlertDefinition(dashboardId int64, sess *xorm.Session) error {
	alerts := make([]m.AlertRule, 0)
	sess.Where("dashboard_id = ?", dashboardId).Find(&alerts)

	for _, alert := range alerts {
		_, err := sess.Exec("DELETE FROM alert_rule WHERE id = ? ", alert.Id)
		if err != nil {
			return err
		}

		if err := SaveAlertChange("DELETED", alert, sess); err != nil {
			return err
		}
	}

	return nil
}

func SaveAlertChange(change string, alert m.AlertRule, sess *xorm.Session) error {
	_, err := sess.Insert(&m.AlertRuleChange{
		OrgId:   alert.OrgId,
		Type:    change,
		Created: time.Now(),
		AlertId: alert.Id,
	})

	if err != nil {
		return err
	}

	return nil
}

func alertIsDifferent(rule1, rule2 m.AlertRule) bool {
	result := false

	result = result || rule1.Aggregator != rule2.Aggregator
	result = result || rule1.CritLevel != rule2.CritLevel
	result = result || rule1.WarnLevel != rule2.WarnLevel
	result = result || rule1.Query != rule2.Query
	result = result || rule1.QueryRefId != rule2.QueryRefId
	result = result || rule1.Interval != rule2.Interval
	result = result || rule1.Title != rule2.Title
	result = result || rule1.Description != rule2.Description
	result = result || rule1.QueryRange != rule2.QueryRange

	return result
}

func SaveAlerts(cmd *m.SaveAlertsCommand) error {
	//this function should be refactored
	return inTransaction(func(sess *xorm.Session) error {
		fmt.Printf("Saving alerts for dashboard %v\n", cmd.DashboardId)

		alerts, err := GetAlertsByDashboardId2(cmd.DashboardId, sess)
		if err != nil {
			return err
		}

		for _, alert := range *cmd.Alerts {
			update := false
			var alertToUpdate m.AlertRule

			for _, k := range alerts {
				if alert.PanelId == k.PanelId {
					update = true
					alert.Id = k.Id
					alertToUpdate = k
				}
			}

			if update {

				if alertIsDifferent(alertToUpdate, alert) {
					_, err = sess.Id(alert.Id).Update(&alert)
					if err != nil {
						return err
					}

					SaveAlertChange("UPDATED", alert, sess)
				}

			} else {
				_, err = sess.Insert(&alert)
				if err != nil {
					return err
				}
				SaveAlertChange("CREATED", alert, sess)
			}
		}

		for _, missingAlert := range alerts {
			missing := true

			for _, k := range *cmd.Alerts {
				if missingAlert.PanelId == k.PanelId {
					missing = false
				}
			}

			if missing {
				_, err = sess.Exec("DELETE FROM alert_rule WHERE id = ?", missingAlert.Id)
				if err != nil {
					return err
				}

				err = SaveAlertChange("DELETED", missingAlert, sess)
				if err != nil {
					return err
				}
			}
		}

		return nil
	})
}

func GetAlertsByDashboardId2(dashboardId int64, sess *xorm.Session) ([]m.AlertRule, error) {
	alerts := make([]m.AlertRule, 0)
	err := sess.Where("dashboard_id = ?", dashboardId).Find(&alerts)

	if err != nil {
		return []m.AlertRule{}, err
	}

	return alerts, nil
}

func GetAlertsByDashboardId(dashboardId int64) ([]m.AlertRule, error) {
	alerts := make([]m.AlertRule, 0)
	err := x.Where("dashboard_id = ?", dashboardId).Find(&alerts)

	if err != nil {
		return []m.AlertRule{}, err
	}

	return alerts, nil
}

func GetAlertsByDashboardAndPanelId(dashboardId, panelId int64) (m.AlertRule, error) {
	// this code should be refactored!!
	// uniqueness should be garanted!

	alerts := make([]m.AlertRule, 0)
	err := x.Where("dashboard_id = ? and panel_id = ?", dashboardId, panelId).Find(&alerts)

	if err != nil {
		return m.AlertRule{}, err
	}

	if len(alerts) != 1 {
		return m.AlertRule{}, err
	}

	return alerts[0], nil
}

func GetAlertRuleChanges(orgid int64) ([]m.AlertRuleChange, error) {
	alertChanges := make([]m.AlertRuleChange, 0)
	err := x.Where("org_id = ?", orgid).Find(&alertChanges)

	if err != nil {
		return []m.AlertRuleChange{}, err
	}

	return alertChanges, nil
}