@intellias/menu 1.0.0

package/helpers/GeneralHelper.ts

@@ -0,0 +1,61 @@
+import axios from "axios";
+import { Collection } from "collect.js";
+
+export function getRandomIntegerBetween(min: number, max: number): number {
+  const randomBuffer = new Uint32Array(1);
+
+  window.crypto.getRandomValues(randomBuffer);
+
+  const randomNumber = randomBuffer[0] / (0xffffffff + 1);
+
+  return Math.floor(randomNumber * (max - min + 1)) + min;
+}
+
+export function sortObjectByKeysCaseInsensitive(
+  object: unknown
+): Record<string, unknown> {
+  return (object instanceof Collection ? object : Object.keys(object))
+    .sort((a, b) => a.localeCompare(b))
+    .reduce((sorted, key) => {
+      sorted[key] = object[key];
+      return sorted;
+    }, {});
+}
+
+export function downloadFile(filePath: string, fileName?: string): void {
+  axios({
+    url: filePath,
+    method: "GET",
+    responseType: "blob",
+  }).then((response) => {
+    const fileURL = window.URL.createObjectURL(new Blob([response.data]));
+    const fileLink = document.createElement("a");
+
+    fileLink.href = fileURL;
+    fileLink.setAttribute(
+      "download",
+      fileName || filePath.replace(/^.*[\\\/]/, "")
+    );
+    document.body.appendChild(fileLink);
+
+    fileLink.click();
+  });
+}
+
+export function postForm(url: string, data?: Record<string, string>): void {
+  const form = document.createElement("form");
+  form.method = "POST";
+  form.action = url;
+
+  Object.entries(data).forEach(([key, value]: [key: string, value: string]) => {
+    const input = document.createElement("input");
+    input.type = "hidden";
+    input.name = key;
+    input.value = value;
+    form.append(input);
+  });
+
+  document.body.appendChild(form);
+
+  form.submit();
+}

package/helpers/PublisherSubscriber.ts

@@ -0,0 +1,34 @@
+// Publisher-Subscriber pattern interface
+type Callback = (data: unknown) => void;
+type Subscriber<Event> = Map<Event, Set<Callback>>;
+
+export default abstract class PublisherSubscriber<Event> {
+  protected subscribers: Map<string, Subscriber<Event>> = new Map();
+
+  subscribe(event: Event, callback: Callback, context = ""): void {
+    if (!this.subscribers.has(context)) {
+      this.createSubscriber(context);
+    }
+    if (!this.subscribers.get(context).has(event)) {
+      this.createEvent(context, event);
+    }
+    this.subscribers.get(context).get(event).add(callback);
+  }
+
+  protected createSubscriber(context: string): void {
+    this.subscribers.set(context, new Map());
+  }
+
+  protected createEvent(context: string, event: Event): void {
+    this.subscribers.get(context).set(event, new Set());
+  }
+
+  protected publish(event: Event, data: unknown, context = ""): void {
+    const subscriber = this.subscribers.get(context);
+    if (subscriber && subscriber.has(event)) {
+      subscriber.get(event).forEach((callback) => {
+        callback(data);
+      });
+    }
+  }
+}

package/helpers/QueryFilter.ts

