ui-soxo-bootstrap-core 2.4.24

package/core/lib/utils/common/common.utils.js

@@ -0,0 +1,123 @@
+/*
+Implements utility functions to be used across project
+*/
+
+/*eslint no-useless-escape:"off",eqeqeq: "off"*/
+import moment from 'moment';
+
+export function IsObjectHaveKeys(obj) {
+  return obj && typeof obj == 'object' && Object.keys(obj).length;
+}
+
+export function capitalizeSentence(sentence) {
+  const words = sentence.split(' ');
+
+  return words
+    .map((word) => {
+      return word[0].toUpperCase() + word.substring(1);
+    })
+    .join(' ');
+}
+
+// export function capitalizeStrings(str) {
+//     // Split the string at all space ccaracters
+//     return str.trim().split(' ')
+//         // get rid of any extra spaces using trim
+//         .map(a => a.trim())
+//         // Convert first char to upper case for each word
+//         .map(a => a[0].toUpperCase() + a.substring(1).toLowerCase())
+//         // Join all the strings back together
+//         .join(" ")
+// }
+
+export function capitalizeStrings(str) {
+  return str;
+}
+
+export function getFormattedDateAndTime(val) {
+  var time = [];
+  var year = moment.duration(val).years();
+  var month = moment.duration(val).months();
+  var days = moment.duration(val).days();
+  var hour = moment.duration(val).hours();
+  var min = moment.duration(val).minutes();
+  if (year > 0) {
+    time.push(year + '  Years' + '  ');
+  }
+  if (month > 0) {
+    time.push(month + '  Months' + '  ');
+  }
+  if (days > 0) {
+    time.push(days + '  Days' + '  ');
+  }
+  if (hour > 0) {
+    time.push(hour + '  Hours' + '  ');
+  }
+  if (min > 0) {
+    time.push(min + '  Minutes' + '  ');
+  }
+  time = [].concat(...time);
+  return time;
+}
+
+/**
+ * Function converts bytes to array
+ *
+ * @param {*} bytes
+ * @returns
+ */
+export function ConvertBytesToArray(bytes) {
+  var bytearray = Object.keys(bytes);
+
+  var arrayelement = Object.values(bytes);
+
+  var uint8Array = new Uint8Array(bytearray.length);
+
+  for (var i = 0; i < uint8Array.length; i++) {
+    uint8Array[i] = arrayelement[i];
+  }
+
+  for (var i = 0; i < bytearray; i++) {
+    var ascii = arrayelement.charCodeAt(i);
+    uint8Array[i] = ascii;
+  }
+
+  return uint8Array;
+}
+
+/**
+ * Check license status and return validity + warnings.
+ *
+ * @param {string|Date} expiryDate - License expiration date.
+ * @returns {{ valid: boolean, daysLeft: number, message: string|null, level: "error"|"warning"|null }}
+ */
+
+export const checkLicenseStatus = (expiryDate) => {
+  const expiry = new Date(expiryDate);
+
+  if (isNaN(expiry)) {
+    return { valid: false, daysLeft: 0, message: 'Invalid license date', level: 'error' };
+  }
+
+  // Normalize both dates to midnight
+  expiry.setHours(0, 0, 0, 0);
+  const today = new Date();
+  today.setHours(0, 0, 0, 0);
+
+  const msDiff = expiry.getTime() - today.getTime();
+  const daysLeft = Math.ceil(msDiff / (1000 * 60 * 60 * 24));
+
+  if (daysLeft < 0) {
+    return { valid: false, daysLeft, message: 'Your license has expired. Please contact support.', level: 'error' };
+  }
+
+  if (daysLeft <= 7) {
+    return { valid: true, daysLeft, message: `Your license will expire in ${daysLeft} day(s)`, level: 'error' };
+  }
+
+  if (daysLeft <= 30) {
+    return { valid: true, daysLeft, message: `License will expire in ${daysLeft} day(s)`, level: 'warning' };
+  }
+
+  return { valid: true, daysLeft, message: null, level: null };
+};

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

@@ -0,0 +1,30 @@
+## Usage
+
+To use Common Utils in your project, simply import the needed functions:
+
+### capitalizeSentence
+
+The capitalizeSentence function takes a string as input and capitalizes the first letter of each sentence in the string. For example:
+
+```sh
+
+
+```
+
+### capitalizeStrings
+
+The capitalizeStrings function takes an array of strings as input and capitalizes the first letter of each string in the array. For example:
+
+```sh
+
+
+```
+
+### convertBytesToArray
+
+The convertBytesToArray function takes a byte array as input and converts it into an array of integers. For example:
+
+```sh
+
+
+```

package/core/lib/utils/date/date.utils.js

