390 lines
9.8 KiB
JavaScript
390 lines
9.8 KiB
JavaScript
var _status_catalog = {
|
|
commands: {},
|
|
responses: {},
|
|
functions: {},
|
|
subscriptions: {}
|
|
},
|
|
status = {};
|
|
|
|
// This is default 'common sense' scope for commands/response which don't
|
|
// define any.
|
|
// We want the command/response to apply for 1-1 chats with registered user,
|
|
// as most of the bot developers will expect the sole registered user (for
|
|
// things like sending, etc.) and it will be non global, available only
|
|
// for that particular bot (that's what "dapps" in scope)
|
|
var defaultScope = ["personal-chats", "registered", "dapps"];
|
|
|
|
function scopeToBitMask(scope) {
|
|
// this function transforms scopes array to a single integer by generating a bit mask
|
|
return ((scope.indexOf("global") > -1) ? 1 : 0) |
|
|
((scope.indexOf("personal-chats") > -1) ? 2 : 0) |
|
|
((scope.indexOf("group-chats") > -1) ? 4 : 0) |
|
|
((scope.indexOf("anonymous") > -1) ? 8 : 0) |
|
|
((scope.indexOf("registered") > -1) ? 16 : 0) |
|
|
((scope.indexOf("dapps") > -1) ? 32 : 0) |
|
|
((scope.indexOf("humans") > -1) ? 64 : 0) |
|
|
((scope.indexOf("public-chats") > -1) ? 128 : 0);
|
|
}
|
|
|
|
function Command() {
|
|
}
|
|
function Response() {
|
|
}
|
|
|
|
Command.prototype.addToCatalog = function () {
|
|
_status_catalog.commands[[this.name, this["scope-bitmask"]]] = this;
|
|
};
|
|
|
|
Command.prototype.param = function (parameter) {
|
|
this.params.push(parameter);
|
|
|
|
return this;
|
|
};
|
|
|
|
Command.prototype.create = function (com) {
|
|
this.name = com.name;
|
|
this.title = com.title;
|
|
this.description = com.description;
|
|
this.handler = com.handler;
|
|
this["has-handler"] = com.handler !== null;
|
|
this["async-handler"] = (com.handler != null) && com.asyncHandler;
|
|
this.validator = com.validator;
|
|
this.color = com.color;
|
|
this.icon = com.icon;
|
|
this.params = com.params || [];
|
|
this.preview = com.preview;
|
|
this["short-preview"] = com.shortPreview;
|
|
this.fullscreen = com.fullscreen;
|
|
this.actions = com.actions;
|
|
this.request = com.request;
|
|
this["execute-immediately?"] = com.executeImmediately;
|
|
this["sequential-params"] = com.sequentialParams;
|
|
this["hide-send-button"] = com.hideSendButton;
|
|
|
|
// scopes
|
|
this.scope = com.scope || defaultScope;
|
|
this["scope-bitmask"] = scopeToBitMask(this["scope"]);
|
|
|
|
this.addToCatalog();
|
|
|
|
return this;
|
|
};
|
|
|
|
|
|
Response.prototype = Object.create(Command.prototype);
|
|
Response.prototype.addToCatalog = function () {
|
|
_status_catalog.responses[[this.name, this["scope-bitmask"]]] = this;
|
|
};
|
|
Response.prototype.onReceiveResponse = function (handler) {
|
|
this.onReceive = handler;
|
|
};
|
|
|
|
var context = {};
|
|
|
|
|
|
function addContext(key, value) {
|
|
context[status.message_id][key] = value;
|
|
}
|
|
|
|
function getContext(key) {
|
|
return context[status.message_id][key];
|
|
}
|
|
|
|
function call(pathStr, paramsStr) {
|
|
var params = JSON.parse(paramsStr),
|
|
path = JSON.parse(pathStr),
|
|
fn, callResult, message_id;
|
|
|
|
if (typeof params.context !== "undefined" &&
|
|
typeof params.context["message-id"] !== "undefined") {
|
|
message_id = params.context["message-id"];
|
|
} else {
|
|
message_id = null;
|
|
}
|
|
context[message_id] = {};
|
|
status.message_id = message_id;
|
|
|
|
fn = path.reduce(function (catalog, name) {
|
|
if (catalog && catalog[name]) {
|
|
return catalog[name];
|
|
}
|
|
},
|
|
_status_catalog
|
|
);
|
|
|
|
if (!fn) {
|
|
return null;
|
|
}
|
|
|
|
context.messages = [];
|
|
|
|
callResult = fn(params.parameters, params.context);
|
|
result = {
|
|
returned: callResult,
|
|
context: context[message_id],
|
|
messages: context.messages
|
|
};
|
|
|
|
return JSON.stringify(result);
|
|
}
|
|
|
|
function view(options, elements) {
|
|
return ['view', options].concat(elements);
|
|
}
|
|
|
|
function text(options, s) {
|
|
s = Array.isArray(s) ? s : [s];
|
|
return ['text', options].concat(s);
|
|
}
|
|
|
|
function chatPreviewText(options, s) {
|
|
return ['chat-preview-text', options, s];
|
|
}
|
|
|
|
function textInput(options) {
|
|
return ['text-input', options];
|
|
}
|
|
|
|
function image(options) {
|
|
return ['image', options];
|
|
}
|
|
|
|
function qrCode(options) {
|
|
return ['qr-code', options];
|
|
}
|
|
|
|
function linking(options) {
|
|
return ['linking', options];
|
|
}
|
|
|
|
function slider(options) {
|
|
return ['slider', options];
|
|
}
|
|
|
|
function image(options) {
|
|
return ['image', options];
|
|
}
|
|
|
|
function touchable(options, element) {
|
|
return ['touchable', options, element];
|
|
}
|
|
|
|
function activityIndicator(options) {
|
|
return ['activity-indicator', options];
|
|
}
|
|
|
|
function scrollView(options, elements) {
|
|
return ['scroll-view', options].concat(elements);
|
|
}
|
|
|
|
function subscribe(path) {
|
|
return ['subscribe', path];
|
|
}
|
|
|
|
function dispatch(path) {
|
|
return ['dispatch', path];
|
|
}
|
|
|
|
function webView(url) {
|
|
return ['web-view', {
|
|
source: {
|
|
uri: url
|
|
},
|
|
javaScriptEnabled: true
|
|
}];
|
|
}
|
|
|
|
function bridgedWebView(url) {
|
|
return ['bridged-web-view', {
|
|
url: url
|
|
}];
|
|
}
|
|
|
|
function validationMessage(titleText, descriptionText) {
|
|
return ['validation-message', {
|
|
title: titleText,
|
|
description: descriptionText
|
|
}];
|
|
}
|
|
|
|
function chooseContact(titleText, botDbKey, argumentIndex) {
|
|
return ['choose-contact', {
|
|
title: titleText,
|
|
"bot-db-key": botDbKey,
|
|
index: argumentIndex
|
|
}];
|
|
}
|
|
|
|
function chooseAsset(botDbKey, argumentIndex) {
|
|
return ['choose-asset', {
|
|
"bot-db-key": botDbKey,
|
|
index: argumentIndex
|
|
}];
|
|
}
|
|
|
|
|
|
function separator() {
|
|
return ['separator'];
|
|
}
|
|
|
|
var status = {
|
|
command: function (h) {
|
|
var command = new Command();
|
|
return command.create(h);
|
|
},
|
|
response: function (h) {
|
|
var response = new Response();
|
|
return response.create(h);
|
|
},
|
|
addListener: function (name, fn) {
|
|
_status_catalog.functions[name] = fn;
|
|
},
|
|
localizeNumber: function (num, del, sep) {
|
|
return I18n.toNumber(
|
|
num.replace(",", "."),
|
|
{
|
|
precision: 10,
|
|
strip_insignificant_zeros: true,
|
|
delimiter: del,
|
|
separator: sep
|
|
});
|
|
},
|
|
types: {
|
|
TEXT: 'text',
|
|
NUMBER: 'number',
|
|
PASSWORD: 'password'
|
|
},
|
|
events: {
|
|
SET_VALUE: 'set-value',
|
|
SET_COMMAND_ARGUMENT: 'set-command-argument',
|
|
UPDATE_DB: 'set',
|
|
SET_COMMAND_ARGUMENT_FROM_DB: 'set-command-argument-from-db',
|
|
SET_VALUE_FROM_DB: 'set-value-from-db',
|
|
FOCUS_INPUT: 'focus-input'
|
|
},
|
|
actions: {
|
|
WEB_VIEW_BACK: 'web-view-back',
|
|
WEB_VIEW_FORWARD: 'web-view-forward',
|
|
FULLSCREEN: 'fullscreen',
|
|
CUSTOM: 'custom',
|
|
},
|
|
components: {
|
|
view: view,
|
|
text: text,
|
|
chatPreviewText: chatPreviewText,
|
|
textInput: textInput,
|
|
slider: slider,
|
|
image: image,
|
|
qrCode: qrCode,
|
|
linking: linking,
|
|
slider: slider,
|
|
touchable: touchable,
|
|
activityIndicator: activityIndicator,
|
|
scrollView: scrollView,
|
|
webView: webView,
|
|
validationMessage: validationMessage,
|
|
bridgedWebView: bridgedWebView,
|
|
chooseAsset: chooseAsset,
|
|
chooseContact: chooseContact,
|
|
subscribe: subscribe,
|
|
dispatch: dispatch,
|
|
separator: separator
|
|
},
|
|
showSuggestions: function (view) {
|
|
status.sendSignal("show-suggestions", view);
|
|
},
|
|
setDefaultDb: function (db) {
|
|
addContext("default-db", db);
|
|
},
|
|
updateDb: function (db) {
|
|
addContext("update-db", db)
|
|
},
|
|
sendMessage: function (message) {
|
|
if(typeof message !== "string") {
|
|
message = JSON.stringify(message);
|
|
}
|
|
status.sendSignal("send-message", message);
|
|
},
|
|
addLogMessage: function (type, message) {
|
|
var message = {
|
|
type: type,
|
|
message: JSON.stringify(message)
|
|
};
|
|
var logMessages = getContext("log-messages");
|
|
if (!logMessages) {
|
|
logMessages = [];
|
|
}
|
|
logMessages.push(message);
|
|
addContext("log-messages", logMessages);
|
|
},
|
|
defineSubscription: function (name, subscriptions, handler) {
|
|
_status_catalog.subscriptions[name] = {
|
|
subscriptions: subscriptions,
|
|
handler: handler
|
|
};
|
|
},
|
|
sendSignal: function (eventName, data) {
|
|
var event = {
|
|
event: eventName,
|
|
data: data
|
|
};
|
|
|
|
statusSignals.sendSignal(JSON.stringify(event));
|
|
}
|
|
};
|
|
|
|
function calculateSubscription(parameters, context) {
|
|
var subscriptionConfig = _status_catalog.subscriptions[parameters.name];
|
|
if (!subscriptionConfig) {
|
|
return;
|
|
}
|
|
|
|
return subscriptionConfig.handler(parameters.subscriptions);
|
|
}
|
|
|
|
status.addListener("subscription", calculateSubscription);
|
|
|
|
console = (function (old) {
|
|
return {
|
|
log: function (text) {
|
|
old.log(text);
|
|
status.addLogMessage('log', text);
|
|
},
|
|
debug: function (text) {
|
|
old.debug(text);
|
|
status.addLogMessage('debug', text);
|
|
},
|
|
info: function (text) {
|
|
old.info(text);
|
|
status.addLogMessage('info', text);
|
|
},
|
|
warn: function (text) {
|
|
old.warn(text);
|
|
status.addLogMessage('warn', text);
|
|
},
|
|
error: function (text) {
|
|
old.error(text);
|
|
status.addLogMessage('error', text);
|
|
}
|
|
};
|
|
}(console));
|
|
|
|
var localStorage = {};
|
|
|
|
localStorage.setItem = function(key, value) {
|
|
if(value === null) {
|
|
delete localStorageData[key];
|
|
} else {
|
|
localStorageData[key] = value;
|
|
}
|
|
|
|
status.sendSignal("local-storage", JSON.stringify(localStorageData));
|
|
};
|
|
|
|
localStorage.getItem = function (key) {
|
|
if (typeof localStorageData[key] === "undefined") {
|
|
return null;
|
|
}
|
|
return localStorageData[key];
|
|
};
|