sprof 0.0.1

package/src/services/BaseStore.ts

@@ -0,0 +1,220 @@
+import Cache from '@/services/CacheS';
+import FileInfo from '@/classes/FileInfo';
+import FTSP from '@/classes/filters/FTSP';
+import HttpResponse from '@/classes/HttpResponse';
+import { Constructable } from '@/services/ClassHelper';
+import HttpClient from '@/services/HttpClientS';
+import IFileInfosGetter from '@/interfaces/IFileInfosGetter';
+import { IBodyfulParams } from '@/interfaces/IHTTPTypes';
+import ItemsWithCount from '@/interfaces/ItemsWithCount';
+import IWithId from '@/interfaces/IWithId';
+
+interface GetAllOptions {
+  withCache?: boolean;
+  ftsp: FTSP;
+}
+
+export default class BaseStore<T extends IWithId & IFileInfosGetter> {
+  protected readonly items: T[] = reactive([]);
+  protected readonly item: T;
+  protected count = ref(0);
+  protected classConstructor: Constructable<T>;
+  protected url = '';
+
+  constructor(i: Constructable<T>, url: string) {
+    this.classConstructor = i;
+    this.item = reactive(new this.classConstructor());
+    this.url = url;
+  }
+
+  Set(item: T | void) {
+    Object.assign(this.item, new this.classConstructor(item));
+  }
+
+  Item(): T {
+    return this.item;
+  }
+
+  // ======= //
+  // ACTIONS //
+  // ======= //
+  protected getUrl(query?: string): string {
+    if (!query) {
+      return this.url;
+    }
+    return `${this.url}/${query}`;
+  }
+
+  async GetAll(options?: GetAllOptions): Promise<void> {
+    let res;
+    const get = HttpClient.Get<T[] | ItemsWithCount<T>>;
+    if (options && options.withCache) {
+      res = await Cache.TryGet<T[] | ItemsWithCount<T>>(this.getUrl(), get);
+    } else {
+      res = await get({ query: this.getUrl() });
+    }
+    if (Array.isArray(res)) {
+      this.SetAll(res);
+    } else {
+      this.SetAllWithCount(res as ItemsWithCount<T>);
+    }
+  }
+  async Get(id?: string) {
+    if (!id) {
+      id = Router.Id();
+    }
+    this.Set(await HttpClient.Get<T>({ query: this.getUrl(id) }));
+  }
+  async FTSP(options?: GetAllOptions) {
+    const ftsp: FTSP = options?.ftsp ?? FTSP.Get();
+    const f = ftsp.clearForHTTP();
+    const p: IBodyfulParams<unknown> = {
+      payload: { ftsp: f },
+      query: this.getUrl('ftsp'),
+    };
+    const res = await HttpClient.Post<unknown, HttpResponse<T[] | ItemsWithCount<T>>>(p);
+    if (!res || !res.ftsp) {
+      return;
+    }
+    if (Array.isArray(res.data)) {
+      this.SetAll(res.data);
+    } else {
+      if (f.p.append) {
+        this.AppendToAll(res.data?.items);
+        return;
+      }
+      this.SetAllWithCount(res.data);
+    }
+  }
+
+  async Create(item?: T): Promise<T | void> {
+    console.log(item);
+    const param = item ?? this.item;
+    const opts: IBodyfulParams<T> = { payload: param, query: this.getUrl() };
+    if (param.getFileInfos) {
+      opts.fileInfos = param.getFileInfos();
+      opts.fileInfos.forEach((f: FileInfo) => (f.url = ''));
+    }
+    return await HttpClient.Post<T, T>(opts);
+  }
+
+  async CreateAndSet(item: T): Promise<void> {
+    const result = await this.Create(item);
+    this.Set(result);
+  }
+
+  // bun не поддерживает множественное создание с uuid. Пока отправляем несколько запросов
+  async CreateMany(items?: T[]): Promise<void> {
+    if (!items) {
+      return;
+    }
+    const promises: Promise<T | void>[] = [];
+    items.forEach((i) => {
+      promises.push(new Promise(() => this.Create(i)));
+    });
+    Promise.all(promises);
+  }
+
+  async Update(item?: T): Promise<T | void> {
+    const param = item ?? this.item;
+    const opts: IBodyfulParams<T> = { query: this.getUrl(`${param.id}`), payload: param };
+    if (param.getFileInfos) {
+      opts.fileInfos = param.getFileInfos();
+      opts.fileInfos.forEach((f: FileInfo) => (f.url = ''));
+    }
+    return await HttpClient.Put<T, T>(opts);
+  }
+
+  async UpdateAndSet(item: T): Promise<void> {
+    const result = await this.Update(item);
+    this.Set(result);
+  }
+
+  async UpdateAndReset(item?: T): Promise<void> {
+    await this.Update(item ?? this.item);
+    this.Set();
+  }
+
+  async Remove(id: string | undefined): Promise<void> {
+    if (!id) {
+      console.warn('BaseStore/Remove. id is undefined');
+      return;
+    }
+    await HttpClient.Delete({ query: this.getUrl(`${id}`) });
+    this.RemoveItem(id);
+  }
+
+  // bun не поддерживает множественное обновление с uuid. Пока отправляем несколько запросов
+  async UpdateMany(items?: T[]): Promise<void> {
+    if (!items) {
+      items = this.items;
+    }
+    if (!items) {
+      return;
+    }
+    const promises: Promise<T | void>[] = [];
+    items.forEach((i) => {
+      promises.push(new Promise(() => this.Update(i)));
+    });
+    Promise.all(promises);
+  }
+
+  // ======= //
+  // COMMITS //
+  // ======= //
+  SetAll(items: T[] | undefined) {
+    if (!items) {
+      return;
+    }
+    this.items.splice(0, this.items.length);
+    this.items.push(...items.map((a: T) => new this.classConstructor(a)));
+  }
+
+  SetAllWithCount(items?: ItemsWithCount<T>) {
+    if (!items) {
+      return;
+    }
+    this.SetAll(items.items);
+    this.count.value = items.count;
+  }
+
+  RemoveItem(id: string) {
+    const index = this.items.findIndex((i: T) => i.id === id);
+    this.items.splice(index, 1);
+  }
+  AppendToAll(items?: T[] | undefined) {
+    if (!items) {
+      return;
+    }
+    const resultItems = items.map((i: T) => new this.classConstructor(i));
+    this.items.push(...resultItems);
+  }
+  ResetState() {
+    this.ResetItem();
+    this.ClearItems();
+    this.count.value = 0;
+  }
+
+  ResetItem() {
+    ClassHelper.BuildClass(this.item, new this.classConstructor());
+  }
+
+  ClearItems() {
+    this.items.splice(0, this.items.length);
+  }
+  UnshiftToAll(item: T) {
+    this.items.unshift(new this.classConstructor(item));
+  }
+
+  // ======= //
+  // GETTERS //
+  // ======= //
+
+  Items(): T[] {
+    return this.items;
+  }
+
+  Count(): Ref<number> {
+    return this.count;
+  }
+}

