grafana/pkg/services/sqlstore/dashboard.go

198 lines
4.3 KiB
Go
Raw Normal View History

2014-12-22 05:25:08 -06:00
package sqlstore
import (
"bytes"
"fmt"
2014-12-22 05:25:08 -06:00
"github.com/go-xorm/xorm"
2015-02-05 03:37:13 -06:00
"github.com/grafana/grafana/pkg/bus"
2015-03-22 14:14:00 -05:00
"github.com/grafana/grafana/pkg/metrics"
2015-02-05 03:37:13 -06:00
m "github.com/grafana/grafana/pkg/models"
2014-12-22 05:25:08 -06:00
)
func init() {
bus.AddHandler("sql", SaveDashboard)
bus.AddHandler("sql", GetDashboard)
bus.AddHandler("sql", DeleteDashboard)
bus.AddHandler("sql", SearchDashboards)
bus.AddHandler("sql", GetDashboardTags)
2014-12-22 05:25:08 -06:00
}
func SaveDashboard(cmd *m.SaveDashboardCommand) error {
2014-12-22 05:25:08 -06:00
return inTransaction(func(sess *xorm.Session) error {
dash := cmd.GetDashboardModel()
// try get existing dashboard
existing := m.Dashboard{Slug: dash.Slug, OrgId: dash.OrgId}
hasExisting, err := sess.Get(&existing)
if err != nil {
return err
}
if hasExisting {
// another dashboard with same name
if dash.Id != existing.Id {
if cmd.Overwrite {
dash.Id = existing.Id
} else {
return m.ErrDashboardWithSameNameExists
}
}
// check for is someone else has written in between
if dash.Version != existing.Version {
if cmd.Overwrite {
dash.Version = existing.Version
} else {
return m.ErrDashboardVersionMismatch
}
}
}
2014-12-22 05:25:08 -06:00
if dash.Id == 0 {
2015-03-22 14:14:00 -05:00
metrics.M_Models_Dashboard_Insert.Inc(1)
2014-12-22 05:25:08 -06:00
_, err = sess.Insert(dash)
} else {
dash.Version += 1
dash.Data["version"] = dash.Version
2014-12-22 05:25:08 -06:00
_, err = sess.Id(dash.Id).Update(dash)
}
// delete existing tabs
_, err = sess.Exec("DELETE FROM dashboard_tag WHERE dashboard_id=?", dash.Id)
if err != nil {
return err
}
// insert new tags
tags := dash.GetTags()
if len(tags) > 0 {
for _, tag := range tags {
if _, err := sess.Insert(&DashboardTag{DashboardId: dash.Id, Term: tag}); err != nil {
return err
}
}
}
2014-12-22 05:25:08 -06:00
cmd.Result = dash
return err
})
}
func GetDashboard(query *m.GetDashboardQuery) error {
dashboard := m.Dashboard{Slug: query.Slug, OrgId: query.OrgId}
2014-12-22 05:25:08 -06:00
has, err := x.Get(&dashboard)
if err != nil {
return err
2014-12-22 05:25:08 -06:00
} else if has == false {
return m.ErrDashboardNotFound
2014-12-22 05:25:08 -06:00
}
dashboard.Data["id"] = dashboard.Id
query.Result = &dashboard
return nil
2014-12-22 05:25:08 -06:00
}
type DashboardSearchProjection struct {
Id int64
Title string
Slug string
Term string
}
func SearchDashboards(query *m.SearchDashboardsQuery) error {
var sql bytes.Buffer
params := make([]interface{}, 0)
sql.WriteString(`SELECT
dashboard.id,
dashboard.title,
dashboard.slug,
dashboard_tag.term
FROM dashboard
LEFT OUTER JOIN dashboard_tag on dashboard_tag.dashboard_id = dashboard.id`)
if query.IsStarred {
sql.WriteString(" INNER JOIN star on star.dashboard_id = dashboard.id")
}
sql.WriteString(` WHERE dashboard.org_id=?`)
params = append(params, query.OrgId)
2015-01-06 10:15:52 -06:00
if query.IsStarred {
sql.WriteString(` AND star.user_id=?`)
params = append(params, query.UserId)
}
if len(query.Title) > 0 {
sql.WriteString(" AND dashboard.title LIKE ?")
params = append(params, "%"+query.Title+"%")
}
2014-12-22 05:25:08 -06:00
if len(query.Tag) > 0 {
sql.WriteString(" AND dashboard_tag.term=?")
params = append(params, query.Tag)
}
2015-02-05 08:53:15 -06:00
if query.Limit == 0 || query.Limit > 10000 {
query.Limit = 300
}
sql.WriteString(fmt.Sprintf(" ORDER BY dashboard.title ASC LIMIT %d", query.Limit))
var res []DashboardSearchProjection
err := x.Sql(sql.String(), params...).Find(&res)
if err != nil {
return err
}
query.Result = make([]*m.DashboardSearchHit, 0)
hits := make(map[int64]*m.DashboardSearchHit)
for _, item := range res {
hit, exists := hits[item.Id]
if !exists {
hit = &m.DashboardSearchHit{
2015-02-02 10:17:57 -06:00
Id: item.Id,
Title: item.Title,
Slug: item.Slug,
Tags: []string{},
}
query.Result = append(query.Result, hit)
hits[item.Id] = hit
}
if len(item.Term) > 0 {
hit.Tags = append(hit.Tags, item.Term)
}
}
2014-12-22 05:25:08 -06:00
return err
2014-12-22 05:25:08 -06:00
}
func GetDashboardTags(query *m.GetDashboardTagsQuery) error {
2015-01-20 08:23:14 -06:00
sql := `SELECT
COUNT(*) as count,
term
FROM dashboard
INNER JOIN dashboard_tag on dashboard_tag.dashboard_id = dashboard.id
WHERE dashboard.org_id=?
2015-01-20 08:23:14 -06:00
GROUP BY term`
query.Result = make([]*m.DashboardTagCloudItem, 0)
sess := x.Sql(sql, query.OrgId)
err := sess.Find(&query.Result)
return err
}
func DeleteDashboard(cmd *m.DeleteDashboardCommand) error {
2014-12-22 05:25:08 -06:00
sess := x.NewSession()
defer sess.Close()
rawSql := "DELETE FROM dashboard WHERE org_id=? and slug=?"
_, err := sess.Exec(rawSql, cmd.OrgId, cmd.Slug)
2014-12-22 05:25:08 -06:00
return err
}