// Copyright 2012-2017 (c) Peter Širka <petersirka@gmail.com>

//

// Permission is hereby granted, free of charge, to any person obtaining a

// copy of this software and associated documentation files (the

// "Software"), to deal in the Software without restriction, including

// without limitation the rights to use, copy, modify, merge, publish,

// distribute, sublicense, and/or sell copies of the Software, and to permit

// persons to whom the Software is furnished to do so, subject to the

// following conditions:

//

// The above copyright notice and this permission notice shall be included

// in all copies or substantial portions of the Software.

//

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN

// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,

// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR

// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE

// USE OR OTHER DEALINGS IN THE SOFTWARE.

/**

* @module Framework

* @version 2.8.0

*/

'use strict';

const Qs = require('querystring');

const Os = require('os');

const Fs = require('fs');

const Zlib = require('zlib');

const Path = require('path');

const Crypto = require('crypto');

const Parser = require('url');

const Child = require('child_process');

const Util = require('util');

const http = require('http');

const ENCODING = 'utf8';

const HEADER_CACHE = 'Cache-Control';

const HEADER_TYPE = 'Content-Type';

const HEADER_LENGTH = 'Content-Length';

const CT_TEXT = 'text/plain';

const CT_HTML = 'text/html';

const CT_JSON = 'application/json';

const COMPRESSION = { 'text/plain': true, 'text/javascript': true, 'text/css': true, 'text/jsx': true, 'application/x-javascript': true, 'application/json': true, 'text/xml': true, 'image/svg+xml': true, 'text/x-markdown': true, 'text/html': true };

const REG_TEMPORARY = /\//g;

const REG_MOBILE = /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini|Mobile|Tablet/i;

const REG_ROBOT = /search|agent|bot|crawler|spider/i;

const REG_VERSIONS = /(href|src)="[a-zA-Z0-9\/\:\-\.]+\.(jpg|js|css|png|gif|svg|html|ico|json|less|sass|scss|swf|txt|webp|woff|woff2|xls|xlsx|xml|xsl|xslt|zip|rar|csv|doc|docx|eps|gzip|jpe|jpeg|manifest|mov|mp3|flac|mp4|ogg|package|pdf)"/gi;

const REG_COMPILECSS = /url\(.*?\)/g;

const REG_ROUTESTATIC = /^(\/\/|https\:|http\:)+/;

const REG_RANGE = /bytes=/;

const REG_EMPTY = /\s/g;

const REG_ACCEPTCLEANER = /\s|\./g;

const REG_SANITIZE_BACKSLASH = /\/\//g;

const REG_WEBSOCKET_ERROR = /ECONNRESET|EHOSTUNREACH|EPIPE|is closed/i;

const REG_WINDOWSPATH = /\\/g;

const REG_SCRIPTCONTENT = /\<|\>|;/;

const REG_HTTPHTTPS = /^(\/)?(http|https)\:\/\//i;

const REG_NOCOMPRESS = /[\.|-]+min\.(css|js)$/i;

const REG_TEXTAPPLICATION = /text|application/;

const REG_ENCODINGCLEANER = /[\;\s]charset=utf\-8/g;

const REG_SKIPERROR = /epipe|invalid\sdistance/i;

const FLAGS_PROXY = ['post', 'json'];

const FLAGS_INSTALL = ['get'];

const FLAGS_DOWNLOAD = ['get', 'dnscache'];

const QUERYPARSEROPTIONS = { maxKeys: 69 };

const EMPTYARRAY = [];

const EMPTYOBJECT = {};

const EMPTYREQUEST = { uri: {} };

const SINGLETONS = {};

const REPOSITORY_HEAD = '$head';

const REPOSITORY_META_TITLE = '$title';

const REPOSITORY_META_DESCRIPTION = '$description';

const REPOSITORY_META_KEYWORDS = '$keywords';

const REPOSITORY_META_AUTHOR = '$author';

const REPOSITORY_META_IMAGE = '$image';

const REPOSITORY_PLACE = '$place';

const REPOSITORY_SITEMAP = '$sitemap';

const ATTR_END = '"';

const ETAG = '858';

const CONCAT = [null, null];

const CLUSTER_CACHE_SET = { TYPE: 'cache-set' };

const CLUSTER_CACHE_REMOVE = { TYPE: 'cache-remove' };

const CLUSTER_CACHE_REMOVEALL = { TYPE: 'cache-remove-all' };

const CLUSTER_CACHE_CLEAR = { TYPE: 'cache-clear' };

Object.freeze(EMPTYOBJECT);

Object.freeze(EMPTYARRAY);

Object.freeze(EMPTYREQUEST);

global.EMPTYOBJECT = EMPTYOBJECT;

global.EMPTYARRAY = EMPTYARRAY;

var PROTORES, PROTOREQ;