@@ -0,0 +1,295 @@
+/**
+ * All the date related activities should happen here
+ */
+
+import moment from "moment-timezone";
+
+import { Timestamp } from "firebase/firestore";
+
+/**
+ *
+ */
+
+let dateFormat = "DD/MM/YYYY";
+
+let timeFormat = " HH:mm DD/MM/YYYY";
+
+let hourFormat = "HH:mm a";
+
+let timezone = process.env.REACT_APP_TIMEZONE;
+
+let datetimeFormat = "YYYY-MM-DD HH:mm:ss";
+
+export default class DateUtils {
+  /**
+   *
+   *
+   * @param {*} branchTimezone
+   */
+  static setTimezone = (branchTimezone) => {
+    timezone = branchTimezone;
+  };
+
+  static getDate = (unix) => {
+    return moment(unix).format("DD/MM/YYYY");
+  };
+
+  /**
+   * Get the timestamp value
+   *
+   * @returns
+   */
+  static getTimestampValue = (value̦) => {
+    return moment(value̦).valueOf();
+  };
+
+  static getFirebaseDate = (value) => {
+    return moment(value, "DD/MM/YYYY HH:mm a").toDate();
+  };
+
+  static displayFirestoreTime = (value, format) => {
+    if (value) {
+      return moment(value.toDate()).format(format || timeFormat);
+    } else {
+      return null;
+    }
+  };
+
+  /**
+   *
+   *
+   * ASDHI
+   */
+  static getFirebaseTimestamp = (value) => {
+    if (moment.isMoment(value)) {
+      let unix = moment(value).valueOf();
+
+      return new Timestamp(unix / 1000, 1000);
+    } else {
+      let unix = moment(value).valueOf();
+
+      //let unix = moment(value, 'DD/MM/YYYY HH:mm a').valueOf();
+
+      return new Timestamp(unix / 1000, 1000);
+    }
+  };
+
+  /**
+   * Get the firebase time
+   *
+   * @returns
+   */
+  static getTime = () => {
+    return moment().valueOf();
+  };
+
+  /**
+   * Gte formatted date in format YYYY-MM-DD HH:mm
+   *
+   * @param {*} time
+   * @returns
+   */
+  static getFormattedTimeDate = (time) => {
+    return moment(time).format(datetimeFormat);
+  };
+
+  /**
+   * Get formatted date in format YYYY-MM-DD HH:mm in asia/calcutta timezone
+   *
+   * @param {*} time
+   * @returns
+   */
+  static getFormattedTimeTz = (time) => {
+    return moment.tz(time, "Asia/Calcutta").format("YYYY-MM-DD HH:mm:ss");
+  };
+
+  /**
+   *
+   */
+  static getStartOfDay = () => {
+    return moment().startOf("day");
+  };
+
+  /**
+   * Get 7 days from today
+   */
+  static getEndOfDay = () => {
+    return moment().endOf("day");
+  };
+
+  /**
+   * Get 7 days from today
+   */
+  static getEndOfWeek = () => {
+    return moment().endOf("week");
+  };
+
+  /**
+   *
+   *
+   * @param {*} time
+   * @returns
+   */
+  static getFormattedTime = (time) => {
+    return moment(time).format(timeFormat);
+  };
+
+  /**
+   *
+   *
+   * @param {*} time
+   * @returns
+   */
+  static getDisplayTime = (time) => {
+    return moment.tz(time, timezone).format(timeFormat);
+  };
+
+  static today = () => {
+    return moment.tz(timezone).valueOf();
+  };
+
+  static time = () => {
+    return {
+      current: moment.tz(timezone).valueOf(),
+      present: moment.tz().valueOf(),
+      notimezone: moment().valueOf(),
+    };
+  };
+
+  static getDuration = (start, end) => {
+    var duration = moment.duration(end.diff(start));
+
+    return duration.asMinutes().toFixed(2);
+  };
+
+  static getPastTime = (start) => {
+    var duration = moment.duration(moment().diff(start));
+
+    return duration.asMinutes();
+  };
+
+  static getCreation = (field) => {
+    let creation = {
+      [field + "_at"]: moment.tz(timezone).format("DD/MM/YYYY HH:mm"),
+      [field + "_date"]: moment.tz(timezone).startOf("day").valueOf(),
+      [field + "_time"]: moment.tz(timezone).valueOf(),
+    };
+
+    return {
+      ...creation,
+    };
+  };
+
+  /**
+   * From Firebase Timestamp
+   *
+   * @param {*} param0
+   * @returns
+   */
+  static fromFirebaseMoment = (time) => {
+    let dt = time.toDate();
+
+    return moment(dt);
+    // return moment(time).tz(timezone).format(dateFormat) + ' ' + appointment_time
+  };
+
+  /**
+   * From Firebase Timestamp
+   *
+   * @param {*} param0
+   * @returns
+   */
+  static fromFirebaseTime = ({ time }) => {
+    let dt = time.toDate();
+
+    return moment(dt).format("DD/MM/YYYY HH:mm a");
+    // return moment(time).tz(timezone).format(dateFormat) + ' ' + appointment_time
+  };
+
+  /**
+   *
+   * @param {*} param0
+   * @returns
+   */
+  static appointmentTime = ({ appointment_date, appointment_time }) => {
+    return (
+      moment(appointment_date).tz(timezone).format(dateFormat) +
+      " " +
+      appointment_time
+    );
+  };
+
+  static formatDate = (value, format) => {
+    return moment(value)
+      .tz(timezone)
+      .format(format || dateFormat);
+  };
+
+  /**
+   *
+   * @param {*} value
+   * @returns
+   */
+  static formatTime = (value) => {
+    return moment.tz(value, timezone).format(hourFormat);
+  };
+
+  /**
+   *
+   * @param {*} value
+   * @returns
+   */
+  static returnTime = (value) => {
+    return moment(value).format(hourFormat);
+  };
+
+  static surgeTime = (time) => {
+    return moment(time, "YYYY-MM-DDTHH:mm:ss.SSSSZ")
+      .utc()
+      .format("DD/MM/YYYY HH:mm a");
+  };
+
+  /**
+   * Return the moment object of the integer , Usually used for datepicker
+   *
+   * @param {*} time
+   * @returns
+   */
+  static getMomentObject = (time) => {
+    return moment(time, timezone);
+  };
+
+  /**
+   *
+   */
+  static isBefore = (date1, date2) => {
+    return moment(date1).isBefore(date2);
+  };
+
+  /**
+   *
+   */
+  static isAfter = (date1, date2) => {
+    return moment(date1).isBefore(date2);
+  };
+
+  /**
+   * Return the moment object of the integer , Usually used for datepicker
+   *
+   * @param {*} time
+   * @returns
+   */
+  static getMomentInFormat = (time, format) => {
+    return moment(time, format);
+  };
+
+  /**
+   * Moment
+   *
+   * @param {*} time
+   * @returns
+   */
+  static getMoment = (time = null) => {
+    return moment();
+  };
+}

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

