Chore: Use dashboard service to retrieve dashboards (#79020)

pkg/services/publicdashboards/api/query_test.go

@@ -25,10 +25,13 @@ import (
 	"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/dashboards/service"
 	"github.com/grafana/grafana/pkg/services/datasources"
 	"github.com/grafana/grafana/pkg/services/datasources/guardian"
 	datasourcesService "github.com/grafana/grafana/pkg/services/datasources/service"
 	"github.com/grafana/grafana/pkg/services/featuremgmt"
+	"github.com/grafana/grafana/pkg/services/folder/folderimpl"
+	"github.com/grafana/grafana/pkg/services/folder/foldertest"
 	"github.com/grafana/grafana/pkg/services/publicdashboards"
 	publicdashboardsStore "github.com/grafana/grafana/pkg/services/publicdashboards/database"
 	. "github.com/grafana/grafana/pkg/services/publicdashboards/models"
@@ -337,15 +340,24 @@ func TestIntegrationUnauthenticatedUserCanGetPubdashPanelQueryData(t *testing.T)
 	cfg := setting.NewCfg()
 	ac := acmock.New()
 	ws := publicdashboardsService.ProvideServiceWrapper(store)
-	service := publicdashboardsService.ProvideService(cfg, store, qds, annotationsService, ac, ws)
+	folderStore := folderimpl.ProvideDashboardFolderStore(db)
-	pubdash, err := service.Create(context.Background(), &user.SignedInUser{}, savePubDashboardCmd)
+	dashPermissionService := acmock.NewMockedPermissionsService()
+	dashService, err := service.ProvideDashboardServiceImpl(
+		cfg, dashboardStoreService, folderStore, nil,
+		featuremgmt.WithFeatures(), acmock.NewMockedPermissionsService(), dashPermissionService, ac,
+		foldertest.NewFakeService(), nil,
+	)
+	require.NoError(t, err)
+
+	pds := publicdashboardsService.ProvideService(cfg, store, qds, annotationsService, ac, ws, dashService)
+	pubdash, err := pds.Create(context.Background(), &user.SignedInUser{}, savePubDashboardCmd)
 	require.NoError(t, err)
 
 	// setup test server
 	server := setupTestServer(t,
 		cfg,
 		featuremgmt.WithFeatures(featuremgmt.FlagPublicDashboards),
-		service,
+		pds,
 		db,
 		anonymousUser,
 	)

pkg/services/publicdashboards/database/database.go

@@ -91,28 +91,6 @@ func (d *PublicDashboardStoreImpl) FindAllWithPagination(ctx context.Context, qu
 	return resp, nil
 }
 
-// FindDashboard returns a dashboard by orgId and 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 {
-		var err error
-		found, err = sess.Get(dashboard)
-		return err
-	})
-
-	if err != nil {
-		return nil, err
-	}
-
-	if !found {
-		return nil, nil
-	}
-
-	return dashboard, nil
-}
-
 // Find Returns public dashboard by Uid or nil if not found
 func (d *PublicDashboardStoreImpl) Find(ctx context.Context, uid string) (*PublicDashboard, error) {
 	if uid == "" {

pkg/services/publicdashboards/database/database_test.go

@@ -162,36 +162,6 @@ func TestIntegrationListPublicDashboard(t *testing.T) {
 	})
 }
 