@@ -0,0 +1,204 @@
+import { Moment } from "moment";
+
+enum SortDirection {
+  asc = "asc",
+  desc = "desc",
+}
+const MAX_ITEMS_ON_PAGE = 25;
+export default class QueryFilter {
+  private query = {};
+  max_on_page = MAX_ITEMS_ON_PAGE as number;
+  total = undefined as number;
+  end_reached = false as boolean;
+  loading = false as boolean;
+
+  equal(key: string, value: string | number | Moment): this {
+    if (value) {
+      this.query[`${key}$eq`] = value;
+    }
+
+    return this;
+  }
+
+  custom(
+    key: string,
+    value: string | number | boolean | Moment | string[]
+  ): this {
+    if (value !== null) {
+      this.query[key] = value;
+    }
+
+    return this;
+  }
+
+  scope(key: string, value: string | number | Moment): this {
+    if (value) {
+      this.query[`${key}$scope`] = value;
+    }
+
+    return this;
+  }
+
+  jsonContains(key: string, value: string | number | Moment): this {
+    if (value) {
+      this.query[`${key}$jc`] = value;
+    }
+
+    return this;
+  }
+
+  notEqual(key: string, value: string | number | Moment): this {
+    if (value) {
+      this.query[`${key}$neq`] = value;
+    }
+
+    return this;
+  }
+
+  gte(key: string, value: string | number | Moment): this {
+    if (value) {
+      this.query[`${key}$gte`] = value;
+    }
+
+    return this;
+  }
+
+  lte(key: string, value: string | number | Moment): this {
+    if (value) {
+      this.query[`${key}$lte`] = value;
+    }
+
+    return this;
+  }
+
+  gt(key: string, value: string | number | Moment): this {
+    if (value) {
+      this.query[`${key}$gt`] = value;
+    }
+
+    return this;
+  }
+
+  lt(key: string, value: string | number | Moment): this {
+    if (value) {
+      this.query[`${key}$lt`] = value;
+    }
+
+    return this;
+  }
+
+  like(key: string, value: string | number | Moment): this {
+    if (value) {
+      this.query[`${key}$like`] = value;
+    }
+
+    return this;
+  }
+
+  offset(offset: number): this {
+    this.query[`@offset`] = offset;
+
+    return this;
+  }
+
+  take(take: number = this.max_on_page): this {
+    this.query[`@take`] = take;
+
+    return this;
+  }
+
+  page(page: number | null, max_on_page = this.max_on_page): this {
+    if (page) {
+      this.offset(page * max_on_page - max_on_page);
+      this.take(max_on_page);
+      this.custom("page", page);
+    }
+
+    return this;
+  }
+
+  firstPage(): this {
+    this.end_reached = false;
+    this.page(1);
+
+    return this;
+  }
+
+  unsetPagination(): this {
+    this.end_reached = false;
+    this.offset(undefined);
+
+    return this;
+  }
+
+  nextPage(): this {
+    if (this.query[`@offset`] !== undefined) {
+      this.offset(this.query[`@offset`] + this.max_on_page);
+    } else {
+      this.offset(0);
+    }
+    this.take(this.max_on_page);
+
+    return this;
+  }
+
+  unlimited(): this {
+    this.take(null);
+    this.offset(null);
+    this.page(null);
+
+    return this;
+  }
+
+  sort(key: number, direction: SortDirection = SortDirection.asc): this {
+    this.query[`@sort,${direction}`] = key;
+
+    return this;
+  }
+
+  in(key: string, values: Array<string | number | Moment>): this {
+    if (values) {
+      this.query[`${key}$in`] = values.join(",");
+    }
+
+    return this;
+  }
+
+  notIn(key: string, values: Array<string | number | Moment>): this {
+    if (values) {
+      this.query[`${key}$nin`] = values.join(",");
+    }
+
+    return this;
+  }
+
+  endList(): void {
+    this.end_reached = true;
+  }
+
+  startLoading(): void {
+    this.loading = true;
+  }
+
+  endLoading(): void {
+    this.loading = false;
+  }
+
+  maxOnPage(max_on_page: number): this {
+    this.max_on_page = max_on_page;
+
+    return this;
+  }
+
+  getKey(key: string): unknown {
+    return this.query[key];
+  }
+
+  clone(): QueryFilter {
+    return Object.assign(Object.create(Object.getPrototypeOf(this)), this);
+  }
+
+  toObject(): Record<string, unknown> {
+    return this.query;
+  }
+}

package/helpers/TimeHelper.ts

