Merge pull request #3655 from grafana/playlist

Persistable playlists

closes #515
closes #1137

pkg/api/api.go

@@ -47,6 +47,9 @@ func Register(r *macaron.Macaron) {
 	r.Get("/dashboard/*", reqSignedIn, Index)
 	r.Get("/dashboard-solo/*", reqSignedIn, Index)
 
+	r.Get("/playlists/", reqSignedIn, Index)
+	r.Get("/playlists/*", reqSignedIn, Index)
+
 	// sign up
 	r.Get("/signup", Index)
 	r.Get("/api/user/signup/options", wrap(GetSignUpOptions))
@@ -169,6 +172,17 @@ func Register(r *macaron.Macaron) {
 			r.Get("/tags", GetDashboardTags)
 		})
 
+		// Playlist
+		r.Group("/playlists", func() {
+			r.Get("/", wrap(SearchPlaylists))
+			r.Get("/:id", ValidateOrgPlaylist, wrap(GetPlaylist))
+			r.Get("/:id/items", ValidateOrgPlaylist, wrap(GetPlaylistItems))
+			r.Get("/:id/dashboards", ValidateOrgPlaylist, wrap(GetPlaylistDashboards))
+			r.Delete("/:id", reqEditorRole, ValidateOrgPlaylist, wrap(DeletePlaylist))
+			r.Put("/:id", reqEditorRole, bind(m.UpdatePlaylistQuery{}), ValidateOrgPlaylist, wrap(UpdatePlaylist))
+			r.Post("/", reqEditorRole, bind(m.CreatePlaylistQuery{}), wrap(CreatePlaylist))
+		})
+
 		// Search
 		r.Get("/search/", Search)
 

pkg/api/index.go

@@ -53,6 +53,12 @@ func setIndexViewData(c *middleware.Context) (*dtos.IndexViewData, error) {
 		Href: "/",
 	})
 
