@oneuptime/common 7.0.2990 → 7.0.3010

package/UI/Components/Charts/Utils/DataPoint.ts

@@ -0,0 +1,188 @@
+/// ChartDataPoint is in the format of:
+// {
+//     date: "Feb 22",
+//     SolarPanels: 2756,
+//     Inverters: 2103,
+// }
+
+import BadDataException from "../../../../Types/Exception/BadDataException";
+import ChartDataPoint from "../ChartLibrary/Types/ChartDataPoint";
+import SeriesPoints from "../Types/SeriesPoints";
+import { XAxis, XAxisAggregateType } from "../Types/XAxis/XAxis";
+import XAxisMaxMin from "../Types/XAxis/XAxisMaxMin";
+import YAxis, { YAxisPrecision } from "../Types/YAxis/YAxis";
+import XAxisUtil from "./XAxis";
+
+interface SeriesData {
+  sum: number;
+  count: number;
+  max: number;
+  min: number;
+}
+
+export default class DataPointUtil {
+  public static getChartDataPoints(data: {
+    seriesPoints: Array<SeriesPoints>;
+    xAxis: XAxis;
+    yAxis: YAxis;
+  }): Array<ChartDataPoint> {
+    const { xAxisLegend, intervals, formatter } = this.initializeXAxisData(
+      data.xAxis,
+    );
+    const arrayOfData: ChartDataPoint[] = this.initializeArrayOfData(
+      intervals,
+      xAxisLegend,
+      formatter,
+    );
+    const seriesDataMap: {
+      [key: string]: SeriesData;
+    } = this.processSeriesData(
+      data.seriesPoints,
+      arrayOfData,
+      xAxisLegend,
+      formatter,
+      data.xAxis.options.aggregateType,
+    );
+    this.formatSeriesData(
+      arrayOfData,
+      seriesDataMap,
+      data.yAxis.options.precision,
+    );
+    return arrayOfData;
+  }
+
+  private static initializeXAxisData(xAxis: XAxis): {
+    xAxisMax: XAxisMaxMin;
+    xAxisMin: XAxisMaxMin;
+    xAxisLegend: string;
+    intervals: Array<Date>;
+    formatter: (value: Date) => string;
+  } {
+    const xAxisMax: XAxisMaxMin = xAxis.options.max;
+    const xAxisMin: XAxisMaxMin = xAxis.options.min;
+    const xAxisLegend: string = xAxis.legend;
+    const intervals: Array<Date> = XAxisUtil.getPrecisionIntervals({
+      xAxisMax,
+      xAxisMin,
+    });
+    const formatter: (value: Date) => string = XAxisUtil.getFormatter({
+      xAxisMax,
+      xAxisMin,
+    });
+    return { xAxisMax, xAxisMin, xAxisLegend, intervals, formatter };
+  }
+
+  private static initializeArrayOfData(
+    intervals: Array<Date>,
+    xAxisLegend: string,
+    formatter: (value: Date) => string,
+  ): Array<ChartDataPoint> {
+    const arrayOfData: Array<ChartDataPoint> = [];
+    for (const interval of intervals) {
+      const dataPoint: ChartDataPoint = {};
+      dataPoint[xAxisLegend] = formatter(interval);
+      arrayOfData.push(dataPoint);
+    }
+    return arrayOfData;
+  }
+
+  private static processSeriesData(
+    seriesPoints: Array<SeriesPoints>,
+    arrayOfData: Array<ChartDataPoint>,
+    xAxisLegend: string,
+    formatter: (value: Date) => string,
+    aggregateType: XAxisAggregateType,
+  ): { [key: string]: SeriesData } {
+    const seriesDataMap: { [key: string]: SeriesData } = {};
+    for (const series of seriesPoints) {
+      for (const dataPoint of series.data) {
+        const date: Date = dataPoint.x;
+        const value: number = dataPoint.y;
+        const formattedDate: string = formatter(date);
+        for (const chartDataPoint of arrayOfData) {
+          if (chartDataPoint[xAxisLegend] === formattedDate) {
+            if (!seriesDataMap[series.seriesName]) {
+              seriesDataMap[series.seriesName] = {
+                sum: 0,
+                count: 0,
+                max: Number.NEGATIVE_INFINITY,
+                min: Number.POSITIVE_INFINITY,
+              };
+            }
+            seriesDataMap[series.seriesName]!.sum += value;
+            seriesDataMap[series.seriesName]!.count += 1;
+            seriesDataMap[series.seriesName]!.max = Math.max(
+              seriesDataMap[series.seriesName]!.max,
+              value,
+            );
+            seriesDataMap[series.seriesName]!.min = Math.min(
+              seriesDataMap[series.seriesName]!.min,
+              value,
+            );
+            chartDataPoint[series.seriesName] = this.calculateAggregate(
+              seriesDataMap[series.seriesName]!,
+              aggregateType,
+            );
+          }
+        }
+      }
+    }
+    return seriesDataMap;
+  }
+
+  private static calculateAggregate(
+    seriesData: SeriesData,
+    aggregateType: XAxisAggregateType,
+  ): number {
+    switch (aggregateType) {
+      case XAxisAggregateType.Average:
+        return seriesData.sum / seriesData.count;
+      case XAxisAggregateType.Sum:
+        return seriesData.sum;
+      case XAxisAggregateType.Max:
+        return seriesData.max;
+      case XAxisAggregateType.Min:
+        return seriesData.min;
+      default:
+        throw new BadDataException("Aggregate type not supported.");
+    }
+  }
+
+  private static formatSeriesData(
+    arrayOfData: Array<ChartDataPoint>,
+    seriesDataMap: { [key: string]: SeriesData },
+    yAxisPrecision: YAxisPrecision,
+  ): void {
+    for (const chartDataPoint of arrayOfData) {
+      for (const seriesName in seriesDataMap) {
+        if (
+          chartDataPoint[seriesName] &&
+          typeof chartDataPoint[seriesName] === "number"
+        ) {
+          chartDataPoint[seriesName] = this.formatValue(
+            chartDataPoint[seriesName] as number,
+            yAxisPrecision,
+          );
+        }
+      }
+    }
+  }
+
+  private static formatValue(
+    value: number,
+    yAxisPrecision: YAxisPrecision,
+  ): number {
+    switch (yAxisPrecision) {
+      case YAxisPrecision.NoDecimals:
+        return parseFloat(value.toFixed(0));
+      case YAxisPrecision.OneDecimal:
+        return parseFloat(value.toFixed(1));
+      case YAxisPrecision.TwoDecimals:
+        return parseFloat(value.toFixed(2));
+      case YAxisPrecision.ThreeDecimals:
+        return parseFloat(value.toFixed(3));
+      default:
+        throw new BadDataException("YAxis precision not supported.");
+    }
+  }
+}