-func TestIntegrationFindDashboard(t *testing.T) {
-	if testing.Short() {
-		t.Skip("skipping integration test")
-	}
-	var sqlStore db.DB
-	var cfg *setting.Cfg
-	var dashboardStore dashboards.Store
-	var publicdashboardStore *PublicDashboardStoreImpl
-	var savedDashboard *dashboards.Dashboard
-
-	setup := func() {
-		sqlStore, cfg = db.InitTestDBwithCfg(t)
-		quotaService := quotatest.New(false, nil)
-		store, err := dashboardsDB.ProvideDashboardStore(sqlStore, cfg, featuremgmt.WithFeatures(), tagimpl.ProvideService(sqlStore), quotaService)
-		require.NoError(t, err)
-		dashboardStore = store
-		publicdashboardStore = ProvideStore(sqlStore, cfg, featuremgmt.WithFeatures())
-		savedDashboard = insertTestDashboard(t, dashboardStore, "testDashie", 1, 0, "", true)
-	}
-
-	t.Run("FindDashboard can get original dashboard by uid", func(t *testing.T) {
-		setup()
-
-		dashboard, err := publicdashboardStore.FindDashboard(context.Background(), savedDashboard.OrgID, savedDashboard.UID)
-
-		require.NoError(t, err)
-		require.Equal(t, savedDashboard.UID, dashboard.UID)
-	})
-}
-
 func TestIntegrationExistsEnabledByAccessToken(t *testing.T) {
 	if testing.Short() {
 		t.Skip("skipping integration test")

pkg/services/publicdashboards/public_dashboard_store_mock.go

@@ -242,32 +242,6 @@ func (_m *FakePublicDashboardStore) FindByDashboardUid(ctx context.Context, orgI
 	return r0, r1
 }
 
-// FindDashboard provides a mock function with given fields: ctx, orgId, dashboardUid
-func (_m *FakePublicDashboardStore) FindDashboard(ctx context.Context, orgId int64, dashboardUid string) (*dashboards.Dashboard, error) {
-	ret := _m.Called(ctx, orgId, dashboardUid)
-
-	var r0 *dashboards.Dashboard
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, int64, string) (*dashboards.Dashboard, error)); ok {
-		return rf(ctx, orgId, dashboardUid)
-	}
-	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).(*dashboards.Dashboard)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, int64, string) error); ok {
-		r1 = rf(ctx, orgId, dashboardUid)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
 // GetMetrics provides a mock function with given fields: ctx
 func (_m *FakePublicDashboardStore) GetMetrics(ctx context.Context) (*models.Metrics, error) {
 	ret := _m.Called(ctx)

pkg/services/publicdashboards/publicdashboard.go

@@ -53,7 +53,6 @@ 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) (*dashboards.Dashboard, error)
 	FindAllWithPagination(ctx context.Context, query *PublicDashboardListQuery) (*PublicDashboardListResponseWithPagination, error)
 	Create(ctx context.Context, cmd SavePublicDashboardCommand) (int64, error)
 	Update(ctx context.Context, cmd SavePublicDashboardCommand) (int64, error)

pkg/services/publicdashboards/service/query_test.go

@@ -689,6 +689,7 @@ func TestGetQueryDataResponse(t *testing.T) {
 	serviceWrapper := ProvideServiceWrapper(publicdashboardStore)
 	fakeQueryService := &query.FakeQueryService{}
 	fakeQueryService.On("QueryData", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(&backend.QueryDataResponse{}, nil)
+	fakeDashboardService := &dashboards.FakeDashboardService{}
 
 	service := &PublicDashboardServiceImpl{
 		log:                log.New("test.logger"),
@@ -696,6 +697,7 @@ func TestGetQueryDataResponse(t *testing.T) {
 		intervalCalculator: intervalv2.NewCalculator(),
 		QueryDataService:   fakeQueryService,
 		serviceWrapper:     serviceWrapper,
+		dashboardService:   fakeDashboardService,
 	}
 
 	publicDashboardQueryDTO := PublicDashboardQueryDTO{
@@ -723,6 +725,8 @@ func TestGetQueryDataResponse(t *testing.T) {
 			}}
 
 		dashboard := insertTestDashboard(t, dashboardStore, "testDashWithHiddenQuery", 1, 0, "", true, []map[string]interface{}{}, customPanels)
+		fakeDashboardService.On("GetDashboard", mock.Anything, mock.Anything, mock.Anything).Return(dashboard, nil)
+
 		isEnabled := true
 		dto := &SavePublicDashboardDTO{
 			DashboardUid: dashboard.UID,
@@ -749,15 +753,16 @@ func TestFindAnnotations(t *testing.T) {
 		tagService := tagimpl.ProvideService(sqlStore)
 		annotationsRepo := annotationsimpl.ProvideService(sqlStore, config, featuremgmt.WithFeatures(), tagService)
 		fakeStore := FakePublicDashboardStore{}
-		service := &PublicDashboardServiceImpl{
-			log:             log.New("test.logger"),
-			store:           &fakeStore,
-			AnnotationsRepo: annotationsRepo,
-		}
 		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")).
+		fakeDashboardService := &dashboards.FakeDashboardService{}
-			Return(dashboards.NewDashboard("dash1"), nil)
+		fakeDashboardService.On("GetDashboard", mock.Anything, mock.Anything, mock.Anything).Return(dashboards.NewDashboard("dash1"), nil)
+		service := &PublicDashboardServiceImpl{
+			log:              log.New("test.logger"),
+			store:            &fakeStore,
+			AnnotationsRepo:  annotationsRepo,
+			dashboardService: fakeDashboardService,
+		}
 
 		reqDTO := AnnotationsQueryDTO{
 			From: 1,
@@ -803,16 +808,19 @@ func TestFindAnnotations(t *testing.T) {
 		dashboard := AddAnnotationsToDashboard(t, dash, annos)
 
 		annotationsRepo := annotations.FakeAnnotationsRepo{}
-		fakeStore := FakePublicDashboardStore{}
-		service := &PublicDashboardServiceImpl{
-			log:             log.New("test.logger"),
-			store:           &fakeStore,
-			AnnotationsRepo: &annotationsRepo,
-		}
 		pubdash := &PublicDashboard{Uid: "uid1", IsEnabled: true, OrgId: 1, DashboardUid: dashboard.UID, AnnotationsEnabled: true}
 
+		fakeStore := FakePublicDashboardStore{}
 		fakeStore.On("FindByAccessToken", mock.Anything, mock.AnythingOfType("string")).Return(pubdash, nil)
-		fakeStore.On("FindDashboard", mock.Anything, mock.Anything, mock.AnythingOfType("string")).Return(dashboard, nil)
+		fakeDashboardService := &dashboards.FakeDashboardService{}
+		fakeDashboardService.On("GetDashboard", mock.Anything, mock.Anything, mock.Anything).Return(dashboard, nil)
+
+		service := &PublicDashboardServiceImpl{
+			log:              log.New("test.logger"),
+			store:            &fakeStore,
+			AnnotationsRepo:  &annotationsRepo,
+			dashboardService: fakeDashboardService,
+		}
 
 		annotationsRepo.On("Find", mock.Anything, mock.Anything).Return([]*annotations.ItemDTO{
 			{
@@ -864,15 +872,17 @@ func TestFindAnnotations(t *testing.T) {
 
 		annotationsRepo := annotations.FakeAnnotationsRepo{}
 		fakeStore := FakePublicDashboardStore{}
-		service := &PublicDashboardServiceImpl{
-			log:             log.New("test.logger"),
-			store:           &fakeStore,
-			AnnotationsRepo: &annotationsRepo,
-		}
 		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)
+		fakeDashboardService := &dashboards.FakeDashboardService{}
+		fakeDashboardService.On("GetDashboard", mock.Anything, mock.Anything, mock.Anything).Return(dashboard, nil)
+
+		service := &PublicDashboardServiceImpl{
+			log:              log.New("test.logger"),
+			store:            &fakeStore,
+			AnnotationsRepo:  &annotationsRepo,
+			dashboardService: fakeDashboardService,
+		}
 
 		annotationsRepo.On("Find", mock.Anything, mock.Anything).Return([]*annotations.ItemDTO{
 			{
@@ -935,16 +945,18 @@ func TestFindAnnotations(t *testing.T) {
 		dashboard := AddAnnotationsToDashboard(t, dash, annos)
 
 		annotationsRepo := annotations.FakeAnnotationsRepo{}
+		pubdash := &PublicDashboard{Uid: "uid1", IsEnabled: true, OrgId: 1, DashboardUid: dashboard.UID, AnnotationsEnabled: true}
 		fakeStore := FakePublicDashboardStore{}
+		fakeStore.On("FindByAccessToken", mock.Anything, mock.AnythingOfType("string")).Return(pubdash, nil)
+		fakeDashboardService := &dashboards.FakeDashboardService{}
+		fakeDashboardService.On("GetDashboard", mock.Anything, mock.Anything, mock.Anything).Return(dashboard, nil)
+
 		service := &PublicDashboardServiceImpl{
-			log:             log.New("test.logger"),
+			log:              log.New("test.logger"),
-			store:           &fakeStore,
+			store:            &fakeStore,
-			AnnotationsRepo: &annotationsRepo,
+			AnnotationsRepo:  &annotationsRepo,
+			dashboardService: fakeDashboardService,
 		}
-		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)
 
 		annotationsRepo.On("Find", mock.Anything, mock.Anything).Return([]*annotations.ItemDTO{
 			{
@@ -979,17 +991,18 @@ func TestFindAnnotations(t *testing.T) {
 
 	t.Run("test will return nothing when dashboard has no annotations", func(t *testing.T) {
 		annotationsRepo := annotations.FakeAnnotationsRepo{}
-		fakeStore := FakePublicDashboardStore{}
-		service := &PublicDashboardServiceImpl{
-			log:             log.New("test.logger"),
-			store:           &fakeStore,
-			AnnotationsRepo: &annotationsRepo,
-		}
 		dashboard := dashboards.NewDashboard("dashWithNoAnnotations")
 		pubdash := &PublicDashboard{Uid: "uid1", IsEnabled: true, OrgId: 1, DashboardUid: dashboard.UID, AnnotationsEnabled: true}
-
+		fakeStore := FakePublicDashboardStore{}
 		fakeStore.On("FindByAccessToken", mock.Anything, mock.AnythingOfType("string")).Return(pubdash, nil)
-		fakeStore.On("FindDashboard", mock.Anything, mock.Anything, mock.AnythingOfType("string")).Return(dashboard, nil)
+		fakeDashboardService := &dashboards.FakeDashboardService{}
+		fakeDashboardService.On("GetDashboard", mock.Anything, mock.Anything, mock.Anything).Return(dashboard, nil)
+		service := &PublicDashboardServiceImpl{
+			log:              log.New("test.logger"),
+			store:            &fakeStore,
+			AnnotationsRepo:  &annotationsRepo,
+			dashboardService: fakeDashboardService,
+		}
 
 		items, err := service.FindAnnotations(context.Background(), AnnotationsQueryDTO{}, "abc123")
 
@@ -998,13 +1011,6 @@ func TestFindAnnotations(t *testing.T) {
 	})
 
 	t.Run("test will return nothing when pubdash annotations are disabled", func(t *testing.T) {
-		annotationsRepo := annotations.FakeAnnotationsRepo{}
-		fakeStore := FakePublicDashboardStore{}
-		service := &PublicDashboardServiceImpl{
-			log:             log.New("test.logger"),
-			store:           &fakeStore,
-			AnnotationsRepo: &annotationsRepo,
-		}
 		dash := dashboards.NewDashboard("test")
 		grafanaAnnotation := DashAnnotation{
 			Datasource: CreateDatasource("grafana", "grafana"),
@@ -1022,9 +1028,17 @@ func TestFindAnnotations(t *testing.T) {
 		annos := []DashAnnotation{grafanaAnnotation}
 		dashboard := AddAnnotationsToDashboard(t, dash, annos)
 		pubdash := &PublicDashboard{Uid: "uid1", IsEnabled: true, OrgId: 1, DashboardUid: dashboard.UID, AnnotationsEnabled: false}
-
+		annotationsRepo := annotations.FakeAnnotationsRepo{}
+		fakeStore := FakePublicDashboardStore{}
 		fakeStore.On("FindByAccessToken", mock.Anything, mock.AnythingOfType("string")).Return(pubdash, nil)
-		fakeStore.On("FindDashboard", mock.Anything, mock.Anything, mock.AnythingOfType("string")).Return(dashboard, nil)
+		fakeDashboardService := &dashboards.FakeDashboardService{}
+		fakeDashboardService.On("GetDashboard", mock.Anything, mock.Anything, mock.Anything).Return(dashboard, nil)
+		service := &PublicDashboardServiceImpl{
+			log:              log.New("test.logger"),
+			store:            &fakeStore,
+			AnnotationsRepo:  &annotationsRepo,
+			dashboardService: fakeDashboardService,
+		}
 
 		items, err := service.FindAnnotations(context.Background(), AnnotationsQueryDTO{}, "abc123")
 
@@ -1033,14 +1047,6 @@ func TestFindAnnotations(t *testing.T) {
 	})
 
 	t.Run("test will error when annotations repo returns an error", func(t *testing.T) {
-		annotationsRepo := annotations.FakeAnnotationsRepo{}
-		fakeStore := FakePublicDashboardStore{}
-		service := &PublicDashboardServiceImpl{
-			log:             log.New("test.logger"),
-			store:           &fakeStore,
-			AnnotationsRepo: &annotationsRepo,
-		}
-		dash := dashboards.NewDashboard("test")
 		grafanaAnnotation := DashAnnotation{
 			Datasource: CreateDatasource("grafana", "grafana"),
 			Enable:     true,
@@ -1053,12 +1059,22 @@ func TestFindAnnotations(t *testing.T) {
 				Type:     "tags",
 			},
 		}
+		dash := dashboards.NewDashboard("test")
+		annotationsRepo := annotations.FakeAnnotationsRepo{}
 		annos := []DashAnnotation{grafanaAnnotation}
 		dash = AddAnnotationsToDashboard(t, dash, annos)
 		pubdash := &PublicDashboard{Uid: "uid1", IsEnabled: true, OrgId: 1, DashboardUid: dash.UID, AnnotationsEnabled: true}
-
+		fakeStore := FakePublicDashboardStore{}
 		fakeStore.On("FindByAccessToken", mock.Anything, mock.AnythingOfType("string")).Return(pubdash, nil)
-		fakeStore.On("FindDashboard", mock.Anything, mock.Anything, mock.AnythingOfType("string")).Return(dash, nil)
+		fakeDashboardService := &dashboards.FakeDashboardService{}
+		fakeDashboardService.On("GetDashboard", mock.Anything, mock.Anything, mock.Anything).Return(dash, nil)
+
+		service := &PublicDashboardServiceImpl{
+			log:              log.New("test.logger"),
+			store:            &fakeStore,
+			AnnotationsRepo:  &annotationsRepo,
+			dashboardService: fakeDashboardService,
+		}
 
 		annotationsRepo.On("Find", mock.Anything, mock.Anything).Return(nil, errors.New("failed")).Maybe()
 
@@ -1081,19 +1097,14 @@ func TestFindAnnotations(t *testing.T) {
 
 		annos := []DashAnnotation{grafanaAnnotation}
 		dashboard := AddAnnotationsToDashboard(t, dash, annos)
-
-		annotationsRepo := annotations.FakeAnnotationsRepo{}
-		fakeStore := FakePublicDashboardStore{}
-		service := &PublicDashboardServiceImpl{
-			log:             log.New("test.logger"),
-			store:           &fakeStore,
-			AnnotationsRepo: &annotationsRepo,
-		}
 		pubdash := &PublicDashboard{Uid: "uid1", IsEnabled: true, OrgId: 1, DashboardUid: dashboard.UID, AnnotationsEnabled: true}
 
+		fakeStore := FakePublicDashboardStore{}
 		fakeStore.On("FindByAccessToken", mock.Anything, mock.AnythingOfType("string")).Return(pubdash, nil)
-		fakeStore.On("FindDashboard", mock.Anything, mock.Anything, mock.AnythingOfType("string")).Return(dashboard, nil)
+		fakeStore.On("FindByAccessToken", mock.Anything, mock.AnythingOfType("string")).Return(pubdash, nil)
-
+		fakeDashboardService := &dashboards.FakeDashboardService{}
+		fakeDashboardService.On("GetDashboard", mock.Anything, mock.Anything, mock.Anything).Return(dashboard, nil)
+		annotationsRepo := annotations.FakeAnnotationsRepo{}
 		annotationsRepo.On("Find", mock.Anything, mock.Anything).Return([]*annotations.ItemDTO{
 			{
 				ID:          1,
@@ -1106,6 +1117,13 @@ func TestFindAnnotations(t *testing.T) {
 			},
 		}, nil).Maybe()
 
+		service := &PublicDashboardServiceImpl{
+			log:              log.New("test.logger"),
+			store:            &fakeStore,
+			AnnotationsRepo:  &annotationsRepo,
+			dashboardService: fakeDashboardService,
+		}
+
 		items, err := service.FindAnnotations(context.Background(), AnnotationsQueryDTO{}, "abc123")
 
 		expected := AnnotationEvent{
@@ -1219,6 +1237,8 @@ func TestBuildMetricRequest(t *testing.T) {
 	serviceWrapper := ProvideServiceWrapper(publicdashboardStore)
 	publicDashboard := insertTestDashboard(t, dashboardStore, "testDashie", 1, 0, "", true, []map[string]interface{}{}, nil)
 	nonPublicDashboard := insertTestDashboard(t, dashboardStore, "testNonPublicDashie", 1, 0, "", true, []map[string]interface{}{}, nil)
+	fakeDashboardService := &dashboards.FakeDashboardService{}
+	fakeDashboardService.On("GetDashboard", mock.Anything, mock.Anything, mock.Anything).Return(publicDashboard, nil)
 	from, to := internal.GetTimeRangeFromDashboard(t, publicDashboard.Data)
 
 	service := &PublicDashboardServiceImpl{
@@ -1226,6 +1246,7 @@ func TestBuildMetricRequest(t *testing.T) {
 		store:              publicdashboardStore,
 		intervalCalculator: intervalv2.NewCalculator(),
 		serviceWrapper:     serviceWrapper,
+		dashboardService:   fakeDashboardService,
 	}
 
 	publicDashboardQueryDTO := PublicDashboardQueryDTO{

pkg/services/publicdashboards/service/service.go

@@ -35,6 +35,7 @@ type PublicDashboardServiceImpl struct {
 	AnnotationsRepo    annotations.Repository
 	ac                 accesscontrol.AccessControl
 	serviceWrapper     publicdashboards.ServiceWrapper
+	dashboardService   dashboards.DashboardService
 }
 
 var LogPrefix = "publicdashboards.service"
@@ -52,6 +53,7 @@ func ProvideService(
 	anno annotations.Repository,
 	ac accesscontrol.AccessControl,
 	serviceWrapper publicdashboards.ServiceWrapper,
+	dashboardService dashboards.DashboardService,
 ) *PublicDashboardServiceImpl {
 	return &PublicDashboardServiceImpl{
 		log:                log.New(LogPrefix),
@@ -62,6 +64,7 @@ func ProvideService(
 		AnnotationsRepo:    anno,
 		ac:                 ac,
 		serviceWrapper:     serviceWrapper,
+		dashboardService:   dashboardService,
 	}
 }
 
@@ -108,15 +111,17 @@ func (pd *PublicDashboardServiceImpl) Find(ctx context.Context, uid string) (*Pu
 
 // FindDashboard Gets a dashboard by Uid
 func (pd *PublicDashboardServiceImpl) FindDashboard(ctx context.Context, orgId int64, dashboardUid string) (*dashboards.Dashboard, error) {
-	dash, err := pd.store.FindDashboard(ctx, orgId, dashboardUid)
+	dash, err := pd.dashboardService.GetDashboard(ctx, &dashboards.GetDashboardQuery{UID: dashboardUid, OrgID: orgId})
 	if err != nil {
+		var dashboardErr dashboards.DashboardErr
+		if ok := errors.As(err, &dashboardErr); ok {
+			if dashboardErr.StatusCode == 404 {
+				return nil, ErrDashboardNotFound.Errorf("FindDashboard: dashboard not found by orgId: %d and dashboardUid: %s", orgId, dashboardUid)
+			}
+		}
 		return nil, ErrInternalServerError.Errorf("FindDashboard: failed to find dashboard by orgId: %d and dashboardUid: %s: %w", orgId, dashboardUid, err)
 	}
 
-	if dash == nil {
-		return nil, ErrDashboardNotFound.Errorf("FindDashboard: dashboard not found by orgId: %d and dashboardUid: %s", orgId, dashboardUid)
-	}
-
 	return dash, nil
 }
 
@@ -155,7 +160,7 @@ func (pd *PublicDashboardServiceImpl) FindPublicDashboardAndDashboardByAccessTok
 		return nil, nil, err
 	}
 
-	dash, err := pd.store.FindDashboard(ctx, pubdash.OrgId, pubdash.DashboardUid)
+	dash, err := pd.FindDashboard(ctx, pubdash.OrgId, pubdash.DashboardUid)
 	if err != nil {
 		return nil, nil, err
 	}

pkg/services/publicdashboards/service/service_test.go

@@ -383,13 +383,15 @@ func TestGetPublicDashboardForView(t *testing.T) {
 	for _, test := range testCases {
 		t.Run(test.Name, func(t *testing.T) {
 			fakeStore := FakePublicDashboardStore{}
+			fakeDashboardService := &dashboards.FakeDashboardService{}
 			service := &PublicDashboardServiceImpl{
-				log:   log.New("test.logger"),
+				log:              log.New("test.logger"),
-				store: &fakeStore,
+				store:            &fakeStore,
+				dashboardService: fakeDashboardService,
 			}
 
 			fakeStore.On("FindByAccessToken", mock.Anything, mock.Anything).Return(test.StoreResp.pd, test.StoreResp.err)
-			fakeStore.On("FindDashboard", mock.Anything, mock.Anything, mock.Anything).Return(test.StoreResp.d, test.StoreResp.err)
+			fakeDashboardService.On("GetDashboard", mock.Anything, mock.Anything, mock.Anything).Return(test.StoreResp.d, test.StoreResp.err)
 
 			dashboardFullWithMeta, err := service.GetPublicDashboardForView(context.Background(), test.AccessToken)
 			if test.ErrResp != nil {
@@ -495,14 +497,16 @@ func TestGetPublicDashboard(t *testing.T) {
 
 	for _, test := range testCases {
 		t.Run(test.Name, func(t *testing.T) {
+			fakeDashboardService := &dashboards.FakeDashboardService{}
 			fakeStore := FakePublicDashboardStore{}
 			service := &PublicDashboardServiceImpl{
-				log:   log.New("test.logger"),
+				log:              log.New("test.logger"),
-				store: &fakeStore,
+				store:            &fakeStore,
+				dashboardService: fakeDashboardService,
 			}
 
 			fakeStore.On("FindByAccessToken", mock.Anything, mock.Anything).Return(test.StoreResp.pd, test.StoreResp.err)
-			fakeStore.On("FindDashboard", mock.Anything, mock.Anything, mock.Anything).Return(test.StoreResp.d, test.StoreResp.err)
+			fakeDashboardService.On("GetDashboard", mock.Anything, mock.Anything, mock.Anything).Return(test.StoreResp.d, test.StoreResp.err)
 
 			pdc, dash, err := service.FindPublicDashboardAndDashboardByAccessToken(context.Background(), test.AccessToken)
 			if test.ErrResp != nil {
@@ -562,13 +566,15 @@ func TestGetEnabledPublicDashboard(t *testing.T) {
 	for _, test := range testCases {
 		t.Run(test.Name, func(t *testing.T) {
 			fakeStore := FakePublicDashboardStore{}
+			fakeDashboardService := &dashboards.FakeDashboardService{}
 			service := &PublicDashboardServiceImpl{
-				log:   log.New("test.logger"),
+				log:              log.New("test.logger"),
-				store: &fakeStore,
+				store:            &fakeStore,
+				dashboardService: fakeDashboardService,
 			}
 
 			fakeStore.On("FindByAccessToken", mock.Anything, mock.Anything).Return(test.StoreResp.pd, test.StoreResp.err)
-			fakeStore.On("FindDashboard", mock.Anything, mock.Anything, mock.Anything).Return(test.StoreResp.d, test.StoreResp.err)
+			fakeDashboardService.On("GetDashboard", mock.Anything, mock.Anything, mock.Anything).Return(test.StoreResp.d, test.StoreResp.err)
 
 			pdc, dash, err := service.FindEnabledPublicDashboardAndDashboardByAccessToken(context.Background(), test.AccessToken)
 			if test.ErrResp != nil {
@@ -599,10 +605,14 @@ func TestCreatePublicDashboard(t *testing.T) {
 		dashboard := insertTestDashboard(t, dashboardStore, "testDashie", 1, 0, "", true, []map[string]any{}, nil)
 		serviceWrapper := ProvideServiceWrapper(publicdashboardStore)
 
+		fakeDashboardService := &dashboards.FakeDashboardService{}
+		fakeDashboardService.On("GetDashboard", mock.Anything, mock.Anything, mock.Anything).Return(dashboard, nil)
+
 		service := &PublicDashboardServiceImpl{
-			log:            log.New("test.logger"),
+			log:              log.New("test.logger"),
-			store:          publicdashboardStore,
+			store:            publicdashboardStore,
-			serviceWrapper: serviceWrapper,
+			serviceWrapper:   serviceWrapper,
+			dashboardService: fakeDashboardService,
 		}
 
 		isEnabled, annotationsEnabled, timeSelectionEnabled := true, false, true
@@ -684,11 +694,14 @@ func TestCreatePublicDashboard(t *testing.T) {
 			publicdashboardStore := database.ProvideStore(sqlStore, sqlStore.Cfg, featuremgmt.WithFeatures())
 			dashboard := insertTestDashboard(t, dashboardStore, "testDashie", 1, 0, "", true, []map[string]any{}, nil)
 			serviceWrapper := ProvideServiceWrapper(publicdashboardStore)
+			fakeDashboardService := &dashboards.FakeDashboardService{}
+			fakeDashboardService.On("GetDashboard", mock.Anything, mock.Anything, mock.Anything).Return(dashboard, nil)
 
 			service := &PublicDashboardServiceImpl{
-				log:            log.New("test.logger"),
+				log:              log.New("test.logger"),
-				store:          publicdashboardStore,
+				store:            publicdashboardStore,
-				serviceWrapper: serviceWrapper,
+				serviceWrapper:   serviceWrapper,
+				dashboardService: fakeDashboardService,
 			}
 
 			dto := &SavePublicDashboardDTO{
@@ -723,10 +736,14 @@ func TestCreatePublicDashboard(t *testing.T) {
 		dashboard := insertTestDashboard(t, dashboardStore, "testDashie", 1, 0, "", true, []map[string]any{}, nil)
 		serviceWrapper := ProvideServiceWrapper(publicdashboardStore)
 
+		fakeDashboardService := &dashboards.FakeDashboardService{}
+		fakeDashboardService.On("GetDashboard", mock.Anything, mock.Anything, mock.Anything).Return(dashboard, nil)
+
 		service := &PublicDashboardServiceImpl{
-			log:            log.New("test.logger"),
+			log:              log.New("test.logger"),
-			store:          publicdashboardStore,
+			store:            publicdashboardStore,
-			serviceWrapper: serviceWrapper,
+			serviceWrapper:   serviceWrapper,
+			dashboardService: fakeDashboardService,
 		}
 
 		isEnabled := true
@@ -756,11 +773,14 @@ func TestCreatePublicDashboard(t *testing.T) {
 		templateVars := make([]map[string]any, 1)
 		dashboard := insertTestDashboard(t, dashboardStore, "testDashie", 1, 0, "", true, templateVars, nil)
 		serviceWrapper := ProvideServiceWrapper(publicdashboardStore)
+		fakeDashboardService := &dashboards.FakeDashboardService{}
+		fakeDashboardService.On("GetDashboard", mock.Anything, mock.Anything, mock.Anything).Return(dashboard, nil)
 
 		service := &PublicDashboardServiceImpl{
-			log:            log.New("test.logger"),
+			log:              log.New("test.logger"),
-			store:          publicdashboardStore,
+			store:            publicdashboardStore,
-			serviceWrapper: serviceWrapper,
+			serviceWrapper:   serviceWrapper,
+			dashboardService: fakeDashboardService,
 		}
 
 		isEnabled := true
@@ -795,16 +815,18 @@ func TestCreatePublicDashboard(t *testing.T) {
 		}
 
 		publicDashboardStore := &FakePublicDashboardStore{}
-		publicDashboardStore.On("FindDashboard", mock.Anything, mock.Anything, mock.Anything).Return(dashboard, nil)
 		publicDashboardStore.On("Find", mock.Anything, "ExistingUid").Return(pubdash, nil)
 		publicDashboardStore.On("FindByDashboardUid", mock.Anything, mock.Anything, mock.Anything).Return(nil, ErrPublicDashboardNotFound.Errorf(""))
+		fakeDashboardService := &dashboards.FakeDashboardService{}
+		fakeDashboardService.On("GetDashboard", mock.Anything, mock.Anything, mock.Anything).Return(dashboard, nil)
 
 		serviceWrapper := ProvideServiceWrapper(publicDashboardStore)
 
 		service := &PublicDashboardServiceImpl{
-			log:            log.New("test.logger"),
+			log:              log.New("test.logger"),
-			store:          publicDashboardStore,
+			store:            publicDashboardStore,
-			serviceWrapper: serviceWrapper,
+			serviceWrapper:   serviceWrapper,
+			dashboardService: fakeDashboardService,
 		}
 
 		isEnabled := true
@@ -831,11 +853,14 @@ func TestCreatePublicDashboard(t *testing.T) {
 		publicdashboardStore := database.ProvideStore(sqlStore, sqlStore.Cfg, featuremgmt.WithFeatures())
 		dashboard := insertTestDashboard(t, dashboardStore, "testDashie", 1, 0, "", true, []map[string]any{}, nil)
 		serviceWrapper := ProvideServiceWrapper(publicdashboardStore)
+		fakeDashboardService := &dashboards.FakeDashboardService{}
+		fakeDashboardService.On("GetDashboard", mock.Anything, mock.Anything, mock.Anything).Return(dashboard, nil)
 
 		service := &PublicDashboardServiceImpl{
-			log:            log.New("test.logger"),
+			log:              log.New("test.logger"),
-			store:          publicdashboardStore,
+			store:            publicdashboardStore,
-			serviceWrapper: serviceWrapper,
+			serviceWrapper:   serviceWrapper,
+			dashboardService: fakeDashboardService,
 		}
 
 		isEnabled := true
@@ -872,17 +897,18 @@ func TestCreatePublicDashboard(t *testing.T) {
 		}
 
 		publicDashboardStore := &FakePublicDashboardStore{}
-		publicDashboardStore.On("FindDashboard", mock.Anything, mock.Anything, mock.Anything).Return(dashboard, nil)
 		publicDashboardStore.On("Find", mock.Anything, mock.Anything).Return(nil, nil)
 		publicDashboardStore.On("FindByAccessToken", mock.Anything, "ExistingAccessToken").Return(pubdash, nil)
 		publicDashboardStore.On("FindByDashboardUid", mock.Anything, mock.Anything, mock.Anything).Return(nil, ErrPublicDashboardNotFound.Errorf(""))
-
+		fakeDashboardService := &dashboards.FakeDashboardService{}
+		fakeDashboardService.On("GetDashboard", mock.Anything, mock.Anything, mock.Anything).Return(dashboard, nil)
 		serviceWrapper := ProvideServiceWrapper(publicDashboardStore)
 
 		service := &PublicDashboardServiceImpl{
-			log:            log.New("test.logger"),
+			log:              log.New("test.logger"),
-			store:          publicDashboardStore,
+			store:            publicDashboardStore,
-			serviceWrapper: serviceWrapper,
+			serviceWrapper:   serviceWrapper,
+			dashboardService: fakeDashboardService,
 		}
 
 		isEnabled := true
@@ -909,11 +935,14 @@ func TestCreatePublicDashboard(t *testing.T) {
 		publicdashboardStore := database.ProvideStore(sqlStore, sqlStore.Cfg, featuremgmt.WithFeatures())
 		dashboard := insertTestDashboard(t, dashboardStore, "testDashie", 1, 0, "", true, []map[string]interface{}{}, nil)
 		serviceWrapper := ProvideServiceWrapper(publicdashboardStore)
+		fakeDashboardService := &dashboards.FakeDashboardService{}
+		fakeDashboardService.On("GetDashboard", mock.Anything, mock.Anything, mock.Anything).Return(dashboard, nil)
 
 		service := &PublicDashboardServiceImpl{
-			log:            log.New("test.logger"),
+			log:              log.New("test.logger"),
-			store:          publicdashboardStore,
+			store:            publicdashboardStore,
-			serviceWrapper: serviceWrapper,
+			serviceWrapper:   serviceWrapper,
+			dashboardService: fakeDashboardService,
 		}
 
 		isEnabled := true
@@ -972,15 +1001,16 @@ func TestCreatePublicDashboard(t *testing.T) {
 
 		publicdashboardStore := &FakePublicDashboardStore{}
 		publicdashboardStore.On("FindByDashboardUid", mock.Anything, mock.Anything, mock.Anything).Return(&PublicDashboard{Uid: "newPubdashUid"}, nil)
-		publicdashboardStore.On("FindDashboard", mock.Anything, mock.Anything, mock.Anything).Return(dashboard, nil)
 		publicdashboardStore.On("Find", mock.Anything, mock.Anything).Return(nil, nil)
-
+		fakeDashboardService := &dashboards.FakeDashboardService{}
+		fakeDashboardService.On("GetDashboard", mock.Anything, mock.Anything, mock.Anything).Return(dashboard, nil)
 		serviceWrapper := ProvideServiceWrapper(publicdashboardStore)
 
 		service := &PublicDashboardServiceImpl{
-			log:            log.New("test.logger"),
+			log:              log.New("test.logger"),
-			store:          publicdashboardStore,
+			store:            publicdashboardStore,
-			serviceWrapper: serviceWrapper,
+			serviceWrapper:   serviceWrapper,
+			dashboardService: fakeDashboardService,
 		}
 
 		isEnabled, annotationsEnabled := true, false
@@ -1007,11 +1037,14 @@ func TestCreatePublicDashboard(t *testing.T) {
 		publicdashboardStore := database.ProvideStore(sqlStore, sqlStore.Cfg, featuremgmt.WithFeatures())
 		dashboard := insertTestDashboard(t, dashboardStore, "testDashie", 1, 0, "", true, []map[string]any{}, nil)
 		serviceWrapper := ProvideServiceWrapper(publicdashboardStore)
+		fakeDashboardService := &dashboards.FakeDashboardService{}
+		fakeDashboardService.On("GetDashboard", mock.Anything, mock.Anything, mock.Anything).Return(dashboard, nil)
 
 		service := &PublicDashboardServiceImpl{
-			log:            log.New("test.logger"),
+			log:              log.New("test.logger"),
-			store:          publicdashboardStore,
+			store:            publicdashboardStore,
-			serviceWrapper: serviceWrapper,
+			serviceWrapper:   serviceWrapper,
+			dashboardService: fakeDashboardService,
 		}
 
 		isEnabled := true
@@ -1051,11 +1084,13 @@ func TestUpdatePublicDashboard(t *testing.T) {
 	serviceWrapper := ProvideServiceWrapper(publicdashboardStore)
 	dashboard := insertTestDashboard(t, dashboardStore, "testDashie", 1, 0, "", true, []map[string]any{}, nil)
 	dashboard2 := insertTestDashboard(t, dashboardStore, "testDashie2", 1, 0, "", true, []map[string]any{}, nil)
-
+	fakeDashboardService := &dashboards.FakeDashboardService{}
+	fakeDashboardService.On("GetDashboard", mock.Anything, mock.Anything, mock.Anything).Return(dashboard, nil)
 	service := &PublicDashboardServiceImpl{
-		log:            log.New("test.logger"),
+		log:              log.New("test.logger"),
-		store:          publicdashboardStore,
+		store:            publicdashboardStore,
-		serviceWrapper: serviceWrapper,
+		serviceWrapper:   serviceWrapper,
+		dashboardService: fakeDashboardService,
 	}
 
 	t.Run("Updating public dashboard", func(t *testing.T) {
@@ -1170,7 +1205,9 @@ func TestUpdatePublicDashboard(t *testing.T) {
 			UserId:          7,
 			PublicDashboard: &PublicDashboardDTO{},
 		}
-
+		fds := &dashboards.FakeDashboardService{}
+		fds.On("GetDashboard", mock.Anything, mock.Anything, mock.Anything).Return(nil, dashboards.ErrDashboardNotFound)
+		service.dashboardService = fds
 		updatedPubdash, err := service.Update(context.Background(), SignedInUser, dto)
 		assert.Error(t, err)
 
@@ -1236,11 +1273,14 @@ func TestUpdatePublicDashboard(t *testing.T) {
 			publicdashboardStore := database.ProvideStore(sqlStore, sqlStore.Cfg, featuremgmt.WithFeatures())
 			serviceWrapper := ProvideServiceWrapper(publicdashboardStore)
 			dashboard := insertTestDashboard(t, dashboardStore, "testDashie", 1, 0, "", true, []map[string]any{}, nil)
+			fakeDashboardService := &dashboards.FakeDashboardService{}
+			fakeDashboardService.On("GetDashboard", mock.Anything, mock.Anything, mock.Anything).Return(dashboard, nil)
 
 			service := &PublicDashboardServiceImpl{
-				log:            log.New("test.logger"),
+				log:              log.New("test.logger"),
-				store:          publicdashboardStore,
+				store:            publicdashboardStore,
-				serviceWrapper: serviceWrapper,
+				serviceWrapper:   serviceWrapper,
+				dashboardService: fakeDashboardService,
 			}
 
 			isEnabled, annotationsEnabled, timeSelectionEnabled := true, true, false

public/app/features/dashboard/services/DashboardLoaderSrv.ts

@@ -59,6 +59,8 @@ export class DashboardLoaderSrv {
             e.data.statusCode === 403 && e.data.messageId === 'publicdashboards.notEnabled';
           const isPublicDashboardNotFound =
             e.data.statusCode === 404 && e.data.messageId === 'publicdashboards.notFound';
+          const isDashboardNotFound =
+            e.data.statusCode === 404 && e.data.messageId === 'publicdashboards.dashboardNotFound';
 
           const dashboardModel = this._dashboardLoadFailed(
             isPublicDashboardPaused ? 'Public Dashboard paused' : 'Public Dashboard Not found',
@@ -69,7 +71,7 @@ export class DashboardLoaderSrv {
             meta: {
               ...dashboardModel.meta,
               publicDashboardEnabled: isPublicDashboardNotFound ? undefined : !isPublicDashboardPaused,
-              dashboardNotFound: isPublicDashboardNotFound,
+              dashboardNotFound: isPublicDashboardNotFound || isDashboardNotFound,
             },
           };
         });