ui-soxo-bootstrap-core 2.4.24

package/core/lib/utils/location/location.utils.js

@@ -0,0 +1,137 @@
+/**************************************************
+ * Implements Location service same as angular have
+ *************************************************/
+
+import { IsObjectHaveKeys } from '../common/common.utils';
+
+/**
+ * takes search string and converts to corresponding object
+ * @param  {string} searchString=''
+ * e.x. ?query=menu_id=5 returns { menu_id: "5" }
+ */
+export function GenerateObjectFromUrlParams(searchString) {
+    if (searchString) {
+        return (searchString).replace(/(^\?)/, '').split("&").map(function (n) { return n = n.split(/=(.+)/), this[n[0]] = n[1], this }.bind({}))[0];
+    } else {
+        return {};
+    }
+}
+
+export function SerializeObj(obj) {
+    const queryString = Object.entries(obj).map(i => [i[0], encodeURIComponent(i[1])].join('=')).join('&');
+    if (queryString) {
+        return `?${queryString}`
+    }
+}
+
+export function GetUrlParams(props) {
+    return {
+        queryString: Location.search(),
+        params: props.match.params
+    }
+}
+
+export class Location {
+    // historyFetchMethod;
+
+    static getHistoryMethod(method) {
+        this.historyFetchMethod = method;
+    }
+
+    /**
+     * used to get and set query strings
+     * if obj is empty, works as getter, else as setter
+     * @param  {object} obj - object params to be set as query param
+     * @param  {boolean} reset=false}={} - if true, overrides existing query else extend previous query
+     */
+    static search(obj, { reset = false, method = 'replace' } = {}) {
+        const location = window.location;
+        let hash = window.location.hash.replace('#', '');
+        let urlParams = GenerateObjectFromUrlParams(decodeURIComponent(location.search))
+
+        if (hash) {
+            urlParams = urlParams[hash] ? JSON.parse(urlParams[hash]) : {};
+        }
+        if (!obj) {
+            hash = window.location.hash.replace('#', '');
+            return urlParams;
+        }
+
+        const { history: History } = this.historyFetchMethod();
+        const finalObj = {};
+
+        Object.keys(obj).forEach((key) => {
+            if (obj[key] == null && urlParams[key]) { // if any attribute is null, will remove from existing query
+                delete urlParams[key];
+            } else {
+                finalObj[key] = obj[key];
+            }
+        });
+
+        urlParams = reset ? { ...{}, ...finalObj } : { ...urlParams, ...finalObj };
+
+        if (!Object.keys(urlParams).length || (!Object.keys(finalObj).length)) {
+            History[method](location.pathname);
+            return;
+        }
+        if (History) {
+            let obj = {};
+            if (hash) {
+                obj[hash] = JSON.stringify(urlParams);
+            } else {
+                obj = urlParams;
+            }
+            let queryUrl = SerializeObj(obj);
+            if (hash) {
+                queryUrl = queryUrl + '#' + hash;
+            }
+            History[method](queryUrl);
+        }
+    }
+
+    /**
+     * used for navigating to different routes
+     * @param  {string} {url}
+     * @param  {string} {method} - used to select method for navigation, can be push, goBack (for pop operation), replace
+     */
+    static navigate({ url, method = 'push', queryParam }, e = {}) {
+        if (IsObjectHaveKeys(queryParam)) {
+            url += SerializeObj(queryParam);
+        }
+        const { history: History } = this.historyFetchMethod();
+
+        if (method === 'push' && e && (e.metaKey || e.ctrlKey)) {
+            var win = window.open(url, '_blank');
+            win.focus();
+            return;
+        }
+        History[method](url);
+    }
+
+    static back() {
+        if (window.history.length > 2) {
+            // if history is not empty, go back:
+            this.navigate({ method: 'goBack' });
+        } else {
+            // go home:
+            this.navigate({ method: 'push', url: '/' });
+        }
+    }
+
+    /**
+     * used for navigating to specified location
+     * @param  {string} {url}
+     * @param  {string} {method} - used to select method for navigation, can be push, goBack to specified scene
+     */
+    static backByLength(n) {
+        n = -(n || 1);
+        if (window.history.length > 2) {
+            // if history is not empty, go back:
+            this.navigate({ url: n, method: 'go' });
+        } else {
+            // go home:
+            this.navigate({ method: 'push', url: '/' });
+        }
+    }
+}
+

package/core/lib/utils/location/readme.md