var RANGE = { start: 0, end: 0 };

var HEADERS = {};

var SUCCESSHELPER = { success: true };

// Cached headers for repeated usage

HEADERS.responseCode = {};

HEADERS.responseCode[HEADER_TYPE] = CT_TEXT;

HEADERS.responseCode['X-Powered-By'] = 'Total.js';

HEADERS.redirect = {};

HEADERS.redirect[HEADER_TYPE] = CT_HTML + '; charset=utf-8';

HEADERS.redirect[HEADER_LENGTH] = '0';

HEADERS.sse = {};

HEADERS.sse[HEADER_CACHE] = 'no-cache, no-store, must-revalidate';

HEADERS.sse['Pragma'] = 'no-cache';

HEADERS.sse['Expires'] = '0';

HEADERS.sse[HEADER_TYPE] = 'text/event-stream';

HEADERS.sse['X-Powered-By'] = 'Total.js';

HEADERS.mmr = {};

HEADERS.mmr[HEADER_CACHE] = 'no-cache, no-store, must-revalidate';

HEADERS.mmr['Pragma'] = 'no-cache';

HEADERS.mmr['Expires'] = '0';

HEADERS.mmr['X-Powered-By'] = 'Total.js';

HEADERS.proxy = {};

HEADERS.proxy['X-Proxy'] = 'total.js';

HEADERS.file_lastmodified = {};

HEADERS.file_lastmodified['Access-Control-Allow-Origin'] = '*';

HEADERS.file_lastmodified[HEADER_CACHE] = 'public, max-age=11111111';

HEADERS.file_lastmodified['X-Powered-By'] = 'Total.js';

HEADERS.file_release_compress = {};

HEADERS.file_release_compress[HEADER_CACHE] = 'public, max-age=11111111';

HEADERS.file_release_compress['Vary'] = 'Accept-Encoding';

HEADERS.file_release_compress['Access-Control-Allow-Origin'] = '*';

HEADERS.file_release_compress['Last-Modified'] = 'Mon, 01 Jan 2001 08:00:00 GMT';

HEADERS.file_release_compress['Content-Encoding'] = 'gzip';

HEADERS.file_release_compress['X-Powered-By'] = 'Total.js';

HEADERS.file_release_compress_range = {};

HEADERS.file_release_compress_range['Accept-Ranges'] = 'bytes';

HEADERS.file_release_compress_range[HEADER_CACHE] = 'public, max-age=11111111';

HEADERS.file_release_compress_range['Vary'] = 'Accept-Encoding';

HEADERS.file_release_compress_range['Access-Control-Allow-Origin'] = '*';

HEADERS.file_release_compress_range['Last-Modified'] = 'Mon, 01 Jan 2001 08:00:00 GMT';

HEADERS.file_release_compress_range['Content-Encoding'] = 'gzip';

HEADERS.file_release_compress_range[HEADER_LENGTH] = '0';

HEADERS.file_release_compress_range['Content-Range'] = '';

HEADERS.file_release_compress_range['X-Powered-By'] = 'Total.js';

HEADERS.file_release = {};

HEADERS.file_release[HEADER_CACHE] = 'public, max-age=11111111';

HEADERS.file_release['Vary'] = 'Accept-Encoding';

HEADERS.file_release['Access-Control-Allow-Origin'] = '*';

HEADERS.file_release['Last-Modified'] = 'Mon, 01 Jan 2001 08:00:00 GMT';

HEADERS.file_release['X-Powered-By'] = 'Total.js';

HEADERS.file_release_range = {};

HEADERS.file_release_range['Accept-Ranges'] = 'bytes';

HEADERS.file_release_range[HEADER_CACHE] = 'public, max-age=11111111';

HEADERS.file_release_range['Vary'] = 'Accept-Encoding';

HEADERS.file_release_range['Access-Control-Allow-Origin'] = '*';

HEADERS.file_release_range['Last-Modified'] = 'Mon, 01 Jan 2001 08:00:00 GMT';

HEADERS.file_release_range[HEADER_LENGTH] = '0';

HEADERS.file_release_range['Content-Range'] = '';

HEADERS.file_release_range['X-Powered-By'] = 'Total.js';

HEADERS.file_debug_compress = {};

HEADERS.file_debug_compress[HEADER_CACHE] = 'private, no-cache, no-store, must-revalidate';

HEADERS.file_debug_compress['Vary'] = 'Accept-Encoding';

HEADERS.file_debug_compress['Access-Control-Allow-Origin'] = '*';

HEADERS.file_debug_compress['Pragma'] = 'no-cache';

HEADERS.file_debug_compress['Expires'] = '0';

HEADERS.file_debug_compress['Content-Encoding'] = 'gzip';

HEADERS.file_debug_compress['X-Powered-By'] = 'Total.js';

