30 | );
31 | },
32 | style: { width: 300 },
33 | }
34 | }
35 | ]
36 | }
37 | }
38 | }
39 |
40 | render () {
41 | return (
42 |
43 |
44 | {this.renderRow("analyzer", this.state.rows.analyzer)}
45 |
46 |
47 | )
48 | }
49 | }
50 | const SimpleAnalyzer = displayRowsComponent(SimpleAnalyzerComponent);
51 | export { SimpleAnalyzer };
52 |
--------------------------------------------------------------------------------
/public/components/app.tsx:
--------------------------------------------------------------------------------
1 | import React from 'react';
2 | import { I18nProvider } from '@kbn/i18n/react';
3 | import { BrowserRouter as Router } from 'react-router-dom';
4 |
5 | import {
6 | EuiPage,
7 | EuiPageBody,
8 | EuiPageContent,
9 | EuiPageHeader,
10 | EuiPageHeaderSection,
11 | EuiSpacer,
12 | EuiTitle,
13 | } from '@elastic/eui';
14 |
15 | import { CoreStart } from '../../../../src/core/public';
16 | import { NavigationPublicPluginStart } from '../../../../src/plugins/navigation/public';
17 |
18 | import {AnalyzeUi} from "./analyze_ui";
19 |
20 | import { PLUGIN_ID } from '../../common';
21 |
22 | interface AnalyzeApiUiAppDeps {
23 | basename: string;
24 | notifications: CoreStart['notifications'];
25 | http: CoreStart['http'];
26 | navigation: NavigationPublicPluginStart;
27 | }
28 |
29 | export const AnalyzeApiUiApp = ({
30 | basename,
31 | http,
32 | navigation,
33 | }: AnalyzeApiUiAppDeps) => {
34 | // Render the application DOM.
35 | // Note that `navigation.ui.TopNavMenu` is a stateful component exported on the `navigation` plugin's start contract.
36 | return (
37 |
38 |
39 | <>
40 |
45 |
46 |
47 |
48 |
49 |
50 | Perform analyze via _analyze API
51 |
52 |
53 |
54 |
55 |
56 |
57 |
58 |
59 |
60 |
61 |
62 |
63 | );
64 | };
65 |
--------------------------------------------------------------------------------
/public/components/common_form/common_form.tsx:
--------------------------------------------------------------------------------
1 | import React, {
2 | Component
3 | } from 'react';
4 | import {
5 | EuiFlexGroup,
6 | EuiFlexItem,
7 | EuiFormRow,
8 | EuiFieldText,
9 | EuiTextColor
10 | } from '@elastic/eui';
11 |
12 | export class CommonForm extends Component {
13 |
14 | constructor(props) {
15 | super(props);
16 | }
17 |
18 | render () {
19 | const {params} = this.props;
20 | const {errors} = this.props;
21 | const showIndexNameError = Object.keys(errors).includes("indexNameError");
22 | const indexNameError = showIndexNameError ? errors.indexNameError : undefined;
23 | const showTextError = Object.keys(errors).includes("textError");
24 | const textError = showTextError ? errors.textError : undefined;
25 |
26 | return (
27 |
28 |
29 |
33 | Index name - select index name if you use the analyzer to configure an index
34 |
35 | }
36 | fullWidth
37 | isInvalid={showIndexNameError}
38 | error={indexNameError}
39 | onChange={this.props.updateParamsWithEvent}
40 | >
41 |
47 |
48 |
52 | Text - Text what you want to analyze
53 |
54 | }
55 | fullWidth
56 | isInvalid={showTextError}
57 | error={textError}
58 | onChange={this.props.updateParamsWithEvent}
59 | >
60 |
66 |
67 |
68 |
69 |
70 | );
71 | }
72 | }
73 |
--------------------------------------------------------------------------------
/public/components/common_form/index.ts:
--------------------------------------------------------------------------------
1 | export { CommonForm } from './common_form';
--------------------------------------------------------------------------------
/public/components/form_control/form_control.tsx:
--------------------------------------------------------------------------------
1 | import React, {
2 | Component
3 | } from 'react';
4 | import {
5 | EuiFlexGroup,
6 | EuiFlexItem,
7 | EuiButton,
8 | EuiSwitch,
9 | } from '@elastic/eui'
10 |
11 | export class FormControl extends Component {
12 | constructor(props) {
13 | super(props);
14 | }
15 |
16 | render () {
17 | return (
18 |
19 |
20 |
27 | Analyze!
28 |
29 |
30 |
31 |
37 |
38 |
39 | );
40 | }
41 | }
42 |
--------------------------------------------------------------------------------
/public/components/form_control/index.ts:
--------------------------------------------------------------------------------
1 | export { FormControl } from './form_control';
--------------------------------------------------------------------------------
/public/components/result/analyzer_result/analyzer_result.tsx:
--------------------------------------------------------------------------------
1 | import React, {
2 | Component,
3 | } from 'react';
4 | import {
5 | EuiCodeBlock,
6 | EuiPanel,
7 | EuiSpacer
8 | } from '@elastic/eui';
9 | import {Charfilters} from "./charfilters";
10 | import {TokenizerAndFilters} from "./tokenizer_and_filters";
11 | import {createTokenIndices, getLength} from "../../../services/token_utils";
12 |
13 | export class AnalyzerResult extends Component {
14 | constructor(props) {
15 | super(props);
16 | }
17 |
18 | countTokenSteamLength(detail) {
19 | // FIXME tokens length is not fit if it has synonym token/compound token...
20 | let tokenStreamLength = 0;
21 |
22 | if (detail.tokenizer) {
23 | tokenStreamLength = getLength(tokenStreamLength, detail.tokenizer.tokens);
24 | } else if (detail.analyzer) {
25 | tokenStreamLength = getLength(tokenStreamLength, detail.analyzer.tokens);
26 | }
27 | if (detail.tokenfilters) {
28 | detail.tokenfilters.forEach( (filter) => {
29 | tokenStreamLength = getLength(tokenStreamLength, filter.tokens);
30 | });
31 | }
32 | return createTokenIndices(tokenStreamLength);
33 | }
34 |
35 | render() {
36 | const {
37 | detail,
38 | esRequest,
39 | indexName
40 | } = this.props;
41 | const tokenIndices = this.countTokenSteamLength(detail);
42 | return (
43 |
44 |
45 |
46 |
47 |
54 |
55 |
56 |
57 | Request for Elasticsearch - you can copy and paste to Console
58 |
59 | GET {indexName}/_analyze
60 | {JSON.stringify(esRequest, null, 2)}
61 |
62 |
63 |
64 | );
65 | }
66 | }
67 |
--------------------------------------------------------------------------------
/public/components/result/analyzer_result/charfilters/chafilters.tsx:
--------------------------------------------------------------------------------
1 | import React, {
2 | Component
3 | } from 'react';
4 | import {
5 | EuiTable,
6 | EuiTableBody,
7 | EuiTableHeader,
8 | EuiTableHeaderCell,
9 | EuiTableRow,
10 | EuiTableRowCell
11 | } from '@elastic/eui';
12 |
13 | export class Charfilters extends Component {
14 | constructor(props) {
15 | super(props);
16 | }
17 |
18 | renderRow(target) {
19 | return (
20 |
21 |
22 | char_filter
23 | {target.name}
24 |
25 |
26 |
27 | {target.filtered_text[0]}
28 |
29 |
30 | );
31 | }
32 |
33 | renderRows(charfilters) {
34 | if (charfilters && charfilters.length > 0) {
35 | const rows = charfilters.map((target) => {
36 | return this.renderRow(target);
37 | });
38 | return rows;
39 | } else {
40 | return null;
41 | }
42 | }
43 |
44 | render() {
45 | const {charfilters} = this.props;
46 | if (charfilters && charfilters.length > 0) {
47 | return (
48 |
49 |
50 |
51 |
55 | type
name
56 |
57 |
60 | filtered text
61 |
62 |
63 |
64 | {this.renderRows(charfilters)}
65 |
66 |
67 |
68 | );
69 | } else {
70 | return null;
71 | }
72 | }
73 | }
74 |
--------------------------------------------------------------------------------
/public/components/result/analyzer_result/charfilters/index.ts:
--------------------------------------------------------------------------------
1 | export { Charfilters } from './chafilters';
--------------------------------------------------------------------------------
/public/components/result/analyzer_result/index.ts:
--------------------------------------------------------------------------------
1 | export { AnalyzerResult } from './analyzer_result';
--------------------------------------------------------------------------------
/public/components/result/analyzer_result/tokenizer_and_filters/filters.tsx:
--------------------------------------------------------------------------------
1 | import React, {
2 | Component
3 | } from 'react';
4 |
5 | import {displayRowsComponent} from "./tokenizer_and_filters";
6 |
7 | class FiltersComponent extends Component {
8 | constructor(props) {
9 | super(props);
10 | }
11 |
12 | render () {
13 | const {
14 | filters,
15 | tokenIndices
16 | } = this.props;
17 | if (filters && filters.length > 0) {
18 | const rows = filters.map((target) => {
19 | return this.renderRow(target, "filter", tokenIndices);
20 | }
21 | );
22 | return rows;
23 | } else {
24 | return null;
25 | }
26 | }
27 | }
28 | const Filters = displayRowsComponent(FiltersComponent);
29 | export { Filters };
30 |
--------------------------------------------------------------------------------
/public/components/result/analyzer_result/tokenizer_and_filters/index.ts:
--------------------------------------------------------------------------------
1 | export { TokenizerAndFilters } from './tokenizer_and_filters';
--------------------------------------------------------------------------------
/public/components/result/analyzer_result/tokenizer_and_filters/token.tsx:
--------------------------------------------------------------------------------
1 | import React, {
2 | Component
3 | } from 'react';
4 |
5 | import { DISP_TOKEN_PROPS } from '../../../../common/constants/token_properties';
6 |
7 | export class Token extends Component {
8 |
9 | constructor(props) {
10 | super(props);
11 | }
12 |
13 | makeTokenListFromTokenStream(index, target) {
14 | const currentLevelTokenList = [];
15 | for (let token of target.tokens) {
16 | if (token.position > index) {
17 | break;
18 | }
19 | if (token.position == index) {
20 | currentLevelTokenList.push(token);
21 | }
22 | }
23 | return currentLevelTokenList;
24 | }
25 |
26 | hideTokenProperty(propertyName) {
27 | if (DISP_TOKEN_PROPS.alwaysShowTokenProperties.includes(propertyName)) {
28 | return true;
29 | } else {
30 | // TODO should we handle each attribute to show/hide?
31 | return this.props.showAllTokenAttr;
32 | }
33 | };
34 |
35 | // filter token properties
36 | filteredCurrentTokenInfo(token) {
37 | if (token != null) {
38 | const result = {};
39 | Object.keys(token).forEach((key) => {
40 | if (!DISP_TOKEN_PROPS.hiddenTokenProperties.includes(key)) {
41 | result[key] = token[key];
42 | }
43 | });
44 | return result;
45 | } else {
46 | return null;
47 | }
48 | }
49 |
50 | renderTokenValue(key, value) {
51 | if (key=='token') {
52 | return (
53 | {value}
54 | );
55 | } else {
56 | return (
57 | {value}
58 | );
59 | }
60 | }
61 |
62 | renderTokenKey(key) {
63 | if (this.props.index == 0) {
64 | return (
65 |
66 | {key}
67 | |
68 | );
69 | } else {
70 | return null;
71 | }
72 | }
73 |
74 | renderRow(key, value) {
75 | if (this.hideTokenProperty(key)) {
76 | return (
77 |
78 | {this.renderTokenKey(key)}
79 | |
80 | {this.renderTokenValue(key, value)}
81 |
82 | |
83 |
84 | );
85 | } else {
86 | return null;
87 | }
88 | }
89 |
90 | renderTokenProperties(token) {
91 | const currentTokenInfo = this.filteredCurrentTokenInfo(token);
92 | if (currentTokenInfo) {
93 | const propRows = [];
94 | Object.keys(token).forEach(
95 | (key) => {
96 | propRows.push(this.renderRow(key, token[key]));
97 | }
98 | );
99 | return propRows;
100 | } else {
101 | return null;
102 | }
103 | }
104 |
105 | renderTokenTable(currentLevelTokenList) {
106 | const tokenTables = currentLevelTokenList.map(
107 | (token) =>
108 |
109 |
110 | {this.renderTokenProperties(token)}
111 |
112 |
113 | );
114 | if (tokenTables.length > 0) {
115 | return tokenTables;
116 | } else {
117 | return (
118 | no token
119 | );
120 | }
121 | }
122 |
123 | render () {
124 | const {
125 | index,
126 | target,
127 | } = this.props;
128 | const currentLevelTokenList = this.makeTokenListFromTokenStream(index, target);
129 | if (currentLevelTokenList.length > 0){
130 | return (
131 |
134 | {this.renderTokenTable(currentLevelTokenList)}
135 |
136 | );
137 | } else {
138 | return null;
139 | }
140 | }
141 | }
142 |
--------------------------------------------------------------------------------
/public/components/result/analyzer_result/tokenizer_and_filters/tokenizer.tsx:
--------------------------------------------------------------------------------
1 | import React, {
2 | Component
3 | } from 'react';
4 |
5 | import {displayRowsComponent} from "./tokenizer_and_filters";
6 |
7 | class TokenizerComponent extends Component {
8 | constructor(props) {
9 | super(props);
10 | }
11 |
12 | render () {
13 | const {
14 | analyzer,
15 | tokenizer,
16 | tokenIndices
17 | } = this.props;
18 |
19 | const target = analyzer? analyzer : tokenizer;
20 | const name = analyzer? "analyzer" : "tokenizer";
21 | return this.renderRow(target, name, tokenIndices);
22 | }
23 | }
24 | const Tokenizer = displayRowsComponent(TokenizerComponent);
25 | export { Tokenizer };
26 |
--------------------------------------------------------------------------------
/public/components/result/analyzer_result/tokenizer_and_filters/tokenizer_and_filters.tsx:
--------------------------------------------------------------------------------
1 | import React, {
2 | Component
3 | } from 'react';
4 |
5 | import {
6 | EuiTable,
7 | EuiTableBody,
8 | EuiTableHeader,
9 | EuiTableHeaderCell,
10 | EuiTableRow,
11 | EuiTableRowCell,
12 | } from '@elastic/eui';
13 | import {Tokenizer} from "./tokenizer";
14 | import {Filters} from "./filters";
15 | import {Token} from "./token";
16 |
17 | export class TokenizerAndFilters extends Component {
18 | constructor(props) {
19 | super(props);
20 | }
21 |
22 | renderHeaderTokensCells(tokenIndices) {
23 | const headerCells = tokenIndices.map(
24 | (index) =>
25 |
29 | tokens[{index}]
30 |
31 | );
32 | return headerCells;
33 | }
34 |
35 | render() {
36 | const {tokenizer} = this.props;
37 | const {analyzer} = this.props;
38 | const {filters} = this.props;
39 | const {tokenIndices} = this.props;
40 | const {showAllTokenAttr} = this.props;
41 | if (tokenizer || analyzer || filters) {
42 | return (
43 |
44 |
45 |
46 |
50 | type
name
51 |
52 | {this.renderHeaderTokensCells(tokenIndices)}
53 |
54 |
55 |
61 |
66 |
67 |
68 |
{name}
105 | {this.shortenName(target.name)}
106 |
107 |
108 | {this.renderTokenCells(tokenIndices, target)}
109 |
110 | );
111 | }
112 | }
113 | }
114 |
--------------------------------------------------------------------------------
/public/components/result/compare_result/compare_result.tsx:
--------------------------------------------------------------------------------
1 | import React, {
2 | Component,
3 | } from 'react';
4 | import {
5 | EuiPanel,
6 | EuiTable,
7 | EuiTableHeader,
8 | EuiTableHeaderCell,
9 | EuiTableBody,
10 | EuiTableRow,
11 | EuiTableRowCell,
12 | } from '@elastic/eui';
13 | import {createTokenIndices, getLength} from "../../../services/token_utils";
14 | import {Token} from "../analyzer_result/tokenizer_and_filters/token";
15 |
16 |
17 | export class CompareResult extends Component {
18 |
19 | constructor(props) {
20 | super(props);
21 | }
22 |
23 | countTokenStreamLength(resultAnalyzers) {
24 | let tokenStreamLength = 0;
25 | resultAnalyzers.forEach((detail) => {
26 | tokenStreamLength = getLength(tokenStreamLength, detail.tokens);
27 | });
28 | return createTokenIndices(tokenStreamLength);
29 | }
30 |
31 | renderHeaderTokensCells(tokenIndices) {
32 | const headerCells = tokenIndices.map(
33 | (index) =>
34 |
38 | type
tokens[{index}]
40 |
41 | );
42 | return headerCells;
43 | }
44 |
45 | renderTokenCells (tokenIndices, target) {
46 | const tokenCells = tokenIndices.map(
47 | (index) =>
48 |
49 |
54 |
55 | );
56 | return tokenCells;
57 | }
58 |
59 | renderRows(tokenIndices, resultAnalyzers) {
60 | const rows = resultAnalyzers.map(
61 | (result) =>
62 |
65 |
66 | analyzer
67 | {result.analyzer}
68 |
69 |
70 | {this.renderTokenCells(tokenIndices, result)}
71 |
72 | );
73 | return rows;
74 | }
75 |
76 | render() {
77 | const {
78 | resultAnalyzers
79 | } = this.props;
80 | const tokenIndices = this.countTokenStreamLength(resultAnalyzers);
81 |
82 | return (
83 |
87 | There are only tokens and positions. If you know analyzer details, use analyzer/custom_analyzer tab.
88 |
89 |
90 |
91 |
92 |
96 | type
name
97 |
98 | {this.renderHeaderTokensCells(tokenIndices)}
99 |
100 |
101 | {this.renderRows(tokenIndices, resultAnalyzers)}
102 |
103 |
104 |
105 |
106 | );
107 | }
108 | }
109 |
--------------------------------------------------------------------------------
/public/components/result/compare_result/index.ts:
--------------------------------------------------------------------------------
1 | export { CompareResult } from './compare_result';
--------------------------------------------------------------------------------
/public/components/result/index.ts:
--------------------------------------------------------------------------------
1 | export { Result } from './result';
--------------------------------------------------------------------------------
/public/components/result/result.tsx:
--------------------------------------------------------------------------------
1 | import React, {
2 | Component
3 | } from 'react';
4 | import {AnalyzerResult} from "./analyzer_result";
5 | import {CompareResult} from "./compare_result";
6 | import {RESULT_TYPE} from "../../common/constants/tab_names";
7 |
8 | export class Result extends Component {
9 |
10 | constructor(props) {
11 | super(props);
12 | }
13 |
14 | render() {
15 | const {type} = this.props;
16 | const {detail} = this.props;
17 | const {esRequest} = this.props;
18 | const {indexName} = this.props;
19 | const {showAllTokenAttr} = this.props;
20 | const {resultAnalyzers} = this.props;
21 | if (type === RESULT_TYPE.SINGLE) {
22 | return (
23 |
29 | );
30 | } else {
31 | return (
32 |
35 | );
36 | }
37 | }
38 | }
39 |
--------------------------------------------------------------------------------
/public/index.scss:
--------------------------------------------------------------------------------
1 | .NoMaxWidth {
2 | max-width: none;
3 | }
4 |
5 | .analyzeApiEUIPage {
6 | flex-direction: column;
7 | }
8 |
9 | .analyzeApiTableScroll {
10 | overflow-x: scroll;
11 | border: 1px solid #E4E4E4;
12 | }
13 |
14 | .analyzeApiTableScroll::-webkit-scrollbar{
15 | height: 0.5em;
16 | background-color: #F1F1F1;
17 | }
18 | .analyzeApiTableScroll::-webkit-scrollbar-thumb{
19 | background-color: #BCBCBC;
20 | border-radius: 12px;
21 | border-radius: 1.2rem;
22 | }
23 | .analyzeApiTableScroll::-webkit-scrollbar-thumb:hover{
24 | background-color: #A9A9AA;
25 | }
26 |
27 | .analyzeApiTableCell{
28 | max-width: none;
29 | padding: 7px 8px 8px;
30 | overflow: unset;
31 | }
32 |
33 | .analyzeApiTableTokenCell{
34 | margin-left: auto;
35 | }
36 |
37 | .analyzeRequest {
38 | margin: 2px;
39 | border: 1px solid #E4E4E4;
40 | background-color: #F1F1F1;
41 | padding: 7px 8px 8px;
42 | }
43 |
44 | .analyzeApiFontBold {
45 | font-weight: bold;
46 | }
47 |
48 | .analyzeApiTableLayout {
49 | table-layout: auto
50 | }
51 |
52 | .analyzeApiTableRowTop {
53 | vertical-align: top
54 | }
55 |
56 | .analyzeApiTableRowTokenCell {
57 | overflow: hidden;
58 | white-space: nowrap;
59 | display: grid;
60 | }
61 |
62 | .analyzeApiEmptyToken {
63 | color: #a7a7a7;
64 | }
65 |
66 | .analyzeApiTextAlignRight {
67 | text-align: right;
68 | }
69 |
70 | .analyzeApiFormWidthSize {
71 | width: 300px;
72 | }
73 |
74 | .analyzeApiFormHeightSize {
75 | height: 100px;
76 | }
77 |
--------------------------------------------------------------------------------
/public/index.ts:
--------------------------------------------------------------------------------
1 | import './index.scss';
2 |
3 | import { AnalyzeApiUiPlugin } from './plugin';
4 |
5 | // This exports static code and TypeScript types,
6 | // as well as, Kibana Platform `plugin()` initializer.
7 | export function plugin() {
8 | return new AnalyzeApiUiPlugin();
9 | }
10 | export { AnalyzeApiUiPluginSetup, AnalyzeApiUiPluginStart } from './types';
11 |
--------------------------------------------------------------------------------
/public/plugin.ts:
--------------------------------------------------------------------------------
1 | import { AppMountParameters, CoreSetup, CoreStart, Plugin } from 'kibana/public';
2 | import {
3 | AnalyzeApiUiPluginSetup,
4 | AnalyzeApiUiPluginStart,
5 | AppPluginStartDependencies,
6 | } from './types';
7 | import { PLUGIN_NAME } from '../common';
8 |
9 | export class AnalyzeApiUiPlugin
10 | implements Plugin
11 | {
12 | public setup(core: CoreSetup): AnalyzeApiUiPluginSetup {
13 | // Register an application into the side navigation menu
14 | core.application.register({
15 | id: 'analyzeApiUi',
16 | title: PLUGIN_NAME,
17 | async mount(params: AppMountParameters) {
18 | // Load application bundle
19 | const { renderApp } = await import('./application');
20 | // Get start services as specified in kibana.json
21 | const [coreStart, depsStart] = await core.getStartServices();
22 | // Render the application
23 | return renderApp(coreStart, depsStart as AppPluginStartDependencies, params);
24 | },
25 | });
26 | return {};
27 | }
28 |
29 | public start(core: CoreStart): AnalyzeApiUiPluginStart {
30 | return {};
31 | }
32 |
33 | public stop() {}
34 | }
35 |
--------------------------------------------------------------------------------
/public/services/api.ts:
--------------------------------------------------------------------------------
1 | let httpClient;
2 | export const setHttpClient = (client) => {
3 | httpClient = client;
4 | };
5 | export const getHttpClient = () => {
6 | return httpClient;
7 | };
8 |
9 | export async function analyze(params) {
10 | return await httpClient.post('/api/analyze_api_ui/analyze', {body: JSON.stringify(params)});
11 | }
12 |
13 | export async function multiAnalyze(params) {
14 | return await httpClient.post('/api/analyze_api_ui/multi_analyze', {body: JSON.stringify(params)});
15 | }
16 |
--------------------------------------------------------------------------------
/public/services/pagestate.ts:
--------------------------------------------------------------------------------
1 | import instance from "./storage";
2 |
3 | const pagestate = {
4 |
5 | updateCurrentState(content: { params: any; }) {
6 | const timestamp = new Date().getTime();
7 | instance.set("page_state", {
8 | time: timestamp,
9 | content: content
10 | });
11 | },
12 |
13 | getSavedEditorState() {
14 | const saved = instance.get('page_state', null);
15 | if (!saved) return;
16 | const { time, content } = saved;
17 | return { time, content };
18 | }
19 |
20 | };
21 |
22 | export default pagestate;
23 |
--------------------------------------------------------------------------------
/public/services/params.ts:
--------------------------------------------------------------------------------
1 | export function updateParamsWithEvent(event: any, params: any) {
2 | const target = event.target;
3 | const value = target.type === 'checkbox' || target.name === 'showAllTokenAttr' ? target.checked : target.value;
4 | const name = target.name;
5 | params[name] = value;
6 | return params;
7 | };
8 |
9 | export function updateParamsWithEventAndIndex(event: any, params: any) {
10 | const index = event.target.getAttribute('data-index');
11 | const target = event.target;
12 | const value = target.type === 'checkbox' ? target.checked : target.value;
13 | const name = target.name;
14 |
15 | if (params[name] == null) {
16 | params[name] = [];
17 | }
18 | params[name][index] = value;
19 | return params;
20 | };
21 |
22 | export function selectTab(tab: any, params: any) {
23 | params["tab"] = tab.name;
24 | return params;
25 | }
26 |
--------------------------------------------------------------------------------
/public/services/state_handler.ts:
--------------------------------------------------------------------------------
1 | import pagestate from './pagestate';
2 |
3 | export function initializeParams() {
4 | const params = {
5 | indexName: '',
6 | text: '',
7 | analyzer: '',
8 | tokenizer: '',
9 | charfilters: [],
10 | filters: [],
11 | field: '',
12 | analyzersForCompare: [],
13 | showAllTokenAttr: false,
14 | };
15 | return params;
16 | }
17 |
18 | // load saved state from storage
19 | export function loadSavedState() {
20 | const preState = pagestate.getSavedEditorState();
21 | let params;
22 | if (preState) {
23 | params = preState.content.params;
24 | } else {
25 | params = initializeParams();
26 | }
27 | return params;
28 | }
29 |
30 | // save state
31 | export function saveState(state) {
32 | try {
33 | pagestate.updateCurrentState({
34 | params: state.params
35 | });
36 | } catch (e) {
37 | console.log("Ignoring saving error: " + e);
38 | }
39 | }
40 |
--------------------------------------------------------------------------------
/public/services/storage.ts:
--------------------------------------------------------------------------------
1 | const { transform, keys, startsWith } = require('lodash');
2 |
3 | class Storage {
4 | engine: globalThis.Storage;
5 | prefix: string;
6 |
7 | constructor(engine: globalThis.Storage, prefix: string) {
8 | this.engine = engine;
9 | this.prefix = prefix;
10 | }
11 |
12 | encode(val: any) {
13 | return JSON.stringify(val);
14 | }
15 |
16 | decode(val: string | null) {
17 | if (typeof val === 'string') {
18 | return JSON.parse(val);
19 | }
20 | }
21 |
22 | encodeKey(key: any) {
23 | return `${this.prefix}${key}`;
24 | }
25 |
26 | decodeKey(key: string | any[]) {
27 | if (startsWith(key, this.prefix)) {
28 | return `${key.slice(this.prefix.length)}`;
29 | }
30 | }
31 |
32 | set(key: any, val: any) {
33 | this.engine.setItem(this.encodeKey(key), this.encode(val));
34 | return val;
35 | }
36 |
37 | has(key: any) {
38 | return this.engine.getItem(this.encodeKey(key)) != null;
39 | }
40 |
41 | get(key: any, _default: any) {
42 | if (this.has(key)) {
43 | return this.decode(this.engine.getItem(this.encodeKey(key)));
44 | } else {
45 | return _default;
46 | }
47 | }
48 |
49 | delete(key: any) {
50 | return this.engine.removeItem(this.encodeKey(key));
51 | }
52 |
53 | keys() {
54 | return transform(keys(this.engine), (ours: string[], key: string | any[]) => {
55 | const ourKey = this.decodeKey(key);
56 | if (ourKey != null) ours.push(ourKey);
57 | });
58 | }
59 | }
60 |
61 | const instance = new Storage(sessionStorage, 'analyzeui:');
62 |
63 | export default instance;
64 |
--------------------------------------------------------------------------------
/public/services/token_utils.ts:
--------------------------------------------------------------------------------
1 | // compare and swap tokenStreamLength
2 | export function getLength(current: number, tokenArray: string | any[] | null) {
3 | // FIXME check if there is synonyms or compound
4 | let length = current;
5 | if (tokenArray != null) {
6 | // FIXME must consider the situation if positionIncrements != 1
7 | if (tokenArray[tokenArray.length -1].position >= current) {
8 | length = tokenArray[tokenArray.length -1].position + 1;
9 | }
10 | }
11 | return length;
12 | };
13 |
14 | export function createTokenIndices(tokenStreamLength: number) {
15 | const tokenIndices = [];
16 | for (let i = 0; i < tokenStreamLength; i++) {
17 | tokenIndices.push(i);
18 | }
19 | return tokenIndices;
20 | }
21 |
--------------------------------------------------------------------------------
/public/services/validator.ts:
--------------------------------------------------------------------------------
1 | import {TAB_NAME} from "../common/constants/tab_names";
2 |
3 | export function validateAnalyzeRequestValues(params) {
4 | let validatedParams = {
5 | requestParams: {
6 | text: params.text
7 | },
8 | errors: {}
9 | };
10 | // console.log("before validation");
11 | // console.log(params);
12 | // console.log("--------------");
13 | if (validatedParams.requestParams.text.trim().length === 0) {
14 | validatedParams.errors.textError= 'text should be not null!'
15 |
16 | }
17 | if (params.indexName.length > 0) {
18 | validatedParams.requestParams.indexName = params.indexName.trim();
19 | }
20 |
21 | if (params.tab == TAB_NAME.ANALYZER) {
22 | if (params.analyzer.length > 0) {
23 | validatedParams.requestParams.analyzer = params.analyzer.trim();
24 | }
25 | } else if (params.tab == TAB_NAME.FIELD) {
26 | if (params.field.trim().length === 0)
27 | validatedParams.errors.fieldError = 'field is required. ';
28 | if (params.indexName.trim().length === 0)
29 | validatedParams.errors.indexNameError = 'index name is required for "field". ';
30 |
31 | validatedParams.requestParams.field = params.field.trim();
32 | } else if (params.tab == TAB_NAME.CUSTOM_ANALYZER) {
33 | if (params.tokenizer) {
34 | let tmpObj = parseCustom(params.tokenizer.trim(), "tokenizer", validatedParams);
35 | if (tmpObj != -1) {
36 | validatedParams.requestParams.tokenizer = tmpObj;
37 | tmpObj = null;
38 | }
39 | }
40 |
41 | if (params.charfilters.length > 0) {
42 | params.charfilters.forEach( (charfilter) => {
43 | if (charfilter && charfilter.trim().length > 0 ) {
44 | if(validatedParams.requestParams.charfilters == null) validatedParams.requestParams.charfilters = [];
45 | let tmpCharfilter = parseCustom(charfilter.trim(), "charfilter", validatedParams);
46 | if (tmpCharfilter != -1) {
47 | validatedParams.requestParams.charfilters.push(tmpCharfilter);
48 | }
49 | }
50 | });
51 | }
52 | if (params.filters.length > 0) {
53 | params.filters.forEach( (filter) => {
54 | if (filter && filter.trim().length > 0 ) {
55 | if(validatedParams.requestParams.filters == null) validatedParams.requestParams.filters = [];
56 | let tmpFilter = parseCustom(filter.trim(), "filter", validatedParams);
57 | if (tmpFilter != -1) {
58 | validatedParams.requestParams.filters.push(tmpFilter);
59 | }
60 | }
61 | });
62 | }
63 | } else if (params.tab == TAB_NAME.COMPARE_ANALYZERS) {
64 | params.analyzersForCompare.forEach( (analyzer) => {
65 | if (analyzer && analyzer.trim().length > 0) {
66 | if (validatedParams.requestParams.analyzers == null) validatedParams.requestParams.analyzers = [];
67 | validatedParams.requestParams.analyzers.push(analyzer);
68 | }
69 | });
70 | }
71 |
72 | //console.log("after validation");
73 | //console.log(validatedParams);
74 | //console.log("--------------");
75 | return validatedParams;
76 | };
77 |
78 | function parseCustom(target, label, validatedParams) {
79 | if (typeof target === 'string' && target.startsWith('{')) {
80 | try {
81 | let tmpJson = JSON.parse(target);
82 | if (tmpJson !== null && typeof tmpJson === 'object') {
83 | return tmpJson;
84 | } else {
85 | validatedParams.errors.analyzerError = label+' has wrong custom '+label;
86 | return -1;
87 | }
88 | } catch (e) {
89 | validatedParams.errors.analyzerError = e.message;
90 | return -1;
91 | }
92 | } else {
93 | return target;
94 | }
95 | };
96 |
--------------------------------------------------------------------------------
/public/types.ts:
--------------------------------------------------------------------------------
1 | import { NavigationPublicPluginStart } from '../../../src/plugins/navigation/public';
2 |
3 | export interface AnalyzeApiUiPluginSetup {}
4 | // eslint-disable-next-line @typescript-eslint/no-empty-interface
5 | export interface AnalyzeApiUiPluginStart {}
6 |
7 | export interface AppPluginStartDependencies {
8 | navigation: NavigationPublicPluginStart;
9 | }
10 |
--------------------------------------------------------------------------------
/server/index.ts:
--------------------------------------------------------------------------------
1 | import { PluginInitializerContext } from 'kibana/server';
2 | import { AnalyzeApiUiPlugin } from './plugin';
3 |
4 | // This exports static code and TypeScript types,
5 | // as well as, Kibana Platform `plugin()` initializer.
6 |
7 | export function plugin(initializerContext: PluginInitializerContext) {
8 | return new AnalyzeApiUiPlugin(initializerContext);
9 | }
10 |
11 | export { AnalyzeApiUiPluginSetup, AnalyzeApiUiPluginStart } from './types';
12 |
--------------------------------------------------------------------------------
/server/plugin.ts:
--------------------------------------------------------------------------------
1 | import {
2 | PluginInitializerContext,
3 | CoreSetup,
4 | CoreStart,
5 | Plugin,
6 | Logger,
7 | } from 'kibana/server';
8 |
9 | import { AnalyzeApiUiPluginSetup, AnalyzeApiUiPluginStart } from './types';
10 | import { defineRoutes } from './routes';
11 |
12 | export class AnalyzeApiUiPlugin
13 | implements Plugin
14 | {
15 | private readonly logger: Logger;
16 |
17 | constructor(initializerContext: PluginInitializerContext) {
18 | this.logger = initializerContext.logger.get();
19 | }
20 |
21 | public setup(core: CoreSetup) {
22 | this.logger.debug('analyze-api-ui-plugin: Setup');
23 | const router = core.http.createRouter();
24 |
25 | // Register server side APIs
26 | defineRoutes(router, this.logger);
27 |
28 | return {};
29 | }
30 |
31 | public start(core: CoreStart) {
32 | this.logger.debug('analyze-api-ui-plugin: Started');
33 | return {};
34 | }
35 |
36 | public stop() {}
37 | }
38 |
--------------------------------------------------------------------------------
/server/routes/handle_es_error.ts:
--------------------------------------------------------------------------------
1 | import Boom from '@hapi/boom';
2 | import { get } from 'lodash';
3 |
4 | const ERR_ES_INDEX_NOT_FOUND = 'index_not_found_exception';
5 | const ERR_ES_ILLEGAL_ARG = 'illegal_argument_exception';
6 |
7 | export function isEsIndexNotFoundError(err: any) {
8 | return get(err, ['body', 'error', 'type']) === ERR_ES_INDEX_NOT_FOUND;
9 | }
10 |
11 | export function isEsIllegalArgumentError(err: any) {
12 | return get(err, ['body', 'error', 'type']) === ERR_ES_ILLEGAL_ARG;
13 | }
14 |
15 | export function convertEsError(response: any, error: any) {
16 | const message = error.body ? error.body.error.reason : undefined;
17 | if (isEsIndexNotFoundError(error)) {
18 | error = Boom.notFound(message, error);
19 | } else if (isEsIllegalArgumentError(error)) {
20 | error = Boom.badRequest(message, error);
21 | }
22 |
23 | if (!Boom.isBoom(error)) {
24 | const statusCode = error.statusCode;
25 | if (!error.message) {
26 | error.message = message;
27 | }
28 | error = Boom.boomify(error, {statusCode: statusCode, message: message});
29 | }
30 | return response.customError({
31 | body: error.output.payload,
32 | statusCode: error.output.statusCode,
33 | headers: error.output.headers as { [key: string]: string },
34 | });
35 | }
36 |
--------------------------------------------------------------------------------
/server/routes/index.ts:
--------------------------------------------------------------------------------
1 | import { IRouter, Logger } from 'kibana/server';
2 | import { schema } from '@kbn/config-schema';
3 | import { convertEsError } from "./handle_es_error";
4 |
5 | export function defineRoutes(router: IRouter, logger: logger) {
6 | router.post(
7 | {
8 | path: '/api/analyze_api_ui/analyze',
9 | validate: {
10 | body: schema.object({
11 | text: schema.string(),
12 | indexName: schema.maybe(schema.nullable(schema.string())),
13 | analyzer: schema.maybe(schema.nullable(schema.string())),
14 | tokenizer: schema.maybe(schema.oneOf([schema.nullable(schema.string()), schema.object({}, { unknowns: 'allow' })])),
15 | field: schema.maybe(schema.nullable(schema.string())),
16 | filters: schema.maybe(schema.arrayOf(schema.nullable(schema.oneOf([schema.string(), schema.object({}, { unknowns: 'allow' })])))),
17 | charfilters: schema.maybe(schema.arrayOf(schema.nullable(schema.oneOf([schema.string(), schema.object({}, { unknowns: 'allow' })]))))
18 | })
19 | }
20 | },
21 | async (context, request, response) => {
22 | let param = {
23 | body: {
24 | explain: true,
25 | text: request.body.text
26 | }
27 | };
28 | if (request.body.indexName) param.index = request.body.indexName;
29 | if (request.body.analyzer) param.body.analyzer = request.body.analyzer;
30 | if (request.body.tokenizer) param.body.tokenizer = request.body.tokenizer;
31 | if (request.body.charfilters) param.body.char_filter = request.body.charfilters;
32 | if (request.body.field) param.body.field = request.body.field;
33 | if (request.body.filters) param.body.filter = request.body.filters;
34 | try {
35 | const results = await context.core.elasticsearch.client.asCurrentUser.indices.analyze(param);
36 | return response.ok({
37 | body: {
38 | detail: results.body.detail,
39 | request: param.body
40 | }
41 | });
42 | } catch (error) {
43 | return convertEsError(response, error);
44 | }
45 | }
46 | );
47 |
48 | router.post(
49 | {
50 | path: '/api/analyze_api_ui/multi_analyze',
51 | validate: {
52 | body: schema.object({
53 | text: schema.string(),
54 | indexName: schema.maybe(schema.nullable(schema.string())),
55 | analyzers: schema.nullable(schema.arrayOf(schema.string(), {minSize: 2}))
56 | })
57 | }
58 | },
59 | async (context, request, response) => {
60 | let param = {
61 | body: {
62 | explain: false,
63 | text: request.body.text
64 | }
65 | };
66 | if (request.body.indexName) param.index = request.body.indexName;
67 | const res = {
68 | body: {
69 | resultAnalyzers: []
70 | }
71 | };
72 |
73 | function getAnalyzerResult(analyzer, id) {
74 | return new Promise(function (resolve, reject) {
75 | param.body.analyzer = analyzer;
76 | const results = context.core.elasticsearch.client.asCurrentUser.indices.analyze(param)
77 | results.then(
78 | (x) => {
79 | res.body.resultAnalyzers.push({analyzer: analyzer, id: id, tokens: x.body.tokens});
80 | resolve(res);
81 | }
82 | );
83 | results.catch(error => {
84 | reject(convertEsError(response, error));
85 | });
86 | });
87 | };
88 |
89 | if (Array.isArray(request.body.analyzers) && request.body.analyzers.length >= 1) {
90 | try {
91 | const res_promise = await Promise.all(request.body.analyzers.map(getAnalyzerResult));
92 | res.body.resultAnalyzers.sort(
93 | function (a, b) {
94 | if (a.id < b.id) return -1;
95 | if (a.id > b.id) return 1;
96 | return 0;
97 | }
98 | );
99 | return response.ok(res);
100 | } catch (error) {
101 | return convertEsError(response, error);
102 | }
103 | } else {
104 | return response.ok(res);
105 | }
106 | }
107 | );
108 | }
109 |
--------------------------------------------------------------------------------
/server/types.ts:
--------------------------------------------------------------------------------
1 | // eslint-disable-next-line @typescript-eslint/no-empty-interface
2 | export interface AnalyzeApiUiPluginSetup {}
3 | // eslint-disable-next-line @typescript-eslint/no-empty-interface
4 | export interface AnalyzeApiUiPluginStart {}
5 |
--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
1 | {
2 | "extends": "../../tsconfig.json",
3 | "compilerOptions": {
4 | "outDir": "./target/types"
5 | },
6 | "include": [
7 | "index.ts",
8 | "common/**/*.ts",
9 | "public/**/*.ts",
10 | "public/**/*.tsx",
11 | "server/**/*.ts",
12 | "../../typings/**/*"
13 | ],
14 | "exclude": []
15 | }
16 |
--------------------------------------------------------------------------------