ActiveEntityBaseClass

component accessors=true extends="coldbox_3_5.system.orm.hibernate.ActiveEntity"{

    // dependency properties

    property name="utilities" inject="coldbox:plugin:utilities" persistent=false;

    property name="ORMService" inject="entityService" persistent=false;

    // constructor

    public any function init(){
        super.init(argumentcollection=arguments);

        return this;
    }

    // override functions

    public any function save(){
        super.save(argumentCollection=arguments);

        return this;
    }

    public boolean function exists(){
        var metaData = getMetaData(this);

        var ID = evaluate("get#this.getKey()#()");

        if(isNull(ID)){
            return false;
        }

        return super.exists(ID);
    }

    // public functions

    public void function deleteCollection(required string entityCollectionName,boolean soft=true){
        var collection = evaluate("get#arguments.entityCollectionName#()");

        for(var x=1;x<=arrayLen(collection);x++){
            collection[x].delete(soft=arguments.soft);
        }
    }

    public void function removeCollection(required string entityCollectionName){
        var collection = evaluate("get#arguments.entityCollectionName#()");

        var metadata = "";

        var entity = "";

        for(var x=1;x<=arrayLen(collection);x++){
            entity = collection[x];

            metadata = getMetaData(entity);

            evaluate("remove#listLast(metadata.name,".")#(entity)");
        }
    }

    public any function getPropertyMemento(string type="struct",boolean recursive=true){
        var result = getEntityMememto(entity=this,recursive=arguments.recursive);

        if(arguments.type == "struct"){
            return result;
        }else{
            return getUtilities().marshallData(type=arguments.type,data=result);
        }
    }

    public any function getPropertyLength(required string propertyName){
        var metaData = getMetaData(this);

        var propertyLength = "";

        for(var x=1; x<=arrayLen(metaData.properties); x++){
            if(metaData.properties[x].name == arguments.propertyName && structKeyExists(metaData.properties[x],"SQLType")){
                propertyLength = REReplace(metaData.properties[x].SQLType,"\D+","","ALL");

                if(len(propertyLength)){
                    return propertyLength;
                }
            }
        }

        return "";
    }

    public any function null(){
        return getUtilities().null();
    }

    // private functions

    private any function getEntityMememto(required any entity,any Parent,boolean recursive=true){
        var objectMetaData = "";

        var entityName = "";

        var metaData = getMetaData(arguments.entity);

        var propertyName = "";

        var propertyValue = "";

        var entityID = "";

        var result = structNew();

        if(structKeyExists(metaData,"entityName")){
            result.entityName = metaData.entityName;
        }

        if(structKeyExists(metaData,"properties")){
            for(var x=1;x<=arrayLen(metaData.properties);x++){
                propertyName = uCase(metaData.properties[x].name);

                propertyValue = evaluate("arguments.entity.get#propertyName#()");

                if(!isNull(propertyValue)){
                    if(!isObject(propertyValue)){
                        if(isArray(propertyValue)){
                            result[propertyName] = getArrayMemento(propertyValue);
                        }else{
                            result[propertyName] = propertyValue;
                        }
                    }else if(isObject(propertyValue) && arguments.recursive){
                        objectMetaData = getMetaData(propertyValue);

                        if(structKeyExists(objectMetaData,"entityName")){
                            entityIDName = uCase(getORMService().getKey(objectMetaData.entityName));

                            result[propertyName & entityIDName] = evaluate("propertyValue.get#entityIDName#()");

                            if(!isNull(arguments.parent) && structKeyExists(arguments.parent,"entityName") && arguments.parent["entityName"] == objectMetaData.entityName){
                                result[propertyName] = "[parent]";
                            }else{
                                result[propertyName] = getEntityMememto(entity=propertyValue,parent=result);
                            }
                        }
                    }
                }else{
                    result[propertyName] = "";
                }
            }
        }

        if(structKeyExists(arguments.entity,"flatten")){
            structAppend(result,arguments.entity.flatten(),true);
        }

        return result;
    }

    private array function getArrayMemento(required array values){
        var result = arrayNew(1);

        for(var x=1;x<=arrayLen(arguments.values);x++){
            if(!isObject(arguments.values[x])){
                arrayAppend(result,arguments.values[x]);
            }else{
                arrayAppend(result,getEntityMememto(entity=arguments.values[x],recursive=false));
            }
        }

        return result;
    }
}