console/web/src/pages/DataManagement/context.js

318 lines
8.7 KiB
JavaScript

import {AutocompleteService} from '../../components/kibana/data/public/autocomplete';
import {FilterManager} from '../../components/kibana/data/public/query/filter_manager/filter_manager';
import {QueryStringManager} from '../../components/kibana/data/public/query/query_string/query_string_manager';
import {Timefilter, TimeHistory} from '../../components/kibana/data/public/query/timefilter';
import { useState, useEffect } from 'react';
import { Subscription } from 'rxjs';
import {buildEsQuery} from '../../components/kibana/data/common/es_query/es_query/build_es_query';
import {getCalculateAutoTimeExpression} from '../../components/kibana/data/common/search/aggs/utils/calculate_auto_time_expression';
import {intervalOptions} from '../../components/kibana/data/common/search/aggs/buckets/_interval_options';
import {TimeBuckets} from '../../components/kibana/data/common/search/aggs/buckets/lib/time_buckets/time_buckets';
import moment from 'moment';
// import { fetch } from 'umi-request';
import {Fetch} from '../../components/kibana/core/public/http/fetch';
import {SavedObjectsClient} from '../../components/kibana/core/public/saved_objects/saved_objects_client';
import {getIndexPatterns, setIndexPatterns} from '../../components/kibana/data/public/services';
import {
IndexPatternsService,
onRedirectNoIndexPattern,
onUnsupportedTimePattern,
IndexPatternsApiClient,
SavedObjectsClientPublicToCommon
} from '../../components/kibana/data/public/index_patterns';
import {FieldFormatsRegistry,} from '../../components/kibana/data/common/field_formats';
import {baseFormattersPublic} from '../../components/kibana/data/public/field_formats';
import { deserializeFieldFormat } from '../../components/kibana/data/public/field_formats/utils/deserialize';
const timeBucketConfig = {
'histogram:maxBars': 100,
'histogram:barTarget': 50,
dateFormat: 'YYYY-MM-DD',
'dateFormat:scaled': [
['', 'HH:mm:ss.SSS'],
['PT1S', 'HH:mm:ss'],
['PT1M', 'HH:mm'],
['PT1H', 'YYYY-MM-DD HH:mm'],
['P1DT', 'YYYY-MM-DD'],
['P1YT', 'YYYY'],
],
};
const basePath = {
get:()=>{
return '';
},
prepend: (path)=>{
return path;
},
remove: (url)=>{
return url;
},
serverBasePath: '/api/',
}
const http = new Fetch({
basePath,
});
const savedObjects = new SavedObjectsClient(http);
const savedObjectsClient = new SavedObjectsClientPublicToCommon(savedObjects);
const getFieldFormatsConfig = (key)=>{
return {
['format:defaultTypeMap']: {
"ip": { "id": "ip", "params": {} },
"date": { "id": "date", "params": {} },
"date_nanos": { "id": "date_nanos", "params": {}, "es": true },
"number": { "id": "number", "params": {} },
"boolean": { "id": "boolean", "params": {} },
"histogram": { "id": "histogram", "params": {} },
"_source": { "id": "_source", "params": {} },
"_default_": { "id": "string", "params": {} }
},
'format:number:defaultPattern': '0,0.[000]',
'format:percent:defaultPattern': '0,0.[000]%',
'format:bytes:defaultPattern': '0,0.[0]b',
'format:currency:defaultPattern': '($0,0.[00])',
}[key];
}
const fieldFormats = new FieldFormatsRegistry();
fieldFormats.init(
getFieldFormatsConfig,
{
parsedUrl: {
origin: window.location.origin,
pathname: window.location.pathname,
basePath: basePath.get(),
},
},
baseFormattersPublic
);
fieldFormats.deserialize = deserializeFieldFormat.bind(
fieldFormats
);
const indexPatternsApiClient = new IndexPatternsApiClient(http);
const uiconfigs = {
['metaFields']: ['_source', '_id', '_type', '_index'],//'_score'
defaultIndex: '',
};
const uiSettings = {
get: (key)=>{
return uiconfigs[key]
},
set: (key, val)=>{
return uiconfigs[key] = val;
},
getAll: ()=>{
return uiconfigs;
}
};
const indexPatternService = new IndexPatternsService({
uiSettings,
savedObjectsClient,
apiClient: indexPatternsApiClient,
fieldFormats,
onNotification:()=>{},
onError:()=>{},
onUnsupportedTimePattern,
onRedirectNoIndexPattern,
});
export class Storage {
store;
constructor(store) {
this.store = store;
}
get = (key) => {
if (!this.store) {
return null;
}
const storageItem = this.store.getItem(key);
if (storageItem === null) {
return null;
}
try {
return JSON.parse(storageItem);
} catch (error) {
return null;
}
};
set = (key, value) => {
try {
return this.store.setItem(key, JSON.stringify(value));
} catch (e) {
return false;
}
};
remove = (key) => {
return this.store.removeItem(key);
};
clear = () => {
return this.store.clear();
};
}
const filterManager = new FilterManager();
const storage = new Storage(localStorage);
const queryStringManager = new QueryStringManager(storage);
const timefilterConfig = {
timeDefaults: { from: 'now-1y', to: 'now' },
refreshIntervalDefaults: { pause: true, value: 10000 },
};
const timeHistory = new TimeHistory(storage);
const timefilter = new Timefilter(timefilterConfig, timeHistory);
const autocomplete = new AutocompleteService();
autocomplete.setup({autocomplete: autocomplete, http:http}, {
timefilter,
});
const getConfig = (key)=>{
const kvals = {
"histogram:maxBars": 100,
"histogram:barTarget": 50,
dateFormat: 'strict_date_optional_time',//'YYYY-MM-DD HH:mm:ss',
'dateFormat:scaled': true,
};
return kvals[key] || '';
};
const calculateAutoTimeExpression = getCalculateAutoTimeExpression(getConfig)
// console.log(calculateAutoTimeExpression({
// from: timefilter.getTime().from,
// to: timefilter.getTime().to,
// }))
//const createAggConfigs = startAggService();
const getTimeBuckets = (interval) => {
const timeBuckets = new TimeBuckets(timeBucketConfig);
const bounds = timefilter.getBounds();
// {
// min: moment(timefilter.getAbsoluteTime().from),
// max: moment(timefilter.getAbsoluteTime().to),
// };
timeBuckets.setBounds(bounds);
timeBuckets.setInterval(interval);
return timeBuckets; //.getInterval(true);
}
const defaultFiltersUpdated = () => {
return (filters) => {
filterManager.setFilters(filters);
};
};
// const subscriptions = new Subscription();
// const [getIndexPatterns, setIndexPatterns] = createGetterSetter('IndexPatterns');
export const getContext = ()=>{
return {
autocomplete: autocomplete,
filterManager,
defaultFiltersUpdated,
// useFilterManager,
getIndexPatterns,
setIndexPatterns,
queryStringManager,
storage,
timefilter,
getEsQuery,
//calculateAutoTimeExpression,
getSearchParams,
intervalOptions,
//createAggConfigs,
getTimeBuckets,
fetchESRequest,
services: {
savedObjects:{
client: savedObjects,
savedObjectsClient,
},
data: {
autocomplete,
},
indexPatternService,
},
http,
}
}
const getEsQuery = (indexPattern) => {
const timeFilter = timefilter.createFilter(indexPattern);
return buildEsQuery(
indexPattern,
queryStringManager.getQuery(),
[...filterManager.getFilters(), ...(timeFilter ? [timeFilter] : [])],
// getEsQueryConfig(getUiSettings())
);
}
const getSearchParams = (indexPattern, internal, sort) =>{
// const timeExp = calculateAutoTimeExpression(timefilter.getTime());
const timeExp = getTimeBuckets(internal).getInterval(true).expression;
// console.log(timeExp, internal)
let esSort = indexPattern.timeFieldName ? [{[indexPattern.timeFieldName]: {order: "desc"}}]: [];
if(sort){
esSort = sort.reduce((sorts, s)=>{
const [sortField, sortDeriction] = s;
sorts.push({
[sortField]: {order: sortDeriction}
})
return sorts;
}, [])
}
const isCalendarInterval = timeExp.includes('w') || timeExp.includes('d') || timeExp.includes('y') || timeExp.includes('M');
let aggs = {
2: {
date_histogram: {
//calendar_interval:
[isCalendarInterval? 'calendar_interval' : 'fixed_interval']: timeExp,
field: indexPattern.timeFieldName,
min_doc_count: 1,
time_zone: "Asia/Shanghai"
}
}
};
let esRequest = {
index: indexPattern.index || indexPattern.title,
body:{
query: getEsQuery(indexPattern),
size: 500,
highlight:{
pre_tags:["@highlighted-field@"],
post_tags:["@highlighted-field@"]
},
sort: esSort,//
}
}
if(indexPattern.timeFieldName){
esRequest.body['aggs']=aggs;
}
return esRequest;
}
const fetchESRequest = (params, clusterID) => {
return fetch(`/elasticsearch/${clusterID}/search/ese`, {
headers:{
'Content-Type': 'application/json',
},
method: 'POST',
body: JSON.stringify(params),
}).then( res => {
return res.json()
}).then(resJson=>{
return resJson;
})
}