@@ -0,0 +1,54 @@
+import { Moment } from "moment";
+import moment from "./moment/Moment";
+
+const workingHours = 8;
+
+const formatDuration = (duration: number) => {
+  const hours = Math.trunc(duration / 60);
+  const minutes = `0${duration % 60}`.slice(-2);
+  return `${hours}:${minutes}`;
+};
+
+const fiveMinutesRound = (minutes: number) => {
+  return Math.round(minutes / 5) * 5;
+};
+
+/**
+ * Returns difference between two dates rounded using 5 minutes grid
+ * @param from
+ * @param to
+ */
+const diffMinutes = (from: Moment, to: Moment) => {
+  const minutes = to.diff(from, "minutes", true);
+  return fiveMinutesRound(minutes);
+};
+
+/**
+ * Example 1: start = 16:03:00, to: 16:04:30 (can be current time), return = 16:05:30
+ * Example 2: start = 16:03:00, to: 16:05:30, return = 16:10:30 (not 16:08:00 because now 5 minutes round is 5 minutes
+ *      and next change (10 minutes) will appear in 16:10:30)
+ * Example 3: start = 16:03:00, to: 16:07:00, return = 16:10:30
+ * Example 4: start = 16:03:00, to: 16:10:00 (can be current time), return = 16:10:30
+ * Example 5: start = 16:10:35, to: 16:10:00 (can be current time), return = 16:15:30
+ *
+ * @todo write tests!!!
+ * @param {Moment} from
+ * @param {Moment} to
+ */
+const nextTimeFiveMinutesWillRound = (from: Moment, to: Moment) => {
+  const minutesDiff = to.diff(from, "minutes", true);
+  const roundedTo5Minutes = fiveMinutesRound(minutesDiff);
+  const timeElapsed = minutesDiff - roundedTo5Minutes;
+  const leftToHalfOf5Minutes = 2.5 - timeElapsed;
+
+  return to.clone().add(leftToHalfOf5Minutes, "minutes");
+};
+
+export {
+  workingHours,
+  formatDuration,
+  diffMinutes,
+  fiveMinutesRound,
+  nextTimeFiveMinutesWillRound,
+  moment,
+};

package/helpers/Validations.ts

@@ -0,0 +1,7 @@
+const onlyLatin = (value: string): boolean => !/[^\u0020-\u007e\u00a0-\u00ff]/g.test(value);
+
+const onlyCyrillic = (value: string): boolean => /^[^A-Za-z]*$/g.test(value);
+
+const monthReportingLimit = (value: number): boolean => value >= 1 && value <= 300;
+
+export { onlyLatin, onlyCyrillic, monthReportingLimit };

package/helpers/model/ModelHelper.ts