package/UI/Components/Charts/Utils/XAxis.ts

@@ -0,0 +1,267 @@
+import NotImplementedException from "../../../../Types/Exception/NotImplementedException";
+import XAxisMaxMin from "../Types/XAxis/XAxisMaxMin";
+import XAxisPrecision from "../Types/XAxis/XAxisPrecision";
+
+export default class XAxisUtil {
+  public static getPrecision(data: {
+    xAxisMin: XAxisMaxMin;
+    xAxisMax: XAxisMaxMin;
+  }): XAxisPrecision {
+    if (
+      typeof data.xAxisMax === "number" ||
+      typeof data.xAxisMin === "number"
+    ) {
+      // number not yet supported.
+      throw new NotImplementedException();
+    }
+
+    const startDate: Date = data.xAxisMin as Date;
+    const endDate: Date = data.xAxisMax as Date;
+
+    const totalMilliseconds: number = endDate.getTime() - startDate.getTime();
+    const totalSeconds: number = totalMilliseconds / 1000;
+    const totalMinutes: number = totalSeconds / 60;
+    const totalHours: number = totalMinutes / 60;
+    const totalDays: number = totalHours / 24;
+    const totalWeeks: number = totalDays / 7;
+    const totalMonths: number = totalDays / 30;
+
+    if (totalSeconds <= 100) {
+      return XAxisPrecision.EVERY_SECOND;
+    }
+    if (totalSeconds <= 500) {
+      return XAxisPrecision.EVERY_FIVE_SECONDS;
+    }
+    if (totalSeconds <= 1000) {
+      return XAxisPrecision.EVERY_TEN_SECONDS;
+    }
+    if (totalSeconds <= 3000) {
+      return XAxisPrecision.EVERY_THIRTY_SECONDS;
+    }
+    if (totalMinutes <= 100) {
+      return XAxisPrecision.EVERY_MINUTE;
+    }
+    if (totalMinutes <= 500) {
+      return XAxisPrecision.EVERY_FIVE_MINUTES;
+    }
+    if (totalMinutes <= 1000) {
+      return XAxisPrecision.EVERY_TEN_MINUTES;
+    }
+    if (totalMinutes <= 3000) {
+      return XAxisPrecision.EVERY_THIRTY_MINUTES;
+    }
+    if (totalHours <= 100) {
+      return XAxisPrecision.EVERY_HOUR;
+    }
+    if (totalHours <= 200) {
+      return XAxisPrecision.EVERY_TWO_HOURS;
+    }
+    if (totalHours <= 300) {
+      return XAxisPrecision.EVERY_THREE_HOURS;
+    }
+    if (totalHours <= 600) {
+      return XAxisPrecision.EVERY_SIX_HOURS;
+    }
+    if (totalHours <= 1200) {
+      return XAxisPrecision.EVERY_TWELVE_HOURS;
+    }
+    if (totalDays <= 100) {
+      return XAxisPrecision.EVERY_DAY;
+    }
+    if (totalDays <= 200) {
+      return XAxisPrecision.EVERY_TWO_DAYS;
+    }
+    if (totalWeeks <= 100) {
+      return XAxisPrecision.EVERY_WEEK;
+    }
+    if (totalWeeks <= 200) {
+      return XAxisPrecision.EVERY_TWO_WEEKS;
+    }
+    if (totalMonths <= 100) {
+      return XAxisPrecision.EVERY_MONTH;
+    }
+    if (totalMonths <= 200) {
+      return XAxisPrecision.EVERY_TWO_MONTHS;
+    }
+    if (totalMonths <= 300) {
+      return XAxisPrecision.EVERY_THREE_MONTHS;
+    }
+    if (totalMonths <= 600) {
+      return XAxisPrecision.EVERY_SIX_MONTHS;
+    }
+    return XAxisPrecision.EVERY_YEAR;
+  }
+
+  public static getPrecisionIntervals(data: {
+    xAxisMin: XAxisMaxMin;
+    xAxisMax: XAxisMaxMin;
+  }): Array<Date> {
+    const precision: XAxisPrecision = XAxisUtil.getPrecision(data);
+
+    if (
+      typeof data.xAxisMax === "number" ||
+      typeof data.xAxisMin === "number"
+    ) {
+      // number not yet supported.
+      throw new NotImplementedException();
+    }
+
+    const startDate: Date = new Date(data.xAxisMin as Date);
+    const endDate: Date = new Date(data.xAxisMax as Date);
+    const intervals: Array<Date> = [];
+
+    const currentDate: Date = new Date(startDate);
+
+    while (currentDate <= endDate) {
+      intervals.push(new Date(currentDate));
+
+      switch (precision) {
+        case XAxisPrecision.EVERY_SECOND:
+          currentDate.setSeconds(currentDate.getSeconds() + 1);
+          break;
+        case XAxisPrecision.EVERY_FIVE_SECONDS:
+          currentDate.setSeconds(currentDate.getSeconds() + 5);
+          break;
+        case XAxisPrecision.EVERY_TEN_SECONDS:
+          currentDate.setSeconds(currentDate.getSeconds() + 10);
+          break;
+        case XAxisPrecision.EVERY_THIRTY_SECONDS:
+          currentDate.setSeconds(currentDate.getSeconds() + 30);
+          break;
+        case XAxisPrecision.EVERY_MINUTE:
+          currentDate.setMinutes(currentDate.getMinutes() + 1);
+          break;
+        case XAxisPrecision.EVERY_FIVE_MINUTES:
+          currentDate.setMinutes(currentDate.getMinutes() + 5);
+          break;
+        case XAxisPrecision.EVERY_TEN_MINUTES:
+          currentDate.setMinutes(currentDate.getMinutes() + 10);
+          break;
+        case XAxisPrecision.EVERY_THIRTY_MINUTES:
+          currentDate.setMinutes(currentDate.getMinutes() + 30);
+          break;
+        case XAxisPrecision.EVERY_HOUR:
+          currentDate.setHours(currentDate.getHours() + 1);
+          break;
+        case XAxisPrecision.EVERY_TWO_HOURS:
+          currentDate.setHours(currentDate.getHours() + 2);
+          break;
+        case XAxisPrecision.EVERY_THREE_HOURS:
+          currentDate.setHours(currentDate.getHours() + 3);
+          break;
+        case XAxisPrecision.EVERY_SIX_HOURS:
+          currentDate.setHours(currentDate.getHours() + 6);
+          break;
+        case XAxisPrecision.EVERY_TWELVE_HOURS:
+          currentDate.setHours(currentDate.getHours() + 12);
+          break;
+        case XAxisPrecision.EVERY_DAY:
+          currentDate.setDate(currentDate.getDate() + 1);
+          break;
+        case XAxisPrecision.EVERY_TWO_DAYS:
+          currentDate.setDate(currentDate.getDate() + 2);
+          break;
+        case XAxisPrecision.EVERY_WEEK:
+          currentDate.setDate(currentDate.getDate() + 7);
+          break;
+        case XAxisPrecision.EVERY_TWO_WEEKS:
+          currentDate.setDate(currentDate.getDate() + 14);
+          break;
+        case XAxisPrecision.EVERY_MONTH:
+          currentDate.setMonth(currentDate.getMonth() + 1);
+          break;
+        case XAxisPrecision.EVERY_TWO_MONTHS:
+          currentDate.setMonth(currentDate.getMonth() + 2);
+          break;
+        case XAxisPrecision.EVERY_THREE_MONTHS:
+          currentDate.setMonth(currentDate.getMonth() + 3);
+          break;
+        case XAxisPrecision.EVERY_SIX_MONTHS:
+          currentDate.setMonth(currentDate.getMonth() + 6);
+          break;
+        case XAxisPrecision.EVERY_YEAR:
+          currentDate.setFullYear(currentDate.getFullYear() + 1);
+          break;
+      }
+    }
+
+    return intervals;
+  }
+
+  public static getFormatter(data: {
+    xAxisMin: XAxisMaxMin;
+    xAxisMax: XAxisMaxMin;
+  }): (value: Date) => string {
+    const precision: XAxisPrecision = XAxisUtil.getPrecision(data);
+
+    switch (precision) {
+      case XAxisPrecision.EVERY_SECOND:
+      case XAxisPrecision.EVERY_FIVE_SECONDS:
+      case XAxisPrecision.EVERY_TEN_SECONDS:
+      case XAxisPrecision.EVERY_THIRTY_SECONDS:
+        return (value: Date) => {
+          return value.toISOString().substring(11, 19);
+        }; // HH:mm:ss
+      case XAxisPrecision.EVERY_MINUTE:
+      case XAxisPrecision.EVERY_FIVE_MINUTES:
+      case XAxisPrecision.EVERY_TEN_MINUTES:
+      case XAxisPrecision.EVERY_THIRTY_MINUTES:
+        return (value: Date) => {
+          return value.toISOString().substring(11, 16);
+        }; // HH:mm
+      case XAxisPrecision.EVERY_HOUR:
+      case XAxisPrecision.EVERY_TWO_HOURS:
+      case XAxisPrecision.EVERY_THREE_HOURS:
+      case XAxisPrecision.EVERY_SIX_HOURS:
+      case XAxisPrecision.EVERY_TWELVE_HOURS:
+        return (value: Date) => {
+          const dateString: string = value.toISOString();
+          const day: string = dateString.substring(8, 10);
+          const month: string = value.toLocaleString("default", {
+            month: "short",
+          });
+          const hour: string = dateString.substring(11, 13);
+          return `${day} ${month}, ${hour}:00`;
+        }; // DD MMM, HH:00
+      case XAxisPrecision.EVERY_DAY:
+      case XAxisPrecision.EVERY_TWO_DAYS:
+        return (value: Date) => {
+          const dateString: string = value.toISOString();
+          const day: string = dateString.substring(8, 10);
+          const month: string = value.toLocaleString("default", {
+            month: "short",
+          });
+          return `${day} ${month}`;
+        }; // DD MMM
+      case XAxisPrecision.EVERY_WEEK:
+      case XAxisPrecision.EVERY_TWO_WEEKS:
+        return (value: Date) => {
+          const dateString: string = value.toISOString();
+          const day: string = dateString.substring(8, 10);
+          const month: string = value.toLocaleString("default", {
+            month: "short",
+          });
+          return `${day} ${month}`;
+        }; // DD MMM
+      case XAxisPrecision.EVERY_MONTH:
+      case XAxisPrecision.EVERY_TWO_MONTHS:
+      case XAxisPrecision.EVERY_THREE_MONTHS:
+      case XAxisPrecision.EVERY_SIX_MONTHS:
+        return (value: Date) => {
+          const dateString: string = value.toISOString();
+          const day: string = dateString.substring(8, 10);
+          const year: string = dateString.substring(0, 4);
+          const month: string = value.toLocaleString("default", {
+            month: "short",
+          });
+          return `${day} ${month} ${year}`;
+        }; // DD MMM
+      case XAxisPrecision.EVERY_YEAR:
+        return (value: Date) => {
+          return value.toISOString().substring(0, 4);
+        }; // YYYY
+      default:
+        throw new Error("Unsupported precision");
+    }
+  }
+}