@@ -0,0 +1,2 @@
+## Usage
+

package/core/lib/utils/firebase.support.utils.js

@@ -0,0 +1,99 @@
+import moment from 'moment';
+
+let content = {};
+
+const Store = {};
+let MemoryStore = GetItem('memoryStore') || {};
+
+
+/**
+ * Sets item in localStorage under 'content' keyword
+ * @param  {string} key
+ * @param  {any} payload 
+ */
+export function SetItem(key, payload) {
+    // let convertedPayload = typeof payload == 'string' ? payload : JSON.stringify(payload);
+    content[key] = payload;
+    localStorage.content = JSON.stringify(content);
+}
+
+/**
+ * Returns data for particular key
+ * @param  {string} key 
+ * @param  {boolean} nonVolatile - (optional)
+ */
+export function GetItem(key, nonVolatile = false) {
+    if (!key) {
+        return null;
+    }
+
+    if (nonVolatile) {
+        return nonVolatile[key];
+    }
+    return content[key];
+
+}
+
+export function GetTime({ dateTime, format } = {}) {
+    let dt = moment();
+    if (dateTime) {
+        if (typeof dateTime == 'string') {
+            dt = new Date(dateTime.replace(' ', 'T'));
+        } else {
+            dt = new Date(dateTime);
+        }
+    }
+
+    return moment(dt).format(format || 'YYYY-MM-DD HH:mm:ss');
+}
+
+/*
+ * Converts a string to a bool.
+ * This conversion will:
+ *
+ *  - match 'true', 'on', or '1' as true.
+ *  - ignore all white-space padding
+ *  - ignore capitalization (case).
+ *
+ * '  tRue  ','ON', and '1   ' will all evaluate as true.
+ */
+export function StrToBool(s) {
+    // will match one and only one of the string 'true','1', or 'on' rerardless
+    // of capitalization and regardless off surrounding white-space.
+    //
+    const regex = /^\s*(true|1|on)\s*$/i;
+
+    return regex.test(s);
+}
+
+/**
+ * Event Broadcaster method
+ * Event can be broadcasted without storing into state or temporarily
+ * 
+ * Expects eventName and data to be broadcasted
+ * 
+ * @param  {string} {eventName - unique identifier of event
+ * @param  {any} data - to be broadcasted
+ * @param  {any} objParams(optional) - extra tag to check if event is already subscribed 
+ * @param  {boolean} isMemoryStore(optional)=false - if set to true, events will be persisted even after current session(for this to work, initialisation of localstorage util is required)
+ * @param  {boolean} isTemp(optional)=false - determines if event is to be broadcasted only one time
+ * @param  {boolean} dontTransmit(optional)=false - event will be stored with the data but wont be broadcasted immediately after update
+ */
+export function StoreEvent({ eventName, data, objParams, isMemoryStore = false, isTemp = false, dontTransmit = false }) {
+    // new Promise((resolve, reject) => {
+    const eventDetail = { eventName, data, objParams };
+    if (!isTemp) { // temporary broadcastings needn't to be stored
+        if (!isMemoryStore) {
+            Store[eventName] = eventDetail;
+        } else {
+            MemoryStore = GetItem('memoryStore') || {};
+            MemoryStore[eventName] = eventDetail;
+            SetItem('memoryStore', MemoryStore);
+        }
+    }
+
+    if (!dontTransmit) {
+        // TransmitToAllEvent({ eventDetail, isMemoryStore });
+    }
+    // });
+}