HEADERS.file_debug_compress_range = {};

HEADERS.file_debug_compress_range['Accept-Ranges'] = 'bytes';

HEADERS.file_debug_compress_range[HEADER_CACHE] = 'private, no-cache, no-store, must-revalidate';

HEADERS.file_debug_compress_range['Vary'] = 'Accept-Encoding';

HEADERS.file_debug_compress_range['Access-Control-Allow-Origin'] = '*';

HEADERS.file_debug_compress_range['Content-Encoding'] = 'gzip';

HEADERS.file_debug_compress_range['Pragma'] = 'no-cache';

HEADERS.file_debug_compress_range['Expires'] = '0';

HEADERS.file_debug_compress_range[HEADER_LENGTH] = '0';

HEADERS.file_debug_compress_range['Content-Range'] = '';

HEADERS.file_debug_compress_range['X-Powered-By'] = 'Total.js';

HEADERS.file_debug = {};

HEADERS.file_debug[HEADER_CACHE] = 'private, no-cache, no-store, must-revalidate';

HEADERS.file_debug['Vary'] = 'Accept-Encoding';

HEADERS.file_debug['Pragma'] = 'no-cache';

HEADERS.file_debug['Expires'] = '0';

HEADERS.file_debug['Access-Control-Allow-Origin'] = '*';

HEADERS.file_debug['X-Powered-By'] = 'Total.js';

HEADERS.file_debug_range = {};

HEADERS.file_debug_range['Accept-Ranges'] = 'bytes';

HEADERS.file_debug_range[HEADER_CACHE] = 'private, no-cache, no-store, must-revalidate';

HEADERS.file_debug_range['Vary'] = 'Accept-Encoding';

HEADERS.file_debug_range['Access-Control-Allow-Origin'] = '*';

HEADERS.file_debug_range['Pragma'] = 'no-cache';

HEADERS.file_debug_range['Expires'] = '0';

HEADERS.file_debug_range[HEADER_LENGTH] = '0';

HEADERS.file_debug_range['Content-Range'] = '';

HEADERS.file_debug_range['X-Powered-By'] = 'Total.js';

HEADERS.content_mobile_release = {};

HEADERS.content_mobile_release['Vary'] = 'Accept-Encoding, User-Agent';

HEADERS.content_mobile_release['Content-Encoding'] = 'gzip';

HEADERS.content_mobile = {};

HEADERS.content_mobile['Vary'] = 'Accept-Encoding, User-Agent';

HEADERS.content_mobile['X-Powered-By'] = 'Total.js';

HEADERS.content_compress = {};

HEADERS.content_compress[HEADER_CACHE] = 'private';

HEADERS.content_compress['Vary'] = 'Accept-Encoding';

HEADERS.content_compress['Content-Encoding'] = 'gzip';

HEADERS.content_compress['X-Powered-By'] = 'Total.js';

HEADERS.content = {};

HEADERS.content['Vary'] = 'Accept-Encoding';

HEADERS.content['X-Powered-By'] = 'Total.js';

HEADERS.stream_release_compress = {};

HEADERS.stream_release_compress[HEADER_CACHE] = 'public, max-age=11111111';

HEADERS.stream_release_compress['Access-Control-Allow-Origin'] = '*';

HEADERS.stream_release_compress['Content-Encoding'] = 'gzip';

HEADERS.stream_release_compress['X-Powered-By'] = 'Total.js';

HEADERS.stream_release = {};

HEADERS.stream_release[HEADER_CACHE] = 'public, max-age=11111111';

HEADERS.stream_release['Access-Control-Allow-Origin'] = '*';

HEADERS.stream_release['X-Powered-By'] = 'Total.js';

HEADERS.stream_debug_compress = {};

HEADERS.stream_debug_compress[HEADER_CACHE] = 'private, no-cache, no-store, must-revalidate';

HEADERS.stream_debug_compress['Pragma'] = 'no-cache';

HEADERS.stream_debug_compress['Expires'] = '0';

HEADERS.stream_debug_compress['Access-Control-Allow-Origin'] = '*';

HEADERS.stream_debug_compress['Content-Encoding'] = 'gzip';

HEADERS.stream_debug_compress['X-Powered-By'] = 'Total.js';

HEADERS.stream_debug = {};

HEADERS.stream_debug[HEADER_CACHE] = 'private, no-cache, no-store, must-revalidate';

HEADERS.stream_debug['Pragma'] = 'no-cache';

HEADERS.stream_debug['Expires'] = '0';

HEADERS.stream_debug['Access-Control-Allow-Origin'] = '*';

HEADERS.stream_debug['X-Powered-By'] = 'Total.js';

HEADERS.binary_compress = {};

HEADERS.binary_compress[HEADER_CACHE] = 'public';

