@azrico/webobject 1.5.58 → 1.5.61

package/dist/src/WebObjects/WebObjectHelper.test.js

@@ -0,0 +1,45 @@
+import { WebObject } from "../index";
+import WebObjectHelper from "./WebObjectHelper";
+class TestWebObject extends WebObject {
+    name = "";
+}
+describe("WebObjectHelper", () => {
+    let wobj;
+    let wobj2;
+    let wobjArray;
+    beforeEach(() => {
+        wobj = new TestWebObject();
+        wobj2 = new TestWebObject();
+        wobjArray = [
+            wobj,
+            new TestWebObject(),
+            new TestWebObject(),
+            new TestWebObject(),
+            wobj2,
+        ];
+    });
+    describe("isChangedWebObjectField", () => {
+        it("returns false for non webobjects", () => {
+            expect(WebObjectHelper.isChangedWebObjectField(1)).toBeFalsy();
+            expect(WebObjectHelper.isChangedWebObjectField("test")).toBeFalsy();
+            expect(WebObjectHelper.isChangedWebObjectField(null)).toBeFalsy();
+            expect(WebObjectHelper.isChangedWebObjectField(undefined)).toBeFalsy();
+            expect(WebObjectHelper.isChangedWebObjectField([])).toBeFalsy();
+            expect(WebObjectHelper.isChangedWebObjectField({})).toBeFalsy();
+        });
+        it("works on single object", () => {
+            expect(WebObjectHelper.isChangedWebObjectField(wobj)).toBeFalsy();
+            wobj.set("name", "test");
+            expect(WebObjectHelper.isChangedWebObjectField(wobj)).toBeTruthy();
+            wobj.clear_changes();
+            expect(WebObjectHelper.isChangedWebObjectField(wobj)).toBeFalsy();
+        });
+        it("works on array", () => {
+            expect(WebObjectHelper.isChangedWebObjectField(wobjArray)).toBeFalsy();
+            wobj2.set("name", "test");
+            expect(WebObjectHelper.isChangedWebObjectField(wobjArray)).toBeTruthy();
+            wobj2.clear_changes();
+            expect(WebObjectHelper.isChangedWebObjectField(wobjArray)).toBeFalsy();
+        });
+    });
+});

package/dist/src/WebObjects/WebObjectManager.d.ts

@@ -0,0 +1,68 @@
+import { ClassType } from "@azrico/types";
+import { WebObject, sendChangesType } from "../index";
+import ObjectManager from "../structs/ObjectManager";
+/**
+ * This class manages the events of an Simple Object
+ */
+export declare class WebObjectManager<ObjType extends WebObject> extends ObjectManager<ObjType> {
+    protected static readonly __object_type: () => typeof WebObject | ClassType<WebObject>;
+    static readonly __save_message: boolean;
+    constructor(defaultObject?: ObjType);
+    setObject(toObj: ObjType | undefined): boolean;
+    /**
+     * Update meta value of this object , meta data is stored in meta_data variable
+     * @param key
+     * @param value
+     * @param createIfNotExists should we create a new meta if key does not exist
+     * @param sendChange
+     * @returns
+     */
+    setMetaValue(key: string, value: any, sendChange?: sendChangesType): Promise<boolean | undefined>;
+    getMetaValue(key: string): any;
+    get_deltaObject(): Promise<any>;
+    Save(): Promise<boolean>;
+    New(): Promise<void>;
+    Delete(): Promise<any>;
+    Lock(): Promise<any>;
+    UnLock(): Promise<any>;
+    Archive(): Promise<any>;
+    UnArchive(): Promise<any>;
+    Load(id: any, ...p: any[]): Promise<WebObject | undefined>;
+    get __web_path(): string;
+    get __db_name(): string;
+    get __object_name(): string;
+    get_webpath(): string;
+    private __getObjectData;
+    /**
+     * Use this when you delete Object
+     * @param p
+     * @returns
+     */
+    onDelete(...p: any): Promise<any>;
+    onArchive(...p: any): Promise<any>;
+    onUnArchive(...p: any): Promise<any>;
+    onLock(...p: any): Promise<any>;
+    onUnLock(...p: any): Promise<any>;
+    /**
+     * Use this when you load new Object
+     * @param p
+     * @returns
+     */
+    onNew(...p: any): Promise<any>;
+    /**
+     * Use this when you load data to the object
+     * @param p
+     * @returns
+     */
+    onLoad(...p: any): Promise<any>;
+    /**
+     * Use this after succesful save to Database
+     * @param p
+     * @returns
+     */
+    onSave(...p: any): Promise<any>;
+    onAfterSave(...p: any): Promise<any>;
+    getObjectType(): typeof WebObject;
+    static getObjectType(): typeof WebObject | ClassType<WebObject>;
+}
+export default WebObjectManager;