+	data.MainNavLinks = append(data.MainNavLinks, &dtos.NavLink{
+		Text: "Playlists",
+		Icon: "fa fa-fw fa-list",
+		Href: "/playlists",
+	})
+
 	if c.OrgRole == m.ROLE_ADMIN {
 		data.MainNavLinks = append(data.MainNavLinks, &dtos.NavLink{
 			Text: "Data Sources",

pkg/api/playlist.go

@@ -0,0 +1,194 @@
+package api
+
+import (
+	"errors"
+	"github.com/grafana/grafana/pkg/bus"
+	"github.com/grafana/grafana/pkg/log"
+	"github.com/grafana/grafana/pkg/middleware"
+	m "github.com/grafana/grafana/pkg/models"
+	"strconv"
+)
+
+func ValidateOrgPlaylist(c *middleware.Context) {
+	id := c.ParamsInt64(":id")
+	query := m.GetPlaylistByIdQuery{Id: id}
+	err := bus.Dispatch(&query)
+
+	if err != nil {
+		c.JsonApiErr(404, "Playlist not found", err)
+		return
+	}
+
+	if query.Result.OrgId != c.OrgId {
+		c.JsonApiErr(403, "You are not allowed to edit/view playlist", nil)
+		return
+	}
+}
+
+func SearchPlaylists(c *middleware.Context) Response {
+	query := c.Query("query")
+	limit := c.QueryInt("limit")
+
+	if limit == 0 {
+		limit = 1000
+	}
+
+	searchQuery := m.PlaylistQuery{
+		Title: query,
+		Limit: limit,
+		OrgId: c.OrgId,
+	}
+
+	err := bus.Dispatch(&searchQuery)
+	if err != nil {
+		return ApiError(500, "Search failed", err)
+	}
+
+	return Json(200, searchQuery.Result)
+}
+
+func GetPlaylist(c *middleware.Context) Response {
+	id := c.ParamsInt64(":id")
+	cmd := m.GetPlaylistByIdQuery{Id: id}
+
+	if err := bus.Dispatch(&cmd); err != nil {
+		return ApiError(500, "Playlist not found", err)
+	}
+
+	playlistDTOs, _ := LoadPlaylistItemDTOs(id)
+
+	dto := &m.PlaylistDTO{
+		Id:       cmd.Result.Id,
+		Title:    cmd.Result.Title,
+		Interval: cmd.Result.Interval,
+		OrgId:    cmd.Result.OrgId,
+		Items:    playlistDTOs,
+	}
+
+	return Json(200, dto)
+}
+
+func LoadPlaylistItemDTOs(id int64) ([]m.PlaylistItemDTO, error) {
+	playlistitems, err := LoadPlaylistItems(id)
+
+	if err != nil {
+		return nil, err
+	}
+
+	playlistDTOs := make([]m.PlaylistItemDTO, 0)
+
+	for _, item := range playlistitems {
+		playlistDTOs = append(playlistDTOs, m.PlaylistItemDTO{
+			Id:         item.Id,
+			PlaylistId: item.PlaylistId,
+			Type:       item.Type,
+			Value:      item.Value,
+			Order:      item.Order,
+			Title:      item.Title,
+		})
+	}
+
+	return playlistDTOs, nil
+}
+
+func LoadPlaylistItems(id int64) ([]m.PlaylistItem, error) {
+	itemQuery := m.GetPlaylistItemsByIdQuery{PlaylistId: id}
+	if err := bus.Dispatch(&itemQuery); err != nil {
+		return nil, err
+	}
+
+	return *itemQuery.Result, nil
+}
+
+func LoadPlaylistDashboards(id int64) ([]m.PlaylistDashboardDto, error) {
+	playlistItems, _ := LoadPlaylistItems(id)
+
+	dashboardIds := make([]int64, 0)
+
+	for _, i := range playlistItems {
+		dashboardId, _ := strconv.ParseInt(i.Value, 10, 64)
+		dashboardIds = append(dashboardIds, dashboardId)
+	}
+
+	if len(dashboardIds) == 0 {
+		return make([]m.PlaylistDashboardDto, 0), nil
+	}
+
+	dashboardQuery := m.GetPlaylistDashboardsQuery{DashboardIds: dashboardIds}
+	if err := bus.Dispatch(&dashboardQuery); err != nil {
+		log.Warn("dashboardquery failed: %v", err)
+		return nil, errors.New("Playlist not found")
+	}
+
+	dtos := make([]m.PlaylistDashboardDto, 0)
+	for _, item := range *dashboardQuery.Result {
+		dtos = append(dtos, m.PlaylistDashboardDto{
+			Id:    item.Id,
+			Slug:  item.Slug,
+			Title: item.Title,
+			Uri:   "db/" + item.Slug,
+		})
+	}
+
+	return dtos, nil
+}
+
+func GetPlaylistItems(c *middleware.Context) Response {
+	id := c.ParamsInt64(":id")
+
+	playlistDTOs, err := LoadPlaylistItemDTOs(id)
+
+	if err != nil {
+		return ApiError(500, "Could not load playlist items", err)
+	}
+
+	return Json(200, playlistDTOs)
+}
+
+func GetPlaylistDashboards(c *middleware.Context) Response {
+	id := c.ParamsInt64(":id")
+
+	playlists, err := LoadPlaylistDashboards(id)
+	if err != nil {
+		return ApiError(500, "Could not load dashboards", err)
+	}
+
+	return Json(200, playlists)
+}
+
+func DeletePlaylist(c *middleware.Context) Response {
+	id := c.ParamsInt64(":id")
+
+	cmd := m.DeletePlaylistQuery{Id: id}
+	if err := bus.Dispatch(&cmd); err != nil {
+		return ApiError(500, "Failed to delete playlist", err)
+	}
+
+	return Json(200, "")
+}
+
+func CreatePlaylist(c *middleware.Context, query m.CreatePlaylistQuery) Response {
+	query.OrgId = c.OrgId
+	err := bus.Dispatch(&query)
+	if err != nil {
+		return ApiError(500, "Failed to create playlist", err)
+	}
+
+	return Json(200, query.Result)
+}
+
+func UpdatePlaylist(c *middleware.Context, query m.UpdatePlaylistQuery) Response {
+	err := bus.Dispatch(&query)
+	if err != nil {
+		return ApiError(500, "Failed to save playlist", err)
+	}
+
+	playlistDTOs, err := LoadPlaylistItemDTOs(query.Id)
+	if err != nil {
+		return ApiError(500, "Failed to save playlist", err)
+	}
+
+	query.Result.Items = playlistDTOs
+
+	return Json(200, query.Result)
+}

pkg/models/playlist.go

@@ -0,0 +1,120 @@
+package models
+
+import (
+	"errors"
+)
+
+// Typed errors
+var (
+	ErrPlaylistNotFound           = errors.New("Playlist not found")
+	ErrPlaylistWithSameNameExists = errors.New("A playlist with the same name already exists")
+)
+
+// Playlist model
+type Playlist struct {
+	Id       int64  `json:"id"`
+	Title    string `json:"title"`
+	Interval string `json:"interval"`
+	OrgId    int64  `json:"-"`
+}
+
+type PlaylistDTO struct {
+	Id       int64             `json:"id"`
+	Title    string            `json:"title"`
+	Interval string            `json:"interval"`
+	OrgId    int64             `json:"-"`
+	Items    []PlaylistItemDTO `json:"items"`
+}
+
+type PlaylistItemDTO struct {
+	Id         int64  `json:"id"`
+	PlaylistId int64  `json:"playlistid"`
+	Type       string `json:"type"`
+	Title      string `json:"title"`
+	Value      string `json:"value"`
+	Order      int    `json:"order"`
+}
+
+type PlaylistDashboard struct {
+	Id    int64  `json:"id"`
+	Slug  string `json:"slug"`
+	Title string `json:"title"`
+}
+
+type PlaylistItem struct {
+	Id         int64
+	PlaylistId int64
+	Type       string
+	Value      string
+	Order      int
+	Title      string
+}
+
+func (this PlaylistDashboard) TableName() string {
+	return "dashboard"
+}
+
+type Playlists []*Playlist
+type PlaylistDashboards []*PlaylistDashboard
+
+//
+// DTOS
+//
+
+type PlaylistDashboardDto struct {
+	Id    int64  `json:"id"`
+	Slug  string `json:"slug"`
+	Title string `json:"title"`
+	Uri   string `json:"uri"`
+}
+
+//
+// COMMANDS
+//
+type PlaylistQuery struct {
+	Title string
+	Limit int
+	OrgId int64
+
+	Result Playlists
+}
+
+type UpdatePlaylistQuery struct {
+	Id       int64
+	Title    string
+	Type     string
+	Interval string
+	Items    []PlaylistItemDTO
+
+	Result *PlaylistDTO
+}
+
+type CreatePlaylistQuery struct {
+	Title    string
+	Type     string
+	Interval string
+	Data     []int64
+	OrgId    int64
+	Items    []PlaylistItemDTO
+
+	Result *Playlist
+}
+
+type GetPlaylistByIdQuery struct {
+	Id     int64
+	Result *Playlist
+}
+
+type GetPlaylistItemsByIdQuery struct {
+	PlaylistId int64
+	Result     *[]PlaylistItem
+}
+
+type GetPlaylistDashboardsQuery struct {
+	DashboardIds []int64
+	Result       *PlaylistDashboards
+}
+
+type DeletePlaylistQuery struct {
+	Id int64
+}

pkg/services/sqlstore/migrations/migrations.go

@@ -20,6 +20,7 @@ func AddMigrations(mg *Migrator) {
 	addQuotaMigration(mg)
 	addPluginBundleMigration(mg)
 	addSessionMigration(mg)
+	addPlaylistMigrations(mg)
 }
 
 func addMigrationLogMigrations(mg *Migrator) {

pkg/services/sqlstore/migrations/playlist_mig.go

@@ -0,0 +1,32 @@
+package migrations
+
+import . "github.com/grafana/grafana/pkg/services/sqlstore/migrator"
+
+func addPlaylistMigrations(mg *Migrator) {
+	playlistV1 := Table{
+		Name: "playlist",
+		Columns: []*Column{
+			{Name: "id", Type: DB_BigInt, IsPrimaryKey: true, IsAutoIncrement: true},
+			{Name: "title", Type: DB_NVarchar, Length: 255, Nullable: false},
+			{Name: "interval", Type: DB_NVarchar, Length: 255, Nullable: false},
+			{Name: "org_id", Type: DB_BigInt, Nullable: false},
+		},
+	}
+
+	// create table
+	mg.AddMigration("create playlist table v1", NewAddTableMigration(playlistV1))
+
+	playlistItemV1 := Table{
+		Name: "playlist_item",
+		Columns: []*Column{
+			{Name: "id", Type: DB_BigInt, IsPrimaryKey: true, IsAutoIncrement: true},
+			{Name: "playlist_id", Type: DB_BigInt, Nullable: false},
+			{Name: "type", Type: DB_NVarchar, Length: 255, Nullable: false},
+			{Name: "value", Type: DB_Text, Nullable: false},
+			{Name: "title", Type: DB_Text, Nullable: false},
+			{Name: "order", Type: DB_Int, Nullable: false},
+		},
+	}
+
+	mg.AddMigration("create playlist item table v1", NewAddTableMigration(playlistItemV1))
+}

pkg/services/sqlstore/playlist.go

@@ -0,0 +1,180 @@
+package sqlstore
+
+import (
+	"fmt"
+	"github.com/go-xorm/xorm"
+
+	"github.com/grafana/grafana/pkg/bus"
+	m "github.com/grafana/grafana/pkg/models"
+)
+
+func init() {
+	bus.AddHandler("sql", CreatePlaylist)
+	bus.AddHandler("sql", UpdatePlaylist)
+	bus.AddHandler("sql", DeletePlaylist)
+	bus.AddHandler("sql", SearchPlaylists)
+	bus.AddHandler("sql", GetPlaylist)
+	bus.AddHandler("sql", GetPlaylistDashboards)
+	bus.AddHandler("sql", GetPlaylistItem)
+}
+
+func CreatePlaylist(query *m.CreatePlaylistQuery) error {
+	var err error
+
+	playlist := m.Playlist{
+		Title:    query.Title,
+		Interval: query.Interval,
+		OrgId:    query.OrgId,
+	}
+
+	_, err = x.Insert(&playlist)
+
+	fmt.Printf("%v", playlist.Id)
+
+	playlistItems := make([]m.PlaylistItem, 0)
+	for _, item := range query.Items {
+		playlistItems = append(playlistItems, m.PlaylistItem{
+			PlaylistId: playlist.Id,
+			Type:       item.Type,
+			Value:      item.Value,
+			Order:      item.Order,
+			Title:      item.Title,
+		})
+	}
+
+	_, err = x.Insert(&playlistItems)
+
+	query.Result = &playlist
+	return err
+}
+
+func UpdatePlaylist(query *m.UpdatePlaylistQuery) error {
+	var err error
+	x.Logger.SetLevel(5)
+	playlist := m.Playlist{
+		Id:       query.Id,
+		Title:    query.Title,
+		Interval: query.Interval,
+	}
+
+	existingPlaylist := x.Where("id = ?", query.Id).Find(m.Playlist{})
+
+	if existingPlaylist == nil {
+		return m.ErrPlaylistNotFound
+	}
+
+	query.Result = &m.PlaylistDTO{
+		Id:       playlist.Id,
+		OrgId:    playlist.OrgId,
+		Title:    playlist.Title,
+		Interval: playlist.Interval,
+	}
+
+	_, err = x.Id(query.Id).Cols("id", "title", "timespan").Update(&playlist)
+
+	if err != nil {
+		return err
+	}
+
+	rawSql := "DELETE FROM playlist_item WHERE playlist_id = ?"
+	_, err = x.Exec(rawSql, query.Id)
+
+	if err != nil {
+		return err
+	}
+
+	playlistItems := make([]m.PlaylistItem, 0)
+
+	for _, item := range query.Items {
+		playlistItems = append(playlistItems, m.PlaylistItem{
+			PlaylistId: playlist.Id,
+			Type:       item.Type,
+			Value:      item.Value,
+			Order:      item.Order,
+			Title:      item.Title,
+		})
+	}
+
+	_, err = x.Insert(&playlistItems)
+
+	return err
+}
+
+func GetPlaylist(query *m.GetPlaylistByIdQuery) error {
+	if query.Id == 0 {
+		return m.ErrCommandValidationFailed
+	}
+
+	playlist := m.Playlist{}
+	_, err := x.Id(query.Id).Get(&playlist)
+
+	query.Result = &playlist
+
+	return err
+}
+
+func DeletePlaylist(query *m.DeletePlaylistQuery) error {
+	if query.Id == 0 {
+		return m.ErrCommandValidationFailed
+	}
+
+	return inTransaction(func(sess *xorm.Session) error {
+		var rawPlaylistSql = "DELETE FROM playlist WHERE id = ?"
+		_, err := sess.Exec(rawPlaylistSql, query.Id)
+
+		if err != nil {
+			return err
+		}
+
+		var rawItemSql = "DELETE FROM playlist_item WHERE playlist_id = ?"
+		_, err2 := sess.Exec(rawItemSql, query.Id)
+
+		return err2
+	})
+}
+
+func SearchPlaylists(query *m.PlaylistQuery) error {
+	var playlists = make(m.Playlists, 0)
+
+	sess := x.Limit(query.Limit)
+
+	if query.Title != "" {
+		sess.Where("title LIKE ?", query.Title)
+	}
+
+	sess.Where("org_id = ?", query.OrgId)
+	err := sess.Find(&playlists)
+	query.Result = playlists
+
+	return err
+}
+
+func GetPlaylistItem(query *m.GetPlaylistItemsByIdQuery) error {
+	if query.PlaylistId == 0 {
+		return m.ErrCommandValidationFailed
+	}
+
+	var playlistItems = make([]m.PlaylistItem, 0)
+	err := x.Where("playlist_id=?", query.PlaylistId).Find(&playlistItems)
+
+	query.Result = &playlistItems
+
+	return err
+}
+
+func GetPlaylistDashboards(query *m.GetPlaylistDashboardsQuery) error {
+	if len(query.DashboardIds) == 0 {
+		return m.ErrCommandValidationFailed
+	}
+
+	var dashboards = make(m.PlaylistDashboards, 0)
+
+	err := x.In("id", query.DashboardIds).Find(&dashboards)
+	query.Result = &dashboards
+
+	if err != nil {
+		return err
+	}
+
+	return nil
+}