package/src/services/Button.ts

@@ -0,0 +1,42 @@
+import { ComputedRef, Ref } from "vue";
+import { NavigationGuardNext } from "vue-router";
+
+import Statuses from "../types/Statuses";
+
+type actionFunction =
+  | ((next?: NavigationGuardNext | undefined) => Promise<void>)
+  | (() => Promise<void>)
+  | (() => void);
+
+type Text = string | ComputedRef<string> | Ref<string>;
+type Condition = boolean | ComputedRef<boolean> | Ref<boolean>;
+type Action = undefined | actionFunction | ComputedRef<actionFunction>;
+
+export default class Button {
+  text?: Text = "Сохранить";
+  type?: Statuses = Statuses.Success;
+  condition?: Condition = true;
+  action?: Action;
+
+  constructor(text: Text, action: Action, t: Statuses, condition?: Condition) {
+    this.text = text;
+    this.type = t;
+    this.action = action;
+    if (condition !== undefined) {
+      this.condition = condition;
+    }
+  }
+
+  static Primary(text: Text, action: Action, condition?: Condition): Button {
+    return new Button(text, action, Statuses.Primary, condition);
+  }
+  static Success(text: Text, action: Action, condition?: Condition): Button {
+    return new Button(text, action, Statuses.Success, condition);
+  }
+  static Warning(text: Text, action: Action, condition?: Condition): Button {
+    return new Button(text, action, Statuses.Warning, condition);
+  }
+  static Error(text: Text, action: Action, condition?: Condition): Button {
+    return new Button(text, action, Statuses.Error, condition);
+  }
+}