@@ -0,0 +1,155 @@
+import { collect, Collection as BaseCollection } from "collect.js";
+import * as moment from "moment";
+
+/**
+ * Map resource to model
+ * @param target model class
+ * @param source resource that we get from api
+ */
+const map = (target, source) => {
+  if (Array.isArray(source)) {
+    return mapCollection(source, target);
+  }
+
+  if (!target) {
+    return;
+  }
+  const model = new target();
+  for (const key of Object.keys(model)) {
+    model[key] = getModelPropertyValue(source[key], model[key]);
+  }
+
+  return model;
+};
+
+const tree = (collection) => {
+  return collection
+    .filter((item) => !item.parent)
+    .map((parent) => {
+      parent.children = collection.where("parent.id", parent.id);
+
+      return parent;
+    });
+};
+
+const arrayTree = (collection) => {
+  return collection
+    .filter((item) => !item.parent)
+    .map((parent) => {
+      parent.children = [];
+      collection
+        .where("parent.id", parent.id)
+        .each((child) => parent.children.push(child));
+      return parent;
+    })
+    .all();
+};
+
+/**
+ * Get value for model object property using source property (api resource property)
+ * @param sourceProperty
+ * @param modelProperty
+ */
+const getModelPropertyValue = (sourceProperty, modelProperty) => {
+  // Todo: Maybe all of this move to fabric with polymorph classes (move to decorators, then this method will not be needed
+  if (sourceProperty === undefined) {
+    return undefined;
+  }
+  if (sourceProperty === null) {
+    return null;
+  }
+
+  if (modelProperty instanceof TypeModel) {
+    return map(modelProperty.getModel(), sourceProperty);
+  }
+
+  if (modelProperty instanceof TypeCollection) {
+    return mapCollection(sourceProperty, modelProperty.getModel());
+  }
+
+  return sourceProperty;
+};
+
+/**
+ * Map array to Collection with models
+ * @param collection
+ * @param model
+ */
+const mapCollection = <TModel>(
+  collection: Array<Partial<TModel>>,
+  model: TModel
+) => {
+  return collect(collection.map((source) => map(model, source)));
+};
+
+/**
+ * Special type that express that we expect get model from resource(api)
+ * @deprecated Use @AsModel decorator instead (example in ExtendedInfoModel)
+ * @param model
+ */
+const asModel = <TModel>(model: TModel) => {
+  return new TypeModel(model);
+};
+
+/**
+ * Special type that express that we expect get collection(array) from resource(api)
+ * @deprecated Use @AsCollection decorator instead (example in ExtendedInfoModel)
+ * @param model
+ */
+
+const asCollection = <TModel extends new (...args: any) => any>(
+  model: TModel
+): TypeCollection<TModel> | TypeCollection<InstanceType<TModel>> => {
+  return new TypeCollection(model);
+};
+
+// TODO: Move somewhere
+const updateProperties = <T, U extends Partial<T>>(target: T, source: U): T => {
+  for (const key of Object.keys(source)) {
+    target[key] = cloneValue(source[key]);
+  }
+  return target;
+};
+
+const Moment = moment().constructor;
+const cloneValue = (value) => {
+  const isMomentInstance = value instanceof Moment;
+  return isMomentInstance ? moment(value) : value;
+};
+
+abstract class Type<TModel> {
+  private readonly model: TModel;
+
+  public constructor(model: TModel) {
+    this.model = model;
+  }
+
+  getModel() {
+    return this.model;
+  }
+}
+
+/** This is helper class to specify type collection with some model for mapping */
+class TypeCollection<TModel> extends Type<TModel> {}
+/** This is helper class to specify type model for mapping */
+class TypeModel<TModel> extends Type<TModel> {}
+
+// Todo: maybe do same as we do with Moment class, just moment().constructor is class
+// This code (class Collection) gives us possibility to check instanceof Collection (collect.js).
+// Default Collection from collect.js causes an error: "TypeError: Right-hand side of 'instanceof' is not an object",
+// because it is just a declaration
+class Collection {}
+Object.assign(Collection, collect().__proto__);
+
+// type Collection<Item> = BaseCollection<Item>;
+
+export {
+  asModel,
+  asCollection,
+  TypeCollection,
+  map,
+  Collection,
+  updateProperties,
+  tree,
+  arrayTree,
+};

package/helpers/model/decorators/AsCollection.ts

@@ -0,0 +1,26 @@
+import { collect } from "collect.js";
+import { map } from "../ModelHelper";
+
+export default (property: string, instance: Object) => {
+  return function <T extends { new (...args: any[]): {} }>(constructor: T) {
+    return class extends constructor {
+      constructor(...args: any[]) {
+        super(...args);
+
+        let value;
+        Object.defineProperty(this, property, {
+          enumerable: true,
+          get: () => {
+            return value;
+          },
+          set: (newValue: Array<any> | undefined) => {
+            value =
+              newValue !== undefined
+                ? collect(newValue.map((source) => map(instance, source)))
+                : newValue;
+          },
+        });
+      }
+    };
+  };
+};

package/helpers/model/decorators/AsModel.ts

@@ -0,0 +1,25 @@
+import { map } from "../ModelHelper";
+
+export default (property: string, instance: Object) => {
+  return function <T extends { new (...args: any[]): {} }>(constructor: T) {
+    return class extends constructor {
+      constructor(...args: any[]) {
+        super(...args);
+
+        let value;
+        Object.defineProperty(this, property, {
+          enumerable: true,
+          get: () => {
+            return value;
+          },
+          set: (newValue: Object | undefined) => {
+            value =
+              newValue !== undefined && newValue !== null
+                ? map(instance, newValue)
+                : newValue;
+          },
+        });
+      }
+    };
+  };
+};

package/helpers/model/decorators/DateTime.ts

