1015 lines
17 KiB
JavaScript
1015 lines
17 KiB
JavaScript
/*
|
|
|
|
Copyright (c) 2020, 2023, The Unified Company.
|
|
|
|
This code is part of Unify.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the ESA Software Community License - Strong Copyleft LICENSE,
|
|
as published by the ESA.
|
|
See the ESA Software Community License - Strong Copyleft LICENSE, for more details.
|
|
|
|
https://unifyjs.org
|
|
|
|
*/
|
|
|
|
|
|
import tableManager from '../server/tableManager.js';
|
|
|
|
import datatype from '../unify/datatype.js';
|
|
|
|
import tools from '../unify/tools.js';
|
|
|
|
import unify from '../unify/unify.js';
|
|
|
|
import collection from '../unify/collection.js';
|
|
|
|
import permissions from '../unify/permissionManager.js';
|
|
|
|
import moduleLoader from './moduleLoader.js';
|
|
|
|
import Console from './console.js';
|
|
|
|
import deepclone from '../unify/clonedeep.js';
|
|
|
|
import consoleColors from '../unify/consoleColors.js';
|
|
|
|
|
|
|
|
export default class core{
|
|
|
|
|
|
__className = "core";
|
|
|
|
tableManager = new tableManager();
|
|
|
|
root = false;
|
|
|
|
client = false;
|
|
|
|
propertyNames = new Array();
|
|
|
|
|
|
|
|
setUserObjects( user, client ) {
|
|
|
|
var root = client.application;
|
|
|
|
var userInstance = new global.user();
|
|
|
|
|
|
this.user = userInstance;
|
|
|
|
this.extendDefaultObject( userInstance );
|
|
|
|
|
|
userInstance.id = user.id;
|
|
|
|
userInstance.get();
|
|
|
|
userInstance.userType = "currentUser";
|
|
|
|
userInstance.parent = false;
|
|
|
|
|
|
this.setUserObjectsChildren( userInstance, client, root );
|
|
|
|
}
|
|
|
|
removeObject( className, id, client ) {
|
|
|
|
if( !this.classObjects ) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if( this.classObjects ) {
|
|
|
|
var clientClassObjects = this.classObjects;
|
|
|
|
} else {
|
|
|
|
var clientClassObjects = client.classObjects;
|
|
|
|
}
|
|
|
|
|
|
|
|
if( className && id ) {
|
|
|
|
var classObjects = this.classObjects[ className ];
|
|
|
|
if( classObjects ) {
|
|
|
|
var object = classObjects[ id ];
|
|
|
|
if( object ) {
|
|
|
|
// todo bug This causes an infinity loop error
|
|
//this.removeChildren( object );
|
|
|
|
delete client.classObjects[ className ][ id ];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
setUserObjectsChildren( user, client, object ) {
|
|
|
|
if( object && object.getChildren ) {
|
|
|
|
var objects = object.getChildren();
|
|
|
|
for ( var i = 0; i < objects.length; i++ ) {
|
|
|
|
if( user ) {
|
|
|
|
objects[i].user = user;
|
|
|
|
} else {
|
|
|
|
objects[i].user = false;
|
|
|
|
}
|
|
|
|
if( objects[i].permission ) {
|
|
|
|
objects[i].permissionManager.permissions = new Array();
|
|
|
|
var clone = tools.structuredClone( objects[i] );
|
|
|
|
objects[i].permission( clone );
|
|
|
|
}
|
|
|
|
this.setUserObjectsChildren( user, client, objects[i] );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
extendDefaultObject( object ) {
|
|
|
|
if( unify.extend( object ) ) {
|
|
|
|
return true;
|
|
|
|
} else {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
prepareObject( object, client ) {
|
|
|
|
object.permissionManager = new permissions();
|
|
|
|
if( this.user && client ) {
|
|
|
|
object.user = client.user;
|
|
|
|
}
|
|
|
|
if( object.permission ) {
|
|
|
|
object.permissionManager.permissions = new Array();
|
|
|
|
var clone = tools.structuredClone(object);
|
|
|
|
object.permission( clone );
|
|
|
|
}
|
|
|
|
if( object.prepare ) {
|
|
|
|
object.prepare();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
addObject( object, client ) {
|
|
|
|
if( client ) {
|
|
|
|
client.objects.push( object );
|
|
|
|
if( !this.getObjectByclassName( object.getClassName(), client ) ) {
|
|
|
|
client.classObjects[ object.getClassName() ] = object;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
parseClient( object, objects ) {
|
|
|
|
objects.push( object );
|
|
|
|
var children = object.getChildren();
|
|
|
|
for( var c = 0; c<children.length; c++ ) {
|
|
|
|
var child = children[c];
|
|
|
|
var className = child.getClassName();
|
|
|
|
this.parseClientChild( child, objects );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
parseClientChild( child, objects ) {
|
|
|
|
var className = child.getClassName();
|
|
|
|
switch( className ) {
|
|
|
|
case "renderCollection":
|
|
|
|
//this.parseClient( child.object, objects );
|
|
|
|
break;
|
|
|
|
case "collection":
|
|
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
this.parseClient( child, objects );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
isClass( obj ) {
|
|
|
|
if(!obj) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if( Array.isArray( obj ) ) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
const isCtorClass = obj.constructor
|
|
&& obj.constructor.toString().substring(0, 5) === 'class'
|
|
if(obj.prototype === undefined) {
|
|
return isCtorClass
|
|
}
|
|
const isPrototypeCtorClass = obj.prototype.constructor
|
|
&& obj.prototype.constructor.toString
|
|
&& obj.prototype.constructor.toString().substring(0, 5) === 'class'
|
|
return isCtorClass || isPrototypeCtorClass
|
|
|
|
}
|
|
|
|
getTables( object, tableStorage ) {
|
|
|
|
var className = tools.getClassName( object );
|
|
|
|
if( object.type == "table" ) {
|
|
|
|
tableStorage[className] = tools.getTableFromObject( object );
|
|
|
|
}
|
|
|
|
var children = tools.getChildren( object );
|
|
|
|
for( var c = 0; c<children.length; c++ ) {
|
|
|
|
var child = children[c];
|
|
|
|
this.getTables( child, tableStorage );
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
removeCollectionObject( object, parentClassName, collectionStorage ) {
|
|
|
|
var children = tools.getChildren( object );
|
|
|
|
var className = tools.getClassName( object );
|
|
|
|
if( object.permission ){
|
|
|
|
console.log("this object has a method called permission", className)
|
|
|
|
}
|
|
|
|
switch( object.type ) {
|
|
|
|
case "renderCollection":
|
|
|
|
if( object.collections ){
|
|
|
|
//console.log("renderCollection - remove object from collection ", object);
|
|
|
|
collectionStorage[className] = object.object;
|
|
|
|
object.object = false;
|
|
|
|
if( object.collections[0]) {
|
|
|
|
object.collections[0].object = false;
|
|
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
case "collection":
|
|
|
|
//console.log("parsing collection ", parentClassName);
|
|
|
|
collectionStorage[parentClassName] = object.object;
|
|
|
|
object.object = false;
|
|
|
|
|
|
break;
|
|
}
|
|
|
|
for( var c = 0; c<children.length; c++ ) {
|
|
|
|
var child = children[c];
|
|
|
|
this.removeCollectionObject( child, className, collectionStorage );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
prepareClone( object, removedMethods ) {
|
|
|
|
var nodeMethodsString = object.__nodeMethods;
|
|
|
|
var className = tools.getClassName( object );
|
|
|
|
if(!removedMethods[className]) {
|
|
|
|
removedMethods[className] = new Array();
|
|
|
|
}
|
|
|
|
|
|
if( nodeMethodsString ) {
|
|
|
|
var nodeMethods = nodeMethodsString.split(",");
|
|
|
|
|
|
|
|
for (var i = 0; i < nodeMethods.length; i++) {
|
|
|
|
var nodeMethodName = nodeMethods[i]
|
|
|
|
removedMethods[className][nodeMethodName] = object[nodeMethodName];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//console.log("className", tools.getClassName( object ), object.type)
|
|
|
|
var properties = Object.getOwnPropertyNames( object );
|
|
|
|
var propertiesFiltered = properties.filter( prop => prop !== "constructor" );
|
|
|
|
for ( const prop of propertiesFiltered ) {
|
|
|
|
try{
|
|
|
|
structuredClone( object[prop] )
|
|
|
|
} catch{
|
|
|
|
if( !this.isClass( object[prop] ) ) {
|
|
|
|
removedMethods[className][prop] = object[prop];
|
|
|
|
delete object[prop];
|
|
|
|
//console.log("---------", prop);
|
|
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
var methods = tools.getAllFuncs( object );
|
|
|
|
var skip = new Array("hasOwnProperty", "isPrototypeOf", "__defineGetter__", "__defineSetter__", "__lookupGetter__", "__lookupSetter__", "length")
|
|
|
|
for (var i = 0; i < methods.length; i++) {
|
|
|
|
var method = methods[i]
|
|
|
|
if( skip.includes( method ) ){
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
try{
|
|
|
|
structuredClone( object[method] )
|
|
|
|
} catch{
|
|
|
|
if( !this.isClass( object[method] ) ) {
|
|
|
|
//console.log("??????", method);
|
|
|
|
removedMethods[className][method] = object[method];
|
|
|
|
delete object[method];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
var extendedInstance = new object.constructor();
|
|
|
|
var prototype = Object.getPrototypeOf( extendedInstance );
|
|
|
|
var propertyNames = Object.getOwnPropertyNames( prototype );
|
|
|
|
|
|
propertyNames.forEach( methodName => {
|
|
|
|
if( !this.isClass( object[methodName] ) ) {
|
|
|
|
//console.log("---------", methodName);
|
|
|
|
removedMethods[className][methodName] = object[methodName];
|
|
delete object[methodName];
|
|
|
|
}
|
|
|
|
|
|
});
|
|
|
|
|
|
var properties = tools.getProperties( object );
|
|
|
|
for (var i = 0; i < properties.length; i++) {
|
|
|
|
var property = properties[i];
|
|
|
|
if( tools.isCSSProperty( property.name ) ) {
|
|
|
|
|
|
|
|
delete object[property.name];
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
if( object.type == "table" ) {
|
|
|
|
//console.log("get table", tools.getTableFromObject( object ));
|
|
|
|
var table = tools.getTableFromObject( object );
|
|
|
|
|
|
if( table ) {
|
|
|
|
object.tableName = tools.getClassName( table );
|
|
}
|
|
//object.tableName = tools.getClassName( );
|
|
|
|
}
|
|
|
|
|
|
if( object.type == "collectionQuery") {
|
|
|
|
//console.log("collectionQuery", className);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
var children = tools.getChildren( object );
|
|
|
|
|
|
|
|
for( var c = 0; c<children.length; c++ ) {
|
|
|
|
var child = children[c];
|
|
|
|
if( child.queryChildren ) {
|
|
|
|
//console.log("prepareClone queryChildren");
|
|
|
|
this.prepareClone( child.queryChildren, removedMethods );
|
|
|
|
this.prepareClone( child.queryRoot, removedMethods );
|
|
|
|
}
|
|
|
|
this.prepareClone( child, removedMethods );
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
fastParse( object, client, parent ){
|
|
|
|
var className = tools.getClassName( object );
|
|
|
|
client.objects.push( object );
|
|
|
|
if( !this.getObjectByclassName( className, client ) ) {
|
|
|
|
client.classObjects[ className ] = object;
|
|
|
|
}
|
|
|
|
object.permissionManager = new permissions();
|
|
|
|
if( object.type == "renderCollection" ) {
|
|
|
|
if( object.collections && object.collections[0] ) {
|
|
|
|
var collection = object.collections[0];
|
|
|
|
// collection.parent = object;
|
|
|
|
// collection.parentName = tools.getClassName(object)
|
|
|
|
this.fastParse( collection, client );
|
|
|
|
this.fastParse( collection.queryChildren, client );
|
|
|
|
this.fastParse( collection.queryRoot, client );
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
if( object.type == "collection" ) {
|
|
|
|
//object.parent = parent;
|
|
|
|
this.fastParse( object.queryChildren, client );
|
|
|
|
this.fastParse( object.queryRoot, client );
|
|
|
|
}
|
|
|
|
|
|
|
|
if( object.type == "collectionQuery" ) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
var children = tools.getChildren( object );
|
|
|
|
for( var c = 0; c < children.length; c++ ) {
|
|
|
|
var child = children[c];
|
|
|
|
child.parent = object;
|
|
|
|
this.fastParse( child, client, object );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
collectObjects( object, client ) {
|
|
|
|
client.objects.push( object );
|
|
|
|
var className = tools.getClassName( object );
|
|
|
|
if( !this.getObjectByclassName( className, client ) ) {
|
|
|
|
client.classObjects[ className ] = object;
|
|
|
|
}
|
|
|
|
if( object.type == "renderCollection" ) {
|
|
|
|
if( object.collections && object.collections[0] ) {
|
|
|
|
var collection = object.collections[0];
|
|
|
|
//collection.parent = object;
|
|
|
|
this.collectObjects( collection, client );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
var children = tools.getChildren( object );
|
|
|
|
for( var c = 0; c < children.length; c++ ) {
|
|
|
|
var child = children[c];
|
|
|
|
child.parent = object;
|
|
|
|
this.collectObjects( child, client );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
fastParse( object, client, ultra = false ){
|
|
|
|
//if( !this.extendDefaultObject( object ) ) {
|
|
|
|
// return false;
|
|
|
|
//}
|
|
|
|
if( !this.root ) {
|
|
|
|
this.root = object;
|
|
|
|
}
|
|
|
|
|
|
//this.prepareObject( object, client );
|
|
|
|
|
|
client.objects.push( object );
|
|
|
|
if( !this.getObjectByclassName( tools.getClassName(object), client ) ) {
|
|
|
|
client.classObjects[ tools.getClassName(object) ] = object;
|
|
|
|
}
|
|
|
|
if( object.type == "renderCollection" ) {
|
|
|
|
if( object.collections && object.collections[0] ) {
|
|
|
|
var collection = object.collections[0];
|
|
|
|
//collection.parent = object;
|
|
|
|
this.fastParse( collection, client );
|
|
|
|
|
|
// this should only be enabled on ultra fast parse
|
|
// but commented on fast parse.
|
|
|
|
if( ultra ) {
|
|
|
|
this.fastParse( collection.queryChildren, client );
|
|
|
|
this.fastParse( collection.queryRoot, client );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
this.prepareObject( object, client );
|
|
|
|
|
|
if( object.type == "collectionQuery" ) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
var children = tools.getChildren( object );
|
|
|
|
for( var c = 0; c < children.length; c++ ) {
|
|
|
|
var child = children[c];
|
|
|
|
child.parent = object;
|
|
|
|
|
|
|
|
this.fastParse( child, client, ultra );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
parse( object, client ) {
|
|
|
|
this.parseServer( object, client );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
parseServer( object, client ){
|
|
|
|
if( !this.extendDefaultObject( object ) ) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if( typeof object == "boolean" ) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if( !this.root ) {
|
|
|
|
this.root = object;
|
|
|
|
}
|
|
|
|
this.tableManager.parse( object );
|
|
|
|
this.prepareObject( object, client );
|
|
|
|
this.addObject( object, client );
|
|
|
|
if( object.parent ) {
|
|
|
|
this.prepareCollection( object.parent, object );
|
|
|
|
}
|
|
|
|
var children = object.getChildren();
|
|
|
|
for( var c = 0; c < children.length; c++ ) {
|
|
|
|
var child = children[c];
|
|
|
|
this.parseChild( child, client );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
findDuplicates( object ) {
|
|
|
|
this.extendDefaultObject( object );
|
|
|
|
for (var i = 0; i < this.propertyNames.length; i++) {
|
|
|
|
var propertyName = this.propertyNames[i];
|
|
|
|
if( propertyName == object.propertyName ) {
|
|
|
|
//tools.logError("Object dublicate not allowed: " + object.getClassName() );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
this.propertyNames.push( object.getClassName() );
|
|
|
|
if( object.getChildren ) {
|
|
|
|
var children = object.getChildren();
|
|
|
|
for(var c = 0; c<children.length; c++) {
|
|
|
|
var child = children[c];
|
|
|
|
this.findDuplicates( child );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
parseRenderCollection( child, client ) {
|
|
|
|
if( child.object ) {
|
|
|
|
var object = child.object;
|
|
|
|
var instance = new object();
|
|
|
|
this.parseServer( instance, client );
|
|
|
|
}
|
|
|
|
this.parseServer( child, client );
|
|
|
|
}
|
|
|
|
parseCollection( child, client, propertyName ) {
|
|
|
|
this.parseServer( child, client );
|
|
|
|
if( propertyName != "collection" ) {
|
|
|
|
this.parseInstance( child, client );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
parseChild( child, client, parseRenderCollection ) {
|
|
|
|
var propertyName = child.propertyName;
|
|
|
|
unify.extend( child );
|
|
|
|
var className = tools.getClassName( child );
|
|
|
|
switch( child.type ) {
|
|
|
|
case "renderCollection":
|
|
|
|
this.parseRenderCollection( child, client );
|
|
|
|
break;
|
|
|
|
case "collection":
|
|
|
|
this.parseCollection( child, client, propertyName );
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
this.parseServer( child, client );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
parseInstance( object, client ){
|
|
|
|
var instance = object.createInstance();
|
|
|
|
var className = tools.getClassName( instance );
|
|
|
|
if( !this.getObjectByclassName( className, client ) ) {
|
|
|
|
this.parseServer( instance, client );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
mapExtendedDependencies( currentClass, extendObjects, client ) {
|
|
|
|
for ( var i = 0; i < extendObjects.length; i++ ) {
|
|
|
|
var extendName = extendObjects[i];
|
|
|
|
if( !client.dependencieMap[ extendName ] ) {
|
|
|
|
client.dependencieMap[ extendName ] = new Array();
|
|
|
|
}
|
|
|
|
//console.log(currentClass.getClassName(), "to", extendName );
|
|
|
|
client.dependencieMap[ extendName ].push( currentClass );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
createDependencyMap( client ) {
|
|
|
|
var classObjects = client.objects;
|
|
|
|
client.dependencieMap = new Array();
|
|
|
|
for (var i = 0; i < classObjects.length; i++) {
|
|
|
|
var currentClass = classObjects[i];
|
|
|
|
var extendObjects = currentClass.getExtends();
|
|
|
|
extendObjects = tools.removeDuplicates( extendObjects );
|
|
|
|
this.mapExtendedDependencies( currentClass, extendObjects, client );
|
|
|
|
}
|
|
|
|
//console.log("map for input", client.dependencieMap["input"].length);
|
|
|
|
}
|
|
|
|
getObjectByclassName( className, client ) {
|
|
|
|
if( !client ) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
var objects = client.classObjects[ tools.validateString( className ) ];
|
|
|
|
if( objects ) {
|
|
|
|
return objects;
|
|
|
|
} else {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
prepareCollection( object, property ) {
|
|
|
|
if( object.table ) {
|
|
|
|
this.prepareStorageCollection( object, property );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
prepareStorageCollection( parentObject, object ) {
|
|
|
|
var tableObject = parentObject.table;
|
|
|
|
var tableProperty = tableObject[ object.propertyName ];
|
|
|
|
if( tableProperty ) {
|
|
|
|
if( tableProperty.object ) {
|
|
|
|
var tableName = tools.getClassName( new tableProperty.object() );
|
|
|
|
var parentName = tools.getClassName( tableObject );
|
|
|
|
if( object.storageCollection ) {
|
|
|
|
object.storageCollection.propertyName = object.propertyName;
|
|
|
|
object.storageCollection.tableName = tableName;
|
|
|
|
object.storageCollection.parentName = parentName;
|
|
|
|
object.storageCollection.enabled = true;
|
|
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
getObjectByclassNameClone( className ) {
|
|
|
|
return deepclone( this.getObjectByclassName( className ) );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|