package/src/services/Cache.ts

@@ -0,0 +1,44 @@
+import ClassHelper from '@/services/ClassHelper';
+
+export default class Cache {
+  name = '';
+
+  constructor(i?: Cache) {
+    ClassHelper.BuildClass(this, i);
+  }
+
+  public cache(): void {
+    // const res = { data, time: new Date() };
+    // sessionStorage.setItem(this.name, JSON.stringify(res));
+  }
+
+  getFromCache<DataType>(min?: number): DataType | null {
+    const res = sessionStorage.getItem(this.name);
+    if (res) {
+      const storeData = JSON.parse(res);
+      const now = new Date();
+      const timestamp = new Date(storeData.time);
+      const difference = now.getTime() - timestamp.getTime(); // difference in milliseconds
+      const resultInMinutes = Math.round(difference / 60000);
+      const defaultMin = 10; // min by default
+      if (resultInMinutes > (min ? min : defaultMin)) {
+        return null;
+      }
+      return storeData.data;
+    } else {
+      return null;
+    }
+  }
+
+  async storeGetWithCache<DataType>(get: () => Promise<DataType | void>, min?: number): Promise<DataType | void | null> {
+    let res;
+    res = this.getFromCache<DataType>(min);
+    if (!res) {
+      res = await get();
+      if (res) {
+        this.cache();
+      }
+    }
+    return res;
+  }
+}

package/src/services/CacheS.ts

@@ -0,0 +1,44 @@
+import ClassHelper from '@/services/ClassHelper';
+
+export default class Cache {
+  name = '';
+
+  constructor(i?: Cache) {
+    ClassHelper.BuildClass(this, i);
+  }
+
+  public static Set(): void {
+    // const res = { data, time: new Date() };
+    // sessionStorage.setItem(this.name, JSON.stringify(res));
+  }
+
+  public static Get<DataType>(name: string, min?: number): DataType | null {
+    const res = sessionStorage.getItem(name);
+    if (res) {
+      const storeData = JSON.parse(res);
+      const now = new Date();
+      const timestamp = new Date(storeData.time);
+      const difference = now.getTime() - timestamp.getTime(); // difference in milliseconds
+      const resultInMinutes = Math.round(difference / 60000);
+      const defaultMin = 10; // min by default
+      if (resultInMinutes > (min ? min : defaultMin)) {
+        return null;
+      }
+      return storeData.data;
+    } else {
+      return null;
+    }
+  }
+
+  async TryGet<DataType>(name: string, get: () => Promise<DataType | void>, min?: number): Promise<DataType | void | null> {
+    let res;
+    res = Cache.Get<DataType>(name, min);
+    if (!res) {
+      res = await get();
+      if (res) {
+        // Cache.Set<DataType>(name, res);
+      }
+    }
+    return res;
+  }
+}

package/src/services/CarouselSwipe.ts

@@ -0,0 +1,14 @@
+interface ISwiper {
+  next: () => void;
+  prev: () => void;
+}
+
+export default function carouselSwipe(direction: string, ref: ISwiper): void {
+  if (direction == 'left') {
+    ref.next();
+  }
+
+  if (direction == 'right') {
+    ref.prev();
+  }
+}

