dashboard.go 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461
  1. package api
  2. import (
  3. "encoding/json"
  4. "fmt"
  5. "os"
  6. "path"
  7. "github.com/grafana/grafana/pkg/services/dashboards"
  8. "github.com/grafana/grafana/pkg/api/dtos"
  9. "github.com/grafana/grafana/pkg/bus"
  10. "github.com/grafana/grafana/pkg/components/dashdiffs"
  11. "github.com/grafana/grafana/pkg/components/simplejson"
  12. "github.com/grafana/grafana/pkg/log"
  13. "github.com/grafana/grafana/pkg/metrics"
  14. "github.com/grafana/grafana/pkg/middleware"
  15. m "github.com/grafana/grafana/pkg/models"
  16. "github.com/grafana/grafana/pkg/plugins"
  17. "github.com/grafana/grafana/pkg/services/guardian"
  18. "github.com/grafana/grafana/pkg/setting"
  19. "github.com/grafana/grafana/pkg/util"
  20. )
  21. func isDashboardStarredByUser(c *middleware.Context, dashId int64) (bool, error) {
  22. if !c.IsSignedIn {
  23. return false, nil
  24. }
  25. query := m.IsStarredByUserQuery{UserId: c.UserId, DashboardId: dashId}
  26. if err := bus.Dispatch(&query); err != nil {
  27. return false, err
  28. }
  29. return query.Result, nil
  30. }
  31. func dashboardGuardianResponse(err error) Response {
  32. if err != nil {
  33. return ApiError(500, "Error while checking dashboard permissions", err)
  34. } else {
  35. return ApiError(403, "Access denied to this dashboard", nil)
  36. }
  37. }
  38. func GetDashboard(c *middleware.Context) Response {
  39. dash, rsp := getDashboardHelper(c.OrgId, c.Params(":slug"), 0, c.Params(":uid"))
  40. if rsp != nil {
  41. return rsp
  42. }
  43. guardian := guardian.NewDashboardGuardian(dash.Id, c.OrgId, c.SignedInUser)
  44. if canView, err := guardian.CanView(); err != nil || !canView {
  45. fmt.Printf("%v", err)
  46. return dashboardGuardianResponse(err)
  47. }
  48. canEdit, _ := guardian.CanEdit()
  49. canSave, _ := guardian.CanSave()
  50. canAdmin, _ := guardian.CanAdmin()
  51. isStarred, err := isDashboardStarredByUser(c, dash.Id)
  52. if err != nil {
  53. return ApiError(500, "Error while checking if dashboard was starred by user", err)
  54. }
  55. // Finding creator and last updater of the dashboard
  56. updater, creator := "Anonymous", "Anonymous"
  57. if dash.UpdatedBy > 0 {
  58. updater = getUserLogin(dash.UpdatedBy)
  59. }
  60. if dash.CreatedBy > 0 {
  61. creator = getUserLogin(dash.CreatedBy)
  62. }
  63. meta := dtos.DashboardMeta{
  64. IsStarred: isStarred,
  65. Slug: dash.Slug,
  66. Type: m.DashTypeDB,
  67. CanStar: c.IsSignedIn,
  68. CanSave: canSave,
  69. CanEdit: canEdit,
  70. CanAdmin: canAdmin,
  71. Created: dash.Created,
  72. Updated: dash.Updated,
  73. UpdatedBy: updater,
  74. CreatedBy: creator,
  75. Version: dash.Version,
  76. HasAcl: dash.HasAcl,
  77. IsFolder: dash.IsFolder,
  78. FolderId: dash.FolderId,
  79. FolderTitle: "Root",
  80. }
  81. // lookup folder title
  82. if dash.FolderId > 0 {
  83. query := m.GetDashboardQuery{Id: dash.FolderId, OrgId: c.OrgId}
  84. if err := bus.Dispatch(&query); err != nil {
  85. return ApiError(500, "Dashboard folder could not be read", err)
  86. }
  87. meta.FolderTitle = query.Result.Title
  88. }
  89. if dash.IsFolder {
  90. meta.Url = m.GetFolderUrl(dash.Uid, dash.Slug)
  91. } else {
  92. meta.Url = m.GetDashboardUrl(dash.Uid, dash.Slug)
  93. }
  94. // make sure db version is in sync with json model version
  95. dash.Data.Set("version", dash.Version)
  96. dto := dtos.DashboardFullWithMeta{
  97. Dashboard: dash.Data,
  98. Meta: meta,
  99. }
  100. c.TimeRequest(metrics.M_Api_Dashboard_Get)
  101. return Json(200, dto)
  102. }
  103. func GetDashboardUidBySlug(c *middleware.Context) Response {
  104. dash, rsp := getDashboardHelper(c.OrgId, c.Params(":slug"), 0, "")
  105. if rsp != nil {
  106. return rsp
  107. }
  108. guardian := guardian.NewDashboardGuardian(dash.Id, c.OrgId, c.SignedInUser)
  109. if canView, err := guardian.CanView(); err != nil || !canView {
  110. fmt.Printf("%v", err)
  111. return dashboardGuardianResponse(err)
  112. }
  113. return Json(200, util.DynMap{"uid": dash.Uid})
  114. }
  115. func getUserLogin(userId int64) string {
  116. query := m.GetUserByIdQuery{Id: userId}
  117. err := bus.Dispatch(&query)
  118. if err != nil {
  119. return "Anonymous"
  120. } else {
  121. user := query.Result
  122. return user.Login
  123. }
  124. }
  125. func getDashboardHelper(orgId int64, slug string, id int64, uid string) (*m.Dashboard, Response) {
  126. var query m.GetDashboardQuery
  127. if len(uid) > 0 {
  128. query = m.GetDashboardQuery{Uid: uid, Id: id, OrgId: orgId}
  129. } else {
  130. query = m.GetDashboardQuery{Slug: slug, Id: id, OrgId: orgId}
  131. }
  132. if err := bus.Dispatch(&query); err != nil {
  133. return nil, ApiError(404, "Dashboard not found", err)
  134. }
  135. return query.Result, nil
  136. }
  137. func DeleteDashboard(c *middleware.Context) Response {
  138. dash, rsp := getDashboardHelper(c.OrgId, c.Params(":slug"), 0, "")
  139. if rsp != nil {
  140. return rsp
  141. }
  142. guardian := guardian.NewDashboardGuardian(dash.Id, c.OrgId, c.SignedInUser)
  143. if canSave, err := guardian.CanSave(); err != nil || !canSave {
  144. return dashboardGuardianResponse(err)
  145. }
  146. cmd := m.DeleteDashboardCommand{OrgId: c.OrgId, Id: dash.Id}
  147. if err := bus.Dispatch(&cmd); err != nil {
  148. return ApiError(500, "Failed to delete dashboard", err)
  149. }
  150. var resp = map[string]interface{}{"title": dash.Title}
  151. return Json(200, resp)
  152. }
  153. func PostDashboard(c *middleware.Context, cmd m.SaveDashboardCommand) Response {
  154. cmd.OrgId = c.OrgId
  155. cmd.UserId = c.UserId
  156. dash := cmd.GetDashboardModel()
  157. guardian := guardian.NewDashboardGuardian(dash.Id, c.OrgId, c.SignedInUser)
  158. if canSave, err := guardian.CanSave(); err != nil || !canSave {
  159. return dashboardGuardianResponse(err)
  160. }
  161. if dash.IsFolder && dash.FolderId > 0 {
  162. return ApiError(400, m.ErrDashboardFolderCannotHaveParent.Error(), nil)
  163. }
  164. // Check if Title is empty
  165. if dash.Title == "" {
  166. return ApiError(400, m.ErrDashboardTitleEmpty.Error(), nil)
  167. }
  168. if dash.Id == 0 {
  169. limitReached, err := middleware.QuotaReached(c, "dashboard")
  170. if err != nil {
  171. return ApiError(500, "failed to get quota", err)
  172. }
  173. if limitReached {
  174. return ApiError(403, "Quota reached", nil)
  175. }
  176. }
  177. dashItem := &dashboards.SaveDashboardItem{
  178. Dashboard: dash,
  179. Message: cmd.Message,
  180. OrgId: c.OrgId,
  181. UserId: c.UserId,
  182. Overwrite: cmd.Overwrite,
  183. }
  184. dashboard, err := dashboards.GetRepository().SaveDashboard(dashItem)
  185. if err == m.ErrDashboardTitleEmpty {
  186. return ApiError(400, m.ErrDashboardTitleEmpty.Error(), nil)
  187. }
  188. if err == m.ErrDashboardContainsInvalidAlertData {
  189. return ApiError(500, "Invalid alert data. Cannot save dashboard", err)
  190. }
  191. if err != nil {
  192. if err == m.ErrDashboardWithSameNameExists {
  193. return Json(412, util.DynMap{"status": "name-exists", "message": err.Error()})
  194. }
  195. if err == m.ErrDashboardVersionMismatch {
  196. return Json(412, util.DynMap{"status": "version-mismatch", "message": err.Error()})
  197. }
  198. if pluginErr, ok := err.(m.UpdatePluginDashboardError); ok {
  199. message := "The dashboard belongs to plugin " + pluginErr.PluginId + "."
  200. // look up plugin name
  201. if pluginDef, exist := plugins.Plugins[pluginErr.PluginId]; exist {
  202. message = "The dashboard belongs to plugin " + pluginDef.Name + "."
  203. }
  204. return Json(412, util.DynMap{"status": "plugin-dashboard", "message": message})
  205. }
  206. if err == m.ErrDashboardNotFound {
  207. return Json(404, util.DynMap{"status": "not-found", "message": err.Error()})
  208. }
  209. return ApiError(500, "Failed to save dashboard", err)
  210. }
  211. if err == m.ErrDashboardFailedToUpdateAlertData {
  212. return ApiError(500, "Invalid alert data. Cannot save dashboard", err)
  213. }
  214. c.TimeRequest(metrics.M_Api_Dashboard_Save)
  215. return Json(200, util.DynMap{"status": "success", "slug": dashboard.Slug, "version": dashboard.Version, "id": dashboard.Id, "uid": dashboard.Uid})
  216. }
  217. func GetHomeDashboard(c *middleware.Context) Response {
  218. prefsQuery := m.GetPreferencesWithDefaultsQuery{OrgId: c.OrgId, UserId: c.UserId}
  219. if err := bus.Dispatch(&prefsQuery); err != nil {
  220. return ApiError(500, "Failed to get preferences", err)
  221. }
  222. if prefsQuery.Result.HomeDashboardId != 0 {
  223. slugQuery := m.GetDashboardSlugByIdQuery{Id: prefsQuery.Result.HomeDashboardId}
  224. err := bus.Dispatch(&slugQuery)
  225. if err == nil {
  226. dashRedirect := dtos.DashboardRedirect{RedirectUri: "db/" + slugQuery.Result}
  227. return Json(200, &dashRedirect)
  228. } else {
  229. log.Warn("Failed to get slug from database, %s", err.Error())
  230. }
  231. }
  232. filePath := path.Join(setting.StaticRootPath, "dashboards/home.json")
  233. file, err := os.Open(filePath)
  234. if err != nil {
  235. return ApiError(500, "Failed to load home dashboard", err)
  236. }
  237. dash := dtos.DashboardFullWithMeta{}
  238. dash.Meta.IsHome = true
  239. dash.Meta.CanEdit = c.SignedInUser.HasRole(m.ROLE_EDITOR)
  240. dash.Meta.FolderTitle = "Root"
  241. jsonParser := json.NewDecoder(file)
  242. if err := jsonParser.Decode(&dash.Dashboard); err != nil {
  243. return ApiError(500, "Failed to load home dashboard", err)
  244. }
  245. if c.HasUserRole(m.ROLE_ADMIN) && !c.HasHelpFlag(m.HelpFlagGettingStartedPanelDismissed) {
  246. addGettingStartedPanelToHomeDashboard(dash.Dashboard)
  247. }
  248. return Json(200, &dash)
  249. }
  250. func addGettingStartedPanelToHomeDashboard(dash *simplejson.Json) {
  251. panels := dash.Get("panels").MustArray()
  252. newpanel := simplejson.NewFromAny(map[string]interface{}{
  253. "type": "gettingstarted",
  254. "id": 123123,
  255. "gridPos": map[string]interface{}{
  256. "x": 0,
  257. "y": 3,
  258. "w": 24,
  259. "h": 4,
  260. },
  261. })
  262. panels = append(panels, newpanel)
  263. dash.Set("panels", panels)
  264. }
  265. // GetDashboardVersions returns all dashboard versions as JSON
  266. func GetDashboardVersions(c *middleware.Context) Response {
  267. dashId := c.ParamsInt64(":dashboardId")
  268. guardian := guardian.NewDashboardGuardian(dashId, c.OrgId, c.SignedInUser)
  269. if canSave, err := guardian.CanSave(); err != nil || !canSave {
  270. return dashboardGuardianResponse(err)
  271. }
  272. query := m.GetDashboardVersionsQuery{
  273. OrgId: c.OrgId,
  274. DashboardId: dashId,
  275. Limit: c.QueryInt("limit"),
  276. Start: c.QueryInt("start"),
  277. }
  278. if err := bus.Dispatch(&query); err != nil {
  279. return ApiError(404, fmt.Sprintf("No versions found for dashboardId %d", dashId), err)
  280. }
  281. for _, version := range query.Result {
  282. if version.RestoredFrom == version.Version {
  283. version.Message = "Initial save (created by migration)"
  284. continue
  285. }
  286. if version.RestoredFrom > 0 {
  287. version.Message = fmt.Sprintf("Restored from version %d", version.RestoredFrom)
  288. continue
  289. }
  290. if version.ParentVersion == 0 {
  291. version.Message = "Initial save"
  292. }
  293. }
  294. return Json(200, query.Result)
  295. }
  296. // GetDashboardVersion returns the dashboard version with the given ID.
  297. func GetDashboardVersion(c *middleware.Context) Response {
  298. dashId := c.ParamsInt64(":dashboardId")
  299. guardian := guardian.NewDashboardGuardian(dashId, c.OrgId, c.SignedInUser)
  300. if canSave, err := guardian.CanSave(); err != nil || !canSave {
  301. return dashboardGuardianResponse(err)
  302. }
  303. query := m.GetDashboardVersionQuery{
  304. OrgId: c.OrgId,
  305. DashboardId: dashId,
  306. Version: c.ParamsInt(":id"),
  307. }
  308. if err := bus.Dispatch(&query); err != nil {
  309. return ApiError(500, fmt.Sprintf("Dashboard version %d not found for dashboardId %d", query.Version, dashId), err)
  310. }
  311. creator := "Anonymous"
  312. if query.Result.CreatedBy > 0 {
  313. creator = getUserLogin(query.Result.CreatedBy)
  314. }
  315. dashVersionMeta := &m.DashboardVersionMeta{
  316. DashboardVersion: *query.Result,
  317. CreatedBy: creator,
  318. }
  319. return Json(200, dashVersionMeta)
  320. }
  321. // POST /api/dashboards/calculate-diff performs diffs on two dashboards
  322. func CalculateDashboardDiff(c *middleware.Context, apiOptions dtos.CalculateDiffOptions) Response {
  323. options := dashdiffs.Options{
  324. OrgId: c.OrgId,
  325. DiffType: dashdiffs.ParseDiffType(apiOptions.DiffType),
  326. Base: dashdiffs.DiffTarget{
  327. DashboardId: apiOptions.Base.DashboardId,
  328. Version: apiOptions.Base.Version,
  329. UnsavedDashboard: apiOptions.Base.UnsavedDashboard,
  330. },
  331. New: dashdiffs.DiffTarget{
  332. DashboardId: apiOptions.New.DashboardId,
  333. Version: apiOptions.New.Version,
  334. UnsavedDashboard: apiOptions.New.UnsavedDashboard,
  335. },
  336. }
  337. result, err := dashdiffs.CalculateDiff(&options)
  338. if err != nil {
  339. if err == m.ErrDashboardVersionNotFound {
  340. return ApiError(404, "Dashboard version not found", err)
  341. }
  342. return ApiError(500, "Unable to compute diff", err)
  343. }
  344. if options.DiffType == dashdiffs.DiffDelta {
  345. return Respond(200, result.Delta).Header("Content-Type", "application/json")
  346. } else {
  347. return Respond(200, result.Delta).Header("Content-Type", "text/html")
  348. }
  349. }
  350. // RestoreDashboardVersion restores a dashboard to the given version.
  351. func RestoreDashboardVersion(c *middleware.Context, apiCmd dtos.RestoreDashboardVersionCommand) Response {
  352. dash, rsp := getDashboardHelper(c.OrgId, "", c.ParamsInt64(":dashboardId"), "")
  353. if rsp != nil {
  354. return rsp
  355. }
  356. guardian := guardian.NewDashboardGuardian(dash.Id, c.OrgId, c.SignedInUser)
  357. if canSave, err := guardian.CanSave(); err != nil || !canSave {
  358. return dashboardGuardianResponse(err)
  359. }
  360. versionQuery := m.GetDashboardVersionQuery{DashboardId: dash.Id, Version: apiCmd.Version, OrgId: c.OrgId}
  361. if err := bus.Dispatch(&versionQuery); err != nil {
  362. return ApiError(404, "Dashboard version not found", nil)
  363. }
  364. version := versionQuery.Result
  365. saveCmd := m.SaveDashboardCommand{}
  366. saveCmd.RestoredFrom = version.Version
  367. saveCmd.OrgId = c.OrgId
  368. saveCmd.UserId = c.UserId
  369. saveCmd.Dashboard = version.Data
  370. saveCmd.Dashboard.Set("version", dash.Version)
  371. saveCmd.Message = fmt.Sprintf("Restored from version %d", version.Version)
  372. return PostDashboard(c, saveCmd)
  373. }
  374. func GetDashboardTags(c *middleware.Context) {
  375. query := m.GetDashboardTagsQuery{OrgId: c.OrgId}
  376. err := bus.Dispatch(&query)
  377. if err != nil {
  378. c.JsonApiErr(500, "Failed to get tags from database", err)
  379. return
  380. }
  381. c.JSON(200, query.Result)
  382. }