Server : Apache/2.4.41 (Ubuntu) System : Linux absol.cf 5.4.0-198-generic #218-Ubuntu SMP Fri Sep 27 20:18:53 UTC 2024 x86_64 User : www-data ( 33) PHP Version : 7.4.33 Disable Function : pcntl_alarm,pcntl_fork,pcntl_waitpid,pcntl_wait,pcntl_wifexited,pcntl_wifstopped,pcntl_wifsignaled,pcntl_wifcontinued,pcntl_wexitstatus,pcntl_wtermsig,pcntl_wstopsig,pcntl_signal,pcntl_signal_get_handler,pcntl_signal_dispatch,pcntl_get_last_error,pcntl_strerror,pcntl_sigprocmask,pcntl_sigwaitinfo,pcntl_sigtimedwait,pcntl_exec,pcntl_getpriority,pcntl_setpriority,pcntl_async_signals,pcntl_unshare, Directory : /var/www/html/tech_preview/hr/
Upload File :
Current File : //var/www/html/tech_preview/hr/jsflexdb.js
'use strict'
const flexDB = Object.freeze(function () {
var retval = {}, core = {
connector: {},
queue: [],
searchQueue: []
};
core.indexedDB = window.indexedDB
|| window.mozIndexedDB
|| window.webkitIndexedDB
|| window.msIndexedDB;
core.IDBTransaction = window.IDBTransaction
|| window.webkitIDBTransaction
|| window.msIDBTransaction;
core.IDBKeyRange = window.IDBKeyRange
|| window.webkitIDBKeyRange
|| window.msIDBKeyRange;
core.connect = function (core) {
return function (params) {
FormClass.api_call({
url: params.host + "flexdb.php",
params: [
{
name: "task",
value: "connect"
},
{
name: "dbname",
value: params.dbname
},
{
name: "tokenmode_stringvalue",
value: params.token
}
],
func: function (params) {
return function(success, message) {
var func, content;
func = params.func;
if (success) {
if (message.substr(0, 2) == "ok") {
message = message.substr(2);
content = EncodingClass.string.toVariable(message);
if (content.result) {
core.token = params.token;
core.initDB(params, content.accesskey);
}
else {
func(false, {
type: "denied",
message: content.message
});
}
}
else {
func(false, {
type: "run-time",
message: message
});
}
}
else {
func(false, {
type: "system",
message: message
});
}
}
} (params)
});
}
} (core);
core.read = function (core) {
return function (data, key, func) {
if (EncodingClass.type.isArray(key)) {
var keys = [];
var i;
for (i = 0; i < key.length; i++) keys.push(key[i]);
setTimeout(function (task) {
return function () {
task.thread(task);
}
} ({
data: data,
toread: keys,
sresult: [],
result: [],
func: func,
thread: function (task) {
if (task.toread.length == 0) {
task.func(task.sresult, task.result);
return;
}
core.read(task.data, task.toread.shift(), function (task) {
return function (success, value) {
task.sresult.push(success);
if (success) {
task.result.push(value);
}
else {
task.result.push(undefined);
}
task.thread(task);
}
} (task));
}
}), 1);
return;
}
var transaction = data.db.transaction([data.xname], "readwrite");
var objectStore = transaction.objectStore(data.xname);
var objectStoreRequest = objectStore.get(key);
transaction.onerror = function (func) {
return function (event) {
try {
func(false);
}
catch (e) {
console.error(e);
}
};
} (func);
objectStoreRequest.onsuccess = function (func, me) {
return function (event) {
if (me.result === undefined) {
try {
func(false);
}
catch (e) {
console.error(e);
}
}
else {
try {
func(true, me.result);
}
catch (e) {
console.error(e);
}
}
};
} (func, objectStoreRequest);
objectStoreRequest.onerror = function (func) {
return function (event) {
try {
func(false);
}
catch (e) {
console.error(e);
}
};
} (func);
}
} (core);
core.write = function (core) {
return function (data, key, value, func) {
var transaction = data.db.transaction([data.xname], "readwrite");
var objectStore = transaction.objectStore(data.xname);
var objectStoreRequest = objectStore.put(value, key);
transaction.onerror = function (func) {
return function (event) {
if (EncodingClass.type.isFunction(func)) func(false);
};
} (func);
objectStoreRequest.onsuccess = function (func) {
return function (event) {
if (EncodingClass.type.isFunction(func)) func(true);
};
} (func);
objectStoreRequest.onerror = function (func) {
return function (event) {
if (EncodingClass.type.isFunction(func)) func(false);
};
} (func);
}
} (core);
core.write2 = function (core) {
return function (data, content, func) {
var i, n = content.length;
var xcontent = [];
for (i = 0; i < n; i++) {
xcontent.push({
key: content[i].key,
value: content[i].value
});
}
var threadFunc = function (params) {
return function (threadFunc) {
var t;
if (params.xcontent.length > 0) {
t = xcontent.shift();
params.core.write(params.data, t.key, t.value, function (threadFunc) {
return function (success) {
threadFunc(threadFunc);
}
} (threadFunc));
}
else {
params.callbackfunc();
}
}
} ({
data: data,
core: core,
xcontent: xcontent,
callbackfunc: func
});
threadFunc(threadFunc);
}
} (core);
core.deleteContent = function (core) {
return function (data, tableid, func) {
var transaction = data.db.transaction([data.xname], "readwrite");
var objectStore = transaction.objectStore(data.xname);
var objectStoreRequest = objectStore.delete(IDBKeyRange.bound("rec_" + tableid + "_", "rec_" + tableid + String.fromCharCode("_".charCodeAt(0) + 1), false, true));
if (func !== undefined) {
if (EncodingClass.type.isFunction(func)) {
transaction.oncomplete = function (func) {
return function () {
try {
func();
}
catch (e) {
console.error(e);
}
}
} (func);
}
}
}
} (core);
core.upgradeContent = function (core) {
return function (data, tid, curformatver, targetformatver, func) {
// nothing to do now, this function is for future features.
if (func !== undefined) {
if (EncodingClass.type.isFunction(func)) {
try {
func();
}
catch (e) {
console.error(e);
}
}
}
}
} (core);
core.registerDB2 = function (core) {
return function (func, data) {
var keys = Object.keys(data.config.tables);
var i;
for (i = 0; i < keys.length; i++) {
data.updatetime[keys[i]] = 0;
data.config.tables[keys[i]].ready = false;
}
core.write(data, "config", data.config, function (success) {
var retval = {};
core.connector[data.dbname] = data;
retval.read = function (core, data) {
return function (tablename, id, func) {
core.loadRecordsById(data, tablename, id, func);
}
} (core, data);
retval.search = function (core, data, me) {
return function (tablename, pattern, func) {
core.loadRecordsByConditions(data, tablename, pattern, func, me);
}
} (core, data, retval);
retval.refresh = function (core, data) {
return function (tablename) {
if (data.config === undefined) return;
if (data.config.tables === undefined) return;
if (data.config.tables[tablename] === undefined) return;
data.config.tables[tablename].ready = false;
}
} (core, data);
try {
for (i = 0; i < keys.length; i++) {
data.config.tables[keys[i]].inited = true;
}
func(true, retval);
}
catch (e) {
console.error(e);
}
});
}
} (core);
core.registerDB = function (core) {
return function (func, data) {
var i;
var xdata = [];
data.typemark = {};
for (i = 0; i < data.config.types.length; i++) {
data.typemark[data.config.types[i].value] = data.config.types[i].id;
xdata.push({
id: data.config.types[i].id,
detail: data.config.types[i].detail,
value: data.config.types[i].value
});
}
xdata.sort(function (a, b) {
return a.id - b.id;
});
var cksum = "";
for (i = 0; i < xdata.length; i++) {
cksum = cksum + EncodingClass.md5.encode(xdata[i].id + "_" + xdata[i].value + "_" + xdata[i].detail) + "//";
}
cksum = EncodingClass.md5.encode(cksum);
if (data.config.lasttabletime === undefined) data.config.lasttabletime = 0;
FormClass.api_call({
url: data.host + "flexdb.php",
params: [
{
name: "task",
value: "init"
},
{
name: "accesskey",
value: data.accesskey
},
{
name: "lasttypeid",
value: data.config.lasttypeid
},
{
name: "lasttabletime",
value: data.config.lasttabletime
},
{
name: "tokenmode_stringvalue",
value: core.token
},
{
name: "checksum",
value: cksum
}
],
func: function(success, message) {
var i, n, t, content;
var id, keys;
var taskqueue = [];
if (success) {
if (message.substr(0, 2) == "ok") {
message = message.substr(2);
content = EncodingClass.string.toVariable(message);
if (!content.valid) {
data.config.types = [];
data.config.tables = {};
}
for (i = 0; i < content.types.length; i++) {
data.config.types.push(content.types[i]);
id = content.types[i].id;
data.typemark[content.types[i].value] = id;
if (data.config.lasttypeid < id) data.config.lasttypeid = id;
}
for (i = 0; i < content.tables.length; i++) {
id = content.tables[i].id;
if (data.config.lasttableid < id) data.config.lasttableid = id;
if (data.config.tables[content.tables[i].name] === undefined) {
data.config.tables[content.tables[i].name] = {
id: id,
lastupdated: 0,
lastupdatedid: 0,
formatver: content.tables[i].formatver,
contentver: content.tables[i].contentver,
lasttableupdated: content.tables[i].lastupdated,
available: content.tables[i].available == 1
}
}
else {
if (data.config.tables[content.tables[i].name].formatver === undefined) data.config.tables[content.tables[i].name].formatver = 0;
if (data.config.tables[content.tables[i].name].contentver === undefined) data.config.tables[content.tables[i].name].contentver = 0;
data.config.tables[content.tables[i].name].lasttableupdated = content.tables[i].lastupdated;
data.config.tables[content.tables[i].name].available = content.tables[i].available == 1;
if (data.config.tables[content.tables[i].name].contentver != content.tables[i].contentver) {
data.config.tables[content.tables[i].name].contentver = content.tables[i].contentver;
data.config.tables[content.tables[i].name].formatver = content.tables[i].formatver;
data.config.tables[content.tables[i].name].lastupdated = 0;
data.config.tables[content.tables[i].name].lastupdatedid = 0;
taskqueue.push({
task: "delete",
id: content.tables[i].id,
name: content.tables[i].name,
targetver: content.tables[i].formatver
});
}
else if (data.config.tables[content.tables[i].name].formatver != content.tables[i].formatver) {
taskqueue.push({
task: "upgrade",
id: content.tables[i].id,
name: content.tables[i].name,
targetver: content.tables[i].formatver
});
}
}
}
var taskThread = function (core, func, data, taskqueue) {
return function (taskThread) {
if (taskqueue.length == 0) {
core.registerDB2(func, data);
return;
}
var curtask = taskqueue.shift();
switch (curtask.task) {
case "delete":
core.deleteContent(data, curtask.id, function (func, data, tid, name, formatver) {
return function () {
data.config.tables[name].lastupdated = 0;
data.config.tables[name].lastupdatedid = 0;
if (data.config.tables[name].formatver != formatver) {
core.upgradeContent(data, tid, data.config.tables[name].formatver, formatver, function () {
setTimeout(function (taskThread) {
return function () {
taskThread(taskThread);
}
} (taskThread), 2);
});
}
else {
setTimeout(function (taskThread) {
return function () {
taskThread(taskThread);
}
} (taskThread), 2);
}
}
} (func, data, curtask.id, curtask.name, curtask.formatver));
return;
case "upgrade":
core.upgradeContent(data, curtask.id, data.config.tables[curtask.name].formatver, curtask.formatver, function () {
setTimeout(function (taskThread) {
return function () {
taskThread(taskThread);
}
} (taskThread), 2);
});
return;
default:
console.error("invalid task [" + curtask.task + "]");
}
}
} (core, func, data, taskqueue);
var keys = Object.keys(data.config.tables);
for (i = 0; i < keys.length; i++) {
data.config.tables[keys[i]].inited = false;
}
setTimeout(function (taskThread) {
return function () {
taskThread(taskThread);
}
} (taskThread), 2);
}
else {
try {
func(false, {
type: "run-time",
message: message
});
}
catch (e) {
console.error(e);
}
}
}
else {
try {
func(false, {
type: "system",
message: message
});
}
catch (e) {
console.error(e);
}
}
}
});
}
} (core);
core.initDB = function (core) {
return function (params, accesskey) {
var data = {
host: params.host,
dbname: params.dbname,
updatetime: {},
accesskey: accesskey,
xname: "flexdb_" + params.dbname
};
var request = core.indexedDB.open(data.xname);
request.onerror = function (func) {
return function (event) {
try {
if (EncodingClass.type.isFunction(func)) {
func(false, {
type: "unsupported",
message: event
});
}
}
catch (e) {
console.error(e);
}
}
} (params.func);
request.onsuccess = function (func, data) {
return function (event) {
data.db = event.target.result;
core.read(data, "config", function (success, value) {
if (success) {
data.config = value;
core.registerDB(func, data);
}
else {
data.config = value = {
lasttypeid: 0,
types: [],
lasttableid: 0,
tables: {}
};
core.write(data, "config", value, function (success) {
if (success) {
core.registerDB(func, data);
}
else {
try {
func(false, {
type: "unsupported",
message: event
});
}
catch (e) {
console.error(e);
}
}
});
}
});
}
} (params.func, data);
request.onupgradeneeded = function (data) {
return function (event) {
if (data.db === undefined) {
data.db = event.target.result;
}
var objectStore = data.db.createObjectStore(data.xname, { autoIncrement: false });
}
} (data);
}
} (core);
core.reinit = function (core) {
return function (params) {
var data = params.data;
var func = params.func;
FormClass.api_call({
url: data.host + "flexdb.php",
params: [
{
name: "task",
value: "init"
},
{
name: "accesskey",
value: data.accesskey
},
{
name: "lasttypeid",
value: data.config.lasttypeid
},
{
name: "tokenmode_stringvalue",
value: core.token
},
{
name: "lasttableid",
value: data.config.lasttableid
}
],
func: function (core, data, func) {
return function (success, message) {
var i, n, t, content;
if (success) {
if (message.substr(0, 2) == "ok") {
message = message.substr(2);
content = EncodingClass.string.toVariable(message);
for (i = 0; i < content.types.length; i++) {
data.config.types.push(content.types[i]);
data.typemark[content.types[i].value] = content.types[i].id;
}
for (i = 0; i < content.tables.length; i++) {
data.updatetime[content.tables[i].name] = 0;
data.config.tables[content.tables[i].name] = {
id: content.tables[i].id,
ready: false,
lastupdated: 0,
lastupdatedid: 0,
available: content.tables[i].available == 1
}
}
core.write(data, "config", data.config, function (success) {
try {
func(true);
}
catch (e) {
console.error(e);
}
});
}
else {
try {
func(false, {
type: "run-time",
message: message
});
}
catch (e) {
console.error(e);
}
}
}
else {
try {
func(false, {
type: "system",
message: message
});
}
catch (e) {
console.error(e);
}
}
}
} (core, data, func)
});
}
} (core);
core.getTableId = function (core) {
return function (data, tablename, func) {
if (data.config.tables[tablename] !== undefined) {
try {
func(true, data.config.tables[tablename].id);
}
catch (e) {
console.error(e);
}
return;
}
core.reinit(data, function (data, func) {
return function (success, message) {
if (success) {
if (data.config.tables[tablename] !== undefined) {
try {
func(true, data.config.tables[tablename].id);
}
catch (e) {
console.error(e);
}
return;
}
try {
func(true, 0);
}
catch (e) {
console.error(e);
}
}
else {
try {
func(false, message);
}
catch (e) {
console.error(e);
}
}
} (data, func)});
}
} (core);
core.loadRecordsById = function (core) {
return function (data, tablename, id, func) {
var i;
if (data.config.tables[tablename] === undefined) {
try {
func(false, {
type: "system",
message: "table not found"
});
}
catch (e) {
console.error(e);
}
return;
}
if (EncodingClass.type.isArray(id)) {
for (i = 0; i < id.length; i++) {
if (EncodingClass.type.isString(id[i])) id[i] = parseInt(id[i]);
if (id[i] <= 0) {
try {
func(false, {
type: "system",
message: "invalid id[" + i + "] (" + id[i] + ")"
});
}
catch (e) {
console.error(e);
}
return;
}
}
}
else {
if (EncodingClass.type.isString(id)) id = parseInt(id);
if (id <= 0) {
try {
func(false, {
type: "system",
message: "invalid id (" + id + ")"
});
}
catch (e) {
console.error(e);
}
return;
}
}
FormClass.api_call({
url: data.host + "flexdb.php",
params: [
{
name: "task",
value: "read"
},
{
name: "accesskey",
value: data.accesskey
},
{
name: "table",
value: tablename
},
{
name: "tokenmode_stringvalue",
value: core.token
},
{
name: "id",
value: EncodingClass.string.fromVariable(id)
}
],
func: function (func) {
return function(success, message) {
var r;
try {
if (success) {
if (message.substr(0, 2) == "ok") {
r = EncodingClass.string.toVariable(message.substr(2));
if (r.result) {
if (r.value !== undefined) {
func(true, r.value);
}
else if (r.values !== undefined) {
func(true, r.values);
}
else {
func(false, {
type: "unknown",
content: r
})
}
}
else {
func(false, {
type: "denied",
message: message
});
}
}
else {
func(false, {
type: "run-time",
message: message
});
}
}
else {
func(false, {
type: "system",
message: message
});
}
}
catch (e) {
console.error(e);
}
}
} (func)
});
}
} (core);
core.remoteSearch = function (core) {
return function (data, tablename, pattern, func) {
FormClass.api_call({
url: data.host + "flexdb.php",
params: [
{
name: "task",
value: "search"
},
{
name: "accesskey",
value: data.accesskey
},
{
name: "table",
value: tablename
},
{
name: "tokenmode_stringvalue",
value: core.token
},
{
name: "pattern",
value: EncodingClass.string.fromVariable(pattern)
}
],
func: function (func) {
return function(success, message) {
if (success) {
if (message.substr(0, 2) == "ok") {
var r = EncodingClass.string.toVariable(message.substr(2));
if (r.result) {
try {
func(r.values);
}
catch (e) {
console.error(e);
}
}
else {
console.log({
type: "denied",
message: message
});
try {
func(false);
}
catch (e) {
console.error(e);
}
}
}
else {
console.log({
type: "run-time",
message: message
});
try {
func(false);
}
catch (e) {
console.error(e);
}
}
}
else {
console.log({
type: "system",
message: message
});
try {
func(false);
}
catch (e) {
console.error(e);
}
}
}
} (func)
});
}
} (core);
core.localSearch = function (core) {
return function (data, tablename, pattern, func) {
core.searchQueue.push({
data: data,
tablename: tablename,
tableid: data.config.tables[tablename].id,
pattern: pattern,
func: func
});
}
} (core);
core.loadRecordsByConditions = function (core) {
return function (data, tablename, pattern, func, me) {
if (data.config.tables[tablename] === undefined) {
core.remoteSearch(data, tablename, pattern, func);
return;
}
if (!data.config.tables[tablename].ready) {
core.remoteSearch(data, tablename, pattern, func);
return;
}
if (data.updatetime[tablename] + 500000 < (new Date()).getTime()) {
core.remoteSearch(data, tablename, pattern, func);
return;
}
core.localSearch(data, tablename, pattern, func);
}
} (core);
core.decode1 = function (st) {
var i, ch;
var n = st.length, v = [], result = [], sx = 0;
for (i = 1; i < n; i++) {
ch = st.charCodeAt(i);
switch (ch) {
case 95: // "_"
v.push(sx);
sx = 0;
break;
case 35: // "#"
v.push(sx);
result.push(v);
sx = 0;
v = [];
break;
default:
sx = sx * 10 + ch - 48;
break;
}
}
return result;
}
core.decode2 = function (st) {
var i, ch;
var n = st.length, result = [], sx = 0;
for (i = 1; i < n; i++) {
ch = st.charCodeAt(i);
if (ch == 35) { // "#"
result.push(sx);
sx = 0;
}
else {
sx = sx * 10 + ch - 48;
}
}
return result;
}
core.updateFetch = function (core) {
return function (params) {
var xdata, tid;
if (params.queue.length > 0) {
xdata = params.queue.shift();
//console.log(xdata);
tid = params.data.config.tables[params.tablename].id;
core.read(params.data, "rec_" + tid + "_" + xdata.segment, function(params) {
return function(success, value) {
var i, n, pdata, tablename = params.tablename;
if (!success) value = [];
n = params.xdata.content.length;
for (i = 0; i < n; i++) {
pdata = params.xdata.content[i];
value[pdata.id] = [pdata.value, pdata.typeid, pdata.dataref, pdata.recordref, pdata.lastupdated];
if (pdata.lastupdated > params.data.config.tables[tablename].lastupdated) {
params.data.config.tables[tablename].lastupdated = pdata.lastupdated;
params.data.config.tables[tablename].lastupdatedid = pdata.id;
}
else if ((pdata.lastupdated == params.data.config.tables[tablename].lastupdated) && (pdata.id > params.data.config.tables[tablename].lastupdatedid)) {
params.data.config.tables[tablename].lastupdated = pdata.lastupdated;
params.data.config.tables[tablename].lastupdatedid = pdata.id;
}
}
params.core.write2(params.data, [
{
key: "rec_" + params.tid + "_" + params.xdata.segment,
value: value
},
{
key: "config",
value: params.data.config
}
], function(params) {
return function () {
params.core.updateFetch({
data: params.data,
finished: params.finished,
queue: params.queue,
tablename: params.tablename,
func: params.func
});
}
} (params));
}
} ({
core: core,
data: params.data,
finished: params.finished,
queue: params.queue,
segment: params.segment,
tablename: params.tablename,
func: params.func,
tid: tid,
xdata: xdata
}));
return;
}
if (!params.finished) {
setTimeout(function (data, tablename, func) {
return function () {
core.fetch(data, tablename, func);
}
} (params.data, params.tablename, params.func), 10);
return;
}
params.data.config.tables[params.tablename].ready = true;
params.data.updatetime[params.tablename] = (new Date()).getTime();
core.write(params.data, "config", params.data.config, function(func) {
return function(success) {
try {
func();
}
catch (e) {
console.error(e);
}
}
} (params.func));
}
} (core);
core.fetch = function (core) {
return function (data, tablename, func) {
FormClass.api_call({
url: data.host + "flexdb.php",
params: [
{
name: "task",
value: "fetch"
},
{
name: "accesskey",
value: data.accesskey
},
{
name: "table",
value: tablename
},
{
name: "tokenmode_stringvalue",
value: core.token
},
{
name: "lastupdated",
value: data.config.tables[tablename].lastupdated
},
{
name: "lastupdatedid",
value: data.config.tables[tablename].lastupdatedid
}
],
func: function (func, data, tablename) {
return function(success, message) {
if (success) {
if (message.substr(0, 2) == "ok") {
var r = EncodingClass.string.toVariable(message.substr(2));
var i, n, s, mark = [], queue = [];
if (r.result) {
n = r.values.length;
for (i = 0; i < n; i++) {
s = ~~(r.values[i].id / 1024);
if (mark[s] === undefined) {
mark[s] = [];
queue.push(s);
}
r.values[i].dataref = core.decode1(r.values[i].dataref);
r.values[i].recordref = core.decode2(r.values[i].recordref);
mark[s].push(r.values[i]);
}
n = queue.length;
for (i = 0; i < n; i++) {
s = queue[i];
mark[s].sort(function (a, b) {
return a.id - b.id;
});
queue[i] = {
segment: s,
content: mark[s]
};
}
if (n > 0) {
setTimeout(function (core, params) {
return function () {
core.updateFetch(params);
}
} (core, {
data: data,
tablename: tablename,
queue: queue,
finished: r.finished,
func: func
}), 10);
}
else if (r.finished) {
data.config.tables[tablename].ready = true;
data.updatetime[tablename] = (new Date()).getTime();
core.write(data, "config", data.config, function(func) {
return function (success) {
try {
func();
}
catch (e) {
console.error(e);
}
}
} (func));
}
else {
setTimeout(function (func) {
return function () {
try {
func();
}
catch (e) {
console.error(e);
}
}
} (func), 10);
}
}
else {
console.log("fetch denied", message);
}
}
else {
console.log("fetch failed", message);
}
}
else {
setTimeout(function(data, tablename, func) {
return function () {
core.fetch(data, tablename, func);
}
} (data, tablename, func), 5000);
}
}
} (func, data, tablename)
});
}
} (core);
core.thread = function (core) {
return function () {
var cList;
var i, j, fetchdata, cdate, notready;
if (core.queue.length > 0) {
fetchdata = core.queue.shift();
core.fetch(fetchdata.data, fetchdata.tablename, function (func) {
return function () {
setTimeout(func, 10);
}
} (core.thread));
}
else {
cdate = (new Date()).getTime() - 300000;
cList = Object.keys(core.connector);
for (i = 0; i < cList.length; i++) {
var data = core.connector[cList[i]];
var tables = Object.keys(data.config.tables);
for (j = 0; j < tables.length; j++) {
if (!data.config.tables[tables[j]].inited) continue;
if ((data.updatetime[tables[j]] < cdate) || (!data.config.tables[tables[j]].ready)) {
core.queue.push({
data: data,
tablename: tables[j]
});
}
}
}
if (core.queue.length > 0) {
setTimeout(core.thread, 2);
}
else {
setTimeout(core.thread, 100);
}
}
}
} (core);
setTimeout(core.thread, 10);
core.searchThread = function (core) {
return function () {
var host = {
index: 0
};
if (core.searchQueue.length > 0) {
host.init = function (core, host) {
return function (success) {
if (success) {
host.fetch();
}
else {
var func = core.searchQueue[0].func;
core.searchQueue.shift();
try {
func(false);
}
catch (e) {
console.error(e);
}
setTimeout(core.searchThread, 10);
}
}
} (core, host);
host.fetch = function (core, host) {
return function () {
core.read(core.searchQueue[0].data, "rec_" + core.searchQueue[0].tableid + "_" + host.index, function (core, host) {
return function (success, value) {
if (success) {
core.fetchSearch(value, function (core, host) {
return function (retval) {
host.index++;
host.fetch();
}
} (core, host));
}
else {
core.getSearchResult(host.finish);
}
}
} (core, host));
}
} (core, host);
host.finish = function (core, host) {
return function (retval) {
var func = core.searchQueue[0].func;
core.searchQueue.shift();
try {
func(retval);
}
catch (e) {
console.error(e);
}
setTimeout(core.searchThread, 10);
}
} (core, host);
core.initSearch(core.searchQueue[0].data, host.init, core.searchQueue[0].pattern);
return;
}
setTimeout(core.searchThread, 10);
}
} (core);
setTimeout(core.searchThread, 10);
core.initSearch = function (core) {
return function (data, func, pattern) {
core.retfunc = func;
core.searchInstance.call({
task: "init",
types: data.config.types,
pattern: pattern
});
}
} (core);
core.fetchSearch = function (core) {
return function (data, func) {
var i, n, keys, xdata = [];
core.retfunc = func;
keys = Object.keys(data);
keys.sort(function (a, b) {return a - b;});
n = keys.length;
for (i = 0; i < n; i++) {
xdata.push([
keys[i],
data[keys[i]][0],
data[keys[i]][1],
data[keys[i]][2],
data[keys[i]][3]
]);
}
core.searchInstance.call({
task: "fetch",
data: xdata
});
}
} (core);
core.getSearchResult = function (core) {
return function (func) {
core.retfunc = func;
core.searchInstance.call({
task: "finish",
});
}
} (core);
retval.connect = function (core) {
return function (params) {
var host = params.host;
var dbname = params.dbname;
var callbackfunc = params.func;
var token = params.token;
if (host === undefined) return;
if (dbname === undefined) return;
if (callbackfunc === undefined) return;
if (token === undefined) token = "";
if (!EncodingClass.type.isString(host)) return;
if (!EncodingClass.type.isString(dbname)) return;
if (!EncodingClass.type.isFunction(callbackfunc)) return;
if (!core.indexedDB) return;
if (host.length == 0) return;
if (core.searchInstance === undefined) {
core.searchInstance = Thread.create({
extcode: "var types, typepath, searchResult, searchQueue, privtype, nodecount, naturalSort = null, makeTypeDesc = null, makeTypePath = null, getType = null, checkPrivPattern = null, checkPattern = null, rowprocessing = null, ncount = 0;",
func: function (params) {
var i, n;
var keys, values;
if (getType === null) {
getType = function (desc) {
return types[desc];
};
}
if (naturalSort === null) {
naturalSort = function (a, b) {
var re = /(^([+\-]?(?:0|[1-9]\d*)(?:\.\d*)?(?:[eE][+\-]?\d+)?)?$|^0x[0-9a-f]+$|\d+)/gi,
sre = /(^[ ]*|[ ]*$)/g,
dre = /(^([\w ]+,?[\w ]+)?[\w ]+,?[\w ]+\d+:\d+(:\d+)?[\w ]?|^\d{1,4}[\/\-]\d{1,4}[\/\-]\d{1,4}|^\w+, \w+ \d+, \d{4})/,
hre = /^0x[0-9a-f]+$/i,
ore = /^0/,
i = function(s) { return naturalSort.insensitive && ('' + s).toLowerCase() || '' + s; },
// convert all to strings strip whitespace
x = i(a).replace(sre, '') || '',
y = i(b).replace(sre, '') || '',
// chunk/tokenize
xN = x.replace(re, '\0$1\0').replace(/\0$/,'').replace(/^\0/,'').split('\0'),
yN = y.replace(re, '\0$1\0').replace(/\0$/,'').replace(/^\0/,'').split('\0'),
// numeric, hex or date detection
xD = parseInt(x.match(hre), 16) || (xN.length !== 1 && x.match(dre) && Date.parse(x)),
yD = parseInt(y.match(hre), 16) || xD && y.match(dre) && Date.parse(y) || null,
oFxNcL, oFyNcL;
// first try and sort Hex codes or Dates
if (yD) {
if ( xD < yD ) { return -1; }
else if ( xD > yD ) { return 1; }
}
// natural sorting through split numeric strings and default strings
for(var cLoc=0, numS=Math.max(xN.length, yN.length); cLoc < numS; cLoc++) {
// find floats not starting with '0', string or 0 if not defined (Clint Priest)
oFxNcL = !(xN[cLoc] || '').match(ore) && parseFloat(xN[cLoc]) || xN[cLoc] || 0;
oFyNcL = !(yN[cLoc] || '').match(ore) && parseFloat(yN[cLoc]) || yN[cLoc] || 0;
// handle numeric vs string comparison - number < string - (Kyle Adams)
if (isNaN(oFxNcL) !== isNaN(oFyNcL)) { return (isNaN(oFxNcL)) ? 1 : -1; }
// rely on string comparison if different types - i.e. '02' < 2 != '02' < '2'
else if (typeof oFxNcL !== typeof oFyNcL) {
oFxNcL += '';
oFyNcL += '';
}
if (oFxNcL < oFyNcL) { return -1; }
if (oFxNcL > oFyNcL) { return 1; }
}
return 0;
};
}
if (makeTypeDesc === null) {
makeTypeDesc = function (pattern) {
var i, n, r, st, children, keys, values;
var typeid, rv;
n = privtype.length;
for (i = 0; i < n; i++) {
if (pattern.type == privtype[i]) {
r = {
type: pattern.type,
typeid: -1 - i,
cond: pattern.cond,
require: 0,
nodeindex: nodecount++
};
if (pattern.value !== undefined) r.value = pattern.value;
if (pattern.minval !== undefined) r.minval = pattern.minval;
if (pattern.maxval !== undefined) r.maxval = pattern.maxval;
return r;
}
}
if (pattern.type == "struct") {
keys = Object.keys(pattern.children);
values = {};
n = keys.length;
for (i = 0; i < n; i++) {
r = makeTypeDesc(pattern.children[keys[i]]);
if (r === null) return null;
values[keys[i]] = r;
}
keys.sort(naturalSort);
children = [];
st = "";
for (i = 0; i < n; i++) {
st += keys[i].length + "#" + keys[i] + values[keys[i]].typeid + "#";
children.push({
name: keys[i],
content: values[keys[i]]
});
}
if (types[st] === undefined) {
console.error("type definition string not found", st);
return null;
}
typeid = types[st];
rv = {
type: "struct",
typeid: typeid,
cond: pattern.cond,
require: children.length,
children: children
};
if (pattern.cond == "or") {
for (i = 0; i < n; i++) {
if (children[i].content.cond == "true") {
rv.cond = "true";
break;
}
}
}
if (pattern.cond == "and") {
for (i = 0; i < n; i++) {
if (children[i].content.cond == "false") {
rv.cond = "false";
break;
}
}
}
rv.nodeindex = nodecount++;
return rv;
}
if (pattern.type == "array") {
if (pattern.children !== undefined) {
n = pattern.children.length;
}
else {
n = 0;
}
rv = {
type: "array",
typeid: 0,
require: n,
cond: pattern.cond
};
if ((pattern.children !== undefined) && (pattern.cond != "true") && (pattern.cond != "false")) {
children = [];
for (i = 0; i < n; i++) {
r = makeTypeDesc(pattern.children[i]);
if (r === null) {
if (pattern.cond != "or") return null;
}
else {
children.push(r);
}
}
rv.children = children;
if ((pattern.cond == "or") && (children.length == 0)) return null;
}
rv.nodeindex = nodecount++;
return rv;
}
console.error("invalid pattern type", pattern.type);
return null;
}
}
if (makeTypePath === null) {
makeTypePath = function (params) {
var typeid = params.pattern.typeid;
var nodeindex = params.pattern.nodeindex;
var parentType;
var i, n, r, t;
if (params.parentIndex < 0) {
parentType = "*";
}
else {
parentType = params.parent.typeid;
}
if (params.pattern.cond == "false") {
if (params.parent !== null) params.parent.require--;
return;
}
if (typeid < 0) {
if (typepath[typeid] === undefined) typepath[typeid] = [];
if (typepath[typeid][parentType] === undefined) typepath[typeid][parentType] = [];
r = {
cond: params.pattern.cond,
parentIndex: params.parentIndex
};
if (params.pattern.value !== undefined) r.value = params.pattern.value;
if (params.pattern.minval !== undefined) r.minval = params.pattern.minval;
if (params.pattern.maxval !== undefined) r.maxval = params.pattern.maxval;
if (typepath[typeid][parentType][params.index] === undefined) typepath[typeid][parentType][params.index] = [];
if (typepath[typeid][parentType][params.index]["*"] === undefined) typepath[typeid][parentType][params.index]["*"] = [];
typepath[typeid][parentType][params.index]["*"].push(r);
}
if (params.pattern.type == "struct") {
if (typepath[typeid] === undefined) typepath[typeid] = [];
if (typepath[typeid][parentType] === undefined) typepath[typeid][parentType] = [];
if (params.pattern.cond == "true") {
t = "*";
}
else {
t = nodeindex;
}
r = {
cond: params.pattern.cond,
parentIndex: params.parentIndex
};
if ((params.pattern.cond != "true") && (params.pattern.cond != "false")) {
n = params.pattern.children.length;
for (i = 0; i < n; i++) {
makeTypePath({
pattern: params.pattern.children[i].content,
parent: params.pattern,
parentIndex: nodeindex,
index: i
});
}
}
r.require = params.pattern.require;
if (parentType == "*") {
if (typepath[typeid][parentType][t] === undefined) typepath[typeid][parentType][t] = [];
typepath[typeid][parentType][t].push(r);
}
else {
if (typepath[typeid][parentType][params.index] === undefined) typepath[typeid][parentType][params.index] = [];
if (typepath[typeid][parentType][params.index][t] === undefined) typepath[typeid][parentType][params.index][t] = [];
typepath[typeid][parentType][params.index][t].push(r);
}
}
if (params.pattern.type == "array") {
if (typepath[typeid] === undefined) typepath[typeid] = [];
if (typepath[typeid][parentType] === undefined) typepath[typeid][parentType] = [];
if (params.pattern.cond == "true") {
t = "*";
}
else {
t = nodeindex;
}
r = {
cond: params.pattern.cond,
parentIndex: params.parentIndex
};
if ((params.pattern.cond != "true") && (params.pattern.cond != "false")) {
n = params.pattern.children.length;
for (i = 0; i < n; i++) {
makeTypePath({
pattern: params.pattern.children[i],
parent: params.pattern,
parentIndex: nodeindex,
index: 0
});
}
}
r.require = params.pattern.require;
if (parentType == "*") {
if (typepath[typeid][parentType][t] === undefined) typepath[typeid][parentType][t] = [];
typepath[typeid][parentType][t].push(r);
}
else {
if (typepath[typeid][parentType][params.index] === undefined) typepath[typeid][parentType][params.index] = [];
if (typepath[typeid][parentType][params.index][t] === undefined) typepath[typeid][parentType][params.index][t] = [];
typepath[typeid][parentType][params.index][t].push(r);
}
}
};
}
if (checkPrivPattern === null) {
checkPrivPattern = function (typeid, content, path) {
var i, n, ok;
if (path.cond == "true") return true;
if (path.cond == "false") return false;
if (path.cond == "and") {
n = path.value.length;
for (i = 0; i < n; i++) {
ok = checkPrivPattern(typeid, content, path.value[i]);
if (!ok) return false;
}
return true;
}
if (path.cond == "or") {
n = path.value.length;
for (i = 0; i < n; i++) {
ok = checkPrivPattern(typeid, content, path.value[i]);
if (ok) return true;
}
return false;
}
if (typeid == -6) {
switch (path.cond) {
case "eq":
return content == path.value;
case "ne":
return content != path.value;
}
return false;
}
switch (path.cond) {
case "prefix":
return content.substr(0, path.value.length) == path.value;
case "!prefix":
return content.substr(0, path.value.length) != path.value;
case "postfix":
n = content.length;
i = path.value.length;
if (n < i) return false;
return content.substr(n - i, i) == path.value;
case "!postfix":
n = content.length;
i = path.value.length;
if (n < i) return true;
return content.substr(n - i, i) != path.value;
case "contains":
return content.includes(path.value);
case "!contains":
return !content.includes(path.value);
case "eq":
return content == path.value;
case "ne":
return content != path.value;
case "ge":
return content >= path.value;
case "le":
return content <= path.value;
case "g":
return content > path.value;
case "l":
return content < path.value;
case "(range)":
return (path.minval < content) && (content < path.maxval);
case "(range]":
return (path.minval < content) && (content <= path.maxval);
case "[range)":
return (path.minval <= content) && (content < path.maxval);
case "[range]":
return (path.minval <= content) && (content <= path.maxval);
case ")range(":
return (content < path.minval) || (path.maxval < content);
case ")range[":
return (content < path.minval) || (path.maxval <= content);
case "]range(":
return (content <= path.minval) || (path.maxval < content);
case "]range[":
return (content <= path.minval) || (path.maxval <= content);
}
return false;
}
}
if (checkPattern === null) {
checkPattern = function (sq, typeid, content, nodeindex, path) {
var v1, v2, r;
if (path.cond == "true") return true;
if (path.cond == "false") return false;
if (typeid < 0) {
try {
r = checkPrivPattern(typeid, content, path);
return r;
}
catch (e) {
return false;
}
}
if (sq === null) return false;
if (sq[nodeindex] === undefined) return false;
if (path.cond == "and") return Object.keys(sq[nodeindex]).length == path.require;
if (path.cond == "or") return Object.keys(sq[nodeindex]).length > 0;
return false;
}
}
if (rowprocessing === null) {
rowprocessing = function (data) {
var id = data[0];
var content = data[1];
var typeid = data[2];
var dataref = data[3];
var recordref = data[4];
var i, j, k, n, m, r, sq;
var parentType, index, nextid, nodeindex, xpath, nList, parentIndex;
if (id == 8982) {
id = id;
}
if (typepath[typeid] === undefined) return;
if (searchQueue[id] !== undefined) {
sq = searchQueue[id];
}
else {
sq = null;
}
n = dataref.length;
for (i = 0; i < n; i++) {
parentType = dataref[i][0];
index = dataref[i][1];
nextid = dataref[i][2];
if (typepath[typeid][parentType] === undefined) continue;
if (parentType == 0) {
if (typepath[typeid][parentType][index] === undefined) continue;
nList = Object.keys(typepath[typeid][parentType][index]);
r = nList.length;
for (k = 0; k < r; k++) {
nodeindex = nList[k];
xpath = typepath[typeid][parentType][index][nodeindex];
m = xpath.length;
for (j = 0; j < m; j++) {
if (checkPattern(sq, typeid, content, nodeindex, xpath[j])) {
if (searchQueue[nextid] === undefined) searchQueue[nextid] = [];
parentIndex = xpath[j].parentIndex;
if (searchQueue[nextid][parentIndex] === undefined) searchQueue[nextid][parentIndex] = [];
searchQueue[nextid][parentIndex].push(true);
}
}
}
}
else {
if (typepath[typeid][parentType][index] === undefined) continue;
nList = Object.keys(typepath[typeid][parentType][index]);
r = nList.length;
for (k = 0; k < r; k++) {
nodeindex = nList[k];
xpath = typepath[typeid][parentType][index][nodeindex];
m = xpath.length;
for (j = 0; j < m; j++) {
if (checkPattern(sq, typeid, content, nodeindex, xpath[j])) {
if (searchQueue[nextid] === undefined) searchQueue[nextid] = [];
parentIndex = xpath[j].parentIndex;
if (searchQueue[nextid][parentIndex] === undefined) searchQueue[nextid][parentIndex] = [];
//searchQueue[nextid][parentIndex].push(true);
searchQueue[nextid][parentIndex][index] = true;
}
}
}
}
}
n = recordref.length;
for (i = 0; i < n; i++) {
nextid = recordref[i];
if (typepath[typeid]["*"] === undefined) continue;
nList = Object.keys(typepath[typeid]["*"]);
r = nList.length;
for (k = 0; k < r; k++) {
nodeindex = nList[k];
xpath = typepath[typeid]["*"][nodeindex];
m = xpath.length;
for (j = 0; j < m; j++) {
if (checkPattern(sq, typeid, content, nodeindex, xpath[j])) {
searchResult.push(nextid);
break;
}
}
}
}
if (searchQueue[id] !== undefined) delete searchQueue[id];
}
}
switch (params.task) {
case "init":
types = {};
typepath = [];
searchResult = [];
searchQueue = [];
privtype = ["string", "number", "realtime", "date", "datetime", "boolean"];
nodecount = 0;
n = params.types.length;
for (i = 0; i < n; i++) {
types[params.types[i].value] = params.types[i].id;
}
params.pattern = makeTypeDesc(params.pattern);
if (params.pattern === null) return false;
try {
makeTypePath({
pattern: params.pattern,
parent: null,
parentIndex: -1,
index: 0
});
return true;
}
catch (e) {
console.error("Invalid search pattern");
console.error(e);
return false;
}
case "fetch":
n = params.data.length;
for (i = 0; i < n; i++) {
rowprocessing(params.data[i]);
}
return 0;
case "finish":
n = searchResult;
types = {};
typepath = [];
searchResult = [];
searchQueue = [];
return n;
}
},
callbackfunc: function (retval) {
core.retfunc(retval);
}
});
}
if (host.substr(host.length - 1, 1) != "/") host = host + "/";
if (core.connector[host] !== undefined) {
func(true, core.connector[host]);
return;
}
core.connect({
host: host,
dbname: dbname,
token: token,
func: callbackfunc
});
}
} (core);
return retval;
} ());
Server : Apache/2.4.41 (Ubuntu)