package/src/services/ClassHelper.ts

@@ -0,0 +1,101 @@
+import 'reflect-metadata';
+
+import { v4 as uuidv4 } from 'uuid';
+
+import IWithId from '@/interfaces/IWithId';
+
+// eslint-disable-next-line
+export type ClassType = { [key: string]: any };
+// eslint-disable-next-line
+export type Constructable<T> = { new (...args: any[]): T };
+
+export default class ClassHelper {
+  static BuildClass(passedClass: ClassType, arg?: ClassType): void {
+    if (!arg) {
+      return;
+    }
+    Object.keys(arg).forEach((key) => {
+      const prop = arg[key];
+      if (this.isPrimitive(prop)) {
+        if (passedClass[key] instanceof Date) {
+          passedClass[key] = new Date(prop);
+        } else {
+          passedClass[key] = prop;
+        }
+      } else if (prop !== null && prop !== undefined && !Array.isArray(prop)) {
+        if (passedClass[key] && passedClass[key].constructor) {
+          passedClass[key] = new passedClass[key].constructor(prop);
+        } else {
+          const constructor = Reflect.getMetadata(key, passedClass);
+          if (constructor) {
+            passedClass[key] = new constructor[key](prop);
+          }
+        }
+      }
+      if (Array.isArray(prop)) {
+        const constructor = Reflect.getMetadata(key, passedClass);
+        if (constructor) {
+          passedClass[key] = prop.map((t) => new constructor[key](t));
+        }
+      }
+    });
+  }
+
+  static GetClassConstructor = <T>(construct: Constructable<T>): PropertyDecorator => {
+    return (targetClass, propertyName) => {
+      const metadataSingleton = Reflect.getMetadata(`property:${propertyName as string}`, targetClass) || {};
+      metadataSingleton[propertyName] = construct;
+      Reflect.defineMetadata(propertyName, metadataSingleton, targetClass);
+    };
+  };
+
+  private static isPrimitive(prop: unknown): boolean {
+    return prop !== null && typeof prop !== 'undefined' && prop !== Object(prop);
+  }
+
+  static RemoveFromClassByIndex(index: number, arrayFromDelete: IWithId[], arrayForDelete?: string[]): void {
+    ClassHelper.RemoveFromClass(index, arrayFromDelete, arrayForDelete);
+  }
+
+  static RemoveFromClassById(id: string | undefined, arrayFromDelete: IWithId[], arrayForDelete?: string[]): string | undefined {
+    if (!id) {
+      return;
+    }
+    const index = arrayFromDelete.findIndex((i: IWithId) => i.id === id);
+    ClassHelper.RemoveFromClass(index, arrayFromDelete, arrayForDelete);
+  }
+
+  private static RemoveFromClass(index: number, arrayFromDelete: IWithId[], arrayForDelete?: string[]): void {
+    if (index < 0) {
+      return;
+    }
+    const idForDelete = arrayFromDelete[index].id;
+    if (idForDelete && arrayForDelete) {
+      arrayForDelete.push(idForDelete);
+    }
+    arrayFromDelete.splice(index, 1);
+  }
+
+  static GetPropertyName<T extends ClassType>(obj: Constructable<T>): T {
+    const o = new obj();
+    return new Proxy(o, {
+      get(t, key) {
+        return key;
+      },
+    });
+  }
+
+  static CreateUUID(): string {
+    return uuidv4();
+  }
+
+  static InitClassInstance(passedClass: ClassType, arg?: ClassType): ClassType {
+    const item = passedClass.constructor(arg);
+    ClassHelper.BuildClass(item);
+    item.id = ClassHelper.CreateUUID();
+    return item;
+  }
+  static ExistsWithId(arr: IWithId[], id?: string): boolean {
+    return arr.some((a: IWithId) => a.id === id);
+  }
+}