package/dist/src/WebObjects/WebObjectManager.js

@@ -0,0 +1,290 @@
+import { SimpleObject, WebObject } from "../index";
+import ObjectManager from "../structs/ObjectManager";
+import { gfunc } from "@azrico/global";
+import { fn_eval, } from "@azrico/object";
+/**
+ * This class manages the events of an Simple Object
+ */
+export class WebObjectManager extends ObjectManager {
+    static __object_type;
+    static __save_message = true;
+    /* -------------------------------------------------------------------------- */
+    constructor(defaultObject) {
+        super(defaultObject);
+        if (this.constructor["__save_message"]) {
+            /* ---------------- should we display a message after saving ? -------------- */
+            this.event_add("on_save", "on_save-sendmsg", async (srt) => {
+                switch (srt) {
+                    case "nothing":
+                        return await gfunc.run_action("show_message", {
+                            message: "Nothing to save",
+                            type: "info",
+                        });
+                    case "normal":
+                        return await gfunc.run_action("show_message", {
+                            message: "Saved",
+                            type: "success",
+                        });
+                    default:
+                        return await gfunc.run_action("show_message", {
+                            message: "Not saved",
+                            type: "error",
+                        });
+                }
+            });
+            this.event_add("on_archive", "on_archive-sendmsg", async (srType) => {
+                switch (srType) {
+                    case "normal":
+                        return await gfunc.run_action("show_message", {
+                            message: "Archived",
+                            type: "success",
+                        });
+                    default:
+                        return await gfunc.run_action("show_message", {
+                            message: `Not archived (${srType})`,
+                            type: "error",
+                        });
+                }
+            });
+            this.event_add("on_unarchive", "on_unarchive-sendmsg", async (srType) => {
+                switch (srType) {
+                    case "normal":
+                        return await gfunc.run_action("show_message", {
+                            message: "Restored",
+                            type: "success",
+                        });
+                    default:
+                        return await gfunc.run_action("show_message", {
+                            message: `Not restored (${srType})`,
+                            type: "error",
+                        });
+                }
+            });
+            this.event_add("on_delete", "on_delete-sendmsg", async (srType) => {
+                switch (srType) {
+                    case "normal":
+                        return await gfunc.run_action("show_message", {
+                            message: "Deleted",
+                            type: "success",
+                        });
+                    default:
+                        return await gfunc.run_action("show_message", {
+                            message: `Not deleted (${srType})`,
+                            type: "error",
+                        });
+                }
+            });
+        }
+    }
+    /* -------------------------------------------------------------------------- */
+    setObject(toObj) {
+        const res = super.setObject(toObj);
+        if (this.__currentObject &&
+            this.__currentObject instanceof SimpleObject) {
+            const checkKeys = ["__web_path", "__db_name", "__object_name"];
+            for (let index = 0; index < checkKeys.length; index++) {
+                const k = checkKeys[index];
+                if (!this.__last_object_data)
+                    this.__last_object_data = {};
+                if (this.__currentObject[k] != null)
+                    this.__last_object_data[k] = this.__currentObject[k];
+            }
+        }
+        return res;
+    }
+    /* -------------------------------------------------------------------------- */
+    /*                                  Meta data                                 */
+    /* -------------------------------------------------------------------------- */
+    /**
+     * Update meta value of this object , meta data is stored in meta_data variable
+     * @param key
+     * @param value
+     * @param createIfNotExists should we create a new meta if key does not exist
+     * @param sendChange
+     * @returns
+     */
+    async setMetaValue(key, value, sendChange = "auto") {
+        return await this.obj?.setMetaValue(key, value, sendChange);
+    }
+    getMetaValue(key) {
+        return this.obj?.getMetaValue(key);
+    }
+    /* -------------------------------------------------------------------------- */
+    async get_deltaObject() {
+        return (await this.obj?.get_deltaObject()) || {};
+    }
+    /* ------------------------------ save and load ----------------------------- */
+    async Save() {
+        return (await this.obj?.Save()) || false;
+    }
+    async New() {
+        const cls = this.getObjectType();
+        this.setObject(new cls());
+        await this.onNew();
+    }
+    async Delete() {
+        return (await this.obj?.Delete()) || false;
+    }
+    async Lock() {
+        return (await this.obj?.Lock()) || false;
+    }
+    async UnLock() {
+        return (await this.obj?.UnLock()) || false;
+    }
+    async Archive() {
+        return (await this.obj?.Archive()) || false;
+    }
+    async UnArchive() {
+        return (await this.obj?.UnArchive()) || false;
+    }
+    /* -------------------------------------------------------------------------- */
+    async Load(id, ...p) {
+        if (!id)
+            return;
+        try {
+            this.event_run("on_process_start", true);
+            const classType = this.getObjectType();
+            if (!classType) {
+                console.error("[webobjectmanager]", "getObjectType failed to get the object_type.", "did you set the __object_type correctly ?");
+            }
+            const result_product = await classType.get_single(id, false);
+            if (result_product &&
+                typeof result_product === "object" &&
+                WebObject.getID(result_product)) {
+                this.setObject(result_product);
+                await result_product.onLoad();
+            }
+            else {
+                console.error("badobject:", id, result_product);
+                WebObject.addError(this.obj, `Invalid ${this.__object_name}`, `The loaded ${this.__object_name} from website is invalid`, true);
+            }
+        }
+        finally {
+            this.event_run("on_process_end", true);
+        }
+        return this.getObject();
+    }
+    /* -------------------------------------------------------------------------- */
+    /*                               Child Functions                              */
+    /* -------------------------------------------------------------------------- */
+    get __web_path() {
+        return this.__getObjectData(["__web_path", "__db_name"]);
+    }
+    get __db_name() {
+        return this.__getObjectData(["__db_name", "__web_path"]);
+    }
+    get __object_name() {
+        return this.__getObjectData(["__object_name", "__db_name"]);
+    }
+    get_webpath() {
+        return this.__getObjectData(["__web_path", "__db_name"]);
+    }
+    __getObjectData(checkKeys) {
+        const objtype = this.getObjectType();
+        for (let index = 0; index < checkKeys.length; index++) {
+            const k = checkKeys[index];
+            const v = this.obj?.[k] || this.__last_object_data[k] || objtype?.[k];
+            if (v)
+                return v;
+        }
+        return "";
+    }
+    /* -------------------------------------------------------------------------- */
+    /*                               Default Events                               */
+    /* -------------------------------------------------------------------------- */
+    /**
+     * Use this when you delete Object
+     * @param p
+     * @returns
+     */
+    async onDelete(...p) {
+        const srt = this.getSaveResultType();
+        await this.event_run("on_delete", srt);
+        await this.event_run("on_after_delete", srt);
+        return true;
+    }
+    async onArchive(...p) {
+        const srt = this.getSaveResultType();
+        await this.event_run("on_archive", srt);
+        await this.event_run("on_after_archive", srt);
+        return true;
+    }
+    async onUnArchive(...p) {
+        const srt = this.getSaveResultType();
+        await this.event_run("on_unarchive", srt);
+        await this.event_run("on_after_unarchive", srt);
+        return true;
+    }
+    async onLock(...p) {
+        const srt = this.getSaveResultType();
+        await this.event_run("on_lock", srt);
+        await this.event_run("on_after_lock", srt);
+        return true;
+    }
+    async onUnLock(...p) {
+        const srt = this.getSaveResultType();
+        await this.event_run("on_unlock", srt);
+        await this.event_run("on_after_unlock", srt);
+        return true;
+    }
+    /**
+     * Use this when you load new Object
+     * @param p
+     * @returns
+     */
+    async onNew(...p) {
+        if (this.canModify) {
+            this.obj?.setOriginal();
+        }
+        await this.event_run("on_new");
+        await this.event_run("on_change", true);
+        await this.event_run("on_after_new");
+        await this.checkIsChanged();
+        return await Promise.resolve(true);
+    }
+    /**
+     * Use this when you load data to the object
+     * @param p
+     * @returns
+     */
+    async onLoad(...p) {
+        if (this.canModify && this.obj) {
+            this.obj.isDeleted = false;
+            this.obj.setOriginal();
+        }
+        await this.event_run("on_load");
+        await this.event_run("on_change", true);
+        await this.event_run("on_after_load");
+        await this.event_run("on_load_finished");
+        await this.checkIsChanged();
+        return true;
+    }
+    /**
+     * Use this after succesful save to Database
+     * @param p
+     * @returns
+     */
+    async onSave(...p) {
+        const srt = this.getSaveResultType();
+        await this.event_run("on_save", srt);
+        await this.event_run("on_change", true);
+        await this.checkIsChanged();
+        return await Promise.resolve(true);
+    }
+    async onAfterSave(...p) {
+        const srt = this.getSaveResultType();
+        await this.event_run("on_after_save", srt);
+        await this.event_run("on_save_finished", srt);
+        return await Promise.resolve(true);
+    }
+    /* -------------------------------------------------------------------------- */
+    /*                              get __object_type                             */
+    /* -------------------------------------------------------------------------- */
+    getObjectType() {
+        return this.constructor["getObjectType"]();
+    }
+    static getObjectType() {
+        return fn_eval(this.__object_type);
+    }
+}
+export default WebObjectManager;