package/UI/Components/Detail/Detail.tsx

@@ -283,7 +283,8 @@ const Detail: DetailFunction = <T extends GenericObject>(
       (field.fieldType === FieldType.HTML ||
         field.fieldType === FieldType.CSS ||
         field.fieldType === FieldType.JSON ||
-        field.fieldType === FieldType.JavaScript)
+        field.fieldType === FieldType.JavaScript ||
+        field.fieldType === FieldType.Code)
     ) {
       let codeType: CodeType = CodeType.HTML;
 
@@ -315,6 +316,10 @@ const Detail: DetailFunction = <T extends GenericObject>(
         codeType = CodeType.JavaScript;
       }
 
+      if (field.fieldType === FieldType.Code) {
+        codeType = CodeType.Text;
+      }
+
       data = (
         <CodeEditor
           type={codeType}

package/UI/Components/GanttChart/Row/Row.tsx

@@ -50,8 +50,10 @@ const Row: FunctionComponent<ComponentProps> = (
       <div
         className={`flex w-full border-b-2 border-gray-200  border-l-2 border-l-gray-400 border-r-2 border-r-gray-400`}
       >
-        <div className="flex w-1/4 border-r-2 border-gray-300">
-          <div className={`pl-${paddingCount} pt-2 pb-2 pr-2 flex`}>
+        <div className="flex w-1/4 border-r-2 border-gray-300 overflow-hidden">
+          <div
+            className={`pl-${paddingCount} pt-2 pb-2 pr-2 flex overflow-hidden`}
+          >
             <div className="w-5 h-5 ml-3 mt-1">
               {hasChildRows && (
                 <Icon

package/UI/Components/GanttChart/Row/RowLabel.tsx

@@ -11,9 +11,13 @@ const RowLabel: FunctionComponent<ComponentProps> = (
   return (
     // rectangle div with curved corners and text inside in tailwindcss
 
-    <div>
-      <div className="text-sm text-gray-600">{props.title}</div>
-      <div className="text-xs text-gray-500">{props.description}</div>
+    <div className="overflow-hidden">
+      <div className="text-sm text-gray-600 truncate overflow-hidden">
+        {props.title}
+      </div>
+      <div className="text-xs text-gray-500 truncate overflow-hidden">
+        {props.description}
+      </div>
     </div>
   );
 };

package/UI/Components/Icon/Icon.tsx

@@ -138,6 +138,14 @@ const Icon: FunctionComponent<ComponentProps> = ({
         d="m3 3 8.735 8.735m0 0a.374.374 0 1 1 .53.53m-.53-.53.53.53m0 0L21 21M14.652 9.348a3.75 3.75 0 0 1 0 5.304m2.121-7.425a6.75 6.75 0 0 1 0 9.546m2.121-11.667c3.808 3.807 3.808 9.98 0 13.788m-9.546-4.242a3.733 3.733 0 0 1-1.06-2.122m-1.061 4.243a6.75 6.75 0 0 1-1.625-6.929m-.496 9.05c-3.068-3.067-3.664-7.67-1.79-11.334M12 12h.008v.008H12V12Z"
       />,
     );
+  } else if (icon === IconProp.Archive) {
+    return getSvgWrapper(
+      <path
+        strokeLinecap="round"
+        strokeLinejoin="round"
+        d="m20.25 7.5-.625 10.632a2.25 2.25 0 0 1-2.247 2.118H6.622a2.25 2.25 0 0 1-2.247-2.118L3.75 7.5M10 11.25h4M3.375 7.5h17.25c.621 0 1.125-.504 1.125-1.125v-1.5c0-.621-.504-1.125-1.125-1.125H3.375c-.621 0-1.125.504-1.125 1.125v1.5c0 .621.504 1.125 1.125 1.125Z"
+      />,
+    );
   } else if (icon === IconProp.ShieldCheck) {
     return getSvgWrapper(
       <path
@@ -370,6 +378,14 @@ const Icon: FunctionComponent<ComponentProps> = ({
         d="M7.5 21L3 16.5m0 0L7.5 12M3 16.5h13.5m0-13.5L21 7.5m0 0L16.5 12M21 7.5H7.5"
       />,
     );
+  } else if (icon === IconProp.Unarchive) {
+    return getSvgWrapper(
+      <path
+        strokeLinecap="round"
+        strokeLinejoin="round"
+        d="m20.25 7.5-.625 10.632a2.25 2.25 0 0 1-2.247 2.118H6.622a2.25 2.25 0 0 1-2.247-2.118L3.75 7.5m6 4.125 2.25 2.25m0 0 2.25 2.25M12 13.875l2.25-2.25M12 13.875l-2.25 2.25M3.375 7.5h17.25c.621 0 1.125-.504 1.125-1.125v-1.5c0-.621-.504-1.125-1.125-1.125H3.375c-.621 0-1.125.504-1.125 1.125v1.5c0 .621.504 1.125 1.125 1.125Z"
+      />,
+    );
   } else if (icon === IconProp.JSON) {
     return getSvgWrapper(
       <path

package/UI/Components/LogsViewer/LogsViewer.tsx

@@ -239,7 +239,7 @@ const LogsViewer: FunctionComponent<ComponentProps> = (
 
           {props.logs.length === 0 && (
             <div className={`text-slate-200 courier-prime`}>
-              {props.noLogsMessage || "No logs found for this service."}
+              {props.noLogsMessage || "No logs found."}
             </div>
           )}
         </div>

package/UI/Components/Types/FieldType.ts

@@ -34,6 +34,7 @@ enum FieldType {
   Element = "Element",
   Minutes = "Minutes",
   ArrayOfText = "ArrayOfText",
+  Code = "Code",
 }
 
 export default FieldType;

package/UI/Config.ts

@@ -209,3 +209,5 @@ const getOpenTelemetryExporterOtlpHeaders: GetOpenTelemetryExporterOtlpHeadersFu
 
 export const OpenTelemetryExporterOtlpHeaders: Dictionary<string> =
   getOpenTelemetryExporterOtlpHeaders();
+
+export const DisableTelemetry: boolean = env("DISABLE_TELEMETRY") === "true";

package/UI/Utils/Telemetry.ts

@@ -1,4 +1,5 @@
 import {
+  DisableTelemetry,
   OpenTelemetryExporterOtlpEndpoint,
   OpenTelemetryExporterOtlpHeaders,
 } from "../Config";
@@ -13,18 +14,22 @@ import {
   TracerConfig,
   WebTracerProvider,
 } from "@opentelemetry/sdk-trace-web";
-import { SemanticResourceAttributes } from "@opentelemetry/semantic-conventions";
+import { ATTR_SERVICE_NAME } from "@opentelemetry/semantic-conventions";
 import URL from "Common/Types/API/URL";
 
 export default class Telemetry {
   public static init(data: { serviceName: string }): void {
+    if (DisableTelemetry) {
+      return;
+    }
+
     const hasHeaders: boolean =
       Object.keys(OpenTelemetryExporterOtlpHeaders).length > 0;
 
     if (OpenTelemetryExporterOtlpEndpoint && hasHeaders) {
       const providerConfig: TracerConfig = {
         resource: new Resource({
-          [SemanticResourceAttributes.SERVICE_NAME]: data.serviceName,
+          [ATTR_SERVICE_NAME]: data.serviceName,
         }),
       };
 

package/Utils/Crypto.ts

@@ -0,0 +1,11 @@
+import CryptoJS from "crypto-js";
+
+export default class Crypto {
+  public static getMd5Hash(text: string): string {
+    return CryptoJS.MD5(text).toString();
+  }
+
+  public static getSha256Hash(text: string): string {
+    return CryptoJS.SHA256(text).toString();
+  }
+}