package/src/services/Color.ts

@@ -0,0 +1,8 @@
+export const BrandColors: string[] = ['#31af5e', '#ff4d3b', '#006BB5', '#f3911c'];
+import Arrays from './Arrays';
+
+export default abstract class Color {
+  static GetRandColor(arr?: string[]): string {
+    return Arrays.GetRandEL(arr ?? BrandColors);
+  }
+}

package/src/services/CreateSortModels.ts

@@ -0,0 +1,26 @@
+import SortModel from '@/classes/SortModel';
+import { Orders } from '@/interfaces/Orders';
+import { SortModelBuilder, SortModelBuildersLib } from '@/interfaces/Sort';
+
+export default function createSortModels(lib: SortModelBuildersLib, mainOrder?: Orders): SortModel[] {
+  const sortModels: SortModel[] = [];
+  const firstOrder = mainOrder ? mainOrder : Orders.Asc;
+  const secondOrder = firstOrder === Orders.Asc ? Orders.Desc : Orders.Asc;
+
+  Object.values(lib).forEach((el: SortModelBuilder) => {
+    sortModels.push(el(firstOrder));
+    sortModels.push(el(secondOrder));
+  });
+  if (sortModels.length > 0 && !sortModels.some((s: SortModel) => s.default)) {
+    sortModels[0].default = true;
+  }
+  if (!mainOrder) {
+    return sortModels;
+  }
+  sortModels.forEach((sortModel: SortModel) => {
+    if (sortModel.default) {
+      sortModel.default = sortModel.order === mainOrder;
+    }
+  });
+  return sortModels;
+}

package/src/services/Cursor.ts

@@ -0,0 +1,51 @@
+import { TimelineMinutes, TimelineSteps } from '@/services/Time';
+
+import Arrays from './Arrays';
+
+export default class Scheduler {
+  startHour = 9;
+  endHour = 19;
+  timelinePxHeight = 50;
+
+  timelineStep: TimelineSteps = TimelineSteps.FiveMinutes;
+
+  activeTime = '';
+  activeObjectId = '';
+
+  dragged = false;
+  draggedStartTime = '';
+  draggedEndTime = '';
+
+  timelines: string[] = TimelineMinutes[TimelineSteps.FiveMinutes];
+
+  startDrag(t1: string, t2: string): void {
+    this.draggedStartTime = t1;
+    this.draggedEndTime = t2;
+    this.dragged = true;
+  }
+
+  endDrag(): void {
+    this.activeTime = '';
+    this.dragged = false;
+  }
+  setTimelineStep(step: TimelineSteps): void {
+    this.timelineStep = step;
+    this.setTimelines();
+  }
+
+  setTimelines(): void {
+    this.timelines = TimelineMinutes[this.timelineStep];
+  }
+
+  getScheduleHeight() {
+    return this.getHourHeight() * this.getHoursArr().length;
+  }
+
+  getHourHeight() {
+    return this.timelinePxHeight * this.timelines.length;
+  }
+
+  getHoursArr(): number[] {
+    return Arrays.GenerateNumsRange(this.startHour, this.endHour);
+  }
+}

package/src/services/DateFormat.ts