HEADERS.binary_compress['Content-Encoding'] = 'gzip';

HEADERS.binary_compress['X-Powered-By'] = 'Total.js';

HEADERS.binary = {};

HEADERS.binary[HEADER_CACHE] = 'public';

HEADERS.binary['X-Powered-By'] = 'Total.js';

HEADERS.authorization = { user: '', password: '', empty: true };

HEADERS.fsStreamRead = { flags: 'r', mode: '0666', autoClose: true };

HEADERS.fsStreamReadRange = { flags: 'r', mode: '0666', autoClose: true, start: 0, end: 0 };

HEADERS.workers = { cwd: '' };

HEADERS.mmrpipe = { end: false };

HEADERS.responseLocalize = {};

HEADERS.responseNotModified = {};

HEADERS.responseNotModified[HEADER_CACHE] = 'public, max-age=11111111';

HEADERS.responseNotModified['X-Powered-By'] = 'Total.js';

HEADERS.response503 = {};

HEADERS.response503[HEADER_CACHE] = 'private, no-cache, no-store, must-revalidate';

HEADERS.response503[HEADER_TYPE] = CT_HTML;

HEADERS.response503['X-Powered-By'] = 'Total.js';

HEADERS.notModifiedEtag = {};

HEADERS.notModifiedEtag['X-Powered-By'] = 'Total.js';

HEADERS.notModifiedLastModifiedDate = {};

HEADERS.notModifiedLastModifiedDate['X-Powered-By'] = 'Total.js';

Object.freeze(HEADERS.authorization);

var IMAGEMAGICK = false;

var _controller = '';

var _owner = '';

var _test;

var _flags;

// GO ONLINE MODE

!global.framework_internal && (global.framework_internal = require('./internal'));

!global.framework_builders && (global.framework_builders = require('./builders'));

!global.framework_utils && (global.framework_utils = require('./utils'));

!global.framework_mail && (global.framework_mail = require('./mail'));

!global.framework_image && (global.framework_image = require('./image'));

!global.framework_nosql && (global.framework_nosql = require('./nosql'));

global.Builders = framework_builders;

var U = global.Utils = global.utils = global.U = global.framework_utils;

global.Mail = framework_mail;

global.WTF = (message, name, uri) => F.problem(message, name, uri);

global.INCLUDE = global.SOURCE = (name, options) => F.source(name, options);

global.MODULE = (name) => F.module(name);

global.NOSQL = (name) => F.nosql(name);

global.NOBIN = (name) => F.nosql(name).binary;

global.NOCOUNTER = (name) => F.nosql(name).counter;

global.NOMEM = global.NOSQLMEMORY = (name, view) => global.framework_nosql.inmemory(name, view);

global.CONFIG = (name) => F.config[name];

global.UPTODATE = (type, url, options, interval, callback) => F.uptodate(type, url, options, interval, callback);

global.INSTALL = (type, name, declaration, options, callback) => F.install(type, name, declaration, options, callback);

global.UNINSTALL = (type, name, options) => F.uninstall(type, name, options);

global.RESOURCE = (name, key) => F.resource(name, key);

global.TRANSLATE = (name, key) => F.translate(name, key);

global.TRANSLATOR = (name, text) => F.translator(name, text);

global.TRACE = (message, name, uri, ip) => F.trace(message, name, uri, ip);

global.MODEL = (name) => F.model(name);

global.$$$ = global.GETSCHEMA = (group, name, fn, timeout) => framework_builders.getschema(group, name, fn, timeout);

global.CREATE = (group, name) => framework_builders.getschema(group, name).default();

global.SCRIPT = (body, value, callback, param) => F.script(body, value, callback, param);

global.SINGLETON = (name, def) => SINGLETONS[name] || (SINGLETONS[name] = (new Function('return ' + (def || '{}')))());

global.EACHSCHEMA = (group, fn) => framework_builders.eachschema(group, fn);

global.FUNCTION = (name) => F.functions[name];

global.ROUTING = (name) => F.routing(name);

global.SCHEDULE = (date, each, fn, param) => F.schedule(date, each, fn, param);

global.FINISHED = (stream, callback) => framework_internal.onFinished(stream, callback);

global.DESTROY = (stream) => framework_internal.destroyStream(stream);

global.UID = () => UIDGENERATOR.date + (++UIDGENERATOR.index).padLeft(4, '0') + UIDGENERATOR.instance + (UIDGENERATOR.index % 2 ? 1 : 0);

global.ROUTE = (a, b, c, d, e) => F.route(a, b, c, d, e);

global.GROUP = (a, b) => F.group(a, b);

global.WEBSOCKET = (a, b, c, d) => F.websocket(a, b, c, d);

global.FILE = (a, b, c) => F.file(a, b, c);

global.REDIRECT = (a, b, c, d) => F.redirect(a, b, c, d);