@@ -0,0 +1,18 @@
+## Usage
+
+Location Utils is a JavaScript library for working with geolocation. It provides a set of functions for getting and manipulating geolocation data, as well as for calculating distances between locations.
+
+To use Location Utils in your JavaScript code, you need to require it:
+
+
+### Geolocation
+
+The following functions are available for working with geolocation:
+
+● getLocation(): Returns a Promise that resolves with the user's current location.<br>
+● getDistance(from, to): Calculates the distance between two locations in kilometers. The from and to parameters should be objects with latitude and longitude properties.<br><br>
+Here is an example of how to use these functions:
+
+```sh
+
+```

package/core/lib/utils/modal.utils.js

@@ -0,0 +1,16 @@
+
+module.exports = {
+    _currentGlobalLoader: null,
+    registerModal: function (ref) {
+        this._currentGlobalLoader = ref;
+    },
+    openModal: function ({ ...args }) {
+        if (this._currentGlobalLoader) {
+            this._currentGlobalLoader.openModal({ ...args });
+        }
+    },
+    closeModal: function ({ ...args }) {
+        this._currentGlobalLoader.closeModal({ ...args });
+    }
+    
+}

package/core/lib/utils/notification.utils.js

@@ -0,0 +1,35 @@
+
+
+
+import React from "react";
+
+
+import { message } from 'antd';
+
+
+export default class Notification {
+
+
+    /**
+     * Trigger a success message
+     * 
+     * @param {*} message 
+     */
+    static success = (text) => {
+
+        message.success(text)
+
+    }
+
+    /**
+     * Trigger a notification of type with message
+     * 
+     * @param {*} param0 
+     */
+    static trigger = ({ type, text }) => {
+
+        message[type](text);
+    }
+
+
+}

package/core/lib/utils/pwa/pwa.utils.js

@@ -0,0 +1,88 @@
+
+// import { StoreEvent } from 'state-manager-utility';
+// import { GetCookie } from './cookie.utils';
+// import GAService from './googleAnalytic.service';
+
+import { message } from 'antd';
+
+
+var deferredPrompt;
+let promptAllowed = false;
+
+function ListenA2HSPrompt() {
+    window.addEventListener('beforeinstallprompt', function (e) {
+        // Prevent Chrome 67 and earlier from automatically showing the prompt
+        e.preventDefault();
+        // Stash the event so it can be triggered later.
+        deferredPrompt = e;
+        // track how many users were shown the a2hs popup
+        // GAService.trackNumberOfTimesA2HSPopupWasShown(true)
+
+
+        if (!promptAllowed) {
+            promptAllowed = true;
+            // StoreEvent({ eventName: 'canShowA2HSBanner', data: promptAllowed });
+        }
+
+    });
+}
+
+ListenA2HSPrompt();
+
+/**
+ * Returns boolean value to convey if A2HS can be prompted
+ */
+export function CanShowPrompt() {
+    return true;
+    // const dontShowAddAppNotification = GetCookie('dontShowAddAppNotification');
+    // if (dontShowAddAppNotification) {
+    //     return false;
+    // }
+    // else {
+    //     return promptAllowed;
+    // }
+
+}
+
+
+/* displays native A2HS prompt & stores results */
+export function TriggerNativePrompt() {
+
+    if (!deferredPrompt.prompt) {
+
+        message.info('Not installed well');
+
+
+    } else {
+
+        return deferredPrompt.prompt()
+            .then(function (evt) {
+                // Wait for the user to respond to the prompt
+                return deferredPrompt.userChoice;
+
+            })
+            .then(function (choiceResult) {
+                if (choiceResult.outcome === "accepted") {
+                    promptAllowed = false;
+                    // StoreEvent({ eventName: 'canShowA2HSBanner', data: promptAllowed });
+                    // alert("User accepted the A2HS prompt, Please pass this info to GA");
+                    // @todo can take some action based on user choice
+                    // track how many users added PWA to home screen
+                    // GAService.trackNumberOfTimesUsersAddedPWAToHomeScreen(true)
+                } else {
+                    // alert("User dismissed the A2HS prompt, Please pass this info to GA");
+                    // @todo can take some action based on user choice
+                }
+                if (typeof window.ga == 'function') {
+                    window.ga('send', 'event', 'A2H', choiceResult.outcome);
+                }
+            })
+            .catch(function (err) {
+
+                alert(err.message);
+
+
+            });
+
+    }
+}

package/core/lib/utils/script.utils.js