@@ -0,0 +1,102 @@
+export const SetDays = ['Понедельник', 'Вторник', 'Среда', 'Четверг', 'Пятница', 'Суббота', 'Воскресенье'];
+export const SetDaysMobile = ['ПН', 'ВТ', 'СР', 'ЧТ', 'ПТ', 'СБ', 'ВС'];
+const SetShortDays = ['ВС', 'ПН', 'ВТ', 'СР', 'ЧТ', 'ПТ', 'СБ'];
+
+interface CustomDateTimeFormatOptions {
+  localeMatcher?: string;
+  weekday?: 'narrow' | 'short' | 'long';
+  era?: string;
+  year?: 'numeric' | '2-digit' | undefined;
+  month?: 'numeric' | '2-digit' | 'narrow' | 'short' | 'long';
+  day?: 'numeric' | '2-digit' | undefined;
+  hour?: 'numeric' | '2-digit';
+  minute?: 'numeric' | '2-digit';
+  second?: string;
+  timeZoneName?: string;
+  formatMatcher?: string;
+  hour12?: boolean;
+  timeZone?: string;
+}
+
+export default class DateTimeFormat {
+  locale = 'ru-RU';
+
+  constructor(locale?: string) {
+    this.locale = locale ?? this.locale;
+  }
+
+  format(date?: Date, options?: CustomDateTimeFormatOptions): string {
+    if (!date) {
+      return '';
+    }
+    const opt: Intl.DateTimeFormatOptions = { year: 'numeric', month: '2-digit', day: '2-digit', hour: undefined, minute: undefined };
+    if (options) {
+      opt.year = options.year || options.year === undefined ? options.year : opt.year;
+      opt.month = options.month || options.month === undefined ? options.month : opt.month;
+      opt.day = options.day || options.day === undefined ? options.day : opt.day;
+      opt.hour = options.hour ?? opt.hour;
+      opt.minute = options.minute ?? opt.minute;
+    }
+    return Intl.DateTimeFormat(this.locale, opt).format(new Date(date));
+  }
+
+  getPeriod(start: Date, end: Date, options?: CustomDateTimeFormatOptions): string {
+    return `${this.format(start, options)}-${this.format(end, options)}`;
+  }
+
+  getShortDayName(date?: Date): string {
+    if (!date) {
+      return '';
+    }
+    return SetShortDays[date.getDay()];
+  }
+
+  getCurrentWeekPeriod(options?: CustomDateTimeFormatOptions): string {
+    const now = new Date();
+    const startOfWeek = new Date(now.getFullYear(), now.getMonth(), now.getDate() - now.getDay() + 1);
+    const endOfWeek = new Date(now.getFullYear(), now.getMonth(), startOfWeek.getDate() + 7);
+    return this.getPeriod(startOfWeek, endOfWeek, options ? options : { month: '2-digit', day: 'numeric', year: undefined });
+  }
+
+  getDurationInDay(time1: string, time2: string): number {
+    const timeStart = new Date();
+    const timeEnd = new Date();
+    const valueStart = DateTimeFormat.SplitHourTime(time1);
+    const valueEnd = DateTimeFormat.SplitHourTime(time2);
+
+    timeStart.setHours(valueStart[0], valueStart[1], 0, 0);
+    timeEnd.setHours(valueEnd[0], valueEnd[1], 0, 0);
+
+    const diff = timeEnd.getTime() - timeStart.getTime();
+
+    return diff / 1000 / 60; // millisecond
+  }
+
+  static HourTimeinMunutes(time: string): number {
+    const parts = DateTimeFormat.SplitHourTime(time);
+    return parts[0] * 60 + parts[1];
+  }
+  static SplitHourTime(time: string): number[] {
+    const parts = time.split(':');
+    return [Number(parts[0]), Number(parts[1])];
+  }
+  static AddMinutesToHM(hm: string, minutes: number): string {
+    const d = new Date();
+    const hmArr = DateTimeFormat.SplitHourTime(hm);
+    d.setHours(hmArr[0], hmArr[1], 0, 0);
+    const newD = new Date(d.getTime() + minutes * 60000);
+    const h = newD.getHours();
+    const m = newD.getMinutes();
+    return `${h}:${m}`;
+  }
+
+  getMonthsDiff(dateFrom: Date, dateTo: Date): number {
+    return dateTo.getMonth() - dateFrom.getMonth() + 12 * (dateTo.getFullYear() - dateFrom.getFullYear());
+  }
+
+  stringToDate(value: string): Date {
+    const parts = value.split('.');
+    const date = new Date(`${parts[2]}-${parts[1]}-${parts[0]}`);
+    return date;
+  }
+}