global.$CREATE = function(schema) {

schema = parseSchema(schema);

var o = framework_builders.getschema(schema[0], schema[1]);

return o ? o.default() : null;

};

global.$MAKE = function(schema, model, filter, callback, novalidate, argument) {

schema = parseSchema(schema);

var o = framework_builders.getschema(schema[0], schema[1]);

return o ? o.make(model, filter, callback, argument, novalidate) : undefined;

};

global.$QUERY = function(schema, options, callback, controller) {

schema = parseSchema(schema);

var o = framework_builders.getschema(schema[0], schema[1]);

o && o.query(options, callback, controller);

return o ? true : false;

};

global.$GET = function(schema, options, callback, controller) {

schema = parseSchema(schema);

var o = framework_builders.getschema(schema[0], schema[1]);

o && o.get(options, callback, controller);

return o ? true : false;

};

global.$WORKFLOW = function(schema, name, options, callback, controller) {

schema = parseSchema(schema);

var o = framework_builders.getschema(schema[0], schema[1]);

o && o.workflow2(name, options, callback, controller);

return o ? true : false;

};

global.$TRANSFORM = function(schema, name, options, callback, controller) {

schema = parseSchema(schema);

var o = framework_builders.getschema(schema[0], schema[1]);

o && o.transform2(name, options, callback, controller);

return o ? true : false;

};

global.$OPERATION = function(schema, name, options, callback, controller) {

schema = parseSchema(schema);

var o = framework_builders.getschema(schema[0], schema[1]);

o && o.operation2(name, options, callback, controller);

return o ? true : false;

};

global.DB = global.DATABASE = function() {

return typeof(F.database) === 'object' ? F.database : F.database.apply(framework, arguments);

};

global.ON = function() {

return F.on.apply(F, arguments);

};

global.OFF = function() {

return arguments.length > 1 ? F.removeListener.apply(F, arguments) : F.removeAllListeners.apply(F, arguments);

};

global.EMIT = function() {

return F.emit.apply(F, arguments);

};

global.LOG = function() {

return F.log.apply(F, arguments);

};

global.LOGGER = function() {

return F.logger.apply(F, arguments);

};

global.MAKE = global.TRANSFORM = function(transform, fn) {

if (typeof(transform) === 'function') {

var tmp = fn;

fn = transform;

transform = tmp;

}

var obj;

if (typeof(fn) === 'function') {

obj = {};

fn.call(obj, obj);

} else

obj = fn;

return transform ? TransformBuilder.transform.apply(obj, arguments) : obj;

};

global.NEWTRANSFORM = function() {

return TransformBuilder.addTransform.apply(this, arguments);

};

global.NEWSCHEMA = function(group, name) {

if (!name) {

name = group;

group = 'default';

}

return framework_builders.newschema(group, name);

};

global.CLEANUP = function(stream, callback) {

var fn = function() {

FINISHED(stream, function() {

DESTROY(stream);

if (callback) {

callback();

callback = null;

}

});

};

stream.on('error', fn);

if (stream.readable)

stream.on('end', fn);

else

stream.on('finish', fn);

};

global.SUCCESS = function(success, value) {

if (typeof(success) === 'function') {

return function(err, value) {

success(err, SUCCESS(err, value));

};

}

var err;

if (success instanceof Error) {

err = success;

success = false;

} else if (success instanceof framework_builders.ErrorBuilder) {

if (success.hasError()) {

err = success.output();

success = false;

} else

success = true;

} else if (success == null)

success = true;

SUCCESSHELPER.success = success ? true : false;

SUCCESSHELPER.value = value == null ? undefined : value;

SUCCESSHELPER.error = err ? err : undefined;

return SUCCESSHELPER;

};

global.TRY = function(fn, err) {

try {

fn();

return true;

} catch (e) {

err && err(e);

return false;

}

};

global.OBSOLETE = function(name, message) {

console.log(F.datetime.format('yyyy-MM-dd HH:mm:ss') + ' :: OBSOLETE / IMPORTANT ---> "' + name + '"', message);

if (global.F)

F.stats.other.obsolete++;

};

global.DEBUG = false;

global.TEST = false;

global.RELEASE = false;

global.is_client = false;

global.is_server = true;

var directory = U.$normalize(require.main ? Path.dirname(require.main.filename) : process.cwd());

// F.service() changes the values below:

var DATE_EXPIRES = new Date().add('y', 1).toUTCString();

const WEBSOCKET_COMPRESS = U.createBuffer([0x00, 0x00, 0xFF, 0xFF]);

const WEBSOCKET_COMPRESS_OPTIONS = { windowBits: Zlib.Z_DEFAULT_WINDOWBITS };