@@ -0,0 +1,235 @@
+
+// import './injectScript.utils.css';
+// import $ from 'jquery';
+
+import { message } from "antd";
+// import { Content } from "antd/lib/layout/layout";
+
+// import SCRIPT_TYPE from './../../Constants/scriptType.constants';
+
+// import { IsUndefined } from 'common-js-util';
+
+/**
+ * Executes script in the context of data
+ * @param  {object} {data
+ * @param  {array} script}
+ */
+
+import * as Utils from './../utils'
+
+// let baseModels = require('./../models/')
+
+let models = {
+    // ...baseModels,
+    // ...CustomModels
+}
+
+
+/**
+ * In case we have multiple scripts to be executed 
+ * we prepare and create the function to execute it
+ * 
+ * @param {*} values 
+ * @returns 
+ */
+export async function prepareAndExecuteScript({
+    field,
+    values,
+    response,
+    script,
+    formUtils
+}) {
+
+    var scripts = [];
+
+    if (script) {
+        scripts.push(script);
+    }
+
+    if (script) {
+
+        return await ExecuteScript({
+            formContent: values,
+            scripts,
+            context: {
+                ...models,
+                ...Utils,
+
+                // Form Utils is to be used to control the active form
+                formUtils,
+            },
+            contextName: 'models',
+            executionType: '',
+            response
+        });
+
+    } else {
+
+        return new Promise(function (resolve, reject) {
+            resolve('start of new Promise');
+        });
+    }
+}
+
+
+export function ExecuteScript({
+    formContent,
+    scripts,
+    context,
+    contextName = 'form',
+    executionType = '',
+    response,
+
+}) {
+
+    if (!Array.isArray(scripts) || !scripts.length) {
+        return formContent;
+    }
+
+    let script = '';
+
+    for (let i in scripts) {
+        script = `${script}
+        ${PrefixScript(scripts[i], executionType)}`;
+    }
+
+    // methods({ formContent, context, contextName, script, scripts });
+    // methods.bind({ a: 'test' })({ formContent, context, contextName, script, scripts, executionType });
+    // return methods.bind({ a: 'test' })({ formContent, context, contextName, script, scripts, executionType });
+
+    // # Note
+    /**
+     * Using any number of variables as argument , Should use Function to have promises
+     */
+
+    let fn = script
+
+    let self = { formContent, context, contextName, script, scripts, executionType }
+
+    let func = new Function('formContent', 'models', 'response', `${fn}`);
+
+    return func(formContent, context, response);
+}
+
+// @TODO change formContent name later as it was built for form execution but later being used in many place
+function methods({ formContent, context, contextName, script, scripts, executionType }) {
+
+    // function methods({ formContent, FormUtils: form }) {
+
+    try {
+
+        window[contextName] = context; // as value of 'this' is getting undefined, using window 
+
+        // if (SCRIPT_TYPE.ON_SUBMIT != executionType) {
+        // window[contextName].setForm(formContent);
+        // 
+        // }
+
+        return eval(script);
+
+        // formContent = window[contextName].getForm(true);
+        // window[contextName].updateForm();
+        // delete window[contextName];
+
+        RemoveError(scripts);
+
+    } catch (err) {
+
+        message.error(err.message);
+
+        // InjectError(scripts, err);
+        console.log("%c🍺 Not valid Script", "color: #49ba8e; font-size:20px;");
+        console.log("%cError =======> ", "color: '#49ba8e'; font-size:14px;");
+        console.error(err);
+        console.log("%cScript ======> ", "color: blue; font-size:14px;");
+        console.log(scripts);
+        // console.log(scripts[i].name + ' - ' + err);
+    }
+};
+
+/**
+* appends error message if found any error while executing scripts
+* @param  {object} script
+* @param  {string} message - text message to be displayed
+*/
+export function InjectError(script, message) {
+    var pageContent = document.getElementsByClassName('right-section'); // main page element
+    var errorElemenet = document.createElement("div"); // new error element to be injected at top
+    errorElemenet.classList.add("alert");
+    errorElemenet.classList.add("alert-danger");
+    errorElemenet.setAttribute("id", "script-" + script.id);
+    errorElemenet.innerHTML = "<strong> " + script.name + " - " + message + " </strong>";
+
+    var crossSymbol = document.createElement("a");
+    crossSymbol.classList.add("close");
+    crossSymbol.innerHTML = "&times;";
+    errorElemenet.appendChild(crossSymbol);
+
+    pageContent.insertBefore(errorElemenet, pageContent.firstChild);
+};
+
+/**
+* appends error message if found any error while executing scripts
+* @param  {object} script
+* @param  {string} message - text message to be displayed
+*/
+export function InjectMessage(message, type, time = 4000) {
+    var pageContent = document.getElementById('parent-admin-element'); // main page element
+    var errorElemenet = document.createElement("div"); // new error element to be injected at top
+    errorElemenet.classList.add("alert");
+    if (type === "success") {
+        errorElemenet.classList.add("alert-success");
+    }
+    if (type === "error") {
+        errorElemenet.classList.add("alert-danger");
+    }
+    if (type === "info") {
+        errorElemenet.classList.add("alert-info");
+    }
+    if (type === "warning") {
+        errorElemenet.classList.add("alert-warning");
+    }
+    errorElemenet.innerHTML = "<strong>" + message + " </strong>";
+
+    window.setTimeout(function () {
+        // $(".alert").fadeTo(500, 0).slideUp(500, function () {
+        //     $(this).remove();
+        // });
+    }, time);
+
+    pageContent.insertBefore(errorElemenet, pageContent.firstChild);
+};
+
+/**
+ * removes error message element
+ * @param  {} script
+ */
+export function RemoveError(script) {
+
+    var pageContent = document.getElementById('parent-admin-element');
+
+    var errorElemenet = document.getElementById("script-" + script.id);
+
+    if (errorElemenet) {
+        pageContent.removeChild(errorElemenet);
+    }
+
+};
+
+// Prepare script for execution according to script type
+export function PrefixScript(definition, executionType) {
+    // if (definition.activity_type_id == SCRIPT_TYPE.ON_CHANGE) {
+    // return `form.onChange({ column: '${definition.column}', callback: (value, column, event)=> { ${definition.script}} })`;
+    // }
+    // if (IsUndefined(executionType) || executionType == definition.activity_type_id) {
+    //     return definition.script;
+    // }
+
+    return definition;
+
+    // return '';
+
+}
+
+
+