package/dist/src/WebObjects/WebObjectPathHelper.d.ts

@@ -0,0 +1,36 @@
+import { AnyClassType } from "@azrico/types";
+import WebObject from "./WebObject";
+type PathFunction<T extends AnyClassType> = string | ((w: InstanceType<T>) => string);
+export declare class WebObjectPathHelper {
+    static readonly defaultPaths: {
+        lock: string;
+        unlock: string;
+        archive: string;
+        unarchive: string;
+        delete: string;
+        new: string;
+        save: string;
+        get: string;
+    };
+    static readonly pathOverrides: {};
+    /**
+     * get path that we use for `action` for the `obj`
+     * @param obj
+     * @param action
+     * @returns
+     */
+    static get_path<T extends WebObject | typeof WebObject>(obj: T, action: string): Promise<string>;
+    /**
+     * clear all paths that are override by `override_path`
+     */
+    static clear_overrides(): Promise<void>;
+    /**
+     * override a save path for the gievn webobject
+     * @param obj
+     * @param pn
+     * @param override
+     * @returns
+     */
+    static override_path<T extends AnyClassType>(obj: T | InstanceType<T> | string, pn: string, override: PathFunction<T>): Promise<false | PathFunction<T>>;
+}
+export default WebObjectPathHelper;

package/dist/src/WebObjects/WebObjectPathHelper.js

