Chore: Introduce playlist service (grafana#52252)

* Store: Introduce playlist service

* Integrate playlist service

* Update swagger

Author: papagian

pkg/api/docs/definitions/playlists.go

@@ -2,7 +2,7 @@ package definitions
 
 import (
 	"github.com/grafana/grafana/pkg/api/dtos"
-	"github.com/grafana/grafana/pkg/models"
+	"github.com/grafana/grafana/pkg/services/playlist"
 )
 
 // swagger:route GET /playlists playlists searchPlaylists
@@ -121,7 +121,7 @@ type DeletePlaylistParams struct {
 type UpdatePlaylistParams struct {
 	// in:body
 	// required:true
-	Body models.UpdatePlaylistCommand
+	Body playlist.UpdatePlaylistCommand
 	// in:path
 	// required:true
 	UID string `json:"uid"`
@@ -131,28 +131,28 @@ type UpdatePlaylistParams struct {
 type CreatePlaylistParams struct {
 	// in:body
 	// required:true
-	Body models.CreatePlaylistCommand
+	Body playlist.CreatePlaylistCommand
 }
 
 // swagger:response searchPlaylistsResponse
 type SearchPlaylistsResponse struct {
 	// The response message
 	// in: body
-	Body models.Playlists `json:"body"`
+	Body playlist.Playlists `json:"body"`
 }
 
 // swagger:response getPlaylistResponse
 type GetPlaylistResponse struct {
 	// The response message
 	// in: body
-	Body *models.PlaylistDTO `json:"body"`
+	Body *playlist.PlaylistDTO `json:"body"`
 }
 
 // swagger:response getPlaylistItemsResponse
 type GetPlaylistItemsResponse struct {
 	// The response message
 	// in: body
-	Body []models.PlaylistItemDTO `json:"body"`
+	Body []playlist.PlaylistItemDTO `json:"body"`
 }
 
 // swagger:response getPlaylistDashboardsResponse
@@ -166,12 +166,12 @@ type GetPlaylistDashboardsResponse struct {
 type UpdatePlaylistResponseResponse struct {
 	// The response message
 	// in: body
-	Body *models.PlaylistDTO `json:"body"`
+	Body *playlist.PlaylistDTO `json:"body"`
 }
 
 // swagger:response createPlaylistResponse
 type CreatePlaylistResponse struct {
 	// The response message
 	// in: body
-	Body *models.Playlist `json:"body"`
+	Body *playlist.Playlist `json:"body"`
 }

pkg/api/http_server.go

@@ -58,6 +58,7 @@ import (
 	"github.com/grafana/grafana/pkg/services/login"
 	"github.com/grafana/grafana/pkg/services/ngalert"
 	"github.com/grafana/grafana/pkg/services/notifications"
+	"github.com/grafana/grafana/pkg/services/playlist"
 	"github.com/grafana/grafana/pkg/services/plugindashboards"
 	pluginSettings "github.com/grafana/grafana/pkg/services/pluginsettings/service"
 	pref "github.com/grafana/grafana/pkg/services/preference"
@@ -168,6 +169,7 @@ type HTTPServer struct {
 	dashboardVersionService      dashver.Service
 	PublicDashboardsApi          *publicdashboardsApi.Api
 	starService                  star.Service
+	playlistService              playlist.Service
 	CoremodelRegistry            *registry.Generic
 	CoremodelStaticRegistry      *registry.Static
 	kvStore                      kvstore.KVStore
@@ -206,7 +208,7 @@ func ProvideHTTPServer(opts ServerOptions, cfg *setting.Cfg, routeRegister routi
 	avatarCacheServer *avatar.AvatarCacheServer, preferenceService pref.Service, entityEventsService store.EntityEventsService,
 	teamsPermissionsService accesscontrol.TeamPermissionsService, folderPermissionsService accesscontrol.FolderPermissionsService,
 	dashboardPermissionsService accesscontrol.DashboardPermissionsService, dashboardVersionService dashver.Service,
-	starService star.Service, csrfService csrf.Service, coremodelRegistry *registry.Generic, coremodelStaticRegistry *registry.Static,
+	starService star.Service, playlistService playlist.Service, csrfService csrf.Service, coremodelRegistry *registry.Generic, coremodelStaticRegistry *registry.Static,
 	kvStore kvstore.KVStore, secretsMigrator secrets.Migrator, remoteSecretsCheck secretsKV.UseRemoteSecretsPluginCheck,
 	publicDashboardsApi *publicdashboardsApi.Api, userService user.Service) (*HTTPServer, error) {
 	web.Env = cfg.Env
@@ -289,6 +291,7 @@ func ProvideHTTPServer(opts ServerOptions, cfg *setting.Cfg, routeRegister routi
 		dashboardPermissionsService:  dashboardPermissionsService,
 		dashboardVersionService:      dashboardVersionService,
 		starService:                  starService,
+		playlistService:              playlistService,
 		CoremodelRegistry:            coremodelRegistry,
 		CoremodelStaticRegistry:      coremodelStaticRegistry,
 		kvStore:                      kvStore,

pkg/api/playlist.go

@@ -6,25 +6,26 @@ import (
 
 	"github.com/grafana/grafana/pkg/api/response"
 	"github.com/grafana/grafana/pkg/models"
+	"github.com/grafana/grafana/pkg/services/playlist"
 	"github.com/grafana/grafana/pkg/web"
 )
 
 func (hs *HTTPServer) ValidateOrgPlaylist(c *models.ReqContext) {
 	uid := web.Params(c.Req)[":uid"]
-	query := models.GetPlaylistByUidQuery{UID: uid, OrgId: c.OrgId}
-	err := hs.SQLStore.GetPlaylist(c.Req.Context(), &query)
+	query := playlist.GetPlaylistByUidQuery{UID: uid, OrgId: c.OrgId}
+	p, err := hs.playlistService.Get(c.Req.Context(), &query)
 
 	if err != nil {
 		c.JsonApiErr(404, "Playlist not found", err)
 		return
 	}
 
-	if query.Result.OrgId == 0 {
+	if p.OrgId == 0 {
 		c.JsonApiErr(404, "Playlist not found", err)
 		return
 	}
 
-	if query.Result.OrgId != c.OrgId {
+	if p.OrgId != c.OrgId {
 		c.JsonApiErr(403, "You are not allowed to edit/view playlist", nil)
 		return
 	}
@@ -38,53 +39,54 @@ func (hs *HTTPServer) SearchPlaylists(c *models.ReqContext) response.Response {
 		limit = 1000
 	}
 
-	searchQuery := models.GetPlaylistsQuery{
+	searchQuery := playlist.GetPlaylistsQuery{
 		Name:  query,
 		Limit: limit,
 		OrgId: c.OrgId,
 	}
 
-	err := hs.SQLStore.SearchPlaylists(c.Req.Context(), &searchQuery)
+	playlists, err := hs.playlistService.Search(c.Req.Context(), &searchQuery)
 	if err != nil {
 		return response.Error(500, "Search failed", err)
 	}
 
-	return response.JSON(http.StatusOK, searchQuery.Result)
+	return response.JSON(http.StatusOK, playlists)
 }
 
 func (hs *HTTPServer) GetPlaylist(c *models.ReqContext) response.Response {
 	uid := web.Params(c.Req)[":uid"]
-	cmd := models.GetPlaylistByUidQuery{UID: uid, OrgId: c.OrgId}
+	cmd := playlist.GetPlaylistByUidQuery{UID: uid, OrgId: c.OrgId}
 
-	if err := hs.SQLStore.GetPlaylist(c.Req.Context(), &cmd); err != nil {
+	p, err := hs.playlistService.Get(c.Req.Context(), &cmd)
+	if err != nil {
 		return response.Error(500, "Playlist not found", err)
 	}
 
 	playlistDTOs, _ := hs.LoadPlaylistItemDTOs(c.Req.Context(), uid, c.OrgId)
 
-	dto := &models.PlaylistDTO{
-		Id:       cmd.Result.Id,
-		UID:      cmd.Result.UID,
-		Name:     cmd.Result.Name,
-		Interval: cmd.Result.Interval,
-		OrgId:    cmd.Result.OrgId,
+	dto := &playlist.PlaylistDTO{
+		Id:       p.Id,
+		UID:      p.UID,
+		Name:     p.Name,
+		Interval: p.Interval,
+		OrgId:    p.OrgId,
 		Items:    playlistDTOs,
 	}
 
 	return response.JSON(http.StatusOK, dto)
 }
 
-func (hs *HTTPServer) LoadPlaylistItemDTOs(ctx context.Context, uid string, orgId int64) ([]models.PlaylistItemDTO, error) {
+func (hs *HTTPServer) LoadPlaylistItemDTOs(ctx context.Context, uid string, orgId int64) ([]playlist.PlaylistItemDTO, error) {
 	playlistitems, err := hs.LoadPlaylistItems(ctx, uid, orgId)
 
 	if err != nil {
 		return nil, err
 	}
 
-	playlistDTOs := make([]models.PlaylistItemDTO, 0)
+	playlistDTOs := make([]playlist.PlaylistItemDTO, 0)
 
 	for _, item := range playlistitems {
-		playlistDTOs = append(playlistDTOs, models.PlaylistItemDTO{
+		playlistDTOs = append(playlistDTOs, playlist.PlaylistItemDTO{
 			Id:         item.Id,
 			PlaylistId: item.PlaylistId,
 			Type:       item.Type,
@@ -97,13 +99,14 @@ func (hs *HTTPServer) LoadPlaylistItemDTOs(ctx context.Context, uid string, orgI
 	return playlistDTOs, nil
 }
 
-func (hs *HTTPServer) LoadPlaylistItems(ctx context.Context, uid string, orgId int64) ([]models.PlaylistItem, error) {
-	itemQuery := models.GetPlaylistItemsByUidQuery{PlaylistUID: uid, OrgId: orgId}
-	if err := hs.SQLStore.GetPlaylistItem(ctx, &itemQuery); err != nil {
+func (hs *HTTPServer) LoadPlaylistItems(ctx context.Context, uid string, orgId int64) ([]playlist.PlaylistItem, error) {
+	itemQuery := playlist.GetPlaylistItemsByUidQuery{PlaylistUID: uid, OrgId: orgId}
+	items, err := hs.playlistService.GetItems(ctx, &itemQuery)
+	if err != nil {
 		return nil, err
 	}
 
-	return *itemQuery.Result, nil
+	return items, nil
 }
 
 func (hs *HTTPServer) GetPlaylistItems(c *models.ReqContext) response.Response {
@@ -132,37 +135,39 @@ func (hs *HTTPServer) GetPlaylistDashboards(c *models.ReqContext) response.Respo
 func (hs *HTTPServer) DeletePlaylist(c *models.ReqContext) response.Response {
 	uid := web.Params(c.Req)[":uid"]
 
-	cmd := models.DeletePlaylistCommand{UID: uid, OrgId: c.OrgId}
-	if err := hs.SQLStore.DeletePlaylist(c.Req.Context(), &cmd); err != nil {
+	cmd := playlist.DeletePlaylistCommand{UID: uid, OrgId: c.OrgId}
+	if err := hs.playlistService.Delete(c.Req.Context(), &cmd); err != nil {
 		return response.Error(500, "Failed to delete playlist", err)
 	}
 
 	return response.JSON(http.StatusOK, "")
 }
 
 func (hs *HTTPServer) CreatePlaylist(c *models.ReqContext) response.Response {
-	cmd := models.CreatePlaylistCommand{}
+	cmd := playlist.CreatePlaylistCommand{}
 	if err := web.Bind(c.Req, &cmd); err != nil {
 		return response.Error(http.StatusBadRequest, "bad request data", err)
 	}
 	cmd.OrgId = c.OrgId
 
-	if err := hs.SQLStore.CreatePlaylist(c.Req.Context(), &cmd); err != nil {
+	p, err := hs.playlistService.Create(c.Req.Context(), &cmd)
+	if err != nil {
 		return response.Error(500, "Failed to create playlist", err)
 	}
 
-	return response.JSON(http.StatusOK, cmd.Result)
+	return response.JSON(http.StatusOK, p)
 }
 
 func (hs *HTTPServer) UpdatePlaylist(c *models.ReqContext) response.Response {
-	cmd := models.UpdatePlaylistCommand{}
+	cmd := playlist.UpdatePlaylistCommand{}
 	if err := web.Bind(c.Req, &cmd); err != nil {
 		return response.Error(http.StatusBadRequest, "bad request data", err)
 	}
 	cmd.OrgId = c.OrgId
 	cmd.UID = web.Params(c.Req)[":uid"]
 
-	if err := hs.SQLStore.UpdatePlaylist(c.Req.Context(), &cmd); err != nil {
+	p, err := hs.playlistService.Update(c.Req.Context(), &cmd)
+	if err != nil {
 		return response.Error(500, "Failed to save playlist", err)
 	}
 
@@ -171,6 +176,6 @@ func (hs *HTTPServer) UpdatePlaylist(c *models.ReqContext) response.Response {
 		return response.Error(500, "Failed to save playlist", err)
 	}
 
-	cmd.Result.Items = playlistDTOs
-	return response.JSON(http.StatusOK, cmd.Result)
+	p.Items = playlistDTOs
+	return response.JSON(http.StatusOK, p)
 }

pkg/server/wire.go

@@ -6,6 +6,7 @@ package server
 import (
 	"github.com/google/wire"
 	sdkhttpclient "github.com/grafana/grafana-plugin-sdk-go/backend/httpclient"
+	"github.com/grafana/grafana/pkg/services/playlist/playlistimpl"
 	"github.com/grafana/grafana/pkg/services/store/sanitizer"
 
 	"github.com/grafana/grafana/pkg/api"
@@ -286,6 +287,7 @@ var wireBasicSet = wire.NewSet(
 	ossaccesscontrol.ProvideDashboardPermissions,
 	wire.Bind(new(accesscontrol.DashboardPermissionsService), new(*ossaccesscontrol.DashboardPermissionsService)),
 	starimpl.ProvideService,
+	playlistimpl.ProvideService,
 	dashverimpl.ProvideService,
 	publicdashboardsService.ProvideService,
 	wire.Bind(new(publicdashboards.Service), new(*publicdashboardsService.PublicDashboardServiceImpl)),

pkg/services/playlist/model.go

@@ -0,0 +1,95 @@
+package playlist
+
+import (
+	"errors"
+)
+
+// Typed errors
+var (
+	ErrPlaylistNotFound                = errors.New("Playlist not found")
+	ErrPlaylistFailedGenerateUniqueUid = errors.New("failed to generate unique playlist UID")
+	ErrCommandValidationFailed         = errors.New("command missing required fields")
+)
+
+// Playlist model
+type Playlist struct {
+	Id       int64  `json:"id"`
+	UID      string `json:"uid" xorm:"uid"`
+	Name     string `json:"name"`
+	Interval string `json:"interval"`
+	OrgId    int64  `json:"-"`
+}
+
+type PlaylistDTO struct {
+	Id       int64             `json:"id"`
+	UID      string            `json:"uid"`
+	Name     string            `json:"name"`
+	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 PlaylistItem struct {
+	Id         int64
+	PlaylistId int64
+	Type       string
+	Value      string
+	Order      int
+	Title      string
+}
+
+type Playlists []*Playlist
+
+//
+// COMMANDS
+//
+
+type UpdatePlaylistCommand struct {
+	OrgId    int64             `json:"-"`
+	UID      string            `json:"uid"`
+	Name     string            `json:"name" binding:"Required"`
+	Interval string            `json:"interval"`
+	Items    []PlaylistItemDTO `json:"items"`
+}
+
+type CreatePlaylistCommand struct {
+	Name     string            `json:"name" binding:"Required"`
+	Interval string            `json:"interval"`
+	Items    []PlaylistItemDTO `json:"items"`
+
+	OrgId int64 `json:"-"`
+}
+
+type DeletePlaylistCommand struct {
+	UID   string
+	OrgId int64
+}
+
+//
+// QUERIES
+//
+
+type GetPlaylistsQuery struct {
+	Name  string
+	Limit int
+	OrgId int64
+}
+
+type GetPlaylistByUidQuery struct {
+	UID   string
+	OrgId int64
+}
+
+type GetPlaylistItemsByUidQuery struct {
+	PlaylistUID string
+	OrgId       int64
+}