const UIDGENERATOR = { date: new Date().format('yyMMddHHmm'), instance: 'abcdefghijklmnoprstuwxy'.split('').random().join('').substring(0, 3), index: 1 };

const EMPTYBUFFER = U.createBufferSize(0);

global.EMPTYBUFFER = EMPTYBUFFER;

const controller_error_status = function(controller, status, problem) {

if (status !== 500 && problem)

controller.problem(problem);

if (controller.res.success || controller.res.headersSent || !controller.isConnected)

return controller;

controller.precache && controller.precache(null, null, null);

controller.req.path = EMPTYARRAY;

controller.req.$total_success();

controller.req.$total_route = F.lookup(controller.req, '#' + status, EMPTYARRAY, 0);

controller.req.$total_exception = problem;

controller.req.$total_execute(status, true);

return controller;

};

function Framework() {

this.$id = null; // F.id ==> property

this.version = 2800;

this.version_header = '2.8.0';

this.version_node = process.version.toString().replace('v', '').replace(/\./g, '').parseFloat();

this.config = {

debug: false,

trace: true,

'trace-console': true,

name: 'Total.js',

version: '1.0.0',

author: '',

secret: Os.hostname() + '-' + Os.platform() + '-' + Os.arch(),

'default-xpoweredby': 'Total.js',

'etag-version': '',

'directory-controllers': '/controllers/',

'directory-components': '/components/',

'directory-views': '/views/',

'directory-definitions': '/definitions/',

'directory-temp': '/tmp/',

'directory-models': '/models/',

'directory-resources': '/resources/',

'directory-public': '/public/',

'directory-public-virtual': '/app/',

'directory-modules': '/modules/',

'directory-source': '/source/',

'directory-logs': '/logs/',

'directory-tests': '/tests/',

'directory-databases': '/databases/',

'directory-workers': '/workers/',

'directory-packages': '/packages/',

'directory-private': '/private/',

'directory-isomorphic': '/isomorphic/',

'directory-configs': '/configs/',

'directory-services': '/services/',

'directory-themes': '/themes/',

// all HTTP static request are routed to directory-public

'static-url': '',

'static-url-script': '/js/',

'static-url-style': '/css/',

'static-url-image': '/img/',

'static-url-video': '/video/',

'static-url-font': '/fonts/',

'static-url-download': '/download/',

'static-url-components': '/components.',

'static-accepts': { 'flac': true, 'jpg': true, 'png': true, 'gif': true, 'ico': true, 'js': true, 'css': true, 'txt': true, 'xml': true, 'woff': true, 'woff2': true, 'otf': true, 'ttf': true, 'eot': true, 'svg': true, 'zip': true, 'rar': true, 'pdf': true, 'docx': true, 'xlsx': true, 'doc': true, 'xls': true, 'html': true, 'htm': true, 'appcache': true, 'manifest': true, 'map': true, 'ogv': true, 'ogg': true, 'mp4': true, 'mp3': true, 'webp': true, 'webm': true, 'swf': true, 'package': true, 'json': true, 'md': true, 'm4v': true, 'jsx': true },

// 'static-accepts-custom': [],

'default-layout': 'layout',

'default-theme': '',

// default maximum request size / length

// default 10 kB

'default-request-length': 10,

'default-websocket-request-length': 2,

'default-websocket-encodedecode': true,

'default-maximum-file-descriptors': 0,

'default-timezone': '',

'default-root': '',

'default-response-maxage': '11111111',

'default-errorbuilder-status': 200,

// Seconds (2 minutes)

'default-cors-maxage': 120,

// in milliseconds

'default-request-timeout': 3000,

// otherwise is used ImageMagick (Heroku supports ImageMagick)

// gm = graphicsmagick or im = imagemagick

'default-image-converter': 'gm',

'default-image-quality': 93,

'default-image-consumption': 30,

'allow-handle-static-files': true,

'allow-gzip': true,

'allow-websocket': true,

'allow-websocket-compression': true,

'allow-compile-script': true,

'allow-compile-style': true,

'allow-compile-html': true,

'allow-performance': false,

'allow-custom-titles': false,

'allow-cache-snapshot': false,

'allow-defer': false,

'allow-debug': false,

'allow-head': false,

'allow-filter-errors': true,

'disable-strict-server-certificate-validation': true,

'disable-clear-temporary-directory': false,

// Used in F.service()

// All values are in minutes

'default-interval-clear-resources': 20,

'default-interval-clear-cache': 10,

'default-interval-precompile-views': 61,

'default-interval-websocket-ping': 3,

'default-interval-clear-dnscache': 120,

'default-interval-uptodate': 5

};

this.global = {};

this.resources = {};

this.connections = {};

this.functions = {};

this.themes = {};

this.versions = null;

this.workflows = {};

this.uptodates = null;

this.schedules = [];

this.isDebug = true;

this.isTest = false;

this.isLoaded = false;

this.isWorker = true;

this.isCluster = process.env.PASSENGER_APP_ENV ? false : require('cluster').isWorker;

this.routes = {

sitemap: null,

web: [],

files: [],

cors: [],

websockets: [],

middleware: {},

redirects: {},

resize: {},

request: [],

views: {},

merge: {},

mapping: {},

packages: {},

blocks: {},

resources: {},

mmr: {}

};

this.owners = [];

this.modificators = null;

this.helpers = {};

this.modules = {};

this.models = {};

this.sources = {};

this.controllers = {};

this.dependencies = {};

this.isomorphic = {};

this.components = { has: false, css: false, js: false, views: {}, instances: {}, version: null, links: '', groups: {} };

this.convertors = [];

this.tests = [];

this.errors = [];

this.problems = [];

this.changes = [];

this.server = null;

this.port = 0;

this.ip = '';

this.validators = {

email: new RegExp('^[a-zA-Z0-9-_.+]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$'),

url: /^(https?:\/\/(?:www\.|(?!www))[^\s\.#!:\?\+=&@!$'~*,;\/\(\)\[\]]+\.[^\s#!\?\+=&@!$'~*,;\(\)\[\]\\]{2,}\/?|www\.[^\s#!:\.\?\+=&@!$'~*,;\/\(\)\[\]]+\.[^\s#!\?\+=&@!$'~*,;\(\)\[\]\\]{2,}\/?)/i,

phone: /^[\+]?[(]?[0-9]{3}[)]?[-\s\.]?[0-9]{3}[-\s\.]?[0-9]{4,6}$/im,

zip: /^\d{5}(?:[-\s]\d{4})?$/,

uid: /^\d{14,}[a-z]{3}[01]{1}$/

};

this.workers = {};

this.databases = {};

this.directory = HEADERS.workers.cwd = directory;

this.isLE = Os.endianness ? Os.endianness() === 'LE' : true;

this.isHTTPS = false;

this.datetime = new Date();

// It's hidden

// this.waits = {};

this.temporary = {

path: {},

notfound: {},

processing: {},

range: {},

views: {},

versions: {},

dependencies: {}, // temporary for module dependencies

other: {},

internal: {}, // controllers/modules names for the routing

owners: {},

ready: {},

defer: {}

};

this.stats = {

other: {

websocketPing: 0,

websocketCleaner: 0,

obsolete: 0,

restart: 0,

mail: 0

},

request: {

request: 0,

pending: 0,

web: 0,

xhr: 0,

file: 0,

websocket: 0,

get: 0,

options: 0,

head: 0,

post: 0,

put: 0,

path: 0,

upload: 0,

schema: 0,

mmr: 0,

blocked: 0,

'delete': 0,

mobile: 0,

desktop: 0

},

response: {

view: 0,

json: 0,

websocket: 0,

timeout: 0,

custom: 0,

binary: 0,

pipe: 0,

file: 0,

image: 0,

destroy: 0,

stream: 0,

streaming: 0,

plain: 0,

empty: 0,

redirect: 0,

forward: 0,

notModified: 0,

sse: 0,

mmr: 0,

errorBuilder: 0,

error400: 0,

error401: 0,

error403: 0,

error404: 0,

error408: 0,

error431: 0,

error500: 0,

error501: 0

}

};

// intialize cache

this.cache = new FrameworkCache();

this.path = new FrameworkPath();

this._request_check_redirect = false;

this._request_check_referer = false;

this._request_check_POST = false;

this._request_check_robot = false;

this._length_middleware = 0;

this._length_request_middleware = 0;

this._length_files = 0;

this._length_wait = 0;

this._length_themes = 0;

this._length_cors = 0;

this._length_subdomain_web = 0;

this._length_subdomain_websocket = 0;

this._length_convertors = 0;

this.isVirtualDirectory = false;

this.isTheme = false;

this.isWindows = Os.platform().substring(0, 3).toLowerCase() === 'win';

this.$events = {};

}

// ======================================================

// PROTOTYPES

// ======================================================

Framework.prototype = {

get cluster() {

return require('./cluster');

},

get id() {

return F.$id;

},

set id(value) {

CLUSTER_CACHE_SET.id = value;

CLUSTER_CACHE_REMOVE.id = value;

CLUSTER_CACHE_REMOVEALL.id = value;

CLUSTER_CACHE_CLEAR.id = value;

F.$id = value;

return F.$id;

},

get onLocate() {

return this.onLocale;

},

set onLocate(value) {

OBSOLETE('F.onLocate', 'Rename "F.onLocate" method for "F.onLocale".');

this.onLocale = value;

}

};

var framework = new Framework();

global.framework = global.F = module.exports = framework;

F.prototypes = function(fn) {

var proto = {};

proto.Chunker = framework_utils.Chunker.prototype;

proto.Controller = Controller.prototype;

proto.Database = framework_nosql.Database.prototype;

proto.DatabaseBinary = framework_nosql.DatabaseBinary.prototype;

proto.DatabaseBuilder = framework_nosql.DatabaseBuilder.prototype;

proto.DatabaseBuilder2 = framework_nosql.DatabaseBuilder2.prototype;

proto.DatabaseCounter = framework_nosql.DatabaseCounter.prototype;

proto.ErrorBuilder = framework_builders.ErrorBuilder.prototype;

proto.HttpFile = framework_internal.HttpFile.prototype;

proto.HttpRequest = PROTOREQ;

proto.HttpResponse = PROTORES;

proto.Image = framework_image.Image.prototype;

proto.Message = Mail.Message.prototype;

proto.Page = framework_builders.Page.prototype;

proto.Pagination = framework_builders.Pagination.prototype;

proto.RESTBuilder = framework_builders.RESTBuilder.prototype;

proto.RESTBuilderResponse = framework_builders.RESTBuilderResponse.prototype;

proto.SchemaBuilder = framework_builders.SchemaBuilder.prototype;

proto.SchemaOptions = framework_builders.SchemaOptions.prototype;

proto.TransformBuilder = framework_builders.TransformBuilder.prototype;

proto.UrlBuilder = framework_builders.UrlBuilder.prototype;

proto.WebSocket = WebSocket.prototype;

proto.WebSocketClient = WebSocketClient.prototype;

fn.call(proto, proto);

return F;

};

F.on = function(name, fn) {

if (name === 'init' || name === 'ready' || name === 'load') {

if (this.isLoaded) {

fn.call(this);

return;

}

} else if (name.indexOf('#') !== -1) {

var arr = name.split('#');

switch (arr[0]) {

case 'middleware':

F.temporary.ready[name] && fn.call(this);

break;

case 'component':

F.temporary.ready[name] && fn.call(this);

break;

case 'model':

F.temporary.ready[name] && fn.call(this, F.models[arr[1]]);

break;

case 'source':

F.temporary.ready[name] && fn.call(this, F.sources[arr[1]]);

break;

case 'package':

case 'module':

F.temporary.ready[name] && fn.call(this, F.modules[arr[1]]);

break;

case 'controller':

F.temporary.ready[name] && fn.call(this, F.controllers[arr[1]]);

break;

}

}

if (F.$events[name])

F.$events[name].push(fn);

else

F.$events[name] = [fn];

return this;

};

F.emit = function(name, a, b, c, d, e, f, g) {

var evt = F.$events[name];

if (evt) {

var clean = false;

for (var i = 0, length = evt.length; i < length; i++) {

if (evt[i].$once)

clean = true;

evt[i].call(F, a, b, c, d, e, f, g);

}

if (clean) {

evt = evt.remove(n => n.$once);

if (evt.length)

F.$events[name] = evt;

else

F.$events[name] = undefined;

}

}

return F;

};

F.once = function(name, fn) {

fn.$once = true;

return F.on(name, fn);

};

F.removeListener = function(name, fn) {

var evt = F.$events[name];

if (evt) {

evt = evt.remove(n => n === fn);

if (evt.length)

F.$events[name] = evt;

else

F.$events[name] = undefined;

}

return F;

};

F.removeAllListeners = function(name) {

if (name)

F.$events[name] = undefined;

else

F.$events = {};

return F;

};

/**

* Internal function

* @return {String} Returns current (dependency type and name) owner.

*/

F.$owner = function() {

return _owner;

};

F.isSuccess = function(obj) {

return obj === SUCCESSHELPER;

};

F.convert = function(value, convertor) {

if (convertor) {

if (F.convertors.findIndex('name', value) !== -1)

return false;

if (convertor === Number)

convertor = U.parseFloat;

else if (convertor === Boolean)

convertor = U.parseBoolean;

else if (typeof(convertor) === 'string') {

switch (convertor.toLowerCase()) {

case 'json':

convertor = U.parseJSON;

break;

case 'float':

case 'number':

case 'double':

convertor = U.parseFloat;

break;

case 'int':

case 'integer':

convertor = U.parseInt2;

break;

default:

return console.log('F.convert unknown convertor type:', convertor);

}

}

F.convertors.push({ name: value, convertor: convertor });

F._length_convertors = F.convertors.length;

return true;

}

for (var i = 0, length = F.convertors.length; i < length; i++) {

if (value[F.convertors[i].name])

value[F.convertors[i].name] = F.convertors[i].convertor(value[F.convertors[i].name]);

}

return value;

};

/**

* Get a controller

* @param {String} name

* @return {Object}

*/

F.controller = function(name) {

return F.controllers[name] || null;

};

/**

* Use configuration