@@ -0,0 +1,84 @@
+import WebObject from "./WebObject";
+export class WebObjectPathHelper {
+    static defaultPaths = {
+        lock: "{wn}/{id}/lock",
+        unlock: "{wn}/{id}/unlock",
+        archive: "{wn}/{id}/archive",
+        unarchive: "{wn}/{id}/unarchive",
+        delete: "{wn}/{id}",
+        new: "{wn}",
+        save: "{wn}/{id}",
+        get: "{wn}",
+    };
+    static pathOverrides = {};
+    /**
+     * get path that we use for `action` for the `obj`
+     * @param obj
+     * @param action
+     * @returns
+     */
+    static async get_path(obj, action) {
+        action = String(action).toLowerCase();
+        const wn = obj.get_webpath();
+        const wp = obj.__web_path;
+        let usepath = "";
+        if (WebObjectPathHelper.pathOverrides[wn] &&
+            WebObjectPathHelper.pathOverrides[wn][action]) {
+            usepath = WebObjectPathHelper.pathOverrides[wn][action];
+        }
+        else {
+            usepath = WebObjectPathHelper.defaultPaths[action];
+        }
+        if (!usepath)
+            usepath = WebObjectPathHelper.defaultPaths["save"];
+        if (typeof usepath === "function")
+            usepath = String(usepath(obj));
+        /* ----------------------------- place variables ---------------------------- */
+        usepath = String(usepath).replaceAll("{wn}", wn).replaceAll("{wp}", wp);
+        if (obj instanceof WebObject) {
+            usepath = usepath.replaceAll("{id}", obj.getID());
+        }
+        /* -------------------------------------------------------------------------- */
+        return usepath;
+    }
+    /**
+     * clear all paths that are override by `override_path`
+     */
+    static async clear_overrides() {
+        for (const key in this.pathOverrides) {
+            this.pathOverrides[key] = {};
+        }
+    }
+    /**
+     * override a save path for the gievn webobject
+     * @param obj
+     * @param pn
+     * @param override
+     * @returns
+     */
+    static async override_path(obj, pn, override) {
+        pn = String(pn).toLowerCase();
+        let wn = "";
+        /* ------------------------------ find webname ------------------------------ */
+        if (typeof obj === "string") {
+            wn = obj;
+        }
+        else if (typeof obj.get_webpath === "function") {
+            wn = obj.get_webpath();
+        }
+        else {
+            console.error("[override_path]", "given object has no get_webpath");
+            wn = obj.__web_path || obj.__web_type;
+        }
+        if (!wn) {
+            console.error("[override_path]", "bad webname");
+            return false;
+        }
+        /* --------------------------- apply the override --------------------------- */
+        if (!WebObjectPathHelper.pathOverrides[wn])
+            WebObjectPathHelper.pathOverrides[wn] = {};
+        WebObjectPathHelper.pathOverrides[wn][pn] = override;
+        return override;
+    }
+}
+export default WebObjectPathHelper;

