Chore: Move dashboard models to dashboard pkg (#61458)

* Copy dashboard models to dashboard pkg

* Use some models from current pkg instead of models

* Adjust api pkg

* Adjust pkg services

* Fix lint

pkg/api/annotations.go

@@ -50,7 +50,7 @@ func (hs *HTTPServer) GetAnnotations(c *models.ReqContext) response.Response {
 
 	// When dashboard UID present in the request, we ignore dashboard ID
 	if query.DashboardUid != "" {
-		dq := models.GetDashboardQuery{Uid: query.DashboardUid, OrgId: c.OrgID}
+		dq := dashboards.GetDashboardQuery{UID: query.DashboardUid, OrgID: c.OrgID}
 		err := hs.DashboardService.GetDashboard(c.Req.Context(), &dq)
 		if err != nil {
 			if hs.Features.IsEnabled(featuremgmt.FlagDashboardsFromStorage) {
@@ -59,7 +59,7 @@ func (hs *HTTPServer) GetAnnotations(c *models.ReqContext) response.Response {
 				return response.Error(http.StatusBadRequest, "Invalid dashboard UID in annotation request", err)
 			}
 		} else {
-			query.DashboardId = dq.Result.Id
+			query.DashboardId = dq.Result.ID
 		}
 	}
 
@@ -79,11 +79,11 @@ func (hs *HTTPServer) GetAnnotations(c *models.ReqContext) response.Response {
 			if val, ok := dashboardCache[item.DashboardId]; ok {
 				item.DashboardUID = val
 			} else {
-				query := models.GetDashboardQuery{Id: item.DashboardId, OrgId: c.OrgID}
+				query := dashboards.GetDashboardQuery{ID: item.DashboardId, OrgID: c.OrgID}
 				err := hs.DashboardService.GetDashboard(c.Req.Context(), &query)
 				if err == nil && query.Result != nil {
-					item.DashboardUID = &query.Result.Uid
-					dashboardCache[item.DashboardId] = &query.Result.Uid
+					item.DashboardUID = &query.Result.UID
+					dashboardCache[item.DashboardId] = &query.Result.UID
 				}
 			}
 		}
@@ -122,10 +122,10 @@ func (hs *HTTPServer) PostAnnotation(c *models.ReqContext) response.Response {
 
 	// overwrite dashboardId when dashboardUID is not empty
 	if cmd.DashboardUID != "" {
-		query := models.GetDashboardQuery{OrgId: c.OrgID, Uid: cmd.DashboardUID}
+		query := dashboards.GetDashboardQuery{OrgID: c.OrgID, UID: cmd.DashboardUID}
 		err := hs.DashboardService.GetDashboard(c.Req.Context(), &query)
 		if err == nil {
-			cmd.DashboardId = query.Result.Id
+			cmd.DashboardId = query.Result.ID
 		}
 	}
 
@@ -379,10 +379,10 @@ func (hs *HTTPServer) MassDeleteAnnotations(c *models.ReqContext) response.Respo
 	}
 
 	if cmd.DashboardUID != "" {
-		query := models.GetDashboardQuery{OrgId: c.OrgID, Uid: cmd.DashboardUID}
+		query := dashboards.GetDashboardQuery{OrgID: c.OrgID, UID: cmd.DashboardUID}
 		err := hs.DashboardService.GetDashboard(c.Req.Context(), &query)
 		if err == nil {
-			cmd.DashboardId = query.Result.Id
+			cmd.DashboardId = query.Result.ID
 		}
 	}
 

pkg/api/annotations_test.go

@@ -227,11 +227,11 @@ func TestAnnotationsAPIEndpoint(t *testing.T) {
 
 			t.Run("Should be able to do anything", func(t *testing.T) {
 				dashSvc := dashboards.NewFakeDashboardService(t)
-				dashSvc.On("GetDashboard", mock.Anything, mock.AnythingOfType("*models.GetDashboardQuery")).Run(func(args mock.Arguments) {
-					q := args.Get(1).(*models.GetDashboardQuery)
-					q.Result = &models.Dashboard{
-						Id:  q.Id,
-						Uid: q.Uid,
+				dashSvc.On("GetDashboard", mock.Anything, mock.AnythingOfType("*dashboards.GetDashboardQuery")).Run(func(args mock.Arguments) {
+					q := args.Get(1).(*dashboards.GetDashboardQuery)
+					q.Result = &dashboards.Dashboard{
+						ID:  q.ID,
+						UID: q.UID,
 					}
 				}).Return(nil)
 				postAnnotationScenario(t, "When calling POST on", "/api/annotations", "/api/annotations", role, cmd, store, dashSvc, func(sc *scenarioContext) {
@@ -244,7 +244,7 @@ func TestAnnotationsAPIEndpoint(t *testing.T) {
 					setUpACL()
 					sc.fakeReqWithParams("POST", sc.url, map[string]string{}).exec()
 					assert.Equal(t, 200, sc.resp.Code)
-					dashSvc.AssertCalled(t, "GetDashboard", mock.Anything, mock.AnythingOfType("*models.GetDashboardQuery"))
+					dashSvc.AssertCalled(t, "GetDashboard", mock.Anything, mock.AnythingOfType("*dashboards.GetDashboardQuery"))
 				})
 
 				putAnnotationScenario(t, "When calling PUT on", "/api/annotations/1", "/api/annotations/:annotationId", role, updateCmd, func(sc *scenarioContext) {
@@ -267,11 +267,11 @@ func TestAnnotationsAPIEndpoint(t *testing.T) {
 					})
 
 				dashSvc = dashboards.NewFakeDashboardService(t)
-				dashSvc.On("GetDashboard", mock.Anything, mock.AnythingOfType("*models.GetDashboardQuery")).Run(func(args mock.Arguments) {
-					q := args.Get(1).(*models.GetDashboardQuery)
-					q.Result = &models.Dashboard{
-						Id:  1,
-						Uid: deleteWithDashboardUIDCmd.DashboardUID,
+				dashSvc.On("GetDashboard", mock.Anything, mock.AnythingOfType("*dashboards.GetDashboardQuery")).Run(func(args mock.Arguments) {
+					q := args.Get(1).(*dashboards.GetDashboardQuery)
+					q.Result = &dashboards.Dashboard{
+						ID:  1,
+						UID: deleteWithDashboardUIDCmd.DashboardUID,
 					}
 				}).Return(nil)
 				deleteAnnotationsScenario(t, "When calling POST with dashboardUID on", "/api/annotations/mass-delete",
@@ -279,7 +279,7 @@ func TestAnnotationsAPIEndpoint(t *testing.T) {
 						setUpACL()
 						sc.fakeReqWithParams("POST", sc.url, map[string]string{}).exec()
 						assert.Equal(t, 200, sc.resp.Code)
-						dashSvc.AssertCalled(t, "GetDashboard", mock.Anything, mock.AnythingOfType("*models.GetDashboardQuery"))
+						dashSvc.AssertCalled(t, "GetDashboard", mock.Anything, mock.AnythingOfType("*dashboards.GetDashboardQuery"))
 					})
 			})
 		})
@@ -687,11 +687,11 @@ func setUpACL() {
 			{Role: &editorRole, Permission: models.PERMISSION_EDIT},
 		}
 	}).Return(nil)
-	dashSvc.On("GetDashboard", mock.Anything, mock.AnythingOfType("*models.GetDashboardQuery")).Run(func(args mock.Arguments) {
-		q := args.Get(1).(*models.GetDashboardQuery)
-		q.Result = &models.Dashboard{
-			Id:  q.Id,
-			Uid: q.Uid,
+	dashSvc.On("GetDashboard", mock.Anything, mock.AnythingOfType("*dashboards.GetDashboardQuery")).Run(func(args mock.Arguments) {
+		q := args.Get(1).(*dashboards.GetDashboardQuery)
+		q.Result = &dashboards.Dashboard{
+			ID:  q.ID,
+			UID: q.UID,
 		}
 	}).Return(nil)
 

pkg/api/dashboard.go

@@ -109,7 +109,7 @@ func (hs *HTTPServer) GetDashboard(c *models.ReqContext) response.Response {
 	// If public dashboards is enabled and we have a public dashboard, update meta
 	// values
 	if hs.Features.IsEnabled(featuremgmt.FlagPublicDashboards) {
-		publicDashboard, err := hs.PublicDashboardsApi.PublicDashboardService.FindByDashboardUid(c.Req.Context(), c.OrgID, dash.Uid)
+		publicDashboard, err := hs.PublicDashboardsApi.PublicDashboardService.FindByDashboardUid(c.Req.Context(), c.OrgID, dash.UID)
 		if err != nil && !errors.Is(err, publicdashboardModels.ErrPublicDashboardNotFound) {
 			return response.Error(500, "Error while retrieving public dashboards", err)
 		}
@@ -146,7 +146,7 @@ func (hs *HTTPServer) GetDashboard(c *models.ReqContext) response.Response {
 	canAdmin, _ := guardian.CanAdmin()
 	canDelete, _ := guardian.CanDelete()
 
-	isStarred, err := hs.isDashboardStarredByUser(c, dash.Id)
+	isStarred, err := hs.isDashboardStarredByUser(c, dash.ID)
 	if err != nil {
 		return response.Error(500, "Error while checking if dashboard was starred by user", err)
 	}
@@ -182,8 +182,8 @@ func (hs *HTTPServer) GetDashboard(c *models.ReqContext) response.Response {
 		Version:                dash.Version,
 		HasACL:                 dash.HasACL,
 		IsFolder:               dash.IsFolder,
-		FolderId:               dash.FolderId,
-		Url:                    dash.GetUrl(),
+		FolderId:               dash.FolderID,
+		Url:                    dash.GetURL(),
 		FolderTitle:            "General",
 		AnnotationsPermissions: annotationPermissions,
 		PublicDashboardEnabled: publicDashboardEnabled,
@@ -191,20 +191,20 @@ func (hs *HTTPServer) GetDashboard(c *models.ReqContext) response.Response {
 	}
 
 	// lookup folder title
-	if dash.FolderId > 0 {
-		query := models.GetDashboardQuery{Id: dash.FolderId, OrgId: c.OrgID}
+	if dash.FolderID > 0 {
+		query := dashboards.GetDashboardQuery{ID: dash.FolderID, OrgID: c.OrgID}
 		if err := hs.DashboardService.GetDashboard(c.Req.Context(), &query); err != nil {
 			if errors.Is(err, dashboards.ErrFolderNotFound) {
 				return response.Error(404, "Folder not found", err)
 			}
 			return response.Error(500, "Dashboard folder could not be read", err)
 		}
-		meta.FolderUid = query.Result.Uid
+		meta.FolderUid = query.Result.UID
 		meta.FolderTitle = query.Result.Title
-		meta.FolderUrl = query.Result.GetUrl()
+		meta.FolderUrl = query.Result.GetURL()
 	}
 
-	provisioningData, err := hs.dashboardProvisioningService.GetProvisionedDashboardDataByDashboardID(c.Req.Context(), dash.Id)
+	provisioningData, err := hs.dashboardProvisioningService.GetProvisionedDashboardDataByDashboardID(c.Req.Context(), dash.ID)
 	if err != nil {
 		return response.Error(500, "Error while checking if dashboard is provisioned", err)
 	}
@@ -275,13 +275,13 @@ func (hs *HTTPServer) getUserLogin(ctx context.Context, userID int64) string {
 	return user.Login
 }
 
-func (hs *HTTPServer) getDashboardHelper(ctx context.Context, orgID int64, id int64, uid string) (*models.Dashboard, response.Response) {
-	var query models.GetDashboardQuery
+func (hs *HTTPServer) getDashboardHelper(ctx context.Context, orgID int64, id int64, uid string) (*dashboards.Dashboard, response.Response) {
+	var query dashboards.GetDashboardQuery
 
 	if len(uid) > 0 {
-		query = models.GetDashboardQuery{Uid: uid, Id: id, OrgId: orgID}
+		query = dashboards.GetDashboardQuery{UID: uid, ID: id, OrgID: orgID}
 	} else {
-		query = models.GetDashboardQuery{Id: id, OrgId: orgID}
+		query = dashboards.GetDashboardQuery{ID: id, OrgID: orgID}
 	}
 
 	if err := hs.DashboardService.GetDashboard(ctx, &query); err != nil {
@@ -322,12 +322,12 @@ func (hs *HTTPServer) deleteDashboard(c *models.ReqContext) response.Response {
 	}
 
 	// disconnect all library elements for this dashboard
-	err = hs.LibraryElementService.DisconnectElementsFromDashboard(c.Req.Context(), dash.Id)
+	err = hs.LibraryElementService.DisconnectElementsFromDashboard(c.Req.Context(), dash.ID)
 	if err != nil {
-		hs.log.Error("Failed to disconnect library elements", "dashboard", dash.Id, "user", c.SignedInUser.UserID, "error", err)
+		hs.log.Error("Failed to disconnect library elements", "dashboard", dash.ID, "user", c.SignedInUser.UserID, "error", err)
 	}
 
-	err = hs.DashboardService.DeleteDashboard(c.Req.Context(), dash.Id, c.OrgID)
+	err = hs.DashboardService.DeleteDashboard(c.Req.Context(), dash.ID, c.OrgID)
 	if err != nil {
 		var dashboardErr dashboards.DashboardErr
 		if ok := errors.As(err, &dashboardErr); ok {
@@ -339,15 +339,15 @@ func (hs *HTTPServer) deleteDashboard(c *models.ReqContext) response.Response {
 	}
 
 	if hs.Live != nil {
-		err := hs.Live.GrafanaScope.Dashboards.DashboardDeleted(c.OrgID, c.ToUserDisplayDTO(), dash.Uid)
+		err := hs.Live.GrafanaScope.Dashboards.DashboardDeleted(c.OrgID, c.ToUserDisplayDTO(), dash.UID)
 		if err != nil {
-			hs.log.Error("Failed to broadcast delete info", "dashboard", dash.Uid, "error", err)
+			hs.log.Error("Failed to broadcast delete info", "dashboard", dash.UID, "error", err)
 		}
 	}
 	return response.JSON(http.StatusOK, util.DynMap{
 		"title":   dash.Title,
 		"message": fmt.Sprintf("Dashboard %s deleted", dash.Title),
-		"id":      dash.Id,
+		"id":      dash.ID,
 	})
 }
 
@@ -367,7 +367,7 @@ func (hs *HTTPServer) deleteDashboard(c *models.ReqContext) response.Response {
 // 422: unprocessableEntityError
 // 500: internalServerError
 func (hs *HTTPServer) PostDashboard(c *models.ReqContext) response.Response {
-	cmd := models.SaveDashboardCommand{}
+	cmd := dashboards.SaveDashboardCommand{}
 	if err := web.Bind(c.Req, &cmd); err != nil {
 		return response.Error(http.StatusBadRequest, "bad request data", err)
 	}
@@ -397,15 +397,15 @@ func (hs *HTTPServer) PostDashboard(c *models.ReqContext) response.Response {
 	return hs.postDashboard(c, cmd)
 }
 
-func (hs *HTTPServer) postDashboard(c *models.ReqContext, cmd models.SaveDashboardCommand) response.Response {
+func (hs *HTTPServer) postDashboard(c *models.ReqContext, cmd dashboards.SaveDashboardCommand) response.Response {
 	ctx := c.Req.Context()
 	var err error
-	cmd.OrgId = c.OrgID
-	cmd.UserId = c.UserID
-	if cmd.FolderUid != "" {
+	cmd.OrgID = c.OrgID
+	cmd.UserID = c.UserID
+	if cmd.FolderUID != "" {
 		folder, err := hs.folderService.Get(ctx, &folder.GetFolderQuery{
 			OrgID:        c.OrgID,
-			UID:          &cmd.FolderUid,
+			UID:          &cmd.FolderUID,
 			SignedInUser: c.SignedInUser,
 		})
 		if err != nil {
@@ -414,11 +414,11 @@ func (hs *HTTPServer) postDashboard(c *models.ReqContext, cmd models.SaveDashboa
 			}
 			return response.Error(500, "Error while checking folder ID", err)
 		}
-		cmd.FolderId = folder.ID
+		cmd.FolderID = folder.ID
 	}
 
 	dash := cmd.GetDashboardModel()
-	newDashboard := dash.Id == 0
+	newDashboard := dash.ID == 0
 	if newDashboard {
 		limitReached, err := hs.QuotaService.QuotaReached(c, dashboards.QuotaTargetSrv)
 		if err != nil {
@@ -430,14 +430,14 @@ func (hs *HTTPServer) postDashboard(c *models.ReqContext, cmd models.SaveDashboa
 	}
 
 	var provisioningData *models.DashboardProvisioning
-	if dash.Id != 0 {
-		data, err := hs.dashboardProvisioningService.GetProvisionedDashboardDataByDashboardID(c.Req.Context(), dash.Id)
+	if dash.ID != 0 {
+		data, err := hs.dashboardProvisioningService.GetProvisionedDashboardDataByDashboardID(c.Req.Context(), dash.ID)
 		if err != nil {
 			return response.Error(500, "Error while checking if dashboard is provisioned using ID", err)
 		}
 		provisioningData = data
-	} else if dash.Uid != "" {
-		data, err := hs.dashboardProvisioningService.GetProvisionedDashboardDataByDashboardUID(c.Req.Context(), dash.OrgId, dash.Uid)
+	} else if dash.UID != "" {
+		data, err := hs.dashboardProvisioningService.GetProvisionedDashboardDataByDashboardUID(c.Req.Context(), dash.OrgID, dash.UID)
 		if err != nil && !errors.Is(err, dashboards.ErrProvisionedDashboardNotFound) && !errors.Is(err, dashboards.ErrDashboardNotFound) {
 			return response.Error(500, "Error while checking if dashboard is provisioned", err)
 		}
@@ -452,7 +452,7 @@ func (hs *HTTPServer) postDashboard(c *models.ReqContext, cmd models.SaveDashboa
 	dashItem := &dashboards.SaveDashboardDTO{
 		Dashboard: dash,
 		Message:   cmd.Message,
-		OrgId:     c.OrgID,
+		OrgID:     c.OrgID,
 		User:      c.SignedInUser,
 		Overwrite: cmd.Overwrite,
 	}
@@ -479,7 +479,7 @@ func (hs *HTTPServer) postDashboard(c *models.ReqContext, cmd models.SaveDashboa
 		}
 
 		if liveerr != nil {
-			hs.log.Warn("unable to broadcast save event", "uid", dashboard.Uid, "error", liveerr)
+			hs.log.Warn("unable to broadcast save event", "uid", dashboard.UID, "error", liveerr)
 		}
 	}
 
@@ -504,9 +504,9 @@ func (hs *HTTPServer) postDashboard(c *models.ReqContext, cmd models.SaveDashboa
 		"status":  "success",
 		"slug":    dashboard.Slug,
 		"version": dashboard.Version,
-		"id":      dashboard.Id,
-		"uid":     dashboard.Uid,
-		"url":     dashboard.GetUrl(),
+		"id":      dashboard.ID,
+		"uid":     dashboard.UID,
+		"url":     dashboard.GetURL(),
 	})
 }
 
@@ -533,10 +533,10 @@ func (hs *HTTPServer) GetHomeDashboard(c *models.ReqContext) response.Response {
 	}
 
 	if preference.HomeDashboardID != 0 {
-		slugQuery := models.GetDashboardRefByIdQuery{Id: preference.HomeDashboardID}
-		err := hs.DashboardService.GetDashboardUIDById(c.Req.Context(), &slugQuery)
+		slugQuery := dashboards.GetDashboardRefByIDQuery{ID: preference.HomeDashboardID}
+		err := hs.DashboardService.GetDashboardUIDByID(c.Req.Context(), &slugQuery)
 		if err == nil {
-			url := models.GetDashboardUrl(slugQuery.Result.Uid, slugQuery.Result.Slug)
+			url := models.GetDashboardUrl(slugQuery.Result.UID, slugQuery.Result.Slug)
 			dashRedirect := dtos.DashboardRedirect{RedirectUri: url}
 			return response.JSON(http.StatusOK, &dashRedirect)
 		}
@@ -655,15 +655,15 @@ func (hs *HTTPServer) GetDashboardVersions(c *models.ReqContext) response.Respon
 
 	query := dashver.ListDashboardVersionsQuery{
 		OrgID:        c.OrgID,
-		DashboardID:  dash.Id,
-		DashboardUID: dash.Uid,
+		DashboardID:  dash.ID,
+		DashboardUID: dash.UID,
 		Limit:        c.QueryInt("limit"),
 		Start:        c.QueryInt("start"),
 	}
 
 	res, err := hs.dashboardVersionService.List(c.Req.Context(), &query)
 	if err != nil {
-		return response.Error(404, fmt.Sprintf("No versions found for dashboardId %d", dash.Id), err)
+		return response.Error(404, fmt.Sprintf("No versions found for dashboardId %d", dash.ID), err)
 	}
 
 	for _, version := range res {
@@ -716,7 +716,7 @@ func (hs *HTTPServer) GetDashboardVersion(c *models.ReqContext) response.Respons
 	var err error
 	dashUID := web.Params(c.Req)[":uid"]
 
-	var dash *models.Dashboard
+	var dash *dashboards.Dashboard
 	if dashUID == "" {
 		dashID, err = strconv.ParseInt(web.Params(c.Req)[":dashboardId"], 10, 64)
 		if err != nil {
@@ -741,13 +741,13 @@ func (hs *HTTPServer) GetDashboardVersion(c *models.ReqContext) response.Respons
 	version, _ := strconv.ParseInt(web.Params(c.Req)[":id"], 10, 32)
 	query := dashver.GetDashboardVersionQuery{
 		OrgID:       c.OrgID,
-		DashboardID: dash.Id,
+		DashboardID: dash.ID,
 		Version:     int(version),
 	}
 
 	res, err := hs.dashboardVersionService.Get(c.Req.Context(), &query)
 	if err != nil {
-		return response.Error(500, fmt.Sprintf("Dashboard version %d not found for dashboardId %d", query.Version, dash.Id), err)
+		return response.Error(500, fmt.Sprintf("Dashboard version %d not found for dashboardId %d", query.Version, dash.ID), err)
 	}
 
 	creator := anonString
@@ -996,15 +996,15 @@ func (hs *HTTPServer) RestoreDashboardVersion(c *models.ReqContext) response.Res
 		return response.Error(404, "Dashboard version not found", nil)
 	}
 
-	saveCmd := models.SaveDashboardCommand{}
+	saveCmd := dashboards.SaveDashboardCommand{}
 	saveCmd.RestoredFrom = version.Version
-	saveCmd.OrgId = c.OrgID
-	saveCmd.UserId = c.UserID
+	saveCmd.OrgID = c.OrgID
+	saveCmd.UserID = c.UserID
 	saveCmd.Dashboard = version.Data
 	saveCmd.Dashboard.Set("version", dash.Version)
-	saveCmd.Dashboard.Set("uid", dash.Uid)
+	saveCmd.Dashboard.Set("uid", dash.UID)
 	saveCmd.Message = fmt.Sprintf("Restored from version %d", version.Version)
-	saveCmd.FolderId = dash.FolderId
+	saveCmd.FolderID = dash.FolderID
 
 	return hs.postDashboard(c, saveCmd)
 }
@@ -1033,18 +1033,18 @@ func (hs *HTTPServer) GetDashboardUIDs(c *models.ReqContext) {
 	ids := strings.Split(web.Params(c.Req)[":ids"], ",")
 	uids := make([]string, 0, len(ids))
 
-	q := &models.GetDashboardRefByIdQuery{}
+	q := &dashboards.GetDashboardRefByIDQuery{}
 	for _, idstr := range ids {
 		id, err := strconv.ParseInt(idstr, 10, 64)
 		if err != nil {
 			continue
 		}
-		q.Id = id
-		err = hs.DashboardService.GetDashboardUIDById(c.Req.Context(), q)
+		q.ID = id
+		err = hs.DashboardService.GetDashboardUIDByID(c.Req.Context(), q)
 		if err != nil {
 			continue
 		}
-		uids = append(uids, q.Result.Uid)
+		uids = append(uids, q.Result.UID)
 	}
 	c.JSON(http.StatusOK, uids)
 }

pkg/api/dashboard_permission.go

@@ -192,7 +192,7 @@ func (hs *HTTPServer) UpdateDashboardPermissions(c *models.ReqContext) response.
 		if err != nil {
 			return response.Error(500, "Error while checking dashboard permissions", err)
 		}
-		if err := hs.updateDashboardAccessControl(c.Req.Context(), dash.OrgId, dash.Uid, false, items, old); err != nil {
+		if err := hs.updateDashboardAccessControl(c.Req.Context(), dash.OrgID, dash.UID, false, items, old); err != nil {
 			return response.Error(500, "Failed to update permissions", err)
 		}
 		return response.Success("Dashboard permissions updated")

pkg/api/dashboard_permission_test.go

@@ -27,11 +27,11 @@ func TestDashboardPermissionAPIEndpoint(t *testing.T) {
 	t.Run("Dashboard permissions test", func(t *testing.T) {
 		settings := setting.NewCfg()
 		dashboardStore := &dashboards.FakeDashboardStore{}
-		dashboardStore.On("GetDashboard", mock.Anything, mock.AnythingOfType("*models.GetDashboardQuery")).Run(func(args mock.Arguments) {
-			q := args.Get(1).(*models.GetDashboardQuery)
-			q.Result = &models.Dashboard{
-				Id:  q.Id,
-				Uid: q.Uid,
+		dashboardStore.On("GetDashboard", mock.Anything, mock.AnythingOfType("*dashboards.GetDashboardQuery")).Run(func(args mock.Arguments) {
+			q := args.Get(1).(*dashboards.GetDashboardQuery)
+			q.Result = &dashboards.Dashboard{
+				ID:  q.ID,
+				UID: q.UID,
 			}
 		}).Return(nil, nil)
 		defer dashboardStore.AssertExpectations(t)

pkg/api/dashboard_snapshot_test.go

@@ -74,11 +74,11 @@ func TestDashboardSnapshotAPIEndpoint_singleSnapshot(t *testing.T) {
 
 				teamSvc := &teamtest.FakeService{}
 				dashSvc := dashboards.NewFakeDashboardService(t)
-				dashSvc.On("GetDashboard", mock.Anything, mock.AnythingOfType("*models.GetDashboardQuery")).Run(func(args mock.Arguments) {
-					q := args.Get(1).(*models.GetDashboardQuery)
-					q.Result = &models.Dashboard{
-						Id:  q.Id,
-						Uid: q.Uid,
+				dashSvc.On("GetDashboard", mock.Anything, mock.AnythingOfType("*dashboards.GetDashboardQuery")).Run(func(args mock.Arguments) {
+					q := args.Get(1).(*dashboards.GetDashboardQuery)
+					q.Result = &dashboards.Dashboard{
+						ID:  q.ID,
+						UID: q.UID,
 					}
 				}).Return(nil).Maybe()
 				dashSvc.On("GetDashboardACLInfoList", mock.Anything, mock.AnythingOfType("*models.GetDashboardACLInfoListQuery")).Return(nil).Maybe()
@@ -136,11 +136,11 @@ func TestDashboardSnapshotAPIEndpoint_singleSnapshot(t *testing.T) {
 					externalRequest = req
 				})
 				dashSvc := dashboards.NewFakeDashboardService(t)
-				dashSvc.On("GetDashboard", mock.Anything, mock.AnythingOfType("*models.GetDashboardQuery")).Run(func(args mock.Arguments) {
-					q := args.Get(1).(*models.GetDashboardQuery)
-					q.Result = &models.Dashboard{
-						Id:    q.Id,
-						OrgId: q.OrgId,
+				dashSvc.On("GetDashboard", mock.Anything, mock.AnythingOfType("*dashboards.GetDashboardQuery")).Run(func(args mock.Arguments) {
+					q := args.Get(1).(*dashboards.GetDashboardQuery)
+					q.Result = &dashboards.Dashboard{
+						ID:    q.ID,
+						OrgID: q.OrgID,
 					}
 				}).Return(nil).Maybe()
 				dashSvc.On("GetDashboardACLInfoList", mock.Anything, mock.AnythingOfType("*models.GetDashboardACLInfoListQuery")).Run(func(args mock.Arguments) {

pkg/api/dashboard_test.go

@@ -128,16 +128,16 @@ func newTestLive(t *testing.T, store db.DB) *live.GrafanaLive {
 
 func TestDashboardAPIEndpoint(t *testing.T) {
 	t.Run("Given a dashboard with a parent folder which does not have an ACL", func(t *testing.T) {
-		fakeDash := models.NewDashboard("Child dash")
-		fakeDash.Id = 1
-		fakeDash.FolderId = 1
+		fakeDash := dashboards.NewDashboard("Child dash")
+		fakeDash.ID = 1
+		fakeDash.FolderID = 1
 		fakeDash.HasACL = false
 		fakeDashboardVersionService := dashvertest.NewDashboardVersionServiceFake()
 		fakeDashboardVersionService.ExpectedDashboardVersion = &dashver.DashboardVersionDTO{}
 		teamService := &teamtest.FakeService{}
 		dashboardService := dashboards.NewFakeDashboardService(t)
-		dashboardService.On("GetDashboard", mock.Anything, mock.AnythingOfType("*models.GetDashboardQuery")).Run(func(args mock.Arguments) {
-			q := args.Get(1).(*models.GetDashboardQuery)
+		dashboardService.On("GetDashboard", mock.Anything, mock.AnythingOfType("*dashboards.GetDashboardQuery")).Run(func(args mock.Arguments) {
+			q := args.Get(1).(*dashboards.GetDashboardQuery)
 			q.Result = fakeDash
 		}).Return(nil)
 		mockSQLStore := mockstore.NewSQLStoreMock()
@@ -236,16 +236,16 @@ func TestDashboardAPIEndpoint(t *testing.T) {
 	})
 
 	t.Run("Given a dashboard with a parent folder which has an ACL", func(t *testing.T) {
-		fakeDash := models.NewDashboard("Child dash")
-		fakeDash.Id = 1
-		fakeDash.FolderId = 1
+		fakeDash := dashboards.NewDashboard("Child dash")
+		fakeDash.ID = 1
+		fakeDash.FolderID = 1
 		fakeDash.HasACL = true
 		fakeDashboardVersionService := dashvertest.NewDashboardVersionServiceFake()
 		fakeDashboardVersionService.ExpectedDashboardVersion = &dashver.DashboardVersionDTO{}
 		teamService := &teamtest.FakeService{}
 		dashboardService := dashboards.NewFakeDashboardService(t)
-		dashboardService.On("GetDashboard", mock.Anything, mock.AnythingOfType("*models.GetDashboardQuery")).Run(func(args mock.Arguments) {
-			q := args.Get(1).(*models.GetDashboardQuery)
+		dashboardService.On("GetDashboard", mock.Anything, mock.AnythingOfType("*dashboards.GetDashboardQuery")).Run(func(args mock.Arguments) {
+			q := args.Get(1).(*dashboards.GetDashboardQuery)
 			q.Result = fakeDash
 		}).Return(nil)
 		dashboardService.On("GetDashboardACLInfoList", mock.Anything, mock.AnythingOfType("*models.GetDashboardACLInfoListQuery")).Run(func(args mock.Arguments) {
@@ -403,9 +403,9 @@ func TestDashboardAPIEndpoint(t *testing.T) {
 			loggedInUserScenarioWithRole(t, "When calling DELETE on", "DELETE", "/api/dashboards/uid/abcdefghi", "/api/dashboards/uid/:uid", role, func(sc *scenarioContext) {
 				setUpInner()
 				dashboardService := dashboards.NewFakeDashboardService(t)
-				dashboardService.On("GetDashboard", mock.Anything, mock.AnythingOfType("*models.GetDashboardQuery")).Run(func(args mock.Arguments) {
-					q := args.Get(1).(*models.GetDashboardQuery)
-					q.Result = models.NewDashboard("test")
+				dashboardService.On("GetDashboard", mock.Anything, mock.AnythingOfType("*dashboards.GetDashboardQuery")).Run(func(args mock.Arguments) {
+					q := args.Get(1).(*dashboards.GetDashboardQuery)
+					q.Result = dashboards.NewDashboard("test")
 				}).Return(nil)
 				dashboardService.On("DeleteDashboard", mock.Anything, mock.AnythingOfType("int64"), mock.AnythingOfType("int64")).Return(nil)
 
@@ -505,9 +505,9 @@ func TestDashboardAPIEndpoint(t *testing.T) {
 				setUpInner()
 				sc.sqlStore = mockSQLStore
 				dashboardService := dashboards.NewFakeDashboardService(t)
-				dashboardService.On("GetDashboard", mock.Anything, mock.AnythingOfType("*models.GetDashboardQuery")).Run(func(args mock.Arguments) {
-					q := args.Get(1).(*models.GetDashboardQuery)
-					q.Result = models.NewDashboard("test")
+				dashboardService.On("GetDashboard", mock.Anything, mock.AnythingOfType("*dashboards.GetDashboardQuery")).Run(func(args mock.Arguments) {
+					q := args.Get(1).(*dashboards.GetDashboardQuery)
+					q.Result = dashboards.NewDashboard("test")
 				}).Return(nil)
 				dashboardService.On("DeleteDashboard", mock.Anything, mock.AnythingOfType("int64"), mock.AnythingOfType("int64")).Return(nil)
 				hs.callDeleteDashboardByUID(t, sc, dashboardService)
@@ -610,7 +610,7 @@ func TestDashboardAPIEndpoint(t *testing.T) {
 
 			dashboardService := dashboards.NewFakeDashboardService(t)
 			dashboardService.On("SaveDashboard", mock.Anything, mock.AnythingOfType("*dashboards.SaveDashboardDTO"), mock.AnythingOfType("bool")).
-				Return(&models.Dashboard{Id: dashID, Uid: "uid", Title: "Dash", Slug: "dash", Version: 2}, nil)
+				Return(&dashboards.Dashboard{ID: dashID, UID: "uid", Title: "Dash", Slug: "dash", Version: 2}, nil)
 
 			postDashboardScenario(t, "When calling POST on", "/api/dashboards", "/api/dashboards", cmd, dashboardService, nil, func(sc *scenarioContext) {
 				callPostDashboardShouldReturnSuccess(sc)
@@ -642,7 +642,7 @@ func TestDashboardAPIEndpoint(t *testing.T) {
 
 			dashboardService := dashboards.NewFakeDashboardService(t)
 			dashboardService.On("SaveDashboard", mock.Anything, mock.AnythingOfType("*dashboards.SaveDashboardDTO"), mock.AnythingOfType("bool")).
-				Return(&models.Dashboard{Id: dashID, Uid: "uid", Title: "Dash", Slug: "dash", Version: 2}, nil)
+				Return(&dashboards.Dashboard{ID: dashID, UID: "uid", Title: "Dash", Slug: "dash", Version: 2}, nil)
 
 			mockFolder := &foldertest.FakeService{
 				ExpectedFolder: &folder.Folder{ID: 1, UID: "folderUID", Title: "Folder"},
@@ -808,11 +808,11 @@ func TestDashboardAPIEndpoint(t *testing.T) {
 			teamSvc := &teamtest.FakeService{}
 			dashSvc := dashboards.NewFakeDashboardService(t)
 			dashSvc.On("GetDashboardACLInfoList", mock.Anything, mock.AnythingOfType("*models.GetDashboardACLInfoListQuery")).Return(nil)
-			dashSvc.On("GetDashboard", mock.Anything, mock.AnythingOfType("*models.GetDashboardQuery")).Run(func(args mock.Arguments) {
-				q := args.Get(1).(*models.GetDashboardQuery)
-				q.Result = &models.Dashboard{
-					OrgId: q.OrgId,
-					Id:    q.Id,
+			dashSvc.On("GetDashboard", mock.Anything, mock.AnythingOfType("*dashboards.GetDashboardQuery")).Run(func(args mock.Arguments) {
+				q := args.Get(1).(*dashboards.GetDashboardQuery)
+				q.Result = &dashboards.Dashboard{
+					OrgID: q.OrgID,
+					ID:    q.ID,
 				}
 			}).Return(nil)
 			guardian.InitLegacyGuardian(&sqlmock, dashSvc, teamSvc)
@@ -853,20 +853,20 @@ func TestDashboardAPIEndpoint(t *testing.T) {
 
 	t.Run("Given dashboard in folder being restored should restore to folder", func(t *testing.T) {
 		const folderID int64 = 1
-		fakeDash := models.NewDashboard("Child dash")
-		fakeDash.Id = 2
-		fakeDash.FolderId = folderID
+		fakeDash := dashboards.NewDashboard("Child dash")
+		fakeDash.ID = 2
+		fakeDash.FolderID = folderID
 		fakeDash.HasACL = false
 
 		dashboardService := dashboards.NewFakeDashboardService(t)
-		dashboardService.On("GetDashboard", mock.Anything, mock.AnythingOfType("*models.GetDashboardQuery")).Run(func(args mock.Arguments) {
-			q := args.Get(1).(*models.GetDashboardQuery)
+		dashboardService.On("GetDashboard", mock.Anything, mock.AnythingOfType("*dashboards.GetDashboardQuery")).Run(func(args mock.Arguments) {
+			q := args.Get(1).(*dashboards.GetDashboardQuery)
 			q.Result = fakeDash
 		}).Return(nil)
 		dashboardService.On("SaveDashboard", mock.Anything, mock.AnythingOfType("*dashboards.SaveDashboardDTO"), mock.AnythingOfType("bool")).Run(func(args mock.Arguments) {
 			cmd := args.Get(1).(*dashboards.SaveDashboardDTO)
-			cmd.Dashboard = &models.Dashboard{
-				Id: 2, Uid: "uid", Title: "Dash", Slug: "dash", Version: 1,
+			cmd.Dashboard = &dashboards.Dashboard{
+				ID: 2, UID: "uid", Title: "Dash", Slug: "dash", Version: 1,
 			}
 		}).Return(nil, nil)
 
@@ -891,19 +891,19 @@ func TestDashboardAPIEndpoint(t *testing.T) {
 	})
 
 	t.Run("Given dashboard in general folder being restored should restore to general folder", func(t *testing.T) {
-		fakeDash := models.NewDashboard("Child dash")
-		fakeDash.Id = 2
+		fakeDash := dashboards.NewDashboard("Child dash")
+		fakeDash.ID = 2
 		fakeDash.HasACL = false
 
 		dashboardService := dashboards.NewFakeDashboardService(t)
-		dashboardService.On("GetDashboard", mock.Anything, mock.AnythingOfType("*models.GetDashboardQuery")).Run(func(args mock.Arguments) {
-			q := args.Get(1).(*models.GetDashboardQuery)
+		dashboardService.On("GetDashboard", mock.Anything, mock.AnythingOfType("*dashboards.GetDashboardQuery")).Run(func(args mock.Arguments) {
+			q := args.Get(1).(*dashboards.GetDashboardQuery)
 			q.Result = fakeDash
 		}).Return(nil)
 		dashboardService.On("SaveDashboard", mock.Anything, mock.AnythingOfType("*dashboards.SaveDashboardDTO"), mock.AnythingOfType("bool")).Run(func(args mock.Arguments) {
 			cmd := args.Get(1).(*dashboards.SaveDashboardDTO)
-			cmd.Dashboard = &models.Dashboard{
-				Id: 2, Uid: "uid", Title: "Dash", Slug: "dash", Version: 1,
+			cmd.Dashboard = &dashboards.Dashboard{
+				ID: 2, UID: "uid", Title: "Dash", Slug: "dash", Version: 1,
 			}
 		}).Return(nil, nil)
 
@@ -936,9 +936,9 @@ func TestDashboardAPIEndpoint(t *testing.T) {
 
 		dataValue, err := simplejson.NewJson([]byte(`{"id": 1, "editable": true, "style": "dark"}`))
 		require.NoError(t, err)
-		dashboardService.On("GetDashboard", mock.Anything, mock.AnythingOfType("*models.GetDashboardQuery")).Run(func(args mock.Arguments) {
-			q := args.Get(1).(*models.GetDashboardQuery)
-			q.Result = &models.Dashboard{Id: 1, Data: dataValue}
+		dashboardService.On("GetDashboard", mock.Anything, mock.AnythingOfType("*dashboards.GetDashboardQuery")).Run(func(args mock.Arguments) {
+			q := args.Get(1).(*dashboards.GetDashboardQuery)
+			q.Result = &dashboards.Dashboard{ID: 1, Data: dataValue}
 		}).Return(nil)
 		dashboardService.On("GetDashboardACLInfoList", mock.Anything, mock.AnythingOfType("*models.GetDashboardACLInfoListQuery")).Run(func(args mock.Arguments) {
 			q := args.Get(1).(*models.GetDashboardACLInfoListQuery)
@@ -1256,7 +1256,7 @@ func (s mockDashboardProvisioningService) GetProvisionedDashboardDataByDashboard
 type mockLibraryPanelService struct {
 }
 
-func (m *mockLibraryPanelService) ConnectLibraryPanelsForDashboard(c context.Context, signedInUser *user.SignedInUser, dash *models.Dashboard) error {
+func (m *mockLibraryPanelService) ConnectLibraryPanelsForDashboard(c context.Context, signedInUser *user.SignedInUser, dash *dashboards.Dashboard) error {
 	return nil
 }
 

pkg/api/folder_test.go

@@ -242,11 +242,11 @@ func createFolderScenario(t *testing.T, desc string, url string, routePattern st
 			q := args.Get(1).(*models.GetDashboardACLInfoListQuery)
 			q.Result = aclMockResp
 		}).Return(nil)
-		dashSvc.On("GetDashboard", mock.Anything, mock.AnythingOfType("*models.GetDashboardQuery")).Run(func(args mock.Arguments) {
-			q := args.Get(1).(*models.GetDashboardQuery)
-			q.Result = &models.Dashboard{
-				Id:  q.Id,
-				Uid: q.Uid,
+		dashSvc.On("GetDashboard", mock.Anything, mock.AnythingOfType("*dashboards.GetDashboardQuery")).Run(func(args mock.Arguments) {
+			q := args.Get(1).(*dashboards.GetDashboardQuery)
+			q.Result = &dashboards.Dashboard{
+				ID:  q.ID,
+				UID: q.UID,
 			}
 		}).Return(nil)
 		store := mockstore.NewSQLStoreMock()

pkg/api/org_users_test.go

@@ -18,6 +18,7 @@ import (
 	"github.com/grafana/grafana/pkg/infra/localcache"
 	"github.com/grafana/grafana/pkg/models"
 	"github.com/grafana/grafana/pkg/services/accesscontrol"
+	"github.com/grafana/grafana/pkg/services/dashboards"
 	"github.com/grafana/grafana/pkg/services/featuremgmt"
 	"github.com/grafana/grafana/pkg/services/org"
 	"github.com/grafana/grafana/pkg/services/org/orgimpl"
@@ -203,9 +204,9 @@ func TestOrgUsersAPIEndpoint_LegacyAccessControl_FolderAdmin(t *testing.T) {
 	setInitCtxSignedInViewer(sc.initCtx)
 
 	// Create a dashboard folder
-	cmd := models.SaveDashboardCommand{
-		OrgId:    testOrgID,
-		FolderId: 1,
+	cmd := dashboards.SaveDashboardCommand{
+		OrgID:    testOrgID,
+		FolderID: 1,
 		IsFolder: true,
 		Dashboard: simplejson.NewFromAny(map[string]interface{}{
 			"id":    nil,
@@ -220,7 +221,7 @@ func TestOrgUsersAPIEndpoint_LegacyAccessControl_FolderAdmin(t *testing.T) {
 	// Grant our test Viewer with permission to admin the folder
 	acls := []*models.DashboardACL{
 		{
-			DashboardID: folder.Id,
+			DashboardID: folder.ID,
 			OrgID:       testOrgID,
 			UserID:      testUserID,
 			Permission:  models.PERMISSION_ADMIN,
@@ -228,7 +229,7 @@ func TestOrgUsersAPIEndpoint_LegacyAccessControl_FolderAdmin(t *testing.T) {
 			Updated:     time.Now(),
 		},
 	}
-	err = sc.dashboardsStore.UpdateDashboardACL(context.Background(), folder.Id, acls)
+	err = sc.dashboardsStore.UpdateDashboardACL(context.Background(), folder.ID, acls)
 	require.NoError(t, err)
 
 	response := callAPI(sc.server, http.MethodGet, "/api/org/users/lookup", nil, t)

pkg/api/playlist_play.go

@@ -9,6 +9,7 @@ import (
 	"github.com/grafana/grafana/pkg/api/dtos"
 	_ "github.com/grafana/grafana/pkg/infra/log"
 	"github.com/grafana/grafana/pkg/models"
+	"github.com/grafana/grafana/pkg/services/dashboards"
 	"github.com/grafana/grafana/pkg/services/playlist"
 	"github.com/grafana/grafana/pkg/services/search"
 	"github.com/grafana/grafana/pkg/services/user"
@@ -18,19 +19,19 @@ func (hs *HTTPServer) populateDashboardsByID(ctx context.Context, dashboardByIDs
 	result := make(dtos.PlaylistDashboardsSlice, 0)
 
 	if len(dashboardByIDs) > 0 {
-		dashboardQuery := models.GetDashboardsQuery{DashboardIds: dashboardByIDs}
+		dashboardQuery := dashboards.GetDashboardsQuery{DashboardIDs: dashboardByIDs}
 		if err := hs.DashboardService.GetDashboards(ctx, &dashboardQuery); err != nil {
 			return result, err
 		}
 
 		for _, item := range dashboardQuery.Result {
 			result = append(result, dtos.PlaylistDashboard{
-				Id:    item.Id,
+				Id:    item.ID,
 				Slug:  item.Slug,
 				Title: item.Title,
 				Uri:   "db/" + item.Slug,
-				Url:   models.GetDashboardUrl(item.Uid, item.Slug),
-				Order: dashboardIDOrder[item.Id],
+				Url:   models.GetDashboardUrl(item.UID, item.Slug),
+				Order: dashboardIDOrder[item.ID],
 			})
 		}
 	}

pkg/api/preferences.go

@@ -7,6 +7,7 @@ import (
 	"github.com/grafana/grafana/pkg/api/dtos"
 	"github.com/grafana/grafana/pkg/api/response"
 	"github.com/grafana/grafana/pkg/models"
+	"github.com/grafana/grafana/pkg/services/dashboards"
 	pref "github.com/grafana/grafana/pkg/services/preference"
 	"github.com/grafana/grafana/pkg/web"
 )
@@ -30,15 +31,15 @@ func (hs *HTTPServer) SetHomeDashboard(c *models.ReqContext) response.Response {
 	// UID is used in preference to identify dashboard
 	dashboardID := cmd.HomeDashboardID
 	if cmd.HomeDashboardUID != nil {
-		query := models.GetDashboardQuery{Uid: *cmd.HomeDashboardUID}
-		if query.Uid == "" {
+		query := dashboards.GetDashboardQuery{UID: *cmd.HomeDashboardUID}
+		if query.UID == "" {
 			dashboardID = 0 // clear the value
 		} else {
 			err := hs.DashboardService.GetDashboard(c.Req.Context(), &query)
 			if err != nil {
 				return response.Error(404, "Dashboard not found", err)
 			}
-			dashboardID = query.Result.Id
+			dashboardID = query.Result.ID
 		}
 	}
 
@@ -75,10 +76,10 @@ func (hs *HTTPServer) getPreferencesFor(ctx context.Context, orgID, userID, team
 
 	// when homedashboardID is 0, that means it is the default home dashboard, no UID would be returned in the response
 	if preference.HomeDashboardID != 0 {
-		query := models.GetDashboardQuery{Id: preference.HomeDashboardID, OrgId: orgID}
+		query := dashboards.GetDashboardQuery{ID: preference.HomeDashboardID, OrgID: orgID}
 		err = hs.DashboardService.GetDashboard(ctx, &query)
 		if err == nil {
-			dashboardUID = query.Result.Uid
+			dashboardUID = query.Result.UID
 		}
 	}
 
@@ -130,8 +131,8 @@ func (hs *HTTPServer) updatePreferencesFor(ctx context.Context, orgID, userID, t
 
 	dashboardID := dtoCmd.HomeDashboardID
 	if dtoCmd.HomeDashboardUID != nil {
-		query := models.GetDashboardQuery{Uid: *dtoCmd.HomeDashboardUID, OrgId: orgID}
-		if query.Uid == "" {
+		query := dashboards.GetDashboardQuery{UID: *dtoCmd.HomeDashboardUID, OrgID: orgID}
+		if query.UID == "" {
 			// clear the value
 			dashboardID = 0
 		} else {
@@ -139,7 +140,7 @@ func (hs *HTTPServer) updatePreferencesFor(ctx context.Context, orgID, userID, t
 			if err != nil {
 				return response.Error(404, "Dashboard not found", err)
 			}
-			dashboardID = query.Result.Id
+			dashboardID = query.Result.ID
 		}
 	}
 	dtoCmd.HomeDashboardID = dashboardID
@@ -189,8 +190,8 @@ func (hs *HTTPServer) patchPreferencesFor(ctx context.Context, orgID, userID, te
 	// convert dashboard UID to ID in order to store internally if it exists in the query, otherwise take the id from query
 	dashboardID := dtoCmd.HomeDashboardID
 	if dtoCmd.HomeDashboardUID != nil {
-		query := models.GetDashboardQuery{Uid: *dtoCmd.HomeDashboardUID, OrgId: orgID}
-		if query.Uid == "" {
+		query := dashboards.GetDashboardQuery{UID: *dtoCmd.HomeDashboardUID, OrgID: orgID}
+		if query.UID == "" {
 			// clear the value
 			defaultDash := int64(0)
 			dashboardID = &defaultDash
@@ -199,7 +200,7 @@ func (hs *HTTPServer) patchPreferencesFor(ctx context.Context, orgID, userID, te
 			if err != nil {
 				return response.Error(404, "Dashboard not found", err)
 			}
-			dashboardID = &query.Result.Id
+			dashboardID = &query.Result.ID
 		}
 	}
 	dtoCmd.HomeDashboardID = dashboardID

pkg/api/preferences_test.go

@@ -14,7 +14,6 @@ import (
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
 
-	"github.com/grafana/grafana/pkg/models"
 	"github.com/grafana/grafana/pkg/services/accesscontrol"
 	"github.com/grafana/grafana/pkg/services/dashboards"
 	"github.com/grafana/grafana/pkg/services/org"
@@ -41,9 +40,9 @@ func TestAPIEndpoint_GetCurrentOrgPreferences_LegacyAccessControl(t *testing.T)
 	cfg.RBACEnabled = false
 	sc := setupHTTPServerWithCfg(t, true, cfg)
 	dashSvc := dashboards.NewFakeDashboardService(t)
-	dashSvc.On("GetDashboard", mock.Anything, mock.AnythingOfType("*models.GetDashboardQuery")).Run(func(args mock.Arguments) {
-		q := args.Get(1).(*models.GetDashboardQuery)
-		q.Result = &models.Dashboard{Uid: "home", Id: 1}
+	dashSvc.On("GetDashboard", mock.Anything, mock.AnythingOfType("*dashboards.GetDashboardQuery")).Run(func(args mock.Arguments) {
+		q := args.Get(1).(*dashboards.GetDashboardQuery)
+		q.Result = &dashboards.Dashboard{UID: "home", ID: 1}
 	}).Return(nil)
 
 	sc.hs.DashboardService = dashSvc
@@ -175,9 +174,9 @@ func TestAPIEndpoint_PatchUserPreferences(t *testing.T) {
 	})
 	input = strings.NewReader(testUpdateOrgPreferencesWithHomeDashboardUIDCmd)
 	dashSvc := dashboards.NewFakeDashboardService(t)
-	dashSvc.On("GetDashboard", mock.Anything, mock.AnythingOfType("*models.GetDashboardQuery")).Run(func(args mock.Arguments) {
-		q := args.Get(1).(*models.GetDashboardQuery)
-		q.Result = &models.Dashboard{Uid: "home", Id: 1}
+	dashSvc.On("GetDashboard", mock.Anything, mock.AnythingOfType("*dashboards.GetDashboardQuery")).Run(func(args mock.Arguments) {
+		q := args.Get(1).(*dashboards.GetDashboardQuery)
+		q.Result = &dashboards.Dashboard{UID: "home", ID: 1}
 	}).Return(nil)
 	sc.hs.DashboardService = dashSvc
 	t.Run("Returns 200 on success", func(t *testing.T) {

pkg/api/stars.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/grafana/grafana/pkg/api/response"
 	"github.com/grafana/grafana/pkg/models"
+	"github.com/grafana/grafana/pkg/services/dashboards"
 	"github.com/grafana/grafana/pkg/services/star"
 	"github.com/grafana/grafana/pkg/web"
 )
@@ -22,15 +23,15 @@ func (hs *HTTPServer) GetStars(c *models.ReqContext) response.Response {
 
 	uids := []string{}
 	for dashboardId := range iuserstars.UserStars {
-		query := &models.GetDashboardQuery{
-			Id:    dashboardId,
-			OrgId: c.OrgID,
+		query := &dashboards.GetDashboardQuery{
+			ID:    dashboardId,
+			OrgID: c.OrgID,
 		}
 		err := hs.DashboardService.GetDashboard(c.Req.Context(), query)
 
 		// Grafana admin users may have starred dashboards in multiple orgs.  This will avoid returning errors when the dashboard is in another org
 		if err == nil {
-			uids = append(uids, query.Result.Uid)
+			uids = append(uids, query.Result.UID)
 		}
 	}
 	return response.JSON(200, uids)
@@ -91,7 +92,7 @@ func (hs *HTTPServer) StarDashboardByUID(c *models.ReqContext) response.Response
 		return rsp
 	}
 
-	cmd := star.StarDashboardCommand{UserID: c.UserID, DashboardID: dash.Id}
+	cmd := star.StarDashboardCommand{UserID: c.UserID, DashboardID: dash.ID}
 
 	if err := hs.starService.Add(c.Req.Context(), &cmd); err != nil {
 		return response.Error(http.StatusInternalServerError, "Failed to star dashboard", err)
@@ -156,7 +157,7 @@ func (hs *HTTPServer) UnstarDashboardByUID(c *models.ReqContext) response.Respon
 		return rsp
 	}
 
-	cmd := star.UnstarDashboardCommand{UserID: c.UserID, DashboardID: dash.Id}
+	cmd := star.UnstarDashboardCommand{UserID: c.UserID, DashboardID: dash.ID}
 
 	if err := hs.starService.Delete(c.Req.Context(), &cmd); err != nil {
 		return response.Error(http.StatusInternalServerError, "Failed to unstar dashboard", err)

pkg/services/accesscontrol/ossaccesscontrol/permissions_services.go

@@ -117,8 +117,8 @@ func ProvideDashboardPermissions(
 	license models.Licensing, dashboardStore dashboards.Store, service accesscontrol.Service,
 	teamService team.Service, userService user.Service,
 ) (*DashboardPermissionsService, error) {
-	getDashboard := func(ctx context.Context, orgID int64, resourceID string) (*models.Dashboard, error) {
-		query := &models.GetDashboardQuery{Uid: resourceID, OrgId: orgID}
+	getDashboard := func(ctx context.Context, orgID int64, resourceID string) (*dashboards.Dashboard, error) {
+		query := &dashboards.GetDashboardQuery{UID: resourceID, OrgID: orgID}
 		if _, err := dashboardStore.GetDashboard(ctx, query); err != nil {
 			return nil, err
 		}
@@ -145,12 +145,12 @@ func ProvideDashboardPermissions(
 			if err != nil {
 				return nil, err
 			}
-			if dashboard.FolderId > 0 {
-				query := &models.GetDashboardQuery{Id: dashboard.FolderId, OrgId: orgID}
+			if dashboard.FolderID > 0 {
+				query := &dashboards.GetDashboardQuery{ID: dashboard.FolderID, OrgID: orgID}
 				if _, err := dashboardStore.GetDashboard(ctx, query); err != nil {
 					return nil, err
 				}
-				return []string{dashboards.ScopeFoldersProvider.GetResourceScopeUID(query.Result.Uid)}, nil
+				return []string{dashboards.ScopeFoldersProvider.GetResourceScopeUID(query.Result.UID)}, nil
 			}
 			return []string{}, nil
 		},
@@ -200,7 +200,7 @@ func ProvideFolderPermissions(
 		Resource:          "folders",
 		ResourceAttribute: "uid",
 		ResourceValidator: func(ctx context.Context, orgID int64, resourceID string) error {
-			query := &models.GetDashboardQuery{Uid: resourceID, OrgId: orgID}
+			query := &dashboards.GetDashboardQuery{UID: resourceID, OrgID: orgID}
 			if _, err := dashboardStore.GetDashboard(ctx, query); err != nil {
 				return err
 			}

pkg/services/alerting/eval_context.go

@@ -29,7 +29,7 @@ type EvalContext struct {
 	Rule           *Rule
 	Log            log.Logger
 
-	dashboardRef *models.DashboardRef
+	dashboardRef *dashboards.DashboardRef
 
 	ImagePublicURL  string
 	ImageOnDiskPath string
@@ -116,13 +116,13 @@ func (c *EvalContext) GetNotificationTitle() string {
 }
 
 // GetDashboardUID returns the dashboard uid for the alert rule.
-func (c *EvalContext) GetDashboardUID() (*models.DashboardRef, error) {
+func (c *EvalContext) GetDashboardUID() (*dashboards.DashboardRef, error) {
 	if c.dashboardRef != nil {
 		return c.dashboardRef, nil
 	}
 
-	uidQuery := &models.GetDashboardRefByIdQuery{Id: c.Rule.DashboardID}
-	if err := c.dashboardService.GetDashboardUIDById(c.Ctx, uidQuery); err != nil {
+	uidQuery := &dashboards.GetDashboardRefByIDQuery{ID: c.Rule.DashboardID}
+	if err := c.dashboardService.GetDashboardUIDByID(c.Ctx, uidQuery); err != nil {
 		return nil, err
 	}
 
@@ -142,7 +142,7 @@ func (c *EvalContext) GetRuleURL() (string, error) {
 	if err != nil {
 		return "", err
 	}
-	return fmt.Sprintf(urlFormat, models.GetFullDashboardUrl(ref.Uid, ref.Slug), c.Rule.PanelID, c.Rule.OrgID), nil
+	return fmt.Sprintf(urlFormat, models.GetFullDashboardUrl(ref.UID, ref.Slug), c.Rule.PanelID, c.Rule.OrgID), nil
 }
 
 // GetNewState returns the new state from the alert rule evaluation.

pkg/services/alerting/extractor.go

@@ -149,7 +149,7 @@ func (e *DashAlertExtractorService) getAlertFromPanels(ctx context.Context, json
 					PanelID: panelID,
 				}
 				if dashAlertInfo.Dash != nil {
-					ve.DashboardID = dashAlertInfo.Dash.Id
+					ve.DashboardID = dashAlertInfo.Dash.ID
 				}
 				return ve
 			}
@@ -175,7 +175,7 @@ func (e *DashAlertExtractorService) getAlertFromPanels(ctx context.Context, json
 		}
 
 		alert := &models.Alert{
-			DashboardId: dashAlertInfo.Dash.Id,
+			DashboardId: dashAlertInfo.Dash.ID,
 			OrgId:       dashAlertInfo.OrgID,
 			PanelId:     panelID,
 			Id:          jsonAlert.Get("id").MustInt64(),

pkg/services/alerting/extractor_test.go

@@ -13,6 +13,7 @@ import (
 	"github.com/grafana/grafana/pkg/components/simplejson"
 	"github.com/grafana/grafana/pkg/infra/db"
 	"github.com/grafana/grafana/pkg/models"
+	"github.com/grafana/grafana/pkg/services/dashboards"
 	"github.com/grafana/grafana/pkg/services/datasources"
 	"github.com/grafana/grafana/pkg/services/datasources/permissions"
 	"github.com/grafana/grafana/pkg/services/sqlstore/mockstore"
@@ -59,7 +60,7 @@ func TestAlertRuleExtraction(t *testing.T) {
 
 		_, _ = extractor.GetAlerts(context.Background(), DashAlertInfo{
 			User:  nil,
-			Dash:  models.NewDashboardFromJson(dashJSON),
+			Dash:  dashboards.NewDashboardFromJson(dashJSON),
 			OrgID: 1,
 		})
 
@@ -73,7 +74,7 @@ func TestAlertRuleExtraction(t *testing.T) {
 		dsService.ExpectedDatasource = &datasources.DataSource{Id: 12}
 		alerts, err := extractor.GetAlerts(context.Background(), DashAlertInfo{
 			User:  nil,
-			Dash:  models.NewDashboardFromJson(dashJSON),
+			Dash:  dashboards.NewDashboardFromJson(dashJSON),
 			OrgID: 1,
 		})
 
@@ -125,7 +126,7 @@ func TestAlertRuleExtraction(t *testing.T) {
 
 		_, err = extractor.GetAlerts(context.Background(), DashAlertInfo{
 			User:  nil,
-			Dash:  models.NewDashboardFromJson(dashJSON),
+			Dash:  dashboards.NewDashboardFromJson(dashJSON),
 			OrgID: 1,
 		})
 
@@ -141,7 +142,7 @@ func TestAlertRuleExtraction(t *testing.T) {
 
 		_, err = extractor.GetAlerts(context.Background(), DashAlertInfo{
 			User:  nil,
-			Dash:  models.NewDashboardFromJson(dashJSON),
+			Dash:  dashboards.NewDashboardFromJson(dashJSON),
 			OrgID: 1,
 		})
 
@@ -156,7 +157,7 @@ func TestAlertRuleExtraction(t *testing.T) {
 
 		_, err = extractor.GetAlerts(WithUAEnabled(context.Background(), true), DashAlertInfo{
 			User:  nil,
-			Dash:  models.NewDashboardFromJson(dashJSON),
+			Dash:  dashboards.NewDashboardFromJson(dashJSON),
 			OrgID: 1,
 		})
 		require.Equal(t, "alert validation error: Alert on PanelId: 2 refers to query(B) that cannot be found. Legacy alerting queries are not able to be removed at this time in order to preserve the ability to rollback to previous versions of Grafana", err.Error())
@@ -172,7 +173,7 @@ func TestAlertRuleExtraction(t *testing.T) {
 		dsService.ExpectedDatasource = &datasources.DataSource{Id: 12}
 		alerts, err := extractor.GetAlerts(context.Background(), DashAlertInfo{
 			User:  nil,
-			Dash:  models.NewDashboardFromJson(dashJSON),
+			Dash:  dashboards.NewDashboardFromJson(dashJSON),
 			OrgID: 1,
 		})
 		require.Nil(t, err)
@@ -191,7 +192,7 @@ func TestAlertRuleExtraction(t *testing.T) {
 
 		alerts, err := extractor.GetAlerts(context.Background(), DashAlertInfo{
 			User:  nil,
-			Dash:  models.NewDashboardFromJson(dashJSON),
+			Dash:  dashboards.NewDashboardFromJson(dashJSON),
 			OrgID: 1,
 		})
 		require.Nil(t, err)
@@ -218,7 +219,7 @@ func TestAlertRuleExtraction(t *testing.T) {
 
 		alerts, err := extractor.GetAlerts(context.Background(), DashAlertInfo{
 			User:  nil,
-			Dash:  models.NewDashboardFromJson(dashJSON),
+			Dash:  dashboards.NewDashboardFromJson(dashJSON),
 			OrgID: 1,
 		})
 		require.Nil(t, err)
@@ -242,7 +243,7 @@ func TestAlertRuleExtraction(t *testing.T) {
 		dashJSON, err := simplejson.NewJson(json)
 		require.Nil(t, err)
 
-		dash := models.NewDashboardFromJson(dashJSON)
+		dash := dashboards.NewDashboardFromJson(dashJSON)
 
 		alerts, err := extractor.GetAlerts(context.Background(), DashAlertInfo{
 			User:  nil,
@@ -263,7 +264,7 @@ func TestAlertRuleExtraction(t *testing.T) {
 
 		dashAlertInfo := DashAlertInfo{
 			User:  nil,
-			Dash:  models.NewDashboardFromJson(dashJSON),
+			Dash:  dashboards.NewDashboardFromJson(dashJSON),
 			OrgID: 1,
 		}
 
@@ -284,7 +285,7 @@ func TestAlertRuleExtraction(t *testing.T) {
 		dsService.ExpectedDatasource = graphite2Ds
 		dashAlertInfo := DashAlertInfo{
 			User:  nil,
-			Dash:  models.NewDashboardFromJson(dashJSON),
+			Dash:  dashboards.NewDashboardFromJson(dashJSON),
 			OrgID: 1,
 		}
 
@@ -355,7 +356,7 @@ func TestFilterPermissionsErrors(t *testing.T) {
 			dsPermissions.ErrResult = test.err
 			_, err = extractor.GetAlerts(WithUAEnabled(context.Background(), true), DashAlertInfo{
 				User:  nil,
-				Dash:  models.NewDashboardFromJson(dashJSON),
+				Dash:  dashboards.NewDashboardFromJson(dashJSON),
 				OrgID: 1,
 			})
 			assert.Equal(t, err, test.expectedErr)

pkg/services/alerting/models.go

@@ -4,7 +4,7 @@ import (
 	"sync"
 
 	"github.com/grafana/grafana/pkg/components/null"
-	"github.com/grafana/grafana/pkg/models"
+	"github.com/grafana/grafana/pkg/services/dashboards"
 	"github.com/grafana/grafana/pkg/services/user"
 )
 
@@ -47,6 +47,6 @@ type EvalMatch struct {
 
 type DashAlertInfo struct {
 	User  *user.SignedInUser
-	Dash  *models.Dashboard
+	Dash  *dashboards.Dashboard
 	OrgID int64
 }

pkg/services/alerting/notifier.go

@@ -225,7 +225,7 @@ func (n *notificationService) renderAndUploadImage(evalCtx *EvalContext, timeout
 		return err
 	}
 
-	renderOpts.Path = fmt.Sprintf("d-solo/%s/%s?orgId=%d&panelId=%d", ref.Uid, ref.Slug, evalCtx.Rule.OrgID, evalCtx.Rule.PanelID)
+	renderOpts.Path = fmt.Sprintf("d-solo/%s/%s?orgId=%d&panelId=%d", ref.UID, ref.Slug, evalCtx.Rule.OrgID, evalCtx.Rule.PanelID)
 
 	n.log.Debug("Rendering alert panel image", "ruleId", evalCtx.Rule.ID, "urlPath", renderOpts.Path)
 	start := time.Now()

pkg/services/alerting/notifier_test.go

@@ -12,6 +12,7 @@ import (
 	"github.com/grafana/grafana/pkg/components/simplejson"
 	"github.com/grafana/grafana/pkg/models"
 	"github.com/grafana/grafana/pkg/services/annotations/annotationstest"
+	"github.com/grafana/grafana/pkg/services/dashboards"
 	"github.com/grafana/grafana/pkg/services/notifications"
 	"github.com/grafana/grafana/pkg/services/rendering"
 	"github.com/grafana/grafana/pkg/services/validations"
@@ -176,7 +177,7 @@ func notificationServiceScenario(t *testing.T, name string, evalCtx *EvalContext
 			Factory:     newTestNotifier,
 		})
 
-		evalCtx.dashboardRef = &models.DashboardRef{Uid: "db-uid"}
+		evalCtx.dashboardRef = &dashboards.DashboardRef{UID: "db-uid"}
 
 		store := evalCtx.Store.(*AlertStoreMock)
 

pkg/services/alerting/test_rule.go

@@ -5,14 +5,14 @@ import (
 	"fmt"
 
 	"github.com/grafana/grafana/pkg/components/simplejson"
-	"github.com/grafana/grafana/pkg/models"
 	"github.com/grafana/grafana/pkg/services/annotations/annotationstest"
+	"github.com/grafana/grafana/pkg/services/dashboards"
 	"github.com/grafana/grafana/pkg/services/user"
 )
 
 // AlertTest makes a test alert.
 func (e *AlertEngine) AlertTest(orgID int64, dashboard *simplejson.Json, panelID int64, user *user.SignedInUser) (*EvalContext, error) {
-	dash := models.NewDashboardFromJson(dashboard)
+	dash := dashboards.NewDashboardFromJson(dashboard)
 	dashInfo := DashAlertInfo{
 		User:  user,
 		Dash:  dash,

pkg/services/annotations/annotationsimpl/xorm_store_test.go

@@ -14,7 +14,6 @@ import (
 	"github.com/grafana/grafana/pkg/components/simplejson"
 	"github.com/grafana/grafana/pkg/infra/db"
 	"github.com/grafana/grafana/pkg/infra/log"
-	"github.com/grafana/grafana/pkg/models"
 	"github.com/grafana/grafana/pkg/services/accesscontrol"
 	"github.com/grafana/grafana/pkg/services/annotations"
 	"github.com/grafana/grafana/pkg/services/dashboards"
@@ -61,9 +60,9 @@ func TestIntegrationAnnotations(t *testing.T) {
 		dashboardStore, err := dashboardstore.ProvideDashboardStore(sql, sql.Cfg, featuremgmt.WithFeatures(), tagimpl.ProvideService(sql, sql.Cfg), quotaService)
 		require.NoError(t, err)
 
-		testDashboard1 := models.SaveDashboardCommand{
-			UserId: 1,
-			OrgId:  1,
+		testDashboard1 := dashboards.SaveDashboardCommand{
+			UserID: 1,
+			OrgID:  1,
 			Dashboard: simplejson.NewFromAny(map[string]interface{}{
 				"title": "Dashboard 1",
 			}),
@@ -72,9 +71,9 @@ func TestIntegrationAnnotations(t *testing.T) {
 		dashboard, err := dashboardStore.SaveDashboard(context.Background(), testDashboard1)
 		require.NoError(t, err)
 
-		testDashboard2 := models.SaveDashboardCommand{
-			UserId: 1,
-			OrgId:  1,
+		testDashboard2 := dashboards.SaveDashboardCommand{
+			UserID: 1,
+			OrgID:  1,
 			Dashboard: simplejson.NewFromAny(map[string]interface{}{
 				"title": "Dashboard 2",
 			}),
@@ -85,7 +84,7 @@ func TestIntegrationAnnotations(t *testing.T) {
 		annotation := &annotations.Item{
 			OrgId:       1,
 			UserId:      1,
-			DashboardId: dashboard.Id,
+			DashboardId: dashboard.ID,
 			Text:        "hello",
 			Type:        "alert",
 			Epoch:       10,
@@ -100,7 +99,7 @@ func TestIntegrationAnnotations(t *testing.T) {
 		annotation2 := &annotations.Item{
 			OrgId:       1,
 			UserId:      1,
-			DashboardId: dashboard2.Id,
+			DashboardId: dashboard2.ID,
 			Text:        "hello",
 			Type:        "alert",
 			Epoch:       21, // Should swap epoch & epochEnd
@@ -139,7 +138,7 @@ func TestIntegrationAnnotations(t *testing.T) {
 		t.Run("Can query for annotation by dashboard id", func(t *testing.T) {
 			items, err := repo.Get(context.Background(), &annotations.ItemQuery{
 				OrgId:        1,
-				DashboardId:  dashboard.Id,
+				DashboardId:  dashboard.ID,
 				From:         0,
 				To:           15,
 				SignedInUser: testUser,
@@ -417,7 +416,7 @@ func TestIntegrationAnnotations(t *testing.T) {
 			annotation3 := &annotations.Item{
 				OrgId:       1,
 				UserId:      1,
-				DashboardId: dashboard2.Id,
+				DashboardId: dashboard2.ID,
 				Text:        "toBeDeletedWithPanelId",
 				Type:        "alert",
 				Epoch:       11,
@@ -501,9 +500,9 @@ func TestIntegrationAnnotationListingWithRBAC(t *testing.T) {
 	dashboardStore, err := dashboardstore.ProvideDashboardStore(sql, sql.Cfg, featuremgmt.WithFeatures(), tagimpl.ProvideService(sql, sql.Cfg), quotaService)
 	require.NoError(t, err)
 
-	testDashboard1 := models.SaveDashboardCommand{
-		UserId:   1,
-		OrgId:    1,
+	testDashboard1 := dashboards.SaveDashboardCommand{
+		UserID:   1,
+		OrgID:    1,
 		IsFolder: false,
 		Dashboard: simplejson.NewFromAny(map[string]interface{}{
 			"title": "Dashboard 1",
@@ -511,11 +510,11 @@ func TestIntegrationAnnotationListingWithRBAC(t *testing.T) {
 	}
 	dashboard, err := dashboardStore.SaveDashboard(context.Background(), testDashboard1)
 	require.NoError(t, err)
-	dash1UID := dashboard.Uid
+	dash1UID := dashboard.UID
 
-	testDashboard2 := models.SaveDashboardCommand{
-		UserId: 1,
-		OrgId:  1,
+	testDashboard2 := dashboards.SaveDashboardCommand{
+		UserID: 1,
+		OrgID:  1,
 		Dashboard: simplejson.NewFromAny(map[string]interface{}{
 			"title": "Dashboard 2",
 		}),

pkg/services/comments/commentmodel/permissions.go

@@ -5,7 +5,6 @@ import (
 	"strconv"
 
 	"github.com/grafana/grafana/pkg/infra/db"
-	"github.com/grafana/grafana/pkg/models"
 	"github.com/grafana/grafana/pkg/services/accesscontrol"
 	"github.com/grafana/grafana/pkg/services/annotations"
 	"github.com/grafana/grafana/pkg/services/dashboards"
@@ -29,16 +28,16 @@ func NewPermissionChecker(sqlStore db.DB, features featuremgmt.FeatureToggles,
 	return &PermissionChecker{sqlStore: sqlStore, features: features, accessControl: accessControl, annotationsRepo: annotationsRepo}
 }
 
-func (c *PermissionChecker) getDashboardByUid(ctx context.Context, orgID int64, uid string) (*models.Dashboard, error) {
-	query := models.GetDashboardQuery{Uid: uid, OrgId: orgID}
+func (c *PermissionChecker) getDashboardByUid(ctx context.Context, orgID int64, uid string) (*dashboards.Dashboard, error) {
+	query := dashboards.GetDashboardQuery{UID: uid, OrgID: orgID}
 	if err := c.dashboardService.GetDashboard(ctx, &query); err != nil {
 		return nil, err
 	}
 	return query.Result, nil
 }
 
-func (c *PermissionChecker) getDashboardById(ctx context.Context, orgID int64, id int64) (*models.Dashboard, error) {
-	query := models.GetDashboardQuery{Id: id, OrgId: orgID}
+func (c *PermissionChecker) getDashboardById(ctx context.Context, orgID int64, id int64) (*dashboards.Dashboard, error) {
+	query := dashboards.GetDashboardQuery{ID: id, OrgID: orgID}
 	if err := c.dashboardService.GetDashboard(ctx, &query); err != nil {
 		return nil, err
 	}

pkg/services/dashboardimport/service/service.go

@@ -106,17 +106,17 @@ func (s *ImportDashboardService) ImportDashboard(ctx context.Context, req *dashb
 		req.FolderUid = folder.UID
 	}
 
-	saveCmd := models.SaveDashboardCommand{
+	saveCmd := dashboards.SaveDashboardCommand{
 		Dashboard: generatedDash,
-		OrgId:     req.User.OrgID,
-		UserId:    req.User.UserID,
+		OrgID:     req.User.OrgID,
+		UserID:    req.User.UserID,
 		Overwrite: req.Overwrite,
-		PluginId:  req.PluginId,
-		FolderId:  req.FolderId,
+		PluginID:  req.PluginId,
+		FolderID:  req.FolderId,
 	}
 
 	dto := &dashboards.SaveDashboardDTO{
-		OrgId:     saveCmd.OrgId,
+		OrgID:     saveCmd.OrgID,
 		Dashboard: saveCmd.GetDashboardModel(),
 		Overwrite: saveCmd.Overwrite,
 		User:      req.User,
@@ -138,18 +138,18 @@ func (s *ImportDashboardService) ImportDashboard(ctx context.Context, req *dashb
 	}
 
 	return &dashboardimport.ImportDashboardResponse{
-		UID:              savedDashboard.Uid,
+		UID:              savedDashboard.UID,
 		PluginId:         req.PluginId,
 		Title:            savedDashboard.Title,
 		Path:             req.Path,
 		Revision:         savedDashboard.Data.Get("revision").MustInt64(1),
-		FolderId:         savedDashboard.FolderId,
+		FolderId:         savedDashboard.FolderID,
 		FolderUID:        req.FolderUid,
 		ImportedUri:      "db/" + savedDashboard.Slug,
-		ImportedUrl:      savedDashboard.GetUrl(),
+		ImportedUrl:      savedDashboard.GetURL(),
 		ImportedRevision: savedDashboard.Data.Get("revision").MustInt64(1),
 		Imported:         true,
-		DashboardId:      savedDashboard.Id,
+		DashboardId:      savedDashboard.ID,
 		Slug:             savedDashboard.Slug,
 	}, nil
 }

pkg/services/dashboardimport/service/service_test.go

@@ -27,16 +27,16 @@ func TestImportDashboardService(t *testing.T) {
 
 		var importDashboardArg *dashboards.SaveDashboardDTO
 		dashboardService := &dashboardServiceMock{
-			importDashboardFunc: func(ctx context.Context, dto *dashboards.SaveDashboardDTO) (*models.Dashboard, error) {
+			importDashboardFunc: func(ctx context.Context, dto *dashboards.SaveDashboardDTO) (*dashboards.Dashboard, error) {
 				importDashboardArg = dto
-				return &models.Dashboard{
-					Id:       4,
-					Uid:      dto.Dashboard.Uid,
+				return &dashboards.Dashboard{
+					ID:       4,
+					UID:      dto.Dashboard.UID,
 					Slug:     dto.Dashboard.Slug,
-					OrgId:    3,
+					OrgID:    3,
 					Version:  dto.Dashboard.Version,
-					PluginId: "prometheus",
-					FolderId: dto.Dashboard.FolderId,
+					PluginID: "prometheus",
+					FolderID: dto.Dashboard.FolderID,
 					Title:    dto.Dashboard.Title,
 					Data:     dto.Dashboard.Data,
 				}, nil
@@ -50,7 +50,7 @@ func TestImportDashboardService(t *testing.T) {
 				importLibraryPanelsForDashboard = true
 				return nil
 			},
-			connectLibraryPanelsForDashboardFunc: func(ctx context.Context, signedInUser *user.SignedInUser, dash *models.Dashboard) error {
+			connectLibraryPanelsForDashboardFunc: func(ctx context.Context, signedInUser *user.SignedInUser, dash *dashboards.Dashboard) error {
 				connectLibraryPanelsForDashboardCalled = true
 				return nil
 			},
@@ -84,10 +84,10 @@ func TestImportDashboardService(t *testing.T) {
 		require.Equal(t, "UDdpyzz7z", resp.UID)
 
 		require.NotNil(t, importDashboardArg)
-		require.Equal(t, int64(3), importDashboardArg.OrgId)
+		require.Equal(t, int64(3), importDashboardArg.OrgID)
 		require.Equal(t, int64(2), importDashboardArg.User.UserID)
-		require.Equal(t, "prometheus", importDashboardArg.Dashboard.PluginId)
-		require.Equal(t, int64(5), importDashboardArg.Dashboard.FolderId)
+		require.Equal(t, "prometheus", importDashboardArg.Dashboard.PluginID)
+		require.Equal(t, int64(5), importDashboardArg.Dashboard.FolderID)
 
 		panel := importDashboardArg.Dashboard.Data.Get("panels").GetIndex(0)
 		require.Equal(t, "prom", panel.Get("datasource").MustString())
@@ -99,16 +99,16 @@ func TestImportDashboardService(t *testing.T) {
 	t.Run("When importing a non-plugin dashboard should save dashboard and sync library panels", func(t *testing.T) {
 		var importDashboardArg *dashboards.SaveDashboardDTO
 		dashboardService := &dashboardServiceMock{
-			importDashboardFunc: func(ctx context.Context, dto *dashboards.SaveDashboardDTO) (*models.Dashboard, error) {
+			importDashboardFunc: func(ctx context.Context, dto *dashboards.SaveDashboardDTO) (*dashboards.Dashboard, error) {
 				importDashboardArg = dto
-				return &models.Dashboard{
-					Id:       4,
-					Uid:      dto.Dashboard.Uid,
+				return &dashboards.Dashboard{
+					ID:       4,
+					UID:      dto.Dashboard.UID,
 					Slug:     dto.Dashboard.Slug,
-					OrgId:    3,
+					OrgID:    3,
 					Version:  dto.Dashboard.Version,
-					PluginId: "prometheus",
-					FolderId: dto.Dashboard.FolderId,
+					PluginID: "prometheus",
+					FolderID: dto.Dashboard.FolderID,
 					Title:    dto.Dashboard.Title,
 					Data:     dto.Dashboard.Data,
 				}, nil
@@ -148,10 +148,10 @@ func TestImportDashboardService(t *testing.T) {
 		require.Equal(t, "UDdpyzz7z", resp.UID)
 
 		require.NotNil(t, importDashboardArg)
-		require.Equal(t, int64(3), importDashboardArg.OrgId)
+		require.Equal(t, int64(3), importDashboardArg.OrgID)
 		require.Equal(t, int64(2), importDashboardArg.User.UserID)
-		require.Equal(t, "", importDashboardArg.Dashboard.PluginId)
-		require.Equal(t, int64(5), importDashboardArg.Dashboard.FolderId)
+		require.Equal(t, "", importDashboardArg.Dashboard.PluginID)
+		require.Equal(t, int64(5), importDashboardArg.Dashboard.FolderID)
 
 		panel := importDashboardArg.Dashboard.Data.Get("panels").GetIndex(0)
 		require.Equal(t, "prom", panel.Get("datasource").MustString())
@@ -191,10 +191,10 @@ func (m *pluginDashboardServiceMock) LoadPluginDashboard(ctx context.Context, re
 
 type dashboardServiceMock struct {
 	dashboards.DashboardService
-	importDashboardFunc func(ctx context.Context, dto *dashboards.SaveDashboardDTO) (*models.Dashboard, error)
+	importDashboardFunc func(ctx context.Context, dto *dashboards.SaveDashboardDTO) (*dashboards.Dashboard, error)
 }
 
-func (s *dashboardServiceMock) ImportDashboard(ctx context.Context, dto *dashboards.SaveDashboardDTO) (*models.Dashboard, error) {
+func (s *dashboardServiceMock) ImportDashboard(ctx context.Context, dto *dashboards.SaveDashboardDTO) (*dashboards.Dashboard, error) {
 	if s.importDashboardFunc != nil {
 		return s.importDashboardFunc(ctx, dto)
 	}
@@ -204,11 +204,11 @@ func (s *dashboardServiceMock) ImportDashboard(ctx context.Context, dto *dashboa
 
 type libraryPanelServiceMock struct {
 	librarypanels.Service
-	connectLibraryPanelsForDashboardFunc func(c context.Context, signedInUser *user.SignedInUser, dash *models.Dashboard) error
+	connectLibraryPanelsForDashboardFunc func(c context.Context, signedInUser *user.SignedInUser, dash *dashboards.Dashboard) error
 	importLibraryPanelsForDashboardFunc  func(c context.Context, signedInUser *user.SignedInUser, libraryPanels *simplejson.Json, panels []interface{}, folderID int64) error
 }
 
-func (s *libraryPanelServiceMock) ConnectLibraryPanelsForDashboard(ctx context.Context, signedInUser *user.SignedInUser, dash *models.Dashboard) error {
+func (s *libraryPanelServiceMock) ConnectLibraryPanelsForDashboard(ctx context.Context, signedInUser *user.SignedInUser, dash *dashboards.Dashboard) error {
 	if s.connectLibraryPanelsForDashboardFunc != nil {
 		return s.connectLibraryPanelsForDashboardFunc(ctx, signedInUser, dash)
 	}

pkg/services/dashboards/accesscontrol.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"strings"
 
-	"github.com/grafana/grafana/pkg/models"
 	ac "github.com/grafana/grafana/pkg/services/accesscontrol"
 )
 
@@ -97,7 +96,7 @@ func NewDashboardIDScopeResolver(db Store) (string, ac.ScopeAttributeResolver) {
 			return nil, err
 		}
 
-		dashboard, err := db.GetDashboard(ctx, &models.GetDashboardQuery{Id: id, OrgId: orgID})
+		dashboard, err := db.GetDashboard(ctx, &GetDashboardQuery{ID: id, OrgID: orgID})
 		if err != nil {
 			return nil, err
 		}
@@ -120,7 +119,7 @@ func NewDashboardUIDScopeResolver(db Store) (string, ac.ScopeAttributeResolver)
 			return nil, err
 		}
 
-		dashboard, err := db.GetDashboard(ctx, &models.GetDashboardQuery{Uid: uid, OrgId: orgID})
+		dashboard, err := db.GetDashboard(ctx, &GetDashboardQuery{UID: uid, OrgID: orgID})
 		if err != nil {
 			return nil, err
 		}
@@ -129,16 +128,16 @@ func NewDashboardUIDScopeResolver(db Store) (string, ac.ScopeAttributeResolver)
 	})
 }
 
-func resolveDashboardScope(ctx context.Context, db Store, orgID int64, dashboard *models.Dashboard) ([]string, error) {
+func resolveDashboardScope(ctx context.Context, db Store, orgID int64, dashboard *Dashboard) ([]string, error) {
 	var folderUID string
-	if dashboard.FolderId < 0 {
-		return []string{ScopeDashboardsProvider.GetResourceScopeUID(dashboard.Uid)}, nil
+	if dashboard.FolderID < 0 {
+		return []string{ScopeDashboardsProvider.GetResourceScopeUID(dashboard.UID)}, nil
 	}
 
-	if dashboard.FolderId == 0 {
+	if dashboard.FolderID == 0 {
 		folderUID = ac.GeneralFolderUID
 	} else {
-		folder, err := db.GetFolderByID(ctx, orgID, dashboard.FolderId)
+		folder, err := db.GetFolderByID(ctx, orgID, dashboard.FolderID)
 		if err != nil {
 			return nil, err
 		}
@@ -146,7 +145,7 @@ func resolveDashboardScope(ctx context.Context, db Store, orgID int64, dashboard
 	}
 
 	return []string{
-		ScopeDashboardsProvider.GetResourceScopeUID(dashboard.Uid),
+		ScopeDashboardsProvider.GetResourceScopeUID(dashboard.UID),
 		ScopeFoldersProvider.GetResourceScopeUID(folderUID),
 	}, nil
 }

pkg/services/dashboards/accesscontrol_test.go

@@ -10,7 +10,6 @@ import (
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
 
-	"github.com/grafana/grafana/pkg/models"
 	ac "github.com/grafana/grafana/pkg/services/accesscontrol"
 	"github.com/grafana/grafana/pkg/services/folder"
 	"github.com/grafana/grafana/pkg/util"
@@ -157,16 +156,16 @@ func TestNewDashboardIDScopeResolver(t *testing.T) {
 
 		orgID := rand.Int63()
 		folder := &folder.Folder{ID: 2, UID: "2"}
-		dashboard := &models.Dashboard{Id: 1, FolderId: folder.ID, Uid: "1"}
+		dashboard := &Dashboard{ID: 1, FolderID: folder.ID, UID: "1"}
 
 		store.On("GetDashboard", mock.Anything, mock.Anything).Return(dashboard, nil).Once()
 		store.On("GetFolderByID", mock.Anything, orgID, folder.ID).Return(folder, nil).Once()
 
-		scope := ac.Scope("dashboards", "id", strconv.FormatInt(dashboard.Id, 10))
+		scope := ac.Scope("dashboards", "id", strconv.FormatInt(dashboard.ID, 10))
 		resolvedScopes, err := resolver.Resolve(context.Background(), orgID, scope)
 		require.NoError(t, err)
 		require.Len(t, resolvedScopes, 2)
-		require.Equal(t, fmt.Sprintf("dashboards:uid:%s", dashboard.Uid), resolvedScopes[0])
+		require.Equal(t, fmt.Sprintf("dashboards:uid:%s", dashboard.UID), resolvedScopes[0])
 		require.Equal(t, fmt.Sprintf("folders:uid:%s", folder.UID), resolvedScopes[1])
 	})
 
@@ -180,7 +179,7 @@ func TestNewDashboardIDScopeResolver(t *testing.T) {
 		store := &FakeDashboardStore{}
 		_, resolver := NewDashboardIDScopeResolver(store)
 
-		dashboard := &models.Dashboard{Id: 1, FolderId: 0, Uid: "1"}
+		dashboard := &Dashboard{ID: 1, FolderID: 0, UID: "1"}
 		store.On("GetDashboard", mock.Anything, mock.Anything).Return(dashboard, nil)
 		resolved, err := resolver.Resolve(context.Background(), 1, ac.Scope("dashboards", "id", "1"))
 		require.NoError(t, err)
@@ -203,16 +202,16 @@ func TestNewDashboardUIDScopeResolver(t *testing.T) {
 
 		orgID := rand.Int63()
 		folder := &folder.Folder{ID: 2, UID: "2"}
-		dashboard := &models.Dashboard{Id: 1, FolderId: folder.ID, Uid: "1"}
+		dashboard := &Dashboard{ID: 1, FolderID: folder.ID, UID: "1"}
 
 		store.On("GetDashboard", mock.Anything, mock.Anything).Return(dashboard, nil).Once()
 		store.On("GetFolderByID", mock.Anything, orgID, folder.ID).Return(folder, nil).Once()
 
-		scope := ac.Scope("dashboards", "uid", dashboard.Uid)
+		scope := ac.Scope("dashboards", "uid", dashboard.UID)
 		resolvedScopes, err := resolver.Resolve(context.Background(), orgID, scope)
 		require.NoError(t, err)
 		require.Len(t, resolvedScopes, 2)
-		require.Equal(t, fmt.Sprintf("dashboards:uid:%s", dashboard.Uid), resolvedScopes[0])
+		require.Equal(t, fmt.Sprintf("dashboards:uid:%s", dashboard.UID), resolvedScopes[0])
 		require.Equal(t, fmt.Sprintf("folders:uid:%s", folder.UID), resolvedScopes[1])
 	})
 
@@ -226,7 +225,7 @@ func TestNewDashboardUIDScopeResolver(t *testing.T) {
 		store := &FakeDashboardStore{}
 		_, resolver := NewDashboardUIDScopeResolver(store)
 
-		dashboard := &models.Dashboard{Id: 1, FolderId: 0, Uid: "1"}
+		dashboard := &Dashboard{ID: 1, FolderID: 0, UID: "1"}
 		store.On("GetDashboard", mock.Anything, mock.Anything).Return(dashboard, nil)
 		resolved, err := resolver.Resolve(context.Background(), 1, ac.Scope("dashboards", "uid", "1"))
 		require.NoError(t, err)

pkg/services/dashboards/dashboard.go

@@ -12,19 +12,19 @@ import (
 //
 //go:generate mockery --name DashboardService --structname FakeDashboardService --inpackage --filename dashboard_service_mock.go
 type DashboardService interface {
-	BuildSaveDashboardCommand(ctx context.Context, dto *SaveDashboardDTO, shouldValidateAlerts bool, validateProvisionedDashboard bool) (*models.SaveDashboardCommand, error)
+	BuildSaveDashboardCommand(ctx context.Context, dto *SaveDashboardDTO, shouldValidateAlerts bool, validateProvisionedDashboard bool) (*SaveDashboardCommand, error)
 	DeleteDashboard(ctx context.Context, dashboardId int64, orgId int64) error
 	FindDashboards(ctx context.Context, query *models.FindPersistedDashboardsQuery) ([]DashboardSearchProjection, error)
-	GetDashboard(ctx context.Context, query *models.GetDashboardQuery) error
+	GetDashboard(ctx context.Context, query *GetDashboardQuery) error
 	GetDashboardACLInfoList(ctx context.Context, query *models.GetDashboardACLInfoListQuery) error
-	GetDashboards(ctx context.Context, query *models.GetDashboardsQuery) error
+	GetDashboards(ctx context.Context, query *GetDashboardsQuery) error
 	GetDashboardTags(ctx context.Context, query *models.GetDashboardTagsQuery) error
-	GetDashboardUIDById(ctx context.Context, query *models.GetDashboardRefByIdQuery) error
+	GetDashboardUIDByID(ctx context.Context, query *GetDashboardRefByIDQuery) error
 	HasAdminPermissionInDashboardsOrFolders(ctx context.Context, query *models.HasAdminPermissionInDashboardsOrFoldersQuery) error
 	HasEditPermissionInFolders(ctx context.Context, query *models.HasEditPermissionInFoldersQuery) error
-	ImportDashboard(ctx context.Context, dto *SaveDashboardDTO) (*models.Dashboard, error)
+	ImportDashboard(ctx context.Context, dto *SaveDashboardDTO) (*Dashboard, error)
 	MakeUserAdmin(ctx context.Context, orgID int64, userID, dashboardID int64, setViewAndEditPermissions bool) error
-	SaveDashboard(ctx context.Context, dto *SaveDashboardDTO, allowUiUpdate bool) (*models.Dashboard, error)
+	SaveDashboard(ctx context.Context, dto *SaveDashboardDTO, allowUiUpdate bool) (*Dashboard, error)
 	SearchDashboards(ctx context.Context, query *models.FindPersistedDashboardsQuery) error
 	UpdateDashboardACL(ctx context.Context, uid int64, items []*models.DashboardACL) error
 	DeleteACLByUser(ctx context.Context, userID int64) error
@@ -45,8 +45,8 @@ type DashboardProvisioningService interface {
 	GetProvisionedDashboardData(ctx context.Context, name string) ([]*models.DashboardProvisioning, error)
 	GetProvisionedDashboardDataByDashboardID(ctx context.Context, dashboardID int64) (*models.DashboardProvisioning, error)
 	GetProvisionedDashboardDataByDashboardUID(ctx context.Context, orgID int64, dashboardUID string) (*models.DashboardProvisioning, error)
-	SaveFolderForProvisionedDashboards(context.Context, *SaveDashboardDTO) (*models.Dashboard, error)
-	SaveProvisionedDashboard(ctx context.Context, dto *SaveDashboardDTO, provisioning *models.DashboardProvisioning) (*models.Dashboard, error)
+	SaveFolderForProvisionedDashboards(context.Context, *SaveDashboardDTO) (*Dashboard, error)
+	SaveProvisionedDashboard(ctx context.Context, dto *SaveDashboardDTO, provisioning *DashboardProvisioning) (*Dashboard, error)
 	UnprovisionDashboard(ctx context.Context, dashboardID int64) error
 }
 
@@ -57,10 +57,10 @@ type Store interface {
 	DeleteDashboard(ctx context.Context, cmd *models.DeleteDashboardCommand) error
 	DeleteOrphanedProvisionedDashboards(ctx context.Context, cmd *models.DeleteOrphanedProvisionedDashboardsCommand) error
 	FindDashboards(ctx context.Context, query *models.FindPersistedDashboardsQuery) ([]DashboardSearchProjection, error)
-	GetDashboard(ctx context.Context, query *models.GetDashboardQuery) (*models.Dashboard, error)
+	GetDashboard(ctx context.Context, query *GetDashboardQuery) (*Dashboard, error)
 	GetDashboardACLInfoList(ctx context.Context, query *models.GetDashboardACLInfoListQuery) error
-	GetDashboardUIDById(ctx context.Context, query *models.GetDashboardRefByIdQuery) error
-	GetDashboards(ctx context.Context, query *models.GetDashboardsQuery) error
+	GetDashboardUIDByID(ctx context.Context, query *GetDashboardRefByIDQuery) error
+	GetDashboards(ctx context.Context, query *GetDashboardsQuery) error
 	// GetDashboardsByPluginID retrieves dashboards identified by plugin.
 	GetDashboardsByPluginID(ctx context.Context, query *models.GetDashboardsByPluginIdQuery) error
 	GetDashboardTags(ctx context.Context, query *models.GetDashboardTagsQuery) error
@@ -71,12 +71,12 @@ type Store interface {
 	HasEditPermissionInFolders(ctx context.Context, query *models.HasEditPermissionInFoldersQuery) error
 	// SaveAlerts saves dashboard alerts.
 	SaveAlerts(ctx context.Context, dashID int64, alerts []*models.Alert) error
-	SaveDashboard(ctx context.Context, cmd models.SaveDashboardCommand) (*models.Dashboard, error)
-	SaveProvisionedDashboard(ctx context.Context, cmd models.SaveDashboardCommand, provisioning *models.DashboardProvisioning) (*models.Dashboard, error)
+	SaveDashboard(ctx context.Context, cmd SaveDashboardCommand) (*Dashboard, error)
+	SaveProvisionedDashboard(ctx context.Context, cmd SaveDashboardCommand, provisioning *DashboardProvisioning) (*Dashboard, error)
 	UnprovisionDashboard(ctx context.Context, id int64) error
 	UpdateDashboardACL(ctx context.Context, uid int64, items []*models.DashboardACL) error
 	// ValidateDashboardBeforeSave validates a dashboard before save.
-	ValidateDashboardBeforeSave(ctx context.Context, dashboard *models.Dashboard, overwrite bool) (bool, error)
+	ValidateDashboardBeforeSave(ctx context.Context, dashboard *Dashboard, overwrite bool) (bool, error)
 	DeleteACLByUser(context.Context, int64) error
 
 	Count(context.Context, *quota.ScopeParameters) (*quota.Map, error)

pkg/services/dashboards/dashboard_provisioning_mock.go

@@ -1,4 +1,4 @@
-// Code generated by mockery v2.14.0. DO NOT EDIT.
+// Code generated by mockery v2.16.0. DO NOT EDIT.
 
 package dashboards
 
@@ -112,15 +112,15 @@ func (_m *FakeDashboardProvisioning) GetProvisionedDashboardDataByDashboardUID(c
 }
 
 // SaveFolderForProvisionedDashboards provides a mock function with given fields: _a0, _a1
-func (_m *FakeDashboardProvisioning) SaveFolderForProvisionedDashboards(_a0 context.Context, _a1 *SaveDashboardDTO) (*models.Dashboard, error) {
+func (_m *FakeDashboardProvisioning) SaveFolderForProvisionedDashboards(_a0 context.Context, _a1 *SaveDashboardDTO) (*Dashboard, error) {
 	ret := _m.Called(_a0, _a1)
 
-	var r0 *models.Dashboard
-	if rf, ok := ret.Get(0).(func(context.Context, *SaveDashboardDTO) *models.Dashboard); ok {
+	var r0 *Dashboard
+	if rf, ok := ret.Get(0).(func(context.Context, *SaveDashboardDTO) *Dashboard); ok {
 		r0 = rf(_a0, _a1)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*models.Dashboard)
+			r0 = ret.Get(0).(*Dashboard)
 		}
 	}
 
@@ -135,20 +135,20 @@ func (_m *FakeDashboardProvisioning) SaveFolderForProvisionedDashboards(_a0 cont
 }
 
 // SaveProvisionedDashboard provides a mock function with given fields: ctx, dto, provisioning
-func (_m *FakeDashboardProvisioning) SaveProvisionedDashboard(ctx context.Context, dto *SaveDashboardDTO, provisioning *models.DashboardProvisioning) (*models.Dashboard, error) {
+func (_m *FakeDashboardProvisioning) SaveProvisionedDashboard(ctx context.Context, dto *SaveDashboardDTO, provisioning *DashboardProvisioning) (*Dashboard, error) {
 	ret := _m.Called(ctx, dto, provisioning)
 
-	var r0 *models.Dashboard
-	if rf, ok := ret.Get(0).(func(context.Context, *SaveDashboardDTO, *models.DashboardProvisioning) *models.Dashboard); ok {
+	var r0 *Dashboard
+	if rf, ok := ret.Get(0).(func(context.Context, *SaveDashboardDTO, *DashboardProvisioning) *Dashboard); ok {
 		r0 = rf(ctx, dto, provisioning)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*models.Dashboard)
+			r0 = ret.Get(0).(*Dashboard)
 		}
 	}
 
 	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *SaveDashboardDTO, *models.DashboardProvisioning) error); ok {
+	if rf, ok := ret.Get(1).(func(context.Context, *SaveDashboardDTO, *DashboardProvisioning) error); ok {
 		r1 = rf(ctx, dto, provisioning)
 	} else {
 		r1 = ret.Error(1)

pkg/services/dashboards/dashboard_service_mock.go

@@ -1,4 +1,4 @@
-// Code generated by mockery v2.14.0. DO NOT EDIT.
+// Code generated by mockery v2.16.0. DO NOT EDIT.
 
 package dashboards
 
@@ -15,15 +15,15 @@ type FakeDashboardService struct {
 }
 
 // BuildSaveDashboardCommand provides a mock function with given fields: ctx, dto, shouldValidateAlerts, validateProvisionedDashboard
-func (_m *FakeDashboardService) BuildSaveDashboardCommand(ctx context.Context, dto *SaveDashboardDTO, shouldValidateAlerts bool, validateProvisionedDashboard bool) (*models.SaveDashboardCommand, error) {
+func (_m *FakeDashboardService) BuildSaveDashboardCommand(ctx context.Context, dto *SaveDashboardDTO, shouldValidateAlerts bool, validateProvisionedDashboard bool) (*SaveDashboardCommand, error) {
 	ret := _m.Called(ctx, dto, shouldValidateAlerts, validateProvisionedDashboard)
 
-	var r0 *models.SaveDashboardCommand
-	if rf, ok := ret.Get(0).(func(context.Context, *SaveDashboardDTO, bool, bool) *models.SaveDashboardCommand); ok {
+	var r0 *SaveDashboardCommand
+	if rf, ok := ret.Get(0).(func(context.Context, *SaveDashboardDTO, bool, bool) *SaveDashboardCommand); ok {
 		r0 = rf(ctx, dto, shouldValidateAlerts, validateProvisionedDashboard)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*models.SaveDashboardCommand)
+			r0 = ret.Get(0).(*SaveDashboardCommand)
 		}
 	}
 
@@ -110,11 +110,11 @@ func (_m *FakeDashboardService) FindDashboards(ctx context.Context, query *model
 }
 
 // GetDashboard provides a mock function with given fields: ctx, query
-func (_m *FakeDashboardService) GetDashboard(ctx context.Context, query *models.GetDashboardQuery) error {
+func (_m *FakeDashboardService) GetDashboard(ctx context.Context, query *GetDashboardQuery) error {
 	ret := _m.Called(ctx, query)
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *models.GetDashboardQuery) error); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *GetDashboardQuery) error); ok {
 		r0 = rf(ctx, query)
 	} else {
 		r0 = ret.Error(0)
@@ -151,12 +151,12 @@ func (_m *FakeDashboardService) GetDashboardTags(ctx context.Context, query *mod
 	return r0
 }
 
-// GetDashboardUIDById provides a mock function with given fields: ctx, query
-func (_m *FakeDashboardService) GetDashboardUIDById(ctx context.Context, query *models.GetDashboardRefByIdQuery) error {
+// GetDashboardUIDByID provides a mock function with given fields: ctx, query
+func (_m *FakeDashboardService) GetDashboardUIDByID(ctx context.Context, query *GetDashboardRefByIDQuery) error {
 	ret := _m.Called(ctx, query)
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *models.GetDashboardRefByIdQuery) error); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *GetDashboardRefByIDQuery) error); ok {
 		r0 = rf(ctx, query)
 	} else {
 		r0 = ret.Error(0)
@@ -166,11 +166,11 @@ func (_m *FakeDashboardService) GetDashboardUIDById(ctx context.Context, query *
 }
 
 // GetDashboards provides a mock function with given fields: ctx, query
-func (_m *FakeDashboardService) GetDashboards(ctx context.Context, query *models.GetDashboardsQuery) error {
+func (_m *FakeDashboardService) GetDashboards(ctx context.Context, query *GetDashboardsQuery) error {
 	ret := _m.Called(ctx, query)
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *models.GetDashboardsQuery) error); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *GetDashboardsQuery) error); ok {
 		r0 = rf(ctx, query)
 	} else {
 		r0 = ret.Error(0)
@@ -208,15 +208,15 @@ func (_m *FakeDashboardService) HasEditPermissionInFolders(ctx context.Context,
 }
 
 // ImportDashboard provides a mock function with given fields: ctx, dto
-func (_m *FakeDashboardService) ImportDashboard(ctx context.Context, dto *SaveDashboardDTO) (*models.Dashboard, error) {
+func (_m *FakeDashboardService) ImportDashboard(ctx context.Context, dto *SaveDashboardDTO) (*Dashboard, error) {
 	ret := _m.Called(ctx, dto)
 
-	var r0 *models.Dashboard
-	if rf, ok := ret.Get(0).(func(context.Context, *SaveDashboardDTO) *models.Dashboard); ok {
+	var r0 *Dashboard
+	if rf, ok := ret.Get(0).(func(context.Context, *SaveDashboardDTO) *Dashboard); ok {
 		r0 = rf(ctx, dto)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*models.Dashboard)
+			r0 = ret.Get(0).(*Dashboard)
 		}
 	}
 
@@ -245,15 +245,15 @@ func (_m *FakeDashboardService) MakeUserAdmin(ctx context.Context, orgID int64,
 }
 
 // SaveDashboard provides a mock function with given fields: ctx, dto, allowUiUpdate
-func (_m *FakeDashboardService) SaveDashboard(ctx context.Context, dto *SaveDashboardDTO, allowUiUpdate bool) (*models.Dashboard, error) {
+func (_m *FakeDashboardService) SaveDashboard(ctx context.Context, dto *SaveDashboardDTO, allowUiUpdate bool) (*Dashboard, error) {
 	ret := _m.Called(ctx, dto, allowUiUpdate)
 
-	var r0 *models.Dashboard
-	if rf, ok := ret.Get(0).(func(context.Context, *SaveDashboardDTO, bool) *models.Dashboard); ok {
+	var r0 *Dashboard
+	if rf, ok := ret.Get(0).(func(context.Context, *SaveDashboardDTO, bool) *Dashboard); ok {
 		r0 = rf(ctx, dto, allowUiUpdate)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*models.Dashboard)
+			r0 = ret.Get(0).(*Dashboard)
 		}
 	}
 

pkg/services/dashboards/database/acl_test.go

@@ -8,6 +8,7 @@ import (
 
 	"github.com/grafana/grafana/pkg/infra/db"
 	"github.com/grafana/grafana/pkg/models"
+	"github.com/grafana/grafana/pkg/services/dashboards"
 	"github.com/grafana/grafana/pkg/services/org"
 	"github.com/grafana/grafana/pkg/services/org/orgimpl"
 	"github.com/grafana/grafana/pkg/services/quota/quotaimpl"
@@ -25,7 +26,7 @@ func TestIntegrationDashboardACLDataAccess(t *testing.T) {
 	}
 	var sqlStore *sqlstore.SQLStore
 	var currentUser user.User
-	var savedFolder, childDash *models.Dashboard
+	var savedFolder, childDash *dashboards.Dashboard
 	var dashboardStore *DashboardStore
 
 	setup := func(t *testing.T) {
@@ -36,14 +37,14 @@ func TestIntegrationDashboardACLDataAccess(t *testing.T) {
 		require.NoError(t, err)
 		currentUser = createUser(t, sqlStore, "viewer", "Viewer", false)
 		savedFolder = insertTestDashboard(t, dashboardStore, "1 test dash folder", 1, 0, true, "prod", "webapp")
-		childDash = insertTestDashboard(t, dashboardStore, "2 test dash", 1, savedFolder.Id, false, "prod", "webapp")
+		childDash = insertTestDashboard(t, dashboardStore, "2 test dash", 1, savedFolder.ID, false, "prod", "webapp")
 	}
 
 	t.Run("Dashboard permission with userId and teamId set to 0", func(t *testing.T) {
 		setup(t)
-		err := updateDashboardACL(t, dashboardStore, savedFolder.Id, models.DashboardACL{
+		err := updateDashboardACL(t, dashboardStore, savedFolder.ID, models.DashboardACL{
 			OrgID:       1,
-			DashboardID: savedFolder.Id,
+			DashboardID: savedFolder.ID,
 			Permission:  models.PERMISSION_EDIT,
 		})
 		require.Equal(t, models.ErrDashboardACLInfoMissing, err)
@@ -51,7 +52,7 @@ func TestIntegrationDashboardACLDataAccess(t *testing.T) {
 
 	t.Run("Folder acl should include default acl", func(t *testing.T) {
 		setup(t)
-		query := models.GetDashboardACLInfoListQuery{DashboardID: savedFolder.Id, OrgID: 1}
+		query := models.GetDashboardACLInfoListQuery{DashboardID: savedFolder.ID, OrgID: 1}
 
 		err := dashboardStore.GetDashboardACLInfoList(context.Background(), &query)
 		require.Nil(t, err)
@@ -68,7 +69,7 @@ func TestIntegrationDashboardACLDataAccess(t *testing.T) {
 
 	t.Run("Dashboard acl should include acl for parent folder", func(t *testing.T) {
 		setup(t)
-		query := models.GetDashboardACLInfoListQuery{DashboardID: childDash.Id, OrgID: 1}
+		query := models.GetDashboardACLInfoListQuery{DashboardID: childDash.ID, OrgID: 1}
 
 		err := dashboardStore.GetDashboardACLInfoList(context.Background(), &query)
 		require.Nil(t, err)
@@ -85,10 +86,10 @@ func TestIntegrationDashboardACLDataAccess(t *testing.T) {
 
 	t.Run("Folder with removed default permissions returns no acl items", func(t *testing.T) {
 		setup(t)
-		err := dashboardStore.UpdateDashboardACL(context.Background(), savedFolder.Id, nil)
+		err := dashboardStore.UpdateDashboardACL(context.Background(), savedFolder.ID, nil)
 		require.Nil(t, err)
 
-		query := models.GetDashboardACLInfoListQuery{DashboardID: childDash.Id, OrgID: 1}
+		query := models.GetDashboardACLInfoListQuery{DashboardID: childDash.ID, OrgID: 1}
 		err = dashboardStore.GetDashboardACLInfoList(context.Background(), &query)
 		require.Nil(t, err)
 
@@ -98,43 +99,43 @@ func TestIntegrationDashboardACLDataAccess(t *testing.T) {
 	t.Run("Given a dashboard folder and a user", func(t *testing.T) {
 		t.Run("Given dashboard folder permission", func(t *testing.T) {
 			setup(t)
-			err := updateDashboardACL(t, dashboardStore, savedFolder.Id, models.DashboardACL{
+			err := updateDashboardACL(t, dashboardStore, savedFolder.ID, models.DashboardACL{
 				OrgID:       1,
 				UserID:      currentUser.ID,
-				DashboardID: savedFolder.Id,
+				DashboardID: savedFolder.ID,
 				Permission:  models.PERMISSION_EDIT,
 			})
 			require.Nil(t, err)
 
 			t.Run("When reading dashboard acl should include acl for parent folder", func(t *testing.T) {
-				query := models.GetDashboardACLInfoListQuery{DashboardID: childDash.Id, OrgID: 1}
+				query := models.GetDashboardACLInfoListQuery{DashboardID: childDash.ID, OrgID: 1}
 
 				err := dashboardStore.GetDashboardACLInfoList(context.Background(), &query)
 				require.Nil(t, err)
 
 				require.Equal(t, 1, len(query.Result))
-				require.Equal(t, savedFolder.Id, query.Result[0].DashboardId)
+				require.Equal(t, savedFolder.ID, query.Result[0].DashboardId)
 			})
 
 			t.Run("Given child dashboard permission", func(t *testing.T) {
-				err := updateDashboardACL(t, dashboardStore, childDash.Id, models.DashboardACL{
+				err := updateDashboardACL(t, dashboardStore, childDash.ID, models.DashboardACL{
 					OrgID:       1,
 					UserID:      currentUser.ID,
-					DashboardID: childDash.Id,
+					DashboardID: childDash.ID,
 					Permission:  models.PERMISSION_EDIT,
 				})
 				require.Nil(t, err)
 
 				t.Run("When reading dashboard acl should include acl for parent folder and child", func(t *testing.T) {
-					query := models.GetDashboardACLInfoListQuery{OrgID: 1, DashboardID: childDash.Id}
+					query := models.GetDashboardACLInfoListQuery{OrgID: 1, DashboardID: childDash.ID}
 
 					err := dashboardStore.GetDashboardACLInfoList(context.Background(), &query)
 					require.Nil(t, err)
 
 					require.Equal(t, 2, len(query.Result))
-					require.Equal(t, savedFolder.Id, query.Result[0].DashboardId)
+					require.Equal(t, savedFolder.ID, query.Result[0].DashboardId)
 					require.True(t, query.Result[0].Inherited)
-					require.Equal(t, childDash.Id, query.Result[1].DashboardId)
+					require.Equal(t, childDash.ID, query.Result[1].DashboardId)
 					require.False(t, query.Result[1].Inherited)
 				})
 			})
@@ -142,15 +143,15 @@ func TestIntegrationDashboardACLDataAccess(t *testing.T) {
 
 		t.Run("Reading dashboard acl should include default acl for parent folder and the child acl", func(t *testing.T) {
 			setup(t)
-			err := updateDashboardACL(t, dashboardStore, childDash.Id, models.DashboardACL{
+			err := updateDashboardACL(t, dashboardStore, childDash.ID, models.DashboardACL{
 				OrgID:       1,
 				UserID:      currentUser.ID,
-				DashboardID: childDash.Id,
+				DashboardID: childDash.ID,
 				Permission:  models.PERMISSION_EDIT,
 			})
 			require.Nil(t, err)
 
-			query := models.GetDashboardACLInfoListQuery{OrgID: 1, DashboardID: childDash.Id}
+			query := models.GetDashboardACLInfoListQuery{OrgID: 1, DashboardID: childDash.ID}
 
 			err = dashboardStore.GetDashboardACLInfoList(context.Background(), &query)
 			require.Nil(t, err)
@@ -163,35 +164,35 @@ func TestIntegrationDashboardACLDataAccess(t *testing.T) {
 			require.Equal(t, defaultPermissionsId, query.Result[1].DashboardId)
 			require.Equal(t, org.RoleEditor, *query.Result[1].Role)
 			require.True(t, query.Result[1].Inherited)
-			require.Equal(t, childDash.Id, query.Result[2].DashboardId)
+			require.Equal(t, childDash.ID, query.Result[2].DashboardId)
 			require.False(t, query.Result[2].Inherited)
 		})
 
 		t.Run("Add and delete dashboard permission", func(t *testing.T) {
 			setup(t)
-			err := updateDashboardACL(t, dashboardStore, savedFolder.Id, models.DashboardACL{
+			err := updateDashboardACL(t, dashboardStore, savedFolder.ID, models.DashboardACL{
 				OrgID:       1,
 				UserID:      currentUser.ID,
-				DashboardID: savedFolder.Id,
+				DashboardID: savedFolder.ID,
 				Permission:  models.PERMISSION_EDIT,
 			})
 			require.Nil(t, err)
 
-			q1 := &models.GetDashboardACLInfoListQuery{DashboardID: savedFolder.Id, OrgID: 1}
+			q1 := &models.GetDashboardACLInfoListQuery{DashboardID: savedFolder.ID, OrgID: 1}
 			err = dashboardStore.GetDashboardACLInfoList(context.Background(), q1)
 			require.Nil(t, err)
 
-			require.Equal(t, savedFolder.Id, q1.Result[0].DashboardId)
+			require.Equal(t, savedFolder.ID, q1.Result[0].DashboardId)
 			require.Equal(t, models.PERMISSION_EDIT, q1.Result[0].Permission)
 			require.Equal(t, "Edit", q1.Result[0].PermissionName)
 			require.Equal(t, currentUser.ID, q1.Result[0].UserId)
 			require.Equal(t, currentUser.Login, q1.Result[0].UserLogin)
 			require.Equal(t, currentUser.Email, q1.Result[0].UserEmail)
 
-			err = updateDashboardACL(t, dashboardStore, savedFolder.Id)
+			err = updateDashboardACL(t, dashboardStore, savedFolder.ID)
 			require.Nil(t, err)
 
-			q3 := &models.GetDashboardACLInfoListQuery{DashboardID: savedFolder.Id, OrgID: 1}
+			q3 := &models.GetDashboardACLInfoListQuery{DashboardID: savedFolder.ID, OrgID: 1}
 			err = dashboardStore.GetDashboardACLInfoList(context.Background(), q3)
 			require.Nil(t, err)
 			require.Equal(t, 0, len(q3.Result))
@@ -203,18 +204,18 @@ func TestIntegrationDashboardACLDataAccess(t *testing.T) {
 			team1, err := teamSvc.CreateTeam("group1 name", "", 1)
 			require.Nil(t, err)
 
-			err = updateDashboardACL(t, dashboardStore, savedFolder.Id, models.DashboardACL{
+			err = updateDashboardACL(t, dashboardStore, savedFolder.ID, models.DashboardACL{
 				OrgID:       1,
 				TeamID:      team1.ID,
-				DashboardID: savedFolder.Id,
+				DashboardID: savedFolder.ID,
 				Permission:  models.PERMISSION_EDIT,
 			})
 			require.Nil(t, err)
 
-			q1 := &models.GetDashboardACLInfoListQuery{DashboardID: savedFolder.Id, OrgID: 1}
+			q1 := &models.GetDashboardACLInfoListQuery{DashboardID: savedFolder.ID, OrgID: 1}
 			err = dashboardStore.GetDashboardACLInfoList(context.Background(), q1)
 			require.Nil(t, err)
-			require.Equal(t, savedFolder.Id, q1.Result[0].DashboardId)
+			require.Equal(t, savedFolder.ID, q1.Result[0].DashboardId)
 			require.Equal(t, models.PERMISSION_EDIT, q1.Result[0].Permission)
 			require.Equal(t, team1.ID, q1.Result[0].TeamId)
 		})
@@ -224,19 +225,19 @@ func TestIntegrationDashboardACLDataAccess(t *testing.T) {
 			teamSvc := teamimpl.ProvideService(sqlStore, sqlStore.Cfg)
 			team1, err := teamSvc.CreateTeam("group1 name", "", 1)
 			require.Nil(t, err)
-			err = updateDashboardACL(t, dashboardStore, savedFolder.Id, models.DashboardACL{
+			err = updateDashboardACL(t, dashboardStore, savedFolder.ID, models.DashboardACL{
 				OrgID:       1,
 				TeamID:      team1.ID,
-				DashboardID: savedFolder.Id,
+				DashboardID: savedFolder.ID,
 				Permission:  models.PERMISSION_ADMIN,
 			})
 			require.Nil(t, err)
 
-			q3 := &models.GetDashboardACLInfoListQuery{DashboardID: savedFolder.Id, OrgID: 1}
+			q3 := &models.GetDashboardACLInfoListQuery{DashboardID: savedFolder.ID, OrgID: 1}
 			err = dashboardStore.GetDashboardACLInfoList(context.Background(), q3)
 			require.Nil(t, err)
 			require.Equal(t, 1, len(q3.Result))
-			require.Equal(t, savedFolder.Id, q3.Result[0].DashboardId)
+			require.Equal(t, savedFolder.ID, q3.Result[0].DashboardId)
 			require.Equal(t, models.PERMISSION_ADMIN, q3.Result[0].Permission)
 			require.Equal(t, team1.ID, q3.Result[0].TeamId)
 		})

pkg/services/dashboards/database/database.go

@@ -69,11 +69,11 @@ func (d *DashboardStore) emitEntityEvent() bool {
 	return d.features != nil && d.features.IsEnabled(featuremgmt.FlagPanelTitleSearch)
 }
 
-func (d *DashboardStore) ValidateDashboardBeforeSave(ctx context.Context, dashboard *models.Dashboard, overwrite bool) (bool, error) {
+func (d *DashboardStore) ValidateDashboardBeforeSave(ctx context.Context, dashboard *dashboards.Dashboard, overwrite bool) (bool, error) {
 	isParentFolderChanged := false
 	err := d.store.WithTransactionalDbSession(ctx, func(sess *db.Session) error {
 		var err error
-		isParentFolderChanged, err = getExistingDashboardByIdOrUidForUpdate(sess, dashboard, d.store.GetDialect(), overwrite)
+		isParentFolderChanged, err = getExistingDashboardByIDOrUIDForUpdate(sess, dashboard, d.store.GetDialect(), overwrite)
 		if err != nil {
 			return err
 		}
@@ -204,7 +204,7 @@ func (d *DashboardStore) GetProvisionedDashboardData(ctx context.Context, name s
 	return result, err
 }
 
-func (d *DashboardStore) SaveProvisionedDashboard(ctx context.Context, cmd models.SaveDashboardCommand, provisioning *models.DashboardProvisioning) (*models.Dashboard, error) {
+func (d *DashboardStore) SaveProvisionedDashboard(ctx context.Context, cmd dashboards.SaveDashboardCommand, provisioning *dashboards.DashboardProvisioning) (*dashboards.Dashboard, error) {
 	err := d.store.WithTransactionalDbSession(ctx, func(sess *db.Session) error {
 		if err := saveDashboard(sess, &cmd, d.emitEntityEvent()); err != nil {
 			return err
@@ -220,7 +220,7 @@ func (d *DashboardStore) SaveProvisionedDashboard(ctx context.Context, cmd model
 	return cmd.Result, err
 }
 
-func (d *DashboardStore) SaveDashboard(ctx context.Context, cmd models.SaveDashboardCommand) (*models.Dashboard, error) {
+func (d *DashboardStore) SaveDashboard(ctx context.Context, cmd dashboards.SaveDashboardCommand) (*dashboards.Dashboard, error) {
 	err := d.store.WithTransactionalDbSession(ctx, func(sess *db.Session) error {
 		return saveDashboard(sess, &cmd, d.emitEntityEvent())
 	})
@@ -354,14 +354,14 @@ func (d *DashboardStore) Count(ctx context.Context, scopeParams *quota.ScopePara
 	return u, nil
 }
 
-func getExistingDashboardByIdOrUidForUpdate(sess *db.Session, dash *models.Dashboard, dialect migrator.Dialect, overwrite bool) (bool, error) {
+func getExistingDashboardByIDOrUIDForUpdate(sess *db.Session, dash *dashboards.Dashboard, dialect migrator.Dialect, overwrite bool) (bool, error) {
 	dashWithIdExists := false
 	isParentFolderChanged := false
 	var existingById models.Dashboard
 
-	if dash.Id > 0 {
+	if dash.ID > 0 {
 		var err error
-		dashWithIdExists, err = sess.Where("id=? AND org_id=?", dash.Id, dash.OrgId).Get(&existingById)
+		dashWithIdExists, err = sess.Where("id=? AND org_id=?", dash.ID, dash.OrgID).Get(&existingById)
 		if err != nil {
 			return false, fmt.Errorf("SQL query for existing dashboard by ID failed: %w", err)
 		}
@@ -370,25 +370,25 @@ func getExistingDashboardByIdOrUidForUpdate(sess *db.Session, dash *models.Dashb
 			return false, dashboards.ErrDashboardNotFound
 		}
 
-		if dash.Uid == "" {
-			dash.SetUid(existingById.Uid)
+		if dash.UID == "" {
+			dash.SetUID(existingById.Uid)
 		}
 	}
 
 	dashWithUidExists := false
 	var existingByUid models.Dashboard
 
-	if dash.Uid != "" {
+	if dash.UID != "" {
 		var err error
-		dashWithUidExists, err = sess.Where("org_id=? AND uid=?", dash.OrgId, dash.Uid).Get(&existingByUid)
+		dashWithUidExists, err = sess.Where("org_id=? AND uid=?", dash.OrgID, dash.UID).Get(&existingByUid)
 		if err != nil {
 			return false, fmt.Errorf("SQL query for existing dashboard by UID failed: %w", err)
 		}
 	}
 
-	if dash.FolderId > 0 {
+	if dash.FolderID > 0 {
 		var existingFolder models.Dashboard
-		folderExists, err := sess.Where("org_id=? AND id=? AND is_folder=?", dash.OrgId, dash.FolderId,
+		folderExists, err := sess.Where("org_id=? AND id=? AND is_folder=?", dash.OrgID, dash.FolderID,
 			dialect.BooleanStr(true)).Get(&existingFolder)
 		if err != nil {
 			return false, fmt.Errorf("SQL query for folder failed: %w", err)
@@ -410,8 +410,8 @@ func getExistingDashboardByIdOrUidForUpdate(sess *db.Session, dash *models.Dashb
 	existing := existingById
 
 	if !dashWithIdExists && dashWithUidExists {
-		dash.SetId(existingByUid.Id)
-		dash.SetUid(existingByUid.Uid)
+		dash.SetID(existingByUid.Id)
+		dash.SetUID(existingByUid.Uid)
 		existing = existingByUid
 	}
 
@@ -420,7 +420,7 @@ func getExistingDashboardByIdOrUidForUpdate(sess *db.Session, dash *models.Dashb
 		return isParentFolderChanged, dashboards.ErrDashboardTypeMismatch
 	}
 
-	if !dash.IsFolder && dash.FolderId != existing.FolderId {
+	if !dash.IsFolder && dash.FolderID != existing.FolderId {
 		isParentFolderChanged = true
 	}
 
@@ -441,16 +441,16 @@ func getExistingDashboardByIdOrUidForUpdate(sess *db.Session, dash *models.Dashb
 	return isParentFolderChanged, nil
 }
 
-func getExistingDashboardByTitleAndFolder(sess *db.Session, dash *models.Dashboard, dialect migrator.Dialect, overwrite,
+func getExistingDashboardByTitleAndFolder(sess *db.Session, dash *dashboards.Dashboard, dialect migrator.Dialect, overwrite,
 	isParentFolderChanged bool) (bool, error) {
 	var existing models.Dashboard
-	exists, err := sess.Where("org_id=? AND slug=? AND (is_folder=? OR folder_id=?)", dash.OrgId, dash.Slug,
-		dialect.BooleanStr(true), dash.FolderId).Get(&existing)
+	exists, err := sess.Where("org_id=? AND slug=? AND (is_folder=? OR folder_id=?)", dash.OrgID, dash.Slug,
+		dialect.BooleanStr(true), dash.FolderID).Get(&existing)
 	if err != nil {
 		return isParentFolderChanged, fmt.Errorf("SQL query for existing dashboard by org ID or folder ID failed: %w", err)
 	}
 
-	if exists && dash.Id != existing.Id {
+	if exists && dash.ID != existing.Id {
 		if existing.IsFolder && !dash.IsFolder {
 			return isParentFolderChanged, dashboards.ErrDashboardWithSameNameAsFolder
 		}
@@ -459,13 +459,13 @@ func getExistingDashboardByTitleAndFolder(sess *db.Session, dash *models.Dashboa
 			return isParentFolderChanged, dashboards.ErrDashboardFolderWithSameNameAsDashboard
 		}
 
-		if !dash.IsFolder && (dash.FolderId != existing.FolderId || dash.Id == 0) {
+		if !dash.IsFolder && (dash.FolderID != existing.FolderId || dash.ID == 0) {
 			isParentFolderChanged = true
 		}
 
 		if overwrite {
-			dash.SetId(existing.Id)
-			dash.SetUid(existing.Uid)
+			dash.SetID(existing.Id)
+			dash.SetUID(existing.Uid)
 			dash.SetVersion(existing.Version)
 		} else {
 			return isParentFolderChanged, dashboards.ErrDashboardWithSameNameInFolderExists
@@ -475,18 +475,18 @@ func getExistingDashboardByTitleAndFolder(sess *db.Session, dash *models.Dashboa
 	return isParentFolderChanged, nil
 }
 
-func saveDashboard(sess *db.Session, cmd *models.SaveDashboardCommand, emitEntityEvent bool) error {
+func saveDashboard(sess *db.Session, cmd *dashboards.SaveDashboardCommand, emitEntityEvent bool) error {
 	dash := cmd.GetDashboardModel()
 
-	userId := cmd.UserId
+	userId := cmd.UserID
 
 	if userId == 0 {
 		userId = -1
 	}
 
-	if dash.Id > 0 {
+	if dash.ID > 0 {
 		var existing models.Dashboard
-		dashWithIdExists, err := sess.Where("id=? AND org_id=?", dash.Id, dash.OrgId).Get(&existing)
+		dashWithIdExists, err := sess.Where("id=? AND org_id=?", dash.ID, dash.OrgID).Get(&existing)
 		if err != nil {
 			return err
 		}
@@ -509,19 +509,19 @@ func saveDashboard(sess *db.Session, cmd *models.SaveDashboardCommand, emitEntit
 		}
 	}
 
-	if dash.Uid == "" {
-		uid, err := generateNewDashboardUid(sess, dash.OrgId)
+	if dash.UID == "" {
+		uid, err := generateNewDashboardUid(sess, dash.OrgID)
 		if err != nil {
 			return err
 		}
-		dash.SetUid(uid)
+		dash.SetUID(uid)
 	}
 
 	parentVersion := dash.Version
 	var affectedRows int64
 	var err error
 
-	if dash.Id == 0 {
+	if dash.ID == 0 {
 		dash.SetVersion(1)
 		dash.Created = time.Now()
 		dash.CreatedBy = userId
@@ -540,7 +540,7 @@ func saveDashboard(sess *db.Session, cmd *models.SaveDashboardCommand, emitEntit
 
 		dash.UpdatedBy = userId
 
-		affectedRows, err = sess.MustCols("folder_id").ID(dash.Id).Update(dash)
+		affectedRows, err = sess.MustCols("folder_id").ID(dash.ID).Update(dash)
 	}
 
 	if err != nil {
@@ -552,7 +552,7 @@ func saveDashboard(sess *db.Session, cmd *models.SaveDashboardCommand, emitEntit
 	}
 
 	dashVersion := &dashver.DashboardVersion{
-		DashboardID:   dash.Id,
+		DashboardID:   dash.ID,
 		ParentVersion: parentVersion,
 		RestoredFrom:  cmd.RestoredFrom,
 		Version:       dash.Version,
@@ -570,7 +570,7 @@ func saveDashboard(sess *db.Session, cmd *models.SaveDashboardCommand, emitEntit
 	}
 
 	// delete existing tags
-	if _, err = sess.Exec("DELETE FROM dashboard_tag WHERE dashboard_id=?", dash.Id); err != nil {
+	if _, err = sess.Exec("DELETE FROM dashboard_tag WHERE dashboard_id=?", dash.ID); err != nil {
 		return err
 	}
 
@@ -578,7 +578,7 @@ func saveDashboard(sess *db.Session, cmd *models.SaveDashboardCommand, emitEntit
 	tags := dash.GetTags()
 	if len(tags) > 0 {
 		for _, tag := range tags {
-			if _, err := sess.Insert(DashboardTag{DashboardId: dash.Id, Term: tag}); err != nil {
+			if _, err := sess.Insert(DashboardTag{DashboardId: dash.ID, Term: tag}); err != nil {
 				return err
 			}
 		}
@@ -612,16 +612,16 @@ func generateNewDashboardUid(sess *db.Session, orgId int64) (string, error) {
 	return "", dashboards.ErrDashboardFailedGenerateUniqueUid
 }
 
-func saveProvisionedData(sess *db.Session, provisioning *models.DashboardProvisioning, dashboard *models.Dashboard) error {
+func saveProvisionedData(sess *db.Session, provisioning *dashboards.DashboardProvisioning, dashboard *dashboards.Dashboard) error {
 	result := &models.DashboardProvisioning{}
 
-	exist, err := sess.Where("dashboard_id=? AND name = ?", dashboard.Id, provisioning.Name).Get(result)
+	exist, err := sess.Where("dashboard_id=? AND name = ?", dashboard.ID, provisioning.Name).Get(result)
 	if err != nil {
 		return err
 	}
 
-	provisioning.Id = result.Id
-	provisioning.DashboardId = dashboard.Id
+	provisioning.ID = result.Id
+	provisioning.DashboardID = dashboard.ID
 
 	if exist {
 		_, err = sess.ID(result.Id).Update(provisioning)
@@ -767,7 +767,7 @@ func (d *DashboardStore) DeleteDashboard(ctx context.Context, cmd *models.Delete
 }
 
 func (d *DashboardStore) deleteDashboard(cmd *models.DeleteDashboardCommand, sess *db.Session, emitEntityEvent bool) error {
-	dashboard := models.Dashboard{Id: cmd.Id, OrgId: cmd.OrgId}
+	dashboard := dashboards.Dashboard{ID: cmd.Id, OrgID: cmd.OrgId}
 	has, err := sess.Get(&dashboard)
 	if err != nil {
 		return err
@@ -794,7 +794,7 @@ func (d *DashboardStore) deleteDashboard(cmd *models.DeleteDashboardCommand, ses
 			Id  int64
 			Uid string
 		}
-		err := sess.SQL("SELECT id, uid FROM dashboard WHERE folder_id = ?", dashboard.Id).Find(&dashIds)
+		err := sess.SQL("SELECT id, uid FROM dashboard WHERE folder_id = ?", dashboard.ID).Find(&dashIds)
 		if err != nil {
 			return err
 		}
@@ -806,7 +806,7 @@ func (d *DashboardStore) deleteDashboard(cmd *models.DeleteDashboardCommand, ses
 		}
 
 		// remove all access control permission with folder scope
-		_, err = sess.Exec("DELETE FROM permission WHERE scope = ?", dashboards.ScopeFoldersProvider.GetResourceScopeUID(dashboard.Uid))
+		_, err = sess.Exec("DELETE FROM permission WHERE scope = ?", dashboards.ScopeFoldersProvider.GetResourceScopeUID(dashboard.UID))
 		if err != nil {
 			return err
 		}
@@ -830,7 +830,7 @@ func (d *DashboardStore) deleteDashboard(cmd *models.DeleteDashboardCommand, ses
 				"DELETE FROM dashboard_public WHERE dashboard_uid IN (SELECT uid FROM dashboard WHERE org_id = ? AND folder_id = ?)",
 			}
 			for _, sql := range childrenDeletes {
-				_, err := sess.Exec(sql, dashboard.OrgId, dashboard.Id)
+				_, err := sess.Exec(sql, dashboard.OrgID, dashboard.ID)
 				if err != nil {
 					return err
 				}
@@ -838,7 +838,7 @@ func (d *DashboardStore) deleteDashboard(cmd *models.DeleteDashboardCommand, ses
 		}
 
 		var existingRuleID int64
-		exists, err := sess.Table("alert_rule").Where("namespace_uid = (SELECT uid FROM dashboard WHERE id = ?)", dashboard.Id).Cols("id").Get(&existingRuleID)
+		exists, err := sess.Table("alert_rule").Where("namespace_uid = (SELECT uid FROM dashboard WHERE id = ?)", dashboard.ID).Cols("id").Get(&existingRuleID)
 		if err != nil {
 			return err
 		}
@@ -854,25 +854,25 @@ func (d *DashboardStore) deleteDashboard(cmd *models.DeleteDashboardCommand, ses
 			}
 
 			for _, sql := range deleteNGAlertsByFolder {
-				_, err := sess.Exec(sql, dashboard.Id)
+				_, err := sess.Exec(sql, dashboard.ID)
 				if err != nil {
 					return err
 				}
 			}
 		}
 	} else {
-		_, err = sess.Exec("DELETE FROM permission WHERE scope = ?", ac.GetResourceScopeUID("dashboards", dashboard.Uid))
+		_, err = sess.Exec("DELETE FROM permission WHERE scope = ?", ac.GetResourceScopeUID("dashboards", dashboard.UID))
 		if err != nil {
 			return err
 		}
 	}
 
-	if err := d.deleteAlertDefinition(dashboard.Id, sess); err != nil {
+	if err := d.deleteAlertDefinition(dashboard.ID, sess); err != nil {
 		return err
 	}
 
 	for _, sql := range deletes {
-		_, err := sess.Exec(sql, dashboard.Id)
+		_, err := sess.Exec(sql, dashboard.ID)
 		if err != nil {
 			return err
 		}
@@ -887,18 +887,18 @@ func (d *DashboardStore) deleteDashboard(cmd *models.DeleteDashboardCommand, ses
 	return nil
 }
 
-func createEntityEvent(dashboard *models.Dashboard, eventType store.EntityEventType) *store.EntityEvent {
+func createEntityEvent(dashboard *dashboards.Dashboard, eventType store.EntityEventType) *store.EntityEvent {
 	var entityEvent *store.EntityEvent
 	if dashboard.IsFolder {
 		entityEvent = &store.EntityEvent{
 			EventType: eventType,
-			EntityId:  store.CreateDatabaseEntityId(dashboard.Uid, dashboard.OrgId, store.EntityTypeFolder),
+			EntityId:  store.CreateDatabaseEntityId(dashboard.UID, dashboard.OrgID, store.EntityTypeFolder),
 			Created:   time.Now().Unix(),
 		}
 	} else {
 		entityEvent = &store.EntityEvent{
 			EventType: eventType,
-			EntityId:  store.CreateDatabaseEntityId(dashboard.Uid, dashboard.OrgId, store.EntityTypeDashboard),
+			EntityId:  store.CreateDatabaseEntityId(dashboard.UID, dashboard.OrgID, store.EntityTypeDashboard),
 			Created:   time.Now().Unix(),
 		}
 	}
@@ -922,13 +922,13 @@ func (d *DashboardStore) deleteAlertDefinition(dashboardId int64, sess *db.Sessi
 	return nil
 }
 
-func (d *DashboardStore) GetDashboard(ctx context.Context, query *models.GetDashboardQuery) (*models.Dashboard, error) {
+func (d *DashboardStore) GetDashboard(ctx context.Context, query *dashboards.GetDashboardQuery) (*dashboards.Dashboard, error) {
 	err := d.store.WithDbSession(ctx, func(sess *db.Session) error {
-		if query.Id == 0 && len(query.Slug) == 0 && len(query.Uid) == 0 {
+		if query.ID == 0 && len(query.Slug) == 0 && len(query.UID) == 0 {
 			return dashboards.ErrDashboardIdentifierNotSet
 		}
 
-		dashboard := models.Dashboard{Slug: query.Slug, OrgId: query.OrgId, Id: query.Id, Uid: query.Uid}
+		dashboard := dashboards.Dashboard{Slug: query.Slug, OrgID: query.OrgID, ID: query.ID, UID: query.UID}
 		has, err := sess.Get(&dashboard)
 
 		if err != nil {
@@ -937,8 +937,8 @@ func (d *DashboardStore) GetDashboard(ctx context.Context, query *models.GetDash
 			return dashboards.ErrDashboardNotFound
 		}
 
-		dashboard.SetId(dashboard.Id)
-		dashboard.SetUid(dashboard.Uid)
+		dashboard.SetID(dashboard.ID)
+		dashboard.SetUID(dashboard.UID)
 		query.Result = &dashboard
 		return nil
 	})
@@ -946,11 +946,11 @@ func (d *DashboardStore) GetDashboard(ctx context.Context, query *models.GetDash
 	return query.Result, err
 }
 
-func (d *DashboardStore) GetDashboardUIDById(ctx context.Context, query *models.GetDashboardRefByIdQuery) error {
+func (d *DashboardStore) GetDashboardUIDByID(ctx context.Context, query *dashboards.GetDashboardRefByIDQuery) error {
 	return d.store.WithDbSession(ctx, func(sess *db.Session) error {
 		var rawSQL = `SELECT uid, slug from dashboard WHERE Id=?`
-		us := &models.DashboardRef{}
-		exists, err := sess.SQL(rawSQL, query.Id).Get(us)
+		us := &dashboards.DashboardRef{}
+		exists, err := sess.SQL(rawSQL, query.ID).Get(us)
 		if err != nil {
 			return err
 		} else if !exists {
@@ -961,18 +961,18 @@ func (d *DashboardStore) GetDashboardUIDById(ctx context.Context, query *models.
 	})
 }
 
-func (d *DashboardStore) GetDashboards(ctx context.Context, query *models.GetDashboardsQuery) error {
+func (d *DashboardStore) GetDashboards(ctx context.Context, query *dashboards.GetDashboardsQuery) error {
 	return d.store.WithDbSession(ctx, func(sess *db.Session) error {
-		if len(query.DashboardIds) == 0 && len(query.DashboardUIds) == 0 {
+		if len(query.DashboardIDs) == 0 && len(query.DashboardUIDs) == 0 {
 			return star.ErrCommandValidationFailed
 		}
 
-		var dashboards = make([]*models.Dashboard, 0)
+		var dashboards = make([]*dashboards.Dashboard, 0)
 		var session *xorm.Session
-		if len(query.DashboardIds) > 0 {
-			session = sess.In("id", query.DashboardIds)
+		if len(query.DashboardIDs) > 0 {
+			session = sess.In("id", query.DashboardIDs)
 		} else {
-			session = sess.In("uid", query.DashboardUIds)
+			session = sess.In("uid", query.DashboardUIDs)
 		}
 
 		err := session.Find(&dashboards)

pkg/services/dashboards/database/database_folder_test.go

@@ -27,7 +27,7 @@ func TestIntegrationDashboardFolderDataAccess(t *testing.T) {
 	}
 	t.Run("Testing DB", func(t *testing.T) {
 		var sqlStore *sqlstore.SQLStore
-		var folder, dashInRoot, childDash *models.Dashboard
+		var folder, dashInRoot, childDash *dashboards.Dashboard
 		var currentUser user.User
 		var dashboardStore *DashboardStore
 
@@ -40,8 +40,8 @@ func TestIntegrationDashboardFolderDataAccess(t *testing.T) {
 			require.NoError(t, err)
 			folder = insertTestDashboard(t, dashboardStore, "1 test dash folder", 1, 0, true, "prod", "webapp")
 			dashInRoot = insertTestDashboard(t, dashboardStore, "test dash 67", 1, 0, false, "prod", "webapp")
-			childDash = insertTestDashboard(t, dashboardStore, "test dash 23", 1, folder.Id, false, "prod", "webapp")
-			insertTestDashboard(t, dashboardStore, "test dash 45", 1, folder.Id, false, "prod")
+			childDash = insertTestDashboard(t, dashboardStore, "test dash 23", 1, folder.ID, false, "prod", "webapp")
+			insertTestDashboard(t, dashboardStore, "test dash 45", 1, folder.ID, false, "prod")
 			currentUser = createUser(t, sqlStore, "viewer", "Viewer", false)
 		}
 
@@ -53,20 +53,20 @@ func TestIntegrationDashboardFolderDataAccess(t *testing.T) {
 					query := &models.FindPersistedDashboardsQuery{
 						SignedInUser: &user.SignedInUser{UserID: currentUser.ID, OrgID: 1, OrgRole: org.RoleViewer},
 						OrgId:        1,
-						DashboardIds: []int64{folder.Id, dashInRoot.Id},
+						DashboardIds: []int64{folder.ID, dashInRoot.ID},
 					}
 					err := testSearchDashboards(dashboardStore, query)
 					require.NoError(t, err)
 					require.Equal(t, len(query.Result), 2)
-					require.Equal(t, query.Result[0].ID, folder.Id)
-					require.Equal(t, query.Result[1].ID, dashInRoot.Id)
+					require.Equal(t, query.Result[0].ID, folder.ID)
+					require.Equal(t, query.Result[1].ID, dashInRoot.ID)
 				})
 			})
 
 			t.Run("and acl is set for dashboard folder", func(t *testing.T) {
 				var otherUser int64 = 999
-				err := updateDashboardACL(t, dashboardStore, folder.Id, models.DashboardACL{
-					DashboardID: folder.Id,
+				err := updateDashboardACL(t, dashboardStore, folder.ID, models.DashboardACL{
+					DashboardID: folder.ID,
 					OrgID:       1,
 					UserID:      otherUser,
 					Permission:  models.PERMISSION_EDIT,
@@ -76,18 +76,18 @@ func TestIntegrationDashboardFolderDataAccess(t *testing.T) {
 				t.Run("should not return folder", func(t *testing.T) {
 					query := &models.FindPersistedDashboardsQuery{
 						SignedInUser: &user.SignedInUser{UserID: currentUser.ID, OrgID: 1, OrgRole: org.RoleViewer},
-						OrgId:        1, DashboardIds: []int64{folder.Id, dashInRoot.Id},
+						OrgId:        1, DashboardIds: []int64{folder.ID, dashInRoot.ID},
 					}
 					err := testSearchDashboards(dashboardStore, query)
 					require.NoError(t, err)
 
 					require.Equal(t, len(query.Result), 1)
-					require.Equal(t, query.Result[0].ID, dashInRoot.Id)
+					require.Equal(t, query.Result[0].ID, dashInRoot.ID)
 				})
 
 				t.Run("when the user is given permission", func(t *testing.T) {
-					err := updateDashboardACL(t, dashboardStore, folder.Id, models.DashboardACL{
-						DashboardID: folder.Id, OrgID: 1, UserID: currentUser.ID, Permission: models.PERMISSION_EDIT,
+					err := updateDashboardACL(t, dashboardStore, folder.ID, models.DashboardACL{
+						DashboardID: folder.ID, OrgID: 1, UserID: currentUser.ID, Permission: models.PERMISSION_EDIT,
 					})
 					require.NoError(t, err)
 
@@ -95,13 +95,13 @@ func TestIntegrationDashboardFolderDataAccess(t *testing.T) {
 						query := &models.FindPersistedDashboardsQuery{
 							SignedInUser: &user.SignedInUser{UserID: currentUser.ID, OrgID: 1, OrgRole: org.RoleViewer},
 							OrgId:        1,
-							DashboardIds: []int64{folder.Id, dashInRoot.Id},
+							DashboardIds: []int64{folder.ID, dashInRoot.ID},
 						}
 						err := testSearchDashboards(dashboardStore, query)
 						require.NoError(t, err)
 						require.Equal(t, len(query.Result), 2)
-						require.Equal(t, query.Result[0].ID, folder.Id)
-						require.Equal(t, query.Result[1].ID, dashInRoot.Id)
+						require.Equal(t, query.Result[0].ID, folder.ID)
+						require.Equal(t, query.Result[1].ID, dashInRoot.ID)
 					})
 				})
 
@@ -114,49 +114,49 @@ func TestIntegrationDashboardFolderDataAccess(t *testing.T) {
 								OrgRole: org.RoleAdmin,
 							},
 							OrgId:        1,
-							DashboardIds: []int64{folder.Id, dashInRoot.Id},
+							DashboardIds: []int64{folder.ID, dashInRoot.ID},
 						}
 						err := testSearchDashboards(dashboardStore, query)
 						require.NoError(t, err)
 						require.Equal(t, len(query.Result), 2)
-						require.Equal(t, query.Result[0].ID, folder.Id)
-						require.Equal(t, query.Result[1].ID, dashInRoot.Id)
+						require.Equal(t, query.Result[0].ID, folder.ID)
+						require.Equal(t, query.Result[1].ID, dashInRoot.ID)
 					})
 				})
 			})
 
 			t.Run("and acl is set for dashboard child and folder has all permissions removed", func(t *testing.T) {
 				var otherUser int64 = 999
-				err := updateDashboardACL(t, dashboardStore, folder.Id)
+				err := updateDashboardACL(t, dashboardStore, folder.ID)
 				require.NoError(t, err)
-				err = updateDashboardACL(t, dashboardStore, childDash.Id, models.DashboardACL{
-					DashboardID: folder.Id, OrgID: 1, UserID: otherUser, Permission: models.PERMISSION_EDIT,
+				err = updateDashboardACL(t, dashboardStore, childDash.ID, models.DashboardACL{
+					DashboardID: folder.ID, OrgID: 1, UserID: otherUser, Permission: models.PERMISSION_EDIT,
 				})
 				require.NoError(t, err)
 
 				t.Run("should not return folder or child", func(t *testing.T) {
 					query := &models.FindPersistedDashboardsQuery{
-						SignedInUser: &user.SignedInUser{UserID: currentUser.ID, OrgID: 1, OrgRole: org.RoleViewer}, OrgId: 1, DashboardIds: []int64{folder.Id, childDash.Id, dashInRoot.Id},
+						SignedInUser: &user.SignedInUser{UserID: currentUser.ID, OrgID: 1, OrgRole: org.RoleViewer}, OrgId: 1, DashboardIds: []int64{folder.ID, childDash.ID, dashInRoot.ID},
 					}
 					err := testSearchDashboards(dashboardStore, query)
 					require.NoError(t, err)
 					require.Equal(t, len(query.Result), 1)
-					require.Equal(t, query.Result[0].ID, dashInRoot.Id)
+					require.Equal(t, query.Result[0].ID, dashInRoot.ID)
 				})
 
 				t.Run("when the user is given permission to child", func(t *testing.T) {
-					err := updateDashboardACL(t, dashboardStore, childDash.Id, models.DashboardACL{
-						DashboardID: childDash.Id, OrgID: 1, UserID: currentUser.ID, Permission: models.PERMISSION_EDIT,
+					err := updateDashboardACL(t, dashboardStore, childDash.ID, models.DashboardACL{
+						DashboardID: childDash.ID, OrgID: 1, UserID: currentUser.ID, Permission: models.PERMISSION_EDIT,
 					})
 					require.NoError(t, err)
 
 					t.Run("should be able to search for child dashboard but not folder", func(t *testing.T) {
-						query := &models.FindPersistedDashboardsQuery{SignedInUser: &user.SignedInUser{UserID: currentUser.ID, OrgID: 1, OrgRole: org.RoleViewer}, OrgId: 1, DashboardIds: []int64{folder.Id, childDash.Id, dashInRoot.Id}}
+						query := &models.FindPersistedDashboardsQuery{SignedInUser: &user.SignedInUser{UserID: currentUser.ID, OrgID: 1, OrgRole: org.RoleViewer}, OrgId: 1, DashboardIds: []int64{folder.ID, childDash.ID, dashInRoot.ID}}
 						err := testSearchDashboards(dashboardStore, query)
 						require.NoError(t, err)
 						require.Equal(t, len(query.Result), 2)
-						require.Equal(t, query.Result[0].ID, childDash.Id)
-						require.Equal(t, query.Result[1].ID, dashInRoot.Id)
+						require.Equal(t, query.Result[0].ID, childDash.ID)
+						require.Equal(t, query.Result[1].ID, dashInRoot.ID)
 					})
 				})
 
@@ -169,14 +169,14 @@ func TestIntegrationDashboardFolderDataAccess(t *testing.T) {
 								OrgRole: org.RoleAdmin,
 							},
 							OrgId:        1,
-							DashboardIds: []int64{folder.Id, dashInRoot.Id, childDash.Id},
+							DashboardIds: []int64{folder.ID, dashInRoot.ID, childDash.ID},
 						}
 						err := testSearchDashboards(dashboardStore, query)
 						require.NoError(t, err)
 						require.Equal(t, len(query.Result), 3)
-						require.Equal(t, query.Result[0].ID, folder.Id)
-						require.Equal(t, query.Result[1].ID, childDash.Id)
-						require.Equal(t, query.Result[2].ID, dashInRoot.Id)
+						require.Equal(t, query.Result[0].ID, folder.ID)
+						require.Equal(t, query.Result[1].ID, childDash.ID)
+						require.Equal(t, query.Result[2].ID, dashInRoot.ID)
 					})
 				})
 			})
@@ -184,7 +184,7 @@ func TestIntegrationDashboardFolderDataAccess(t *testing.T) {
 
 		t.Run("Given two dashboard folders with one dashboard each and one dashboard in the root folder", func(t *testing.T) {
 			var sqlStore *sqlstore.SQLStore
-			var folder1, folder2, dashInRoot, childDash1, childDash2 *models.Dashboard
+			var folder1, folder2, dashInRoot, childDash1, childDash2 *dashboards.Dashboard
 			var currentUser user.User
 			var rootFolderId int64 = 0
 
@@ -196,8 +196,8 @@ func TestIntegrationDashboardFolderDataAccess(t *testing.T) {
 				folder1 = insertTestDashboard(t, dashboardStore, "1 test dash folder", 1, 0, true, "prod")
 				folder2 = insertTestDashboard(t, dashboardStore, "2 test dash folder", 1, 0, true, "prod")
 				dashInRoot = insertTestDashboard(t, dashboardStore, "test dash 67", 1, 0, false, "prod")
-				childDash1 = insertTestDashboard(t, dashboardStore, "child dash 1", 1, folder1.Id, false, "prod")
-				childDash2 = insertTestDashboard(t, dashboardStore, "child dash 2", 1, folder2.Id, false, "prod")
+				childDash1 = insertTestDashboard(t, dashboardStore, "child dash 1", 1, folder1.ID, false, "prod")
+				childDash2 = insertTestDashboard(t, dashboardStore, "child dash 2", 1, folder2.ID, false, "prod")
 
 				currentUser = createUser(t, sqlStore, "viewer", "Viewer", false)
 			}
@@ -207,7 +207,7 @@ func TestIntegrationDashboardFolderDataAccess(t *testing.T) {
 				t.Run("should return dashboards in root and expanded folder", func(t *testing.T) {
 					query := &models.FindPersistedDashboardsQuery{
 						FolderIds: []int64{
-							rootFolderId, folder1.Id}, SignedInUser: &user.SignedInUser{UserID: currentUser.ID,
+							rootFolderId, folder1.ID}, SignedInUser: &user.SignedInUser{UserID: currentUser.ID,
 							OrgID: 1, OrgRole: org.RoleViewer,
 						},
 						OrgId: 1,
@@ -215,76 +215,76 @@ func TestIntegrationDashboardFolderDataAccess(t *testing.T) {
 					err := testSearchDashboards(dashboardStore, query)
 					require.NoError(t, err)
 					require.Equal(t, len(query.Result), 4)
-					require.Equal(t, query.Result[0].ID, folder1.Id)
-					require.Equal(t, query.Result[1].ID, folder2.Id)
-					require.Equal(t, query.Result[2].ID, childDash1.Id)
-					require.Equal(t, query.Result[3].ID, dashInRoot.Id)
+					require.Equal(t, query.Result[0].ID, folder1.ID)
+					require.Equal(t, query.Result[1].ID, folder2.ID)
+					require.Equal(t, query.Result[2].ID, childDash1.ID)
+					require.Equal(t, query.Result[3].ID, dashInRoot.ID)
 				})
 			})
 
 			t.Run("and acl is set for one dashboard folder", func(t *testing.T) {
 				const otherUser int64 = 999
-				err := updateDashboardACL(t, dashboardStore, folder1.Id, models.DashboardACL{
-					DashboardID: folder1.Id, OrgID: 1, UserID: otherUser, Permission: models.PERMISSION_EDIT,
+				err := updateDashboardACL(t, dashboardStore, folder1.ID, models.DashboardACL{
+					DashboardID: folder1.ID, OrgID: 1, UserID: otherUser, Permission: models.PERMISSION_EDIT,
 				})
 				require.NoError(t, err)
 
 				t.Run("and a dashboard is moved from folder without acl to the folder with an acl", func(t *testing.T) {
-					moveDashboard(t, dashboardStore, 1, childDash2.Data, folder1.Id)
+					moveDashboard(t, dashboardStore, 1, childDash2.Data, folder1.ID)
 
 					t.Run("should not return folder with acl or its children", func(t *testing.T) {
 						query := &models.FindPersistedDashboardsQuery{
 							SignedInUser: &user.SignedInUser{UserID: currentUser.ID, OrgID: 1, OrgRole: org.RoleViewer},
 							OrgId:        1,
-							DashboardIds: []int64{folder1.Id, childDash1.Id, childDash2.Id, dashInRoot.Id},
+							DashboardIds: []int64{folder1.ID, childDash1.ID, childDash2.ID, dashInRoot.ID},
 						}
 						err := testSearchDashboards(dashboardStore, query)
 						require.NoError(t, err)
 						require.Equal(t, len(query.Result), 1)
-						require.Equal(t, query.Result[0].ID, dashInRoot.Id)
+						require.Equal(t, query.Result[0].ID, dashInRoot.ID)
 					})
 				})
 				t.Run("and a dashboard is moved from folder with acl to the folder without an acl", func(t *testing.T) {
 					setup2()
-					moveDashboard(t, dashboardStore, 1, childDash1.Data, folder2.Id)
+					moveDashboard(t, dashboardStore, 1, childDash1.Data, folder2.ID)
 
 					t.Run("should return folder without acl and its children", func(t *testing.T) {
 						query := &models.FindPersistedDashboardsQuery{
 							SignedInUser: &user.SignedInUser{UserID: currentUser.ID, OrgID: 1, OrgRole: org.RoleViewer},
 							OrgId:        1,
-							DashboardIds: []int64{folder2.Id, childDash1.Id, childDash2.Id, dashInRoot.Id},
+							DashboardIds: []int64{folder2.ID, childDash1.ID, childDash2.ID, dashInRoot.ID},
 						}
 						err := testSearchDashboards(dashboardStore, query)
 						require.NoError(t, err)
 						require.Equal(t, len(query.Result), 4)
-						require.Equal(t, query.Result[0].ID, folder2.Id)
-						require.Equal(t, query.Result[1].ID, childDash1.Id)
-						require.Equal(t, query.Result[2].ID, childDash2.Id)
-						require.Equal(t, query.Result[3].ID, dashInRoot.Id)
+						require.Equal(t, query.Result[0].ID, folder2.ID)
+						require.Equal(t, query.Result[1].ID, childDash1.ID)
+						require.Equal(t, query.Result[2].ID, childDash2.ID)
+						require.Equal(t, query.Result[3].ID, dashInRoot.ID)
 					})
 				})
 
 				t.Run("and a dashboard with an acl is moved to the folder without an acl", func(t *testing.T) {
-					err := updateDashboardACL(t, dashboardStore, childDash1.Id, models.DashboardACL{
-						DashboardID: childDash1.Id, OrgID: 1, UserID: otherUser, Permission: models.PERMISSION_EDIT,
+					err := updateDashboardACL(t, dashboardStore, childDash1.ID, models.DashboardACL{
+						DashboardID: childDash1.ID, OrgID: 1, UserID: otherUser, Permission: models.PERMISSION_EDIT,
 					})
 					require.NoError(t, err)
 
-					moveDashboard(t, dashboardStore, 1, childDash1.Data, folder2.Id)
+					moveDashboard(t, dashboardStore, 1, childDash1.Data, folder2.ID)
 
 					t.Run("should return folder without acl but not the dashboard with acl", func(t *testing.T) {
 						query := &models.FindPersistedDashboardsQuery{
 							SignedInUser: &user.SignedInUser{UserID: currentUser.ID, OrgID: 1, OrgRole: org.RoleViewer},
 							OrgId:        1,
-							DashboardIds: []int64{folder2.Id, childDash1.Id, childDash2.Id, dashInRoot.Id},
+							DashboardIds: []int64{folder2.ID, childDash1.ID, childDash2.ID, dashInRoot.ID},
 						}
 						err = testSearchDashboards(dashboardStore, query)
 						require.NoError(t, err)
 						require.Equal(t, len(query.Result), 4)
-						require.Equal(t, query.Result[0].ID, folder2.Id)
-						require.Equal(t, query.Result[1].ID, childDash1.Id)
-						require.Equal(t, query.Result[2].ID, childDash2.Id)
-						require.Equal(t, query.Result[3].ID, dashInRoot.Id)
+						require.Equal(t, query.Result[0].ID, folder2.ID)
+						require.Equal(t, query.Result[1].ID, childDash1.ID)
+						require.Equal(t, query.Result[2].ID, childDash2.ID)
+						require.Equal(t, query.Result[3].ID, dashInRoot.ID)
 					})
 				})
 			})
@@ -292,7 +292,7 @@ func TestIntegrationDashboardFolderDataAccess(t *testing.T) {
 
 		t.Run("Given two dashboard folders", func(t *testing.T) {
 			var sqlStore *sqlstore.SQLStore
-			var folder1, folder2 *models.Dashboard
+			var folder1, folder2 *dashboards.Dashboard
 			var adminUser, editorUser, viewerUser user.User
 
 			setup3 := func() {
@@ -323,8 +323,8 @@ func TestIntegrationDashboardFolderDataAccess(t *testing.T) {
 					require.NoError(t, err)
 
 					require.Equal(t, len(query.Result), 2)
-					require.Equal(t, query.Result[0].ID, folder1.Id)
-					require.Equal(t, query.Result[1].ID, folder2.Id)
+					require.Equal(t, query.Result[0].ID, folder1.ID)
+					require.Equal(t, query.Result[1].ID, folder2.ID)
 				})
 
 				t.Run("should have edit permission in folders", func(t *testing.T) {
@@ -358,13 +358,13 @@ func TestIntegrationDashboardFolderDataAccess(t *testing.T) {
 					require.NoError(t, err)
 
 					require.Equal(t, len(query.Result), 2)
-					require.Equal(t, query.Result[0].ID, folder1.Id)
-					require.Equal(t, query.Result[1].ID, folder2.Id)
+					require.Equal(t, query.Result[0].ID, folder1.ID)
+					require.Equal(t, query.Result[1].ID, folder2.ID)
 				})
 
 				t.Run("Should have write access to one dashboard folder if default role changed to view for one folder", func(t *testing.T) {
-					err := updateDashboardACL(t, dashboardStore, folder1.Id, models.DashboardACL{
-						DashboardID: folder1.Id, OrgID: 1, UserID: editorUser.ID, Permission: models.PERMISSION_VIEW,
+					err := updateDashboardACL(t, dashboardStore, folder1.ID, models.DashboardACL{
+						DashboardID: folder1.ID, OrgID: 1, UserID: editorUser.ID, Permission: models.PERMISSION_VIEW,
 					})
 					require.NoError(t, err)
 
@@ -372,7 +372,7 @@ func TestIntegrationDashboardFolderDataAccess(t *testing.T) {
 					require.NoError(t, err)
 
 					require.Equal(t, len(query.Result), 1)
-					require.Equal(t, query.Result[0].ID, folder2.Id)
+					require.Equal(t, query.Result[0].ID, folder2.ID)
 				})
 
 				t.Run("should have edit permission in folders", func(t *testing.T) {
@@ -409,8 +409,8 @@ func TestIntegrationDashboardFolderDataAccess(t *testing.T) {
 				})
 
 				t.Run("Should be able to get one dashboard folder if default role changed to edit for one folder", func(t *testing.T) {
-					err := updateDashboardACL(t, dashboardStore, folder1.Id, models.DashboardACL{
-						DashboardID: folder1.Id, OrgID: 1, UserID: viewerUser.ID, Permission: models.PERMISSION_EDIT,
+					err := updateDashboardACL(t, dashboardStore, folder1.ID, models.DashboardACL{
+						DashboardID: folder1.ID, OrgID: 1, UserID: viewerUser.ID, Permission: models.PERMISSION_EDIT,
 					})
 					require.NoError(t, err)
 
@@ -418,7 +418,7 @@ func TestIntegrationDashboardFolderDataAccess(t *testing.T) {
 					require.NoError(t, err)
 
 					require.Equal(t, len(query.Result), 1)
-					require.Equal(t, query.Result[0].ID, folder1.Id)
+					require.Equal(t, query.Result[0].ID, folder1.ID)
 				})
 
 				t.Run("should not have edit permission in folders", func(t *testing.T) {
@@ -442,8 +442,8 @@ func TestIntegrationDashboardFolderDataAccess(t *testing.T) {
 				})
 
 				t.Run("and admin permission is given for user with org role viewer in one dashboard folder", func(t *testing.T) {
-					err := updateDashboardACL(t, dashboardStore, folder1.Id, models.DashboardACL{
-						DashboardID: folder1.Id, OrgID: 1, UserID: viewerUser.ID, Permission: models.PERMISSION_ADMIN,
+					err := updateDashboardACL(t, dashboardStore, folder1.ID, models.DashboardACL{
+						DashboardID: folder1.ID, OrgID: 1, UserID: viewerUser.ID, Permission: models.PERMISSION_ADMIN,
 					})
 					require.NoError(t, err)
 
@@ -458,8 +458,8 @@ func TestIntegrationDashboardFolderDataAccess(t *testing.T) {
 				})
 
 				t.Run("and edit permission is given for user with org role viewer in one dashboard folder", func(t *testing.T) {
-					err := updateDashboardACL(t, dashboardStore, folder1.Id, models.DashboardACL{
-						DashboardID: folder1.Id, OrgID: 1, UserID: viewerUser.ID, Permission: models.PERMISSION_EDIT,
+					err := updateDashboardACL(t, dashboardStore, folder1.ID, models.DashboardACL{
+						DashboardID: folder1.ID, OrgID: 1, UserID: viewerUser.ID, Permission: models.PERMISSION_EDIT,
 					})
 					require.NoError(t, err)
 
@@ -479,19 +479,19 @@ func TestIntegrationDashboardFolderDataAccess(t *testing.T) {
 			var orgId int64 = 1
 			title := "Very Unique Name"
 			var sqlStore *sqlstore.SQLStore
-			var folder1, folder2 *models.Dashboard
+			var folder1, folder2 *dashboards.Dashboard
 			sqlStore = db.InitTestDB(t)
 			quotaService := quotatest.New(false, nil)
 			dashboardStore, err := ProvideDashboardStore(sqlStore, sqlStore.Cfg, testFeatureToggles, tagimpl.ProvideService(sqlStore, sqlStore.Cfg), quotaService)
 			require.NoError(t, err)
 			folder2 = insertTestDashboard(t, dashboardStore, "TEST", orgId, 0, true, "prod")
-			_ = insertTestDashboard(t, dashboardStore, title, orgId, folder2.Id, false, "prod")
+			_ = insertTestDashboard(t, dashboardStore, title, orgId, folder2.ID, false, "prod")
 			folder1 = insertTestDashboard(t, dashboardStore, title, orgId, 0, true, "prod")
 
 			t.Run("GetFolderByTitle should find the folder", func(t *testing.T) {
 				result, err := dashboardStore.GetFolderByTitle(context.Background(), orgId, title)
 				require.NoError(t, err)
-				require.Equal(t, folder1.Id, result.ID)
+				require.Equal(t, folder1.ID, result.ID)
 			})
 		})
 
@@ -502,20 +502,20 @@ func TestIntegrationDashboardFolderDataAccess(t *testing.T) {
 			dashboardStore, err := ProvideDashboardStore(sqlStore, sqlStore.Cfg, testFeatureToggles, tagimpl.ProvideService(sqlStore, sqlStore.Cfg), quotaService)
 			require.NoError(t, err)
 			folder := insertTestDashboard(t, dashboardStore, "TEST", orgId, 0, true, "prod")
-			dash := insertTestDashboard(t, dashboardStore, "Very Unique Name", orgId, folder.Id, false, "prod")
+			dash := insertTestDashboard(t, dashboardStore, "Very Unique Name", orgId, folder.ID, false, "prod")
 
 			t.Run("should return folder by UID", func(t *testing.T) {
-				d, err := dashboardStore.GetFolderByUID(context.Background(), orgId, folder.Uid)
-				require.Equal(t, folder.Id, d.ID)
+				d, err := dashboardStore.GetFolderByUID(context.Background(), orgId, folder.UID)
+				require.Equal(t, folder.ID, d.ID)
 				require.NoError(t, err)
 			})
 			t.Run("should not find dashboard", func(t *testing.T) {
-				d, err := dashboardStore.GetFolderByUID(context.Background(), orgId, dash.Uid)
+				d, err := dashboardStore.GetFolderByUID(context.Background(), orgId, dash.UID)
 				require.Nil(t, d)
 				require.ErrorIs(t, err, dashboards.ErrFolderNotFound)
 			})
 			t.Run("should search in organization", func(t *testing.T) {
-				d, err := dashboardStore.GetFolderByUID(context.Background(), orgId+1, folder.Uid)
+				d, err := dashboardStore.GetFolderByUID(context.Background(), orgId+1, folder.UID)
 				require.Nil(t, d)
 				require.ErrorIs(t, err, dashboards.ErrFolderNotFound)
 			})
@@ -528,20 +528,20 @@ func TestIntegrationDashboardFolderDataAccess(t *testing.T) {
 			dashboardStore, err := ProvideDashboardStore(sqlStore, sqlStore.Cfg, testFeatureToggles, tagimpl.ProvideService(sqlStore, sqlStore.Cfg), quotaService)
 			require.NoError(t, err)
 			folder := insertTestDashboard(t, dashboardStore, "TEST", orgId, 0, true, "prod")
-			dash := insertTestDashboard(t, dashboardStore, "Very Unique Name", orgId, folder.Id, false, "prod")
+			dash := insertTestDashboard(t, dashboardStore, "Very Unique Name", orgId, folder.ID, false, "prod")
 
 			t.Run("should return folder by ID", func(t *testing.T) {
-				d, err := dashboardStore.GetFolderByID(context.Background(), orgId, folder.Id)
-				require.Equal(t, folder.Id, d.ID)
+				d, err := dashboardStore.GetFolderByID(context.Background(), orgId, folder.ID)
+				require.Equal(t, folder.ID, d.ID)
 				require.NoError(t, err)
 			})
 			t.Run("should not find dashboard", func(t *testing.T) {
-				d, err := dashboardStore.GetFolderByID(context.Background(), orgId, dash.Id)
+				d, err := dashboardStore.GetFolderByID(context.Background(), orgId, dash.ID)
 				require.Nil(t, d)
 				require.ErrorIs(t, err, dashboards.ErrFolderNotFound)
 			})
 			t.Run("should search in organization", func(t *testing.T) {
-				d, err := dashboardStore.GetFolderByID(context.Background(), orgId+1, folder.Id)
+				d, err := dashboardStore.GetFolderByID(context.Background(), orgId+1, folder.ID)
 				require.Nil(t, d)
 				require.ErrorIs(t, err, dashboards.ErrFolderNotFound)
 			})
@@ -550,12 +550,12 @@ func TestIntegrationDashboardFolderDataAccess(t *testing.T) {
 }
 
 func moveDashboard(t *testing.T, dashboardStore *DashboardStore, orgId int64, dashboard *simplejson.Json,
-	newFolderId int64) *models.Dashboard {
+	newFolderId int64) *dashboards.Dashboard {
 	t.Helper()
 
-	cmd := models.SaveDashboardCommand{
-		OrgId:     orgId,
-		FolderId:  newFolderId,
+	cmd := dashboards.SaveDashboardCommand{
+		OrgID:     orgId,
+		FolderID:  newFolderId,
 		Dashboard: dashboard,
 		Overwrite: true,
 	}

pkg/services/dashboards/database/database_provisioning_test.go

@@ -10,6 +10,7 @@ import (
 	"github.com/grafana/grafana/pkg/components/simplejson"
 	"github.com/grafana/grafana/pkg/infra/db"
 	"github.com/grafana/grafana/pkg/models"
+	"github.com/grafana/grafana/pkg/services/dashboards"
 	"github.com/grafana/grafana/pkg/services/quota/quotatest"
 	"github.com/grafana/grafana/pkg/services/tag/tagimpl"
 )
@@ -23,9 +24,9 @@ func TestIntegrationDashboardProvisioningTest(t *testing.T) {
 	dashboardStore, err := ProvideDashboardStore(sqlStore, sqlStore.Cfg, testFeatureToggles, tagimpl.ProvideService(sqlStore, sqlStore.Cfg), quotaService)
 	require.NoError(t, err)
 
-	folderCmd := models.SaveDashboardCommand{
-		OrgId:    1,
-		FolderId: 0,
+	folderCmd := dashboards.SaveDashboardCommand{
+		OrgID:    1,
+		FolderID: 0,
 		IsFolder: true,
 		Dashboard: simplejson.NewFromAny(map[string]interface{}{
 			"id":    nil,
@@ -36,10 +37,10 @@ func TestIntegrationDashboardProvisioningTest(t *testing.T) {
 	dash, err := dashboardStore.SaveDashboard(context.Background(), folderCmd)
 	require.Nil(t, err)
 
-	saveDashboardCmd := models.SaveDashboardCommand{
-		OrgId:    1,
+	saveDashboardCmd := dashboards.SaveDashboardCommand{
+		OrgID:    1,
 		IsFolder: false,
-		FolderId: dash.Id,
+		FolderID: dash.ID,
 		Dashboard: simplejson.NewFromAny(map[string]interface{}{
 			"id":    nil,
 			"title": "test dashboard",
@@ -49,38 +50,38 @@ func TestIntegrationDashboardProvisioningTest(t *testing.T) {
 	t.Run("Saving dashboards with provisioning meta data", func(t *testing.T) {
 		now := time.Now()
 
-		provisioning := &models.DashboardProvisioning{
+		provisioning := &dashboards.DashboardProvisioning{
 			Name:       "default",
-			ExternalId: "/var/grafana.json",
+			ExternalID: "/var/grafana.json",
 			Updated:    now.Unix(),
 		}
 
 		dash, err := dashboardStore.SaveProvisionedDashboard(context.Background(), saveDashboardCmd, provisioning)
 		require.Nil(t, err)
 		require.NotNil(t, dash)
-		require.NotEqual(t, 0, dash.Id)
-		dashId := dash.Id
+		require.NotEqual(t, 0, dash.ID)
+		dashId := dash.ID
 
 		t.Run("Deleting orphaned provisioned dashboards", func(t *testing.T) {
-			saveCmd := models.SaveDashboardCommand{
-				OrgId:    1,
+			saveCmd := dashboards.SaveDashboardCommand{
+				OrgID:    1,
 				IsFolder: false,
-				FolderId: dash.Id,
+				FolderID: dash.ID,
 				Dashboard: simplejson.NewFromAny(map[string]interface{}{
 					"id":    nil,
 					"title": "another_dashboard",
 				}),
 			}
-			provisioning := &models.DashboardProvisioning{
+			provisioning := &dashboards.DashboardProvisioning{
 				Name:       "another_reader",
-				ExternalId: "/var/grafana.json",
+				ExternalID: "/var/grafana.json",
 				Updated:    now.Unix(),
 			}
 
 			anotherDash, err := dashboardStore.SaveProvisionedDashboard(context.Background(), saveCmd, provisioning)
 			require.Nil(t, err)
 
-			query := &models.GetDashboardsQuery{DashboardIds: []int64{anotherDash.Id}}
+			query := &dashboards.GetDashboardsQuery{DashboardIDs: []int64{anotherDash.ID}}
 			err = dashboardStore.GetDashboards(context.Background(), query)
 			require.Nil(t, err)
 			require.NotNil(t, query.Result)
@@ -88,12 +89,12 @@ func TestIntegrationDashboardProvisioningTest(t *testing.T) {
 			deleteCmd := &models.DeleteOrphanedProvisionedDashboardsCommand{ReaderNames: []string{"default"}}
 			require.Nil(t, dashboardStore.DeleteOrphanedProvisionedDashboards(context.Background(), deleteCmd))
 
-			query = &models.GetDashboardsQuery{DashboardIds: []int64{dash.Id, anotherDash.Id}}
+			query = &dashboards.GetDashboardsQuery{DashboardIDs: []int64{dash.ID, anotherDash.ID}}
 			err = dashboardStore.GetDashboards(context.Background(), query)
 			require.Nil(t, err)
 
 			require.Equal(t, 1, len(query.Result))
-			require.Equal(t, dashId, query.Result[0].Id)
+			require.Equal(t, dashId, query.Result[0].ID)
 		})
 
 		t.Run("Can query for provisioned dashboards", func(t *testing.T) {
@@ -106,7 +107,7 @@ func TestIntegrationDashboardProvisioningTest(t *testing.T) {
 		})
 
 		t.Run("Can query for one provisioned dashboard", func(t *testing.T) {
-			data, err := dashboardStore.GetProvisionedDataByDashboardID(context.Background(), dash.Id)
+			data, err := dashboardStore.GetProvisionedDataByDashboardID(context.Background(), dash.ID)
 			require.Nil(t, err)
 			require.NotNil(t, data)
 		})
@@ -119,13 +120,13 @@ func TestIntegrationDashboardProvisioningTest(t *testing.T) {
 
 		t.Run("Deleting folder should delete provision meta data", func(t *testing.T) {
 			deleteCmd := &models.DeleteDashboardCommand{
-				Id:    dash.Id,
+				Id:    dash.ID,
 				OrgId: 1,
 			}
 
 			require.Nil(t, dashboardStore.DeleteDashboard(context.Background(), deleteCmd))
 
-			data, err := dashboardStore.GetProvisionedDataByDashboardID(context.Background(), dash.Id)
+			data, err := dashboardStore.GetProvisionedDataByDashboardID(context.Background(), dash.ID)
 			require.Nil(t, err)
 			require.Nil(t, data)
 		})

pkg/services/dashboards/database/database_test.go

@@ -35,7 +35,7 @@ func TestIntegrationDashboardDataAccess(t *testing.T) {
 	}
 	var sqlStore *sqlstore.SQLStore
 	var cfg *setting.Cfg
-	var savedFolder, savedDash, savedDash2 *models.Dashboard
+	var savedFolder, savedDash, savedDash2 *dashboards.Dashboard
 	var dashboardStore *DashboardStore
 	var starService star.Service
 	var publicDashboardStore *database.PublicDashboardStoreImpl
@@ -48,10 +48,10 @@ func TestIntegrationDashboardDataAccess(t *testing.T) {
 		dashboardStore, err = ProvideDashboardStore(sqlStore, cfg, testFeatureToggles, tagimpl.ProvideService(sqlStore, cfg), quotaService)
 		require.NoError(t, err)
 		savedFolder = insertTestDashboard(t, dashboardStore, "1 test dash folder", 1, 0, true, "prod", "webapp")
-		savedDash = insertTestDashboard(t, dashboardStore, "test dash 23", 1, savedFolder.Id, false, "prod", "webapp")
-		insertTestDashboard(t, dashboardStore, "test dash 45", 1, savedFolder.Id, false, "prod")
+		savedDash = insertTestDashboard(t, dashboardStore, "test dash 23", 1, savedFolder.ID, false, "prod", "webapp")
+		insertTestDashboard(t, dashboardStore, "test dash 45", 1, savedFolder.ID, false, "prod")
 		savedDash2 = insertTestDashboard(t, dashboardStore, "test dash 67", 1, 0, false, "prod")
-		insertTestRule(t, sqlStore, savedFolder.OrgId, savedFolder.Uid)
+		insertTestRule(t, sqlStore, savedFolder.OrgID, savedFolder.UID)
 
 		publicDashboardStore = database.ProvideStore(sqlStore)
 	}
@@ -60,24 +60,24 @@ func TestIntegrationDashboardDataAccess(t *testing.T) {
 		setup()
 		require.Equal(t, savedDash.Title, "test dash 23")
 		require.Equal(t, savedDash.Slug, "test-dash-23")
-		require.NotEqual(t, savedDash.Id, 0)
+		require.NotEqual(t, savedDash.ID, 0)
 		require.False(t, savedDash.IsFolder)
-		require.Positive(t, savedDash.FolderId)
-		require.Positive(t, len(savedDash.Uid))
+		require.Positive(t, savedDash.FolderID)
+		require.Positive(t, len(savedDash.UID))
 
 		require.Equal(t, savedFolder.Title, "1 test dash folder")
 		require.Equal(t, savedFolder.Slug, "1-test-dash-folder")
-		require.NotEqual(t, savedFolder.Id, 0)
+		require.NotEqual(t, savedFolder.ID, 0)
 		require.True(t, savedFolder.IsFolder)
-		require.EqualValues(t, savedFolder.FolderId, 0)
-		require.Positive(t, len(savedFolder.Uid))
+		require.EqualValues(t, savedFolder.FolderID, 0)
+		require.Positive(t, len(savedFolder.UID))
 	})
 
 	t.Run("Should be able to get dashboard by id", func(t *testing.T) {
 		setup()
-		query := models.GetDashboardQuery{
-			Id:    savedDash.Id,
-			OrgId: 1,
+		query := dashboards.GetDashboardQuery{
+			ID:    savedDash.ID,
+			OrgID: 1,
 		}
 
 		_, err := dashboardStore.GetDashboard(context.Background(), &query)
@@ -85,16 +85,16 @@ func TestIntegrationDashboardDataAccess(t *testing.T) {
 
 		require.Equal(t, query.Result.Title, "test dash 23")
 		require.Equal(t, query.Result.Slug, "test-dash-23")
-		require.Equal(t, query.Result.Id, savedDash.Id)
-		require.Equal(t, query.Result.Uid, savedDash.Uid)
+		require.Equal(t, query.Result.ID, savedDash.ID)
+		require.Equal(t, query.Result.UID, savedDash.UID)
 		require.False(t, query.Result.IsFolder)
 	})
 
 	t.Run("Should be able to get dashboard by slug", func(t *testing.T) {
 		setup()
-		query := models.GetDashboardQuery{
+		query := dashboards.GetDashboardQuery{
 			Slug:  "test-dash-23",
-			OrgId: 1,
+			OrgID: 1,
 		}
 
 		_, err := dashboardStore.GetDashboard(context.Background(), &query)
@@ -102,16 +102,16 @@ func TestIntegrationDashboardDataAccess(t *testing.T) {
 
 		require.Equal(t, query.Result.Title, "test dash 23")
 		require.Equal(t, query.Result.Slug, "test-dash-23")
-		require.Equal(t, query.Result.Id, savedDash.Id)
-		require.Equal(t, query.Result.Uid, savedDash.Uid)
+		require.Equal(t, query.Result.ID, savedDash.ID)
+		require.Equal(t, query.Result.UID, savedDash.UID)
 		require.False(t, query.Result.IsFolder)
 	})
 
 	t.Run("Should be able to get dashboard by uid", func(t *testing.T) {
 		setup()
-		query := models.GetDashboardQuery{
-			Uid:   savedDash.Uid,
-			OrgId: 1,
+		query := dashboards.GetDashboardQuery{
+			UID:   savedDash.UID,
+			OrgID: 1,
 		}
 
 		_, err := dashboardStore.GetDashboard(context.Background(), &query)
@@ -119,23 +119,23 @@ func TestIntegrationDashboardDataAccess(t *testing.T) {
 
 		require.Equal(t, query.Result.Title, "test dash 23")
 		require.Equal(t, query.Result.Slug, "test-dash-23")
-		require.Equal(t, query.Result.Id, savedDash.Id)
-		require.Equal(t, query.Result.Uid, savedDash.Uid)
+		require.Equal(t, query.Result.ID, savedDash.ID)
+		require.Equal(t, query.Result.UID, savedDash.UID)
 		require.False(t, query.Result.IsFolder)
 	})
 
 	t.Run("Should be able to get a dashboard UID by ID", func(t *testing.T) {
 		setup()
-		query := models.GetDashboardRefByIdQuery{Id: savedDash.Id}
-		err := dashboardStore.GetDashboardUIDById(context.Background(), &query)
+		query := dashboards.GetDashboardRefByIDQuery{ID: savedDash.ID}
+		err := dashboardStore.GetDashboardUIDByID(context.Background(), &query)
 		require.NoError(t, err)
-		require.Equal(t, query.Result.Uid, savedDash.Uid)
+		require.Equal(t, query.Result.UID, savedDash.UID)
 	})
 
 	t.Run("Shouldn't be able to get a dashboard with just an OrgID", func(t *testing.T) {
 		setup()
-		query := models.GetDashboardQuery{
-			OrgId: 1,
+		query := dashboards.GetDashboardQuery{
+			OrgID: 1,
 		}
 
 		_, err := dashboardStore.GetDashboard(context.Background(), &query)
@@ -144,12 +144,12 @@ func TestIntegrationDashboardDataAccess(t *testing.T) {
 
 	t.Run("Should be able to get dashboards by IDs & UIDs", func(t *testing.T) {
 		setup()
-		query := models.GetDashboardsQuery{DashboardIds: []int64{savedDash.Id, savedDash2.Id}}
+		query := dashboards.GetDashboardsQuery{DashboardIDs: []int64{savedDash.ID, savedDash2.ID}}
 		err := dashboardStore.GetDashboards(context.Background(), &query)
 		require.NoError(t, err)
 		assert.Equal(t, len(query.Result), 2)
 
-		query = models.GetDashboardsQuery{DashboardUIds: []string{savedDash.Uid, savedDash2.Uid}}
+		query = dashboards.GetDashboardsQuery{DashboardUIDs: []string{savedDash.UID, savedDash2.UID}}
 		err = dashboardStore.GetDashboards(context.Background(), &query)
 		require.NoError(t, err)
 		assert.Equal(t, len(query.Result), 2)
@@ -160,7 +160,7 @@ func TestIntegrationDashboardDataAccess(t *testing.T) {
 		dash := insertTestDashboard(t, dashboardStore, "delete me", 1, 0, false, "delete this")
 
 		err := dashboardStore.DeleteDashboard(context.Background(), &models.DeleteDashboardCommand{
-			Id:    dash.Id,
+			Id:    dash.ID,
 			OrgId: 1,
 		})
 		require.NoError(t, err)
@@ -168,13 +168,13 @@ func TestIntegrationDashboardDataAccess(t *testing.T) {
 
 	t.Run("Should be able to create dashboard", func(t *testing.T) {
 		setup()
-		cmd := models.SaveDashboardCommand{
-			OrgId: 1,
+		cmd := dashboards.SaveDashboardCommand{
+			OrgID: 1,
 			Dashboard: simplejson.NewFromAny(map[string]interface{}{
 				"title": "folderId",
 				"tags":  []interface{}{},
 			}),
-			UserId: 100,
+			UserID: 100,
 		}
 		dashboard, err := dashboardStore.SaveDashboard(context.Background(), cmd)
 		require.NoError(t, err)
@@ -186,43 +186,43 @@ func TestIntegrationDashboardDataAccess(t *testing.T) {
 
 	t.Run("Should be able to update dashboard by id and remove folderId", func(t *testing.T) {
 		setup()
-		cmd := models.SaveDashboardCommand{
-			OrgId: 1,
+		cmd := dashboards.SaveDashboardCommand{
+			OrgID: 1,
 			Dashboard: simplejson.NewFromAny(map[string]interface{}{
-				"id":    savedDash.Id,
+				"id":    savedDash.ID,
 				"title": "folderId",
 				"tags":  []interface{}{},
 			}),
 			Overwrite: true,
-			FolderId:  2,
-			UserId:    100,
+			FolderID:  2,
+			UserID:    100,
 		}
 		dash, err := dashboardStore.SaveDashboard(context.Background(), cmd)
 		require.NoError(t, err)
-		require.EqualValues(t, dash.FolderId, 2)
+		require.EqualValues(t, dash.FolderID, 2)
 
-		cmd = models.SaveDashboardCommand{
-			OrgId: 1,
+		cmd = dashboards.SaveDashboardCommand{
+			OrgID: 1,
 			Dashboard: simplejson.NewFromAny(map[string]interface{}{
-				"id":    savedDash.Id,
+				"id":    savedDash.ID,
 				"title": "folderId",
 				"tags":  []interface{}{},
 			}),
-			FolderId:  0,
+			FolderID:  0,
 			Overwrite: true,
-			UserId:    100,
+			UserID:    100,
 		}
 		_, err = dashboardStore.SaveDashboard(context.Background(), cmd)
 		require.NoError(t, err)
 
-		query := models.GetDashboardQuery{
-			Id:    savedDash.Id,
-			OrgId: 1,
+		query := dashboards.GetDashboardQuery{
+			ID:    savedDash.ID,
+			OrgID: 1,
 		}
 
 		_, err = dashboardStore.GetDashboard(context.Background(), &query)
 		require.NoError(t, err)
-		require.Equal(t, query.Result.FolderId, int64(0))
+		require.Equal(t, query.Result.FolderID, int64(0))
 		require.Equal(t, query.Result.CreatedBy, savedDash.CreatedBy)
 		require.WithinDuration(t, query.Result.Created, savedDash.Created, 3*time.Second)
 		require.Equal(t, query.Result.UpdatedBy, int64(100))
@@ -233,14 +233,14 @@ func TestIntegrationDashboardDataAccess(t *testing.T) {
 		setup()
 		emptyFolder := insertTestDashboard(t, dashboardStore, "2 test dash folder", 1, 0, true, "prod", "webapp")
 
-		deleteCmd := &models.DeleteDashboardCommand{Id: emptyFolder.Id}
+		deleteCmd := &models.DeleteDashboardCommand{Id: emptyFolder.ID}
 		err := dashboardStore.DeleteDashboard(context.Background(), deleteCmd)
 		require.NoError(t, err)
 	})
 
 	t.Run("Should be not able to delete a dashboard if force delete rules is disabled", func(t *testing.T) {
 		setup()
-		deleteCmd := &models.DeleteDashboardCommand{Id: savedFolder.Id, ForceDeleteFolderRules: false}
+		deleteCmd := &models.DeleteDashboardCommand{Id: savedFolder.ID, ForceDeleteFolderRules: false}
 		err := dashboardStore.DeleteDashboard(context.Background(), deleteCmd)
 		require.True(t, errors.Is(err, dashboards.ErrFolderContainsAlertRules))
 	})
@@ -252,8 +252,8 @@ func TestIntegrationDashboardDataAccess(t *testing.T) {
 		cmd := publicDashboardModels.SavePublicDashboardCommand{
 			PublicDashboard: publicDashboardModels.PublicDashboard{
 				Uid:          uid,
-				DashboardUid: savedDash.Uid,
-				OrgId:        savedDash.OrgId,
+				DashboardUid: savedDash.UID,
+				OrgId:        savedDash.OrgID,
 				IsEnabled:    true,
 				TimeSettings: &publicDashboardModels.TimeSettings{},
 				CreatedBy:    1,
@@ -266,11 +266,11 @@ func TestIntegrationDashboardDataAccess(t *testing.T) {
 		pubdashConfig, _ := publicDashboardStore.FindByAccessToken(context.Background(), "an-access-token")
 		require.NotNil(t, pubdashConfig)
 
-		deleteCmd := &models.DeleteDashboardCommand{Id: savedDash.Id, OrgId: savedDash.OrgId}
+		deleteCmd := &models.DeleteDashboardCommand{Id: savedDash.ID, OrgId: savedDash.OrgID}
 		err = dashboardStore.DeleteDashboard(context.Background(), deleteCmd)
 		require.NoError(t, err)
 
-		query := models.GetDashboardQuery{Uid: savedDash.Uid, OrgId: savedDash.OrgId}
+		query := dashboards.GetDashboardQuery{UID: savedDash.UID, OrgID: savedDash.OrgID}
 		dash, getErr := dashboardStore.GetDashboard(context.Background(), &query)
 		require.Equal(t, getErr, dashboards.ErrDashboardNotFound)
 		assert.Nil(t, dash)
@@ -287,8 +287,8 @@ func TestIntegrationDashboardDataAccess(t *testing.T) {
 		cmd := publicDashboardModels.SavePublicDashboardCommand{
 			PublicDashboard: publicDashboardModels.PublicDashboard{
 				Uid:          uid,
-				DashboardUid: savedDash.Uid,
-				OrgId:        savedDash.OrgId,
+				DashboardUid: savedDash.UID,
+				OrgId:        savedDash.OrgID,
 				IsEnabled:    true,
 				TimeSettings: &publicDashboardModels.TimeSettings{},
 				CreatedBy:    1,
@@ -301,12 +301,12 @@ func TestIntegrationDashboardDataAccess(t *testing.T) {
 		pubdashConfig, _ := publicDashboardStore.FindByAccessToken(context.Background(), "an-access-token")
 		require.NotNil(t, pubdashConfig)
 
-		deleteCmd := &models.DeleteDashboardCommand{Id: savedFolder.Id, ForceDeleteFolderRules: true}
+		deleteCmd := &models.DeleteDashboardCommand{Id: savedFolder.ID, ForceDeleteFolderRules: true}
 		err = dashboardStore.DeleteDashboard(context.Background(), deleteCmd)
 		require.NoError(t, err)
 
-		query := models.GetDashboardsQuery{
-			DashboardIds: []int64{savedFolder.Id, savedDash.Id},
+		query := dashboards.GetDashboardsQuery{
+			DashboardIDs: []int64{savedFolder.ID, savedDash.ID},
 		}
 		err = dashboardStore.GetDashboards(context.Background(), &query)
 		require.NoError(t, err)
@@ -319,13 +319,13 @@ func TestIntegrationDashboardDataAccess(t *testing.T) {
 
 	t.Run("Should be able to delete a dashboard folder and its children if force delete rules is enabled", func(t *testing.T) {
 		setup()
-		deleteCmd := &models.DeleteDashboardCommand{Id: savedFolder.Id, ForceDeleteFolderRules: true}
+		deleteCmd := &models.DeleteDashboardCommand{Id: savedFolder.ID, ForceDeleteFolderRules: true}
 		err := dashboardStore.DeleteDashboard(context.Background(), deleteCmd)
 		require.NoError(t, err)
 
 		query := models.FindPersistedDashboardsQuery{
 			OrgId:        1,
-			FolderIds:    []int64{savedFolder.Id},
+			FolderIds:    []int64{savedFolder.ID},
 			SignedInUser: &user.SignedInUser{},
 		}
 
@@ -335,12 +335,12 @@ func TestIntegrationDashboardDataAccess(t *testing.T) {
 
 		err = sqlStore.WithDbSession(context.Background(), func(sess *db.Session) error {
 			var existingRuleID int64
-			exists, err := sess.Table("alert_rule").Where("namespace_uid = (SELECT uid FROM dashboard WHERE id = ?)", savedFolder.Id).Cols("id").Get(&existingRuleID)
+			exists, err := sess.Table("alert_rule").Where("namespace_uid = (SELECT uid FROM dashboard WHERE id = ?)", savedFolder.ID).Cols("id").Get(&existingRuleID)
 			require.NoError(t, err)
 			require.False(t, exists)
 
 			var existingRuleVersionID int64
-			exists, err = sess.Table("alert_rule_version").Where("rule_namespace_uid = (SELECT uid FROM dashboard WHERE id = ?)", savedFolder.Id).Cols("id").Get(&existingRuleVersionID)
+			exists, err = sess.Table("alert_rule_version").Where("rule_namespace_uid = (SELECT uid FROM dashboard WHERE id = ?)", savedFolder.ID).Cols("id").Get(&existingRuleVersionID)
 			require.NoError(t, err)
 			require.False(t, exists)
 
@@ -350,8 +350,8 @@ func TestIntegrationDashboardDataAccess(t *testing.T) {
 	})
 
 	t.Run("Should return error if no dashboard is found for update when dashboard id is greater than zero", func(t *testing.T) {
-		cmd := models.SaveDashboardCommand{
-			OrgId:     1,
+		cmd := dashboards.SaveDashboardCommand{
+			OrgID:     1,
 			Overwrite: true,
 			Dashboard: simplejson.NewFromAny(map[string]interface{}{
 				"id":    float64(123412321),
@@ -365,8 +365,8 @@ func TestIntegrationDashboardDataAccess(t *testing.T) {
 	})
 
 	t.Run("Should not return error if no dashboard is found for update when dashboard id is zero", func(t *testing.T) {
-		cmd := models.SaveDashboardCommand{
-			OrgId:     1,
+		cmd := dashboards.SaveDashboardCommand{
+			OrgID:     1,
 			Overwrite: true,
 			Dashboard: simplejson.NewFromAny(map[string]interface{}{
 				"id":    0,
@@ -408,7 +408,7 @@ func TestIntegrationDashboardDataAccess(t *testing.T) {
 		require.Equal(t, len(query.Result), 1)
 		hit := query.Result[0]
 		require.Equal(t, hit.Type, models.DashHitFolder)
-		require.Equal(t, hit.URL, fmt.Sprintf("/dashboards/f/%s/%s", savedFolder.Uid, savedFolder.Slug))
+		require.Equal(t, hit.URL, fmt.Sprintf("/dashboards/f/%s/%s", savedFolder.UID, savedFolder.Slug))
 		require.Equal(t, hit.FolderTitle, "")
 	})
 
@@ -484,7 +484,7 @@ func TestIntegrationDashboardDataAccess(t *testing.T) {
 		setup()
 		query := models.FindPersistedDashboardsQuery{
 			OrgId:     1,
-			FolderIds: []int64{savedFolder.Id},
+			FolderIds: []int64{savedFolder.ID},
 			SignedInUser: &user.SignedInUser{
 				OrgID:   1,
 				OrgRole: org.RoleEditor,
@@ -499,18 +499,18 @@ func TestIntegrationDashboardDataAccess(t *testing.T) {
 
 		require.Equal(t, len(query.Result), 2)
 		hit := query.Result[0]
-		require.Equal(t, hit.ID, savedDash.Id)
-		require.Equal(t, hit.URL, fmt.Sprintf("/d/%s/%s", savedDash.Uid, savedDash.Slug))
-		require.Equal(t, hit.FolderID, savedFolder.Id)
-		require.Equal(t, hit.FolderUID, savedFolder.Uid)
+		require.Equal(t, hit.ID, savedDash.ID)
+		require.Equal(t, hit.URL, fmt.Sprintf("/d/%s/%s", savedDash.UID, savedDash.Slug))
+		require.Equal(t, hit.FolderID, savedFolder.ID)
+		require.Equal(t, hit.FolderUID, savedFolder.UID)
 		require.Equal(t, hit.FolderTitle, savedFolder.Title)
-		require.Equal(t, hit.FolderURL, fmt.Sprintf("/dashboards/f/%s/%s", savedFolder.Uid, savedFolder.Slug))
+		require.Equal(t, hit.FolderURL, fmt.Sprintf("/dashboards/f/%s/%s", savedFolder.UID, savedFolder.Slug))
 	})
 
 	t.Run("Should be able to find dashboards by ids", func(t *testing.T) {
 		setup()
 		query := models.FindPersistedDashboardsQuery{
-			DashboardIds: []int64{savedDash.Id, savedDash2.Id},
+			DashboardIds: []int64{savedDash.ID, savedDash2.ID},
 			SignedInUser: &user.SignedInUser{
 				OrgID:   1,
 				OrgRole: org.RoleEditor,
@@ -536,13 +536,13 @@ func TestIntegrationDashboardDataAccess(t *testing.T) {
 		setup()
 		starredDash := insertTestDashboard(t, dashboardStore, "starred dash", 1, 0, false)
 		err := starService.Add(context.Background(), &star.StarDashboardCommand{
-			DashboardID: starredDash.Id,
+			DashboardID: starredDash.ID,
 			UserID:      10,
 		})
 		require.NoError(t, err)
 
 		err = starService.Add(context.Background(), &star.StarDashboardCommand{
-			DashboardID: savedDash.Id,
+			DashboardID: savedDash.ID,
 			UserID:      1,
 		})
 		require.NoError(t, err)
@@ -576,7 +576,7 @@ func TestIntegrationDashboardDataAccess(t *testing.T) {
 
 		count, err = dashboardStore.CountDashboardsInFolder(
 			context.Background(),
-			&dashboards.CountDashboardsInFolderRequest{FolderID: savedFolder.Id, OrgID: 1})
+			&dashboards.CountDashboardsInFolderRequest{FolderID: savedFolder.ID, OrgID: 1})
 		require.NoError(t, err)
 		require.Equal(t, int64(2), count)
 	})
@@ -595,8 +595,8 @@ func TestIntegrationDashboardDataAccessGivenPluginWithImportedDashboards(t *test
 	pluginId := "test-app"
 
 	appFolder := insertTestDashboardForPlugin(t, dashboardStore, "app-test", 1, 0, true, pluginId)
-	insertTestDashboardForPlugin(t, dashboardStore, "app-dash1", 1, appFolder.Id, false, pluginId)
-	insertTestDashboardForPlugin(t, dashboardStore, "app-dash2", 1, appFolder.Id, false, pluginId)
+	insertTestDashboardForPlugin(t, dashboardStore, "app-dash1", 1, appFolder.ID, false, pluginId)
+	insertTestDashboardForPlugin(t, dashboardStore, "app-dash2", 1, appFolder.ID, false, pluginId)
 
 	query := models.GetDashboardsByPluginIdQuery{
 		PluginId: pluginId,
@@ -621,8 +621,8 @@ func TestIntegrationDashboard_SortingOptions(t *testing.T) {
 
 	dashB := insertTestDashboard(t, dashboardStore, "Beta", 1, 0, false)
 	dashA := insertTestDashboard(t, dashboardStore, "Alfa", 1, 0, false)
-	assert.NotZero(t, dashA.Id)
-	assert.Less(t, dashB.Id, dashA.Id)
+	assert.NotZero(t, dashA.ID)
+	assert.Less(t, dashB.ID, dashA.ID)
 	qNoSort := &models.FindPersistedDashboardsQuery{
 		SignedInUser: &user.SignedInUser{
 			OrgID:   1,
@@ -636,8 +636,8 @@ func TestIntegrationDashboard_SortingOptions(t *testing.T) {
 	results, err := dashboardStore.FindDashboards(context.Background(), qNoSort)
 	require.NoError(t, err)
 	require.Len(t, results, 2)
-	assert.Equal(t, dashA.Id, results[0].ID)
-	assert.Equal(t, dashB.Id, results[1].ID)
+	assert.Equal(t, dashA.ID, results[0].ID)
+	assert.Equal(t, dashB.ID, results[1].ID)
 
 	qSort := &models.FindPersistedDashboardsQuery{
 		SignedInUser: &user.SignedInUser{
@@ -657,8 +657,8 @@ func TestIntegrationDashboard_SortingOptions(t *testing.T) {
 	results, err = dashboardStore.FindDashboards(context.Background(), qSort)
 	require.NoError(t, err)
 	require.Len(t, results, 2)
-	assert.Equal(t, dashB.Id, results[0].ID)
-	assert.Equal(t, dashA.Id, results[1].ID)
+	assert.Equal(t, dashB.ID, results[0].ID)
+	assert.Equal(t, dashA.ID, results[1].ID)
 }
 
 func TestIntegrationDashboard_Filter(t *testing.T) {
@@ -706,7 +706,7 @@ func TestIntegrationDashboard_Filter(t *testing.T) {
 	results, err = dashboardStore.FindDashboards(context.Background(), qFilter)
 	require.NoError(t, err)
 	require.Len(t, results, 1)
-	assert.Equal(t, dashB.Id, results[0].ID)
+	assert.Equal(t, dashB.ID, results[0].ID)
 }
 
 func insertTestRule(t *testing.T, sqlStore db.DB, foderOrgID int64, folderUID string) {
@@ -783,11 +783,11 @@ func insertTestRule(t *testing.T, sqlStore db.DB, foderOrgID int64, folderUID st
 }
 
 func insertTestDashboard(t *testing.T, dashboardStore *DashboardStore, title string, orgId int64,
-	folderId int64, isFolder bool, tags ...interface{}) *models.Dashboard {
+	folderId int64, isFolder bool, tags ...interface{}) *dashboards.Dashboard {
 	t.Helper()
-	cmd := models.SaveDashboardCommand{
-		OrgId:    orgId,
-		FolderId: folderId,
+	cmd := dashboards.SaveDashboardCommand{
+		OrgID:    orgId,
+		FolderID: folderId,
 		IsFolder: isFolder,
 		Dashboard: simplejson.NewFromAny(map[string]interface{}{
 			"id":    nil,
@@ -798,23 +798,23 @@ func insertTestDashboard(t *testing.T, dashboardStore *DashboardStore, title str
 	dash, err := dashboardStore.SaveDashboard(context.Background(), cmd)
 	require.NoError(t, err)
 	require.NotNil(t, dash)
-	dash.Data.Set("id", dash.Id)
-	dash.Data.Set("uid", dash.Uid)
+	dash.Data.Set("id", dash.ID)
+	dash.Data.Set("uid", dash.UID)
 	return dash
 }
 
 func insertTestDashboardForPlugin(t *testing.T, dashboardStore *DashboardStore, title string, orgId int64,
-	folderId int64, isFolder bool, pluginId string) *models.Dashboard {
+	folderId int64, isFolder bool, pluginId string) *dashboards.Dashboard {
 	t.Helper()
-	cmd := models.SaveDashboardCommand{
-		OrgId:    orgId,
-		FolderId: folderId,
+	cmd := dashboards.SaveDashboardCommand{
+		OrgID:    orgId,
+		FolderID: folderId,
 		IsFolder: isFolder,
 		Dashboard: simplejson.NewFromAny(map[string]interface{}{
 			"id":    nil,
 			"title": title,
 		}),
-		PluginId: pluginId,
+		PluginID: pluginId,
 	}
 
 	dash, err := dashboardStore.SaveDashboard(context.Background(), cmd)

pkg/services/dashboards/models.go

@@ -1,20 +1,299 @@
 package dashboards
 
 import (
+	"fmt"
 	"time"
 
+	"github.com/grafana/grafana/pkg/components/simplejson"
+	"github.com/grafana/grafana/pkg/infra/slugify"
 	"github.com/grafana/grafana/pkg/models"
+	"github.com/grafana/grafana/pkg/services/folder"
 	"github.com/grafana/grafana/pkg/services/quota"
 	"github.com/grafana/grafana/pkg/services/user"
+	"github.com/grafana/grafana/pkg/setting"
 )
 
+const RootFolderName = "General"
+
+const (
+	DashTypeDB       = "db"
+	DashTypeSnapshot = "snapshot"
+)
+
+// Dashboard model
+type Dashboard struct {
+	ID       int64  `xorm:"pk autoincr 'id'"`
+	UID      string `xorm:"uid"`
+	Slug     string
+	OrgID    int64 `xorm:"org_id"`
+	GnetID   int64 `xorm:"gnet_id"`
+	Version  int
+	PluginID string `xorm:"plugin_id"`
+
+	Created time.Time
+	Updated time.Time
+
+	UpdatedBy int64
+	CreatedBy int64
+	FolderID  int64 `xorm:"folder_id"`
+	IsFolder  bool
+	HasACL    bool `xorm:"has_acl"`
+
+	Title string
+	Data  *simplejson.Json
+}
+
+func (d *Dashboard) SetID(id int64) {
+	d.ID = id
+	d.Data.Set("id", id)
+}
+
+func (d *Dashboard) SetUID(uid string) {
+	d.UID = uid
+	d.Data.Set("uid", uid)
+}
+
+func (d *Dashboard) SetVersion(version int) {
+	d.Version = version
+	d.Data.Set("version", version)
+}
+
+// NewDashboard creates a new dashboard
+func NewDashboard(title string) *Dashboard {
+	dash := &Dashboard{}
+	dash.Data = simplejson.New()
+	dash.Data.Set("title", title)
+	dash.Title = title
+	dash.Created = time.Now()
+	dash.Updated = time.Now()
+	dash.UpdateSlug()
+	return dash
+}
+
+// NewDashboardFolder creates a new dashboard folder
+func NewDashboardFolder(title string) *Dashboard {
+	folder := NewDashboard(title)
+	folder.IsFolder = true
+	folder.Data.Set("schemaVersion", 17)
+	folder.Data.Set("version", 0)
+	folder.IsFolder = true
+	return folder
+}
+
+// GetTags turns the tags in data json into go string array
+func (d *Dashboard) GetTags() []string {
+	return d.Data.Get("tags").MustStringArray()
+}
+
+func NewDashboardFromJson(data *simplejson.Json) *Dashboard {
+	dash := &Dashboard{}
+	dash.Data = data
+	dash.Title = dash.Data.Get("title").MustString()
+	dash.UpdateSlug()
+	update := false
+
+	if id, err := dash.Data.Get("id").Float64(); err == nil {
+		dash.ID = int64(id)
+		update = true
+	}
+
+	if uid, err := dash.Data.Get("uid").String(); err == nil {
+		dash.UID = uid
+		update = true
+	}
+
+	if version, err := dash.Data.Get("version").Float64(); err == nil && update {
+		dash.Version = int(version)
+		dash.Updated = time.Now()
+	} else {
+		dash.Data.Set("version", 0)
+		dash.Created = time.Now()
+		dash.Updated = time.Now()
+	}
+
+	if gnetId, err := dash.Data.Get("gnetId").Float64(); err == nil {
+		dash.GnetID = int64(gnetId)
+	}
+
+	return dash
+}
+
+// GetDashboardModel turns the command into the saveable model
+func (cmd *SaveDashboardCommand) GetDashboardModel() *Dashboard {
+	dash := NewDashboardFromJson(cmd.Dashboard)
+	userID := cmd.UserID
+
+	if userID == 0 {
+		userID = -1
+	}
+
+	dash.UpdatedBy = userID
+	dash.OrgID = cmd.OrgID
+	dash.PluginID = cmd.PluginID
+	dash.IsFolder = cmd.IsFolder
+	dash.FolderID = cmd.FolderID
+	dash.UpdateSlug()
+	return dash
+}
+
+// UpdateSlug updates the slug
+func (d *Dashboard) UpdateSlug() {
+	title := d.Data.Get("title").MustString()
+	d.Slug = slugify.Slugify(title)
+}
+
+// GetURL return the html url for a folder if it's folder, otherwise for a dashboard
+func (d *Dashboard) GetURL() string {
+	return GetDashboardFolderURL(d.IsFolder, d.UID, d.Slug)
+}
+
+// GetDashboardFolderURL return the html url for a folder if it's folder, otherwise for a dashboard
+func GetDashboardFolderURL(isFolder bool, uid string, slug string) string {
+	if isFolder {
+		return GetFolderURL(uid, slug)
+	}
+
+	return GetDashboardURL(uid, slug)
+}
+
+// GetDashboardURL returns the HTML url for a dashboard.
+func GetDashboardURL(uid string, slug string) string {
+	return fmt.Sprintf("%s/d/%s/%s", setting.AppSubUrl, uid, slug)
+}
+
+// GetKioskModeDashboardUrl returns the HTML url for a dashboard in kiosk mode.
+func GetKioskModeDashboardURL(uid string, slug string, theme models.Theme) string {
+	return fmt.Sprintf("%s?kiosk&theme=%s", GetDashboardURL(uid, slug), string(theme))
+}
+
+// GetFullDashboardURL returns the full URL for a dashboard.
+func GetFullDashboardURL(uid string, slug string) string {
+	return fmt.Sprintf("%sd/%s/%s", setting.AppUrl, uid, slug)
+}
+
+// GetFolderURL returns the HTML url for a folder.
+func GetFolderURL(folderUID string, slug string) string {
+	return fmt.Sprintf("%s/dashboards/f/%s/%s", setting.AppSubUrl, folderUID, slug)
+}
+
+type ValidateDashboardBeforeSaveResult struct {
+	IsParentFolderChanged bool
+}
+
+//
+// COMMANDS
+//
+
+type SaveDashboardCommand struct {
+	Dashboard    *simplejson.Json `json:"dashboard" binding:"Required"`
+	UserID       int64            `json:"userId" xorm:"user_id"`
+	Overwrite    bool             `json:"overwrite"`
+	Message      string           `json:"message"`
+	OrgID        int64            `json:"-" xorm:"org_id"`
+	RestoredFrom int              `json:"-"`
+	PluginID     string           `json:"-" xorm:"plugin_id"`
+	FolderID     int64            `json:"folderId" xorm:"folder_id"`
+	FolderUID    string           `json:"folderUid" xorm:"folder_uid"`
+	IsFolder     bool             `json:"isFolder"`
+
+	UpdatedAt time.Time
+
+	Result *Dashboard `json:"-"`
+}
+
+type ValidateDashboardCommand struct {
+	Dashboard string `json:"dashboard" binding:"Required"`
+}
+
+type TrimDashboardCommand struct {
+	Dashboard *simplejson.Json `json:"dashboard" binding:"Required"`
+	Meta      *simplejson.Json `json:"meta"`
+	Result    *Dashboard       `json:"-"`
+}
+
+type DashboardProvisioning struct {
+	ID          int64 `xorm:"pk autoincr 'id'"`
+	DashboardID int64 `xorm:"dashboard_id"`
+	Name        string
+	ExternalID  string `xorm:"external_id"`
+	CheckSum    string
+	Updated     int64
+}
+
+type DeleteDashboardCommand struct {
+	ID                     int64
+	OrgID                  int64
+	ForceDeleteFolderRules bool
+}
+
+type DeleteOrphanedProvisionedDashboardsCommand struct {
+	ReaderNames []string
+}
+
+//
+// QUERIES
+//
+
+type GetDashboardQuery struct {
+	Slug  string // required if no ID or Uid is specified
+	ID    int64  // optional if slug is set
+	UID   string // optional if slug is set
+	OrgID int64
+
+	Result *Dashboard
+}
+
+type DashboardTagCloudItem struct {
+	Term  string `json:"term"`
+	Count int    `json:"count"`
+}
+
+type GetDashboardTagsQuery struct {
+	OrgID  int64
+	Result []*DashboardTagCloudItem
+}
+
+type GetDashboardsQuery struct {
+	DashboardIDs  []int64
+	DashboardUIDs []string
+	Result        []*Dashboard
+}
+
+type GetDashboardsByPluginIdQuery struct {
+	OrgID    int64
+	PluginId string
+	Result   []*Dashboard
+}
+
+type GetDashboardSlugByIdQuery struct {
+	ID     int64
+	Result string
+}
+
+type GetDashboardsBySlugQuery struct {
+	OrgID int64
+	Slug  string
+
+	Result []*Dashboard
+}
+
+type DashboardRef struct {
+	UID  string `xorm:"uid"`
+	Slug string
+}
+
+type GetDashboardRefByIDQuery struct {
+	ID     int64
+	Result *DashboardRef
+}
+
 type SaveDashboardDTO struct {
-	OrgId     int64
+	OrgID     int64
 	UpdatedAt time.Time
 	User      *user.SignedInUser
 	Message   string
 	Overwrite bool
-	Dashboard *models.Dashboard
+	Dashboard *Dashboard
 }
 
 type DashboardSearchProjection struct {
@@ -48,3 +327,18 @@ type CountDashboardsInFolderRequest struct {
 	FolderID int64
 	OrgID    int64
 }
+
+func FromDashboard(dash *Dashboard) *folder.Folder {
+	return &folder.Folder{
+		ID:        dash.ID,
+		UID:       dash.UID,
+		Title:     dash.Title,
+		HasACL:    dash.HasACL,
+		Url:       models.GetFolderUrl(dash.UID, dash.Slug),
+		Version:   dash.Version,
+		Created:   dash.Created,
+		CreatedBy: dash.CreatedBy,
+		Updated:   dash.Updated,
+		UpdatedBy: dash.UpdatedBy,
+	}
+}

pkg/services/dashboards/service/dashboard_service.go

@@ -77,19 +77,19 @@ func (dr *DashboardServiceImpl) GetProvisionedDashboardDataByDashboardUID(ctx co
 }
 
 func (dr *DashboardServiceImpl) BuildSaveDashboardCommand(ctx context.Context, dto *dashboards.SaveDashboardDTO, shouldValidateAlerts bool,
-	validateProvisionedDashboard bool) (*models.SaveDashboardCommand, error) {
+	validateProvisionedDashboard bool) (*dashboards.SaveDashboardCommand, error) {
 	dash := dto.Dashboard
 
-	dash.OrgId = dto.OrgId
+	dash.OrgID = dto.OrgID
 	dash.Title = strings.TrimSpace(dash.Title)
 	dash.Data.Set("title", dash.Title)
-	dash.SetUid(strings.TrimSpace(dash.Uid))
+	dash.SetUID(strings.TrimSpace(dash.UID))
 
 	if dash.Title == "" {
 		return nil, dashboards.ErrDashboardTitleEmpty
 	}
 
-	if dash.IsFolder && dash.FolderId > 0 {
+	if dash.IsFolder && dash.FolderID > 0 {
 		return nil, dashboards.ErrDashboardFolderCannotHaveParent
 	}
 
@@ -97,9 +97,9 @@ func (dr *DashboardServiceImpl) BuildSaveDashboardCommand(ctx context.Context, d
 		return nil, dashboards.ErrDashboardFolderNameExists
 	}
 
-	if !util.IsValidShortUID(dash.Uid) {
+	if !util.IsValidShortUID(dash.UID) {
 		return nil, dashboards.ErrDashboardInvalidUid
-	} else if util.IsShortUIDTooLong(dash.Uid) {
+	} else if util.IsShortUIDTooLong(dash.UID) {
 		return nil, dashboards.ErrDashboardUidTooLong
 	}
 
@@ -108,7 +108,7 @@ func (dr *DashboardServiceImpl) BuildSaveDashboardCommand(ctx context.Context, d
 	}
 
 	if shouldValidateAlerts {
-		dashAlertInfo := alerting.DashAlertInfo{Dash: dash, User: dto.User, OrgID: dash.OrgId}
+		dashAlertInfo := alerting.DashAlertInfo{Dash: dash, User: dto.User, OrgID: dash.OrgID}
 		if err := dr.dashAlertExtractor.ValidateAlerts(ctx, dashAlertInfo); err != nil {
 			return nil, err
 		}
@@ -121,11 +121,11 @@ func (dr *DashboardServiceImpl) BuildSaveDashboardCommand(ctx context.Context, d
 
 	if isParentFolderChanged {
 		// Check that the user is allowed to add a dashboard to the folder
-		guardian, err := guardian.NewByDashboard(ctx, dash, dto.OrgId, dto.User)
+		guardian, err := guardian.NewByDashboard(ctx, dash, dto.OrgID, dto.User)
 		if err != nil {
 			return nil, err
 		}
-		if canSave, err := guardian.CanCreate(dash.FolderId, dash.IsFolder); err != nil || !canSave {
+		if canSave, err := guardian.CanCreate(dash.FolderID, dash.IsFolder); err != nil || !canSave {
 			if err != nil {
 				return nil, err
 			}
@@ -134,7 +134,7 @@ func (dr *DashboardServiceImpl) BuildSaveDashboardCommand(ctx context.Context, d
 	}
 
 	if validateProvisionedDashboard {
-		provisionedData, err := dr.GetProvisionedDashboardDataByDashboardID(ctx, dash.Id)
+		provisionedData, err := dr.GetProvisionedDashboardDataByDashboardID(ctx, dash.ID)
 		if err != nil {
 			return nil, err
 		}
@@ -149,8 +149,8 @@ func (dr *DashboardServiceImpl) BuildSaveDashboardCommand(ctx context.Context, d
 		return nil, err
 	}
 
-	if dash.Id == 0 {
-		if canCreate, err := guard.CanCreate(dash.FolderId, dash.IsFolder); err != nil || !canCreate {
+	if dash.ID == 0 {
+		if canCreate, err := guard.CanCreate(dash.FolderID, dash.IsFolder); err != nil || !canCreate {
 			if err != nil {
 				return nil, err
 			}
@@ -165,15 +165,15 @@ func (dr *DashboardServiceImpl) BuildSaveDashboardCommand(ctx context.Context, d
 		}
 	}
 
-	cmd := &models.SaveDashboardCommand{
+	cmd := &dashboards.SaveDashboardCommand{
 		Dashboard: dash.Data,
 		Message:   dto.Message,
-		OrgId:     dto.OrgId,
+		OrgID:     dto.OrgID,
 		Overwrite: dto.Overwrite,
-		UserId:    dto.User.UserID,
-		FolderId:  dash.FolderId,
+		UserID:    dto.User.UserID,
+		FolderID:  dash.FolderID,
 		IsFolder:  dash.IsFolder,
-		PluginId:  dash.PluginId,
+		PluginID:  dash.PluginID,
 	}
 
 	if !dto.UpdatedAt.IsZero() {
@@ -193,25 +193,25 @@ func (dr *DashboardServiceImpl) DeleteOrphanedProvisionedDashboards(ctx context.
 
 // getGuardianForSavePermissionCheck returns the guardian to be used for checking permission of dashboard
 // It replaces deleted Dashboard.GetDashboardIdForSavePermissionCheck()
-func getGuardianForSavePermissionCheck(ctx context.Context, d *models.Dashboard, user *user.SignedInUser) (guardian.DashboardGuardian, error) {
-	newDashboard := d.Id == 0
+func getGuardianForSavePermissionCheck(ctx context.Context, d *dashboards.Dashboard, user *user.SignedInUser) (guardian.DashboardGuardian, error) {
+	newDashboard := d.ID == 0
 
 	if newDashboard {
 		// if it's a new dashboard/folder check the parent folder permissions
-		guard, err := guardian.New(ctx, d.FolderId, d.OrgId, user)
+		guard, err := guardian.New(ctx, d.FolderID, d.OrgID, user)
 		if err != nil {
 			return nil, err
 		}
 		return guard, nil
 	}
-	guard, err := guardian.NewByDashboard(ctx, d, d.OrgId, user)
+	guard, err := guardian.NewByDashboard(ctx, d, d.OrgID, user)
 	if err != nil {
 		return nil, err
 	}
 	return guard, nil
 }
 
-func validateDashboardRefreshInterval(dash *models.Dashboard) error {
+func validateDashboardRefreshInterval(dash *dashboards.Dashboard) error {
 	if setting.MinRefreshInterval == "" {
 		return nil
 	}
@@ -239,14 +239,14 @@ func validateDashboardRefreshInterval(dash *models.Dashboard) error {
 }
 
 func (dr *DashboardServiceImpl) SaveProvisionedDashboard(ctx context.Context, dto *dashboards.SaveDashboardDTO,
-	provisioning *models.DashboardProvisioning) (*models.Dashboard, error) {
+	provisioning *dashboards.DashboardProvisioning) (*dashboards.Dashboard, error) {
 	if err := validateDashboardRefreshInterval(dto.Dashboard); err != nil {
 		dr.log.Warn("Changing refresh interval for provisioned dashboard to minimum refresh interval", "dashboardUid",
-			dto.Dashboard.Uid, "dashboardTitle", dto.Dashboard.Title, "minRefreshInterval", setting.MinRefreshInterval)
+			dto.Dashboard.UID, "dashboardTitle", dto.Dashboard.Title, "minRefreshInterval", setting.MinRefreshInterval)
 		dto.Dashboard.Data.Set("refresh", setting.MinRefreshInterval)
 	}
 
-	dto.User = accesscontrol.BackgroundUser("dashboard_provisioning", dto.OrgId, org.RoleAdmin, provisionerPermissions)
+	dto.User = accesscontrol.BackgroundUser("dashboard_provisioning", dto.OrgID, org.RoleAdmin, provisionerPermissions)
 
 	cmd, err := dr.BuildSaveDashboardCommand(ctx, dto, setting.IsLegacyAlertingEnabled(), false)
 	if err != nil {
@@ -263,7 +263,7 @@ func (dr *DashboardServiceImpl) SaveProvisionedDashboard(ctx context.Context, dt
 	dashAlertInfo := alerting.DashAlertInfo{
 		User:  dto.User,
 		Dash:  dash,
-		OrgID: dto.OrgId,
+		OrgID: dto.OrgID,
 	}
 
 	// extract/save legacy alerts only if legacy alerting is enabled
@@ -273,13 +273,13 @@ func (dr *DashboardServiceImpl) SaveProvisionedDashboard(ctx context.Context, dt
 			return nil, err
 		}
 
-		err = dr.dashboardStore.SaveAlerts(ctx, dash.Id, alerts)
+		err = dr.dashboardStore.SaveAlerts(ctx, dash.ID, alerts)
 		if err != nil {
 			return nil, err
 		}
 	}
 
-	if dto.Dashboard.Id == 0 {
+	if dto.Dashboard.ID == 0 {
 		if err := dr.setDefaultPermissions(ctx, dto, dash, true); err != nil {
 			dr.log.Error("Could not make user admin", "dashboard", dash.Title, "user", dto.User.UserID, "error", err)
 		}
@@ -288,8 +288,8 @@ func (dr *DashboardServiceImpl) SaveProvisionedDashboard(ctx context.Context, dt
 	return dash, nil
 }
 
-func (dr *DashboardServiceImpl) SaveFolderForProvisionedDashboards(ctx context.Context, dto *dashboards.SaveDashboardDTO) (*models.Dashboard, error) {
-	dto.User = accesscontrol.BackgroundUser("dashboard_provisioning", dto.OrgId, org.RoleAdmin, provisionerPermissions)
+func (dr *DashboardServiceImpl) SaveFolderForProvisionedDashboards(ctx context.Context, dto *dashboards.SaveDashboardDTO) (*dashboards.Dashboard, error) {
+	dto.User = accesscontrol.BackgroundUser("dashboard_provisioning", dto.OrgID, org.RoleAdmin, provisionerPermissions)
 	cmd, err := dr.BuildSaveDashboardCommand(ctx, dto, false, false)
 	if err != nil {
 		return nil, err
@@ -303,7 +303,7 @@ func (dr *DashboardServiceImpl) SaveFolderForProvisionedDashboards(ctx context.C
 	dashAlertInfo := alerting.DashAlertInfo{
 		User:  dto.User,
 		Dash:  dash,
-		OrgID: dto.OrgId,
+		OrgID: dto.OrgID,
 	}
 
 	// extract/save legacy alerts only if legacy alerting is enabled
@@ -313,13 +313,13 @@ func (dr *DashboardServiceImpl) SaveFolderForProvisionedDashboards(ctx context.C
 			return nil, err
 		}
 
-		err = dr.dashboardStore.SaveAlerts(ctx, dash.Id, alerts)
+		err = dr.dashboardStore.SaveAlerts(ctx, dash.ID, alerts)
 		if err != nil {
 			return nil, err
 		}
 	}
 
-	if dto.Dashboard.Id == 0 {
+	if dto.Dashboard.ID == 0 {
 		if err := dr.setDefaultPermissions(ctx, dto, dash, true); err != nil {
 			dr.log.Error("Could not make user admin", "dashboard", dash.Title, "user", dto.User.UserID, "error", err)
 		}
@@ -329,10 +329,10 @@ func (dr *DashboardServiceImpl) SaveFolderForProvisionedDashboards(ctx context.C
 }
 
 func (dr *DashboardServiceImpl) SaveDashboard(ctx context.Context, dto *dashboards.SaveDashboardDTO,
-	allowUiUpdate bool) (*models.Dashboard, error) {
+	allowUiUpdate bool) (*dashboards.Dashboard, error) {
 	if err := validateDashboardRefreshInterval(dto.Dashboard); err != nil {
 		dr.log.Warn("Changing refresh interval for imported dashboard to minimum refresh interval",
-			"dashboardUid", dto.Dashboard.Uid, "dashboardTitle", dto.Dashboard.Title, "minRefreshInterval",
+			"dashboardUid", dto.Dashboard.UID, "dashboardTitle", dto.Dashboard.Title, "minRefreshInterval",
 			setting.MinRefreshInterval)
 		dto.Dashboard.Data.Set("refresh", setting.MinRefreshInterval)
 	}
@@ -350,7 +350,7 @@ func (dr *DashboardServiceImpl) SaveDashboard(ctx context.Context, dto *dashboar
 	dashAlertInfo := alerting.DashAlertInfo{
 		User:  dto.User,
 		Dash:  dash,
-		OrgID: dto.OrgId,
+		OrgID: dto.OrgID,
 	}
 
 	// extract/save legacy alerts only if legacy alerting is enabled
@@ -360,14 +360,14 @@ func (dr *DashboardServiceImpl) SaveDashboard(ctx context.Context, dto *dashboar
 			return nil, err
 		}
 
-		err = dr.dashboardStore.SaveAlerts(ctx, dash.Id, alerts)
+		err = dr.dashboardStore.SaveAlerts(ctx, dash.ID, alerts)
 		if err != nil {
 			return nil, err
 		}
 	}
 
 	// new dashboard created
-	if dto.Dashboard.Id == 0 {
+	if dto.Dashboard.ID == 0 {
 		if err := dr.setDefaultPermissions(ctx, dto, dash, false); err != nil {
 			dr.log.Error("Could not make user admin", "dashboard", dash.Title, "user", dto.User.UserID, "error", err)
 		}
@@ -450,10 +450,10 @@ func (dr *DashboardServiceImpl) deleteDashboard(ctx context.Context, dashboardId
 }
 
 func (dr *DashboardServiceImpl) ImportDashboard(ctx context.Context, dto *dashboards.SaveDashboardDTO) (
-	*models.Dashboard, error) {
+	*dashboards.Dashboard, error) {
 	if err := validateDashboardRefreshInterval(dto.Dashboard); err != nil {
 		dr.log.Warn("Changing refresh interval for imported dashboard to minimum refresh interval",
-			"dashboardUid", dto.Dashboard.Uid, "dashboardTitle", dto.Dashboard.Title,
+			"dashboardUid", dto.Dashboard.UID, "dashboardTitle", dto.Dashboard.Title,
 			"minRefreshInterval", setting.MinRefreshInterval)
 		dto.Dashboard.Data.Set("refresh", setting.MinRefreshInterval)
 	}
@@ -485,8 +485,8 @@ func (dr *DashboardServiceImpl) GetDashboardsByPluginID(ctx context.Context, que
 	return dr.dashboardStore.GetDashboardsByPluginID(ctx, query)
 }
 
-func (dr *DashboardServiceImpl) setDefaultPermissions(ctx context.Context, dto *dashboards.SaveDashboardDTO, dash *models.Dashboard, provisioned bool) error {
-	inFolder := dash.FolderId > 0
+func (dr *DashboardServiceImpl) setDefaultPermissions(ctx context.Context, dto *dashboards.SaveDashboardDTO, dash *dashboards.Dashboard, provisioned bool) error {
+	inFolder := dash.FolderID > 0
 	if !accesscontrol.IsDisabled(dr.cfg) {
 		var permissions []accesscontrol.SetResourcePermissionCommand
 		if !provisioned && dto.User.IsRealUser() && !dto.User.IsAnonymous {
@@ -507,12 +507,12 @@ func (dr *DashboardServiceImpl) setDefaultPermissions(ctx context.Context, dto *
 			svc = dr.folderPermissions
 		}
 
-		_, err := svc.SetPermissions(ctx, dto.OrgId, dash.Uid, permissions...)
+		_, err := svc.SetPermissions(ctx, dto.OrgID, dash.UID, permissions...)
 		if err != nil {
 			return err
 		}
 	} else if dr.cfg.EditorsCanAdmin && !provisioned && dto.User.IsRealUser() && !dto.User.IsAnonymous {
-		if err := dr.MakeUserAdmin(ctx, dto.OrgId, dto.User.UserID, dash.Id, !inFolder); err != nil {
+		if err := dr.MakeUserAdmin(ctx, dto.OrgID, dto.User.UserID, dash.ID, !inFolder); err != nil {
 			return err
 		}
 	}
@@ -520,16 +520,16 @@ func (dr *DashboardServiceImpl) setDefaultPermissions(ctx context.Context, dto *
 	return nil
 }
 
-func (dr *DashboardServiceImpl) GetDashboard(ctx context.Context, query *models.GetDashboardQuery) error {
+func (dr *DashboardServiceImpl) GetDashboard(ctx context.Context, query *dashboards.GetDashboardQuery) error {
 	_, err := dr.dashboardStore.GetDashboard(ctx, query)
 	return err
 }
 
-func (dr *DashboardServiceImpl) GetDashboardUIDById(ctx context.Context, query *models.GetDashboardRefByIdQuery) error {
-	return dr.dashboardStore.GetDashboardUIDById(ctx, query)
+func (dr *DashboardServiceImpl) GetDashboardUIDByID(ctx context.Context, query *dashboards.GetDashboardRefByIDQuery) error {
+	return dr.dashboardStore.GetDashboardUIDByID(ctx, query)
 }
 
-func (dr *DashboardServiceImpl) GetDashboards(ctx context.Context, query *models.GetDashboardsQuery) error {
+func (dr *DashboardServiceImpl) GetDashboards(ctx context.Context, query *dashboards.GetDashboardsQuery) error {
 	return dr.dashboardStore.GetDashboards(ctx, query)
 }
 

pkg/services/dashboards/service/dashboard_service_integration_test.go

@@ -35,8 +35,8 @@ func TestIntegrationIntegratedDashboardService(t *testing.T) {
 
 		permissionScenario(t, "When saving a dashboard with non-existing id", true,
 			func(t *testing.T, sc *permissionScenarioContext) {
-				cmd := models.SaveDashboardCommand{
-					OrgId: testOrgID,
+				cmd := dashboards.SaveDashboardCommand{
+					OrgID: testOrgID,
 					Dashboard: simplejson.NewFromAny(map[string]interface{}{
 						"id":    float64(123412321),
 						"title": "Expect error",
@@ -54,10 +54,10 @@ func TestIntegrationIntegratedDashboardService(t *testing.T) {
 
 			permissionScenario(t, "When creating a dashboard with same id as dashboard in organization A",
 				true, func(t *testing.T, sc *permissionScenarioContext) {
-					cmd := models.SaveDashboardCommand{
-						OrgId: otherOrgId,
+					cmd := dashboards.SaveDashboardCommand{
+						OrgID: otherOrgId,
 						Dashboard: simplejson.NewFromAny(map[string]interface{}{
-							"id":    sc.savedDashInFolder.Id,
+							"id":    sc.savedDashInFolder.ID,
 							"title": "Expect error",
 						}),
 						Overwrite: false,
@@ -70,10 +70,10 @@ func TestIntegrationIntegratedDashboardService(t *testing.T) {
 			permissionScenario(t, "When creating a dashboard with same uid as dashboard in organization A, it should create a new dashboard in org B",
 				true, func(t *testing.T, sc *permissionScenarioContext) {
 					const otherOrgId int64 = 2
-					cmd := models.SaveDashboardCommand{
-						OrgId: otherOrgId,
+					cmd := dashboards.SaveDashboardCommand{
+						OrgID: otherOrgId,
 						Dashboard: simplejson.NewFromAny(map[string]interface{}{
-							"uid":   sc.savedDashInFolder.Uid,
+							"uid":   sc.savedDashInFolder.UID,
 							"title": "Dash with existing uid in other org",
 						}),
 						Overwrite: false,
@@ -82,9 +82,9 @@ func TestIntegrationIntegratedDashboardService(t *testing.T) {
 					res := callSaveWithResult(t, cmd, sc.sqlStore)
 					require.NotNil(t, res)
 
-					_, err := sc.dashboardStore.GetDashboard(context.Background(), &models.GetDashboardQuery{
-						OrgId: otherOrgId,
-						Uid:   sc.savedDashInFolder.Uid,
+					_, err := sc.dashboardStore.GetDashboard(context.Background(), &dashboards.GetDashboardQuery{
+						OrgID: otherOrgId,
+						UID:   sc.savedDashInFolder.UID,
 					})
 					require.NoError(t, err)
 				})
@@ -96,12 +96,12 @@ func TestIntegrationIntegratedDashboardService(t *testing.T) {
 			permissionScenario(t, "When creating a new dashboard in the General folder", canSave,
 				func(t *testing.T, sc *permissionScenarioContext) {
 					sqlStore := db.InitTestDB(t)
-					cmd := models.SaveDashboardCommand{
-						OrgId: testOrgID,
+					cmd := dashboards.SaveDashboardCommand{
+						OrgID: testOrgID,
 						Dashboard: simplejson.NewFromAny(map[string]interface{}{
 							"title": "Dash",
 						}),
-						UserId:    10000,
+						UserID:    10000,
 						Overwrite: true,
 					}
 
@@ -109,195 +109,195 @@ func TestIntegrationIntegratedDashboardService(t *testing.T) {
 					assert.Equal(t, dashboards.ErrDashboardUpdateAccessDenied, err)
 
 					assert.Equal(t, "", sc.dashboardGuardianMock.DashUID)
-					assert.Equal(t, cmd.OrgId, sc.dashboardGuardianMock.OrgId)
-					assert.Equal(t, cmd.UserId, sc.dashboardGuardianMock.User.UserID)
+					assert.Equal(t, cmd.OrgID, sc.dashboardGuardianMock.OrgId)
+					assert.Equal(t, cmd.UserID, sc.dashboardGuardianMock.User.UserID)
 				})
 
 			permissionScenario(t, "When creating a new dashboard in other folder, it should create dashboard guardian for other folder with correct arguments and rsult in access denied error",
 				canSave, func(t *testing.T, sc *permissionScenarioContext) {
-					cmd := models.SaveDashboardCommand{
-						OrgId: testOrgID,
+					cmd := dashboards.SaveDashboardCommand{
+						OrgID: testOrgID,
 						Dashboard: simplejson.NewFromAny(map[string]interface{}{
 							"title": "Dash",
 						}),
-						FolderId:  sc.otherSavedFolder.Id,
-						UserId:    10000,
+						FolderID:  sc.otherSavedFolder.ID,
+						UserID:    10000,
 						Overwrite: true,
 					}
 
 					err := callSaveWithError(t, cmd, sc.sqlStore)
 					require.Equal(t, dashboards.ErrDashboardUpdateAccessDenied, err)
 
-					assert.Equal(t, sc.otherSavedFolder.Id, sc.dashboardGuardianMock.DashID)
-					assert.Equal(t, cmd.OrgId, sc.dashboardGuardianMock.OrgId)
-					assert.Equal(t, cmd.UserId, sc.dashboardGuardianMock.User.UserID)
+					assert.Equal(t, sc.otherSavedFolder.ID, sc.dashboardGuardianMock.DashID)
+					assert.Equal(t, cmd.OrgID, sc.dashboardGuardianMock.OrgId)
+					assert.Equal(t, cmd.UserID, sc.dashboardGuardianMock.User.UserID)
 				})
 
 			permissionScenario(t, "When creating a new dashboard by existing title in folder, it should create dashboard guardian for dashboard with correct arguments and result in access denied error",
 				canSave, func(t *testing.T, sc *permissionScenarioContext) {
-					cmd := models.SaveDashboardCommand{
-						OrgId: testOrgID,
+					cmd := dashboards.SaveDashboardCommand{
+						OrgID: testOrgID,
 						Dashboard: simplejson.NewFromAny(map[string]interface{}{
 							"title": sc.savedDashInFolder.Title,
 						}),
-						FolderId:  sc.savedFolder.Id,
-						UserId:    10000,
+						FolderID:  sc.savedFolder.ID,
+						UserID:    10000,
 						Overwrite: true,
 					}
 
 					err := callSaveWithError(t, cmd, sc.sqlStore)
 					require.Equal(t, dashboards.ErrDashboardUpdateAccessDenied, err)
 
-					assert.Equal(t, sc.savedDashInFolder.Uid, sc.dashboardGuardianMock.DashUID)
-					assert.Equal(t, cmd.OrgId, sc.dashboardGuardianMock.OrgId)
-					assert.Equal(t, cmd.UserId, sc.dashboardGuardianMock.User.UserID)
+					assert.Equal(t, sc.savedDashInFolder.UID, sc.dashboardGuardianMock.DashUID)
+					assert.Equal(t, cmd.OrgID, sc.dashboardGuardianMock.OrgId)
+					assert.Equal(t, cmd.UserID, sc.dashboardGuardianMock.User.UserID)
 				})
 
 			permissionScenario(t, "When creating a new dashboard by existing UID in folder, it should create dashboard guardian for dashboard with correct arguments and result in access denied error",
 				canSave, func(t *testing.T, sc *permissionScenarioContext) {
-					cmd := models.SaveDashboardCommand{
-						OrgId: testOrgID,
+					cmd := dashboards.SaveDashboardCommand{
+						OrgID: testOrgID,
 						Dashboard: simplejson.NewFromAny(map[string]interface{}{
-							"uid":   sc.savedDashInFolder.Uid,
+							"uid":   sc.savedDashInFolder.UID,
 							"title": "New dash",
 						}),
-						FolderId:  sc.savedFolder.Id,
-						UserId:    10000,
+						FolderID:  sc.savedFolder.ID,
+						UserID:    10000,
 						Overwrite: true,
 					}
 
 					err := callSaveWithError(t, cmd, sc.sqlStore)
 					require.Equal(t, dashboards.ErrDashboardUpdateAccessDenied, err)
 
-					assert.Equal(t, sc.savedDashInFolder.Uid, sc.dashboardGuardianMock.DashUID)
-					assert.Equal(t, cmd.OrgId, sc.dashboardGuardianMock.OrgId)
-					assert.Equal(t, cmd.UserId, sc.dashboardGuardianMock.User.UserID)
+					assert.Equal(t, sc.savedDashInFolder.UID, sc.dashboardGuardianMock.DashUID)
+					assert.Equal(t, cmd.OrgID, sc.dashboardGuardianMock.OrgId)
+					assert.Equal(t, cmd.UserID, sc.dashboardGuardianMock.User.UserID)
 				})
 
 			permissionScenario(t, "When updating a dashboard by existing id in the General folder, it should create dashboard guardian for dashboard with correct arguments and result in access denied error",
 				canSave, func(t *testing.T, sc *permissionScenarioContext) {
-					cmd := models.SaveDashboardCommand{
-						OrgId: testOrgID,
+					cmd := dashboards.SaveDashboardCommand{
+						OrgID: testOrgID,
 						Dashboard: simplejson.NewFromAny(map[string]interface{}{
-							"id":    sc.savedDashInGeneralFolder.Id,
+							"id":    sc.savedDashInGeneralFolder.ID,
 							"title": "Dash",
 						}),
-						FolderId:  sc.savedDashInGeneralFolder.FolderId,
-						UserId:    10000,
+						FolderID:  sc.savedDashInGeneralFolder.FolderID,
+						UserID:    10000,
 						Overwrite: true,
 					}
 
 					err := callSaveWithError(t, cmd, sc.sqlStore)
 					assert.Equal(t, dashboards.ErrDashboardUpdateAccessDenied, err)
 
-					assert.Equal(t, sc.savedDashInGeneralFolder.Uid, sc.dashboardGuardianMock.DashUID)
-					assert.Equal(t, cmd.OrgId, sc.dashboardGuardianMock.OrgId)
-					assert.Equal(t, cmd.UserId, sc.dashboardGuardianMock.User.UserID)
+					assert.Equal(t, sc.savedDashInGeneralFolder.UID, sc.dashboardGuardianMock.DashUID)
+					assert.Equal(t, cmd.OrgID, sc.dashboardGuardianMock.OrgId)
+					assert.Equal(t, cmd.UserID, sc.dashboardGuardianMock.User.UserID)
 				})
 
 			permissionScenario(t, "When updating a dashboard by existing id in other folder, it should create dashboard guardian for dashboard with correct arguments and result in access denied error",
 				canSave, func(t *testing.T, sc *permissionScenarioContext) {
-					cmd := models.SaveDashboardCommand{
-						OrgId: testOrgID,
+					cmd := dashboards.SaveDashboardCommand{
+						OrgID: testOrgID,
 						Dashboard: simplejson.NewFromAny(map[string]interface{}{
-							"id":    sc.savedDashInFolder.Id,
+							"id":    sc.savedDashInFolder.ID,
 							"title": "Dash",
 						}),
-						FolderId:  sc.savedDashInFolder.FolderId,
-						UserId:    10000,
+						FolderID:  sc.savedDashInFolder.FolderID,
+						UserID:    10000,
 						Overwrite: true,
 					}
 
 					err := callSaveWithError(t, cmd, sc.sqlStore)
 					require.Equal(t, dashboards.ErrDashboardUpdateAccessDenied, err)
 
-					assert.Equal(t, sc.savedDashInFolder.Uid, sc.dashboardGuardianMock.DashUID)
-					assert.Equal(t, cmd.OrgId, sc.dashboardGuardianMock.OrgId)
-					assert.Equal(t, cmd.UserId, sc.dashboardGuardianMock.User.UserID)
+					assert.Equal(t, sc.savedDashInFolder.UID, sc.dashboardGuardianMock.DashUID)
+					assert.Equal(t, cmd.OrgID, sc.dashboardGuardianMock.OrgId)
+					assert.Equal(t, cmd.UserID, sc.dashboardGuardianMock.User.UserID)
 				})
 
 			permissionScenario(t, "When moving a dashboard by existing ID to other folder from General folder, it should create dashboard guardian for dashboard with correct arguments and result in access denied error",
 				canSave, func(t *testing.T, sc *permissionScenarioContext) {
-					cmd := models.SaveDashboardCommand{
-						OrgId: testOrgID,
+					cmd := dashboards.SaveDashboardCommand{
+						OrgID: testOrgID,
 						Dashboard: simplejson.NewFromAny(map[string]interface{}{
-							"id":    sc.savedDashInGeneralFolder.Id,
+							"id":    sc.savedDashInGeneralFolder.ID,
 							"title": "Dash",
 						}),
-						FolderId:  sc.otherSavedFolder.Id,
-						UserId:    10000,
+						FolderID:  sc.otherSavedFolder.ID,
+						UserID:    10000,
 						Overwrite: true,
 					}
 
 					err := callSaveWithError(t, cmd, sc.sqlStore)
 					require.Equal(t, dashboards.ErrDashboardUpdateAccessDenied, err)
 
-					assert.Equal(t, sc.savedDashInGeneralFolder.Uid, sc.dashboardGuardianMock.DashUID)
-					assert.Equal(t, cmd.OrgId, sc.dashboardGuardianMock.OrgId)
-					assert.Equal(t, cmd.UserId, sc.dashboardGuardianMock.User.UserID)
+					assert.Equal(t, sc.savedDashInGeneralFolder.UID, sc.dashboardGuardianMock.DashUID)
+					assert.Equal(t, cmd.OrgID, sc.dashboardGuardianMock.OrgId)
+					assert.Equal(t, cmd.UserID, sc.dashboardGuardianMock.User.UserID)
 				})
 
 			permissionScenario(t, "When moving a dashboard by existing id to the General folder from other folder, it should create dashboard guardian for dashboard with correct arguments and result in access denied error",
 				canSave, func(t *testing.T, sc *permissionScenarioContext) {
-					cmd := models.SaveDashboardCommand{
-						OrgId: testOrgID,
+					cmd := dashboards.SaveDashboardCommand{
+						OrgID: testOrgID,
 						Dashboard: simplejson.NewFromAny(map[string]interface{}{
-							"id":    sc.savedDashInFolder.Id,
+							"id":    sc.savedDashInFolder.ID,
 							"title": "Dash",
 						}),
-						FolderId:  0,
-						UserId:    10000,
+						FolderID:  0,
+						UserID:    10000,
 						Overwrite: true,
 					}
 
 					err := callSaveWithError(t, cmd, sc.sqlStore)
 					assert.Equal(t, dashboards.ErrDashboardUpdateAccessDenied, err)
 
-					assert.Equal(t, sc.savedDashInFolder.Uid, sc.dashboardGuardianMock.DashUID)
-					assert.Equal(t, cmd.OrgId, sc.dashboardGuardianMock.OrgId)
-					assert.Equal(t, cmd.UserId, sc.dashboardGuardianMock.User.UserID)
+					assert.Equal(t, sc.savedDashInFolder.UID, sc.dashboardGuardianMock.DashUID)
+					assert.Equal(t, cmd.OrgID, sc.dashboardGuardianMock.OrgId)
+					assert.Equal(t, cmd.UserID, sc.dashboardGuardianMock.User.UserID)
 				})
 
 			permissionScenario(t, "When moving a dashboard by existing uid to other folder from General folder, it should create dashboard guardian for dashboard with correct arguments and result in access denied error",
 				canSave, func(t *testing.T, sc *permissionScenarioContext) {
-					cmd := models.SaveDashboardCommand{
-						OrgId: testOrgID,
+					cmd := dashboards.SaveDashboardCommand{
+						OrgID: testOrgID,
 						Dashboard: simplejson.NewFromAny(map[string]interface{}{
-							"uid":   sc.savedDashInGeneralFolder.Uid,
+							"uid":   sc.savedDashInGeneralFolder.UID,
 							"title": "Dash",
 						}),
-						FolderId:  sc.otherSavedFolder.Id,
-						UserId:    10000,
+						FolderID:  sc.otherSavedFolder.ID,
+						UserID:    10000,
 						Overwrite: true,
 					}
 
 					err := callSaveWithError(t, cmd, sc.sqlStore)
 					require.Equal(t, dashboards.ErrDashboardUpdateAccessDenied, err)
 
-					assert.Equal(t, sc.savedDashInGeneralFolder.Uid, sc.dashboardGuardianMock.DashUID)
-					assert.Equal(t, cmd.OrgId, sc.dashboardGuardianMock.OrgId)
-					assert.Equal(t, cmd.UserId, sc.dashboardGuardianMock.User.UserID)
+					assert.Equal(t, sc.savedDashInGeneralFolder.UID, sc.dashboardGuardianMock.DashUID)
+					assert.Equal(t, cmd.OrgID, sc.dashboardGuardianMock.OrgId)
+					assert.Equal(t, cmd.UserID, sc.dashboardGuardianMock.User.UserID)
 				})
 
 			permissionScenario(t, "When moving a dashboard by existing UID to the General folder from other folder, it should create dashboard guardian for dashboard with correct arguments and result in access denied error",
 				canSave, func(t *testing.T, sc *permissionScenarioContext) {
-					cmd := models.SaveDashboardCommand{
-						OrgId: testOrgID,
+					cmd := dashboards.SaveDashboardCommand{
+						OrgID: testOrgID,
 						Dashboard: simplejson.NewFromAny(map[string]interface{}{
-							"uid":   sc.savedDashInFolder.Uid,
+							"uid":   sc.savedDashInFolder.UID,
 							"title": "Dash",
 						}),
-						FolderId:  0,
-						UserId:    10000,
+						FolderID:  0,
+						UserID:    10000,
 						Overwrite: true,
 					}
 
 					err := callSaveWithError(t, cmd, sc.sqlStore)
 					require.Equal(t, dashboards.ErrDashboardUpdateAccessDenied, err)
 
-					assert.Equal(t, sc.savedDashInFolder.Uid, sc.dashboardGuardianMock.DashUID)
-					assert.Equal(t, cmd.OrgId, sc.dashboardGuardianMock.OrgId)
-					assert.Equal(t, cmd.UserId, sc.dashboardGuardianMock.User.UserID)
+					assert.Equal(t, sc.savedDashInFolder.UID, sc.dashboardGuardianMock.DashUID)
+					assert.Equal(t, cmd.OrgID, sc.dashboardGuardianMock.OrgId)
+					assert.Equal(t, cmd.UserID, sc.dashboardGuardianMock.User.UserID)
 				})
 		})
 
@@ -309,22 +309,22 @@ func TestIntegrationIntegratedDashboardService(t *testing.T) {
 
 				permissionScenario(t, "When creating a dashboard in General folder with same name as dashboard in other folder",
 					canSave, func(t *testing.T, sc *permissionScenarioContext) {
-						cmd := models.SaveDashboardCommand{
-							OrgId: testOrgID,
+						cmd := dashboards.SaveDashboardCommand{
+							OrgID: testOrgID,
 							Dashboard: simplejson.NewFromAny(map[string]interface{}{
 								"id":    nil,
 								"title": sc.savedDashInFolder.Title,
 							}),
-							FolderId:  0,
+							FolderID:  0,
 							Overwrite: shouldOverwrite,
 						}
 
 						res := callSaveWithResult(t, cmd, sc.sqlStore)
 						require.NotNil(t, res)
 
-						_, err := sc.dashboardStore.GetDashboard(context.Background(), &models.GetDashboardQuery{
-							Id:    res.Id,
-							OrgId: cmd.OrgId,
+						_, err := sc.dashboardStore.GetDashboard(context.Background(), &dashboards.GetDashboardQuery{
+							ID:    res.ID,
+							OrgID: cmd.OrgID,
 						})
 
 						require.NoError(t, err)
@@ -332,32 +332,32 @@ func TestIntegrationIntegratedDashboardService(t *testing.T) {
 
 				permissionScenario(t, "When creating a dashboard in other folder with same name as dashboard in General folder",
 					canSave, func(t *testing.T, sc *permissionScenarioContext) {
-						cmd := models.SaveDashboardCommand{
-							OrgId: testOrgID,
+						cmd := dashboards.SaveDashboardCommand{
+							OrgID: testOrgID,
 							Dashboard: simplejson.NewFromAny(map[string]interface{}{
 								"id":    nil,
 								"title": sc.savedDashInGeneralFolder.Title,
 							}),
-							FolderId:  sc.savedFolder.Id,
+							FolderID:  sc.savedFolder.ID,
 							Overwrite: shouldOverwrite,
 						}
 
 						res := callSaveWithResult(t, cmd, sc.sqlStore)
 						require.NotNil(t, res)
 
-						assert.NotEqual(t, sc.savedDashInGeneralFolder.Id, res.Id)
+						assert.NotEqual(t, sc.savedDashInGeneralFolder.ID, res.ID)
 
-						_, err := sc.dashboardStore.GetDashboard(context.Background(), &models.GetDashboardQuery{
-							Id:    res.Id,
-							OrgId: cmd.OrgId,
+						_, err := sc.dashboardStore.GetDashboard(context.Background(), &dashboards.GetDashboardQuery{
+							ID:    res.ID,
+							OrgID: cmd.OrgID,
 						})
 						require.NoError(t, err)
 					})
 
 				permissionScenario(t, "When creating a folder with same name as dashboard in other folder",
 					canSave, func(t *testing.T, sc *permissionScenarioContext) {
-						cmd := models.SaveDashboardCommand{
-							OrgId: testOrgID,
+						cmd := dashboards.SaveDashboardCommand{
+							OrgID: testOrgID,
 							Dashboard: simplejson.NewFromAny(map[string]interface{}{
 								"id":    nil,
 								"title": sc.savedDashInFolder.Title,
@@ -369,20 +369,20 @@ func TestIntegrationIntegratedDashboardService(t *testing.T) {
 						res := callSaveWithResult(t, cmd, sc.sqlStore)
 						require.NotNil(t, res)
 
-						assert.NotEqual(t, sc.savedDashInGeneralFolder.Id, res.Id)
+						assert.NotEqual(t, sc.savedDashInGeneralFolder.ID, res.ID)
 						assert.True(t, res.IsFolder)
 
-						_, err := sc.dashboardStore.GetDashboard(context.Background(), &models.GetDashboardQuery{
-							Id:    res.Id,
-							OrgId: cmd.OrgId,
+						_, err := sc.dashboardStore.GetDashboard(context.Background(), &dashboards.GetDashboardQuery{
+							ID:    res.ID,
+							OrgID: cmd.OrgID,
 						})
 						require.NoError(t, err)
 					})
 
 				permissionScenario(t, "When saving a dashboard without id and uid and unique title in folder",
 					canSave, func(t *testing.T, sc *permissionScenarioContext) {
-						cmd := models.SaveDashboardCommand{
-							OrgId: testOrgID,
+						cmd := dashboards.SaveDashboardCommand{
+							OrgID: testOrgID,
 							Dashboard: simplejson.NewFromAny(map[string]interface{}{
 								"title": "Dash without id and uid",
 							}),
@@ -392,19 +392,19 @@ func TestIntegrationIntegratedDashboardService(t *testing.T) {
 						res := callSaveWithResult(t, cmd, sc.sqlStore)
 						require.NotNil(t, res)
 
-						assert.Greater(t, res.Id, int64(0))
-						assert.NotEmpty(t, res.Uid)
-						_, err := sc.dashboardStore.GetDashboard(context.Background(), &models.GetDashboardQuery{
-							Id:    res.Id,
-							OrgId: cmd.OrgId,
+						assert.Greater(t, res.ID, int64(0))
+						assert.NotEmpty(t, res.UID)
+						_, err := sc.dashboardStore.GetDashboard(context.Background(), &dashboards.GetDashboardQuery{
+							ID:    res.ID,
+							OrgID: cmd.OrgID,
 						})
 						require.NoError(t, err)
 					})
 
 				permissionScenario(t, "When saving a dashboard when dashboard id is zero ", canSave,
 					func(t *testing.T, sc *permissionScenarioContext) {
-						cmd := models.SaveDashboardCommand{
-							OrgId: testOrgID,
+						cmd := dashboards.SaveDashboardCommand{
+							OrgID: testOrgID,
 							Dashboard: simplejson.NewFromAny(map[string]interface{}{
 								"id":    0,
 								"title": "Dash with zero id",
@@ -415,21 +415,21 @@ func TestIntegrationIntegratedDashboardService(t *testing.T) {
 						res := callSaveWithResult(t, cmd, sc.sqlStore)
 						require.NotNil(t, res)
 
-						_, err := sc.dashboardStore.GetDashboard(context.Background(), &models.GetDashboardQuery{
-							Id:    res.Id,
-							OrgId: cmd.OrgId,
+						_, err := sc.dashboardStore.GetDashboard(context.Background(), &dashboards.GetDashboardQuery{
+							ID:    res.ID,
+							OrgID: cmd.OrgID,
 						})
 						require.NoError(t, err)
 					})
 
 				permissionScenario(t, "When saving a dashboard in non-existing folder", canSave,
 					func(t *testing.T, sc *permissionScenarioContext) {
-						cmd := models.SaveDashboardCommand{
-							OrgId: testOrgID,
+						cmd := dashboards.SaveDashboardCommand{
+							OrgID: testOrgID,
 							Dashboard: simplejson.NewFromAny(map[string]interface{}{
 								"title": "Expect error",
 							}),
-							FolderId:  123412321,
+							FolderID:  123412321,
 							Overwrite: shouldOverwrite,
 						}
 
@@ -439,13 +439,13 @@ func TestIntegrationIntegratedDashboardService(t *testing.T) {
 
 				permissionScenario(t, "When updating an existing dashboard by id without current version", canSave,
 					func(t *testing.T, sc *permissionScenarioContext) {
-						cmd := models.SaveDashboardCommand{
-							OrgId: 1,
+						cmd := dashboards.SaveDashboardCommand{
+							OrgID: 1,
 							Dashboard: simplejson.NewFromAny(map[string]interface{}{
-								"id":    sc.savedDashInGeneralFolder.Id,
+								"id":    sc.savedDashInGeneralFolder.ID,
 								"title": "test dash 23",
 							}),
-							FolderId:  sc.savedFolder.Id,
+							FolderID:  sc.savedFolder.ID,
 							Overwrite: shouldOverwrite,
 						}
 
@@ -455,23 +455,23 @@ func TestIntegrationIntegratedDashboardService(t *testing.T) {
 
 				permissionScenario(t, "When updating an existing dashboard by id with current version", canSave,
 					func(t *testing.T, sc *permissionScenarioContext) {
-						cmd := models.SaveDashboardCommand{
-							OrgId: 1,
+						cmd := dashboards.SaveDashboardCommand{
+							OrgID: 1,
 							Dashboard: simplejson.NewFromAny(map[string]interface{}{
-								"id":      sc.savedDashInGeneralFolder.Id,
+								"id":      sc.savedDashInGeneralFolder.ID,
 								"title":   "Updated title",
 								"version": sc.savedDashInGeneralFolder.Version,
 							}),
-							FolderId:  sc.savedFolder.Id,
+							FolderID:  sc.savedFolder.ID,
 							Overwrite: shouldOverwrite,
 						}
 
 						res := callSaveWithResult(t, cmd, sc.sqlStore)
 						require.NotNil(t, res)
 
-						_, err := sc.dashboardStore.GetDashboard(context.Background(), &models.GetDashboardQuery{
-							Id:    sc.savedDashInGeneralFolder.Id,
-							OrgId: cmd.OrgId,
+						_, err := sc.dashboardStore.GetDashboard(context.Background(), &dashboards.GetDashboardQuery{
+							ID:    sc.savedDashInGeneralFolder.ID,
+							OrgID: cmd.OrgID,
 						})
 
 						require.NoError(t, err)
@@ -479,13 +479,13 @@ func TestIntegrationIntegratedDashboardService(t *testing.T) {
 
 				permissionScenario(t, "When updating an existing dashboard by uid without current version", canSave,
 					func(t *testing.T, sc *permissionScenarioContext) {
-						cmd := models.SaveDashboardCommand{
-							OrgId: 1,
+						cmd := dashboards.SaveDashboardCommand{
+							OrgID: 1,
 							Dashboard: simplejson.NewFromAny(map[string]interface{}{
-								"uid":   sc.savedDashInFolder.Uid,
+								"uid":   sc.savedDashInFolder.UID,
 								"title": "test dash 23",
 							}),
-							FolderId:  0,
+							FolderID:  0,
 							Overwrite: shouldOverwrite,
 						}
 
@@ -495,36 +495,36 @@ func TestIntegrationIntegratedDashboardService(t *testing.T) {
 
 				permissionScenario(t, "When updating an existing dashboard by uid with current version", canSave,
 					func(t *testing.T, sc *permissionScenarioContext) {
-						cmd := models.SaveDashboardCommand{
-							OrgId: 1,
+						cmd := dashboards.SaveDashboardCommand{
+							OrgID: 1,
 							Dashboard: simplejson.NewFromAny(map[string]interface{}{
-								"uid":     sc.savedDashInFolder.Uid,
+								"uid":     sc.savedDashInFolder.UID,
 								"title":   "Updated title",
 								"version": sc.savedDashInFolder.Version,
 							}),
-							FolderId:  0,
+							FolderID:  0,
 							Overwrite: shouldOverwrite,
 						}
 
 						res := callSaveWithResult(t, cmd, sc.sqlStore)
 						require.NotNil(t, res)
 
-						_, err := sc.dashboardStore.GetDashboard(context.Background(), &models.GetDashboardQuery{
-							Id:    sc.savedDashInFolder.Id,
-							OrgId: cmd.OrgId,
+						_, err := sc.dashboardStore.GetDashboard(context.Background(), &dashboards.GetDashboardQuery{
+							ID:    sc.savedDashInFolder.ID,
+							OrgID: cmd.OrgID,
 						})
 						require.NoError(t, err)
 					})
 
 				permissionScenario(t, "When creating a dashboard with same name as dashboard in other folder",
 					canSave, func(t *testing.T, sc *permissionScenarioContext) {
-						cmd := models.SaveDashboardCommand{
-							OrgId: testOrgID,
+						cmd := dashboards.SaveDashboardCommand{
+							OrgID: testOrgID,
 							Dashboard: simplejson.NewFromAny(map[string]interface{}{
 								"id":    nil,
 								"title": sc.savedDashInFolder.Title,
 							}),
-							FolderId:  sc.savedDashInFolder.FolderId,
+							FolderID:  sc.savedDashInFolder.FolderID,
 							Overwrite: shouldOverwrite,
 						}
 
@@ -534,13 +534,13 @@ func TestIntegrationIntegratedDashboardService(t *testing.T) {
 
 				permissionScenario(t, "When creating a dashboard with same name as dashboard in General folder",
 					canSave, func(t *testing.T, sc *permissionScenarioContext) {
-						cmd := models.SaveDashboardCommand{
-							OrgId: testOrgID,
+						cmd := dashboards.SaveDashboardCommand{
+							OrgID: testOrgID,
 							Dashboard: simplejson.NewFromAny(map[string]interface{}{
 								"id":    nil,
 								"title": sc.savedDashInGeneralFolder.Title,
 							}),
-							FolderId:  sc.savedDashInGeneralFolder.FolderId,
+							FolderID:  sc.savedDashInGeneralFolder.FolderID,
 							Overwrite: shouldOverwrite,
 						}
 
@@ -550,8 +550,8 @@ func TestIntegrationIntegratedDashboardService(t *testing.T) {
 
 				permissionScenario(t, "When creating a folder with same name as existing folder", canSave,
 					func(t *testing.T, sc *permissionScenarioContext) {
-						cmd := models.SaveDashboardCommand{
-							OrgId: testOrgID,
+						cmd := dashboards.SaveDashboardCommand{
+							OrgID: testOrgID,
 							Dashboard: simplejson.NewFromAny(map[string]interface{}{
 								"id":    nil,
 								"title": sc.savedFolder.Title,
@@ -570,54 +570,54 @@ func TestIntegrationIntegratedDashboardService(t *testing.T) {
 
 				permissionScenario(t, "When updating an existing dashboard by id without current version", canSave,
 					func(t *testing.T, sc *permissionScenarioContext) {
-						cmd := models.SaveDashboardCommand{
-							OrgId: 1,
+						cmd := dashboards.SaveDashboardCommand{
+							OrgID: 1,
 							Dashboard: simplejson.NewFromAny(map[string]interface{}{
-								"id":    sc.savedDashInGeneralFolder.Id,
+								"id":    sc.savedDashInGeneralFolder.ID,
 								"title": "Updated title",
 							}),
-							FolderId:  sc.savedFolder.Id,
+							FolderID:  sc.savedFolder.ID,
 							Overwrite: shouldOverwrite,
 						}
 
 						res := callSaveWithResult(t, cmd, sc.sqlStore)
 						require.NotNil(t, res)
 
-						_, err := sc.dashboardStore.GetDashboard(context.Background(), &models.GetDashboardQuery{
-							Id:    sc.savedDashInGeneralFolder.Id,
-							OrgId: cmd.OrgId,
+						_, err := sc.dashboardStore.GetDashboard(context.Background(), &dashboards.GetDashboardQuery{
+							ID:    sc.savedDashInGeneralFolder.ID,
+							OrgID: cmd.OrgID,
 						})
 						require.NoError(t, err)
 					})
 
 				permissionScenario(t, "When updating an existing dashboard by uid without current version", canSave,
 					func(t *testing.T, sc *permissionScenarioContext) {
-						cmd := models.SaveDashboardCommand{
-							OrgId: 1,
+						cmd := dashboards.SaveDashboardCommand{
+							OrgID: 1,
 							Dashboard: simplejson.NewFromAny(map[string]interface{}{
-								"uid":   sc.savedDashInFolder.Uid,
+								"uid":   sc.savedDashInFolder.UID,
 								"title": "Updated title",
 							}),
-							FolderId:  0,
+							FolderID:  0,
 							Overwrite: shouldOverwrite,
 						}
 
 						res := callSaveWithResult(t, cmd, sc.sqlStore)
 						require.NotNil(t, res)
 
-						_, err := sc.dashboardStore.GetDashboard(context.Background(), &models.GetDashboardQuery{
-							Id:    sc.savedDashInFolder.Id,
-							OrgId: cmd.OrgId,
+						_, err := sc.dashboardStore.GetDashboard(context.Background(), &dashboards.GetDashboardQuery{
+							ID:    sc.savedDashInFolder.ID,
+							OrgID: cmd.OrgID,
 						})
 						require.NoError(t, err)
 					})
 
 				permissionScenario(t, "When updating uid for existing dashboard using id", canSave,
 					func(t *testing.T, sc *permissionScenarioContext) {
-						cmd := models.SaveDashboardCommand{
-							OrgId: 1,
+						cmd := dashboards.SaveDashboardCommand{
+							OrgID: 1,
 							Dashboard: simplejson.NewFromAny(map[string]interface{}{
-								"id":    sc.savedDashInFolder.Id,
+								"id":    sc.savedDashInFolder.ID,
 								"uid":   "new-uid",
 								"title": sc.savedDashInFolder.Title,
 							}),
@@ -626,23 +626,23 @@ func TestIntegrationIntegratedDashboardService(t *testing.T) {
 
 						res := callSaveWithResult(t, cmd, sc.sqlStore)
 						require.NotNil(t, res)
-						assert.Equal(t, sc.savedDashInFolder.Id, res.Id)
-						assert.Equal(t, "new-uid", res.Uid)
+						assert.Equal(t, sc.savedDashInFolder.ID, res.ID)
+						assert.Equal(t, "new-uid", res.UID)
 
-						_, err := sc.dashboardStore.GetDashboard(context.Background(), &models.GetDashboardQuery{
-							Id:    sc.savedDashInFolder.Id,
-							OrgId: cmd.OrgId,
+						_, err := sc.dashboardStore.GetDashboard(context.Background(), &dashboards.GetDashboardQuery{
+							ID:    sc.savedDashInFolder.ID,
+							OrgID: cmd.OrgID,
 						})
 						require.NoError(t, err)
 					})
 
 				permissionScenario(t, "When updating uid to an existing uid for existing dashboard using id", canSave,
 					func(t *testing.T, sc *permissionScenarioContext) {
-						cmd := models.SaveDashboardCommand{
-							OrgId: 1,
+						cmd := dashboards.SaveDashboardCommand{
+							OrgID: 1,
 							Dashboard: simplejson.NewFromAny(map[string]interface{}{
-								"id":    sc.savedDashInFolder.Id,
-								"uid":   sc.savedDashInGeneralFolder.Uid,
+								"id":    sc.savedDashInFolder.ID,
+								"uid":   sc.savedDashInGeneralFolder.UID,
 								"title": sc.savedDashInFolder.Title,
 							}),
 							Overwrite: shouldOverwrite,
@@ -654,58 +654,58 @@ func TestIntegrationIntegratedDashboardService(t *testing.T) {
 
 				permissionScenario(t, "When creating a dashboard with same name as dashboard in other folder", canSave,
 					func(t *testing.T, sc *permissionScenarioContext) {
-						cmd := models.SaveDashboardCommand{
-							OrgId: testOrgID,
+						cmd := dashboards.SaveDashboardCommand{
+							OrgID: testOrgID,
 							Dashboard: simplejson.NewFromAny(map[string]interface{}{
 								"id":    nil,
 								"title": sc.savedDashInFolder.Title,
 							}),
-							FolderId:  sc.savedDashInFolder.FolderId,
+							FolderID:  sc.savedDashInFolder.FolderID,
 							Overwrite: shouldOverwrite,
 						}
 
 						res := callSaveWithResult(t, cmd, sc.sqlStore)
 						require.NotNil(t, res)
-						assert.Equal(t, sc.savedDashInFolder.Id, res.Id)
-						assert.Equal(t, sc.savedDashInFolder.Uid, res.Uid)
+						assert.Equal(t, sc.savedDashInFolder.ID, res.ID)
+						assert.Equal(t, sc.savedDashInFolder.UID, res.UID)
 
-						_, err := sc.dashboardStore.GetDashboard(context.Background(), &models.GetDashboardQuery{
-							Id:    res.Id,
-							OrgId: cmd.OrgId,
+						_, err := sc.dashboardStore.GetDashboard(context.Background(), &dashboards.GetDashboardQuery{
+							ID:    res.ID,
+							OrgID: cmd.OrgID,
 						})
 						require.NoError(t, err)
 					})
 
 				permissionScenario(t, "When creating a dashboard with same name as dashboard in General folder", canSave,
 					func(t *testing.T, sc *permissionScenarioContext) {
-						cmd := models.SaveDashboardCommand{
-							OrgId: testOrgID,
+						cmd := dashboards.SaveDashboardCommand{
+							OrgID: testOrgID,
 							Dashboard: simplejson.NewFromAny(map[string]interface{}{
 								"id":    nil,
 								"title": sc.savedDashInGeneralFolder.Title,
 							}),
-							FolderId:  sc.savedDashInGeneralFolder.FolderId,
+							FolderID:  sc.savedDashInGeneralFolder.FolderID,
 							Overwrite: shouldOverwrite,
 						}
 
 						res := callSaveWithResult(t, cmd, sc.sqlStore)
 						require.NotNil(t, res)
-						assert.Equal(t, sc.savedDashInGeneralFolder.Id, res.Id)
-						assert.Equal(t, sc.savedDashInGeneralFolder.Uid, res.Uid)
+						assert.Equal(t, sc.savedDashInGeneralFolder.ID, res.ID)
+						assert.Equal(t, sc.savedDashInGeneralFolder.UID, res.UID)
 
-						_, err := sc.dashboardStore.GetDashboard(context.Background(), &models.GetDashboardQuery{
-							Id:    res.Id,
-							OrgId: cmd.OrgId,
+						_, err := sc.dashboardStore.GetDashboard(context.Background(), &dashboards.GetDashboardQuery{
+							ID:    res.ID,
+							OrgID: cmd.OrgID,
 						})
 						require.NoError(t, err)
 					})
 
 				permissionScenario(t, "When updating existing folder to a dashboard using id", canSave,
 					func(t *testing.T, sc *permissionScenarioContext) {
-						cmd := models.SaveDashboardCommand{
-							OrgId: 1,
+						cmd := dashboards.SaveDashboardCommand{
+							OrgID: 1,
 							Dashboard: simplejson.NewFromAny(map[string]interface{}{
-								"id":    sc.savedFolder.Id,
+								"id":    sc.savedFolder.ID,
 								"title": "new title",
 							}),
 							IsFolder:  false,
@@ -718,10 +718,10 @@ func TestIntegrationIntegratedDashboardService(t *testing.T) {
 
 				permissionScenario(t, "When updating existing dashboard to a folder using id", canSave,
 					func(t *testing.T, sc *permissionScenarioContext) {
-						cmd := models.SaveDashboardCommand{
-							OrgId: 1,
+						cmd := dashboards.SaveDashboardCommand{
+							OrgID: 1,
 							Dashboard: simplejson.NewFromAny(map[string]interface{}{
-								"id":    sc.savedDashInFolder.Id,
+								"id":    sc.savedDashInFolder.ID,
 								"title": "new folder title",
 							}),
 							IsFolder:  true,
@@ -734,10 +734,10 @@ func TestIntegrationIntegratedDashboardService(t *testing.T) {
 
 				permissionScenario(t, "When updating existing folder to a dashboard using uid", canSave,
 					func(t *testing.T, sc *permissionScenarioContext) {
-						cmd := models.SaveDashboardCommand{
-							OrgId: 1,
+						cmd := dashboards.SaveDashboardCommand{
+							OrgID: 1,
 							Dashboard: simplejson.NewFromAny(map[string]interface{}{
-								"uid":   sc.savedFolder.Uid,
+								"uid":   sc.savedFolder.UID,
 								"title": "new title",
 							}),
 							IsFolder:  false,
@@ -750,10 +750,10 @@ func TestIntegrationIntegratedDashboardService(t *testing.T) {
 
 				permissionScenario(t, "When updating existing dashboard to a folder using uid", canSave,
 					func(t *testing.T, sc *permissionScenarioContext) {
-						cmd := models.SaveDashboardCommand{
-							OrgId: 1,
+						cmd := dashboards.SaveDashboardCommand{
+							OrgID: 1,
 							Dashboard: simplejson.NewFromAny(map[string]interface{}{
-								"uid":   sc.savedDashInFolder.Uid,
+								"uid":   sc.savedDashInFolder.UID,
 								"title": "new folder title",
 							}),
 							IsFolder:  true,
@@ -766,8 +766,8 @@ func TestIntegrationIntegratedDashboardService(t *testing.T) {
 
 				permissionScenario(t, "When updating existing folder to a dashboard using title", canSave,
 					func(t *testing.T, sc *permissionScenarioContext) {
-						cmd := models.SaveDashboardCommand{
-							OrgId: 1,
+						cmd := dashboards.SaveDashboardCommand{
+							OrgID: 1,
 							Dashboard: simplejson.NewFromAny(map[string]interface{}{
 								"title": sc.savedFolder.Title,
 							}),
@@ -781,8 +781,8 @@ func TestIntegrationIntegratedDashboardService(t *testing.T) {
 
 				permissionScenario(t, "When updating existing dashboard to a folder using title", canSave,
 					func(t *testing.T, sc *permissionScenarioContext) {
-						cmd := models.SaveDashboardCommand{
-							OrgId: 1,
+						cmd := dashboards.SaveDashboardCommand{
+							OrgID: 1,
 							Dashboard: simplejson.NewFromAny(map[string]interface{}{
 								"title": sc.savedDashInGeneralFolder.Title,
 							}),
@@ -802,10 +802,10 @@ type permissionScenarioContext struct {
 	dashboardGuardianMock    *guardian.FakeDashboardGuardian
 	sqlStore                 db.DB
 	dashboardStore           dashboards.Store
-	savedFolder              *models.Dashboard
-	savedDashInFolder        *models.Dashboard
-	otherSavedFolder         *models.Dashboard
-	savedDashInGeneralFolder *models.Dashboard
+	savedFolder              *dashboards.Dashboard
+	savedDashInFolder        *dashboards.Dashboard
+	otherSavedFolder         *dashboards.Dashboard
+	savedDashInGeneralFolder *dashboards.Dashboard
 }
 
 type permissionScenarioFunc func(t *testing.T, sc *permissionScenarioContext)
@@ -835,24 +835,24 @@ func permissionScenario(t *testing.T, desc string, canSave bool, fn permissionSc
 		guardian.InitLegacyGuardian(sqlStore, service, &teamtest.FakeService{})
 
 		savedFolder := saveTestFolder(t, "Saved folder", testOrgID, sqlStore)
-		savedDashInFolder := saveTestDashboard(t, "Saved dash in folder", testOrgID, savedFolder.Id, sqlStore)
-		saveTestDashboard(t, "Other saved dash in folder", testOrgID, savedFolder.Id, sqlStore)
+		savedDashInFolder := saveTestDashboard(t, "Saved dash in folder", testOrgID, savedFolder.ID, sqlStore)
+		saveTestDashboard(t, "Other saved dash in folder", testOrgID, savedFolder.ID, sqlStore)
 		savedDashInGeneralFolder := saveTestDashboard(t, "Saved dashboard in general folder", testOrgID, 0, sqlStore)
 		otherSavedFolder := saveTestFolder(t, "Other saved folder", testOrgID, sqlStore)
 
 		require.Equal(t, "Saved folder", savedFolder.Title)
 		require.Equal(t, "saved-folder", savedFolder.Slug)
-		require.NotEqual(t, int64(0), savedFolder.Id)
+		require.NotEqual(t, int64(0), savedFolder.ID)
 		require.True(t, savedFolder.IsFolder)
-		require.Equal(t, int64(0), savedFolder.FolderId)
-		require.NotEmpty(t, savedFolder.Uid)
+		require.Equal(t, int64(0), savedFolder.FolderID)
+		require.NotEmpty(t, savedFolder.UID)
 
 		require.Equal(t, "Saved dash in folder", savedDashInFolder.Title)
 		require.Equal(t, "saved-dash-in-folder", savedDashInFolder.Slug)
-		require.NotEqual(t, int64(0), savedDashInFolder.Id)
+		require.NotEqual(t, int64(0), savedDashInFolder.ID)
 		require.False(t, savedDashInFolder.IsFolder)
-		require.Equal(t, savedFolder.Id, savedDashInFolder.FolderId)
-		require.NotEmpty(t, savedDashInFolder.Uid)
+		require.Equal(t, savedFolder.ID, savedDashInFolder.FolderID)
+		require.NotEmpty(t, savedDashInFolder.UID)
 
 		origNewDashboardGuardian := guardian.New
 		t.Cleanup(func() {
@@ -874,7 +874,7 @@ func permissionScenario(t *testing.T, desc string, canSave bool, fn permissionSc
 	})
 }
 
-func callSaveWithResult(t *testing.T, cmd models.SaveDashboardCommand, sqlStore db.DB) *models.Dashboard {
+func callSaveWithResult(t *testing.T, cmd dashboards.SaveDashboardCommand, sqlStore db.DB) *dashboards.Dashboard {
 	t.Helper()
 
 	dto := toSaveDashboardDto(cmd)
@@ -897,7 +897,7 @@ func callSaveWithResult(t *testing.T, cmd models.SaveDashboardCommand, sqlStore
 	return res
 }
 
-func callSaveWithError(t *testing.T, cmd models.SaveDashboardCommand, sqlStore db.DB) error {
+func callSaveWithError(t *testing.T, cmd dashboards.SaveDashboardCommand, sqlStore db.DB) error {
 	dto := toSaveDashboardDto(cmd)
 	cfg := setting.NewCfg()
 	cfg.RBACEnabled = false
@@ -916,12 +916,12 @@ func callSaveWithError(t *testing.T, cmd models.SaveDashboardCommand, sqlStore d
 	return err
 }
 
-func saveTestDashboard(t *testing.T, title string, orgID, folderID int64, sqlStore db.DB) *models.Dashboard {
+func saveTestDashboard(t *testing.T, title string, orgID, folderID int64, sqlStore db.DB) *dashboards.Dashboard {
 	t.Helper()
 
-	cmd := models.SaveDashboardCommand{
-		OrgId:    orgID,
-		FolderId: folderID,
+	cmd := dashboards.SaveDashboardCommand{
+		OrgID:    orgID,
+		FolderID: folderID,
 		IsFolder: false,
 		Dashboard: simplejson.NewFromAny(map[string]interface{}{
 			"id":    nil,
@@ -930,7 +930,7 @@ func saveTestDashboard(t *testing.T, title string, orgID, folderID int64, sqlSto
 	}
 
 	dto := dashboards.SaveDashboardDTO{
-		OrgId:     orgID,
+		OrgID:     orgID,
 		Dashboard: cmd.GetDashboardModel(),
 		User: &user.SignedInUser{
 			UserID:  1,
@@ -957,11 +957,11 @@ func saveTestDashboard(t *testing.T, title string, orgID, folderID int64, sqlSto
 	return res
 }
 
-func saveTestFolder(t *testing.T, title string, orgID int64, sqlStore db.DB) *models.Dashboard {
+func saveTestFolder(t *testing.T, title string, orgID int64, sqlStore db.DB) *dashboards.Dashboard {
 	t.Helper()
-	cmd := models.SaveDashboardCommand{
-		OrgId:    orgID,
-		FolderId: 0,
+	cmd := dashboards.SaveDashboardCommand{
+		OrgID:    orgID,
+		FolderID: 0,
 		IsFolder: true,
 		Dashboard: simplejson.NewFromAny(map[string]interface{}{
 			"id":    nil,
@@ -970,7 +970,7 @@ func saveTestFolder(t *testing.T, title string, orgID int64, sqlStore db.DB) *mo
 	}
 
 	dto := dashboards.SaveDashboardDTO{
-		OrgId:     orgID,
+		OrgID:     orgID,
 		Dashboard: cmd.GetDashboardModel(),
 		User: &user.SignedInUser{
 			UserID:  1,
@@ -997,14 +997,14 @@ func saveTestFolder(t *testing.T, title string, orgID int64, sqlStore db.DB) *mo
 	return res
 }
 
-func toSaveDashboardDto(cmd models.SaveDashboardCommand) dashboards.SaveDashboardDTO {
+func toSaveDashboardDto(cmd dashboards.SaveDashboardCommand) dashboards.SaveDashboardDTO {
 	dash := (&cmd).GetDashboardModel()
 
 	return dashboards.SaveDashboardDTO{
 		Dashboard: dash,
 		Message:   cmd.Message,
-		OrgId:     cmd.OrgId,
-		User:      &user.SignedInUser{UserID: cmd.UserId},
+		OrgID:     cmd.OrgID,
+		User:      &user.SignedInUser{UserID: cmd.UserID},
 		Overwrite: cmd.Overwrite,
 	}
 }

pkg/services/dashboards/service/dashboard_service_test.go

@@ -43,21 +43,21 @@ func TestDashboardService(t *testing.T) {
 				titles := []string{"", " ", "   \t   "}
 
 				for _, title := range titles {
-					dto.Dashboard = models.NewDashboard(title)
+					dto.Dashboard = dashboards.NewDashboard(title)
 					_, err := service.SaveDashboard(context.Background(), dto, false)
 					require.Equal(t, err, dashboards.ErrDashboardTitleEmpty)
 				}
 			})
 
 			t.Run("Should return validation error if it's a folder and have a folder id", func(t *testing.T) {
-				dto.Dashboard = models.NewDashboardFolder("Folder")
-				dto.Dashboard.FolderId = 1
+				dto.Dashboard = dashboards.NewDashboardFolder("Folder")
+				dto.Dashboard.FolderID = 1
 				_, err := service.SaveDashboard(context.Background(), dto, false)
 				require.Equal(t, err, dashboards.ErrDashboardFolderCannotHaveParent)
 			})
 
 			t.Run("Should return validation error if folder is named General", func(t *testing.T) {
-				dto.Dashboard = models.NewDashboardFolder("General")
+				dto.Dashboard = dashboards.NewDashboardFolder("General")
 				_, err := service.SaveDashboard(context.Background(), dto, false)
 				require.Equal(t, err, dashboards.ErrDashboardFolderNameExists)
 			})
@@ -77,8 +77,8 @@ func TestDashboardService(t *testing.T) {
 				}
 
 				for _, tc := range testCases {
-					dto.Dashboard = models.NewDashboard("title")
-					dto.Dashboard.SetUid(tc.Uid)
+					dto.Dashboard = dashboards.NewDashboard("title")
+					dto.Dashboard.SetUID(tc.Uid)
 					dto.User = &user.SignedInUser{}
 
 					if tc.Error == nil {
@@ -93,8 +93,8 @@ func TestDashboardService(t *testing.T) {
 				fakeStore.On("ValidateDashboardBeforeSave", mock.Anything, mock.Anything, mock.AnythingOfType("bool")).Return(true, nil).Once()
 				fakeStore.On("GetProvisionedDataByDashboardID", mock.Anything, mock.AnythingOfType("int64")).Return(&models.DashboardProvisioning{}, nil).Once()
 
-				dto.Dashboard = models.NewDashboard("Dash")
-				dto.Dashboard.SetId(3)
+				dto.Dashboard = dashboards.NewDashboard("Dash")
+				dto.Dashboard.SetID(3)
 				dto.User = &user.SignedInUser{UserID: 1}
 				_, err := service.SaveDashboard(context.Background(), dto, false)
 				require.Equal(t, err, dashboards.ErrDashboardCannotSaveProvisionedDashboard)
@@ -102,10 +102,10 @@ func TestDashboardService(t *testing.T) {
 
 			t.Run("Should not return validation error if dashboard is provisioned but UI updates allowed", func(t *testing.T) {
 				fakeStore.On("ValidateDashboardBeforeSave", mock.Anything, mock.Anything, mock.AnythingOfType("bool")).Return(true, nil).Once()
-				fakeStore.On("SaveDashboard", mock.Anything, mock.AnythingOfType("models.SaveDashboardCommand")).Return(&models.Dashboard{Data: simplejson.New()}, nil).Once()
+				fakeStore.On("SaveDashboard", mock.Anything, mock.AnythingOfType("dashboards.SaveDashboardCommand")).Return(&dashboards.Dashboard{Data: simplejson.New()}, nil).Once()
 
-				dto.Dashboard = models.NewDashboard("Dash")
-				dto.Dashboard.SetId(3)
+				dto.Dashboard = dashboards.NewDashboard("Dash")
+				dto.Dashboard.SetID(3)
 				dto.User = &user.SignedInUser{UserID: 1}
 				_, err := service.SaveDashboard(context.Background(), dto, true)
 				require.NoError(t, err)
@@ -128,10 +128,10 @@ func TestDashboardService(t *testing.T) {
 
 				fakeStore.On("ValidateDashboardBeforeSave", mock.Anything, mock.Anything, mock.AnythingOfType("bool")).Return(true, nil).Once()
 				fakeStore.On("GetProvisionedDataByDashboardID", mock.Anything, mock.AnythingOfType("int64")).Return(nil, nil).Once()
-				fakeStore.On("SaveDashboard", mock.Anything, mock.AnythingOfType("models.SaveDashboardCommand")).Return(&models.Dashboard{Data: simplejson.New()}, nil).Once()
+				fakeStore.On("SaveDashboard", mock.Anything, mock.AnythingOfType("dashboards.SaveDashboardCommand")).Return(&dashboards.Dashboard{Data: simplejson.New()}, nil).Once()
 				fakeStore.On("SaveAlerts", mock.Anything, mock.Anything, mock.Anything).Return(errors.New("alert validation error")).Once()
 
-				dto.Dashboard = models.NewDashboard("Dash")
+				dto.Dashboard = dashboards.NewDashboard("Dash")
 				dto.User = &user.SignedInUser{UserID: 1}
 				_, err := service.SaveDashboard(context.Background(), dto, false)
 				require.Error(t, err)
@@ -144,10 +144,10 @@ func TestDashboardService(t *testing.T) {
 
 			t.Run("Should not return validation error if dashboard is provisioned", func(t *testing.T) {
 				fakeStore.On("ValidateDashboardBeforeSave", mock.Anything, mock.Anything, mock.AnythingOfType("bool")).Return(true, nil).Once()
-				fakeStore.On("SaveProvisionedDashboard", mock.Anything, mock.AnythingOfType("models.SaveDashboardCommand"), mock.AnythingOfType("*models.DashboardProvisioning")).Return(&models.Dashboard{Data: simplejson.New()}, nil).Once()
+				fakeStore.On("SaveProvisionedDashboard", mock.Anything, mock.AnythingOfType("dashboards.SaveDashboardCommand"), mock.AnythingOfType("*dashboards.DashboardProvisioning")).Return(&dashboards.Dashboard{Data: simplejson.New()}, nil).Once()
 
-				dto.Dashboard = models.NewDashboard("Dash")
-				dto.Dashboard.SetId(3)
+				dto.Dashboard = dashboards.NewDashboard("Dash")
+				dto.Dashboard.SetID(3)
 				dto.User = &user.SignedInUser{UserID: 1}
 				_, err := service.SaveProvisionedDashboard(context.Background(), dto, nil)
 				require.NoError(t, err)
@@ -155,14 +155,14 @@ func TestDashboardService(t *testing.T) {
 
 			t.Run("Should override invalid refresh interval if dashboard is provisioned", func(t *testing.T) {
 				fakeStore.On("ValidateDashboardBeforeSave", mock.Anything, mock.Anything, mock.AnythingOfType("bool")).Return(true, nil).Once()
-				fakeStore.On("SaveProvisionedDashboard", mock.Anything, mock.AnythingOfType("models.SaveDashboardCommand"), mock.AnythingOfType("*models.DashboardProvisioning")).Return(&models.Dashboard{Data: simplejson.New()}, nil).Once()
+				fakeStore.On("SaveProvisionedDashboard", mock.Anything, mock.AnythingOfType("dashboards.SaveDashboardCommand"), mock.AnythingOfType("*dashboards.DashboardProvisioning")).Return(&dashboards.Dashboard{Data: simplejson.New()}, nil).Once()
 
 				oldRefreshInterval := setting.MinRefreshInterval
 				setting.MinRefreshInterval = "5m"
 				defer func() { setting.MinRefreshInterval = oldRefreshInterval }()
 
-				dto.Dashboard = models.NewDashboard("Dash")
-				dto.Dashboard.SetId(3)
+				dto.Dashboard = dashboards.NewDashboard("Dash")
+				dto.Dashboard.SetID(3)
 				dto.User = &user.SignedInUser{UserID: 1}
 				dto.Dashboard.Data.Set("refresh", "1s")
 				_, err := service.SaveProvisionedDashboard(context.Background(), dto, nil)
@@ -178,8 +178,8 @@ func TestDashboardService(t *testing.T) {
 				fakeStore.On("ValidateDashboardBeforeSave", mock.Anything, mock.Anything, mock.AnythingOfType("bool")).Return(true, nil).Once()
 				fakeStore.On("GetProvisionedDataByDashboardID", mock.Anything, mock.AnythingOfType("int64")).Return(&models.DashboardProvisioning{}, nil).Once()
 
-				dto.Dashboard = models.NewDashboard("Dash")
-				dto.Dashboard.SetId(3)
+				dto.Dashboard = dashboards.NewDashboard("Dash")
+				dto.Dashboard.SetID(3)
 				dto.User = &user.SignedInUser{UserID: 1}
 				_, err := service.ImportDashboard(context.Background(), dto)
 				require.Equal(t, err, dashboards.ErrDashboardCannotSaveProvisionedDashboard)

pkg/services/dashboards/store_mock.go

@@ -1,14 +1,16 @@
-// Code generated by mockery v2.14.0. DO NOT EDIT.
+// Code generated by mockery v2.16.0. DO NOT EDIT.
 
 package dashboards
 
 import (
 	context "context"
 
-	models "github.com/grafana/grafana/pkg/models"
 	folder "github.com/grafana/grafana/pkg/services/folder"
-	"github.com/grafana/grafana/pkg/services/quota"
 	mock "github.com/stretchr/testify/mock"
+
+	models "github.com/grafana/grafana/pkg/models"
+
+	quota "github.com/grafana/grafana/pkg/services/quota"
 )
 
 // FakeDashboardStore is an autogenerated mock type for the Store type
@@ -16,6 +18,29 @@ type FakeDashboardStore struct {
 	mock.Mock
 }
 
+// Count provides a mock function with given fields: _a0, _a1
+func (_m *FakeDashboardStore) Count(_a0 context.Context, _a1 *quota.ScopeParameters) (*quota.Map, error) {
+	ret := _m.Called(_a0, _a1)
+
+	var r0 *quota.Map
+	if rf, ok := ret.Get(0).(func(context.Context, *quota.ScopeParameters) *quota.Map); ok {
+		r0 = rf(_a0, _a1)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*quota.Map)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(context.Context, *quota.ScopeParameters) error); ok {
+		r1 = rf(_a0, _a1)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
 // CountDashboardsInFolder provides a mock function with given fields: ctx, request
 func (_m *FakeDashboardStore) CountDashboardsInFolder(ctx context.Context, request *CountDashboardsInFolderRequest) (int64, error) {
 	ret := _m.Called(ctx, request)
@@ -103,20 +128,20 @@ func (_m *FakeDashboardStore) FindDashboards(ctx context.Context, query *models.
 }
 
 // GetDashboard provides a mock function with given fields: ctx, query
-func (_m *FakeDashboardStore) GetDashboard(ctx context.Context, query *models.GetDashboardQuery) (*models.Dashboard, error) {
+func (_m *FakeDashboardStore) GetDashboard(ctx context.Context, query *GetDashboardQuery) (*Dashboard, error) {
 	ret := _m.Called(ctx, query)
 
-	var r0 *models.Dashboard
-	if rf, ok := ret.Get(0).(func(context.Context, *models.GetDashboardQuery) *models.Dashboard); ok {
+	var r0 *Dashboard
+	if rf, ok := ret.Get(0).(func(context.Context, *GetDashboardQuery) *Dashboard); ok {
 		r0 = rf(ctx, query)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*models.Dashboard)
+			r0 = ret.Get(0).(*Dashboard)
 		}
 	}
 
 	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *models.GetDashboardQuery) error); ok {
+	if rf, ok := ret.Get(1).(func(context.Context, *GetDashboardQuery) error); ok {
 		r1 = rf(ctx, query)
 	} else {
 		r1 = ret.Error(1)
@@ -153,12 +178,12 @@ func (_m *FakeDashboardStore) GetDashboardTags(ctx context.Context, query *model
 	return r0
 }
 
-// GetDashboardUIDById provides a mock function with given fields: ctx, query
-func (_m *FakeDashboardStore) GetDashboardUIDById(ctx context.Context, query *models.GetDashboardRefByIdQuery) error {
+// GetDashboardUIDByID provides a mock function with given fields: ctx, query
+func (_m *FakeDashboardStore) GetDashboardUIDByID(ctx context.Context, query *GetDashboardRefByIDQuery) error {
 	ret := _m.Called(ctx, query)
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *models.GetDashboardRefByIdQuery) error); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *GetDashboardRefByIDQuery) error); ok {
 		r0 = rf(ctx, query)
 	} else {
 		r0 = ret.Error(0)
@@ -168,11 +193,11 @@ func (_m *FakeDashboardStore) GetDashboardUIDById(ctx context.Context, query *mo
 }
 
 // GetDashboards provides a mock function with given fields: ctx, query
-func (_m *FakeDashboardStore) GetDashboards(ctx context.Context, query *models.GetDashboardsQuery) error {
+func (_m *FakeDashboardStore) GetDashboards(ctx context.Context, query *GetDashboardsQuery) error {
 	ret := _m.Called(ctx, query)
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *models.GetDashboardsQuery) error); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *GetDashboardsQuery) error); ok {
 		r0 = rf(ctx, query)
 	} else {
 		r0 = ret.Error(0)
@@ -376,20 +401,20 @@ func (_m *FakeDashboardStore) SaveAlerts(ctx context.Context, dashID int64, aler
 }
 
 // SaveDashboard provides a mock function with given fields: ctx, cmd
-func (_m *FakeDashboardStore) SaveDashboard(ctx context.Context, cmd models.SaveDashboardCommand) (*models.Dashboard, error) {
+func (_m *FakeDashboardStore) SaveDashboard(ctx context.Context, cmd SaveDashboardCommand) (*Dashboard, error) {
 	ret := _m.Called(ctx, cmd)
 
-	var r0 *models.Dashboard
-	if rf, ok := ret.Get(0).(func(context.Context, models.SaveDashboardCommand) *models.Dashboard); ok {
+	var r0 *Dashboard
+	if rf, ok := ret.Get(0).(func(context.Context, SaveDashboardCommand) *Dashboard); ok {
 		r0 = rf(ctx, cmd)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*models.Dashboard)
+			r0 = ret.Get(0).(*Dashboard)
 		}
 	}
 
 	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, models.SaveDashboardCommand) error); ok {
+	if rf, ok := ret.Get(1).(func(context.Context, SaveDashboardCommand) error); ok {
 		r1 = rf(ctx, cmd)
 	} else {
 		r1 = ret.Error(1)
@@ -399,20 +424,20 @@ func (_m *FakeDashboardStore) SaveDashboard(ctx context.Context, cmd models.Save
 }
 
 // SaveProvisionedDashboard provides a mock function with given fields: ctx, cmd, provisioning
-func (_m *FakeDashboardStore) SaveProvisionedDashboard(ctx context.Context, cmd models.SaveDashboardCommand, provisioning *models.DashboardProvisioning) (*models.Dashboard, error) {
+func (_m *FakeDashboardStore) SaveProvisionedDashboard(ctx context.Context, cmd SaveDashboardCommand, provisioning *DashboardProvisioning) (*Dashboard, error) {
 	ret := _m.Called(ctx, cmd, provisioning)
 
-	var r0 *models.Dashboard
-	if rf, ok := ret.Get(0).(func(context.Context, models.SaveDashboardCommand, *models.DashboardProvisioning) *models.Dashboard); ok {
+	var r0 *Dashboard
+	if rf, ok := ret.Get(0).(func(context.Context, SaveDashboardCommand, *DashboardProvisioning) *Dashboard); ok {
 		r0 = rf(ctx, cmd, provisioning)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*models.Dashboard)
+			r0 = ret.Get(0).(*Dashboard)
 		}
 	}
 
 	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, models.SaveDashboardCommand, *models.DashboardProvisioning) error); ok {
+	if rf, ok := ret.Get(1).(func(context.Context, SaveDashboardCommand, *DashboardProvisioning) error); ok {
 		r1 = rf(ctx, cmd, provisioning)
 	} else {
 		r1 = ret.Error(1)
@@ -450,18 +475,18 @@ func (_m *FakeDashboardStore) UpdateDashboardACL(ctx context.Context, uid int64,
 }
 
 // ValidateDashboardBeforeSave provides a mock function with given fields: ctx, dashboard, overwrite
-func (_m *FakeDashboardStore) ValidateDashboardBeforeSave(ctx context.Context, dashboard *models.Dashboard, overwrite bool) (bool, error) {
+func (_m *FakeDashboardStore) ValidateDashboardBeforeSave(ctx context.Context, dashboard *Dashboard, overwrite bool) (bool, error) {
 	ret := _m.Called(ctx, dashboard, overwrite)
 
 	var r0 bool
-	if rf, ok := ret.Get(0).(func(context.Context, *models.Dashboard, bool) bool); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *Dashboard, bool) bool); ok {
 		r0 = rf(ctx, dashboard, overwrite)
 	} else {
 		r0 = ret.Get(0).(bool)
 	}
 
 	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *models.Dashboard, bool) error); ok {
+	if rf, ok := ret.Get(1).(func(context.Context, *Dashboard, bool) error); ok {
 		r1 = rf(ctx, dashboard, overwrite)
 	} else {
 		r1 = ret.Error(1)
@@ -475,10 +500,6 @@ type mockConstructorTestingTNewFakeDashboardStore interface {
 	Cleanup(func())
 }
 
-func (_m *FakeDashboardStore) Count(context.Context, *quota.ScopeParameters) (*quota.Map, error) {
-	return nil, nil
-}
-
 // NewFakeDashboardStore creates a new instance of FakeDashboardStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
 func NewFakeDashboardStore(t mockConstructorTestingTNewFakeDashboardStore) *FakeDashboardStore {
 	mock := &FakeDashboardStore{}

pkg/services/folder/folderimpl/folder.go

@@ -293,15 +293,15 @@ func (s *Service) getFolderByTitle(ctx context.Context, user *user.SignedInUser,
 func (s *Service) Create(ctx context.Context, cmd *folder.CreateFolderCommand) (*folder.Folder, error) {
 	logger := s.log.FromContext(ctx)
 
-	dashFolder := models.NewDashboardFolder(cmd.Title)
-	dashFolder.OrgId = cmd.OrgID
+	dashFolder := dashboards.NewDashboardFolder(cmd.Title)
+	dashFolder.OrgID = cmd.OrgID
 
 	trimmedUID := strings.TrimSpace(cmd.UID)
 	if trimmedUID == accesscontrol.GeneralFolderUID {
 		return nil, dashboards.ErrFolderInvalidUID
 	}
 
-	dashFolder.SetUid(trimmedUID)
+	dashFolder.SetUID(trimmedUID)
 
 	if cmd.SignedInUser == nil {
 		return nil, folder.ErrBadRequest.Errorf("missing signed in user")
@@ -317,7 +317,7 @@ func (s *Service) Create(ctx context.Context, cmd *folder.CreateFolderCommand) (
 
 	dto := &dashboards.SaveDashboardDTO{
 		Dashboard: dashFolder,
-		OrgId:     cmd.OrgID,
+		OrgID:     cmd.OrgID,
 		User:      user,
 	}
 
@@ -332,7 +332,7 @@ func (s *Service) Create(ctx context.Context, cmd *folder.CreateFolderCommand) (
 	}
 
 	var createdFolder *folder.Folder
-	createdFolder, err = s.dashboardStore.GetFolderByID(ctx, cmd.OrgID, dash.Id)
+	createdFolder, err = s.dashboardStore.GetFolderByID(ctx, cmd.OrgID, dash.ID)
 	if err != nil {
 		return nil, err
 	}
@@ -366,7 +366,7 @@ func (s *Service) Create(ctx context.Context, cmd *folder.CreateFolderCommand) (
 			// TODO: Today, if a UID isn't specified, the dashboard store
 			// generates a new UID. The new folder store will need to do this as
 			// well, but for now we take the UID from the newly created folder.
-			UID:         dash.Uid,
+			UID:         dash.UID,
 			OrgID:       cmd.OrgID,
 			Title:       cmd.Title,
 			Description: cmd.Description,
@@ -384,11 +384,11 @@ func (s *Service) Create(ctx context.Context, cmd *folder.CreateFolderCommand) (
 			}); deleteErr != nil {
 				logger.Error("error deleting folder after failed save to nested folder store", "error", err)
 			}
-			return folder.FromDashboard(dash), err
+			return dashboards.FromDashboard(dash), err
 		}
 	}
 
-	f := folder.FromDashboard(dash)
+	f := dashboards.FromDashboard(dash)
 	if nestedFolder != nil && nestedFolder.ParentUID != "" {
 		f.ParentUID = nestedFolder.ParentUID
 	}
@@ -439,7 +439,7 @@ func (s *Service) Update(ctx context.Context, cmd *folder.UpdateFolderCommand) (
 func (s *Service) legacyUpdate(ctx context.Context, cmd *folder.UpdateFolderCommand) (*folder.Folder, error) {
 	logger := s.log.FromContext(ctx)
 
-	query := models.GetDashboardQuery{OrgId: cmd.OrgID, Uid: cmd.UID}
+	query := dashboards.GetDashboardQuery{OrgID: cmd.OrgID, UID: cmd.UID}
 	_, err := s.dashboardStore.GetDashboard(ctx, &query)
 	if err != nil {
 		return nil, toFolderError(err)
@@ -461,7 +461,7 @@ func (s *Service) legacyUpdate(ctx context.Context, cmd *folder.UpdateFolderComm
 
 	dto := &dashboards.SaveDashboardDTO{
 		Dashboard: dashFolder,
-		OrgId:     cmd.OrgID,
+		OrgID:     cmd.OrgID,
 		User:      cmd.SignedInUser,
 		Overwrite: cmd.Overwrite,
 	}
@@ -477,7 +477,7 @@ func (s *Service) legacyUpdate(ctx context.Context, cmd *folder.UpdateFolderComm
 	}
 
 	var foldr *folder.Folder
-	foldr, err = s.dashboardStore.GetFolderByID(ctx, cmd.OrgID, dash.Id)
+	foldr, err = s.dashboardStore.GetFolderByID(ctx, cmd.OrgID, dash.ID)
 	if err != nil {
 		return nil, err
 	}
@@ -486,8 +486,8 @@ func (s *Service) legacyUpdate(ctx context.Context, cmd *folder.UpdateFolderComm
 		if err := s.bus.Publish(ctx, &events.FolderTitleUpdated{
 			Timestamp: foldr.Updated,
 			Title:     foldr.Title,
-			ID:        dash.Id,
-			UID:       dash.Uid,
+			ID:        dash.ID,
+			UID:       dash.UID,
 			OrgID:     cmd.OrgID,
 		}); err != nil {
 			logger.Error("failed to publish FolderTitleUpdated event", "folder", foldr.Title, "user", user.UserID, "error", err)
@@ -497,8 +497,8 @@ func (s *Service) legacyUpdate(ctx context.Context, cmd *folder.UpdateFolderComm
 }
 
 // prepareForUpdate updates an existing dashboard model from command into model for folder update
-func prepareForUpdate(dashFolder *models.Dashboard, orgId int64, userId int64, cmd *folder.UpdateFolderCommand) {
-	dashFolder.OrgId = orgId
+func prepareForUpdate(dashFolder *dashboards.Dashboard, orgId int64, userId int64, cmd *folder.UpdateFolderCommand) {
+	dashFolder.OrgID = orgId
 
 	title := dashFolder.Title
 	if cmd.NewTitle != nil && *cmd.NewTitle != "" {
@@ -508,7 +508,7 @@ func prepareForUpdate(dashFolder *models.Dashboard, orgId int64, userId int64, c
 	dashFolder.Data.Set("title", dashFolder.Title)
 
 	if cmd.NewUID != nil && *cmd.NewUID != "" {
-		dashFolder.SetUid(*cmd.NewUID)
+		dashFolder.SetUID(*cmd.NewUID)
 	}
 
 	dashFolder.SetVersion(cmd.Version)

pkg/services/folder/folderimpl/folder_test.go

@@ -116,7 +116,7 @@ func TestIntegrationFolderService(t *testing.T) {
 			})
 
 			t.Run("When creating folder should return access denied error", func(t *testing.T) {
-				dashStore.On("ValidateDashboardBeforeSave", mock.Anything, mock.AnythingOfType("*models.Dashboard"), mock.AnythingOfType("bool")).Return(true, nil).Times(2)
+				dashStore.On("ValidateDashboardBeforeSave", mock.Anything, mock.AnythingOfType("*dashboards.Dashboard"), mock.AnythingOfType("bool")).Return(true, nil).Times(2)
 				_, err := service.Create(context.Background(), &folder.CreateFolderCommand{
 					OrgID:        orgID,
 					Title:        f.Title,
@@ -128,11 +128,11 @@ func TestIntegrationFolderService(t *testing.T) {
 
 			title := "Folder-TEST"
 			t.Run("When updating folder should return access denied error", func(t *testing.T) {
-				dashStore.On("GetDashboard", mock.Anything, mock.AnythingOfType("*models.GetDashboardQuery")).Run(func(args mock.Arguments) {
-					folder := args.Get(1).(*models.GetDashboardQuery)
-					folder.Result = models.NewDashboard("dashboard-test")
+				dashStore.On("GetDashboard", mock.Anything, mock.AnythingOfType("*dashboards.GetDashboardQuery")).Run(func(args mock.Arguments) {
+					folder := args.Get(1).(*dashboards.GetDashboardQuery)
+					folder.Result = dashboards.NewDashboard("dashboard-test")
 					folder.Result.IsFolder = true
-				}).Return(&models.Dashboard{}, nil)
+				}).Return(&dashboards.Dashboard{}, nil)
 				_, err := service.Update(context.Background(), &folder.UpdateFolderCommand{
 					UID:          folderUID,
 					OrgID:        orgID,
@@ -169,13 +169,13 @@ func TestIntegrationFolderService(t *testing.T) {
 			guardian.MockDashboardGuardian(&guardian.FakeDashboardGuardian{CanSaveValue: true})
 
 			t.Run("When creating folder should not return access denied error", func(t *testing.T) {
-				dash := models.NewDashboardFolder("Test-Folder")
-				dash.Id = rand.Int63()
-				f := folder.FromDashboard(dash)
+				dash := dashboards.NewDashboardFolder("Test-Folder")
+				dash.ID = rand.Int63()
+				f := dashboards.FromDashboard(dash)
 
-				dashStore.On("ValidateDashboardBeforeSave", mock.Anything, mock.AnythingOfType("*models.Dashboard"), mock.AnythingOfType("bool")).Return(true, nil)
-				dashStore.On("SaveDashboard", mock.Anything, mock.AnythingOfType("models.SaveDashboardCommand")).Return(dash, nil).Once()
-				dashStore.On("GetFolderByID", mock.Anything, orgID, dash.Id).Return(f, nil)
+				dashStore.On("ValidateDashboardBeforeSave", mock.Anything, mock.AnythingOfType("*dashboards.Dashboard"), mock.AnythingOfType("bool")).Return(true, nil)
+				dashStore.On("SaveDashboard", mock.Anything, mock.AnythingOfType("dashboards.SaveDashboardCommand")).Return(dash, nil).Once()
+				dashStore.On("GetFolderByID", mock.Anything, orgID, dash.ID).Return(f, nil)
 
 				actualFolder, err := service.Create(context.Background(), &folder.CreateFolderCommand{
 					OrgID:        orgID,
@@ -188,8 +188,8 @@ func TestIntegrationFolderService(t *testing.T) {
 			})
 
 			t.Run("When creating folder should return error if uid is general", func(t *testing.T) {
-				dash := models.NewDashboardFolder("Test-Folder")
-				dash.Id = rand.Int63()
+				dash := dashboards.NewDashboardFolder("Test-Folder")
+				dash.ID = rand.Int63()
 
 				_, err := service.Create(context.Background(), &folder.CreateFolderCommand{
 					OrgID:        orgID,
@@ -201,18 +201,18 @@ func TestIntegrationFolderService(t *testing.T) {
 			})
 
 			t.Run("When updating folder should not return access denied error", func(t *testing.T) {
-				dashboardFolder := models.NewDashboardFolder("Folder")
-				dashboardFolder.Id = rand.Int63()
-				dashboardFolder.Uid = util.GenerateShortUID()
-				f := folder.FromDashboard(dashboardFolder)
+				dashboardFolder := dashboards.NewDashboardFolder("Folder")
+				dashboardFolder.ID = rand.Int63()
+				dashboardFolder.UID = util.GenerateShortUID()
+				f := dashboards.FromDashboard(dashboardFolder)
 
-				dashStore.On("ValidateDashboardBeforeSave", mock.Anything, mock.AnythingOfType("*models.Dashboard"), mock.AnythingOfType("bool")).Return(true, nil)
-				dashStore.On("SaveDashboard", mock.Anything, mock.AnythingOfType("models.SaveDashboardCommand")).Return(dashboardFolder, nil)
-				dashStore.On("GetFolderByID", mock.Anything, orgID, dashboardFolder.Id).Return(f, nil)
+				dashStore.On("ValidateDashboardBeforeSave", mock.Anything, mock.AnythingOfType("*dashboards.Dashboard"), mock.AnythingOfType("bool")).Return(true, nil)
+				dashStore.On("SaveDashboard", mock.Anything, mock.AnythingOfType("dashboards.SaveDashboardCommand")).Return(dashboardFolder, nil)
+				dashStore.On("GetFolderByID", mock.Anything, orgID, dashboardFolder.ID).Return(f, nil)
 
 				title := "TEST-Folder"
 				req := &folder.UpdateFolderCommand{
-					UID:          dashboardFolder.Uid,
+					UID:          dashboardFolder.UID,
 					OrgID:        orgID,
 					NewTitle:     &title,
 					SignedInUser: usr,
@@ -324,9 +324,9 @@ func TestNestedFolderServiceFeatureToggle(t *testing.T) {
 	dashboardsvc := dashboards.FakeDashboardService{}
 	dashboardsvc.On("BuildSaveDashboardCommand",
 		mock.Anything, mock.AnythingOfType("*dashboards.SaveDashboardDTO"),
-		mock.AnythingOfType("bool"), mock.AnythingOfType("bool")).Return(&models.SaveDashboardCommand{}, nil)
+		mock.AnythingOfType("bool"), mock.AnythingOfType("bool")).Return(&dashboards.SaveDashboardCommand{}, nil)
 	dashStore := dashboards.FakeDashboardStore{}
-	dashStore.On("SaveDashboard", mock.Anything, mock.AnythingOfType("models.SaveDashboardCommand")).Return(&models.Dashboard{}, nil)
+	dashStore.On("SaveDashboard", mock.Anything, mock.AnythingOfType("dashboards.SaveDashboardCommand")).Return(&dashboards.Dashboard{}, nil)
 	dashStore.On("GetFolderByID", mock.Anything, mock.AnythingOfType("int64"), mock.AnythingOfType("int64")).Return(&folder.Folder{}, nil)
 	cfg := setting.NewCfg()
 	cfg.RBACEnabled = false
@@ -368,8 +368,8 @@ func TestNestedFolderService(t *testing.T) {
 			// dashboard store & service commands that should be called.
 			dashboardsvc.On("BuildSaveDashboardCommand",
 				mock.Anything, mock.AnythingOfType("*dashboards.SaveDashboardDTO"),
-				mock.AnythingOfType("bool"), mock.AnythingOfType("bool")).Return(&models.SaveDashboardCommand{}, nil)
-			dashStore.On("SaveDashboard", mock.Anything, mock.AnythingOfType("models.SaveDashboardCommand")).Return(&models.Dashboard{}, nil)
+				mock.AnythingOfType("bool"), mock.AnythingOfType("bool")).Return(&dashboards.SaveDashboardCommand{}, nil)
+			dashStore.On("SaveDashboard", mock.Anything, mock.AnythingOfType("dashboards.SaveDashboardCommand")).Return(&dashboards.Dashboard{}, nil)
 			dashStore.On("GetFolderByID", mock.Anything, mock.AnythingOfType("int64"), mock.AnythingOfType("int64")).Return(&folder.Folder{}, nil)
 
 			_, err := foldersvc.Create(context.Background(), &folder.CreateFolderCommand{
@@ -427,8 +427,8 @@ func TestNestedFolderService(t *testing.T) {
 			// dashboard store & service commands that should be called.
 			dashboardsvc.On("BuildSaveDashboardCommand",
 				mock.Anything, mock.AnythingOfType("*dashboards.SaveDashboardDTO"),
-				mock.AnythingOfType("bool"), mock.AnythingOfType("bool")).Return(&models.SaveDashboardCommand{}, nil)
-			dashStore.On("SaveDashboard", mock.Anything, mock.AnythingOfType("models.SaveDashboardCommand")).Return(&models.Dashboard{}, nil)
+				mock.AnythingOfType("bool"), mock.AnythingOfType("bool")).Return(&dashboards.SaveDashboardCommand{}, nil)
+			dashStore.On("SaveDashboard", mock.Anything, mock.AnythingOfType("dashboards.SaveDashboardCommand")).Return(&dashboards.Dashboard{}, nil)
 			dashStore.On("GetFolderByID", mock.Anything, mock.AnythingOfType("int64"), mock.AnythingOfType("int64")).Return(&folder.Folder{}, nil)
 			_, err := foldersvc.Create(context.Background(), &folder.CreateFolderCommand{
 				OrgID:        orgID,
@@ -447,8 +447,8 @@ func TestNestedFolderService(t *testing.T) {
 			foldersvc.dashboardStore = dashStore
 			dashboardsvc.On("BuildSaveDashboardCommand",
 				mock.Anything, mock.AnythingOfType("*dashboards.SaveDashboardDTO"),
-				mock.AnythingOfType("bool"), mock.AnythingOfType("bool")).Return(&models.SaveDashboardCommand{}, nil)
-			dashStore.On("SaveDashboard", mock.Anything, mock.AnythingOfType("models.SaveDashboardCommand")).Return(&models.Dashboard{Uid: "newUID"}, nil)
+				mock.AnythingOfType("bool"), mock.AnythingOfType("bool")).Return(&dashboards.SaveDashboardCommand{}, nil)
+			dashStore.On("SaveDashboard", mock.Anything, mock.AnythingOfType("dashboards.SaveDashboardCommand")).Return(&dashboards.Dashboard{UID: "newUID"}, nil)
 			dashStore.On("GetFolderByID", mock.Anything, mock.AnythingOfType("int64"), mock.AnythingOfType("int64")).Return(&folder.Folder{}, nil)
 			f, err := foldersvc.Create(context.Background(), &folder.CreateFolderCommand{
 				OrgID:        orgID,
@@ -463,16 +463,16 @@ func TestNestedFolderService(t *testing.T) {
 
 		t.Run("create failed because of circular reference", func(t *testing.T) {
 			// dashboard store & service commands that should be called.
-			dashboardFolder := models.NewDashboardFolder("myFolder")
-			dashboardFolder.Id = rand.Int63()
-			dashboardFolder.Uid = "myFolder"
-			f := folder.FromDashboard(dashboardFolder)
+			dashboardFolder := dashboards.NewDashboardFolder("myFolder")
+			dashboardFolder.ID = rand.Int63()
+			dashboardFolder.UID = "myFolder"
+			f := dashboards.FromDashboard(dashboardFolder)
 
 			dashStore = &dashboards.FakeDashboardStore{}
 			foldersvc.dashboardStore = dashStore
-			dashStore.On("ValidateDashboardBeforeSave", mock.Anything, mock.AnythingOfType("*models.Dashboard"), mock.AnythingOfType("bool")).Return(true, nil)
-			dashStore.On("SaveDashboard", mock.Anything, mock.AnythingOfType("models.SaveDashboardCommand")).Return(dashboardFolder, nil)
-			dashStore.On("GetFolderByID", mock.Anything, orgID, dashboardFolder.Id).Return(f, nil)
+			dashStore.On("ValidateDashboardBeforeSave", mock.Anything, mock.AnythingOfType("*dashboards.Dashboard"), mock.AnythingOfType("bool")).Return(true, nil)
+			dashStore.On("SaveDashboard", mock.Anything, mock.AnythingOfType("dashboards.SaveDashboardCommand")).Return(dashboardFolder, nil)
+			dashStore.On("GetFolderByID", mock.Anything, orgID, dashboardFolder.ID).Return(f, nil)
 			var actualCmd *models.DeleteDashboardCommand
 			dashStore.On("DeleteDashboard", mock.Anything, mock.Anything).Run(func(args mock.Arguments) {
 				actualCmd = args.Get(1).(*models.DeleteDashboardCommand)
@@ -509,8 +509,8 @@ func TestNestedFolderService(t *testing.T) {
 			// dashboard store & service commands that should be called.
 			dashboardsvc.On("BuildSaveDashboardCommand",
 				mock.Anything, mock.AnythingOfType("*dashboards.SaveDashboardDTO"),
-				mock.AnythingOfType("bool"), mock.AnythingOfType("bool")).Return(&models.SaveDashboardCommand{}, nil)
-			dashStore.On("SaveDashboard", mock.Anything, mock.AnythingOfType("models.SaveDashboardCommand")).Return(&models.Dashboard{}, nil)
+				mock.AnythingOfType("bool"), mock.AnythingOfType("bool")).Return(&dashboards.SaveDashboardCommand{}, nil)
+			dashStore.On("SaveDashboard", mock.Anything, mock.AnythingOfType("dashboards.SaveDashboardCommand")).Return(&dashboards.Dashboard{}, nil)
 			dashStore.On("GetFolderByID", mock.Anything, mock.AnythingOfType("int64"), mock.AnythingOfType("int64")).Return(&folder.Folder{}, nil)
 			dashStore.On("GetFolderByUID", mock.Anything, mock.AnythingOfType("int64"), mock.AnythingOfType("string")).Return(&folder.Folder{}, nil)
 			var actualCmd *models.DeleteDashboardCommand
@@ -670,8 +670,8 @@ func TestNestedFolderService(t *testing.T) {
 			// dashboard store & service commands that should be called.
 			dashboardsvc.On("BuildSaveDashboardCommand",
 				mock.Anything, mock.AnythingOfType("*dashboards.SaveDashboardDTO"),
-				mock.AnythingOfType("bool"), mock.AnythingOfType("bool")).Return(&models.SaveDashboardCommand{}, nil)
-			dashStore.On("SaveDashboard", mock.Anything, mock.AnythingOfType("models.SaveDashboardCommand")).Return(&models.Dashboard{}, nil)
+				mock.AnythingOfType("bool"), mock.AnythingOfType("bool")).Return(&dashboards.SaveDashboardCommand{}, nil)
+			dashStore.On("SaveDashboard", mock.Anything, mock.AnythingOfType("dashboards.SaveDashboardCommand")).Return(&dashboards.Dashboard{}, nil)
 			dashStore.On("GetFolderByID", mock.Anything, mock.AnythingOfType("int64"), mock.AnythingOfType("int64")).Return(&folder.Folder{}, nil)
 			dashStore.On("GetFolderByUID", mock.Anything, mock.AnythingOfType("int64"), mock.AnythingOfType("string")).Return(&folder.Folder{}, nil)
 			var actualCmd *models.DeleteDashboardCommand

pkg/services/guardian/accesscontrol_guardian.go

@@ -30,11 +30,11 @@ func NewAccessControlDashboardGuardian(
 	dashboardPermissionsService accesscontrol.DashboardPermissionsService,
 	dashboardService dashboards.DashboardService,
 ) (*AccessControlDashboardGuardian, error) {
-	var dashboard *models.Dashboard
+	var dashboard *dashboards.Dashboard
 	if dashboardId != 0 {
-		q := &models.GetDashboardQuery{
-			Id:    dashboardId,
-			OrgId: user.OrgID,
+		q := &dashboards.GetDashboardQuery{
+			ID:    dashboardId,
+			OrgID: user.OrgID,
 		}
 
 		if err := dashboardService.GetDashboard(ctx, q); err != nil {
@@ -67,11 +67,11 @@ func NewAccessControlDashboardGuardianByUID(
 	dashboardPermissionsService accesscontrol.DashboardPermissionsService,
 	dashboardService dashboards.DashboardService,
 ) (*AccessControlDashboardGuardian, error) {
-	var dashboard *models.Dashboard
+	var dashboard *dashboards.Dashboard
 	if dashboardUID != "" {
-		q := &models.GetDashboardQuery{
-			Uid:   dashboardUID,
-			OrgId: user.OrgID,
+		q := &dashboards.GetDashboardQuery{
+			UID:   dashboardUID,
+			OrgID: user.OrgID,
 		}
 
 		if err := dashboardService.GetDashboard(ctx, q); err != nil {
@@ -100,7 +100,7 @@ func NewAccessControlDashboardGuardianByUID(
 // This constructor should be preferred over the other two if the dashboard in available
 // since it avoids querying the database for fetching the dashboard.
 func NewAccessControlDashboardGuardianByDashboard(
-	ctx context.Context, dashboard *models.Dashboard, user *user.SignedInUser,
+	ctx context.Context, dashboard *dashboards.Dashboard, user *user.SignedInUser,
 	store db.DB, ac accesscontrol.AccessControl,
 	folderPermissionsService accesscontrol.FolderPermissionsService,
 	dashboardPermissionsService accesscontrol.DashboardPermissionsService,
@@ -122,7 +122,7 @@ func NewAccessControlDashboardGuardianByDashboard(
 type AccessControlDashboardGuardian struct {
 	ctx                         context.Context
 	log                         log.Logger
-	dashboard                   *models.Dashboard
+	dashboard                   *dashboards.Dashboard
 	user                        *user.SignedInUser
 	store                       db.DB
 	ac                          accesscontrol.AccessControl
@@ -137,11 +137,11 @@ func (a *AccessControlDashboardGuardian) CanSave() (bool, error) {
 	}
 
 	if a.dashboard.IsFolder {
-		return a.evaluate(accesscontrol.EvalPermission(dashboards.ActionFoldersWrite, dashboards.ScopeFoldersProvider.GetResourceScopeUID(a.dashboard.Uid)))
+		return a.evaluate(accesscontrol.EvalPermission(dashboards.ActionFoldersWrite, dashboards.ScopeFoldersProvider.GetResourceScopeUID(a.dashboard.UID)))
 	}
 
 	return a.evaluate(
-		accesscontrol.EvalPermission(dashboards.ActionDashboardsWrite, dashboards.ScopeDashboardsProvider.GetResourceScopeUID(a.dashboard.Uid)),
+		accesscontrol.EvalPermission(dashboards.ActionDashboardsWrite, dashboards.ScopeDashboardsProvider.GetResourceScopeUID(a.dashboard.UID)),
 	)
 }
 
@@ -155,11 +155,11 @@ func (a *AccessControlDashboardGuardian) CanEdit() (bool, error) {
 	}
 
 	if a.dashboard.IsFolder {
-		return a.evaluate(accesscontrol.EvalPermission(dashboards.ActionFoldersWrite, dashboards.ScopeFoldersProvider.GetResourceScopeUID(a.dashboard.Uid)))
+		return a.evaluate(accesscontrol.EvalPermission(dashboards.ActionFoldersWrite, dashboards.ScopeFoldersProvider.GetResourceScopeUID(a.dashboard.UID)))
 	}
 
 	return a.evaluate(
-		accesscontrol.EvalPermission(dashboards.ActionDashboardsWrite, dashboards.ScopeDashboardsProvider.GetResourceScopeUID(a.dashboard.Uid)),
+		accesscontrol.EvalPermission(dashboards.ActionDashboardsWrite, dashboards.ScopeDashboardsProvider.GetResourceScopeUID(a.dashboard.UID)),
 	)
 }
 
@@ -169,11 +169,11 @@ func (a *AccessControlDashboardGuardian) CanView() (bool, error) {
 	}
 
 	if a.dashboard.IsFolder {
-		return a.evaluate(accesscontrol.EvalPermission(dashboards.ActionFoldersRead, dashboards.ScopeFoldersProvider.GetResourceScopeUID(a.dashboard.Uid)))
+		return a.evaluate(accesscontrol.EvalPermission(dashboards.ActionFoldersRead, dashboards.ScopeFoldersProvider.GetResourceScopeUID(a.dashboard.UID)))
 	}
 
 	return a.evaluate(
-		accesscontrol.EvalPermission(dashboards.ActionDashboardsRead, dashboards.ScopeDashboardsProvider.GetResourceScopeUID(a.dashboard.Uid)),
+		accesscontrol.EvalPermission(dashboards.ActionDashboardsRead, dashboards.ScopeDashboardsProvider.GetResourceScopeUID(a.dashboard.UID)),
 	)
 }
 
@@ -184,14 +184,14 @@ func (a *AccessControlDashboardGuardian) CanAdmin() (bool, error) {
 
 	if a.dashboard.IsFolder {
 		return a.evaluate(accesscontrol.EvalAll(
-			accesscontrol.EvalPermission(dashboards.ActionFoldersPermissionsRead, dashboards.ScopeFoldersProvider.GetResourceScopeUID(a.dashboard.Uid)),
-			accesscontrol.EvalPermission(dashboards.ActionFoldersPermissionsWrite, dashboards.ScopeFoldersProvider.GetResourceScopeUID(a.dashboard.Uid)),
+			accesscontrol.EvalPermission(dashboards.ActionFoldersPermissionsRead, dashboards.ScopeFoldersProvider.GetResourceScopeUID(a.dashboard.UID)),
+			accesscontrol.EvalPermission(dashboards.ActionFoldersPermissionsWrite, dashboards.ScopeFoldersProvider.GetResourceScopeUID(a.dashboard.UID)),
 		))
 	}
 
 	return a.evaluate(accesscontrol.EvalAll(
-		accesscontrol.EvalPermission(dashboards.ActionDashboardsPermissionsRead, dashboards.ScopeDashboardsProvider.GetResourceScopeUID(a.dashboard.Uid)),
-		accesscontrol.EvalPermission(dashboards.ActionDashboardsPermissionsWrite, dashboards.ScopeDashboardsProvider.GetResourceScopeUID(a.dashboard.Uid)),
+		accesscontrol.EvalPermission(dashboards.ActionDashboardsPermissionsRead, dashboards.ScopeDashboardsProvider.GetResourceScopeUID(a.dashboard.UID)),
+		accesscontrol.EvalPermission(dashboards.ActionDashboardsPermissionsWrite, dashboards.ScopeDashboardsProvider.GetResourceScopeUID(a.dashboard.UID)),
 	))
 }
 
@@ -201,11 +201,11 @@ func (a *AccessControlDashboardGuardian) CanDelete() (bool, error) {
 	}
 
 	if a.dashboard.IsFolder {
-		return a.evaluate(accesscontrol.EvalPermission(dashboards.ActionFoldersDelete, dashboards.ScopeFoldersProvider.GetResourceScopeUID(a.dashboard.Uid)))
+		return a.evaluate(accesscontrol.EvalPermission(dashboards.ActionFoldersDelete, dashboards.ScopeFoldersProvider.GetResourceScopeUID(a.dashboard.UID)))
 	}
 
 	return a.evaluate(
-		accesscontrol.EvalPermission(dashboards.ActionDashboardsDelete, dashboards.ScopeDashboardsProvider.GetResourceScopeUID(a.dashboard.Uid)),
+		accesscontrol.EvalPermission(dashboards.ActionDashboardsDelete, dashboards.ScopeDashboardsProvider.GetResourceScopeUID(a.dashboard.UID)),
 	)
 }
 
@@ -217,17 +217,17 @@ func (a *AccessControlDashboardGuardian) CanCreate(folderID int64, isFolder bool
 	if err != nil {
 		return false, err
 	}
-	return a.evaluate(accesscontrol.EvalPermission(dashboards.ActionDashboardsCreate, dashboards.ScopeFoldersProvider.GetResourceScopeUID(folder.Uid)))
+	return a.evaluate(accesscontrol.EvalPermission(dashboards.ActionDashboardsCreate, dashboards.ScopeFoldersProvider.GetResourceScopeUID(folder.UID)))
 }
 
 func (a *AccessControlDashboardGuardian) evaluate(evaluator accesscontrol.Evaluator) (bool, error) {
 	ok, err := a.ac.Evaluate(a.ctx, a.user, evaluator)
 	if err != nil {
-		a.log.Debug("Failed to evaluate access control to folder or dashboard", "error", err, "userId", a.user.UserID, "id", a.dashboard.Id)
+		a.log.Debug("Failed to evaluate access control to folder or dashboard", "error", err, "userId", a.user.UserID, "id", a.dashboard.ID)
 	}
 
 	if !ok && err == nil {
-		a.log.Debug("Access denied to folder or dashboard", "userId", a.user.UserID, "id", a.dashboard.Id, "permissions", evaluator.GoString())
+		a.log.Debug("Access denied to folder or dashboard", "userId", a.user.UserID, "id", a.dashboard.ID, "permissions", evaluator.GoString())
 	}
 
 	return ok, err
@@ -251,7 +251,7 @@ func (a *AccessControlDashboardGuardian) GetACL() ([]*models.DashboardACLInfoDTO
 		svc = a.dashboardPermissionsService
 	}
 
-	permissions, err := svc.GetPermissions(a.ctx, a.user, a.dashboard.Uid)
+	permissions, err := svc.GetPermissions(a.ctx, a.user, a.dashboard.UID)
 	if err != nil {
 		return nil, err
 	}
@@ -269,9 +269,9 @@ func (a *AccessControlDashboardGuardian) GetACL() ([]*models.DashboardACLInfoDTO
 		}
 
 		acl = append(acl, &models.DashboardACLInfoDTO{
-			OrgId:          a.dashboard.OrgId,
-			DashboardId:    a.dashboard.Id,
-			FolderId:       a.dashboard.FolderId,
+			OrgId:          a.dashboard.OrgID,
+			DashboardId:    a.dashboard.ID,
+			FolderId:       a.dashboard.FolderID,
 			Created:        p.Created,
 			Updated:        p.Updated,
 			UserId:         p.UserId,
@@ -283,11 +283,11 @@ func (a *AccessControlDashboardGuardian) GetACL() ([]*models.DashboardACLInfoDTO
 			Role:           role,
 			Permission:     permissionMap[svc.MapActions(p)],
 			PermissionName: permissionMap[svc.MapActions(p)].String(),
-			Uid:            a.dashboard.Uid,
+			Uid:            a.dashboard.UID,
 			Title:          a.dashboard.Title,
 			Slug:           a.dashboard.Slug,
 			IsFolder:       a.dashboard.IsFolder,
-			Url:            a.dashboard.GetUrl(),
+			Url:            a.dashboard.GetURL(),
 			Inherited:      false,
 		})
 	}
@@ -332,11 +332,11 @@ func (a *AccessControlDashboardGuardian) GetHiddenACL(cfg *setting.Cfg) ([]*mode
 	return hiddenACL, nil
 }
 
-func (a *AccessControlDashboardGuardian) loadParentFolder(folderID int64) (*models.Dashboard, error) {
+func (a *AccessControlDashboardGuardian) loadParentFolder(folderID int64) (*dashboards.Dashboard, error) {
 	if folderID == 0 {
-		return &models.Dashboard{Uid: accesscontrol.GeneralFolderUID}, nil
+		return &dashboards.Dashboard{UID: accesscontrol.GeneralFolderUID}, nil
 	}
-	folderQuery := &models.GetDashboardQuery{Id: folderID, OrgId: a.user.OrgID}
+	folderQuery := &dashboards.GetDashboardQuery{ID: folderID, OrgID: a.user.OrgID}
 	if err := a.dashboardService.GetDashboard(a.ctx, folderQuery); err != nil {
 		return nil, err
 	}

pkg/services/guardian/accesscontrol_guardian_test.go

@@ -584,7 +584,7 @@ func TestAccessControlDashboardGuardian_GetHiddenACL(t *testing.T) {
 	}
 }
 
-func setupAccessControlGuardianTest(t *testing.T, uid string, permissions []accesscontrol.Permission, dashboardSvc dashboards.DashboardService) (*AccessControlDashboardGuardian, *models.Dashboard) {
+func setupAccessControlGuardianTest(t *testing.T, uid string, permissions []accesscontrol.Permission, dashboardSvc dashboards.DashboardService) (*AccessControlDashboardGuardian, *dashboards.Dashboard) {
 	t.Helper()
 	store := db.InitTestDB(t)
 
@@ -595,10 +595,10 @@ func setupAccessControlGuardianTest(t *testing.T, uid string, permissions []acce
 	quotaService := quotatest.New(false, nil)
 	dashStore, err := dashdb.ProvideDashboardStore(store, store.Cfg, featuremgmt.WithFeatures(), tagimpl.ProvideService(store, store.Cfg), quotaService)
 	require.NoError(t, err)
-	dash, err := dashStore.SaveDashboard(context.Background(), models.SaveDashboardCommand{
+	dash, err := dashStore.SaveDashboard(context.Background(), dashboards.SaveDashboardCommand{
 		Dashboard: toSave.Data,
-		UserId:    1,
-		OrgId:     1,
+		UserID:    1,
+		OrgID:     1,
 	})
 	require.NoError(t, err)
 	ac := accesscontrolmock.New().WithPermissions(permissions)
@@ -617,29 +617,29 @@ func setupAccessControlGuardianTest(t *testing.T, uid string, permissions []acce
 	require.NoError(t, err)
 	if dashboardSvc == nil {
 		fakeDashboardService := dashboards.NewFakeDashboardService(t)
-		fakeDashboardService.On("GetDashboard", mock.Anything, mock.AnythingOfType("*models.GetDashboardQuery")).Run(func(args mock.Arguments) {
-			q := args.Get(1).(*models.GetDashboardQuery)
-			q.Result = &models.Dashboard{
-				Id:    q.Id,
-				Uid:   q.Uid,
-				OrgId: q.OrgId,
+		fakeDashboardService.On("GetDashboard", mock.Anything, mock.AnythingOfType("*dashboards.GetDashboardQuery")).Run(func(args mock.Arguments) {
+			q := args.Get(1).(*dashboards.GetDashboardQuery)
+			q.Result = &dashboards.Dashboard{
+				ID:    q.ID,
+				UID:   q.UID,
+				OrgID: q.OrgID,
 			}
 		}).Return(nil)
 		dashboardSvc = fakeDashboardService
 	}
 
-	g, err := NewAccessControlDashboardGuardian(context.Background(), dash.Id, &user.SignedInUser{OrgID: 1}, store, ac, folderPermissions, dashboardPermissions, dashboardSvc)
+	g, err := NewAccessControlDashboardGuardian(context.Background(), dash.ID, &user.SignedInUser{OrgID: 1}, store, ac, folderPermissions, dashboardPermissions, dashboardSvc)
 	require.NoError(t, err)
 	return g, dash
 }
 
 func testDashSvc(t *testing.T) dashboards.DashboardService {
 	dashSvc := dashboards.NewFakeDashboardService(t)
-	dashSvc.On("GetDashboard", mock.Anything, mock.AnythingOfType("*models.GetDashboardQuery")).Run(func(args mock.Arguments) {
-		q := args.Get(1).(*models.GetDashboardQuery)
-		d := models.NewDashboard("mocked")
-		d.Id = 1
-		d.Uid = "1"
+	dashSvc.On("GetDashboard", mock.Anything, mock.AnythingOfType("*dashboards.GetDashboardQuery")).Run(func(args mock.Arguments) {
+		q := args.Get(1).(*dashboards.GetDashboardQuery)
+		d := dashboards.NewDashboard("mocked")
+		d.ID = 1
+		d.UID = "1"
 		q.Result = d
 	}).Return(nil)
 	return dashSvc

pkg/services/guardian/guardian.go

@@ -69,16 +69,16 @@ var NewByUID = func(ctx context.Context, dashUID string, orgId int64, user *user
 
 // NewByDashboard factory for creating a new dashboard guardian instance
 // When using access control this function is replaced on startup and the AccessControlDashboardGuardian is returned
-var NewByDashboard = func(ctx context.Context, dash *models.Dashboard, orgId int64, user *user.SignedInUser) (DashboardGuardian, error) {
+var NewByDashboard = func(ctx context.Context, dash *dashboards.Dashboard, orgId int64, user *user.SignedInUser) (DashboardGuardian, error) {
 	panic("no guardian factory implementation provided")
 }
 
 // newDashboardGuardian creates a dashboard guardian by the provided dashId.
 func newDashboardGuardian(ctx context.Context, dashId int64, orgId int64, user *user.SignedInUser, store db.DB, dashSvc dashboards.DashboardService, teamSvc team.Service) (*dashboardGuardianImpl, error) {
 	if dashId != 0 {
-		q := &models.GetDashboardQuery{
-			Id:    dashId,
-			OrgId: orgId,
+		q := &dashboards.GetDashboardQuery{
+			ID:    dashId,
+			OrgID: orgId,
 		}
 
 		if err := dashSvc.GetDashboard(ctx, q); err != nil {
@@ -105,9 +105,9 @@ func newDashboardGuardian(ctx context.Context, dashId int64, orgId int64, user *
 func newDashboardGuardianByUID(ctx context.Context, dashUID string, orgId int64, user *user.SignedInUser, store db.DB, dashSvc dashboards.DashboardService, teamSvc team.Service) (*dashboardGuardianImpl, error) {
 	dashID := int64(0)
 	if dashUID != "" {
-		q := &models.GetDashboardQuery{
-			Uid:   dashUID,
-			OrgId: orgId,
+		q := &dashboards.GetDashboardQuery{
+			UID:   dashUID,
+			OrgID: orgId,
 		}
 
 		if err := dashSvc.GetDashboard(ctx, q); err != nil {
@@ -116,7 +116,7 @@ func newDashboardGuardianByUID(ctx context.Context, dashUID string, orgId int64,
 			}
 			return nil, ErrGuardianGetDashboardFailure.Errorf("failed to get dashboard by UID: %w", err)
 		}
-		dashID = q.Result.Id
+		dashID = q.Result.ID
 	}
 
 	return &dashboardGuardianImpl{
@@ -134,10 +134,10 @@ func newDashboardGuardianByUID(ctx context.Context, dashUID string, orgId int64,
 // newDashboardGuardianByDashboard creates a dashboard guardian by the provided dashboard.
 // This constructor should be preferred over the other two if the dashboard in available
 // since it avoids querying the database for fetching the dashboard.
-func newDashboardGuardianByDashboard(ctx context.Context, dash *models.Dashboard, orgId int64, user *user.SignedInUser, store db.DB, dashSvc dashboards.DashboardService, teamSvc team.Service) (*dashboardGuardianImpl, error) {
+func newDashboardGuardianByDashboard(ctx context.Context, dash *dashboards.Dashboard, orgId int64, user *user.SignedInUser, store db.DB, dashSvc dashboards.DashboardService, teamSvc team.Service) (*dashboardGuardianImpl, error) {
 	return &dashboardGuardianImpl{
 		user:             user,
-		dashId:           dash.Id,
+		dashId:           dash.ID,
 		orgId:            orgId,
 		log:              log.New("dashboard.permissions"),
 		ctx:              ctx,
@@ -470,10 +470,10 @@ func MockDashboardGuardian(mock *FakeDashboardGuardian) {
 		return mock, nil
 	}
 
-	NewByDashboard = func(_ context.Context, dash *models.Dashboard, orgId int64, user *user.SignedInUser) (DashboardGuardian, error) {
+	NewByDashboard = func(_ context.Context, dash *dashboards.Dashboard, orgId int64, user *user.SignedInUser) (DashboardGuardian, error) {
 		mock.OrgId = orgId
-		mock.DashUID = dash.Uid
-		mock.DashID = dash.Id
+		mock.DashUID = dash.UID
+		mock.DashID = dash.ID
 		mock.User = user
 		return mock, nil
 	}

pkg/services/guardian/guardian_test.go

@@ -698,12 +698,12 @@ func TestGuardianGetHiddenACL(t *testing.T) {
 				{Inherited: true, UserId: 3, UserLogin: "user3", Permission: models.PERMISSION_VIEW},
 			}
 		}).Return(nil)
-		dashSvc.On("GetDashboard", mock.Anything, mock.AnythingOfType("*models.GetDashboardQuery")).Run(func(args mock.Arguments) {
-			q := args.Get(1).(*models.GetDashboardQuery)
-			q.Result = &models.Dashboard{
-				Id:    q.Id,
-				Uid:   q.Uid,
-				OrgId: q.OrgId,
+		dashSvc.On("GetDashboard", mock.Anything, mock.AnythingOfType("*dashboards.GetDashboardQuery")).Run(func(args mock.Arguments) {
+			q := args.Get(1).(*dashboards.GetDashboardQuery)
+			q.Result = &dashboards.Dashboard{
+				ID:    q.ID,
+				UID:   q.UID,
+				OrgID: q.OrgID,
 			}
 		}).Return(nil)
 
@@ -734,11 +734,11 @@ func TestGuardianGetHiddenACL(t *testing.T) {
 				IsGrafanaAdmin: true,
 			}
 			dashSvc := dashboards.NewFakeDashboardService(t)
-			dashSvc.On("GetDashboard", mock.Anything, mock.AnythingOfType("*models.GetDashboardQuery")).Run(func(args mock.Arguments) {
-				q := args.Get(1).(*models.GetDashboardQuery)
-				q.Result = &models.Dashboard{
-					Id:  q.Id,
-					Uid: q.Uid,
+			dashSvc.On("GetDashboard", mock.Anything, mock.AnythingOfType("*dashboards.GetDashboardQuery")).Run(func(args mock.Arguments) {
+				q := args.Get(1).(*dashboards.GetDashboardQuery)
+				q.Result = &dashboards.Dashboard{
+					ID:  q.ID,
+					UID: q.UID,
 				}
 			}).Return(nil)
 			g, err := newDashboardGuardian(context.Background(), dashboardID, orgID, user, store, dashSvc, &teamtest.FakeService{})
@@ -769,12 +769,12 @@ func TestGuardianGetACLWithoutDuplicates(t *testing.T) {
 				{Inherited: false, UserId: 6, UserLogin: "user6", Permission: models.PERMISSION_EDIT},
 			}
 		}).Return(nil)
-		dashSvc.On("GetDashboard", mock.Anything, mock.AnythingOfType("*models.GetDashboardQuery")).Run(func(args mock.Arguments) {
-			q := args.Get(1).(*models.GetDashboardQuery)
-			q.Result = &models.Dashboard{
-				Id:    q.Id,
-				Uid:   q.Uid,
-				OrgId: q.OrgId,
+		dashSvc.On("GetDashboard", mock.Anything, mock.AnythingOfType("*dashboards.GetDashboardQuery")).Run(func(args mock.Arguments) {
+			q := args.Get(1).(*dashboards.GetDashboardQuery)
+			q.Result = &dashboards.Dashboard{
+				ID:    q.ID,
+				UID:   q.UID,
+				OrgID: q.OrgID,
 			}
 		}).Return(nil)
 

pkg/services/guardian/guardian_util_test.go

@@ -47,11 +47,11 @@ func orgRoleScenario(desc string, t *testing.T, role org.RoleType, fn scenarioFu
 		store := dbtest.NewFakeDB()
 
 		fakeDashboardService := dashboards.NewFakeDashboardService(t)
-		fakeDashboardService.On("GetDashboard", mock.Anything, mock.AnythingOfType("*models.GetDashboardQuery")).Run(func(args mock.Arguments) {
-			q := args.Get(1).(*models.GetDashboardQuery)
-			q.Result = &models.Dashboard{
-				Id:  q.Id,
-				Uid: q.Uid,
+		fakeDashboardService.On("GetDashboard", mock.Anything, mock.AnythingOfType("*dashboards.GetDashboardQuery")).Run(func(args mock.Arguments) {
+			q := args.Get(1).(*dashboards.GetDashboardQuery)
+			q.Result = &dashboards.Dashboard{
+				ID:  q.ID,
+				UID: q.UID,
 			}
 		}).Return(nil)
 		guard, err := newDashboardGuardian(context.Background(), dashboardID, orgID, user, store, fakeDashboardService, &teamtest.FakeService{})
@@ -78,11 +78,11 @@ func apiKeyScenario(desc string, t *testing.T, role org.RoleType, fn scenarioFun
 		}
 		store := dbtest.NewFakeDB()
 		dashSvc := dashboards.NewFakeDashboardService(t)
-		dashSvc.On("GetDashboard", mock.Anything, mock.AnythingOfType("*models.GetDashboardQuery")).Run(func(args mock.Arguments) {
-			q := args.Get(1).(*models.GetDashboardQuery)
-			q.Result = &models.Dashboard{
-				Id:  q.Id,
-				Uid: q.Uid,
+		dashSvc.On("GetDashboard", mock.Anything, mock.AnythingOfType("*dashboards.GetDashboardQuery")).Run(func(args mock.Arguments) {
+			q := args.Get(1).(*dashboards.GetDashboardQuery)
+			q.Result = &dashboards.Dashboard{
+				ID:  q.ID,
+				UID: q.UID,
 			}
 		}).Return(nil)
 		guard, err := newDashboardGuardian(context.Background(), dashboardID, orgID, user, store, dashSvc, &teamtest.FakeService{})
@@ -118,12 +118,12 @@ func permissionScenario(desc string, dashboardID int64, sc *scenarioContext,
 			q := args.Get(1).(*models.GetDashboardACLInfoListQuery)
 			q.Result = permissions
 		}).Return(nil)
-		dashSvc.On("GetDashboard", mock.Anything, mock.AnythingOfType("*models.GetDashboardQuery")).Run(func(args mock.Arguments) {
-			q := args.Get(1).(*models.GetDashboardQuery)
-			q.Result = &models.Dashboard{
-				Id:    q.Id,
-				Uid:   q.Uid,
-				OrgId: q.OrgId,
+		dashSvc.On("GetDashboard", mock.Anything, mock.AnythingOfType("*dashboards.GetDashboardQuery")).Run(func(args mock.Arguments) {
+			q := args.Get(1).(*dashboards.GetDashboardQuery)
+			q.Result = &dashboards.Dashboard{
+				ID:    q.ID,
+				UID:   q.UID,
+				OrgID: q.OrgID,
 			}
 		}).Return(nil)
 

pkg/services/guardian/provider.go

@@ -4,7 +4,6 @@ import (
 	"context"
 
 	"github.com/grafana/grafana/pkg/infra/db"
-	"github.com/grafana/grafana/pkg/models"
 	"github.com/grafana/grafana/pkg/services/accesscontrol"
 	"github.com/grafana/grafana/pkg/services/dashboards"
 	"github.com/grafana/grafana/pkg/services/team"
@@ -36,7 +35,7 @@ func InitLegacyGuardian(store db.DB, dashSvc dashboards.DashboardService, teamSv
 		return newDashboardGuardianByUID(ctx, dashUID, orgId, user, store, dashSvc, teamSvc)
 	}
 
-	NewByDashboard = func(ctx context.Context, dash *models.Dashboard, orgId int64, user *user.SignedInUser) (DashboardGuardian, error) {
+	NewByDashboard = func(ctx context.Context, dash *dashboards.Dashboard, orgId int64, user *user.SignedInUser) (DashboardGuardian, error) {
 		return newDashboardGuardianByDashboard(ctx, dash, orgId, user, store, dashSvc, teamSvc)
 	}
 }
@@ -53,7 +52,7 @@ func InitAccessControlGuardian(
 		return NewAccessControlDashboardGuardianByUID(ctx, dashUID, user, store, ac, folderPermissionsService, dashboardPermissionsService, dashboardService)
 	}
 
-	NewByDashboard = func(ctx context.Context, dash *models.Dashboard, orgId int64, user *user.SignedInUser) (DashboardGuardian, error) {
+	NewByDashboard = func(ctx context.Context, dash *dashboards.Dashboard, orgId int64, user *user.SignedInUser) (DashboardGuardian, error) {
 		return NewAccessControlDashboardGuardianByDashboard(ctx, dash, user, store, ac, folderPermissionsService, dashboardPermissionsService, dashboardService)
 	}
 }

pkg/services/libraryelements/libraryelements_delete_test.go

@@ -5,11 +5,10 @@ import (
 	"testing"
 
 	"github.com/grafana/grafana/pkg/components/simplejson"
+	"github.com/grafana/grafana/pkg/services/dashboards"
 	"github.com/grafana/grafana/pkg/services/org"
 	"github.com/grafana/grafana/pkg/web"
 	"github.com/stretchr/testify/require"
-
-	"github.com/grafana/grafana/pkg/models"
 )
 
 func TestDeleteLibraryElement(t *testing.T) {
@@ -69,12 +68,12 @@ func TestDeleteLibraryElement(t *testing.T) {
 					},
 				},
 			}
-			dash := models.Dashboard{
+			dash := dashboards.Dashboard{
 				Title: "Testing deleteHandler ",
 				Data:  simplejson.NewFromAny(dashJSON),
 			}
 			dashInDB := createDashboard(t, sc.sqlStore, sc.user, &dash, sc.folder.ID)
-			err := sc.service.ConnectElementsToDashboard(sc.reqContext.Req.Context(), sc.reqContext.SignedInUser, []string{sc.initialResult.Result.UID}, dashInDB.Id)
+			err := sc.service.ConnectElementsToDashboard(sc.reqContext.Req.Context(), sc.reqContext.SignedInUser, []string{sc.initialResult.Result.UID}, dashInDB.ID)
 			require.NoError(t, err)
 
 			sc.ctx.Req = web.SetURLParams(sc.ctx.Req, map[string]string{":uid": sc.initialResult.Result.UID})

pkg/services/libraryelements/libraryelements_get_test.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/google/go-cmp/cmp"
 	"github.com/grafana/grafana/pkg/components/simplejson"
+	"github.com/grafana/grafana/pkg/services/dashboards"
 	"github.com/grafana/grafana/pkg/services/org"
 	"github.com/grafana/grafana/pkg/web"
 	"github.com/stretchr/testify/require"
@@ -115,12 +116,12 @@ func TestGetLibraryElement(t *testing.T) {
 					},
 				},
 			}
-			dash := models.Dashboard{
+			dash := dashboards.Dashboard{
 				Title: "Testing getHandler",
 				Data:  simplejson.NewFromAny(dashJSON),
 			}
 			dashInDB := createDashboard(t, sc.sqlStore, sc.user, &dash, sc.folder.ID)
-			err := sc.service.ConnectElementsToDashboard(sc.reqContext.Req.Context(), sc.reqContext.SignedInUser, []string{sc.initialResult.Result.UID}, dashInDB.Id)
+			err := sc.service.ConnectElementsToDashboard(sc.reqContext.Req.Context(), sc.reqContext.SignedInUser, []string{sc.initialResult.Result.UID}, dashInDB.ID)
 			require.NoError(t, err)
 
 			expected := func(res libraryElementResult) libraryElementResult {

pkg/services/libraryelements/libraryelements_test.go

@@ -72,12 +72,12 @@ func TestDeleteLibraryPanelsInFolder(t *testing.T) {
 					},
 				},
 			}
-			dash := models.Dashboard{
+			dash := dashboards.Dashboard{
 				Title: "Testing DeleteLibraryElementsInFolder",
 				Data:  simplejson.NewFromAny(dashJSON),
 			}
 			dashInDB := createDashboard(t, sc.sqlStore, sc.user, &dash, sc.folder.ID)
-			err := sc.service.ConnectElementsToDashboard(sc.reqContext.Req.Context(), sc.reqContext.SignedInUser, []string{sc.initialResult.Result.UID}, dashInDB.Id)
+			err := sc.service.ConnectElementsToDashboard(sc.reqContext.Req.Context(), sc.reqContext.SignedInUser, []string{sc.initialResult.Result.UID}, dashInDB.ID)
 			require.NoError(t, err)
 
 			err = sc.service.DeleteLibraryElementsInFolder(sc.reqContext.Req.Context(), sc.reqContext.SignedInUser, sc.folder.UID)
@@ -145,12 +145,12 @@ func TestGetLibraryPanelConnections(t *testing.T) {
 					},
 				},
 			}
-			dash := models.Dashboard{
+			dash := dashboards.Dashboard{
 				Title: "Testing GetLibraryPanelConnections",
 				Data:  simplejson.NewFromAny(dashJSON),
 			}
 			dashInDB := createDashboard(t, sc.sqlStore, sc.user, &dash, sc.folder.ID)
-			err := sc.service.ConnectElementsToDashboard(sc.reqContext.Req.Context(), sc.reqContext.SignedInUser, []string{sc.initialResult.Result.UID}, dashInDB.Id)
+			err := sc.service.ConnectElementsToDashboard(sc.reqContext.Req.Context(), sc.reqContext.SignedInUser, []string{sc.initialResult.Result.UID}, dashInDB.ID)
 			require.NoError(t, err)
 
 			var expected = func(res LibraryElementConnectionsResponse) LibraryElementConnectionsResponse {
@@ -160,8 +160,8 @@ func TestGetLibraryPanelConnections(t *testing.T) {
 							ID:            sc.initialResult.Result.ID,
 							Kind:          sc.initialResult.Result.Kind,
 							ElementID:     1,
-							ConnectionID:  dashInDB.Id,
-							ConnectionUID: dashInDB.Uid,
+							ConnectionID:  dashInDB.ID,
+							ConnectionUID: dashInDB.UID,
 							Created:       res.Result[0].Created,
 							CreatedBy: LibraryElementDTOMetaUser{
 								ID:        1,
@@ -269,12 +269,12 @@ type folderACLItem struct {
 	permission models.PermissionType
 }
 
-func createDashboard(t *testing.T, sqlStore db.DB, user user.SignedInUser, dash *models.Dashboard, folderID int64) *models.Dashboard {
-	dash.FolderId = folderID
+func createDashboard(t *testing.T, sqlStore db.DB, user user.SignedInUser, dash *dashboards.Dashboard, folderID int64) *dashboards.Dashboard {
+	dash.FolderID = folderID
 	dashItem := &dashboards.SaveDashboardDTO{
 		Dashboard: dash,
 		Message:   "",
-		OrgId:     user.OrgID,
+		OrgID:     user.OrgID,
 		User:      &user,
 		Overwrite: false,
 	}

pkg/services/librarypanels/librarypanels.go

@@ -10,6 +10,7 @@ import (
 	"github.com/grafana/grafana/pkg/infra/db"
 	"github.com/grafana/grafana/pkg/infra/log"
 	"github.com/grafana/grafana/pkg/models"
+	"github.com/grafana/grafana/pkg/services/dashboards"
 	"github.com/grafana/grafana/pkg/services/libraryelements"
 	"github.com/grafana/grafana/pkg/services/user"
 	"github.com/grafana/grafana/pkg/setting"
@@ -28,7 +29,7 @@ func ProvideService(cfg *setting.Cfg, sqlStore db.DB, routeRegister routing.Rout
 
 // Service is a service for operating on library panels.
 type Service interface {
-	ConnectLibraryPanelsForDashboard(c context.Context, signedInUser *user.SignedInUser, dash *models.Dashboard) error
+	ConnectLibraryPanelsForDashboard(c context.Context, signedInUser *user.SignedInUser, dash *dashboards.Dashboard) error
 	ImportLibraryPanelsForDashboard(c context.Context, signedInUser *user.SignedInUser, libraryPanels *simplejson.Json, panels []interface{}, folderID int64) error
 }
 
@@ -47,7 +48,7 @@ type LibraryPanelService struct {
 }
 
 // ConnectLibraryPanelsForDashboard loops through all panels in dashboard JSON and connects any library panels to the dashboard.
-func (lps *LibraryPanelService) ConnectLibraryPanelsForDashboard(c context.Context, signedInUser *user.SignedInUser, dash *models.Dashboard) error {
+func (lps *LibraryPanelService) ConnectLibraryPanelsForDashboard(c context.Context, signedInUser *user.SignedInUser, dash *dashboards.Dashboard) error {
 	panels := dash.Data.Get("panels").MustArray()
 	libraryPanels := make(map[string]string)
 	err := connectLibraryPanelsRecursively(c, panels, libraryPanels)
@@ -60,7 +61,7 @@ func (lps *LibraryPanelService) ConnectLibraryPanelsForDashboard(c context.Conte
 		elementUIDs = append(elementUIDs, libraryPanel)
 	}
 
-	return lps.LibraryElementService.ConnectElementsToDashboard(c, signedInUser, elementUIDs, dash.Id)
+	return lps.LibraryElementService.ConnectElementsToDashboard(c, signedInUser, elementUIDs, dash.ID)
 }
 
 func isLibraryPanelOrRow(panel *simplejson.Json, panelType string) bool {

pkg/services/librarypanels/librarypanels_test.go

@@ -72,7 +72,7 @@ func TestConnectLibraryPanelsForDashboard(t *testing.T) {
 					},
 				},
 			}
-			dash := models.Dashboard{
+			dash := dashboards.Dashboard{
 				Title: "Testing ConnectLibraryPanelsForDashboard",
 				Data:  simplejson.NewFromAny(dashJSON),
 			}
@@ -81,7 +81,7 @@ func TestConnectLibraryPanelsForDashboard(t *testing.T) {
 			err := sc.service.ConnectLibraryPanelsForDashboard(sc.ctx, sc.user, dashInDB)
 			require.NoError(t, err)
 
-			elements, err := sc.elementService.GetElementsForDashboard(sc.ctx, dashInDB.Id)
+			elements, err := sc.elementService.GetElementsForDashboard(sc.ctx, dashInDB.ID)
 			require.NoError(t, err)
 			require.Len(t, elements, 1)
 			require.Equal(t, sc.initialResult.Result.UID, elements[sc.initialResult.Result.UID].UID)
@@ -170,7 +170,7 @@ func TestConnectLibraryPanelsForDashboard(t *testing.T) {
 					},
 				},
 			}
-			dash := models.Dashboard{
+			dash := dashboards.Dashboard{
 				Title: "Testing ConnectLibraryPanelsForDashboard",
 				Data:  simplejson.NewFromAny(dashJSON),
 			}
@@ -179,7 +179,7 @@ func TestConnectLibraryPanelsForDashboard(t *testing.T) {
 			err = sc.service.ConnectLibraryPanelsForDashboard(sc.ctx, sc.user, dashInDB)
 			require.NoError(t, err)
 
-			elements, err := sc.elementService.GetElementsForDashboard(sc.ctx, dashInDB.Id)
+			elements, err := sc.elementService.GetElementsForDashboard(sc.ctx, dashInDB.ID)
 			require.NoError(t, err)
 			require.Len(t, elements, 2)
 			require.Equal(t, sc.initialResult.Result.UID, elements[sc.initialResult.Result.UID].UID)
@@ -216,7 +216,7 @@ func TestConnectLibraryPanelsForDashboard(t *testing.T) {
 					},
 				},
 			}
-			dash := models.Dashboard{
+			dash := dashboards.Dashboard{
 				Title: "Testing ConnectLibraryPanelsForDashboard",
 				Data:  simplejson.NewFromAny(dashJSON),
 			}
@@ -272,12 +272,12 @@ func TestConnectLibraryPanelsForDashboard(t *testing.T) {
 				},
 			}
 
-			dash := models.Dashboard{
+			dash := dashboards.Dashboard{
 				Title: "Testing ConnectLibraryPanelsForDashboard",
 				Data:  simplejson.NewFromAny(dashJSON),
 			}
 			dashInDB := createDashboard(t, sc.sqlStore, sc.user, &dash, sc.folder.Id)
-			err = sc.elementService.ConnectElementsToDashboard(sc.ctx, sc.user, []string{sc.initialResult.Result.UID}, dashInDB.Id)
+			err = sc.elementService.ConnectElementsToDashboard(sc.ctx, sc.user, []string{sc.initialResult.Result.UID}, dashInDB.ID)
 			require.NoError(t, err)
 
 			panelJSON := []interface{}{
@@ -310,7 +310,7 @@ func TestConnectLibraryPanelsForDashboard(t *testing.T) {
 			err = sc.service.ConnectLibraryPanelsForDashboard(sc.ctx, sc.user, dashInDB)
 			require.NoError(t, err)
 
-			elements, err := sc.elementService.GetElementsForDashboard(sc.ctx, dashInDB.Id)
+			elements, err := sc.elementService.GetElementsForDashboard(sc.ctx, dashInDB.ID)
 			require.NoError(t, err)
 			require.Len(t, elements, 1)
 			require.Equal(t, sc.initialResult.Result.UID, elements[sc.initialResult.Result.UID].UID)
@@ -684,12 +684,12 @@ func getExpected(t *testing.T, res libraryelements.LibraryElementDTO, UID string
 	}
 }
 
-func createDashboard(t *testing.T, sqlStore db.DB, user *user.SignedInUser, dash *models.Dashboard, folderID int64) *models.Dashboard {
-	dash.FolderId = folderID
+func createDashboard(t *testing.T, sqlStore db.DB, user *user.SignedInUser, dash *dashboards.Dashboard, folderID int64) *dashboards.Dashboard {
+	dash.FolderID = folderID
 	dashItem := &dashboards.SaveDashboardDTO{
 		Dashboard: dash,
 		Message:   "",
-		OrgId:     user.OrgID,
+		OrgID:     user.OrgID,
 		User:      user,
 		Overwrite: false,
 	}
@@ -767,11 +767,11 @@ func scenarioWithLibraryPanel(t *testing.T, desc string, fn func(t *testing.T, s
 	store := dbtest.NewFakeDB()
 
 	dashSvc := dashboards.NewFakeDashboardService(t)
-	dashSvc.On("GetDashboard", mock.Anything, mock.AnythingOfType("*models.GetDashboardQuery")).Run(func(args mock.Arguments) {
-		q := args.Get(1).(*models.GetDashboardQuery)
-		q.Result = &models.Dashboard{
-			Id:  q.Id,
-			Uid: q.Uid,
+	dashSvc.On("GetDashboard", mock.Anything, mock.AnythingOfType("*dashboards.GetDashboardQuery")).Run(func(args mock.Arguments) {
+		q := args.Get(1).(*dashboards.GetDashboardQuery)
+		q.Result = &dashboards.Dashboard{
+			ID:  q.ID,
+			UID: q.UID,
 		}
 	}).Return(nil)
 	guardian.InitLegacyGuardian(store, dashSvc, &teamtest.FakeService{})

pkg/services/live/features/dashboard.go

@@ -29,13 +29,13 @@ const (
 
 // DashboardEvent events related to dashboards
 type dashboardEvent struct {
-	UID       string               `json:"uid"`
-	Action    actionType           `json:"action"` // saved, editing, deleted
-	User      *user.UserDisplayDTO `json:"user,omitempty"`
-	SessionID string               `json:"sessionId,omitempty"`
-	Message   string               `json:"message,omitempty"`
-	Dashboard *models.Dashboard    `json:"dashboard,omitempty"`
-	Error     string               `json:"error,omitempty"`
+	UID       string                `json:"uid"`
+	Action    actionType            `json:"action"` // saved, editing, deleted
+	User      *user.UserDisplayDTO  `json:"user,omitempty"`
+	SessionID string                `json:"sessionId,omitempty"`
+	Message   string                `json:"message,omitempty"`
+	Dashboard *dashboards.Dashboard `json:"dashboard,omitempty"`
+	Error     string                `json:"error,omitempty"`
 }
 
 // DashboardHandler manages all the `grafana/dashboard/*` channels
@@ -66,7 +66,7 @@ func (h *DashboardHandler) OnSubscribe(ctx context.Context, user *user.SignedInU
 
 	// make sure can view this dashboard
 	if len(parts) == 2 && parts[0] == "uid" {
-		query := models.GetDashboardQuery{Uid: parts[1], OrgId: user.OrgID}
+		query := dashboards.GetDashboardQuery{UID: parts[1], OrgID: user.OrgID}
 		if err := h.DashboardService.GetDashboard(ctx, &query); err != nil {
 			logger.Error("Error getting dashboard", "query", query, "error", err)
 			return models.SubscribeReply{}, backend.SubscribeStreamStatusNotFound, nil
@@ -116,7 +116,7 @@ func (h *DashboardHandler) OnPublish(ctx context.Context, user *user.SignedInUse
 			// just ignore the event
 			return models.PublishReply{}, backend.PublishStreamStatusNotFound, fmt.Errorf("ignore???")
 		}
-		query := models.GetDashboardQuery{Uid: parts[1], OrgId: user.OrgID}
+		query := dashboards.GetDashboardQuery{UID: parts[1], OrgID: user.OrgID}
 		if err := h.DashboardService.GetDashboard(ctx, &query); err != nil {
 			logger.Error("Unknown dashboard", "query", query)
 			return models.PublishReply{}, backend.PublishStreamStatusNotFound, nil
@@ -171,13 +171,13 @@ func (h *DashboardHandler) publish(orgID int64, event dashboardEvent) error {
 }
 
 // DashboardSaved will broadcast to all connected dashboards
-func (h *DashboardHandler) DashboardSaved(orgID int64, user *user.UserDisplayDTO, message string, dashboard *models.Dashboard, err error) error {
+func (h *DashboardHandler) DashboardSaved(orgID int64, user *user.UserDisplayDTO, message string, dashboard *dashboards.Dashboard, err error) error {
 	if err != nil && !h.HasGitOpsObserver(orgID) {
 		return nil // only broadcast if it was OK
 	}
 
 	msg := dashboardEvent{
-		UID:       dashboard.Uid,
+		UID:       dashboard.UID,
 		Action:    ActionSaved,
 		User:      user,
 		Message:   message,

pkg/services/live/live.go

@@ -69,7 +69,7 @@ type CoreGrafanaScope struct {
 	Features map[string]models.ChannelHandlerFactory
 
 	// The generic service to advertise dashboard changes
-	Dashboards models.DashboardActivityChannel
+	Dashboards DashboardActivityChannel
 }
 
 func ProvideService(plugCtxProvider *plugincontext.Provider, cfg *setting.Cfg, routeRegister routing.RouteRegister,
@@ -437,6 +437,22 @@ type GrafanaLive struct {
 	usageStats        usageStats
 }
 
+// DashboardActivityChannel is a service to advertise dashboard activity
+type DashboardActivityChannel interface {
+	// Called when a dashboard is saved -- this includes the error so we can support a
+	// gitops workflow that knows if the value was saved to the local database or not
+	// in many cases all direct save requests will fail, but the request should be forwarded
+	// to any gitops observers
+	DashboardSaved(orgID int64, user *user.UserDisplayDTO, message string, dashboard *dashboards.Dashboard, err error) error
+
+	// Called when a dashboard is deleted
+	DashboardDeleted(orgID int64, user *user.UserDisplayDTO, uid string) error
+
+	// Experimental! Indicate is GitOps is active.  This really means
+	// someone is subscribed to the `grafana/dashboards/gitops` channel
+	HasGitOpsObserver(orgID int64) bool
+}
+
 func (g *GrafanaLive) getStreamPlugin(ctx context.Context, pluginID string) (backend.StreamHandler, error) {
 	plugin, exists := g.pluginStore.Plugin(ctx, pluginID)
 	if !exists {

pkg/services/navtree/navtreeimpl/navtree.go

@@ -219,10 +219,10 @@ func (s *ServiceImpl) getHomeNode(c *models.ReqContext, prefs *pref.Preference)
 	}
 
 	if prefs.HomeDashboardID != 0 {
-		slugQuery := models.GetDashboardRefByIdQuery{Id: prefs.HomeDashboardID}
-		err := s.dashboardService.GetDashboardUIDById(c.Req.Context(), &slugQuery)
+		slugQuery := dashboards.GetDashboardRefByIDQuery{ID: prefs.HomeDashboardID}
+		err := s.dashboardService.GetDashboardUIDByID(c.Req.Context(), &slugQuery)
 		if err == nil {
-			homeUrl = models.GetDashboardUrl(slugQuery.Result.Uid, slugQuery.Result.Slug)
+			homeUrl = models.GetDashboardUrl(slugQuery.Result.UID, slugQuery.Result.Slug)
 		}
 	}
 
@@ -331,7 +331,7 @@ func (s *ServiceImpl) buildStarredItemsNavLinks(c *models.ReqContext) ([]*navtre
 		return nil, err
 	}
 
-	starredDashboards := []*models.Dashboard{}
+	starredDashboards := []*dashboards.Dashboard{}
 	starredDashboardsCounter := 0
 	for dashboardId := range starredDashboardResult.UserStars {
 		// Set a loose limit to the first 50 starred dashboards found
@@ -339,9 +339,9 @@ func (s *ServiceImpl) buildStarredItemsNavLinks(c *models.ReqContext) ([]*navtre
 			break
 		}
 		starredDashboardsCounter++
-		query := &models.GetDashboardQuery{
-			Id:    dashboardId,
-			OrgId: c.OrgID,
+		query := &dashboards.GetDashboardQuery{
+			ID:    dashboardId,
+			OrgID: c.OrgID,
 		}
 		err := s.dashboardService.GetDashboard(c.Req.Context(), query)
 		if err == nil {
@@ -355,9 +355,9 @@ func (s *ServiceImpl) buildStarredItemsNavLinks(c *models.ReqContext) ([]*navtre
 		})
 		for _, starredItem := range starredDashboards {
 			starredItemsChildNavs = append(starredItemsChildNavs, &navtree.NavLink{
-				Id:   "starred/" + starredItem.Uid,
+				Id:   "starred/" + starredItem.UID,
 				Text: starredItem.Title,
-				Url:  starredItem.GetUrl(),
+				Url:  starredItem.GetURL(),
 			})
 		}
 	}

pkg/services/ngalert/state/historian/dashboard.go

@@ -8,7 +8,6 @@ import (
 	"time"
 
 	"github.com/grafana/grafana/pkg/infra/log"
-	"github.com/grafana/grafana/pkg/models"
 	"github.com/grafana/grafana/pkg/services/dashboards"
 	"github.com/patrickmn/go-cache"
 	"golang.org/x/sync/singleflight"
@@ -51,9 +50,9 @@ func (r *dashboardResolver) getID(ctx context.Context, orgID int64, uid string)
 		r.log.Debug("Dashboard cache miss, querying dashboards", "dashboardUID", uid)
 
 		var result interface{}
-		query := &models.GetDashboardQuery{
-			Uid:   uid,
-			OrgId: orgID,
+		query := &dashboards.GetDashboardQuery{
+			UID:   uid,
+			OrgID: orgID,
 		}
 		err := r.dashboards.GetDashboard(ctx, query)
 		// We also cache lookups where we don't find anything.
@@ -64,7 +63,7 @@ func (r *dashboardResolver) getID(ctx context.Context, orgID int64, uid string)
 		} else if query.Result == nil {
 			result = dashboards.ErrDashboardNotFound
 		} else {
-			result = query.Result.Id
+			result = query.Result.ID
 		}
 
 		// By setting the cache inside the singleflighted routine, we avoid any accidental re-queries that could get initiated after the query completes.

pkg/services/ngalert/state/historian/dashboard_test.go

@@ -5,7 +5,6 @@ import (
 	"testing"
 	"time"
 
-	"github.com/grafana/grafana/pkg/models"
 	"github.com/grafana/grafana/pkg/services/dashboards"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
@@ -16,7 +15,7 @@ func TestDashboardResolver(t *testing.T) {
 		dbs := &dashboards.FakeDashboardService{}
 		exp := int64(14)
 		dbs.On("GetDashboard", mock.Anything, mock.Anything).Run(func(args mock.Arguments) {
-			args.Get(1).(*models.GetDashboardQuery).Result = &models.Dashboard{Id: exp}
+			args.Get(1).(*dashboards.GetDashboardQuery).Result = &dashboards.Dashboard{ID: exp}
 		}).Return(nil)
 		sut := createDashboardResolverSut(dbs)
 
@@ -29,7 +28,7 @@ func TestDashboardResolver(t *testing.T) {
 	t.Run("fetches dashboardNotFound if underlying dashboard does not exist", func(t *testing.T) {
 		dbs := &dashboards.FakeDashboardService{}
 		dbs.On("GetDashboard", mock.Anything, mock.Anything).Run(func(args mock.Arguments) {
-			args.Get(1).(*models.GetDashboardQuery).Result = nil
+			args.Get(1).(*dashboards.GetDashboardQuery).Result = nil
 		}).Return(dashboards.ErrDashboardNotFound)
 		sut := createDashboardResolverSut(dbs)
 

pkg/services/provisioning/alerting/rules_provisioner.go

@@ -7,7 +7,6 @@ import (
 
 	"github.com/grafana/grafana/pkg/infra/log"
 	"github.com/grafana/grafana/pkg/infra/slugify"
-	"github.com/grafana/grafana/pkg/models"
 	"github.com/grafana/grafana/pkg/services/dashboards"
 	alert_models "github.com/grafana/grafana/pkg/services/ngalert/models"
 	"github.com/grafana/grafana/pkg/services/ngalert/provisioning"
@@ -99,9 +98,9 @@ func (prov *defaultAlertRuleProvisioner) provisionRule(
 
 func (prov *defaultAlertRuleProvisioner) getOrCreateFolderUID(
 	ctx context.Context, folderName string, orgID int64) (string, error) {
-	cmd := &models.GetDashboardQuery{
+	cmd := &dashboards.GetDashboardQuery{
 		Slug:  slugify.Slugify(folderName),
-		OrgId: orgID,
+		OrgID: orgID,
 	}
 	err := prov.dashboardService.GetDashboard(ctx, cmd)
 	if err != nil && !errors.Is(err, dashboards.ErrDashboardNotFound) {
@@ -111,22 +110,22 @@ func (prov *defaultAlertRuleProvisioner) getOrCreateFolderUID(
 	// dashboard folder not found. create one.
 	if errors.Is(err, dashboards.ErrDashboardNotFound) {
 		dash := &dashboards.SaveDashboardDTO{}
-		dash.Dashboard = models.NewDashboardFolder(folderName)
+		dash.Dashboard = dashboards.NewDashboardFolder(folderName)
 		dash.Dashboard.IsFolder = true
 		dash.Overwrite = true
-		dash.OrgId = orgID
-		dash.Dashboard.SetUid(util.GenerateShortUID())
+		dash.OrgID = orgID
+		dash.Dashboard.SetUID(util.GenerateShortUID())
 		dbDash, err := prov.dashboardProvService.SaveFolderForProvisionedDashboards(ctx, dash)
 		if err != nil {
 			return "", err
 		}
 
-		return dbDash.Uid, nil
+		return dbDash.UID, nil
 	}
 
 	if !cmd.Result.IsFolder {
 		return "", fmt.Errorf("got invalid response. expected folder, found dashboard")
 	}
 
-	return cmd.Result.Uid, nil
+	return cmd.Result.UID, nil
 }

pkg/services/provisioning/dashboards/file_reader.go

@@ -244,26 +244,26 @@ func (fr *FileReader) saveDashboard(ctx context.Context, path string, folderID i
 
 	// keeps track of which UIDs and titles we have already provisioned
 	dash := jsonFile.dashboard
-	provisioningMetadata.uid = dash.Dashboard.Uid
-	provisioningMetadata.identity = dashboardIdentity{title: dash.Dashboard.Title, folderID: dash.Dashboard.FolderId}
+	provisioningMetadata.uid = dash.Dashboard.UID
+	provisioningMetadata.identity = dashboardIdentity{title: dash.Dashboard.Title, folderID: dash.Dashboard.FolderID}
 
 	if upToDate {
 		return provisioningMetadata, nil
 	}
 
-	if dash.Dashboard.Id != 0 {
+	if dash.Dashboard.ID != 0 {
 		dash.Dashboard.Data.Set("id", nil)
-		dash.Dashboard.Id = 0
+		dash.Dashboard.ID = 0
 	}
 
 	if alreadyProvisioned {
-		dash.Dashboard.SetId(provisionedData.DashboardId)
+		dash.Dashboard.SetID(provisionedData.DashboardId)
 	}
 
 	if !fr.isDatabaseAccessRestricted() {
-		fr.log.Debug("saving new dashboard", "provisioner", fr.Cfg.Name, "file", path, "folderId", dash.Dashboard.FolderId)
-		dp := &models.DashboardProvisioning{
-			ExternalId: path,
+		fr.log.Debug("saving new dashboard", "provisioner", fr.Cfg.Name, "file", path, "folderId", dash.Dashboard.FolderID)
+		dp := &dashboards.DashboardProvisioning{
+			ExternalID: path,
 			Name:       fr.Cfg.Name,
 			Updated:    resolvedFileInfo.ModTime().Unix(),
 			CheckSum:   jsonFile.checkSum,
@@ -274,7 +274,7 @@ func (fr *FileReader) saveDashboard(ctx context.Context, path string, folderID i
 		}
 	} else {
 		fr.log.Warn("Not saving new dashboard due to restricted database access", "provisioner", fr.Cfg.Name,
-			"file", path, "folderId", dash.Dashboard.FolderId)
+			"file", path, "folderId", dash.Dashboard.FolderID)
 	}
 
 	return provisioningMetadata, nil
@@ -300,7 +300,7 @@ func (fr *FileReader) getOrCreateFolderID(ctx context.Context, cfg *config, serv
 		return 0, ErrFolderNameMissing
 	}
 
-	cmd := &models.GetDashboardQuery{Slug: slugify.Slugify(folderName), OrgId: cfg.OrgID}
+	cmd := &dashboards.GetDashboardQuery{Slug: slugify.Slugify(folderName), OrgID: cfg.OrgID}
 	err := fr.dashboardStore.GetDashboard(ctx, cmd)
 
 	if err != nil && !errors.Is(err, dashboards.ErrDashboardNotFound) {
@@ -310,28 +310,28 @@ func (fr *FileReader) getOrCreateFolderID(ctx context.Context, cfg *config, serv
 	// dashboard folder not found. create one.
 	if errors.Is(err, dashboards.ErrDashboardNotFound) {
 		dash := &dashboards.SaveDashboardDTO{}
-		dash.Dashboard = models.NewDashboardFolder(folderName)
+		dash.Dashboard = dashboards.NewDashboardFolder(folderName)
 		dash.Dashboard.IsFolder = true
 		dash.Overwrite = true
-		dash.OrgId = cfg.OrgID
+		dash.OrgID = cfg.OrgID
 		// set dashboard folderUid if given
 		if cfg.FolderUID == accesscontrol.GeneralFolderUID {
 			return 0, dashboards.ErrFolderInvalidUID
 		}
-		dash.Dashboard.SetUid(cfg.FolderUID)
+		dash.Dashboard.SetUID(cfg.FolderUID)
 		dbDash, err := service.SaveFolderForProvisionedDashboards(ctx, dash)
 		if err != nil {
 			return 0, err
 		}
 
-		return dbDash.Id, nil
+		return dbDash.ID, nil
 	}
 
 	if !cmd.Result.IsFolder {
 		return 0, fmt.Errorf("got invalid response. expected folder, found dashboard")
 	}
 
-	return cmd.Result.Id, nil
+	return cmd.Result.ID, nil
 }
 
 func resolveSymlink(fileinfo os.FileInfo, path string) (os.FileInfo, error) {

pkg/services/provisioning/dashboards/file_reader_test.go

@@ -114,8 +114,8 @@ func TestDashboardFileReader(t *testing.T) {
 			cfg.Folder = "Team A"
 
 			fakeService.On("GetProvisionedDashboardData", mock.Anything, configName).Return(nil, nil).Once()
-			fakeService.On("SaveFolderForProvisionedDashboards", mock.Anything, mock.Anything).Return(&models.Dashboard{Id: 1}, nil).Once()
-			fakeService.On("SaveProvisionedDashboard", mock.Anything, mock.Anything, mock.Anything).Return(&models.Dashboard{Id: 2}, nil).Times(2)
+			fakeService.On("SaveFolderForProvisionedDashboards", mock.Anything, mock.Anything).Return(&dashboards.Dashboard{ID: 1}, nil).Once()
+			fakeService.On("SaveProvisionedDashboard", mock.Anything, mock.Anything, mock.Anything).Return(&dashboards.Dashboard{ID: 2}, nil).Times(2)
 
 			reader, err := NewDashboardFileReader(cfg, logger, nil, fakeStore)
 			reader.dashboardProvisioningService = fakeService
@@ -132,7 +132,7 @@ func TestDashboardFileReader(t *testing.T) {
 			inserted := 0
 			fakeService.On("GetProvisionedDashboardData", mock.Anything, configName).Return(nil, nil).Once()
 			fakeService.On("SaveProvisionedDashboard", mock.Anything, mock.Anything, mock.Anything).
-				Return(&models.Dashboard{}, nil).Once().
+				Return(&dashboards.Dashboard{}, nil).Once().
 				Run(func(args mock.Arguments) {
 					inserted++
 				})
@@ -200,7 +200,7 @@ func TestDashboardFileReader(t *testing.T) {
 			}
 
 			fakeService.On("GetProvisionedDashboardData", mock.Anything, configName).Return(provisionedDashboard, nil).Once()
-			fakeService.On("SaveProvisionedDashboard", mock.Anything, mock.Anything, mock.Anything).Return(&models.Dashboard{}, nil).Once()
+			fakeService.On("SaveProvisionedDashboard", mock.Anything, mock.Anything, mock.Anything).Return(&dashboards.Dashboard{}, nil).Once()
 
 			reader, err := NewDashboardFileReader(cfg, logger, nil, fakeStore)
 			reader.dashboardProvisioningService = fakeService
@@ -263,7 +263,7 @@ func TestDashboardFileReader(t *testing.T) {
 			}
 
 			fakeService.On("GetProvisionedDashboardData", mock.Anything, configName).Return(provisionedDashboard, nil).Once()
-			fakeService.On("SaveProvisionedDashboard", mock.Anything, mock.Anything, mock.Anything).Return(&models.Dashboard{}, nil).Once()
+			fakeService.On("SaveProvisionedDashboard", mock.Anything, mock.Anything, mock.Anything).Return(&dashboards.Dashboard{}, nil).Once()
 
 			reader, err := NewDashboardFileReader(cfg, logger, nil, fakeStore)
 			reader.dashboardProvisioningService = fakeService
@@ -278,7 +278,7 @@ func TestDashboardFileReader(t *testing.T) {
 			cfg.Options["path"] = containingID
 
 			fakeService.On("GetProvisionedDashboardData", mock.Anything, configName).Return(nil, nil).Once()
-			fakeService.On("SaveProvisionedDashboard", mock.Anything, mock.Anything, mock.Anything).Return(&models.Dashboard{}, nil).Once()
+			fakeService.On("SaveProvisionedDashboard", mock.Anything, mock.Anything, mock.Anything).Return(&dashboards.Dashboard{}, nil).Once()
 
 			reader, err := NewDashboardFileReader(cfg, logger, nil, fakeStore)
 			reader.dashboardProvisioningService = fakeService
@@ -294,8 +294,8 @@ func TestDashboardFileReader(t *testing.T) {
 			cfg.Options["foldersFromFilesStructure"] = true
 
 			fakeService.On("GetProvisionedDashboardData", mock.Anything, configName).Return(nil, nil).Once()
-			fakeService.On("SaveFolderForProvisionedDashboards", mock.Anything, mock.Anything).Return(&models.Dashboard{}, nil).Times(2)
-			fakeService.On("SaveProvisionedDashboard", mock.Anything, mock.Anything, mock.Anything).Return(&models.Dashboard{}, nil).Times(3)
+			fakeService.On("SaveFolderForProvisionedDashboards", mock.Anything, mock.Anything).Return(&dashboards.Dashboard{}, nil).Times(2)
+			fakeService.On("SaveProvisionedDashboard", mock.Anything, mock.Anything, mock.Anything).Return(&dashboards.Dashboard{}, nil).Times(3)
 
 			reader, err := NewDashboardFileReader(cfg, logger, nil, fakeStore)
 			reader.dashboardProvisioningService = fakeService
@@ -332,8 +332,8 @@ func TestDashboardFileReader(t *testing.T) {
 			cfg2 := &config{Name: "2", Type: "file", OrgID: 1, Folder: "f2", Options: map[string]interface{}{"path": containingID}}
 
 			fakeService.On("GetProvisionedDashboardData", mock.Anything, mock.AnythingOfType("string")).Return(nil, nil).Times(2)
-			fakeService.On("SaveFolderForProvisionedDashboards", mock.Anything, mock.Anything).Return(&models.Dashboard{}, nil).Times(2)
-			fakeService.On("SaveProvisionedDashboard", mock.Anything, mock.Anything, mock.Anything).Return(&models.Dashboard{}, nil).Times(2)
+			fakeService.On("SaveFolderForProvisionedDashboards", mock.Anything, mock.Anything).Return(&dashboards.Dashboard{}, nil).Times(2)
+			fakeService.On("SaveProvisionedDashboard", mock.Anything, mock.Anything, mock.Anything).Return(&dashboards.Dashboard{}, nil).Times(2)
 
 			reader1, err := NewDashboardFileReader(cfg1, logger, nil, fakeStore)
 			reader1.dashboardProvisioningService = fakeService
@@ -380,7 +380,7 @@ func TestDashboardFileReader(t *testing.T) {
 				"folder": defaultDashboards,
 			},
 		}
-		fakeService.On("SaveFolderForProvisionedDashboards", mock.Anything, mock.Anything).Return(&models.Dashboard{Id: 1}, nil).Once()
+		fakeService.On("SaveFolderForProvisionedDashboards", mock.Anything, mock.Anything).Return(&dashboards.Dashboard{ID: 1}, nil).Once()
 
 		r, err := NewDashboardFileReader(cfg, logger, nil, fakeStore)
 		require.NoError(t, err)
@@ -453,7 +453,7 @@ func TestDashboardFileReader(t *testing.T) {
 
 			fakeService.On("GetProvisionedDashboardData", mock.Anything, configName).Return(provisionedDashboard, nil).Once()
 			fakeService.On("UnprovisionDashboard", mock.Anything, mock.Anything).Return(nil).Once()
-			fakeService.On("SaveProvisionedDashboard", mock.Anything, mock.Anything, mock.Anything).Return(&models.Dashboard{}, nil).Once()
+			fakeService.On("SaveProvisionedDashboard", mock.Anything, mock.Anything, mock.Anything).Return(&dashboards.Dashboard{}, nil).Once()
 
 			cfg.DisableDeletion = true
 
@@ -469,7 +469,7 @@ func TestDashboardFileReader(t *testing.T) {
 			setupFakeService()
 
 			fakeService.On("GetProvisionedDashboardData", mock.Anything, configName).Return(provisionedDashboard, nil).Once()
-			fakeService.On("SaveProvisionedDashboard", mock.Anything, mock.Anything, mock.Anything).Return(&models.Dashboard{}, nil).Once()
+			fakeService.On("SaveProvisionedDashboard", mock.Anything, mock.Anything, mock.Anything).Return(&dashboards.Dashboard{}, nil).Once()
 			fakeService.On("DeleteProvisionedDashboard", mock.Anything, mock.Anything, mock.Anything).Return(nil).Once()
 
 			reader, err := NewDashboardFileReader(cfg, logger, nil, fakeStore)
@@ -513,6 +513,6 @@ func (ffi FakeFileInfo) Sys() interface{} {
 
 type fakeDashboardStore struct{}
 
-func (fds *fakeDashboardStore) GetDashboard(_ context.Context, _ *models.GetDashboardQuery) error {
+func (fds *fakeDashboardStore) GetDashboard(_ context.Context, _ *dashboards.GetDashboardQuery) error {
 	return dashboards.ErrDashboardNotFound
 }

pkg/services/provisioning/dashboards/types.go

@@ -5,7 +5,6 @@ import (
 	"time"
 
 	"github.com/grafana/grafana/pkg/components/simplejson"
-	"github.com/grafana/grafana/pkg/models"
 	"github.com/grafana/grafana/pkg/services/dashboards"
 	"github.com/grafana/grafana/pkg/services/provisioning/values"
 )
@@ -59,12 +58,12 @@ type configs struct {
 
 func createDashboardJSON(data *simplejson.Json, lastModified time.Time, cfg *config, folderID int64) (*dashboards.SaveDashboardDTO, error) {
 	dash := &dashboards.SaveDashboardDTO{}
-	dash.Dashboard = models.NewDashboardFromJson(data)
+	dash.Dashboard = dashboards.NewDashboardFromJson(data)
 	dash.UpdatedAt = lastModified
 	dash.Overwrite = true
-	dash.OrgId = cfg.OrgID
-	dash.Dashboard.OrgId = cfg.OrgID
-	dash.Dashboard.FolderId = folderID
+	dash.OrgID = cfg.OrgID
+	dash.Dashboard.OrgID = cfg.OrgID
+	dash.Dashboard.FolderID = folderID
 
 	if dash.Dashboard.Title == "" {
 		return nil, dashboards.ErrDashboardTitleEmpty

pkg/services/provisioning/dashboards/validator_test.go

@@ -37,9 +37,9 @@ func TestDuplicatesValidator(t *testing.T) {
 		fakeStore := &fakeDashboardStore{}
 		r, err := NewDashboardFileReader(cfg, logger, nil, fakeStore)
 		require.NoError(t, err)
-		fakeService.On("SaveFolderForProvisionedDashboards", mock.Anything, mock.Anything).Return(&models.Dashboard{}, nil).Times(6)
+		fakeService.On("SaveFolderForProvisionedDashboards", mock.Anything, mock.Anything).Return(&dashboards.Dashboard{}, nil).Times(6)
 		fakeService.On("GetProvisionedDashboardData", mock.Anything, mock.AnythingOfType("string")).Return([]*models.DashboardProvisioning{}, nil).Times(4)
-		fakeService.On("SaveProvisionedDashboard", mock.Anything, mock.Anything, mock.Anything).Return(&models.Dashboard{}, nil).Times(5)
+		fakeService.On("SaveProvisionedDashboard", mock.Anything, mock.Anything, mock.Anything).Return(&dashboards.Dashboard{}, nil).Times(5)
 		folderID, err := r.getOrCreateFolderID(context.Background(), cfg, fakeService, folderName)
 		require.NoError(t, err)
 
@@ -151,9 +151,9 @@ func TestDuplicatesValidator(t *testing.T) {
 	})
 
 	t.Run("Duplicates validator should restrict write access only for readers with duplicates", func(t *testing.T) {
-		fakeService.On("SaveFolderForProvisionedDashboards", mock.Anything, mock.Anything).Return(&models.Dashboard{}, nil).Times(5)
+		fakeService.On("SaveFolderForProvisionedDashboards", mock.Anything, mock.Anything).Return(&dashboards.Dashboard{}, nil).Times(5)
 		fakeService.On("GetProvisionedDashboardData", mock.Anything, mock.AnythingOfType("string")).Return([]*models.DashboardProvisioning{}, nil).Times(3)
-		fakeService.On("SaveProvisionedDashboard", mock.Anything, mock.Anything, mock.Anything).Return(&models.Dashboard{}, nil).Times(5)
+		fakeService.On("SaveProvisionedDashboard", mock.Anything, mock.Anything, mock.Anything).Return(&dashboards.Dashboard{}, nil).Times(5)
 		fakeStore := &fakeDashboardStore{}
 
 		cfg1 := &config{

pkg/services/provisioning/utils/utils.go

@@ -5,12 +5,12 @@ import (
 	"errors"
 	"fmt"
 
-	"github.com/grafana/grafana/pkg/models"
+	"github.com/grafana/grafana/pkg/services/dashboards"
 	"github.com/grafana/grafana/pkg/services/org"
 )
 
 type DashboardStore interface {
-	GetDashboard(context.Context, *models.GetDashboardQuery) error
+	GetDashboard(context.Context, *dashboards.GetDashboardQuery) error
 }
 
 func CheckOrgExists(ctx context.Context, orgService org.Service, orgID int64) error {

pkg/services/publicdashboards/api/query.go

@@ -40,7 +40,7 @@ func (api *Api) ViewPublicDashboard(c *models.ReqContext) response.Response {
 		Updated:                    dash.Updated,
 		Version:                    dash.Version,
 		IsFolder:                   false,
-		FolderId:                   dash.FolderId,
+		FolderId:                   dash.FolderID,
 		PublicDashboardAccessToken: pubdash.AccessToken,
 	}
 	dash.Data.Get("timepicker").Set("hidden", !pubdash.TimeSelectionEnabled)

pkg/services/publicdashboards/api/query_test.go

@@ -17,9 +17,9 @@ import (
 	"github.com/grafana/grafana/pkg/infra/db"
 	"github.com/grafana/grafana/pkg/infra/localcache"
 	"github.com/grafana/grafana/pkg/infra/log"
-	"github.com/grafana/grafana/pkg/models"
 	acmock "github.com/grafana/grafana/pkg/services/accesscontrol/mock"
 	"github.com/grafana/grafana/pkg/services/annotations/annotationstest"
+	"github.com/grafana/grafana/pkg/services/dashboards"
 	dashboardStore "github.com/grafana/grafana/pkg/services/dashboards/database"
 	"github.com/grafana/grafana/pkg/services/datasources"
 	datasourcesService "github.com/grafana/grafana/pkg/services/datasources/service"
@@ -46,7 +46,7 @@ func TestAPIViewPublicDashboard(t *testing.T) {
 		Name                 string
 		AccessToken          string
 		ExpectedHttpResponse int
-		DashboardResult      *models.Dashboard
+		DashboardResult      *dashboards.Dashboard
 		Err                  error
 		FixedErrorResponse   string
 	}{
@@ -54,7 +54,7 @@ func TestAPIViewPublicDashboard(t *testing.T) {
 			Name:                 "It gets a public dashboard",
 			AccessToken:          validAccessToken,
 			ExpectedHttpResponse: http.StatusOK,
-			DashboardResult: &models.Dashboard{
+			DashboardResult: &dashboards.Dashboard{
 				Data: simplejson.NewFromAny(map[string]interface{}{
 					"Uid": DashboardUid,
 				}),
@@ -279,9 +279,9 @@ func TestIntegrationUnauthenticatedUserCanGetPubdashPanelQueryData(t *testing.T)
 	})
 
 	// Create Dashboard
-	saveDashboardCmd := models.SaveDashboardCommand{
-		OrgId:    1,
-		FolderId: 1,
+	saveDashboardCmd := dashboards.SaveDashboardCommand{
+		OrgID:    1,
+		FolderID: 1,
 		IsFolder: false,
 		Dashboard: simplejson.NewFromAny(map[string]interface{}{
 			"id":    nil,
@@ -311,8 +311,8 @@ func TestIntegrationUnauthenticatedUserCanGetPubdashPanelQueryData(t *testing.T)
 
 	// Create public dashboard
 	savePubDashboardCmd := &SavePublicDashboardDTO{
-		DashboardUid: dashboard.Uid,
-		OrgId:        dashboard.OrgId,
+		DashboardUid: dashboard.UID,
+		OrgId:        dashboard.OrgID,
 		PublicDashboard: &PublicDashboard{
 			IsEnabled: true,
 		},

pkg/services/publicdashboards/database/database.go

@@ -6,7 +6,6 @@ import (
 
 	"github.com/grafana/grafana/pkg/infra/db"
 	"github.com/grafana/grafana/pkg/infra/log"
-	"github.com/grafana/grafana/pkg/models"
 	"github.com/grafana/grafana/pkg/services/dashboards"
 	"github.com/grafana/grafana/pkg/services/publicdashboards"
 	. "github.com/grafana/grafana/pkg/services/publicdashboards/models"
@@ -56,8 +55,8 @@ func (d *PublicDashboardStoreImpl) FindAll(ctx context.Context, orgId int64) ([]
 }
 
 // FindDashboard returns a dashboard by orgId and dashboardUid
-func (d *PublicDashboardStoreImpl) FindDashboard(ctx context.Context, orgId int64, dashboardUid string) (*models.Dashboard, error) {
-	dashboard := &models.Dashboard{OrgId: orgId, Uid: dashboardUid}
+func (d *PublicDashboardStoreImpl) FindDashboard(ctx context.Context, orgId int64, dashboardUid string) (*dashboards.Dashboard, error) {
+	dashboard := &dashboards.Dashboard{OrgID: orgId, UID: dashboardUid}
 
 	var found bool
 	err := d.sqlStore.WithDbSession(ctx, func(sess *db.Session) error {

pkg/services/publicdashboards/database/database_test.go

@@ -7,7 +7,6 @@ import (
 
 	"github.com/grafana/grafana/pkg/components/simplejson"
 	"github.com/grafana/grafana/pkg/infra/db"
-	"github.com/grafana/grafana/pkg/models"
 	"github.com/grafana/grafana/pkg/services/dashboards"
 	dashboardsDB "github.com/grafana/grafana/pkg/services/dashboards/database"
 	"github.com/grafana/grafana/pkg/services/featuremgmt"
@@ -48,9 +47,9 @@ func TestIntegrationListPublicDashboard(t *testing.T) {
 	cDash := insertTestDashboard(t, dashboardStore, "c", orgId, 0, true)
 
 	// these are in order of how they should be returned from ListPUblicDashboards
-	a := insertPublicDashboard(t, publicdashboardStore, bDash.Uid, orgId, true)
-	b := insertPublicDashboard(t, publicdashboardStore, cDash.Uid, orgId, true)
-	c := insertPublicDashboard(t, publicdashboardStore, aDash.Uid, orgId, false)
+	a := insertPublicDashboard(t, publicdashboardStore, bDash.UID, orgId, true)
+	b := insertPublicDashboard(t, publicdashboardStore, cDash.UID, orgId, true)
+	c := insertPublicDashboard(t, publicdashboardStore, aDash.UID, orgId, false)
 
 	// this is case that can happen as of now, however, postgres and mysql sort
 	// null in the exact opposite fashion and there is no shared syntax to sort
@@ -77,7 +76,7 @@ func TestIntegrationFindDashboard(t *testing.T) {
 	var cfg *setting.Cfg
 	var dashboardStore *dashboardsDB.DashboardStore
 	var publicdashboardStore *PublicDashboardStoreImpl
-	var savedDashboard *models.Dashboard
+	var savedDashboard *dashboards.Dashboard
 
 	setup := func() {
 		sqlStore, cfg = db.InitTestDBwithCfg(t)
@@ -92,10 +91,10 @@ func TestIntegrationFindDashboard(t *testing.T) {
 	t.Run("FindDashboard can get original dashboard by uid", func(t *testing.T) {
 		setup()
 
-		dashboard, err := publicdashboardStore.FindDashboard(context.Background(), savedDashboard.OrgId, savedDashboard.Uid)
+		dashboard, err := publicdashboardStore.FindDashboard(context.Background(), savedDashboard.OrgID, savedDashboard.UID)
 
 		require.NoError(t, err)
-		require.Equal(t, savedDashboard.Uid, dashboard.Uid)
+		require.Equal(t, savedDashboard.UID, dashboard.UID)
 	})
 }
 
@@ -107,7 +106,7 @@ func TestIntegrationExistsEnabledByAccessToken(t *testing.T) {
 	var cfg *setting.Cfg
 	var dashboardStore *dashboardsDB.DashboardStore
 	var publicdashboardStore *PublicDashboardStoreImpl
-	var savedDashboard *models.Dashboard
+	var savedDashboard *dashboards.Dashboard
 
 	setup := func() {
 		sqlStore, cfg = db.InitTestDBwithCfg(t)
@@ -125,8 +124,8 @@ func TestIntegrationExistsEnabledByAccessToken(t *testing.T) {
 			PublicDashboard: PublicDashboard{
 				IsEnabled:    true,
 				Uid:          "abc123",
-				DashboardUid: savedDashboard.Uid,
-				OrgId:        savedDashboard.OrgId,
+				DashboardUid: savedDashboard.UID,
+				OrgId:        savedDashboard.OrgID,
 				CreatedAt:    time.Now(),
 				CreatedBy:    7,
 				AccessToken:  "accessToken",
@@ -147,8 +146,8 @@ func TestIntegrationExistsEnabledByAccessToken(t *testing.T) {
 			PublicDashboard: PublicDashboard{
 				IsEnabled:    false,
 				Uid:          "abc123",
-				DashboardUid: savedDashboard.Uid,
-				OrgId:        savedDashboard.OrgId,
+				DashboardUid: savedDashboard.UID,
+				OrgId:        savedDashboard.OrgID,
 				CreatedAt:    time.Now(),
 				CreatedBy:    7,
 				AccessToken:  "accessToken",
@@ -180,7 +179,7 @@ func TestIntegrationExistsEnabledByDashboardUid(t *testing.T) {
 	var cfg *setting.Cfg
 	var dashboardStore *dashboardsDB.DashboardStore
 	var publicdashboardStore *PublicDashboardStoreImpl
-	var savedDashboard *models.Dashboard
+	var savedDashboard *dashboards.Dashboard
 
 	setup := func() {
 		sqlStore, cfg = db.InitTestDBwithCfg(t)
@@ -199,8 +198,8 @@ func TestIntegrationExistsEnabledByDashboardUid(t *testing.T) {
 			PublicDashboard: PublicDashboard{
 				IsEnabled:    true,
 				Uid:          "abc123",
-				DashboardUid: savedDashboard.Uid,
-				OrgId:        savedDashboard.OrgId,
+				DashboardUid: savedDashboard.UID,
+				OrgId:        savedDashboard.OrgID,
 				CreatedAt:    time.Now(),
 				CreatedBy:    7,
 				AccessToken:  "NOTAREALUUID",
@@ -208,7 +207,7 @@ func TestIntegrationExistsEnabledByDashboardUid(t *testing.T) {
 		})
 		require.NoError(t, err)
 
-		res, err := publicdashboardStore.ExistsEnabledByDashboardUid(context.Background(), savedDashboard.Uid)
+		res, err := publicdashboardStore.ExistsEnabledByDashboardUid(context.Background(), savedDashboard.UID)
 		require.NoError(t, err)
 
 		require.True(t, res)
@@ -221,8 +220,8 @@ func TestIntegrationExistsEnabledByDashboardUid(t *testing.T) {
 			PublicDashboard: PublicDashboard{
 				IsEnabled:    false,
 				Uid:          "abc123",
-				DashboardUid: savedDashboard.Uid,
-				OrgId:        savedDashboard.OrgId,
+				DashboardUid: savedDashboard.UID,
+				OrgId:        savedDashboard.OrgID,
 				CreatedAt:    time.Now(),
 				CreatedBy:    7,
 				AccessToken:  "NOTAREALUUID",
@@ -230,7 +229,7 @@ func TestIntegrationExistsEnabledByDashboardUid(t *testing.T) {
 		})
 		require.NoError(t, err)
 
-		res, err := publicdashboardStore.ExistsEnabledByDashboardUid(context.Background(), savedDashboard.Uid)
+		res, err := publicdashboardStore.ExistsEnabledByDashboardUid(context.Background(), savedDashboard.UID)
 		require.NoError(t, err)
 
 		require.False(t, res)
@@ -245,7 +244,7 @@ func TestIntegrationFindByDashboardUid(t *testing.T) {
 	var cfg *setting.Cfg
 	var dashboardStore *dashboardsDB.DashboardStore
 	var publicdashboardStore *PublicDashboardStoreImpl
-	var savedDashboard *models.Dashboard
+	var savedDashboard *dashboards.Dashboard
 
 	setup := func() {
 		sqlStore, cfg = db.InitTestDBwithCfg(t)
@@ -259,15 +258,15 @@ func TestIntegrationFindByDashboardUid(t *testing.T) {
 
 	t.Run("returns public dashboard by dashboardUid", func(t *testing.T) {
 		setup()
-		savedPubdash := insertPublicDashboard(t, publicdashboardStore, savedDashboard.Uid, savedDashboard.OrgId, false)
-		pubdash, err := publicdashboardStore.FindByDashboardUid(context.Background(), savedDashboard.OrgId, savedDashboard.Uid)
+		savedPubdash := insertPublicDashboard(t, publicdashboardStore, savedDashboard.UID, savedDashboard.OrgID, false)
+		pubdash, err := publicdashboardStore.FindByDashboardUid(context.Background(), savedDashboard.OrgID, savedDashboard.UID)
 		require.NoError(t, err)
 		assert.Equal(t, savedPubdash, pubdash)
 	})
 
 	t.Run("returns nil when identifier is not set", func(t *testing.T) {
 		setup()
-		pubdash, err := publicdashboardStore.FindByDashboardUid(context.Background(), savedDashboard.OrgId, "")
+		pubdash, err := publicdashboardStore.FindByDashboardUid(context.Background(), savedDashboard.OrgID, "")
 		assert.Nil(t, err)
 		assert.Nil(t, pubdash)
 	})
@@ -278,8 +277,8 @@ func TestIntegrationFindByDashboardUid(t *testing.T) {
 			PublicDashboard: PublicDashboard{
 				IsEnabled:    true,
 				Uid:          "pubdash-uid",
-				DashboardUid: savedDashboard.Uid,
-				OrgId:        savedDashboard.OrgId,
+				DashboardUid: savedDashboard.UID,
+				OrgId:        savedDashboard.OrgID,
 				TimeSettings: DefaultTimeSettings,
 				CreatedAt:    DefaultTime,
 				CreatedBy:    7,
@@ -291,7 +290,7 @@ func TestIntegrationFindByDashboardUid(t *testing.T) {
 		require.NoError(t, err)
 
 		// retrieve from db
-		pubdash, err := publicdashboardStore.FindByDashboardUid(context.Background(), savedDashboard.OrgId, savedDashboard.Uid)
+		pubdash, err := publicdashboardStore.FindByDashboardUid(context.Background(), savedDashboard.OrgID, savedDashboard.UID)
 		require.NoError(t, err)
 
 		assert.True(t, assert.ObjectsAreEqualValues(&cmd.PublicDashboard, pubdash))
@@ -313,7 +312,7 @@ func TestIntegrationFindByAccessToken(t *testing.T) {
 	var cfg *setting.Cfg
 	var dashboardStore *dashboardsDB.DashboardStore
 	var publicdashboardStore *PublicDashboardStoreImpl
-	var savedDashboard *models.Dashboard
+	var savedDashboard *dashboards.Dashboard
 	var err error
 
 	setup := func() {
@@ -326,7 +325,7 @@ func TestIntegrationFindByAccessToken(t *testing.T) {
 
 	t.Run("returns public dashboard by accessToken", func(t *testing.T) {
 		setup()
-		savedPubdash := insertPublicDashboard(t, publicdashboardStore, savedDashboard.Uid, savedDashboard.OrgId, false)
+		savedPubdash := insertPublicDashboard(t, publicdashboardStore, savedDashboard.UID, savedDashboard.OrgID, false)
 		pubdash, err := publicdashboardStore.FindByAccessToken(context.Background(), savedPubdash.AccessToken)
 		require.NoError(t, err)
 		assert.Equal(t, savedPubdash, pubdash)
@@ -345,8 +344,8 @@ func TestIntegrationFindByAccessToken(t *testing.T) {
 			PublicDashboard: PublicDashboard{
 				IsEnabled:    true,
 				Uid:          "pubdash-uid",
-				DashboardUid: savedDashboard.Uid,
-				OrgId:        savedDashboard.OrgId,
+				DashboardUid: savedDashboard.UID,
+				OrgId:        savedDashboard.OrgID,
 				TimeSettings: DefaultTimeSettings,
 				CreatedAt:    DefaultTime,
 				CreatedBy:    7,
@@ -381,8 +380,8 @@ func TestIntegrationCreatePublicDashboard(t *testing.T) {
 	var cfg *setting.Cfg
 	var dashboardStore *dashboardsDB.DashboardStore
 	var publicdashboardStore *PublicDashboardStoreImpl
-	var savedDashboard *models.Dashboard
-	var savedDashboard2 *models.Dashboard
+	var savedDashboard *dashboards.Dashboard
+	var savedDashboard2 *dashboards.Dashboard
 
 	setup := func() {
 		sqlStore, cfg = db.InitTestDBwithCfg(t, db.InitTestDBOpt{FeatureFlags: []string{featuremgmt.FlagPublicDashboards}})
@@ -393,7 +392,7 @@ func TestIntegrationCreatePublicDashboard(t *testing.T) {
 		publicdashboardStore = ProvideStore(sqlStore)
 		savedDashboard = insertTestDashboard(t, dashboardStore, "testDashie", 1, 0, true)
 		savedDashboard2 = insertTestDashboard(t, dashboardStore, "testDashie2", 1, 0, true)
-		insertPublicDashboard(t, publicdashboardStore, savedDashboard2.Uid, savedDashboard2.OrgId, false)
+		insertPublicDashboard(t, publicdashboardStore, savedDashboard2.UID, savedDashboard2.OrgID, false)
 	}
 
 	t.Run("saves new public dashboard", func(t *testing.T) {
@@ -404,8 +403,8 @@ func TestIntegrationCreatePublicDashboard(t *testing.T) {
 				AnnotationsEnabled:   true,
 				TimeSelectionEnabled: true,
 				Uid:                  "pubdash-uid",
-				DashboardUid:         savedDashboard.Uid,
-				OrgId:                savedDashboard.OrgId,
+				DashboardUid:         savedDashboard.UID,
+				OrgId:                savedDashboard.OrgID,
 				TimeSettings:         DefaultTimeSettings,
 				CreatedAt:            DefaultTime,
 				CreatedBy:            7,
@@ -416,7 +415,7 @@ func TestIntegrationCreatePublicDashboard(t *testing.T) {
 		require.NoError(t, err)
 		assert.EqualValues(t, affectedRows, 1)
 
-		pubdash, err := publicdashboardStore.FindByDashboardUid(context.Background(), savedDashboard.OrgId, savedDashboard.Uid)
+		pubdash, err := publicdashboardStore.FindByDashboardUid(context.Background(), savedDashboard.OrgID, savedDashboard.UID)
 		require.NoError(t, err)
 		assert.Equal(t, pubdash.AccessToken, "NOTAREALUUID")
 		assert.True(t, pubdash.IsEnabled)
@@ -424,7 +423,7 @@ func TestIntegrationCreatePublicDashboard(t *testing.T) {
 		assert.True(t, pubdash.TimeSelectionEnabled)
 
 		// verify we didn't update all dashboards
-		pubdash2, err := publicdashboardStore.FindByDashboardUid(context.Background(), savedDashboard2.OrgId, savedDashboard2.Uid)
+		pubdash2, err := publicdashboardStore.FindByDashboardUid(context.Background(), savedDashboard2.OrgID, savedDashboard2.UID)
 		require.NoError(t, err)
 		assert.False(t, pubdash2.IsEnabled)
 	})
@@ -436,7 +435,7 @@ func TestIntegrationCreatePublicDashboard(t *testing.T) {
 				IsEnabled:    true,
 				Uid:          "pubdash-uid",
 				DashboardUid: "",
-				OrgId:        savedDashboard.OrgId,
+				OrgId:        savedDashboard.OrgID,
 				TimeSettings: DefaultTimeSettings,
 				CreatedAt:    DefaultTime,
 				CreatedBy:    7,
@@ -458,8 +457,8 @@ func TestIntegrationUpdatePublicDashboard(t *testing.T) {
 	var cfg *setting.Cfg
 	var dashboardStore *dashboardsDB.DashboardStore
 	var publicdashboardStore *PublicDashboardStoreImpl
-	var savedDashboard *models.Dashboard
-	var anotherSavedDashboard *models.Dashboard
+	var savedDashboard *dashboards.Dashboard
+	var anotherSavedDashboard *dashboards.Dashboard
 	var err error
 
 	setup := func() {
@@ -479,8 +478,8 @@ func TestIntegrationUpdatePublicDashboard(t *testing.T) {
 		cmd := SavePublicDashboardCommand{
 			PublicDashboard: PublicDashboard{
 				Uid:                  pdUid,
-				DashboardUid:         savedDashboard.Uid,
-				OrgId:                savedDashboard.OrgId,
+				DashboardUid:         savedDashboard.UID,
+				OrgId:                savedDashboard.OrgID,
 				IsEnabled:            false,
 				AnnotationsEnabled:   true,
 				TimeSelectionEnabled: true,
@@ -498,8 +497,8 @@ func TestIntegrationUpdatePublicDashboard(t *testing.T) {
 		cmd = SavePublicDashboardCommand{
 			PublicDashboard: PublicDashboard{
 				Uid:                  anotherPdUid,
-				DashboardUid:         anotherSavedDashboard.Uid,
-				OrgId:                anotherSavedDashboard.OrgId,
+				DashboardUid:         anotherSavedDashboard.UID,
+				OrgId:                anotherSavedDashboard.OrgID,
 				IsEnabled:            true,
 				AnnotationsEnabled:   false,
 				TimeSelectionEnabled: false,
@@ -515,8 +514,8 @@ func TestIntegrationUpdatePublicDashboard(t *testing.T) {
 
 		updatedPublicDashboard := PublicDashboard{
 			Uid:                  pdUid,
-			DashboardUid:         savedDashboard.Uid,
-			OrgId:                savedDashboard.OrgId,
+			DashboardUid:         savedDashboard.UID,
+			OrgId:                savedDashboard.OrgID,
 			IsEnabled:            false,
 			AnnotationsEnabled:   true,
 			TimeSelectionEnabled: true,
@@ -532,7 +531,7 @@ func TestIntegrationUpdatePublicDashboard(t *testing.T) {
 		assert.EqualValues(t, rowsAffected, 1)
 
 		// updated dashboard should have changed
-		pdRetrieved, err := publicdashboardStore.FindByDashboardUid(context.Background(), savedDashboard.OrgId, savedDashboard.Uid)
+		pdRetrieved, err := publicdashboardStore.FindByDashboardUid(context.Background(), savedDashboard.OrgID, savedDashboard.UID)
 		require.NoError(t, err)
 
 		assert.Equal(t, updatedPublicDashboard.UpdatedAt, pdRetrieved.UpdatedAt)
@@ -543,7 +542,7 @@ func TestIntegrationUpdatePublicDashboard(t *testing.T) {
 		assert.Equal(t, updatedPublicDashboard.TimeSelectionEnabled, pdRetrieved.TimeSelectionEnabled)
 
 		// not updated dashboard shouldn't have changed
-		pdNotUpdatedRetrieved, err := publicdashboardStore.FindByDashboardUid(context.Background(), anotherSavedDashboard.OrgId, anotherSavedDashboard.Uid)
+		pdNotUpdatedRetrieved, err := publicdashboardStore.FindByDashboardUid(context.Background(), anotherSavedDashboard.OrgID, anotherSavedDashboard.UID)
 		require.NoError(t, err)
 		assert.NotEqual(t, updatedPublicDashboard.UpdatedAt, pdNotUpdatedRetrieved.UpdatedAt)
 		assert.NotEqual(t, updatedPublicDashboard.IsEnabled, pdNotUpdatedRetrieved.IsEnabled)
@@ -559,7 +558,7 @@ func TestIntegrationGetOrgIdByAccessToken(t *testing.T) {
 	var cfg *setting.Cfg
 	var dashboardStore *dashboardsDB.DashboardStore
 	var publicdashboardStore *PublicDashboardStoreImpl
-	var savedDashboard *models.Dashboard
+	var savedDashboard *dashboards.Dashboard
 	var err error
 
 	setup := func() {
@@ -576,8 +575,8 @@ func TestIntegrationGetOrgIdByAccessToken(t *testing.T) {
 			PublicDashboard: PublicDashboard{
 				IsEnabled:    true,
 				Uid:          "abc123",
-				DashboardUid: savedDashboard.Uid,
-				OrgId:        savedDashboard.OrgId,
+				DashboardUid: savedDashboard.UID,
+				OrgId:        savedDashboard.OrgID,
 				CreatedAt:    time.Now(),
 				CreatedBy:    7,
 				AccessToken:  "accessToken",
@@ -589,7 +588,7 @@ func TestIntegrationGetOrgIdByAccessToken(t *testing.T) {
 		orgId, err := publicdashboardStore.GetOrgIdByAccessToken(context.Background(), "accessToken")
 		require.NoError(t, err)
 
-		assert.Equal(t, savedDashboard.OrgId, orgId)
+		assert.Equal(t, savedDashboard.OrgID, orgId)
 	})
 
 	t.Run("GetOrgIdByAccessToken will return 0 when IsEnabled=false", func(t *testing.T) {
@@ -598,8 +597,8 @@ func TestIntegrationGetOrgIdByAccessToken(t *testing.T) {
 			PublicDashboard: PublicDashboard{
 				IsEnabled:    false,
 				Uid:          "abc123",
-				DashboardUid: savedDashboard.Uid,
-				OrgId:        savedDashboard.OrgId,
+				DashboardUid: savedDashboard.UID,
+				OrgId:        savedDashboard.OrgID,
 				CreatedAt:    time.Now(),
 				CreatedBy:    7,
 				AccessToken:  "accessToken",
@@ -611,7 +610,7 @@ func TestIntegrationGetOrgIdByAccessToken(t *testing.T) {
 
 		orgId, err := publicdashboardStore.GetOrgIdByAccessToken(context.Background(), "accessToken")
 		require.NoError(t, err)
-		assert.NotEqual(t, savedDashboard.OrgId, orgId)
+		assert.NotEqual(t, savedDashboard.OrgID, orgId)
 	})
 
 	t.Run("GetOrgIdByAccessToken will return 0 when no public dashboard has matching access token", func(t *testing.T) {
@@ -619,7 +618,7 @@ func TestIntegrationGetOrgIdByAccessToken(t *testing.T) {
 
 		orgId, err := publicdashboardStore.GetOrgIdByAccessToken(context.Background(), "nonExistentAccessToken")
 		require.NoError(t, err)
-		assert.NotEqual(t, savedDashboard.OrgId, orgId)
+		assert.NotEqual(t, savedDashboard.OrgID, orgId)
 	})
 }
 
@@ -631,7 +630,7 @@ func TestIntegrationDelete(t *testing.T) {
 	var cfg *setting.Cfg
 	var dashboardStore *dashboardsDB.DashboardStore
 	var publicdashboardStore *PublicDashboardStoreImpl
-	var savedDashboard *models.Dashboard
+	var savedDashboard *dashboards.Dashboard
 	var savedPublicDashboard *PublicDashboard
 	var err error
 
@@ -641,7 +640,7 @@ func TestIntegrationDelete(t *testing.T) {
 		require.NoError(t, err)
 		publicdashboardStore = ProvideStore(sqlStore)
 		savedDashboard = insertTestDashboard(t, dashboardStore, "testDashie", 1, 0, true)
-		savedPublicDashboard = insertPublicDashboard(t, publicdashboardStore, savedDashboard.Uid, savedDashboard.OrgId, true)
+		savedPublicDashboard = insertPublicDashboard(t, publicdashboardStore, savedDashboard.UID, savedDashboard.OrgID, true)
 	}
 
 	t.Run("Delete success", func(t *testing.T) {
@@ -668,11 +667,11 @@ func TestIntegrationDelete(t *testing.T) {
 
 // helper function to insert a dashboard
 func insertTestDashboard(t *testing.T, dashboardStore *dashboardsDB.DashboardStore, title string, orgId int64,
-	folderId int64, isFolder bool, tags ...interface{}) *models.Dashboard {
+	folderId int64, isFolder bool, tags ...interface{}) *dashboards.Dashboard {
 	t.Helper()
-	cmd := models.SaveDashboardCommand{
-		OrgId:    orgId,
-		FolderId: folderId,
+	cmd := dashboards.SaveDashboardCommand{
+		OrgID:    orgId,
+		FolderID: folderId,
 		IsFolder: isFolder,
 		Dashboard: simplejson.NewFromAny(map[string]interface{}{
 			"id":    nil,
@@ -683,8 +682,8 @@ func insertTestDashboard(t *testing.T, dashboardStore *dashboardsDB.DashboardSto
 	dash, err := dashboardStore.SaveDashboard(context.Background(), cmd)
 	require.NoError(t, err)
 	require.NotNil(t, dash)
-	dash.Data.Set("id", dash.Id)
-	dash.Data.Set("uid", dash.Uid)
+	dash.Data.Set("id", dash.ID)
+	dash.Data.Set("uid", dash.UID)
 	return dash
 }
 

pkg/services/publicdashboards/models/models.go

@@ -6,7 +6,7 @@ import (
 	"time"
 
 	"github.com/grafana/grafana/pkg/kinds/dashboard"
-	"github.com/grafana/grafana/pkg/models"
+	"github.com/grafana/grafana/pkg/services/dashboards"
 	"github.com/grafana/grafana/pkg/tsdb/legacydata"
 )
 
@@ -95,7 +95,7 @@ func (ts *TimeSettings) ToDB() ([]byte, error) {
 }
 
 // BuildTimeSettings build time settings object using selected values if enabled and are valid or dashboard default values
-func (pd PublicDashboard) BuildTimeSettings(dashboard *models.Dashboard, reqDTO PublicDashboardQueryDTO) TimeSettings {
+func (pd PublicDashboard) BuildTimeSettings(dashboard *dashboards.Dashboard, reqDTO PublicDashboardQueryDTO) TimeSettings {
 	from := dashboard.Data.GetPath("time", "from").MustString()
 	to := dashboard.Data.GetPath("time", "to").MustString()
 

pkg/services/publicdashboards/models/models_test.go

@@ -6,7 +6,7 @@ import (
 	"time"
 
 	"github.com/grafana/grafana/pkg/components/simplejson"
-	"github.com/grafana/grafana/pkg/models"
+	"github.com/grafana/grafana/pkg/services/dashboards"
 	"github.com/grafana/grafana/pkg/services/publicdashboards/internal"
 	"github.com/stretchr/testify/assert"
 )
@@ -24,14 +24,14 @@ func TestBuildTimeSettings(t *testing.T) {
 
 	testCases := []struct {
 		name       string
-		dashboard  *models.Dashboard
+		dashboard  *dashboards.Dashboard
 		pubdash    *PublicDashboard
 		timeResult TimeSettings
 		reqDTO     PublicDashboardQueryDTO
 	}{
 		{
 			name:      "should use dashboard time if pubdash time empty",
-			dashboard: &models.Dashboard{Data: dashboardData},
+			dashboard: &dashboards.Dashboard{Data: dashboardData},
 			pubdash:   &PublicDashboard{TimeSelectionEnabled: false},
 			timeResult: TimeSettings{
 				From: defaultFromMs,
@@ -41,7 +41,7 @@ func TestBuildTimeSettings(t *testing.T) {
 		},
 		{
 			name:      "should use dashboard time when time selection is disabled",
-			dashboard: &models.Dashboard{Data: dashboardData},
+			dashboard: &dashboards.Dashboard{Data: dashboardData},
 			pubdash:   &PublicDashboard{TimeSelectionEnabled: false, TimeSettings: &TimeSettings{From: "now-12", To: "now"}},
 			timeResult: TimeSettings{
 				From: defaultFromMs,
@@ -51,7 +51,7 @@ func TestBuildTimeSettings(t *testing.T) {
 		},
 		{
 			name:      "should use selected values if time selection is enabled",
-			dashboard: &models.Dashboard{Data: dashboardData},
+			dashboard: &dashboards.Dashboard{Data: dashboardData},
 			pubdash:   &PublicDashboard{TimeSelectionEnabled: true, TimeSettings: &TimeSettings{From: "now-12", To: "now"}},
 			reqDTO: PublicDashboardQueryDTO{
 				TimeRange: TimeSettings{

pkg/services/publicdashboards/public_dashboard_service_mock.go

@@ -1,4 +1,4 @@
-// Code generated by mockery v2.14.0. DO NOT EDIT.
+// Code generated by mockery v2.16.0. DO NOT EDIT.
 
 package publicdashboards
 
@@ -7,14 +7,14 @@ import (
 
 	backend "github.com/grafana/grafana-plugin-sdk-go/backend"
 
+	dashboards "github.com/grafana/grafana/pkg/services/dashboards"
+
 	dtos "github.com/grafana/grafana/pkg/api/dtos"
 
 	mock "github.com/stretchr/testify/mock"
 
 	models "github.com/grafana/grafana/pkg/services/publicdashboards/models"
 
-	pkgmodels "github.com/grafana/grafana/pkg/models"
-
 	user "github.com/grafana/grafana/pkg/services/user"
 )
 
@@ -195,15 +195,15 @@ func (_m *FakePublicDashboardService) FindByDashboardUid(ctx context.Context, or
 }
 
 // FindDashboard provides a mock function with given fields: ctx, orgId, dashboardUid
-func (_m *FakePublicDashboardService) FindDashboard(ctx context.Context, orgId int64, dashboardUid string) (*pkgmodels.Dashboard, error) {
+func (_m *FakePublicDashboardService) FindDashboard(ctx context.Context, orgId int64, dashboardUid string) (*dashboards.Dashboard, error) {
 	ret := _m.Called(ctx, orgId, dashboardUid)
 
-	var r0 *pkgmodels.Dashboard
-	if rf, ok := ret.Get(0).(func(context.Context, int64, string) *pkgmodels.Dashboard); ok {
+	var r0 *dashboards.Dashboard
+	if rf, ok := ret.Get(0).(func(context.Context, int64, string) *dashboards.Dashboard); ok {
 		r0 = rf(ctx, orgId, dashboardUid)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*pkgmodels.Dashboard)
+			r0 = ret.Get(0).(*dashboards.Dashboard)
 		}
 	}
 
@@ -218,7 +218,7 @@ func (_m *FakePublicDashboardService) FindDashboard(ctx context.Context, orgId i
 }
 
 // FindPublicDashboardAndDashboardByAccessToken provides a mock function with given fields: ctx, accessToken
-func (_m *FakePublicDashboardService) FindPublicDashboardAndDashboardByAccessToken(ctx context.Context, accessToken string) (*models.PublicDashboard, *pkgmodels.Dashboard, error) {
+func (_m *FakePublicDashboardService) FindPublicDashboardAndDashboardByAccessToken(ctx context.Context, accessToken string) (*models.PublicDashboard, *dashboards.Dashboard, error) {
 	ret := _m.Called(ctx, accessToken)
 
 	var r0 *models.PublicDashboard
@@ -230,12 +230,12 @@ func (_m *FakePublicDashboardService) FindPublicDashboardAndDashboardByAccessTok
 		}
 	}
 
-	var r1 *pkgmodels.Dashboard
-	if rf, ok := ret.Get(1).(func(context.Context, string) *pkgmodels.Dashboard); ok {
+	var r1 *dashboards.Dashboard
+	if rf, ok := ret.Get(1).(func(context.Context, string) *dashboards.Dashboard); ok {
 		r1 = rf(ctx, accessToken)
 	} else {
 		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*pkgmodels.Dashboard)
+			r1 = ret.Get(1).(*dashboards.Dashboard)
 		}
 	}
 
@@ -250,18 +250,18 @@ func (_m *FakePublicDashboardService) FindPublicDashboardAndDashboardByAccessTok
 }
 
 // GetMetricRequest provides a mock function with given fields: ctx, dashboard, publicDashboard, panelId, reqDTO
-func (_m *FakePublicDashboardService) GetMetricRequest(ctx context.Context, dashboard *pkgmodels.Dashboard, publicDashboard *models.PublicDashboard, panelId int64, reqDTO models.PublicDashboardQueryDTO) (dtos.MetricRequest, error) {
+func (_m *FakePublicDashboardService) GetMetricRequest(ctx context.Context, dashboard *dashboards.Dashboard, publicDashboard *models.PublicDashboard, panelId int64, reqDTO models.PublicDashboardQueryDTO) (dtos.MetricRequest, error) {
 	ret := _m.Called(ctx, dashboard, publicDashboard, panelId, reqDTO)
 
 	var r0 dtos.MetricRequest
-	if rf, ok := ret.Get(0).(func(context.Context, *pkgmodels.Dashboard, *models.PublicDashboard, int64, models.PublicDashboardQueryDTO) dtos.MetricRequest); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *dashboards.Dashboard, *models.PublicDashboard, int64, models.PublicDashboardQueryDTO) dtos.MetricRequest); ok {
 		r0 = rf(ctx, dashboard, publicDashboard, panelId, reqDTO)
 	} else {
 		r0 = ret.Get(0).(dtos.MetricRequest)
 	}
 
 	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *pkgmodels.Dashboard, *models.PublicDashboard, int64, models.PublicDashboardQueryDTO) error); ok {
+	if rf, ok := ret.Get(1).(func(context.Context, *dashboards.Dashboard, *models.PublicDashboard, int64, models.PublicDashboardQueryDTO) error); ok {
 		r1 = rf(ctx, dashboard, publicDashboard, panelId, reqDTO)
 	} else {
 		r1 = ret.Error(1)

pkg/services/publicdashboards/public_dashboard_store_mock.go

@@ -1,16 +1,14 @@
-// Code generated by mockery v2.12.1. DO NOT EDIT.
+// Code generated by mockery v2.16.0. DO NOT EDIT.
 
 package publicdashboards
 
 import (
 	context "context"
 
-	models "github.com/grafana/grafana/pkg/services/publicdashboards/models"
+	dashboards "github.com/grafana/grafana/pkg/services/dashboards"
 	mock "github.com/stretchr/testify/mock"
 
-	pkgmodels "github.com/grafana/grafana/pkg/models"
-
-	testing "testing"
+	models "github.com/grafana/grafana/pkg/services/publicdashboards/models"
 )
 
 // FakePublicDashboardStore is an autogenerated mock type for the Store type
@@ -195,15 +193,15 @@ func (_m *FakePublicDashboardStore) FindByDashboardUid(ctx context.Context, orgI
 }
 
 // FindDashboard provides a mock function with given fields: ctx, orgId, dashboardUid
-func (_m *FakePublicDashboardStore) FindDashboard(ctx context.Context, orgId int64, dashboardUid string) (*pkgmodels.Dashboard, error) {
+func (_m *FakePublicDashboardStore) FindDashboard(ctx context.Context, orgId int64, dashboardUid string) (*dashboards.Dashboard, error) {
 	ret := _m.Called(ctx, orgId, dashboardUid)
 
-	var r0 *pkgmodels.Dashboard
-	if rf, ok := ret.Get(0).(func(context.Context, int64, string) *pkgmodels.Dashboard); ok {
+	var r0 *dashboards.Dashboard
+	if rf, ok := ret.Get(0).(func(context.Context, int64, string) *dashboards.Dashboard); ok {
 		r0 = rf(ctx, orgId, dashboardUid)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*pkgmodels.Dashboard)
+			r0 = ret.Get(0).(*dashboards.Dashboard)
 		}
 	}
 
@@ -259,8 +257,13 @@ func (_m *FakePublicDashboardStore) Update(ctx context.Context, cmd models.SaveP
 	return r0, r1
 }
 
-// NewFakePublicDashboardStore creates a new instance of FakePublicDashboardStore. It also registers the testing.TB interface on the mock and a cleanup function to assert the mocks expectations.
-func NewFakePublicDashboardStore(t testing.TB) *FakePublicDashboardStore {
+type mockConstructorTestingTNewFakePublicDashboardStore interface {
+	mock.TestingT
+	Cleanup(func())
+}
+
+// NewFakePublicDashboardStore creates a new instance of FakePublicDashboardStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+func NewFakePublicDashboardStore(t mockConstructorTestingTNewFakePublicDashboardStore) *FakePublicDashboardStore {
 	mock := &FakePublicDashboardStore{}
 	mock.Mock.Test(t)
 

pkg/services/publicdashboards/publicdashboard.go

@@ -5,7 +5,7 @@ import (
 
 	"github.com/grafana/grafana-plugin-sdk-go/backend"
 	"github.com/grafana/grafana/pkg/api/dtos"
-	"github.com/grafana/grafana/pkg/models"
+	"github.com/grafana/grafana/pkg/services/dashboards"
 	. "github.com/grafana/grafana/pkg/services/publicdashboards/models"
 	"github.com/grafana/grafana/pkg/services/user"
 )
@@ -15,17 +15,17 @@ import (
 //go:generate go run ./commands/generate_datasources/main.go
 //go:generate mockery --name Service --structname FakePublicDashboardService --inpackage --filename public_dashboard_service_mock.go
 type Service interface {
-	FindPublicDashboardAndDashboardByAccessToken(ctx context.Context, accessToken string) (*PublicDashboard, *models.Dashboard, error)
+	FindPublicDashboardAndDashboardByAccessToken(ctx context.Context, accessToken string) (*PublicDashboard, *dashboards.Dashboard, error)
 	FindByAccessToken(ctx context.Context, accessToken string) (*PublicDashboard, error)
 	FindByDashboardUid(ctx context.Context, orgId int64, dashboardUid string) (*PublicDashboard, error)
 	FindAnnotations(ctx context.Context, reqDTO AnnotationsQueryDTO, accessToken string) ([]AnnotationEvent, error)
-	FindDashboard(ctx context.Context, orgId int64, dashboardUid string) (*models.Dashboard, error)
+	FindDashboard(ctx context.Context, orgId int64, dashboardUid string) (*dashboards.Dashboard, error)
 	FindAll(ctx context.Context, u *user.SignedInUser, orgId int64) ([]PublicDashboardListResponse, error)
 	Create(ctx context.Context, u *user.SignedInUser, dto *SavePublicDashboardDTO) (*PublicDashboard, error)
 	Update(ctx context.Context, u *user.SignedInUser, dto *SavePublicDashboardDTO) (*PublicDashboard, error)
 	Delete(ctx context.Context, orgId int64, uid string) error
 
-	GetMetricRequest(ctx context.Context, dashboard *models.Dashboard, publicDashboard *PublicDashboard, panelId int64, reqDTO PublicDashboardQueryDTO) (dtos.MetricRequest, error)
+	GetMetricRequest(ctx context.Context, dashboard *dashboards.Dashboard, publicDashboard *PublicDashboard, panelId int64, reqDTO PublicDashboardQueryDTO) (dtos.MetricRequest, error)
 	GetQueryDataResponse(ctx context.Context, skipCache bool, reqDTO PublicDashboardQueryDTO, panelId int64, accessToken string) (*backend.QueryDataResponse, error)
 	GetOrgIdByAccessToken(ctx context.Context, accessToken string) (int64, error)
 	NewPublicDashboardAccessToken(ctx context.Context) (string, error)
@@ -40,7 +40,7 @@ type Store interface {
 	Find(ctx context.Context, uid string) (*PublicDashboard, error)
 	FindByAccessToken(ctx context.Context, accessToken string) (*PublicDashboard, error)
 	FindByDashboardUid(ctx context.Context, orgId int64, dashboardUid string) (*PublicDashboard, error)
-	FindDashboard(ctx context.Context, orgId int64, dashboardUid string) (*models.Dashboard, error)
+	FindDashboard(ctx context.Context, orgId int64, dashboardUid string) (*dashboards.Dashboard, error)
 	FindAll(ctx context.Context, orgId int64) ([]PublicDashboardListResponse, error)
 	Create(ctx context.Context, cmd SavePublicDashboardCommand) (int64, error)
 	Update(ctx context.Context, cmd SavePublicDashboardCommand) (int64, error)

pkg/services/publicdashboards/service/query.go

@@ -6,7 +6,6 @@ import (
 	"github.com/grafana/grafana-plugin-sdk-go/backend"
 	"github.com/grafana/grafana/pkg/api/dtos"
 	"github.com/grafana/grafana/pkg/components/simplejson"
-	dashmodels "github.com/grafana/grafana/pkg/models"
 	"github.com/grafana/grafana/pkg/services/accesscontrol"
 	"github.com/grafana/grafana/pkg/services/annotations"
 	"github.com/grafana/grafana/pkg/services/dashboards"
@@ -44,9 +43,9 @@ func (pd *PublicDashboardServiceImpl) FindAnnotations(ctx context.Context, reqDT
 		annoQuery := &annotations.ItemQuery{
 			From:         reqDTO.From,
 			To:           reqDTO.To,
-			OrgId:        dash.OrgId,
-			DashboardId:  dash.Id,
-			DashboardUid: dash.Uid,
+			OrgId:        dash.OrgID,
+			DashboardId:  dash.ID,
+			DashboardUid: dash.UID,
 			Limit:        anno.Target.Limit,
 			MatchAny:     anno.Target.MatchAny,
 			SignedInUser: anonymousUser,
@@ -98,7 +97,7 @@ func (pd *PublicDashboardServiceImpl) FindAnnotations(ctx context.Context, reqDT
 }
 
 // GetMetricRequest returns a metric request for the given panel and query
-func (pd *PublicDashboardServiceImpl) GetMetricRequest(ctx context.Context, dashboard *dashmodels.Dashboard, publicDashboard *models.PublicDashboard, panelId int64, queryDto models.PublicDashboardQueryDTO) (dtos.MetricRequest, error) {
+func (pd *PublicDashboardServiceImpl) GetMetricRequest(ctx context.Context, dashboard *dashboards.Dashboard, publicDashboard *models.PublicDashboard, panelId int64, queryDto models.PublicDashboardQueryDTO) (dtos.MetricRequest, error) {
 	err := validation.ValidateQueryPublicDashboardRequest(queryDto, publicDashboard)
 	if err != nil {
 		return dtos.MetricRequest{}, err
@@ -150,7 +149,7 @@ func (pd *PublicDashboardServiceImpl) GetQueryDataResponse(ctx context.Context,
 }
 
 // buildMetricRequest merges public dashboard parameters with dashboard and returns a metrics request to be sent to query backend
-func (pd *PublicDashboardServiceImpl) buildMetricRequest(ctx context.Context, dashboard *dashmodels.Dashboard, publicDashboard *models.PublicDashboard, panelId int64, reqDTO models.PublicDashboardQueryDTO) (dtos.MetricRequest, error) {
+func (pd *PublicDashboardServiceImpl) buildMetricRequest(ctx context.Context, dashboard *dashboards.Dashboard, publicDashboard *models.PublicDashboard, panelId int64, reqDTO models.PublicDashboardQueryDTO) (dtos.MetricRequest, error) {
 	// group queries by panel
 	queriesByPanel := groupQueriesByPanelId(dashboard.Data)
 	queries, ok := queriesByPanel[panelId]
@@ -175,11 +174,11 @@ func (pd *PublicDashboardServiceImpl) buildMetricRequest(ctx context.Context, da
 }
 
 // buildAnonymousUser creates a user with permissions to read from all datasources used in the dashboard
-func buildAnonymousUser(ctx context.Context, dashboard *dashmodels.Dashboard) *user.SignedInUser {
+func buildAnonymousUser(ctx context.Context, dashboard *dashboards.Dashboard) *user.SignedInUser {
 	datasourceUids := getUniqueDashboardDatasourceUids(dashboard.Data)
 
 	// Create a user with blank permissions
-	anonymousUser := &user.SignedInUser{OrgID: dashboard.OrgId, Permissions: make(map[int64]map[string][]string)}
+	anonymousUser := &user.SignedInUser{OrgID: dashboard.OrgID, Permissions: make(map[int64]map[string][]string)}
 
 	// Scopes needed for Annotation queries
 	annotationScopes := []string{accesscontrol.ScopeAnnotationsTypeDashboard}
@@ -202,7 +201,7 @@ func buildAnonymousUser(ctx context.Context, dashboard *dashmodels.Dashboard) *u
 	permissions[accesscontrol.ActionAnnotationsRead] = annotationScopes
 	permissions[dashboards.ActionDashboardsRead] = dashboardScopes
 
-	anonymousUser.Permissions[dashboard.OrgId] = permissions
+	anonymousUser.Permissions[dashboard.OrgID] = permissions
 
 	return anonymousUser
 }

pkg/services/publicdashboards/service/query_test.go

@@ -11,9 +11,9 @@ import (
 	"github.com/grafana/grafana/pkg/infra/db"
 	"github.com/grafana/grafana/pkg/infra/log"
 	dashboard2 "github.com/grafana/grafana/pkg/kinds/dashboard"
-	grafanamodels "github.com/grafana/grafana/pkg/models"
 	"github.com/grafana/grafana/pkg/services/annotations"
 	"github.com/grafana/grafana/pkg/services/annotations/annotationsimpl"
+	"github.com/grafana/grafana/pkg/services/dashboards"
 	dashboardsDB "github.com/grafana/grafana/pkg/services/dashboards/database"
 	"github.com/grafana/grafana/pkg/services/featuremgmt"
 	. "github.com/grafana/grafana/pkg/services/publicdashboards"
@@ -391,8 +391,8 @@ func TestGetQueryDataResponse(t *testing.T) {
 
 		dashboard := insertTestDashboard(t, dashboardStore, "testDashWithHiddenQuery", 1, 0, true, []map[string]interface{}{}, customPanels)
 		dto := &SavePublicDashboardDTO{
-			DashboardUid: dashboard.Uid,
-			OrgId:        dashboard.OrgId,
+			DashboardUid: dashboard.UID,
+			OrgId:        dashboard.OrgID,
 			UserId:       7,
 			PublicDashboard: &PublicDashboard{
 				IsEnabled:    true,
@@ -426,13 +426,13 @@ func TestGetAnnotations(t *testing.T) {
 		fakeStore.On("FindByAccessToken", mock.Anything, mock.AnythingOfType("string")).
 			Return(&PublicDashboard{Uid: "uid1", IsEnabled: true}, nil)
 		fakeStore.On("FindDashboard", mock.Anything, mock.Anything, mock.AnythingOfType("string")).
-			Return(grafanamodels.NewDashboard("dash1"), nil)
+			Return(dashboards.NewDashboard("dash1"), nil)
 
 		reqDTO := AnnotationsQueryDTO{
 			From: 1,
 			To:   2,
 		}
-		dash := grafanamodels.NewDashboard("testDashboard")
+		dash := dashboards.NewDashboard("testDashboard")
 
 		items, _ := service.FindAnnotations(context.Background(), reqDTO, "abc123")
 		anonUser := buildAnonymousUser(context.Background(), dash)
@@ -442,7 +442,7 @@ func TestGetAnnotations(t *testing.T) {
 	})
 
 	t.Run("Test events from tag queries overwrite built-in annotation queries and duplicate events are not returned", func(t *testing.T) {
-		dash := grafanamodels.NewDashboard("test")
+		dash := dashboards.NewDashboard("test")
 		grafanaAnnotation := DashAnnotation{
 			Datasource: CreateDatasource("grafana", "grafana"),
 			Enable:     true,
@@ -478,7 +478,7 @@ func TestGetAnnotations(t *testing.T) {
 			store:           &fakeStore,
 			AnnotationsRepo: &annotationsRepo,
 		}
-		pubdash := &PublicDashboard{Uid: "uid1", IsEnabled: true, OrgId: 1, DashboardUid: dashboard.Uid, AnnotationsEnabled: true}
+		pubdash := &PublicDashboard{Uid: "uid1", IsEnabled: true, OrgId: 1, DashboardUid: dashboard.UID, AnnotationsEnabled: true}
 
 		fakeStore.On("FindByAccessToken", mock.Anything, mock.AnythingOfType("string")).Return(pubdash, nil)
 		fakeStore.On("FindDashboard", mock.Anything, mock.Anything, mock.AnythingOfType("string")).Return(dashboard, nil)
@@ -515,7 +515,7 @@ func TestGetAnnotations(t *testing.T) {
 	})
 
 	t.Run("Test panelId set to zero when annotation event is for a tags query", func(t *testing.T) {
-		dash := grafanamodels.NewDashboard("test")
+		dash := dashboards.NewDashboard("test")
 		grafanaAnnotation := DashAnnotation{
 			Datasource: CreateDatasource("grafana", "grafana"),
 			Enable:     true,
@@ -538,7 +538,7 @@ func TestGetAnnotations(t *testing.T) {
 			store:           &fakeStore,
 			AnnotationsRepo: &annotationsRepo,
 		}
-		pubdash := &PublicDashboard{Uid: "uid1", IsEnabled: true, OrgId: 1, DashboardUid: dashboard.Uid, AnnotationsEnabled: true}
+		pubdash := &PublicDashboard{Uid: "uid1", IsEnabled: true, OrgId: 1, DashboardUid: dashboard.UID, AnnotationsEnabled: true}
 
 		fakeStore.On("FindByAccessToken", mock.Anything, mock.AnythingOfType("string")).Return(pubdash, nil)
 		fakeStore.On("FindDashboard", mock.Anything, mock.Anything, mock.AnythingOfType("string")).Return(dashboard, nil)
@@ -575,7 +575,7 @@ func TestGetAnnotations(t *testing.T) {
 	})
 
 	t.Run("Test can get grafana annotations and will skip annotation queries and disabled annotations", func(t *testing.T) {
-		dash := grafanamodels.NewDashboard("test")
+		dash := dashboards.NewDashboard("test")
 		disabledGrafanaAnnotation := DashAnnotation{
 			Datasource: CreateDatasource("grafana", "grafana"),
 			Enable:     false,
@@ -610,7 +610,7 @@ func TestGetAnnotations(t *testing.T) {
 			store:           &fakeStore,
 			AnnotationsRepo: &annotationsRepo,
 		}
-		pubdash := &PublicDashboard{Uid: "uid1", IsEnabled: true, OrgId: 1, DashboardUid: dashboard.Uid, AnnotationsEnabled: true}
+		pubdash := &PublicDashboard{Uid: "uid1", IsEnabled: true, OrgId: 1, DashboardUid: dashboard.UID, AnnotationsEnabled: true}
 
 		fakeStore.On("FindByAccessToken", mock.Anything, mock.AnythingOfType("string")).Return(pubdash, nil)
 		fakeStore.On("FindDashboard", mock.Anything, mock.Anything, mock.AnythingOfType("string")).Return(dashboard, nil)
@@ -654,8 +654,8 @@ func TestGetAnnotations(t *testing.T) {
 			store:           &fakeStore,
 			AnnotationsRepo: &annotationsRepo,
 		}
-		dashboard := grafanamodels.NewDashboard("dashWithNoAnnotations")
-		pubdash := &PublicDashboard{Uid: "uid1", IsEnabled: true, OrgId: 1, DashboardUid: dashboard.Uid, AnnotationsEnabled: true}
+		dashboard := dashboards.NewDashboard("dashWithNoAnnotations")
+		pubdash := &PublicDashboard{Uid: "uid1", IsEnabled: true, OrgId: 1, DashboardUid: dashboard.UID, AnnotationsEnabled: true}
 
 		fakeStore.On("FindByAccessToken", mock.Anything, mock.AnythingOfType("string")).Return(pubdash, nil)
 		fakeStore.On("FindDashboard", mock.Anything, mock.Anything, mock.AnythingOfType("string")).Return(dashboard, nil)
@@ -674,7 +674,7 @@ func TestGetAnnotations(t *testing.T) {
 			store:           &fakeStore,
 			AnnotationsRepo: &annotationsRepo,
 		}
-		dash := grafanamodels.NewDashboard("test")
+		dash := dashboards.NewDashboard("test")
 		grafanaAnnotation := DashAnnotation{
 			Datasource: CreateDatasource("grafana", "grafana"),
 			Enable:     true,
@@ -690,7 +690,7 @@ func TestGetAnnotations(t *testing.T) {
 		}
 		annos := []DashAnnotation{grafanaAnnotation}
 		dashboard := AddAnnotationsToDashboard(t, dash, annos)
-		pubdash := &PublicDashboard{Uid: "uid1", IsEnabled: true, OrgId: 1, DashboardUid: dashboard.Uid, AnnotationsEnabled: false}
+		pubdash := &PublicDashboard{Uid: "uid1", IsEnabled: true, OrgId: 1, DashboardUid: dashboard.UID, AnnotationsEnabled: false}
 
 		fakeStore.On("FindByAccessToken", mock.Anything, mock.AnythingOfType("string")).Return(pubdash, nil)
 		fakeStore.On("FindDashboard", mock.Anything, mock.Anything, mock.AnythingOfType("string")).Return(dashboard, nil)
@@ -709,7 +709,7 @@ func TestGetAnnotations(t *testing.T) {
 			store:           &fakeStore,
 			AnnotationsRepo: &annotationsRepo,
 		}
-		dash := grafanamodels.NewDashboard("test")
+		dash := dashboards.NewDashboard("test")
 		grafanaAnnotation := DashAnnotation{
 			Datasource: CreateDatasource("grafana", "grafana"),
 			Enable:     true,
@@ -724,7 +724,7 @@ func TestGetAnnotations(t *testing.T) {
 		}
 		annos := []DashAnnotation{grafanaAnnotation}
 		dash = AddAnnotationsToDashboard(t, dash, annos)
-		pubdash := &PublicDashboard{Uid: "uid1", IsEnabled: true, OrgId: 1, DashboardUid: dash.Uid, AnnotationsEnabled: true}
+		pubdash := &PublicDashboard{Uid: "uid1", IsEnabled: true, OrgId: 1, DashboardUid: dash.UID, AnnotationsEnabled: true}
 
 		fakeStore.On("FindByAccessToken", mock.Anything, mock.AnythingOfType("string")).Return(pubdash, nil)
 		fakeStore.On("FindDashboard", mock.Anything, mock.Anything, mock.AnythingOfType("string")).Return(dash, nil)
@@ -746,7 +746,7 @@ func TestGetMetricRequest(t *testing.T) {
 	dashboard := insertTestDashboard(t, dashboardStore, "testDashie", 1, 0, true, []map[string]interface{}{}, nil)
 	publicDashboard := &PublicDashboard{
 		Uid:          "1",
-		DashboardUid: dashboard.Uid,
+		DashboardUid: dashboard.UID,
 		IsEnabled:    true,
 		AccessToken:  "abc123",
 	}
@@ -834,8 +834,8 @@ func TestBuildMetricRequest(t *testing.T) {
 	}
 
 	dto := &SavePublicDashboardDTO{
-		DashboardUid: publicDashboard.Uid,
-		OrgId:        publicDashboard.OrgId,
+		DashboardUid: publicDashboard.UID,
+		OrgId:        publicDashboard.OrgID,
 		PublicDashboard: &PublicDashboard{
 			IsEnabled:    true,
 			DashboardUid: "NOTTHESAME",
@@ -848,8 +848,8 @@ func TestBuildMetricRequest(t *testing.T) {
 	require.NoError(t, err)
 
 	nonPublicDto := &SavePublicDashboardDTO{
-		DashboardUid: nonPublicDashboard.Uid,
-		OrgId:        nonPublicDashboard.OrgId,
+		DashboardUid: nonPublicDashboard.UID,
+		OrgId:        nonPublicDashboard.OrgID,
 		PublicDashboard: &PublicDashboard{
 			IsEnabled:    false,
 			DashboardUid: "NOTTHESAME",
@@ -1038,7 +1038,7 @@ func TestBuildAnonymousUser(t *testing.T) {
 	t.Run("will add datasource read and query permissions to user for each datasource in dashboard", func(t *testing.T) {
 		user := buildAnonymousUser(context.Background(), dashboard)
 
-		require.Equal(t, dashboard.OrgId, user.OrgID)
+		require.Equal(t, dashboard.OrgID, user.OrgID)
 		require.Equal(t, "datasources:uid:ds1", user.Permissions[user.OrgID]["datasources:query"][0])
 		require.Equal(t, "datasources:uid:ds3", user.Permissions[user.OrgID]["datasources:query"][1])
 		require.Equal(t, "datasources:uid:ds1", user.Permissions[user.OrgID]["datasources:read"][0])
@@ -1047,7 +1047,7 @@ func TestBuildAnonymousUser(t *testing.T) {
 	t.Run("will add dashboard and annotation permissions needed for getting annotations", func(t *testing.T) {
 		user := buildAnonymousUser(context.Background(), dashboard)
 
-		require.Equal(t, dashboard.OrgId, user.OrgID)
+		require.Equal(t, dashboard.OrgID, user.OrgID)
 		require.Equal(t, "annotations:type:dashboard", user.Permissions[user.OrgID]["annotations:read"][0])
 		require.Equal(t, "dashboards:*", user.Permissions[user.OrgID]["dashboards:read"][0])
 	})

pkg/services/publicdashboards/service/service.go

@@ -7,7 +7,6 @@ import (
 
 	"github.com/grafana/grafana-plugin-sdk-go/backend"
 	"github.com/grafana/grafana/pkg/infra/log"
-	"github.com/grafana/grafana/pkg/models"
 	"github.com/grafana/grafana/pkg/services/accesscontrol"
 	"github.com/grafana/grafana/pkg/services/annotations"
 	"github.com/grafana/grafana/pkg/services/dashboards"
@@ -62,7 +61,7 @@ func ProvideService(
 }
 
 // FindDashboard Gets a dashboard by Uid
-func (pd *PublicDashboardServiceImpl) FindDashboard(ctx context.Context, orgId int64, dashboardUid string) (*models.Dashboard, error) {
+func (pd *PublicDashboardServiceImpl) FindDashboard(ctx context.Context, orgId int64, dashboardUid string) (*dashboards.Dashboard, error) {
 	dash, err := pd.store.FindDashboard(ctx, orgId, dashboardUid)
 	if err != nil {
 		return nil, ErrInternalServerError.Errorf("FindDashboard: failed to find dashboard by orgId: %d and dashboardUid: %s: %w", orgId, dashboardUid, err)
@@ -90,7 +89,7 @@ func (pd *PublicDashboardServiceImpl) FindByAccessToken(ctx context.Context, acc
 }
 
 // FindPublicDashboardAndDashboardByAccessToken Gets public dashboard and a dashboard by access token
-func (pd *PublicDashboardServiceImpl) FindPublicDashboardAndDashboardByAccessToken(ctx context.Context, accessToken string) (*PublicDashboard, *models.Dashboard, error) {
+func (pd *PublicDashboardServiceImpl) FindPublicDashboardAndDashboardByAccessToken(ctx context.Context, accessToken string) (*PublicDashboard, *dashboards.Dashboard, error) {
 	pubdash, err := pd.FindByAccessToken(ctx, accessToken)
 	if err != nil {
 		return nil, nil, err

pkg/services/publicdashboards/service/service_test.go

@@ -12,7 +12,6 @@ import (
 	"github.com/grafana/grafana/pkg/components/simplejson"
 	"github.com/grafana/grafana/pkg/infra/db"
 	"github.com/grafana/grafana/pkg/infra/log"
-	"github.com/grafana/grafana/pkg/models"
 	"github.com/grafana/grafana/pkg/services/accesscontrol"
 	"github.com/grafana/grafana/pkg/services/dashboards"
 	dashboardsDB "github.com/grafana/grafana/pkg/services/dashboards/database"
@@ -44,7 +43,7 @@ func TestLogPrefix(t *testing.T) {
 func TestGetPublicDashboard(t *testing.T) {
 	type storeResp struct {
 		pd  *PublicDashboard
-		d   *models.Dashboard
+		d   *dashboards.Dashboard
 		err error
 	}
 
@@ -53,25 +52,25 @@ func TestGetPublicDashboard(t *testing.T) {
 		AccessToken string
 		StoreResp   *storeResp
 		ErrResp     error
-		DashResp    *models.Dashboard
+		DashResp    *dashboards.Dashboard
 	}{
 		{
 			Name:        "returns a dashboard",
 			AccessToken: "abc123",
 			StoreResp: &storeResp{
 				pd:  &PublicDashboard{AccessToken: "abcdToken", IsEnabled: true},
-				d:   &models.Dashboard{Uid: "mydashboard", Data: dashboardData},
+				d:   &dashboards.Dashboard{UID: "mydashboard", Data: dashboardData},
 				err: nil,
 			},
 			ErrResp:  nil,
-			DashResp: &models.Dashboard{Uid: "mydashboard", Data: dashboardData},
+			DashResp: &dashboards.Dashboard{UID: "mydashboard", Data: dashboardData},
 		},
 		{
 			Name:        "returns ErrPublicDashboardNotFound when isEnabled is false",
 			AccessToken: "abc123",
 			StoreResp: &storeResp{
 				pd:  &PublicDashboard{AccessToken: "abcdToken", IsEnabled: false},
-				d:   &models.Dashboard{Uid: "mydashboard"},
+				d:   &dashboards.Dashboard{UID: "mydashboard"},
 				err: nil,
 			},
 			ErrResp:  ErrPublicDashboardNotFound,
@@ -138,8 +137,8 @@ func TestCreatePublicDashboard(t *testing.T) {
 		}
 
 		dto := &SavePublicDashboardDTO{
-			DashboardUid: dashboard.Uid,
-			OrgId:        dashboard.OrgId,
+			DashboardUid: dashboard.UID,
+			OrgId:        dashboard.OrgID,
 			UserId:       7,
 			PublicDashboard: &PublicDashboard{
 				IsEnabled:          true,
@@ -153,12 +152,12 @@ func TestCreatePublicDashboard(t *testing.T) {
 		_, err = service.Create(context.Background(), SignedInUser, dto)
 		require.NoError(t, err)
 
-		pubdash, err := service.FindByDashboardUid(context.Background(), dashboard.OrgId, dashboard.Uid)
+		pubdash, err := service.FindByDashboardUid(context.Background(), dashboard.OrgID, dashboard.UID)
 		require.NoError(t, err)
 
 		// DashboardUid/OrgId/CreatedBy set by the command, not parameters
-		assert.Equal(t, dashboard.Uid, pubdash.DashboardUid)
-		assert.Equal(t, dashboard.OrgId, pubdash.OrgId)
+		assert.Equal(t, dashboard.UID, pubdash.DashboardUid)
+		assert.Equal(t, dashboard.OrgID, pubdash.OrgId)
 		assert.Equal(t, dto.UserId, pubdash.CreatedBy)
 		assert.Equal(t, dto.PublicDashboard.AnnotationsEnabled, pubdash.AnnotationsEnabled)
 		// ExistsEnabledByDashboardUid set by parameters
@@ -186,8 +185,8 @@ func TestCreatePublicDashboard(t *testing.T) {
 		}
 
 		dto := &SavePublicDashboardDTO{
-			DashboardUid: dashboard.Uid,
-			OrgId:        dashboard.OrgId,
+			DashboardUid: dashboard.UID,
+			OrgId:        dashboard.OrgID,
 			UserId:       7,
 			PublicDashboard: &PublicDashboard{
 				IsEnabled:    true,
@@ -199,7 +198,7 @@ func TestCreatePublicDashboard(t *testing.T) {
 		_, err = service.Create(context.Background(), SignedInUser, dto)
 		require.NoError(t, err)
 
-		pubdash, err := service.FindByDashboardUid(context.Background(), dashboard.OrgId, dashboard.Uid)
+		pubdash, err := service.FindByDashboardUid(context.Background(), dashboard.OrgID, dashboard.UID)
 		require.NoError(t, err)
 		assert.Equal(t, defaultPubdashTimeSettings, pubdash.TimeSettings)
 	})
@@ -219,8 +218,8 @@ func TestCreatePublicDashboard(t *testing.T) {
 		}
 
 		dto := &SavePublicDashboardDTO{
-			DashboardUid: dashboard.Uid,
-			OrgId:        dashboard.OrgId,
+			DashboardUid: dashboard.UID,
+			OrgId:        dashboard.OrgID,
 			UserId:       7,
 			PublicDashboard: &PublicDashboard{
 				IsEnabled:    true,
@@ -234,7 +233,7 @@ func TestCreatePublicDashboard(t *testing.T) {
 	})
 
 	t.Run("Throws an error when pubdash with generated access token already exists", func(t *testing.T) {
-		dashboard := models.NewDashboard("testDashie")
+		dashboard := dashboards.NewDashboard("testDashie")
 		pubdash := &PublicDashboard{
 			IsEnabled:          true,
 			AnnotationsEnabled: false,
@@ -283,8 +282,8 @@ func TestCreatePublicDashboard(t *testing.T) {
 		}
 
 		dto := &SavePublicDashboardDTO{
-			DashboardUid: dashboard.Uid,
-			OrgId:        dashboard.OrgId,
+			DashboardUid: dashboard.UID,
+			OrgId:        dashboard.OrgID,
 			UserId:       7,
 			PublicDashboard: &PublicDashboard{
 				AnnotationsEnabled: false,
@@ -298,8 +297,8 @@ func TestCreatePublicDashboard(t *testing.T) {
 
 		// attempt to overwrite settings
 		dto = &SavePublicDashboardDTO{
-			DashboardUid: dashboard.Uid,
-			OrgId:        dashboard.OrgId,
+			DashboardUid: dashboard.UID,
+			OrgId:        dashboard.OrgID,
 			UserId:       8,
 			PublicDashboard: &PublicDashboard{
 				Uid:          savedPubdash.Uid,
@@ -336,8 +335,8 @@ func TestUpdatePublicDashboard(t *testing.T) {
 		}
 
 		dto := &SavePublicDashboardDTO{
-			DashboardUid: dashboard.Uid,
-			OrgId:        dashboard.OrgId,
+			DashboardUid: dashboard.UID,
+			OrgId:        dashboard.OrgID,
 			UserId:       7,
 			PublicDashboard: &PublicDashboard{
 				AnnotationsEnabled: false,
@@ -352,8 +351,8 @@ func TestUpdatePublicDashboard(t *testing.T) {
 
 		// attempt to overwrite settings
 		dto = &SavePublicDashboardDTO{
-			DashboardUid: dashboard.Uid,
-			OrgId:        dashboard.OrgId,
+			DashboardUid: dashboard.UID,
+			OrgId:        dashboard.OrgID,
 			UserId:       8,
 			PublicDashboard: &PublicDashboard{
 				Uid:          savedPubdash.Uid,
@@ -400,8 +399,8 @@ func TestUpdatePublicDashboard(t *testing.T) {
 		}
 
 		dto := &SavePublicDashboardDTO{
-			DashboardUid: dashboard.Uid,
-			OrgId:        dashboard.OrgId,
+			DashboardUid: dashboard.UID,
+			OrgId:        dashboard.OrgID,
 			UserId:       7,
 			PublicDashboard: &PublicDashboard{
 				IsEnabled:    true,
@@ -414,8 +413,8 @@ func TestUpdatePublicDashboard(t *testing.T) {
 
 		// attempt to overwrite settings
 		dto = &SavePublicDashboardDTO{
-			DashboardUid: dashboard.Uid,
-			OrgId:        dashboard.OrgId,
+			DashboardUid: dashboard.UID,
+			OrgId:        dashboard.OrgID,
 			UserId:       8,
 			PublicDashboard: &PublicDashboard{
 				Uid:          savedPubdash.Uid,
@@ -933,7 +932,7 @@ func CreateDatasource(dsType string, uid string) struct {
 	}
 }
 
-func AddAnnotationsToDashboard(t *testing.T, dash *models.Dashboard, annotations []DashAnnotation) *models.Dashboard {
+func AddAnnotationsToDashboard(t *testing.T, dash *dashboards.Dashboard, annotations []DashAnnotation) *dashboards.Dashboard {
 	type annotationsDto struct {
 		List []DashAnnotation `json:"list"`
 	}
@@ -951,7 +950,7 @@ func AddAnnotationsToDashboard(t *testing.T, dash *models.Dashboard, annotations
 }
 
 func insertTestDashboard(t *testing.T, dashboardStore *dashboardsDB.DashboardStore, title string, orgId int64,
-	folderId int64, isFolder bool, templateVars []map[string]interface{}, customPanels []interface{}, tags ...interface{}) *models.Dashboard {
+	folderId int64, isFolder bool, templateVars []map[string]interface{}, customPanels []interface{}, tags ...interface{}) *dashboards.Dashboard {
 	t.Helper()
 
 	var dashboardPanels []interface{}
@@ -999,9 +998,9 @@ func insertTestDashboard(t *testing.T, dashboardStore *dashboardsDB.DashboardSto
 		}
 	}
 
-	cmd := models.SaveDashboardCommand{
-		OrgId:    orgId,
-		FolderId: folderId,
+	cmd := dashboards.SaveDashboardCommand{
+		OrgID:    orgId,
+		FolderID: folderId,
 		IsFolder: isFolder,
 		Dashboard: simplejson.NewFromAny(map[string]interface{}{
 			"id":     nil,
@@ -1020,7 +1019,7 @@ func insertTestDashboard(t *testing.T, dashboardStore *dashboardsDB.DashboardSto
 	dash, err := dashboardStore.SaveDashboard(context.Background(), cmd)
 	require.NoError(t, err)
 	require.NotNil(t, dash)
-	dash.Data.Set("id", dash.Id)
-	dash.Data.Set("uid", dash.Uid)
+	dash.Data.Set("id", dash.ID)
+	dash.Data.Set("uid", dash.UID)
 	return dash
 }

pkg/services/publicdashboards/validation/validation.go

@@ -1,12 +1,12 @@
 package validation
 
 import (
-	"github.com/grafana/grafana/pkg/models"
+	"github.com/grafana/grafana/pkg/services/dashboards"
 	. "github.com/grafana/grafana/pkg/services/publicdashboards/models"
 	"github.com/grafana/grafana/pkg/tsdb/legacydata"
 )
 
-func ValidatePublicDashboard(dto *SavePublicDashboardDTO, dashboard *models.Dashboard) error {
+func ValidatePublicDashboard(dto *SavePublicDashboardDTO, dashboard *dashboards.Dashboard) error {
 	if hasTemplateVariables(dashboard) {
 		return ErrPublicDashboardHasTemplateVariables.Errorf("ValidateSavePublicDashboard: public dashboard has template variables")
 	}
@@ -14,7 +14,7 @@ func ValidatePublicDashboard(dto *SavePublicDashboardDTO, dashboard *models.Dash
 	return nil
 }
 
-func hasTemplateVariables(dashboard *models.Dashboard) bool {
+func hasTemplateVariables(dashboard *dashboards.Dashboard) bool {
 	templateVariables := dashboard.Data.Get("templating").Get("list").MustArray()
 
 	return len(templateVariables) > 0

pkg/services/publicdashboards/validation/validation_test.go

@@ -4,7 +4,7 @@ import (
 	"testing"
 
 	"github.com/grafana/grafana/pkg/components/simplejson"
-	"github.com/grafana/grafana/pkg/models"
+	"github.com/grafana/grafana/pkg/services/dashboards"
 	. "github.com/grafana/grafana/pkg/services/publicdashboards/models"
 	"github.com/stretchr/testify/require"
 )
@@ -21,7 +21,7 @@ func TestValidatePublicDashboard(t *testing.T) {
 			}
 		}`)
 		dashboardData, _ := simplejson.NewJson(templateVars)
-		dashboard := models.NewDashboardFromJson(dashboardData)
+		dashboard := dashboards.NewDashboardFromJson(dashboardData)
 		dto := &SavePublicDashboardDTO{DashboardUid: "abc123", OrgId: 1, UserId: 1, PublicDashboard: nil}
 
 		err := ValidatePublicDashboard(dto, dashboard)
@@ -35,7 +35,7 @@ func TestValidatePublicDashboard(t *testing.T) {
 			}
 		}`)
 		dashboardData, _ := simplejson.NewJson(templateVars)
-		dashboard := models.NewDashboardFromJson(dashboardData)
+		dashboard := dashboards.NewDashboardFromJson(dashboardData)
 		dto := &SavePublicDashboardDTO{DashboardUid: "abc123", OrgId: 1, UserId: 1, PublicDashboard: nil}
 
 		err := ValidatePublicDashboard(dto, dashboard)

pkg/services/querylibrary/querylibraryimpl/service.go

@@ -9,7 +9,7 @@ import (
 	"github.com/grafana/grafana/pkg/expr"
 	"github.com/grafana/grafana/pkg/infra/log"
 	"github.com/grafana/grafana/pkg/infra/x/persistentcollection"
-	"github.com/grafana/grafana/pkg/models"
+	"github.com/grafana/grafana/pkg/services/dashboards"
 	"github.com/grafana/grafana/pkg/services/featuremgmt"
 	"github.com/grafana/grafana/pkg/services/querylibrary"
 	"github.com/grafana/grafana/pkg/services/store/kind/dashboard"
@@ -67,7 +67,7 @@ type queryLoader interface {
 	byUID(uid string) (*querylibrary.Query, error)
 }
 
-func (s *service) UpdateDashboardQueries(ctx context.Context, user *user.SignedInUser, dash *models.Dashboard) error {
+func (s *service) UpdateDashboardQueries(ctx context.Context, user *user.SignedInUser, dash *dashboards.Dashboard) error {
 	queryLoader := newPerRequestQueryLoader(ctx, user, s)
 	return s.updateQueriesRecursively(queryLoader, dash.Data)
 }

pkg/services/querylibrary/types.go

@@ -5,8 +5,8 @@ import (
 
 	"github.com/grafana/grafana/pkg/api/routing"
 	"github.com/grafana/grafana/pkg/components/simplejson"
-	"github.com/grafana/grafana/pkg/models"
 	"github.com/grafana/grafana/pkg/registry"
+	"github.com/grafana/grafana/pkg/services/dashboards"
 	"github.com/grafana/grafana/pkg/services/store/kind/dashboard"
 	"github.com/grafana/grafana/pkg/services/user"
 )
@@ -78,7 +78,7 @@ type Service interface {
 	GetBatch(ctx context.Context, user *user.SignedInUser, uids []string) ([]*Query, error)
 	Update(ctx context.Context, user *user.SignedInUser, query *Query) error
 	Delete(ctx context.Context, user *user.SignedInUser, uid string) error
-	UpdateDashboardQueries(ctx context.Context, user *user.SignedInUser, dash *models.Dashboard) error
+	UpdateDashboardQueries(ctx context.Context, user *user.SignedInUser, dash *dashboards.Dashboard) error
 	registry.CanBeDisabled
 }
 

pkg/services/screenshot/screenshot.go

@@ -12,7 +12,6 @@ import (
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
 
-	"github.com/grafana/grafana/pkg/models"
 	"github.com/grafana/grafana/pkg/services/dashboards"
 	"github.com/grafana/grafana/pkg/services/org"
 	"github.com/grafana/grafana/pkg/services/rendering"
@@ -86,7 +85,7 @@ func (s *HeadlessScreenshotService) Take(ctx context.Context, opts ScreenshotOpt
 	start := time.Now()
 	defer func() { s.duration.Observe(time.Since(start).Seconds()) }()
 
-	q := models.GetDashboardQuery{Uid: opts.DashboardUID}
+	q := dashboards.GetDashboardQuery{UID: opts.DashboardUID}
 	if err := s.ds.GetDashboard(ctx, &q); err != nil {
 		s.instrumentError(err)
 		return nil, err
@@ -95,9 +94,9 @@ func (s *HeadlessScreenshotService) Take(ctx context.Context, opts ScreenshotOpt
 	opts = opts.SetDefaults()
 
 	u := url.URL{}
-	u.Path = path.Join("d-solo", q.Result.Uid, q.Result.Slug)
+	u.Path = path.Join("d-solo", q.Result.UID, q.Result.Slug)
 	p := u.Query()
-	p.Add("orgId", strconv.FormatInt(q.Result.OrgId, 10))
+	p.Add("orgId", strconv.FormatInt(q.Result.OrgID, 10))
 	p.Add("panelId", strconv.FormatInt(opts.PanelID, 10))
 	p.Add("from", opts.From)
 	p.Add("to", opts.To)
@@ -105,7 +104,7 @@ func (s *HeadlessScreenshotService) Take(ctx context.Context, opts ScreenshotOpt
 
 	renderOpts := rendering.Opts{
 		AuthOpts: rendering.AuthOpts{
-			OrgID:   q.Result.OrgId,
+			OrgID:   q.Result.OrgID,
 			OrgRole: org.RoleAdmin,
 		},
 		ErrorOpts: rendering.ErrorOpts{

pkg/services/screenshot/screenshot_test.go

@@ -11,7 +11,6 @@ import (
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
 
-	"github.com/grafana/grafana/pkg/models"
 	"github.com/grafana/grafana/pkg/services/dashboards"
 	"github.com/grafana/grafana/pkg/services/org"
 	"github.com/grafana/grafana/pkg/services/rendering"
@@ -27,7 +26,7 @@ func TestHeadlessScreenshotService(t *testing.T) {
 	s := NewHeadlessScreenshotService(&d, r, prometheus.NewRegistry())
 
 	// a non-existent dashboard should return error
-	d.On("GetDashboard", mock.Anything, mock.AnythingOfType("*models.GetDashboardQuery")).Return(dashboards.ErrDashboardNotFound).Once()
+	d.On("GetDashboard", mock.Anything, mock.AnythingOfType("*dashboards.GetDashboardQuery")).Return(dashboards.ErrDashboardNotFound).Once()
 	ctx := context.Background()
 	opts := ScreenshotOptions{}
 	screenshot, err := s.Take(ctx, opts)
@@ -35,9 +34,9 @@ func TestHeadlessScreenshotService(t *testing.T) {
 	assert.Nil(t, screenshot)
 
 	// should take a screenshot
-	d.On("GetDashboard", mock.Anything, mock.AnythingOfType("*models.GetDashboardQuery")).Run(func(args mock.Arguments) {
-		q := args.Get(1).(*models.GetDashboardQuery)
-		q.Result = &models.Dashboard{Id: 1, Uid: "foo", Slug: "bar", OrgId: 2}
+	d.On("GetDashboard", mock.Anything, mock.AnythingOfType("*dashboards.GetDashboardQuery")).Run(func(args mock.Arguments) {
+		q := args.Get(1).(*dashboards.GetDashboardQuery)
+		q.Result = &dashboards.Dashboard{ID: 1, UID: "foo", Slug: "bar", OrgID: 2}
 	}).Return(nil)
 
 	renderOpts := rendering.Opts{