list(streamId: String, skip: Number, limit: Number) {
var failCallback = (error) => {
UserNotification.error("Fetching alerts failed with status: " + error.message,
"Could not retrieve alerts.");
};
var url = URLUtils.qualifyUrl(ApiRoutes.AlertsApiController.list(streamId, skip, limit).url);
return fetch('GET', url).catch(failCallback);
}
listForAlert(streamId: String, alertId: String) {
var failCallback = (error) => {
UserNotification.error("Fetching alarm callback history failed with status: " + error,
"Could not retrieve alarm callback history.");
};
var url = URLUtils.qualifyUrl(jsRoutes.controllers.api.AlarmCallbackHistoryApiController.list(streamId, alertId).url);
return fetch('GET', url).catch(failCallback);
}
interface Field {
name: string;
value: string;
}
interface Message {
id: string;
index: number;
fields: Array<Field>;
}
var MessagesStore = {
loadMessage(index: string, messageId: string): Promise<Message> {
var url = ApiRoutes.MessagesController.single(index.trim(), messageId.trim()).url;
const promise = fetch('GET', URLUtils.qualifyUrl(url))
.then(response => {
const message = response.message;
const fields = message.fields;
const filteredFields = MessageFieldsFilter.filterFields(fields);
const newMessage = {
id: message.id,
timestamp: moment(message.timestamp).unix(),
filtered_fields: filteredFields,
formatted_fields: filteredFields,
fields: fields,
index: response.index,
source_node_id: fields.gl2_source_node,
source_input_id: fields.gl2_source_input,
stream_ids: message.streams,
};
case 'absolute':
timerange['from'] = originalSearchURLParams.get('from');
timerange['to'] = originalSearchURLParams.get('to');
break;
case 'keyword':
timerange['keyword'] = originalSearchURLParams.get('keyword');
break;
}
var url = ApiRoutes.UniversalSearchApiController.fieldTerms(
rangeType,
originalSearchURLParams.get('q') || '*',
field,
timerange,
streamId
).url;
url = URLUtils.qualifyUrl(url);
var promise = fetch('GET', url);
promise.catch(error => {
UserNotification.error('Loading quick values failed with status: ' + error,
'Could not load quick values');
});
return promise;
},
};
module.exports = FieldQuickValuesStore;
/// <reference path="../../../declarations/bluebird/bluebird.d.ts" />
import jsRoutes = require('routing/jsRoutes');
const URLUtils = require('util/URLUtils');
const fetch = require('logic/rest/FetchProvider').default;
const UserNotification = require('util/UserNotification');
export interface UsageStatsOptOutState {
opt_out: boolean
}
export var UsageStatsOptOutStore = {
pluginEnabled(): Promise<boolean> {
var url = URLUtils.qualifyUrl(jsRoutes.controllers.api.UsageStatsApiController.pluginEnabled().url);
var promise = fetch('GET', url);
promise = promise
.then(response => {
return response.enabled;
})
.catch(() => {
// When the plugin is not loaded the CORS options request will fail and we can't tell at this point
// what was the cause for the problem. Therefore, we return false and don't notify the user.
return false;
});
return promise;
},
getOptOutState(): Promise<UsageStatsOptOutState> {
var url = URLUtils.qualifyUrl(jsRoutes.controllers.api.UsageStatsApiController.setOptOutState().url);
total += count;
sourcesArray.push({name: StringUtils.escapeHTML(name), message_count: count})
});
sourcesArray.forEach((d) => {
d.percentage = d.message_count / total * 100;
});
return sourcesArray;
};
const SourcesStore = {
SOURCES_URL: '/sources',
loadSources(range: number, callback: (sources: Array<Source>) => void) {
let url = URLUtils.qualifyUrl(this.SOURCES_URL);
if (typeof range !== 'undefined') {
url += "?range=" + range;
}
fetch('GET', url)
.then(response => {
var sources = processSourcesData(response.sources);
callback(sources);
})
.catch((errorThrown) => {
UserNotification.error("Loading of sources data failed with status: " + errorThrown + ". Try reloading the page.",
"Could not load sources data");
});
}
};
export = SourcesStore;
import UserNotification = require("../../util/UserNotification");
import URLUtils = require("../../util/URLUtils");
import jsRoutes = require('routing/jsRoutes');
const fetch = require('logic/rest/FetchProvider').default;
interface Output {
id: string;
title: string;
type: string;
}
const OutputsStore = {
OUTPUTS_URL: URLUtils.qualifyUrl(jsRoutes.controllers.api.OutputsApiController.index().url),
load(callback : (outputs: Array<Output>) => void) {
fetch('GET', this.OUTPUTS_URL).then(callback, this._failCallback);
},
loadForStreamId(streamId: string, callback: (outputs: Array<Output>) => void) {
const url = URLUtils.qualifyUrl(jsRoutes.controllers.api.StreamOutputsApiController.index(streamId).url);
fetch('GET', url).then(callback, this._failCallback);
},
loadAvailableTypes(callback: (available: any) => void) {
const url = URLUtils.qualifyUrl(jsRoutes.controllers.api.OutputsApiController.availableTypes().url);
fetch('GET', url).then(callback, this._failCallback);
},
loadAvailable(typeName: string, callback: (available: any) => void) {
const url = URLUtils.qualifyUrl(jsRoutes.controllers.api.OutputsApiController.availableTypes().url);
fetch('GET', url).then((resp) => {
return resp.types[typeName];
}, this._failCallback).then(callback);
},
/// <reference path="../../../declarations/bluebird/bluebird.d.ts" />
import ApiRoutes = require('routing/ApiRoutes');
const URLUtils = require('util/URLUtils');
const UserNotification = require('util/UserNotification');
const fetch = require('logic/rest/FetchProvider').default;
const ToolsStore = {
testNaturalDate(text: string): Promise<string[]> {
const url = ApiRoutes.ToolsApiController.naturalDateTest(text).url;
const promise = fetch('GET', URLUtils.qualifyUrl(url));
promise.catch((errorThrown) => {
if (errorThrown.additional.status !== 422) {
UserNotification.error("Loading keyword preview failed with status: " + errorThrown,
"Could not load keyword preview");
}
});
return promise;
},
testGrok(pattern: string, string: string): Promise<Object> {
const url = ApiRoutes.ToolsApiController.grokTest().url;
const promise = fetch('POST', URLUtils.qualifyUrl(url), {pattern: pattern, string: string});
promise.catch((errorThrown) => {
UserNotification.error('Details: ' + errorThrown,
'We were not able to run the grok extraction. Please check your parameters.');
});
return promise;
/// <reference path="../../../declarations/bluebird/bluebird.d.ts" />
import ApiRoutes = require('routing/ApiRoutes');
const URLUtils = require('util/URLUtils');
const UserNotification = require('util/UserNotification');
const fetch = require('logic/rest/FetchProvider').default;
const ToolsStore = {
testNaturalDate(text: string): Promise<string[]> {
const url = ApiRoutes.ToolsApiController.naturalDateTest(text).url;
const promise = fetch('GET', URLUtils.qualifyUrl(url));
promise.catch((errorThrown) => {
if (errorThrown.additional.status !== 422) {
UserNotification.error("Loading keyword preview failed with status: " + errorThrown,
"Could not load keyword preview");
}
});
return promise;
},
testGrok(pattern: string, namedCapturesOnly: boolean, string: string): Promise<Object> {
const url = ApiRoutes.ToolsApiController.grokTest().url;
const promise = fetch('POST', URLUtils.qualifyUrl(url), {pattern: pattern, string: string, named_captures_only: namedCapturesOnly});
promise.catch((errorThrown) => {
UserNotification.error('Details: ' + errorThrown,
'We were not able to run the grok extraction. Please check your parameters.');
});
return promise;
const fetch = require('logic/rest/FetchProvider').default;
interface Role {
name: string;
description: string;
permissions: string[];
}
interface RoleMembership {
role: string;
users: UsersStore.User[];
}
const RolesStore = {
loadRoles(): Promise<string[]> {
const promise = fetch('GET', URLUtils.qualifyUrl(ApiRoutes.RolesApiController.listRoles().url))
.then(
response => response.roles,
error => {
if (error.additional.status !== 404) {
UserNotification.error("Loading role list failed with status: " + error,
"Could not load role list");
}
}
);
return promise;
},
createRole(role: Role): Promise<Role> {
const url = URLUtils.qualifyUrl(ApiRoutes.RolesApiController.createRole().url);
