@azrico/webobject 1.5.58 → 1.5.61

package/dist/src/structs/SimpleObject.js

@@ -0,0 +1,1138 @@
+import { array_intersection, array_isEmpty, array_merge, fn_eval, fn_eval_this, object_clone, object_equals, object_get, object_getStatic, object_isClass, object_isEmpty, object_isTrue, object_removeKeys, object_set, wrap_array, } from "@azrico/object";
+import { combine_if_not_blank, string_isEmpty, string_to_color, } from "@azrico/string";
+import { gcache, gfunc } from "@azrico/global";
+import { MapableObject } from "./MapableObject";
+import ObjectManager from "./ObjectManager";
+import EventManager from "@azrico/event";
+export class SimpleObject extends MapableObject {
+    static __db_name = "";
+    static __object_name = "";
+    //these properties should not be changed and are usually set by server
+    static __unchangeables = [];
+    //these properties can be directly changed and are included in deltaObject
+    static __changeables = [];
+    //these properties usually are not directly changed and sometimes are included in deltaObject
+    static __extraProperties = [];
+    //these properties are never sent to database but may be sent to client
+    static __tempProperties = [];
+    //these properties can only be changed by the _creator
+    static __protectedProperties = [];
+    //these properties will be evaluated when needed
+    static __functionProperties = [];
+    //apply these string formats
+    static __formatList;
+    //types for children can be used when importing children
+    static __childTypes;
+    //these fields are used when importing
+    static __importColumns;
+    //these fields can be used when importing and checking if an item exists
+    static __checkProperties = [];
+    static __use_delta = true;
+    _static() {
+        return this.constructor;
+    }
+    //an exact copy of this object is stored here
+    __originalobject;
+    //changes are saved here
+    __delta = {};
+    //// protected __has_delta: boolean = false;
+    //the last thing that was changed on this object
+    __lastChanged;
+    //is the object read only
+    __is_readonly;
+    //should we throw errors when encountering an error?
+    //is TRUE by default
+    __throw_errors;
+    //is this object marked as deleted?
+    _deleted;
+    _archived;
+    _deletedBy;
+    //is this object locked?
+    _locked;
+    //errors
+    __errors;
+    __showErrors;
+    //refresh func
+    __refresh_functions;
+    //save results
+    __saveResultObject;
+    __saveResultIsSuccess = true;
+    __saveResultType;
+    //init function
+    __initialized;
+    #objectColor;
+    //id in the database
+    _id = "";
+    //sequence key (usually managed by the database)
+    _index_key = "";
+    //sequence value , used to index the object with increasing numbers
+    _index_value = -1;
+    constructor(is_readonly = false) {
+        super();
+        this.__is_readonly = is_readonly;
+        if (this._id)
+            this.__table_id = this._id;
+        this.clear_changes();
+    }
+    init(...p) {
+        this.__initialized = true;
+    }
+    get(key, original = false) {
+        //check if we should treat the prop as a function
+        const is_fnc = this.constructor["__functionProperties"] != null &&
+            this.constructor["__functionProperties"].includes(key);
+        //check if we should use delta version or normal version for this property
+        let used_value;
+        if (typeof key === "string" && key.includes(".")) {
+            /* ----------------------------- using sub value ---------------------------- */
+            const keysp = key.split(".");
+            const key_part = keysp.shift();
+            const subkey_part = keysp.shift();
+            used_value = this.#getSubProperty(key_part, subkey_part);
+        }
+        else {
+            /* --------------------------- using this or delta -------------------------- */
+            const self_key = key;
+            const use_orig = original || !this.__use_delta || !(self_key in this.__delta);
+            used_value = (use_orig ? this[self_key] : this.__delta[self_key]);
+        }
+        return is_fnc ? fn_eval_this(this, used_value) : used_value;
+    }
+    /**
+     * static get method for SimpleObject
+     * @param obj
+     * @param key
+     * @param original
+     * @returns
+     */
+    static get(obj, key, original = false) {
+        if (obj == null)
+            return undefined;
+        if (obj instanceof SimpleObject && typeof obj.get === "function")
+            return obj.get(key, original);
+        /* ------------------------------- manual get ------------------------------- */
+        if (!original &&
+            obj.__use_delta != false &&
+            typeof obj.__delta === "object" &&
+            key in obj.__delta) {
+            //@ts-ignore
+            return obj.__delta[key];
+        }
+        return obj[key];
+    }
+    useProperty(key) {
+        if (this.manager == null) {
+            console.warn("Objects with no manager should not use useProperty");
+            return this.get(key);
+        }
+        return EventManager.useProperty(this.manager, key);
+    }
+    #getSubProperty(key, subkey, original = false) {
+        let subobj = this.get(key, original);
+        if (subobj == null || typeof subobj !== "object")
+            return undefined;
+        return subobj[subkey];
+    }
+    getSubValue = this.#getSubProperty;
+    /* -------------------------------------------------------------------------- */
+    /*                                  set                                  	  */
+    /* -------------------------------------------------------------------------- */
+    /**
+     * set value of a key only if the value is empty (null,undef,"")
+     * @param key
+     * @param value
+     * @returns
+     */
+    setDefaultValue(key, value) {
+        //@ts-ignore
+        if (this[key] == undefined || this[key] === "" || this[key] === 0) {
+            this[key] = value;
+            return true;
+        }
+        return false;
+    }
+    setDefault = this.setDefaultValue;
+    setDefaultPropertyNow(key) {
+        //@ts-ignore
+        if (this[key] == undefined || this[key] === "" || this[key] === 0) {
+            this[key] = new Date();
+            return true;
+        }
+        return false;
+    }
+    #setSubProperty(key, subkey, value) {
+        let subobj = this.get(key);
+        //@ts-ignore
+        if (subobj == null || typeof subobj !== "object")
+            subobj = {};
+        else
+            subobj = { ...subobj }; //make a clone so we dont update the original
+        subobj[subkey] = value;
+        this.#setProperty(key, subobj);
+    }
+    /**
+     * update a property on this object by updating the `__delta`
+     * or update the object property directly depending on `__use_delta` setting
+     *
+     * @param key
+     * @param value
+     */
+    #setProperty(key, value) {
+        let checkIsChanged = false;
+        if (this.__use_delta) {
+            if (this[key] === value) {
+                /**
+                 * we set something back to its original value
+                 * no need to save it as delta
+                 */
+                delete this.__delta[key];
+                ////checkIsChanged = true; //check if we should set __has_delta to false
+            }
+            else {
+                this.__delta[key] = value; //always update delta to keep track of changes
+            }
+        }
+        else {
+            this[key] = value; //on noDelta mode update the object itself
+            this.__delta[key] = value; //always update delta to keep track of changes
+        }
+        return true;
+    }
+    /**
+     * set value and run the event handlers if needed
+     * @param key
+     * @param value
+     * @param shouldNotify
+     * @param autoApply if the field is not in delta, instantly calls the `apply` function to remove from delta
+     * @returns
+     */
+    async set(key, value, shouldNotify = "auto", autoApply = false) {
+        /* -------------------- check if modification is allowed -------------------- */
+        if (!this.canModify) {
+            if (this.__throw_errors !== false)
+                throw Error(`Cant use set(${String(key)}) when on readonly mode`);
+            else
+                return false;
+        }
+        let isValueChanged, mkey, keyExists = false;
+        /* -------------------------------------------------------------------------- */
+        /*                         set all values from object                         */
+        /* -------------------------------------------------------------------------- */
+        if (typeof key === "object") {
+            let finalResult = true;
+            let changeablesOnly = Boolean(value);
+            value = key;
+            const checkKeys = changeablesOnly
+                ? array_intersection(this.__changeables, Object.keys(value))
+                : Object.keys(value);
+            for (let index = 0; index < checkKeys.length; index++) {
+                const key = checkKeys[index];
+                if (false ==
+                    (await this.set(key, value[key], shouldNotify, autoApply)))
+                    finalResult = false;
+            }
+            return finalResult;
+        }
+        if (typeof key === "string" && key.includes(".")) {
+            /* -------------------------------------------------------------------------- */
+            /*                             set value of object                            */
+            /* -------------------------------------------------------------------------- */
+            const keysp = key.split(".");
+            mkey = keysp.shift();
+            keyExists = mkey in this.__delta;
+            const subkey_part = keysp.shift();
+            //if accessing subval of an object, make sure the object is not null
+            const subval = this.#getSubProperty(mkey, subkey_part);
+            isValueChanged = !object_equals(subval, value, {
+                ignoredStartingWords: "_",
+                strictArrayCheck: true,
+            });
+            if (isValueChanged)
+                this.#setSubProperty(mkey, subkey_part, value);
+        }
+        else {
+            /* -------------------------------------------------------------------------- */
+            /*                               set basic value                              */
+            /* -------------------------------------------------------------------------- */
+            mkey = key;
+            keyExists = mkey in this.__delta;
+            const old_value = this.get(mkey);
+            isValueChanged = !object_equals(old_value, value, {
+                strictArrayCheck: true,
+                ignoredStartingWords: "_",
+            });
+            if (isValueChanged)
+                this.#setProperty(mkey, value);
+        }
+        if (autoApply && keyExists === false) {
+            /**
+             * if the field is not in delta
+             * instantly calls the `apply` function to remove from delta
+             */
+            this.apply(mkey);
+            if (shouldNotify === "auto")
+                shouldNotify = false;
+        }
+        if (isValueChanged) {
+            /**
+             * notify the manager when the state of `__has_delta` is changed
+             * managers can use this to detect if they need to save
+             */
+            this.manager?.checkIsChanged();
+        }
+        /* --------------------------------- notify --------------------------------- */
+        if (shouldNotify === true ||
+            (shouldNotify === "auto" && isValueChanged)) {
+            await this.notifyChanged("", key, value);
+        }
+        return isValueChanged;
+    }
+    /**
+     * @deprecated use `set`
+     * set value and run the event handlers if needed
+     * @return true if changed , false otherwise
+     */
+    setValue = this.set;
+    /**
+     * @deprecated use set function
+     */
+    setAll = this.set;
+    /**
+     * set value and run the event handlers if needed
+     *
+     * if the field is not in delta  instantly calls the `apply` function to remove from delta
+     * @param key
+     * @param value
+     */
+    async setPreferApply(key, value, shouldNotify = "auto") {
+        return await this.set(key, value, shouldNotify, true);
+    }
+    /**
+     * set key of subObject
+     * @param key
+     * @param value
+     * @param subvalue
+     * @param sendChanges
+     * @return true if changed , false otherwise
+     */
+    async setSubValue(key, objKey, subvalue, sendChanges = "auto") {
+        return await this.set(`${String(key)}.${objKey}`, subvalue, sendChanges);
+    }
+    async setTemp(key, value, sendChanges = false) {
+        let isValueChanged = await super.setTemp(key, value);
+        if (sendChanges === true ||
+            (sendChanges === "auto" && isValueChanged)) {
+            await this.notifyChanged("temp", key, value);
+        }
+        return isValueChanged;
+    }
+    /**
+     * Push a single value to array property
+     * @param key
+     * @param value
+     * @param sendChanges
+     * @returns
+     */
+    async pushValue(key, value, sendChanges = "auto") {
+        return await this.pushValues(key, [value], sendChanges);
+    }
+    /**
+     * Push a list of values to array property
+     * @param key
+     * @param values
+     * @param sendChanges
+     * @returns
+     */
+    async pushValues(key, values, sendChanges = "auto") {
+        if (array_isEmpty(values))
+            return false;
+        if (!this.canModify) {
+            if (this.__throw_errors !== false)
+                throw Error(`Cant use pushValues (${String(key)}) when on readonly mode`);
+            else
+                return false;
+        }
+        if (this.get(key) == null)
+            this.#setProperty(key, []);
+        let tempArray = this.get(key);
+        if (!Array.isArray(tempArray)) {
+            if (this.__throw_errors !== false)
+                throw Error(`Cant use pushValues (${String(key)}) on non Array keys`);
+            else
+                return false;
+        }
+        this.#setProperty(key, array_merge(tempArray, values));
+        if (sendChanges === true || sendChanges === "auto")
+            await this.notifyChanged("", key, values);
+        return tempArray;
+    }
+    /* -------------------------------------------------------------------------- */
+    /*                                    Load                                    */
+    /* -------------------------------------------------------------------------- */
+    /**
+     * load all properties in `initObject` into the current object
+     * @param initObject
+     * @param fullUpdate
+     * @returns
+     */
+    loadValues(initObject, fullUpdate = false) {
+        return SimpleObject.loadValues(this, initObject, fullUpdate);
+    }
+    static loadValues(obj, initObject, fullUpdate = false) {
+        if (typeof initObject === "number" || typeof initObject === "string") {
+            initObject = { _id: initObject };
+        }
+        SimpleObject.factoryClear(obj);
+        if (initObject == null) {
+            for (const key in obj) {
+                if (typeof obj[key] === "function")
+                    continue;
+                if (key.startsWith("__"))
+                    continue;
+                delete obj[key];
+            }
+        }
+        else if (typeof initObject == "object") {
+            for (const key in initObject) {
+                if (key.startsWith("__"))
+                    continue;
+                if (fullUpdate ||
+                    Object.prototype.hasOwnProperty.call(obj, key)) {
+                    obj[key] = initObject[key];
+                }
+            }
+            /* --------------------- special case 1, temp properties -------------------- */
+            if ("__temp" in initObject) {
+                obj["__temp"] = initObject["__temp"];
+            }
+        }
+        return true;
+    }
+    /* -------------------------------------------------------------------------- */
+    /*                              Refresh Functions                             */
+    /* -------------------------------------------------------------------------- */
+    async clearRefreshFunction() {
+        this.__refresh_functions = undefined;
+    }
+    async setRefreshFunction(new_fnc) {
+        return await this.addRefreshFunction(new_fnc);
+    }
+    async addRefreshFunction(key, new_fnc) {
+        if (typeof key === "function") {
+            new_fnc = key;
+            key = "main";
+        }
+        key = key || "main";
+        let oldFunctions = this.__refresh_functions;
+        if (oldFunctions == null || typeof oldFunctions !== "object")
+            oldFunctions = {};
+        oldFunctions[key] = new_fnc;
+        this.__refresh_functions = oldFunctions;
+    }
+    async runRefreshFunction(...params) {
+        let oldFunctions = this.__refresh_functions;
+        if (oldFunctions == null || typeof oldFunctions !== "object")
+            return;
+        const fncArray = Object.values(oldFunctions);
+        for (let index = 0; index < fncArray.length; index++) {
+            const fnc = fncArray[index];
+            await fn_eval(fnc, ...params);
+        }
+    }
+    /**
+     *
+     * @param type
+     * @param key
+     * @param value
+     * @param subvalue
+     * @returns true if manager was notified. false otherwise
+     */
+    async notifyChanged(type, key, value, subvalue) {
+        if (value === undefined && type == "")
+            value = this.get(key);
+        let lc = "";
+        if (type)
+            lc += `$${String(type)}$`;
+        if (subvalue) {
+            lc += `${String(key)}.${value}`;
+        }
+        else {
+            lc += `${String(key)}`;
+        }
+        this.__lastChanged = lc;
+        /* --------------------------- notify the manager --------------------------- */
+        const manager_class = this.manager;
+        if (typeof manager_class?.notifyChanged === "function") {
+            return await manager_class.notifyChanged(type, key, value, subvalue);
+        }
+        return false;
+    }
+    /**
+     * get a list of all keys that can be changed in given objcet
+     * @param object
+     * @param options
+     * @returns
+     */
+    static getChangeableKeys(object, options) {
+        if (!object)
+            return [];
+        let key_list = [];
+        key_list.push(...object.constructor["__changeables"]);
+        const __unchangeables = object.constructor["__unchangeables"];
+        if (!array_isEmpty(__unchangeables)) {
+            key_list = key_list.filter((s) => !__unchangeables.includes(s));
+        }
+        /* -------------------------------------------------------------------------- */
+        if (options.extraProperties) {
+            key_list.push(...object.constructor["__extraProperties"]);
+        }
+        if (options.tempProperties) {
+            key_list.push("__temp");
+            key_list.push(...object.constructor["__tempProperties"]);
+        }
+        if (options.bypassProtected !== true && !options.allProperties) {
+            const __protectedProperties = object.constructor["__protectedProperties"];
+            //protected keys can only be changed by the creator of this object
+            //make sure you set the is_current_user function correctly
+            if (!object.isNew &&
+                !array_isEmpty(__protectedProperties) &&
+                !Boolean(gfunc.run_action_sync("is_current_user", object.get("_creator")))) {
+                key_list = key_list.filter((s) => !__protectedProperties.includes(s));
+            }
+        }
+        return key_list;
+    }
+    /**
+     * check if a key can be changed on an object
+     * @param object the object we are checking
+     * @param key key of the object
+     * @param useExtraProps should we check extra props?
+     * @returns
+     */
+    static canChangeKey(object, key, options) {
+        if (!object || !key)
+            return false;
+        const keys = this.getChangeableKeys(object, options);
+        return keys.includes(key);
+    }
+    static hasIllegalChanges(referenceObject, changesObject, updaterUser) {
+        const __protectedProperties = object_getStatic(referenceObject, "__protectedProperties");
+        if (object_isEmpty(__protectedProperties))
+            return false;
+        const referenceUser = object_isClass(referenceObject)
+            ? object_get(changesObject, "__user", "_creator")
+            : object_get(referenceObject, "__user", "_creator");
+        if (Boolean(SimpleObject.getID(referenceUser) ==
+            SimpleObject.getID(updaterUser))) {
+            return false;
+        }
+        for (const key in changesObject) {
+            if (__protectedProperties.includes(key)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /* -------------------------------------------------------------------------- */
+    /*                                   Changes                                  */
+    /* -------------------------------------------------------------------------- */
+    /**
+     * Apply all the changes and empty the delta object
+     */
+    apply_changes() {
+        try {
+            if (!this.__use_delta) {
+                /**
+                 * in this mode , we track changes by updating the original product
+                 */
+                this.setOriginal();
+                return true;
+            }
+            if (!this.isChanged) {
+                console.warn("No changes to apply");
+                return false;
+            }
+            for (const key in this.__delta) {
+                const nv = this.__delta[key];
+                this[key] = nv;
+            }
+            return true;
+        }
+        finally {
+            this.clear_changes();
+        }
+    }
+    /**
+     * apply changes for the given fields
+     * @param key
+     * @returns
+     */
+    apply(keylist) {
+        if (!this.__use_delta) {
+            /**
+             * in this mode , we track changes by updating the original
+             */
+            return true;
+        }
+        if (this.__delta == null || Object.keys(this.__delta).length == 0) {
+            /**
+             * nothing to apply
+             */
+            return true;
+        }
+        keylist = wrap_array(keylist);
+        if (keylist.length == 0) {
+            /**
+             * nothing to apply
+             */
+            return true;
+        }
+        for (const key of keylist) {
+            if (key in this.__delta) {
+                this[key] = this.__delta[key];
+                delete this.__delta[key];
+            }
+        }
+        return true;
+    }
+    /**
+     * set the value to its original
+     * @param key
+     */
+    async discard(key, shouldNotify = "auto") {
+        let originalValue;
+        if (this.__use_delta) {
+            originalValue = this[key];
+        }
+        else if (this.__originalobject)
+            originalValue = this.__originalobject[key];
+        else
+            originalValue = this[key];
+        return await this.set(key, originalValue, shouldNotify);
+    }
+    /**
+     * reset all values back to their original
+     *
+     * this function also calls `on_change` and then `clear_changes`
+     * @param key
+     */
+    async discardAll(shouldNotify = "auto") {
+        let final_result = true;
+        for (const key in this.__delta) {
+            final_result =
+                final_result && (await this.discard(key, shouldNotify));
+        }
+        if (final_result)
+            this.clear_changes();
+        return final_result;
+    }
+    /**
+     * clear and discard all changes
+     *
+     * does not call `on_change` functions
+     * @returns
+     */
+    clear_changes() {
+        this.__delta = {};
+        ////this.__has_delta = false;
+        return true;
+    }
+    /**
+     * Sets readonly property on given objects
+     * @param objs array of given objects or a single object
+     * @param readonlyval readonly
+     * @param clearChanges should we clean the changes after setting readonly
+     */
+    static setReadonly(objs, readonlyval = true, clearChanges = false) {
+        let checkObjs = [];
+        if (!objs)
+            objs = [];
+        if (!Array.isArray(objs))
+            checkObjs = [objs];
+        else
+            checkObjs = objs;
+        for (let index = 0; index < checkObjs.length; index++) {
+            const obj = checkObjs[index];
+            obj.__is_readonly = Boolean(readonlyval);
+            if (obj instanceof SimpleObject) {
+                if (obj.canModify) {
+                    if (!obj.getOriginal())
+                        obj.setOriginal();
+                }
+                else {
+                    if (clearChanges)
+                        obj.clear_changes();
+                    //we dont need the original object in readonly mode
+                    obj.setOriginal(null);
+                }
+            }
+        }
+    }
+    static setThrowErrors(objs, throwErr = true) {
+        let checkObjs = [];
+        if (!objs)
+            objs = [];
+        if (!Array.isArray(objs))
+            checkObjs = [objs];
+        else
+            checkObjs = objs;
+        for (let index = 0; index < checkObjs.length; index++) {
+            const element = checkObjs[index];
+            element.__throw_errors = throwErr;
+        }
+    }
+    /* -------------------------------------------------------------------------- */
+    /*                                  Get/Check                                 */
+    /* -------------------------------------------------------------------------- */
+    get __object_name() {
+        return this.constructor["__object_name"] || this.__db_name;
+    }
+    get __db_name() {
+        return this.constructor["__db_name"] || this.constructor["__web_path"];
+    }
+    get isChanged() {
+        ////const deltaIsBlank = object_isEmpty(this.__delta);
+        ////if (!deltaIsBlank) return true; //delta is not blank, definitely changed
+        ////if (this.__use_delta) return !deltaIsBlank; //trust the delta.
+        if (this.__use_delta) {
+            ////return this.__has_delta;
+            /**
+             * if there is any key in delta, then the object is changed
+             */
+            for (const key in this.__delta)
+                return true;
+            return false;
+        }
+        /* --------------------- check the properties one by one -------------------- */
+        const orig = this.getOriginal();
+        if (!orig)
+            return false; //we dont know if anything has changed
+        /**
+         * if object is not using delta mode,
+         * check changes by comparing changeable fields with original object
+         */
+        if (Array.isArray(this.__changeables)) {
+            return (this.__changeables.find((c) => {
+                return !object_equals(this[c], orig[c]);
+            }) != undefined);
+        }
+        else {
+            /* check all fields */
+            for (const key in this) {
+                if (key.startsWith("__"))
+                    continue;
+                if (!object_equals(this[key], orig[key]))
+                    return true;
+            }
+            return false;
+        }
+    }
+    get isArchived() {
+        return this._archived || false;
+    }
+    set isArchived(v) {
+        this._archived = v;
+    }
+    get isDeleted() {
+        return this.get("_deleted") || false;
+    }
+    get isLocked() {
+        return this.get("_locked") || false;
+    }
+    get objectColor() {
+        if (!this.#objectColor) {
+            const lastid = this.getID();
+            if (lastid)
+                this.#objectColor = string_to_color(lastid);
+        }
+        return this.#objectColor || "#000000";
+    }
+    set isLocked(v) {
+        this._locked = v;
+    }
+    set isDeleted(v) {
+        this._deleted = v;
+    }
+    get d() {
+        return this.__use_delta ? this.__delta : this;
+    }
+    /* all updated properties */
+    get allproperties() {
+        const result = { ...this, ...this.__delta };
+        result.__delta = {};
+        return result;
+    }
+    get canModify() {
+        return !Boolean(this.__is_readonly);
+    }
+    get __changeables() {
+        return this.constructor["__changeables"];
+    }
+    get __unchangeables() {
+        return this.constructor["__unchangeables"];
+    }
+    get __use_delta() {
+        return this.constructor["__use_delta"];
+    }
+    get isSaved() {
+        return Boolean(this.__saveResultIsSuccess ?? false);
+    }
+    get isNew() {
+        const mid = this.getID();
+        if (!mid)
+            return true;
+        if (typeof mid === "string")
+            return mid === "" || mid === "-1";
+        if (typeof mid === "number")
+            return mid === -1;
+        return false;
+    }
+    get lastChanged() {
+        return this.__lastChanged || "";
+    }
+    get manager() {
+        return this.get_managerClass() || undefined;
+    }
+    get_managerClass = () => undefined;
+    /**
+     * @deprecated use setManager
+     * @param mng
+     */
+    set_managerClass(mng) {
+        return this.setManager(mng);
+    }
+    /**
+     * update the manager class for this object
+     * @param mng
+     */
+    setManager(mng) {
+        if (mng instanceof ObjectManager &&
+            typeof mng.setObject === "function") {
+            //make sure the manager knows what object it is managing
+            return mng.setObject(this);
+        }
+        else {
+            console.error("set_managerClass was used with a bad manager. make sure the input to this function is a correct ObjectManager");
+        }
+    }
+    static isDeleted(obj) {
+        if (obj instanceof SimpleObject)
+            return obj.isDeleted === true;
+        return false;
+    }
+    getIndexOrID() {
+        return SimpleObject.getIndexOrID(this);
+    }
+    getIndex() {
+        return SimpleObject.getIndex(this);
+    }
+    getID() {
+        return SimpleObject.getID(this);
+    }
+    static getIndexOrID(o) {
+        let res = SimpleObject.getIndex(o);
+        if (!res || res == -1)
+            res = SimpleObject.getID(o);
+        return res || -1;
+    }
+    static getIndex(o) {
+        if (o == null || o == undefined)
+            return -1;
+        switch (typeof o) {
+            case "object":
+                return o._index_value || -1;
+            case "number":
+            case "string":
+                return Number(o);
+        }
+        return -1;
+    }
+    static getID(obj) {
+        if (obj == null || obj == undefined)
+            return "";
+        switch (typeof obj) {
+            case "object":
+                if (String(obj._bsontype).toLowerCase() == "objectid") {
+                    return String(obj);
+                }
+                return String(obj._id ||
+                    obj.insertedId ||
+                    obj.ID ||
+                    obj.id ||
+                    obj.__data_id ||
+                    "");
+            case "string":
+            case "number":
+                return String(obj);
+        }
+        return "";
+    }
+    /* -------------------------------------------------------------------------- */
+    /*                                   Events                                   */
+    /* -------------------------------------------------------------------------- */
+    async event_run(eventName, ...params) {
+        if (!this.manager) {
+            if (this.__showErrors === true)
+                console.error(`you cant use events (${eventName}) if your object has no manager`);
+            return;
+        }
+        return await this.manager.event_run(eventName, ...params);
+    }
+    event_use(name, runEvent, onlyOn = null, runOnce = false) {
+        if (!this.manager) {
+            if (this.__showErrors === true)
+                console.error(`you cant use events (${name}) if your object has no manager`);
+            return;
+        }
+        return this.manager.event_use(name, runEvent, onlyOn, runOnce);
+    }
+    event_remove(name, uname) {
+        if (!this.manager) {
+            if (this.__showErrors === true)
+                console.error(`you cant use events (${name}) if your object has no manager`);
+            return;
+        }
+        return this.manager.event_remove(name, uname);
+    }
+    async event_add(name, uname, runEvent, onlyOn = null, runOnce = false) {
+        if (!this.manager) {
+            if (this.__showErrors === true)
+                console.error(`you cant use events (${name}) if your object has no manager`);
+            return;
+        }
+        await this.manager.event_add(name, uname, runEvent, onlyOn, runOnce);
+    }
+    /* -------------------------------------------------------------------------- */
+    /*                                  Original                                  */
+    /* -------------------------------------------------------------------------- */
+    getOriginal() {
+        return this.__originalobject || undefined;
+    }
+    setOriginal(toObj = 0) {
+        if (toObj === null) {
+            delete this.__originalobject;
+            return;
+        }
+        if (!this.canModify) {
+            console.warn("Cant use setOriginal on non original OR readonly objects ! this will create an infinite loop");
+            delete this.__originalobject;
+            return;
+        }
+        if (toObj === 0) {
+            toObj = this;
+        }
+        const cloneObject = object_clone(toObj);
+        SimpleObject.setReadonly(cloneObject, true);
+        this.__originalobject = object_removeKeys(cloneObject, ["__"]);
+        return this;
+    }
+    static setOriginal(obj, toObj = 0) {
+        if (!(obj instanceof SimpleObject))
+            return undefined;
+        return obj.setOriginal(toObj);
+    }
+    static getOriginal(obj) {
+        if (obj instanceof SimpleObject)
+            return obj.getOriginal();
+        return obj?.__originalobject;
+    }
+    /* -------------------------------------------------------------------------- */
+    /*                                   Errors                                   */
+    /* -------------------------------------------------------------------------- */
+    addError(title, message, sendToRegister = "auto") {
+        return SimpleObject.addError(this, title, message, sendToRegister);
+    }
+    clearErrors() {
+        return SimpleObject.clearErrors(this);
+    }
+    getErrors() {
+        return SimpleObject.getErrors(this);
+    }
+    static addError(o, title, message, sendToRegister = "auto") {
+        const errStr = combine_if_not_blank(title, " : ", message);
+        if (o) {
+            if (!Array.isArray(o.__errors))
+                o.__errors = [];
+            o.__errors.push(errStr);
+            if (o.__showErrors === false)
+                return;
+        }
+        else if (sendToRegister === "auto")
+            sendToRegister = true;
+        if (sendToRegister === true) {
+            console.error("[REGISTER-ERROR]", errStr);
+            gfunc.run_action("add_error", {
+                title: title,
+                message: message,
+                type: "error",
+            });
+        }
+        else {
+            console.error("[ERROR]", errStr);
+        }
+        return o?.__errors || [];
+    }
+    static getErrors(o) {
+        return o?.__errors || [];
+    }
+    static clearErrors(o) {
+        if (o)
+            o.__errors = [];
+        return true;
+    }
+    /* -------------------------------------------------------------------------- */
+    /*                                Save Results                                */
+    /* -------------------------------------------------------------------------- */
+    /**
+     * Checks if the given object is a valid and truthy save result
+     * @param result_object
+     * @returns
+     */
+    static isResultValid(result_object, depth = 0) {
+        if (object_isEmpty(result_object))
+            return false;
+        switch (typeof result_object) {
+            case "string":
+                try {
+                    result_object = JSON.parse(result_object);
+                    return this.isResultValid(result_object);
+                }
+                catch {
+                    return false;
+                }
+            case "number":
+                return result_object > 0;
+            case "boolean":
+                return result_object === true;
+            case "object":
+                /* ----------------------------- result is error ---------------------------- */
+                if (result_object instanceof Error) {
+                    return false;
+                }
+                /* ----------------- maybe website sends the result as array ---------------- */
+                if (Array.isArray(result_object)) {
+                    const allResults = result_object.map((r) => {
+                        return Boolean(this.isResultValid(r, depth + 1));
+                    });
+                    return allResults.find((s) => s === false) == null;
+                }
+                /* ----------------------------- check products/variations ----------------------------- */
+                const varKeys = ["products", "variations"];
+                for (const vk of varKeys) {
+                    if (!(vk in result_object) ||
+                        array_isEmpty(result_object[vk]))
+                        continue;
+                    /**
+                     * if one product is not valid the result is not valid
+                     * but if all products are valid we still need to check the object itself
+                     */
+                    if (!this.isResultValid(result_object[vk], depth + 1))
+                        return false;
+                }
+                if (result_object.order) {
+                    /**
+                     * if we get a order-products pair, checking the order is enough
+                     */
+                    return this.isResultValid(result_object.order, depth + 1);
+                }
+                /* -------------------------- check if acknowledged ------------------------- */
+                if (object_isTrue(result_object.acknowledged)) {
+                    return true;
+                }
+                if (result_object.expected && result_object.result) {
+                    return object_equals(result_object.expected, result_object.result);
+                }
+                return !string_isEmpty(this.getID(result_object));
+        }
+        return false;
+    }
+    /**
+     * set the response of last save from site
+     * and its type
+     * @param toObj
+     */
+    setSaveResult(toObj, type = "auto", registerErrors = false) {
+        this.#setSaveResultObject(toObj);
+        //check if the given object is a valid save result
+        if (type === "error")
+            this.__saveResultIsSuccess = false;
+        else
+            this.__saveResultIsSuccess = Boolean(type === "nothing" || this.constructor["isResultValid"](toObj));
+        if (type === "auto") {
+            type = this.__saveResultIsSuccess ? "normal" : "error";
+        }
+        if (registerErrors && !this.__saveResultIsSuccess) {
+            const sr = this.__saveResultObject;
+            const errorString = sr == null
+                ? ""
+                : sr instanceof Error
+                    ? sr.message
+                    : JSON.stringify(sr);
+            SimpleObject.addError(this, "save result is not valid", errorString, true);
+        }
+        this.__saveResultType = type;
+        return type;
+    }
+    /**
+     * set the response of last save from site
+     * @param toObj
+     */
+    #setSaveResultObject(toObj) {
+        if (toObj == null)
+            toObj = null; //null or undefined
+        this.__saveResultObject = toObj;
+        return true;
+    }
+    getSaveResult(original = false) {
+        if (this.isSaved)
+            return this.__saveResultObject;
+        return false;
+    }
+    getSaveResultType() {
+        return this.__saveResultType || "nothing";
+    }
+    /** did we create on the last save */
+    getIsLastSaveCreate() {
+        return this.isSaved && this.getSaveResult().insertedId;
+    }
+    /* -------------------------------------------------------------------------- */
+    /*                                   statics                                  */
+    /* -------------------------------------------------------------------------- */
+    static async setTemp(obj, key, value, sendChanges = false) {
+        if (typeof obj !== "object" || !obj || Array.isArray(obj))
+            return;
+        if (obj instanceof SimpleObject)
+            return await obj.setTemp(key, value, sendChanges);
+        //
+        if (obj.__temp == null)
+            obj.__temp = {};
+        object_set(obj.__temp, key, value);
+    }
+    static factoryClear(obj) {
+        obj.clear_changes();
+        SimpleObject.clearErrors(obj);
+    }
+    static async delete_cache(context) {
+        if (!this.__db_name)
+            return;
+        if (!context)
+            await gcache.delete_session_cache(this.__db_name);
+        else {
+            const cacheKey = `${this.__db_name}-${context}`;
+            await gcache.delete_session_cache(cacheKey);
+        }
+    }
+    static get_canModify(o) {
+        if (o instanceof SimpleObject)
+            return o.canModify;
+        return false;
+    }
+    /* -------------------------------------------------------------------------- */
+    static equals(a, b) {
+        console.warn("Dont use the default equals method !");
+        if (a == undefined || b == undefined)
+            return false;
+        return a === b;
+    }
+}
+export default SimpleObject;