First commit

2025-12-25 11:16:59 +01:00
commit 0c5ca09a63
720 changed files with 329234 additions and 0 deletions
--- a/framework/unify/serializer.object.js
+++ b/framework/unify/serializer.object.js
@@ -0,0 +1,580 @@
+/*
+
+	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 tools				from './tools.js';
+
+import unify				from './unify.js';
+
+import defaultObject		from './defaultObject.js';
+
+import datatype 			from '../unify/datatype.js';
+
+import placeholder 			from '../unify/placeholder.js';
+
+import serialized 			from '../unify/serialized.js';
+
+import permissionObject 	from '../unify/permissionObject.js';
+
+import consoleColors		from './consoleColors.js';
+
+class objectSerializer{
+
+
+	serialize( sourceObject, targetObject, client, secure = false ) {
+
+		console.log("\n");
+
+		console.log( consoleColors.yellow("Serialize Object" ), consoleColors.yellow( targetObject.getClassName() ) );
+
+		var serializedObject = this.serializeObject( sourceObject, targetObject, client, secure );
+
+		this.findColumns( targetObject );
+
+		var defaultObjectInstance = new defaultObject();
+
+		console.log("\n");
+		
+		return defaultObjectInstance.agregateDefaultObject( serializedObject );
+
+	} 
+
+	serializeObject( sourceObject, targetObject, client, depth = 0, secure ) {
+
+		if( !sourceObject ) {
+
+			return false;
+
+		}
+	
+		unify.extend( targetObject );
+
+		if( tools.getEnvironment() == "Browser" ) {
+
+			this.serializeID( sourceObject, targetObject ); // save
+
+		}
+
+		this.serializeProperties( sourceObject, targetObject, secure ); // save
+
+		this.serializeChildren( sourceObject, targetObject, depth, secure ); // save
+
+		this.serializePermissionObjects( sourceObject, targetObject ); // save
+
+		return targetObject;
+
+	}
+	
+	serializeChildren( clientObject, targetObject, depth, secure ) {
+	
+		if( !targetObject.getChildren ){
+
+			console.error( "This object cannot be serialized", targetObject );
+
+			return false;
+
+		}
+
+		var children = targetObject.getChildren();
+
+		for( var c = 0; c < children.length; c++ ) {
+		
+			var child 					= children[c];
+
+			if( tools.getEnvironment() == "Node" ) {
+
+				if( child.type == "collection" || child.type == "table" || child.type == "renderCollection" ) {
+
+					continue;
+
+				}
+
+				if( child.propertyName == "groups" ) {
+
+					continue;
+
+				}
+
+			}
+
+			this.serializeChild( child, clientObject, targetObject, depth, secure );
+
+		}
+
+	}
+
+
+
+	serializeChild( child, clientObject, targetObject, depth, secure ) {
+
+		var propertyName			= tools.validateString( child.propertyName ); // target class is save
+		
+		var clientObjectChild 		= clientObject[ propertyName ];
+
+		console.log("	".repeat( depth ), consoleColors.yellow(" - set value of" ), consoleColors.yellow( propertyName ) );
+
+
+		// bug fixen needs todo path
+		if( clientObjectChild ) {
+
+			targetObject[ propertyName ] 	= this.serializeObject( clientObjectChild, child, depth++, secure );
+			
+		}
+			
+
+	}
+
+	serializePermission( sourceObject, targetObject ) {
+
+		var targetObject = new permissionObject();
+
+		if( !sourceObject ) {
+
+			return false;
+
+		}
+
+		if( typeof sourceObject.WRITE == "boolean" ) {
+
+			targetObject.WRITE				= tools.validateBoolean( sourceObject.WRITE );
+
+		}
+		
+		if( typeof sourceObject.DELETE == "boolean" ) {
+
+			targetObject.DELETE				= tools.validateBoolean( sourceObject.DELETE );
+
+		}
+		
+		if( typeof sourceObject.READ == "boolean" ) {
+
+			targetObject.READ				= tools.validateBoolean( sourceObject.READ );
+
+		}
+
+		return targetObject;
+
+	}
+
+	createPermissionObject( currentPermissionObject ) {
+
+		var permissionObject 			= new serialized();
+
+		permissionObject.path 			= tools.validateString( currentPermissionObject.path );
+
+		permissionObject.permission 	= this.validatePermission( currentPermissionObject.permission );
+
+	}
+
+	serializePermissionObject( currentPermissionObject, targetObject, c ) {
+
+		var permissionObject				= this.createPermissionObject( currentPermissionObject );
+
+		targetObject.permissionObjects[ c ]	= permissionObject;
+
+	}
+
+	serializePermissionObjects( sourceObject, targetObject ) {
+
+		if( !sourceObject.permissionObjects ) {
+
+			return false
+
+		}
+
+		if( !tools.isArray( sourceObject.permissionObjects ) ) {
+
+			return false
+
+		} 
+
+		var permissionObjects 			= sourceObject.permissionObjects;
+		
+		targetObject.permissionObjects 	= new Array();
+		
+		for( var c = 0; c < permissionObjects.length;c++) {
+		
+			var currentPermissionObject = permissionObjects[c];
+			
+			this.serializePermissionObject( currentPermissionObject, targetObject, c );
+
+		}
+
+	}
+
+	serializeFilterObject( sourceObject, targetObject ) {
+
+		if( sourceObject.filterObject ) {
+
+			targetObject.filterObject = new serialized();
+
+			this.serializeObject( sourceObject.filterObject, targetObject.filterObject );
+
+		}
+
+	}
+
+	serializeIDNumber( sourceObject, targetObject ) {
+
+		var id = tools.validateNumber( sourceObject.id );
+
+		targetObject.id = id;
+		
+		targetObject.setID( id );
+
+	}
+
+	serializeUndefinedID( targetObject ) {
+
+		if( tools.getEnvironment() == "Node" ) {
+
+			targetObject.id = false;
+
+			targetObject.setID( false );
+
+		}
+
+	}
+
+	serializeJoinID( sourceObject, targetObject ) {
+
+		var join_id = tools.validateNumber( sourceObject.join_id );
+
+		targetObject.join_id = join_id;
+
+		targetObject.setJoinID( id );
+		
+	}
+
+	serializeID( sourceObject, targetObject ) {
+
+		if( sourceObject && sourceObject.id ) {
+
+			this.serializeIDNumber( sourceObject, targetObject );
+
+		} else {
+
+			this.serializeUndefinedID( targetObject );
+
+		}
+
+		if( sourceObject.join_id ) {
+		
+			this.serializeJoinID( sourceObject, targetObject );
+
+		} 
+
+	}
+
+	serializeNumberValue( sourceObject, targetObject ) {
+
+		targetObject.value 	= sourceObject.value;
+
+	}
+
+	serializeBooleanValue( sourceObject, targetObject ) {
+
+		if( !sourceObject.value ) {
+
+			targetObject.value = false;
+
+		} else {
+
+			targetObject.value = true;
+
+		} 
+
+	}
+
+	serializeEmptyValue( targetObject ) {
+
+		targetObject.value 		= "";
+
+
+	}
+
+	serializeStringValue( sourceObject, targetObject ) {
+
+		targetObject.value 	= tools.validateValue( sourceObject.value );
+
+	}
+
+	serializeFalse( targetObject ) {
+	
+		if( typeof targetObject.value ) {
+
+			targetObject.value = false;
+
+		}
+
+	}
+
+	serializeValue( sourceObject, targetObject ) {
+
+		if( typeof sourceObject.value == "number" ) {
+
+			this.serializeNumberValue( sourceObject, targetObject );
+
+		} else if( sourceObject.datatype == "BOOLEAN" ) {
+
+			this.serializeBooleanValue( sourceObject, targetObject );
+
+		} else if( sourceObject.value == "" ) {
+
+			this.serializeEmptyValue( targetObject );
+
+		} else if( typeof sourceObject.value && sourceObject.value != "undefined" ) {
+
+			this.serializeStringValue( sourceObject, targetObject );
+
+		} else {
+
+			this.serializeFalse( targetObject );
+		
+		}
+
+		return targetObject;
+
+	}
+
+	serializeProperties( sourceObject, targetObject, method, type, secure ) {
+
+
+		this.serializeValue( sourceObject, targetObject );
+
+		if( !secure ) {
+
+			if( sourceObject.permissions ) {
+
+				targetObject.permissions			= this.validatePermission( sourceObject.permissions );
+			
+			}
+/*
+			if( !method || method == "callNodeMethod" ) {
+
+				if( sourceObject.nodeMethodName ) {
+				
+					targetObject.nodeMethodName 		= tools.validateValue( sourceObject.nodeMethodName );
+
+				} 
+				
+				if( sourceObject.nodeMethodArguments ) {
+				
+					targetObject.nodeMethodArguments 	= tools.validateValue( sourceObject.nodeMethodArguments );
+
+				}
+
+			}
+*/
+		}
+
+
+		//if( sourceObject.rowID ) {
+		
+		//	targetObject.rowID					= tools.validateNumber( sourceObject.rowID );
+		
+		//}	
+/*
+		if( typeof sourceObject.count ) {
+		
+			targetObject.count					= tools.validateNumber( sourceObject.count );
+
+		}
+
+			
+*/
+	/*
+		if( typeof sourceObject.WRITE == "boolean" ) {
+
+			targetObject.WRITE					= tools.validateBoolean( sourceObject.WRITE );
+
+		}
+		
+		if( typeof sourceObject.DELETE == "boolean" ) {
+
+			targetObject.DELETE					= tools.validateBoolean( sourceObject.DELETE );
+
+		}
+		
+		if( typeof sourceObject.READ == "boolean" ) {
+
+			targetObject.READ					= tools.validateBoolean( sourceObject.READ );
+
+		}
+*/
+		// bug. if enabled permissions dont work.
+
+		//if( tools.getEnvironment() == "Node" ) {
+
+
+		//}
+	
+
+
+		//}
+
+		return targetObject;
+
+	}
+
+	validatePermission( sourcePermission ) {
+
+		var targetPermission			= new permissionObject();
+
+		if( !sourcePermission ) {
+
+			return targetPermission;
+
+		}
+
+		if( typeof sourcePermission.READ == "boolean" ) {
+		
+			targetPermission.READ		= tools.validateBoolean( sourcePermission.READ );
+		
+		}
+
+		targetPermission.WRITE		= sourcePermission.WRITE;
+		
+		if( typeof sourcePermission.WRITE  == "boolean" ) {
+		
+			targetPermission.WRITE		= tools.validateBoolean( sourcePermission.WRITE );
+		
+		}
+		
+		if( typeof sourcePermission.DELETE == "boolean" ) {
+		
+			targetPermission.DELETE		= tools.validateBoolean( sourcePermission.DELETE );
+		
+		}
+		
+		return targetPermission;
+	
+	}
+
+	// Everything above needs to be save.
+
+
+
+
+
+
+	copyValueToChild( child, extendedClass, column, table ) {
+
+		var columnName = tools.getClassName( extendedClass );
+
+		if( !extendedClass.datatype ) {
+
+			return false;
+
+		}
+
+		if( !column ) {
+
+			return false;
+
+		}
+
+		if( !table[ columnName ] ) {
+
+			return false;
+		}
+
+		child.value = table[ columnName ].value;
+
+		if( tools.getEnvironment() == "Browser" && child.updateElementContent ) {
+			
+			child.updateElementContent()
+		
+		}
+
+	}
+
+	findExtendedClasses( child, parent, table ) {
+
+		if( child.type == "collection"  ) {
+
+			return false;
+
+		} 
+
+		if( child.type == "renderCollection"  ) {
+
+			return false;
+
+		} 
+
+		if( !child.datatype ) {
+
+			return false;
+
+		}
+
+
+
+		var extendedClasses = tools.getExtendedClassesMulti( child );
+
+		for ( var c = 0; c < extendedClasses.length; c++)  {
+
+			var extendedClass 	= extendedClasses[ c ];
+
+			var column 			= tools.isUnifyColumn( extendedClass ) ;
+
+			this.copyValueToChild( child, extendedClass, column, table );
+
+		}
+
+		//console.log("This is an floating column", child, extendedClasses );
+
+	}
+
+	findColumns( parent, table = false ) {
+
+		if( !parent.getChildren ) {
+
+			return false;
+
+		}
+
+		unify.extend( parent );
+
+		var children = parent.getChildren();
+
+		for ( var i = 0; i < children.length; i++ ) {
+
+			var child = children[i];
+
+
+			if( parent.type == "table" ) {
+
+				table = parent;
+
+			}
+
+			this.findExtendedClasses( child, parent, table );
+
+
+			//if( child.type != "collection" && child.type != "renderCollection" ) {
+
+				this.findColumns( child, table );
+
+			//}
+			
+		}
+
+	}
+
+
+}
+
+export default new objectSerializer();