define(function (require) {
var chrome = require('ui/chrome');
var routes = require('ui/routes');
routes.when('/default', {
resolve: {
defaultPath: function ($location, $window, Private) {
var urlHelper = Private(require('ui/kibi/helpers/url_helper'));
var app = chrome.getApp();
var tabs = chrome.getTabs();
urlHelper.getInitialPath(app, tabs).then(function (path) {
if (path.indexOf('http') === 0) {
$window.location.href = path;
} else {
$location.path(path);
}
}).catch(function (err) {
// fallback to what kibana would do by default
$location.path(`/${chrome.getInjected('kbnDefaultAppId', 'discover')}`);
});
}
}
});
});
} from '../../common/constants/search';
import { annotationsRefresh$ } from '../services/annotations_service';
import { interval$ } from '../components/controls/select_interval/select_interval';
import { severity$ } from '../components/controls/select_severity/select_severity';
import { setGlobalState, getSelectedJobIds } from '../components/job_selector/job_select_service_utils';
import chrome from 'ui/chrome';
let mlAnnotationsEnabled = chrome.getInjected('mlAnnotationsEnabled', false);
uiRoutes
.when('/timeseriesexplorer/?', {
template,
k7Breadcrumbs: getSingleMetricViewerBreadcrumbs,
resolve: {
CheckLicense: checkFullLicense,
privileges: checkGetJobsPrivilege,
indexPatterns: loadIndexPatterns,
mlNodeCount: getMlNodeCount,
jobs: mlJobService.loadJobsWrapper
}
});
import { uiModules } from 'ui/modules';
const module = uiModules.get('apps/ml');
module.controller('MlTimeSeriesExplorerController', function (
$injector,
$scope,
$timeout,
Private,
AppState,
routes.when(`${BASE_PATH}:view?/:action?/:id?`, {
template: template,
k7Breadcrumbs: () => [
MANAGEMENT_BREADCRUMB,
{
text: i18n.translate('xpack.idxMgmt.breadcrumb', {
defaultMessage: 'Index management'
}),
}
],
controllerAs: 'indexManagement',
controller: class IndexManagementController {
constructor($scope, $route, $http, kbnUrl, $rootScope) {
// clean up previously rendered React app if one exists
// this happens because of React Router redirects
elem && unmountComponentAtNode(elem);
// NOTE: We depend upon Angular's $http service because it's decorated with interceptors,
// e.g. to check license status per request.
setHttpClient($http);
setUrlService({
change(url) {
kbnUrl.change(url);
$rootScope.$digest();
}
});
$scope.$$postDigest(() => {
elem = document.getElementById('indexManagementReactRoot');
renderReact(elem);
manageAngularLifecycle($scope, $route, elem);
});
}
}
});
import _ from 'lodash';
import angular from 'angular';
import rison from 'rison-node';
import { savedObjectManagementRegistry } from 'plugins/kibana/management/saved_object_registry';
import objectViewHTML from 'plugins/kibana/management/sections/objects/_view.html';
import { IndexPatternsCastMappingTypeProvider } from 'ui/index_patterns/_cast_mapping_type';
import uiRoutes from 'ui/routes';
import { uiModules } from 'ui/modules';
uiRoutes
.when('/management/kibana/objects/:service/:id', {
template: objectViewHTML
});
uiModules.get('apps/management')
.directive('kbnManagementObjectsView', function (kbnIndex, Notifier, confirmModal) {
return {
restrict: 'E',
controller: function ($scope, $injector, $routeParams, $location, $window, $rootScope, esAdmin, Private) {
const notify = new Notifier({ location: 'SavedObject view' });
const castMappingType = Private(IndexPatternsCastMappingTypeProvider);
const serviceObj = savedObjectManagementRegistry.get($routeParams.service);
const service = $injector.get(serviceObj.service);
/**
* Creates a field definition and pushes it to the memo stack. This function
* is designed to be used in conjunction with _.reduce(). If the
* values is plain object it will recurse through all the keys till it hits
* a string, number or an array.
*
* @param {array} memo The stack of fields
import { SavedObjectSaveModal } from 'ui/saved_objects/components/saved_object_save_modal';
import { getEditBreadcrumbs, getCreateBreadcrumbs } from '../breadcrumbs';
uiRoutes
.when(VisualizeConstants.CREATE_PATH, {
template: editorTemplate,
k7Breadcrumbs: getCreateBreadcrumbs,
resolve: {
savedVis: function (savedVisualizations, redirectWhenMissing, $route, Private, i18n) {
const visTypes = Private(VisTypesRegistryProvider);
const visType = _.find(visTypes, { name: $route.current.params.type });
const shouldHaveIndex = visType.requiresSearch && visType.options.showIndexSelection;
const hasIndex = $route.current.params.indexPattern || $route.current.params.savedSearchId;
if (shouldHaveIndex && !hasIndex) {
throw new Error(
i18n('kbn.visualize.createVisualization.noIndexPatternOrSavedSearchIdErrorMessage', {
defaultMessage: 'You must provide either an indexPattern or a savedSearchId',
})
);
}
return savedVisualizations.get($route.current.params)
.catch(redirectWhenMissing({
'*': '/visualize'
}));
}
}
})
.when(`${VisualizeConstants.EDIT_PATH}/:id`, {
template: editorTemplate,
k7Breadcrumbs: getEditBreadcrumbs,
import { VisualizeConstants } from '../visualize_constants';
import routes from 'ui/routes';
import { VisTypesRegistryProvider } from 'ui/registry/vis_types';
import { uiModules } from 'ui/modules';
import visualizeWizardStep1Template from './step_1.html';
import visualizeWizardStep2Template from './step_2.html';
const module = uiModules.get('app/visualize', ['kibana/courier']);
/********
/** Wizard Step 1
/********/
// Redirect old route to new route.
routes.when('/visualize/step/1', {
redirectTo: VisualizeConstants.WIZARD_STEP_1_PAGE_PATH,
});
routes.when(VisualizeConstants.WIZARD_STEP_1_PAGE_PATH, {
template: visualizeWizardStep1Template,
controller: 'VisualizeWizardStep1',
});
module.controller('VisualizeWizardStep1', function ($scope, $route, kbnUrl, timefilter, Private) {
timefilter.enabled = false;
const VisType = Private(VisVisTypeProvider);
const visTypeCategoryToHumanReadableMap = {
[VisType.CATEGORY.BASIC]: 'Basic Charts',
[VisType.CATEGORY.DATA]: 'Data',
import { SingleMetricJobServiceProvider } from './create_job_service';
import { FullTimeRangeSelectorServiceProvider } from 'plugins/ml/components/full_time_range_selector/full_time_range_selector_service';
import { mlMessageBarService } from 'plugins/ml/components/messagebar/messagebar_service';
import { initPromise } from 'plugins/ml/util/promise';
import template from './create_job.html';
import { timefilter } from 'ui/timefilter';
uiRoutes
.when('/jobs/new_job/simple/single_metric', {
template,
resolve: {
CheckLicense: checkLicenseExpired,
privileges: checkCreateJobsPrivilege,
indexPattern: loadCurrentIndexPattern,
savedSearch: loadCurrentSavedSearch,
checkMlNodesAvailable,
loadNewJobDefaults,
initPromise: initPromise(true)
}
});
import { uiModules } from 'ui/modules';
const module = uiModules.get('apps/ml');
module
.controller('MlCreateSingleMetricJob', function (
$scope,
$route,
$filter,
import 'plugins/kibana/management/sections/indices/_scripted_fields';
import 'plugins/kibana/management/sections/indices/source_filters/source_filters';
import 'plugins/kibana/management/sections/indices/_index_header';
import RefreshKibanaIndex from 'plugins/kibana/management/sections/indices/_refresh_kibana_index';
import UrlProvider from 'ui/url';
import IndicesEditSectionsProvider from 'plugins/kibana/management/sections/indices/_edit_sections';
import uiRoutes from 'ui/routes';
import uiModules from 'ui/modules';
import editTemplate from 'plugins/kibana/management/sections/indices/_edit.html';
uiRoutes
.when('/management/kibana/indices/:indexPatternId', {
template: editTemplate,
resolve: {
indexPattern: function ($route, courier) {
return courier.indexPatterns
.get($route.current.params.indexPatternId)
.catch(courier.redirectWhenMissing('/management/kibana/index'));
}
}
});
uiRoutes
.when('/management/kibana/indices', {
resolve: {
redirect: function ($location, config) {
const defaultIndex = config.get('defaultIndex');
let path = '/management/kibana/index';
if (defaultIndex) {
path = `/management/kibana/indices/${defaultIndex}`;
import { getMlNodeCount } from 'plugins/ml/ml_nodes_check/check_ml_nodes';
import { FilterLists } from './filter_lists';
import uiRoutes from 'ui/routes';
const template = `
<div class="euiSpacer euiSpacer--s" />
<ml-nav-menu name="settings" />
<ml-filter-lists />
`;
uiRoutes
.when('/settings/filter_lists', {
template,
k7Breadcrumbs: getFilterListsBreadcrumbs,
resolve: {
CheckLicense: checkFullLicense,
privileges: checkGetJobsPrivilege,
mlNodeCount: getMlNodeCount,
}
});
module.directive('mlFilterLists', function () {
return {
restrict: 'E',
replace: false,
scope: {},
link: function (element) {
const props = {
canCreateFilter: checkPermission('canCreateFilter'),
canDeleteFilter: checkPermission('canDeleteFilter'),
};
import { saveAs } from '@spalger/filesaver';
import { find, flattenDeep, pluck, sortBy } from 'lodash';
import angular from 'angular';
import { savedObjectManagementRegistry } from 'plugins/kibana/management/saved_object_registry';
import objectIndexHTML from 'plugins/kibana/management/sections/objects/_objects.html';
import 'ui/directives/file_upload';
import uiRoutes from 'ui/routes';
import { SavedObjectsClientProvider } from 'ui/saved_objects';
import { uiModules } from 'ui/modules';
uiRoutes
.when('/management/kibana/objects', {
template: objectIndexHTML
});
uiRoutes
.when('/management/kibana/objects/:service', {
redirectTo: '/management/kibana/objects'
});
uiModules.get('apps/management')
.directive('kbnManagementObjects', function (kbnIndex, Notifier, Private, kbnUrl, Promise, confirmModal) {
const savedObjectsClient = Private(SavedObjectsClientProvider);
return {
restrict: 'E',
controllerAs: 'managementObjectsController',
controller: function ($scope, $injector, $q, AppState) {
const notify = new Notifier({ location: 'Saved Objects' });
// TODO: Migrate all scope variables to the controller.
import 'ui/autoload/styles';
import chrome from 'ui/chrome';
import { hashUrl } from 'ui/state_management/state_hashing';
import uiRoutes from 'ui/routes';
uiRoutes.enable();
uiRoutes
.when('/', {
resolve: {
url: function (AppState, globalState, $window) {
const redirectUrl = chrome.getInjected('redirectUrl');
const hashedUrl = hashUrl([new AppState(), globalState], redirectUrl);
const url = chrome.addBasePath(hashedUrl);
$window.location = url;
}
}
});
* you may not use this file except in compliance with the Elastic License.
*/
import React from 'react';
import { render, unmountComponentAtNode } from 'react-dom';
import routes from 'ui/routes';
import template from 'plugins/security/views/management/roles_grid/roles.html';
import { ROLES_PATH } from '../management_urls';
import { getRolesBreadcrumbs } from '../breadcrumbs';
import { I18nContext } from 'ui/i18n';
import { RolesGridPage } from './components';
routes.when(ROLES_PATH, {
template,
k7Breadcrumbs: getRolesBreadcrumbs,
controller($scope) {
$scope.$$postDigest(() => {
const domNode = document.getElementById('rolesGridReactRoot');
render(
<I18nContext>
<RolesGridPage />
</I18nContext>, domNode);
// unmount react on controller destroy
$scope.$on('$destroy', () => {
unmountComponentAtNode(domNode);
});
});
},
});
app.directive('homeApp', function (reactDirective) {
return reactDirective(HomeApp);
});
function getRoute() {
return {
template,
controller($scope, config, indexPatterns, Private) {
$scope.addBasePath = chrome.addBasePath;
$scope.directories = Private(FeatureCatalogueRegistryProvider).inTitleOrder;
$scope.recentlyAccessed = recentlyAccessed.get().map(item => {
item.link = chrome.addBasePath(item.link);
return item;
});
$scope.getConfig = (...args) => config.get(...args);
$scope.setConfig = (...args) => config.set(...args);
$scope.clearIndexPatternsCache = () => {
const getter = indexPatterns.getIds;
getter.clearCache();
};
}
};
}
// All routing will be handled inside HomeApp via react, we just need to make sure angular doesn't
// redirect us to the default page by encountering a url it isn't marked as being able to handle.
routes.when('/home', getRoute());
routes.when('/home/feature_directory', getRoute());
routes.when('/home/tutorial_directory/:tab?', getRoute());
routes.when('/home/tutorial/:id', getRoute());
uiRoutes.when('/apm/instances', {
template,
resolve: {
clusters: function (Private) {
const routeInit = Private(routeInitProvider);
return routeInit();
},
},
controller: class extends MonitoringViewBaseEuiTableController {
constructor($injector, $scope, i18n) {
const $route = $injector.get('$route');
const globalState = $injector.get('globalState');
$scope.cluster = find($route.current.locals.clusters, {
cluster_uuid: globalState.cluster_uuid
});
super({
title: i18n('xpack.monitoring.apm.instances.routeTitle', {
defaultMessage: '{apm} - Instances',
values: {
apm: 'APM'
}
}),
storageKey: 'apm.instances',
api: `../api/monitoring/v1/clusters/${globalState.cluster_uuid}/apm/instances`,
defaultData: {},
reactNodeId: 'apmInstancesReact',
$scope,
$injector
});
$scope.$watch(() => this.data, data => {
this.renderReact(data);
});
}
renderReact(data) {
const {
pagination,
sorting,
onTableChange,
} = this;
const component = (
<I18nContext>
<ApmServerInstances
apms={{
pagination,
sorting,
onTableChange,
data,
}}
/>
</I18nContext>
);
super.renderReact(component);
}
}
});
uiRoutes.when('/kibana', {
template,
resolve: {
clusters: function (Private) {
const routeInit = Private(routeInitProvider);
return routeInit();
},
pageData: getPageData
},
controller($injector, $scope) {
timefilter.enableTimeRangeSelector();
timefilter.enableAutoRefreshSelector();
const $route = $injector.get('$route');
const globalState = $injector.get('globalState');
$scope.cluster = find($route.current.locals.clusters, { cluster_uuid: globalState.cluster_uuid });
$scope.pageData = $route.current.locals.pageData;
const title = $injector.get('title');
title($scope.cluster, 'Kibana');
const $executor = $injector.get('$executor');
$executor.register({
execute: () => getPageData($injector),
handleResponse: (response) => $scope.pageData = response
});
$executor.start($scope);
$scope.$on('$destroy', $executor.destroy);
}
});
uiRoutes.when('/elasticsearch/ml_jobs', {
template,
resolve: {
clusters: function (Private) {
const routeInit = Private(routeInitProvider);
return routeInit();
},
pageData: getPageData
},
controllerAs: 'mlJobs',
controller: class MlJobsList extends MonitoringViewBaseEuiTableController {
constructor($injector, $scope, i18n) {
super({
title: i18n('xpack.monitoring.elasticsearch.mlJobs.routeTitle', {
defaultMessage: 'Elasticsearch - Machine Learning Jobs'
}),
storageKey: 'elasticsearch.mlJobs',
getPageData,
$scope,
$injector
});
const $route = $injector.get('$route');
this.data = $route.current.locals.pageData;
const globalState = $injector.get('globalState');
$scope.cluster = find($route.current.locals.clusters, { cluster_uuid: globalState.cluster_uuid });
}
}
});
uiRoutes.enable();
}
uiRoutes
.when('/home', {
template: appTemplate,
k7Breadcrumbs: getHomeBreadcrumbs,
resolve: {
//Copied from example found in wizard.js ( Kibana TODO - can't
// IndexPatternsProvider abstract these implementation details better?)
indexPatterns: function (Private) {
const savedObjectsClient = Private(SavedObjectsClientProvider);
return savedObjectsClient.find({
type: 'index-pattern',
fields: ['title', 'type'],
perPage: 10000
}).then(response => response.savedObjects);
},
GetIndexPatternProvider: function (Private) {
return Private(IndexPatternsProvider);
},
SavedWorkspacesProvider: function (Private) {
return Private(SavedWorkspacesProvider);
},
CheckLicense: checkLicense
}
})
.when('/workspace/:id', {
template: appTemplate,
k7Breadcrumbs: getWorkspaceBreadcrumbs,
import 'ace';
import 'angular-ui-ace';
import 'plugins/searchprofiler/directives';
import { Range } from './range';
import { nsToPretty } from 'plugins/searchprofiler/filters/ns_to_pretty';
import { msToPretty } from 'plugins/searchprofiler/filters/ms_to_pretty';
import { checkForParseErrors } from 'plugins/searchprofiler/app_util.js';
// Styles and templates
import 'ui/autoload/all';
import './less/main.less';
import template from './templates/index.html';
import { defaultQuery } from './templates/default_query';
uiRoutes.when('/dev_tools/searchprofiler', {
template: template
});
uiModules
.get('app/searchprofiler', ['ui.bootstrap.buttons', 'ui.ace'])
.controller('profileViz', profileVizController)
.filter('nsToPretty', () => nsToPretty)
.filter('msToPretty', () => msToPretty)
.factory('HighlightService', () => {
const service = {
details: null
};
return service;
});
function profileVizController($scope, $route, $interval, $http, HighlightService, Private) {
import 'ui/field_editor';
import 'plugins/kibana/settings/sections/indices/_index_header';
import IndexPatternsFieldProvider from 'ui/index_patterns/_field';
import UrlProvider from 'ui/url';
import uiRoutes from 'ui/routes';
import fieldEditorTemplate from 'plugins/kibana/settings/sections/indices/_field_editor.html';
uiRoutes
.when('/settings/indices/:indexPatternId/field/:fieldName', { mode: 'edit' })
.when('/settings/indices/:indexPatternId/create-field/', { mode: 'create' })
.defaults(/settings\/indices\/[^\/]+\/(field|create-field)(\/|$)/, {
template: fieldEditorTemplate,
resolve: {
indexPattern: function ($route, courier) {
return courier.indexPatterns.get($route.current.params.indexPatternId)
.catch(courier.redirectWhenMissing('/settings/indices'));
}
},
controllerAs: 'fieldSettings',
controller: function FieldEditorPageController($route, Private, Notifier, docTitle) {
const Field = Private(IndexPatternsFieldProvider);
const notify = new Notifier({ location: 'Field Editor' });
const kbnUrl = Private(UrlProvider);
this.mode = $route.current.mode;
this.indexPattern = $route.current.locals.indexPattern;
if (this.mode === 'edit') {
const fieldName = $route.current.params.fieldName;
elem
);
};
routes.when(`${EDIT_USERS_PATH}/:username?`, {
template,
k7Breadcrumbs: ($injector, $route) => $injector.invoke(
$route.current.params.username
? getEditUserBreadcrumbs
: getCreateUserBreadcrumbs
),
controllerAs: 'editUser',
controller($scope, $route, kbnUrl, $http) {
$scope.$on('$destroy', () => {
const elem = document.getElementById('editUserReactRoot');
if (elem) {
unmountComponentAtNode(elem);
}
});
$scope.$$postDigest(() => {
const elem = document.getElementById('editUserReactRoot');
const username = $route.current.params.username;
const changeUrl = (url) => {
kbnUrl.change(url);
$scope.$apply();
};
renderReact(elem, $http, changeUrl, username);
});
},
});
/*
* Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
* or more contributor license agreements. Licensed under the Elastic License;
* you may not use this file except in compliance with the Elastic License.
*/
import uiRoutes from 'ui/routes';
import { routeInitProvider } from 'plugins/monitoring/lib/route_init';
import template from './index.html';
import { ElasticsearchOverviewController } from './controller';
uiRoutes.when('/elasticsearch', {
template,
resolve: {
clusters(Private) {
const routeInit = Private(routeInitProvider);
return routeInit();
}
},
controllerAs: 'elasticsearchOverview',
controller: ElasticsearchOverviewController
});
import 'plugins/kibana/visualize/styles/main.less';
import 'plugins/kibana/visualize/editor/editor';
import 'plugins/kibana/visualize/wizard/wizard';
import 'plugins/kibana/visualize/editor/add_bucket_agg';
import 'plugins/kibana/visualize/editor/agg';
import 'plugins/kibana/visualize/editor/agg_add';
import 'plugins/kibana/visualize/editor/agg_filter';
import 'plugins/kibana/visualize/editor/agg_group';
import 'plugins/kibana/visualize/editor/agg_param';
import 'plugins/kibana/visualize/editor/agg_params';
import 'plugins/kibana/visualize/editor/nesting_indicator';
import 'plugins/kibana/visualize/editor/sidebar';
import 'plugins/kibana/visualize/editor/vis_options';
import 'plugins/kibana/visualize/saved_visualizations/_saved_vis';
import 'plugins/kibana/visualize/saved_visualizations/saved_visualizations';
import uiRoutes from 'ui/routes';
uiRoutes
.when('/visualize', {
redirectTo: '/visualize/step/1'
});
// preloading
require('ui/saved_objects/saved_object_registry')
.register(require('plugins/kibana/visualize/saved_visualizations/saved_visualization_register'));
uiRoutes.when('/management/kibana/index', {
template: angularTemplate,
controller: function ($scope, $injector) {
// Wait for the directives to execute
const kbnUrl = $injector.get('kbnUrl');
$scope.$$postDigest(() => {
const $routeParams = $injector.get('$routeParams');
const services = {
config: $injector.get('config'),
es: $injector.get('es'),
indexPatterns: $injector.get('indexPatterns'),
savedObjectsClient: $injector.get('Private')(SavedObjectsClientProvider),
changeUrl: url => {
$scope.$evalAsync(() => kbnUrl.changePath(url));
},
};
const initialQuery = $routeParams.id ? decodeURIComponent($routeParams.id) : undefined;
renderCreateIndexPatternWizard(
documentationLinks.indexPatterns.loadingData,
initialQuery,
services
);
});
$scope.$on('$destroy', destroyCreateIndexPatternWizard);
}
});
/*
* Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
* or more contributor license agreements. Licensed under the Elastic License;
* you may not use this file except in compliance with the Elastic License.
*/
import uiRoutes from 'ui/routes';
import template from './index.html';
import { NoDataController } from './controller';
uiRoutes
.when('/no-data', {
template,
resolve: {
clusters: $injector => {
const monitoringClusters = $injector.get('monitoringClusters');
const kbnUrl = $injector.get('kbnUrl');
return monitoringClusters().then(clusters => {
if (clusters && clusters.length) {
kbnUrl.changePath('/home');
return Promise.reject();
}
return Promise.resolve();
});
}
},
controller: NoDataController
})
.otherwise({ redirectTo: '/home' });
routes.when(`${EDIT_ROLES_PATH}/:name?`, {
template,
k7Breadcrumbs: ($injector, $route) => $injector.invoke(
$route.current.params.name
? getEditRoleBreadcrumbs
: getCreateRoleBreadcrumbs
),
resolve: {
role($route, ShieldRole, kbnUrl, Promise, Notifier) {
const name = $route.current.params.name;
let role;
if (name != null) {
role = ShieldRole.get({ name }).$promise
.catch((response) => {
if (response.status !== 404) {
return fatalError(response);
}
const notifier = new Notifier();
notifier.error(`No "${name}" role found.`);
kbnUrl.redirect(ROLES_PATH);
return Promise.halt();
});
} else {
role = Promise.resolve(new ShieldRole({
elasticsearch: {
cluster: [],
indices: [],
run_as: [],
},
kibana: {
global: [],
space: {},
},
_unrecognized_applications: [],
}));
}
return role.then(res => res.toJSON());
},
users(ShieldUser, kbnUrl, Promise, Private) {
// $promise is used here because the result is an ngResource, not a promise itself
return ShieldUser.query().$promise
.then(users => _.map(users, 'username'))
.catch(checkLicenseError(kbnUrl, Promise, Private));
},
indexPatterns(Private) {
const indexPatterns = Private(IndexPatternsProvider);
return indexPatterns.getTitles();
},
spaces($http, chrome, spacesEnabled) {
if (spacesEnabled) {
return new SpacesManager($http, chrome).getSpaces();
}
return [];
}
},
controllerAs: 'editRole',
controller($injector, $scope, $http, enableSpaceAwarePrivileges) {
const $route = $injector.get('$route');
const Private = $injector.get('Private');
const role = $route.current.locals.role;
const xpackInfo = Private(XPackInfoProvider);
const userProfile = Private(UserProfileProvider);
const allowDocumentLevelSecurity = xpackInfo.get('features.security.allowRoleDocumentLevelSecurity');
const allowFieldLevelSecurity = xpackInfo.get('features.security.allowRoleFieldLevelSecurity');
const rbacApplication = chrome.getInjected('rbacApplication');
if (role.elasticsearch.indices.length === 0) {
const emptyOption = {
names: [],
privileges: []
};
if (allowFieldLevelSecurity) {
emptyOption.field_security = {
grant: ['*']
};
}
if (allowDocumentLevelSecurity) {
emptyOption.query = '';
}
role.elasticsearch.indices.push(emptyOption);
}
const {
users,
indexPatterns,
spaces,
} = $route.current.locals;
$scope.$$postDigest(() => {
const domNode = document.getElementById('editRoleReactRoot');
render(
<I18nContext>
<EditRolePage
runAsUsers={users}
role={role}
kibanaAppPrivileges={KibanaAppPrivileges}
indexPatterns={indexPatterns}
rbacEnabled={true}
rbacApplication={rbacApplication}
httpClient={$http}
allowDocumentLevelSecurity={allowDocumentLevelSecurity}
allowFieldLevelSecurity={allowFieldLevelSecurity}
spaces={spaces}
spacesEnabled={enableSpaceAwarePrivileges}
userProfile={userProfile}
/>
</I18nContext>, domNode);
// unmount react on controller destroy
$scope.$on('$destroy', () => {
unmountComponentAtNode(domNode);
});
});
}
});
uiRoutes.when('/kibana/instances', {
template,
resolve: {
clusters(Private) {
const routeInit = Private(routeInitProvider);
return routeInit();
},
pageData: getPageData,
},
controllerAs: 'kibanas',
controller: class KibanaInstancesList extends MonitoringViewBaseEuiTableController {
constructor($injector, $scope) {
super({
title: 'Kibana Instances',
storageKey: 'kibana.instances',
getPageData,
reactNodeId: 'monitoringKibanaInstancesApp',
$scope,
$injector
});
const kbnUrl = $injector.get('kbnUrl');
$scope.$watch(() => this.data, data => {
if (!data || !data.kibanas) {
return;
}
const dataFlattened = data.kibanas.map(item => ({
...item,
name: item.kibana.name,
status: item.kibana.status,
}));
this.renderReact(
<I18nContext>
<EuiPage>
<EuiPageBody>
<EuiPanel>
<ClusterStatus stats={$scope.pageData.clusterStatus} />
</EuiPanel>
<EuiSpacer size="m" />
<EuiPageContent>
<EuiMonitoringTable
className="kibanaInstancesTable"
rows={dataFlattened}
columns={getColumns(kbnUrl, $scope)}
sorting={this.sorting}
pagination={this.pagination}
search={{
box: {
incremental: true,
placeholder: i18n.translate('xpack.monitoring.kibana.listing.filterInstancesPlaceholder', {
defaultMessage: 'Filter Instances…'
})
},
}}
onTableChange={this.onTableChange}
executeQueryOptions={{
defaultFields: ['name']
}}
/>
</EuiPageContent>
</EuiPageBody>
</EuiPage>
</I18nContext>
);
});
}
}
});
fields: ['title', 'type'],
perPage: 10000
}).then(response => response.savedObjects);
}
};
// add a dependency to all of the subsection routes
uiRoutes
.defaults(/management\/kibana\/(index_patterns|index_pattern)/, {
resolve: indexPatternsResolutions,
requireUICapability: 'management.kibana.index_patterns',
});
uiRoutes
.when('/management/kibana/index_patterns', {
template: indexPatternListTemplate,
k7Breadcrumbs: getListBreadcrumbs
});
// wrapper directive, which sets some global stuff up like the left nav
uiModules.get('apps/management')
.directive('kbnManagementIndexPatterns', function ($route, config, kbnUrl, Private) {
return {
restrict: 'E',
transclude: true,
template: indexTemplate,
link: async function ($scope) {
const indexPatternListProvider = Private(IndexPatternListFactory)();
const indexPatternCreationProvider = Private(IndexPatternCreationFactory)();
const indexPatternCreationOptions = await indexPatternCreationProvider.getIndexPatternCreationOptions((url) => {
$scope.$evalAsync(() => kbnUrl.change(url));
import template from './timeseriesexplorer.html';
import { getMlNodeCount } from 'plugins/ml/ml_nodes_check/check_ml_nodes';
import { ml } from 'plugins/ml/services/ml_api_service';
import { mlJobService } from 'plugins/ml/services/job_service';
import { mlFieldFormatService } from 'plugins/ml/services/field_format_service';
import { JobSelectServiceProvider } from 'plugins/ml/components/job_select_list/job_select_service';
import { mlForecastService } from 'plugins/ml/services/forecast_service';
import { mlTimeSeriesSearchService } from 'plugins/ml/timeseriesexplorer/timeseries_search_service';
import { initPromise } from 'plugins/ml/util/promise';
uiRoutes
.when('/timeseriesexplorer/?', {
template,
resolve: {
CheckLicense: checkLicense,
privileges: checkGetJobsPrivilege,
indexPatterns: loadIndexPatterns,
mlNodeCount: getMlNodeCount,
initPromise: initPromise(true)
}
});
import { uiModules } from 'ui/modules';
const module = uiModules.get('apps/ml');
module.controller('MlTimeSeriesExplorerController', function (
$scope,
$route,
$timeout,
Private,
AppState,
* Controller for the first step in the Create Job wizard, allowing the user to
* select the Kibana index pattern or saved search to use for creating a job.
*/
import uiRoutes from 'ui/routes';
import { checkLicenseExpired } from 'plugins/ml/license/check_license';
import { preConfiguredJobRedirect } from 'plugins/ml/jobs/new_job/wizard/preconfigured_job_redirect';
import { checkCreateJobsPrivilege } from 'plugins/ml/privilege/check_privilege';
import { loadIndexPatterns, getIndexPatterns } from 'plugins/ml/util/index_utils';
import { checkMlNodesAvailable } from 'plugins/ml/ml_nodes_check/check_ml_nodes';
import { initPromise } from 'plugins/ml/util/promise';
import template from './index_or_search.html';
import { timefilter } from 'ui/timefilter';
uiRoutes
.when('/jobs/new_job', {
redirectTo: '/jobs/new_job/step/index_or_search'
});
uiRoutes
.when('/jobs/new_job/step/index_or_search', {
template,
resolve: {
CheckLicense: checkLicenseExpired,
privileges: checkCreateJobsPrivilege,
indexPatterns: loadIndexPatterns,
preConfiguredJobRedirect,
checkMlNodesAvailable,
initPromise: initPromise(true)
}
});
routes.when(`${BASE_PATH}/:section?/:view?/:id?`, {
template: template,
controllerAs: 'ccr',
controller: class CrossClusterReplicationController {
constructor($scope, $route, $http) {
/**
* React-router's <Redirect> does not play well with the angular router. It will cause this controller
* to re-execute without the $destroy handler being called. This means that the app will be mounted twice
* creating a memory leak when leaving (only 1 app will be unmounted).
* To avoid this, we unmount the React app each time we enter the controller.
*/
unmountReactApp();
// NOTE: We depend upon Angular's $http service because it's decorated with interceptors,
// e.g. to check license status per request.
setHttpClient($http);
$scope.$$postDigest(() => {
elem = document.getElementById(CCR_REACT_ROOT);
renderReact(elem);
// Angular Lifecycle
const appRoute = $route.current;
const stopListeningForLocationChange = $scope.$on('$locationChangeSuccess', () => {
const currentRoute = $route.current;
const isNavigationInApp = currentRoute.$$route.template === appRoute.$$route.template;
// When we navigate within CCR, prevent Angular from re-matching the route and rebuild the app
if (isNavigationInApp) {
$route.current = appRoute;
} else {
// Any clean up when User leaves the CCR
}
$scope.$on('$destroy', () => {
stopListeningForLocationChange && stopListeningForLocationChange();
unmountReactApp();
});
});
});
}
}
});