package/dist/src/WebObjects/WebObjectPathHelper.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/WebObjects/WebObjectPathHelper.test.js

@@ -0,0 +1,31 @@
+import { WebObject } from "../index";
+import WebObjectPathHelper from "./WebObjectPathHelper";
+class TestWebObject extends WebObject {
+    static __web_path = "test-wp";
+}
+describe("WebObjectPathHelper", () => {
+    let wobj;
+    beforeEach(() => {
+        WebObjectPathHelper.clear_overrides();
+        wobj = new TestWebObject();
+        wobj._id = "test";
+    });
+    it("get_path", async () => {
+        expect(await WebObjectPathHelper.get_path(wobj, "save")).toBe(wobj.get_webpath() + "/" + wobj.getID());
+        expect(await WebObjectPathHelper.get_path(wobj, "new")).toBe(wobj.get_webpath());
+        expect(await WebObjectPathHelper.get_path(wobj, "lock")).toBe(`${wobj.get_webpath()}/${wobj.getID()}/lock`);
+    });
+    it("override_path", async () => {
+        await WebObjectPathHelper.override_path(wobj.get_webpath(), "save", "blah");
+        expect(await WebObjectPathHelper.get_path(wobj, "save")).toBe("blah");
+        /* -------------------------------------------------------------------------- */
+        await WebObjectPathHelper.override_path(wobj.get_webpath(), "save", "{id}");
+        expect(await WebObjectPathHelper.get_path(wobj, "save")).toBe(wobj.getID());
+        /* ------------------------ old data is not affected ------------------------ */
+        expect(await WebObjectPathHelper.get_path(wobj, "new")).toBe(wobj.get_webpath());
+    });
+    it("override_path with function", async () => {
+        await WebObjectPathHelper.override_path(wobj, "save", (s) => s._id);
+        expect(await WebObjectPathHelper.get_path(wobj, "save")).toBe(wobj.getID());
+    });
+});

