feat: Initial commit after clean slate

1 files changed, 254 insertions, 0 deletions

diff --git a/src/wwwroot/scripts/utilities.js b/src/wwwroot/scripts/utilities.js
new file mode 100644
index 0000000..02af8b5
--- /dev/null
+++ b/src/wwwroot/scripts/utilities.js
@@ -0,0 +1,254 @@
+import {toaster} from "./base";
+import {messages} from "./messages";
+
+export const utilites = {
+    dom: {
+        restrictInputToNumbers(el, specials, mergeSpecialsWithDefaults) {
+            el.addEventListener("keydown", e => {
+                const defaultSpecials = [
+                    "Backspace",
+                    "ArrowLeft",
+                    "ArrowRight",
+                    "Tab",
+                ];
+                let keys = specials ?? defaultSpecials;
+                if (mergeSpecialsWithDefaults && specials) keys = [...specials, ...defaultSpecials];
+                if (keys.indexOf(e.key) !== -1) {
+                    return;
+                }
+                if (isNaN(parseInt(e.key))) {
+                    e.preventDefault();
+                }
+            });
+        },
+        elementHasFocus: (el) => el === document.activeElement,
+        moveFocus(element) {
+            if (!element) element = document.getElementsByTagName("body")[0];
+            element.focus();
+            if (!this.elementHasFocus(element)) {
+                element.setAttribute("tabindex", "-1");
+                element.focus();
+            }
+        },
+    },
+    array: {
+        isEmpty: (arr) => arr === undefined || !Array.isArray(arr) || arr.length <= 0,
+        removeItemOnce(arr, value) {
+            const index = arr.indexOf(value);
+            if (index > -1) {
+                arr.splice(index, 1);
+            }
+            return arr;
+        },
+        pushOrUpdate(arr, obj) {
+            const index = arr.findIndex((e) => e.id === obj.id);
+            if (index === -1) {
+                arr.push(obj);
+            } else {
+                arr[index] = obj;
+            }
+        },
+        removeItemAll(arr, value) {
+            let i = 0;
+            while (i < arr.length) {
+                if (arr[i] === value) {
+                    arr.splice(i, 1);
+                } else {
+                    ++i;
+                }
+            }
+            return arr;
+        },
+        removeItemByIdAll(arr, value) {
+            let i = 0;
+            while (i < arr.length) {
+                if (arr[i].id === value.id) {
+                    arr.splice(i, 1);
+                } else {
+                    ++i;
+                }
+            }
+            return arr;
+        },
+    },
+    object: {
+        // http://youmightnotneedjquery.com/#deep_extend
+        extend(object, ext) {
+            ext = ext || {};
+            for (let i = 1; i < object.length; i++) {
+                let obj = object[i];
+                if (!obj) continue;
+                for (let key in obj) {
+                    if (obj.hasOwnProperty(key)) {
+                        if (typeof obj[key] === "object") {
+                            if (obj[key] instanceof Array)
+                                ext[key] = obj[key].slice(0);
+                            else
+                                ext[key] = this.extend(ext[key], obj[key]);
+                        } else
+                            ext[key] = obj[key];
+                    }
+                }
+            }
+            return ext;
+        },
+        isEmptyObj(obj) {
+            return obj !== undefined && Object.keys(obj).length > 0;
+        },
+    },
+    validators: {
+        isEmail(input) {
+            const re = /\S+@\S+\.\S+/;
+            return re.test(input);
+        },
+    },
+    getRandomInt(min, max) {
+        min = Math.ceil(min);
+        max = Math.floor(max);
+        return Math.floor(Math.random() * (max - min + 1)) + min;
+    },
+    isInternetExplorer() {
+        const ua = navigator.userAgent;
+        return ua.indexOf("MSIE") > -1 || ua.indexOf("Trident") > -1;
+    },
+    toReadableDateString(date) {
+        date.setMinutes(date.getMinutes() - date.getTimezoneOffset());
+        return date.toLocaleString("nb-NO");
+    },
+    toReadableBytes(bytes) {
+        const s = ["bytes", "kB", "MB", "GB", "TB", "PB"];
+        const e = Math.floor(Math.log(bytes) / Math.log(1024));
+        return (bytes / Math.pow(1024, e)).toFixed(2) + " " + s[e];
+    },
+    toReadablePriceSuffix(suffix) {
+        switch (suffix) {
+            case 0:
+                return ",-";
+            case 1:
+                return ",- kg";
+            case 2:
+                return ",- stk";
+        }
+    },
+    setSessionStorageJSON(key, object) {
+        sessionStorage.setItem(key, JSON.stringify(object));
+    },
+    getSessionStorageJSON(key) {
+        const dataString = sessionStorage.getItem(key);
+        if (dataString === null) return undefined;
+        return JSON.parse(dataString);
+    },
+    setLocalStorageJSON(key, object) {
+        localStorage.setItem(key, JSON.stringify(object));
+    },
+    getLocalStorageJSON(key) {
+        const dataString = localStorage.getItem(key);
+        if (dataString === null) return undefined;
+        return JSON.parse(dataString);
+    },
+    handleError: (httpResult, fallback) => {
+        if (httpResult.headers !== undefined && httpResult.headers.get("ContentType") === "application/json") {
+            httpResult.json().then(error => {
+                console.error(error);
+                toaster.errorObj(utilites.errorOrDefault(error, fallback));
+            });
+        } else {
+            toaster.errorObj(fallback);
+        }
+    },
+    getOrderStatusName: (status) => {
+        switch (status) {
+            case 0:
+                return "Pågående";
+            case 1:
+                return "Kansellert";
+            case 2:
+                return "Feilet";
+            case 3:
+                return "Fullført";
+            case 4:
+                return "Venter på faktura";
+            case 5:
+                return "Venter på vipps";
+            default:
+                return "Ukjent";
+        }
+    },
+    getOrderPaymentName: (status) => {
+        switch (status) {
+            case 0:
+                return "Vipps";
+            case 1:
+                return "Faktura på mail";
+            default:
+                return "Ukjent";
+        }
+    },
+    errorOrDefault: (res, fallback) => {
+        let title;
+        let message;
+
+        if (res.title) title = res.title;
+        else if (fallback.title) title = fallback.title;
+        else title = messages.unknownError.title;
+
+        if (res.message) message = res.message;
+        else if (fallback.message) message = fallback.message;
+        else message = messages.unknownError.message;
+
+        return {
+            title,
+            message,
+        };
+    },
+    // https://stackoverflow.com/a/15757499/11961742
+    resolveReferences(json) {
+        if (typeof json === "string")
+            json = JSON.parse(json);
+
+        const byid = {}, // all objects by id
+            refs = []; // references to objects that could not be resolved
+        json = (function recurse(obj, prop, parent) {
+            if (typeof obj !== "object" || !obj) // a primitive value
+                return obj;
+            if (Object.prototype.toString.call(obj) === "[object Array]") {
+                for (let i = 0; i < obj.length; i++) {
+                    // check also if the array element is not a primitive value
+                    if (typeof obj[i] !== "object" || !obj[i]) {// a primitive value
+                        continue;
+                    } else if ("$ref" in obj[i]) {
+                        obj[i] = recurse(obj[i], i, obj);
+                    } else {
+                        obj[i] = recurse(obj[i], prop, obj);
+                    }
+                }
+                return obj;
+            }
+            if ("$ref" in obj) { // a reference
+                let ref = obj.$ref;
+                if (ref in byid)
+                    return byid[ref];
+                // else we have to make it lazy:
+                refs.push([parent, prop, ref]);
+                return;
+            } else if ("$id" in obj) {
+                let id = obj.$id;
+                delete obj.$id;
+                if ("$values" in obj) // an array
+                    obj = obj.$values.map(recurse);
+                else // a plain object
+                    for (let prop in obj)
+                        obj[prop] = recurse(obj[prop], prop, obj);
+                byid[id] = obj;
+            }
+            return obj;
+        })(json); // run it!
+
+        for (let i = 0; i < refs.length; i++) { // resolve previously unknown references
+            let ref = refs[i];
+            ref[0][ref[1]] = byid[ref[2]];
+            // Notice that this throws if you put in a reference at top-level
+        }
+        return json;
+    },
+};