@@ -0,0 +1,26 @@
+import { Moment } from "moment";
+import { moment } from "../../TimeHelper";
+
+export default (property) => {
+  return function <T extends { new (...args: any[]): {} }>(constructor: T) {
+    return class extends constructor {
+      constructor(...args: any[]) {
+        super(...args);
+
+        let value;
+        Object.defineProperty(this, property, {
+          enumerable: true,
+          get: () => {
+            return value;
+          },
+          set: (newValue: Moment | undefined | null) => {
+            value =
+              newValue !== undefined && newValue !== null
+                ? moment(newValue)
+                : newValue;
+          },
+        });
+      }
+    };
+  };
+};

package/helpers/model/decorators/TimeDuration.ts

@@ -0,0 +1,33 @@
+import { Duration as DurationType } from "moment";
+import { moment } from "../../TimeHelper";
+
+const Duration = moment.duration().constructor;
+
+export default (property) => {
+  return function <T extends { new (...args: any[]): {} }>(constructor: T) {
+    return class extends constructor {
+      constructor(...args: any[]) {
+        super(...args);
+
+        let value = moment.duration(0);
+        Object.defineProperty(this, property, {
+          enumerable: true,
+          get: () => {
+            return value;
+          },
+          set: (newValue: DurationType | number) => {
+            if (!(newValue instanceof Duration)) {
+              let minutes = Number(newValue);
+              if (Number.isNaN(minutes)) {
+                minutes = 0;
+              }
+              newValue = moment.duration(minutes, "minutes");
+            }
+
+            value = moment.duration(newValue);
+          },
+        });
+      }
+    };
+  };
+};

package/helpers/moment/Duration.ts

@@ -0,0 +1,64 @@
+import { DurationInputArg1, DurationInputArg2 } from "moment";
+import * as moment from "moment";
+import { Duration } from "./index";
+import { workingHours } from "../TimeHelper";
+
+const duration = (
+  inp?: DurationInputArg1,
+  unit?: DurationInputArg2
+): Duration => {
+  const momentDurationPrototype = moment.duration(inp, unit);
+  const intemsDuration: Duration = Object.create(momentDurationPrototype);
+
+  // Is used when we do some primitive manipulations with class (eg. Duration + 5, will transform Duration into minutes and add 5)
+  intemsDuration.valueOf = () => {
+    return intemsDuration.asMinutes();
+  };
+
+  intemsDuration.clone = () => {
+    return duration(intemsDuration);
+  };
+
+  intemsDuration.minutesWithLeadingZeroes = () => {
+    return intemsDuration.minutes().toString().padStart(2, "0");
+  };
+
+  intemsDuration.hoursAsNumber = () => {
+    return Math.floor(intemsDuration.asHours());
+  };
+
+  intemsDuration.humanizedHours = () => {
+    return intemsDuration.hoursAsNumber() === 1 ? "hour" : "hours";
+  };
+
+  intemsDuration.humanizedMinutes = () => {
+    return intemsDuration.minutes() === 1 ? "minute" : "minutes";
+  };
+
+  intemsDuration.formatted = () => {
+    return `${intemsDuration.hoursAsNumber()}:${intemsDuration.minutesWithLeadingZeroes()}`;
+  };
+
+  intemsDuration.formattedInLongForm = () => {
+    const formattedHours = `${intemsDuration.hoursAsNumber()} ${intemsDuration.humanizedHours()}`;
+    const formattedMinutes = `${intemsDuration.minutes()} ${intemsDuration.humanizedMinutes()}`;
+
+    if (intemsDuration.hoursAsNumber() === 0) {
+      return formattedMinutes;
+    }
+
+    return intemsDuration.minutes() === 0
+      ? formattedHours
+      : `${formattedHours} ${formattedMinutes}`;
+  };
+
+  intemsDuration.formattedInWorkingDays = () => {
+    const workingDays = Math.floor(intemsDuration.asHours() / workingHours);
+    const humanizedDays = workingDays === 1 ? "day" : "days";
+    return `${workingDays} ${humanizedDays}`;
+  };
+
+  return intemsDuration;
+};
+
+export default duration;