package/dist/src/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./structs/SimpleObject";
+export * from "./structs/ObjectArray";
+export * from "./structs/MapableObject";
+export * from "./structs/MetaObject";
+export * from "./structs/DummyObject";
+export * from "./structs/ObjectManager";
+export * from "./WebObjects/WebObjectManager";
+export * from "./WebObjects/WebObject";
+export * from "./WebObjects/WebObjectPathHelper";
+export * from "./WebObjects/ParentWebObject";

package/dist/src/index.js

@@ -0,0 +1,10 @@
+export * from "./structs/SimpleObject";
+export * from "./structs/ObjectArray";
+export * from "./structs/MapableObject";
+export * from "./structs/MetaObject";
+export * from "./structs/DummyObject";
+export * from "./structs/ObjectManager";
+export * from "./WebObjects/WebObjectManager";
+export * from "./WebObjects/WebObject";
+export * from "./WebObjects/WebObjectPathHelper";
+export * from "./WebObjects/ParentWebObject";

package/dist/src/structs/DummyObject.d.ts

@@ -0,0 +1,5 @@
+import { SimpleObject } from "./SimpleObject";
+export declare class DummyObject extends SimpleObject {
+    constructor(initObject: Partial<DummyObject> | null | undefined);
+}
+export default DummyObject;

package/dist/src/structs/DummyObject.js

@@ -0,0 +1,8 @@
+import { SimpleObject } from "./SimpleObject";
+export class DummyObject extends SimpleObject {
+    constructor(initObject) {
+        super(false);
+        this.loadValues(initObject, true);
+    }
+}
+export default DummyObject;

package/dist/src/structs/MapableObject.d.ts

@@ -0,0 +1,43 @@
+import ObjectWithTemp from "./ObjectWithTemp";
+declare type FirstInTuple<T extends any[]> = ((...args: T) => any) extends (arg: infer R, ...rest: infer U) => any ? R : T;
+/**
+ * This object can be mapped and converted
+ */
+export declare class MapableObject extends ObjectWithTemp {
+    readonly __uid: string;
+    __table_id?: string;
+    __parent__table_id?: string;
+    __row_number?: number;
+    constructor();
+    getUID(): string;
+    static getUID(o: MapableObject): string;
+    static mapto<T>(maptoType: {
+        new (...p: any): T;
+    }, objectlist: any[] | null | undefined, is_readonly?: boolean, ...p: any[]): T[];
+    static mapto<T extends typeof MapableObject>(objectlist: any[] | null | undefined, is_readonly?: boolean, ...p: any[]): InstanceType<T>[];
+    /**
+     * construct a new class from the given first parameter
+     * @param maptoType class
+     * @param first_param first parameter
+     * @returns
+     */
+    static ensure<ClassType extends new (...args: any) => any>(maptoType: ClassType, first_param: FirstInTuple<ConstructorParameters<ClassType>>): InstanceType<ClassType>;
+    /**
+     * construct a new class from the given parameters
+     * @param maptoType class
+     * @param first_param first parameter
+     * @returns
+     */
+    static ensure<ClassType extends new (...args: any) => any>(maptoType: ClassType, ...rest_params: ConstructorParameters<ClassType>): InstanceType<ClassType>;
+    /**
+     * make sure the object is instance of class
+     * @param maptoType class
+     * @param obj
+     * @returns
+     */
+    static ensure<ClassType extends new (...args: any) => any>(maptoType: ClassType, obj: InstanceType<ClassType>): InstanceType<ClassType>;
+    static map_rowindex<T extends MapableObject>(objectlist: T[] | null | undefined): T[];
+    static map_tableid<T extends MapableObject>(objectlist: T[] | null | undefined): T[];
+    static equals(a?: MapableObject | any, b?: MapableObject | any): boolean;
+}
+export default MapableObject;