package/core/lib/utils/setting.utils.js

@@ -0,0 +1,69 @@
+
+import React, { Component } from 'react';
+
+// import { ModalManager } from 'drivezy-web-utils/build/Utils';
+
+// import ConfigureSettings from './../Components/Configure-Settings/configureSettings.component';
+
+export default class SettingsUtil {
+
+    _currentGlobalLoader = null;
+
+    menus = [];
+
+    searchConfig = [];
+
+    static registerModal(ref) {
+
+        this._currentGlobalLoader = ref;
+    }
+
+    static openSpotlightModal() {
+        if (this._currentGlobalLoader && this._currentGlobalLoader.openSpotlightModal) {
+            this._currentGlobalLoader.openSpotlightModal();
+        }
+    }
+
+    static configureModal() {
+        // ModalManager.openModal({
+        //     headerText: "Settings",
+        //     modalBody: () => (<ConfigureSettings />),
+        // })
+    }
+
+    /**
+     * 
+     * @param {*} menus 
+     */
+    static registerMenus(menus) {
+
+        this.menus = menus;
+    }
+
+    /**
+     * 
+     * @param {*} config 
+     */
+    static setConfig(config) {
+
+        this.searchConfig = config;
+    }
+
+    /**
+     * 
+     * @param {*} config 
+     */
+    static getConfig() {
+
+        return config;
+    }
+
+
+    /**
+     * 
+     * @returns 
+     */
+    static getMenus() {
+        return this.menus;
+    }
+}

package/core/lib/utils/upload.utils.js

@@ -0,0 +1,30 @@
+// /**
+// * Upload file implementation
+// * All upload calls are made through this method
+// * @param  {object} obj - contains url, params(optional){proccessed and attached to url}, 
+// * headers(optional)
+// */
+export async function UploadUtils(url, data) {
+
+    return fetch(process.env.REACT_APP_endpoint + url, { // Your POST endpoint
+        method: 'POST',
+        headers: {
+            //   'App-Type': 313,
+            //   'App-Version': '1.0.1',
+            Authorization: 'Bearer ' + localStorage.access_token,
+            // type:'multipart/formData'
+        },
+        //   credentials: 'include',
+        body: data
+    }).then((result) => {
+
+        return result.json();
+
+    }, (error) => {
+        console.log(error);
+        return error;
+    }, (progress) => {
+        console.log(progress);
+        return progress;
+    })
+}

package/core/models/Preference/Preferences.js

@@ -0,0 +1,46 @@
+/**
+ * Preference Model
+ *
+ *
+ * 
+ *
+ */
+import React from 'react';
+
+import Base from '../base/base';
+
+import { ApiUtils } from './../../lib/'
+
+
+class Preference extends Base {
+
+    constructor() {
+        super();
+
+        this.fields = [
+            {
+                field: 'name',
+                caption: 'Name'
+            }
+        ];
+
+        // this.columns = ;
+    }
+
+    get id() {
+        return 'preferences';
+    }
+
+    get getEndpoint() {
+        return 'core-user-preferences';
+    }
+
+
+    get modelName() {
+        return `core-user-preferences`;
+    }
+
+
+}
+
+export default Preference;