Disable url tracking for dashboard

src/legacy/core_plugins/kibana/index.js

@@ -106,6 +106,7 @@ export default function(kibana) {
           // to determine what url to use for the app link.
           subUrlBase: `${kbnBaseUrl}#/dashboard`,
           euiIconType: 'dashboardApp',
+          disableSubUrlTracking: true,
           category: DEFAULT_APP_CATEGORIES.analyze,
         },
         {

src/legacy/core_plugins/kibana/public/dashboard/legacy.ts

@@ -41,6 +41,7 @@ async function getAngularDependencies(): Promise<LegacyAngularInjectedDependenci
   const instance = plugin({} as PluginInitializerContext);
   instance.setup(npSetup.core, {
     ...npSetup.plugins,
+    npData: npSetup.plugins.data,
     __LEGACY: {
       getAngularDependencies,
     },

src/legacy/core_plugins/kibana/public/dashboard/np_ready/application.ts

@@ -74,7 +74,6 @@ export const renderApp = (element: HTMLElement, appBasePath: string, deps: Rende
     angularModuleInstance = createLocalAngularModule(deps.core, deps.navigation);
     // global routing stuff
     configureAppAngularModule(angularModuleInstance, deps.core as LegacyCoreStart, true);
-    // custom routing stuff
     initDashboardApp(angularModuleInstance, deps);
   }
 

src/legacy/core_plugins/kibana/public/dashboard/plugin.ts

@@ -17,6 +17,7 @@
  * under the License.
  */
 
+import { BehaviorSubject } from 'rxjs';
 import {
   App,
   CoreSetup,
@@ -28,7 +29,10 @@ import {
 import { i18n } from '@kbn/i18n';
 import { RenderDeps } from './np_ready/application';
 import { DataStart } from '../../../data/public';
-import { DataPublicPluginStart as NpDataStart } from '../../../../../plugins/data/public';
+import {
+  DataPublicPluginStart as NpDataStart,
+  DataPublicPluginSetup as NpDataSetup,
+} from '../../../../../plugins/data/public';
 import { IEmbeddableStart } from '../../../../../plugins/embeddable/public';
 import { Storage } from '../../../../../plugins/kibana_utils/public';
 import { NavigationPublicPluginStart as NavigationStart } from '../../../../../plugins/navigation/public';
@@ -38,8 +42,13 @@ import {
   HomePublicPluginSetup,
 } from '../../../../../plugins/home/public';
 import { SharePluginStart } from '../../../../../plugins/share/public';
-import { KibanaLegacySetup } from '../../../../../plugins/kibana_legacy/public';
+import {
+  AngularRenderedAppUpdater,
+  KibanaLegacySetup,
+} from '../../../../../plugins/kibana_legacy/public';
 import { createSavedDashboardLoader } from './saved_dashboard/saved_dashboards';
+import { createKbnUrlTracker } from '../../../../../plugins/kibana_utils/public/state_management/url/kbn_url_tracker';
+import { getQueryStateContainer } from '../../../../../plugins/data/public/query/state_sync/sync_query';
 
 export interface LegacyAngularInjectedDependencies {
   dashboardConfig: any;
@@ -59,6 +68,7 @@ export interface DashboardPluginSetupDependencies {
   };
   home: HomePublicPluginSetup;
   kibana_legacy: KibanaLegacySetup;
+  npData: NpDataSetup;
 }
 
 export class DashboardPlugin implements Plugin {
@@ -70,17 +80,46 @@ export class DashboardPlugin implements Plugin {
     share: SharePluginStart;
   } | null = null;
 
+  private appStateUpdater = new BehaviorSubject<AngularRenderedAppUpdater>(() => ({}));
+  private stopUrlTracking: (() => void) | undefined = undefined;
+
   public setup(
     core: CoreSetup,
-    { __LEGACY: { getAngularDependencies }, home, kibana_legacy }: DashboardPluginSetupDependencies
+    {
+      __LEGACY: { getAngularDependencies },
+      home,
+      kibana_legacy,
+      npData,
+    }: DashboardPluginSetupDependencies
   ) {
+    const { querySyncStateContainer, stop: stopQuerySyncStateContainer } = getQueryStateContainer(
+      npData.query
+    );
+    const { appMounted, appUnMounted, stop: stopUrlTracker } = createKbnUrlTracker({
+      baseUrl: core.http.basePath.prepend('/app/kibana'),
+      defaultSubUrl: '#/dashboards',
+      storageKey: 'lastUrl:dashboard',
+      navLinkUpdater$: this.appStateUpdater,
+      toastNotifications: core.notifications.toasts,
+      stateParams: [
+        {
+          kbnUrlKey: '_g',
+          stateUpdate$: querySyncStateContainer.state$,
+        },
+      ],
+    });
+    this.stopUrlTracking = () => {
+      stopQuerySyncStateContainer();
+      stopUrlTracker();
+    };
     const app: App = {
       id: '',
       title: 'Dashboards',
       mount: async ({ core: contextCore }, params) => {
         if (this.startDependencies === null) {
           throw new Error('not started yet');
         }
+        appMounted();
         const {
           savedObjectsClient,
           embeddables,
@@ -113,10 +152,20 @@ export class DashboardPlugin implements Plugin {
           localStorage: new Storage(localStorage),
         };
         const { renderApp } = await import('./np_ready/application');
-        return renderApp(params.element, params.appBasePath, deps);
+        const unmount = renderApp(params.element, params.appBasePath, deps);
+        return () => {
+          unmount();
+          appUnMounted();
+        };
       },
     };
-    kibana_legacy.registerLegacyApp({ ...app, id: 'dashboard' });
+    kibana_legacy.registerLegacyApp({
+      ...app,
+      id: 'dashboard',
+      // only register the updater in once app, otherwise all updates would happen twice
+      updater$: this.appStateUpdater.asObservable(),
+      navLinkId: 'kibana:dashboard',
+    });
     kibana_legacy.registerLegacyApp({ ...app, id: 'dashboards' });
 
     home.featureCatalogue.register({
@@ -146,4 +195,10 @@ export class DashboardPlugin implements Plugin {
       share,
     };
   }
+
+  stop() {
+    if (this.stopUrlTracking) {
+      this.stopUrlTracking();
+    }
+  }
 }

src/legacy/core_plugins/kibana/public/local_application_service/local_application_service.ts

@@ -79,6 +79,17 @@ export class LocalApplicationService {
           })();
         },
       });
+
+      if (app.updater$) {
+        app.updater$.subscribe(updater => {
+          const updatedFields = updater(app);
+          if (updatedFields && updatedFields.activeUrl) {
+            npStart.core.chrome.navLinks.update(app.navLinkId || app.id, {
+              url: updatedFields.activeUrl,
+            });
+          }
+        });
+      }
     });
 
     npStart.plugins.kibana_legacy.getForwards().forEach(({ legacyAppId, newAppId, keepPrefix }) => {

src/plugins/data/public/query/state_sync/sync_query.test.ts

@@ -31,7 +31,7 @@ import {
 import { QueryService, QueryStart } from '../query_service';
 import { StubBrowserStorage } from 'test_utils/stub_browser_storage';
 import { TimefilterContract } from '../timefilter';
-import { QuerySyncState, syncQuery } from './sync_query';
+import { getQueryStateContainer, QuerySyncState, syncQuery } from './sync_query';
 
 const setupMock = coreMock.createSetup();
 const startMock = coreMock.createStart();
@@ -163,4 +163,69 @@ describe('sync_query', () => {
     expect(spy).not.toBeCalled();
     stop();
   });
+
+  describe('getQueryStateContainer', () => {
+    test('state is initialized with state from query service', () => {
+      const { stop, querySyncStateContainer, initialState } = getQueryStateContainer(
+        queryServiceStart
+      );
+      expect(querySyncStateContainer.getState()).toMatchInlineSnapshot(`
+        Object {
+          "filters": Array [],
+          "refreshInterval": Object {
+            "pause": true,
+            "value": 0,
+          },
+          "time": Object {
+            "from": "now-15m",
+            "to": "now",
+          },
+        }
+      `);
+      expect(initialState).toEqual(querySyncStateContainer.getState());
+      stop();
+    });
+
+    test('state takes initial overrides into account', () => {
+      const { stop, querySyncStateContainer, initialState } = getQueryStateContainer(
+        queryServiceStart,
+        {
+          time: { from: 'now-99d', to: 'now' },
+        }
+      );
+      expect(querySyncStateContainer.getState().time).toEqual({
+        from: 'now-99d',
+        to: 'now',
+      });
+      expect(initialState).toEqual(querySyncStateContainer.getState());
+      stop();
+    });
+
+    test('when filters change, state container contains updated global filters', () => {
+      const { stop, querySyncStateContainer } = getQueryStateContainer(queryServiceStart);
+      filterManager.setFilters([gF, aF]);
+      expect(querySyncStateContainer.getState().filters).toHaveLength(1);
+      stop();
+    });
+
+    test('when time range changes, state container contains updated time range', () => {
+      const { stop, querySyncStateContainer } = getQueryStateContainer(queryServiceStart);
+      timefilter.setTime({ from: 'now-30m', to: 'now' });
+      expect(querySyncStateContainer.getState().time).toEqual({
+        from: 'now-30m',
+        to: 'now',
+      });
+      stop();
+    });
+
+    test('when refresh interval changes, state container contains updated refresh interval', () => {
+      const { stop, querySyncStateContainer } = getQueryStateContainer(queryServiceStart);
+      timefilter.setRefreshInterval({ pause: true, value: 100 });
+      expect(querySyncStateContainer.getState().refreshInterval).toEqual({
+        pause: true,
+        value: 100,
+      });
+      stop();
+    });
+  });
 });