sprof 0.0.1

package/src/services/DateMask.ts

@@ -0,0 +1,69 @@
+const isRemove = (n: number) => n === 8 || n === 46;
+const isDigit = (n: number) => n > 46 && n < 58;
+const isNavigate = (n: number) => n > 34 && n < 41;
+// const isSpace = (n: number) => n === 47;
+const addDot = (val: string) => val + '.';
+
+const checkInvalidKey = (e: KeyboardEvent, code: number, len: number) => {
+  if (isRemove(code) || isNavigate(code)) {
+    return;
+  }
+  if (!isDigit(code) || len > 9) {
+    e.preventDefault();
+  }
+};
+
+function replaceDots(val: string, len: number): string {
+  if (len > 8) {
+    let day = val.substring(0, 2).replace('.', '1');
+    if (Number(day) > 31) {
+      day = '31';
+    }
+    let month = val.substring(3, 5).replace('.', '1');
+    if (Number(month) > 12) {
+      month = '12';
+    }
+    let year = val.substring(6, 10).replace('.', '1');
+    if (Number(year) > 2100) {
+      year = '2100';
+    }
+    val = day + '.' + month + '.' + year;
+  }
+  return val;
+}
+
+export default function dateFormat(e: KeyboardEvent): void {
+  const code = e.keyCode;
+  let val = (<HTMLInputElement>e.srcElement).value;
+  const len = val.length;
+  checkInvalidKey(e, code, len);
+  if (!isRemove(code) && (len === 2 || len === 5)) {
+    val = addDot(val);
+  }
+
+  const allValue = (<HTMLInputElement>e.srcElement).value + String.fromCharCode(e.which);
+  if (isRemove(code)) {
+    (<HTMLInputElement>e.srcElement).value = val;
+    return;
+  }
+
+  if (val.length === 0 && Number(allValue) > 3) {
+    val = '3';
+    e.preventDefault();
+  }
+
+  if (val.length === 1 && Number(allValue) > 31) {
+    val = '31';
+    e.preventDefault();
+  }
+
+  if (allValue.length === 5) {
+    const month = Number(allValue.substring(3, 5));
+    if (month > 12) {
+      val = val.substring(0, 3) + '12';
+      e.preventDefault();
+    }
+  }
+  val = replaceDots(val, len);
+  (<HTMLInputElement>e.srcElement).value = val;
+}

package/src/services/Dates.ts

@@ -0,0 +1,41 @@
+import DatesFormatter from './DatesFormatter';
+import Period from './Period';
+
+// const SetDays = ['Понедельник', 'Вторник', 'Среда', 'Четверг', 'Пятница', 'Суббота', 'Воскресенье'];
+// const SetDaysMobile = ['ПН', 'ВТ', 'СР', 'ЧТ', 'ПТ', 'СБ', 'ВС'];
+// const SetShortDays = ['ВС', 'ПН', 'ВТ', 'СР', 'ЧТ', 'ПТ', 'СБ'];
+
+interface IWithDate {
+  date: Date;
+}
+
+export default abstract class Dates {
+  static GetPeriod(start: Date, end: Date): string {
+    return Period.Get(DatesFormatter.Format(start), DatesFormatter.Format(end));
+  }
+  static GetDateOrToday(item?: IWithDate): Date {
+    return item ? item.date : new Date();
+  }
+  static InPeriod(date: Date, start: Date, end: Date): boolean {
+    return Period.In(new Date(date), new Date(start), new Date(end));
+  }
+  static GetDatesFromPeriod(start: Date, end: Date): Date[] {
+    const dates: Date[] = [new Date(start)];
+    let curDate = start;
+    while (curDate <= end) {
+      curDate = Dates.AddDays(curDate, 1);
+      dates.push(curDate);
+    }
+    return dates;
+  }
+
+  static AddDays(date: Date, days: number): Date {
+    const res = new Date(date);
+    res.setDate(res.getDate() + days);
+    return res;
+  }
+
+  static Eq(d1: Date, d2: Date): boolean {
+    return d1.getTime() === d2.getTime();
+  }
+}

package/src/services/DatesFormatter.ts

@@ -0,0 +1,45 @@
+// const SetDays = ['Понедельник', 'Вторник', 'Среда', 'Четверг', 'Пятница', 'Суббота', 'Воскресенье'];
+// 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;
+}
+
+const locale = 'ru-RU';
+export default abstract class DatesFormatter {
+  locale = 'ru-RU';
+
+  static 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(locale, opt).format(new Date(date));
+  }
+
+  static FromRuStr(value: string): Date {
+    const parts = value.split('.');
+    const date = new Date(`${parts[2]}-${parts[1]}-${parts[0]}`);
+    return date;
+  }
+}

package/src/services/Dialog.ts

@@ -0,0 +1,70 @@
+import Message, { MessageOpts } from './Message';
+
+type DialogResultType = 'cancel' | 'submit';
+interface DialogResult {
+  type: DialogResultType;
+  // eslint-disable-next-line
+  [key: string]: any;
+}
+
+type DialogOpts = MessageOpts & {
+  text: string;
+  confirmButtonText: string;
+  cancelButtonText: string;
+};
+
+class DialogConstructor extends Message {
+  private confirmButtonText = 'Да';
+  private cancelButtonText = 'Нет';
+
+  // eslint-disable-next-line
+  private resolve?: any;
+  // eslint-disable-next-line
+  private reject?: any;
+
+  GetConfirmButtonText(): string {
+    return this.confirmButtonText;
+  }
+
+  GetCancelButtonText(): string {
+    return this.cancelButtonText;
+  }
+
+  Show(m: string | DialogOpts): Promise<DialogResult> {
+    super.show();
+    if (typeof m !== 'string') {
+      this.confirmButtonText = m.confirmButtonText;
+      this.cancelButtonText = m.cancelButtonText;
+    }
+    return new Promise<DialogResult>((resolve, reject) => {
+      this.resolve = resolve;
+      this.reject = reject;
+    });
+  }
+
+  Save(): Promise<DialogResult> {
+    return this.Show({
+      text: 'У вас есть несохранённые изменения',
+      confirmButtonText: 'Сохранить',
+      cancelButtonText: 'Не сохранять',
+    });
+  }
+
+  Submit() {
+    this.resolve(true);
+    this.hide();
+  }
+  Cancel() {
+    this.reject();
+    this.hide();
+  }
+
+  protected hide() {
+    this.resolve = undefined;
+    this.reject = undefined;
+    super.hide();
+  }
+}
+
+const Dialog: DialogConstructor = new DialogConstructor();
+export default Dialog;

package/src/services/Dragger.ts

@@ -0,0 +1,22 @@
+export default class Dragger {
+  private dragged = false;
+  private dragImg = new Image();
+
+  constructor() {
+    this.dragImg.src = 'data:image/gif;base64,R0lGODlhAQABAIAAAAUEBAAAACwAAAAAAQABAAACAkQBADs=';
+  }
+
+  start(e?: DragEvent): void {
+    this.dragged = true;
+    if (e && e.dataTransfer) {
+      e.dataTransfer.setDragImage(this.dragImg, 0, 0);
+    }
+  }
+
+  end(): void {
+    this.dragged = false;
+  }
+  isDragged(): boolean {
+    return this.dragged;
+  }
+}

package/src/services/Extension.ts

@@ -0,0 +1,6 @@
+export default class Extenstion {
+  static Get(filename: string): string {
+    const parts = filename.split('.');
+    return parts[parts.length - 1];
+  }
+}

package/src/services/Favourite.ts

@@ -0,0 +1,62 @@
+const FavouriteService = (() => {
+  function _setFavourite(domain: string, id: (string | undefined)[]) {
+    localStorage.setItem(`${domain}_favourite`, id.toString());
+  }
+
+  function _isFavourite(domain: string, id: string): boolean {
+    const ids = localStorage.getItem(`${domain}_favourite`);
+    if (!ids) {
+      return false;
+    }
+    const idArr = ids.split(',');
+    return idArr.includes(id);
+  }
+
+  function _addToFavourite(domain: string, id: string) {
+    const ids = localStorage.getItem(`${domain}_favourite`);
+    if (!ids) {
+      _setFavourite(domain, [id]);
+      return;
+    }
+    const idArr = ids!.split(',');
+    idArr.push(id);
+    _setFavourite(domain, idArr);
+  }
+
+  function _removeFromFavourite(domain: string, id: string) {
+    const ids = localStorage.getItem(`${domain}_favourite`);
+    if (!ids) {
+      return;
+    }
+    const idArr = ids.split(',').filter((i: string) => i !== id);
+    _setFavourite(domain, idArr);
+  }
+
+  function _clearFavourite() {
+    for (const key in localStorage) {
+      if (key.includes('_favourite')) {
+        localStorage.removeItem(key);
+      }
+    }
+  }
+  // function _getAccessToken() {
+  //   return localStorage.getItem('access_token');
+  // }
+  // function _getRefreshToken() {
+  //   return localStorage.getItem('refresh_token');
+  // }
+  // function _clearTokens() {
+  //   localStorage.removeItem('access_token');
+  //   localStorage.removeItem('refresh_token');
+  // }
+
+  return {
+    addToFavourite: _addToFavourite,
+    removeFromFavourite: _removeFromFavourite,
+    setFavourite: _setFavourite,
+    isFavourite: _isFavourite,
+    clearFavourite: _clearFavourite,
+  };
+})();
+
+export default FavouriteService;

package/src/services/HttpClient.ts

@@ -0,0 +1,199 @@
+import HttpEngine from "@/services/Axios";
+import FileInfo from "@/classes/FileInfo";
+import {
+  IBodilessParams,
+  IBodyfulParams,
+} from "@/interfaces/IHTTPTypes";
+
+import LocalStore from "../classes/LocalStore";
+import LocalStoreKeys from "../interfaces/LocalStoreKeys";
+import HttpHeaders, {
+  HttpHeadersKeys,
+  HttpHeadersValues,
+} from "../types/HttpHeaders";
+
+const baseUrl = import.meta.env.VITE_APP_BASE_URL ?? "";
+const apiVersion = import.meta.env.VITE_APP_API_V1 ?? "";
+const apiHost = import.meta.env.VITE_APP_API_HOST ?? "";
+
+export default class HttpClient {
+  endpoint: string;
+  headers: HttpHeaders;
+
+  constructor(endpoint = "") {
+    this.endpoint = endpoint;
+    this.headers = {
+      [HttpHeadersKeys.ContentType]: HttpHeadersValues.ApplicationJson,
+    };
+  }
+
+  newWebSocket(query: string): WebSocket {
+    const url =
+      apiHost.replace("http", "ws") + "/ws" + "/" + this.endpoint + "/" + query;
+    return new WebSocket(url);
+  }
+
+  private static download(clientFileName: string | undefined, res: unknown) {
+    const fileName = HttpClient.getDownloadFileName(
+      clientFileName,
+      res.headers
+    );
+    const url = URL.createObjectURL(res.data);
+
+    const link = document.createElement("a");
+    link.href = url;
+    link.setAttribute("download", fileName);
+    link.setAttribute("target", "_blank");
+    document.body.appendChild(link);
+    link.click();
+  }
+
+  // eslint-disable-next-line
+  private static getDownloadFileName(
+    clientFileName: string | undefined,
+    headers: any
+  ): string {
+    if (clientFileName) {
+      return clientFileName;
+    }
+    const headerLine = headers["content-disposition"];
+    const startFileNameIndex = headerLine.indexOf('"') + 1;
+    const endFileNameIndex = headerLine.lastIndexOf('"');
+    const serverFileName = headerLine.substring(
+      startFileNameIndex,
+      endFileNameIndex
+    );
+
+    if (serverFileName) {
+      return serverFileName;
+    }
+    return "file";
+  }
+
+  private getHeaders(headers?: HttpHeaders): HttpHeaders {
+    const token = LocalStore.Get<string>(LocalStoreKeys.AccessToken);
+    if (!headers) {
+      headers = this.headers;
+    }
+    if (token) {
+      headers[HttpHeadersKeys.Token] = token;
+    }
+    return headers ?? this.headers;
+  }
+
+  private returnResponse<ReturnType, PayloadType>(
+    params: IBodilessParams | IBodyfulParams<PayloadType> | undefined,
+    res: unknown
+  ): ReturnType | void {
+    if (!res) {
+      return;
+    }
+    return params?.isBlob
+      ? HttpClient.download(params.downloadFileName, res)
+      : res.data;
+  }
+
+  async get<ReturnType>(params?: IBodilessParams): Promise<ReturnType | void> {
+    return this.returnResponse(
+      params,
+      await HttpEngine.Get(
+        this.buildUrl(params?.query),
+        this.getHeaders(params?.headers),
+        this.getResponseType(params?.isBlob)
+      )
+    );
+  }
+
+  async post<PayloadType, ReturnType>(
+    params: IBodyfulParams<PayloadType>
+  ): Promise<ReturnType | void> {
+    return this.returnResponse(
+      params,
+      await HttpEngine.Post(
+        this.buildUrl(params?.query),
+        this.getHeaders(params?.headers),
+        this.getResponseType(params.isBlob),
+        this.createFormDataPayload<PayloadType>(
+          params?.payload,
+          params?.fileInfos
+        )
+      )
+    );
+  }
+
+  async put<PayloadType, ReturnType>(
+    params: IBodyfulParams<PayloadType>
+  ): Promise<ReturnType | void> {
+    return this.returnResponse(
+      params,
+      await HttpEngine.Put(
+        this.buildUrl(params?.query),
+        this.getHeaders(params?.headers),
+        this.createFormDataPayload<PayloadType>(
+          params?.payload,
+          params?.fileInfos
+        )
+      )
+    );
+  }
+
+  async delete<PayloadType, ReturnType>(
+    params: IBodyfulParams<PayloadType>
+  ): Promise<ReturnType | void> {
+    return this.returnResponse(
+      params,
+      await HttpEngine.Delete(
+        this.buildUrl(params?.query),
+        this.getHeaders(params?.headers),
+        this.createFormDataPayload<PayloadType>(
+          params?.payload,
+          params?.fileInfos
+        )
+      )
+    );
+  }
+
+  async subscribe<PayloadType>(
+    params: IBodyfulParams<PayloadType>
+  ): Promise<EventSource> {
+    const { query } = params;
+
+    const source = new EventSource(this.buildUrl(query));
+    return source;
+  }
+
+  private buildUrl(query?: string): string {
+    if (query) {
+      const queryString = query ?? "";
+      return this.endpoint.length <= 0
+        ? baseUrl + apiVersion + queryString
+        : baseUrl + apiVersion + this.endpoint + "/" + queryString;
+    }
+    return baseUrl + apiVersion + this.endpoint;
+  }
+
+  private getResponseType(blob?: boolean): "blob" | "json" {
+    return blob ? "blob" : "json";
+  }
+
+  private createFormDataPayload<PayloadType>(
+    payload?: PayloadType,
+    fileInfos?: FileInfo[]
+  ): FormData {
+    const data = new FormData();
+    data.append("form", JSON.stringify(payload));
+
+    if (fileInfos) {
+      for (const fileInfo of fileInfos) {
+        if (fileInfo.file) {
+          data.append(
+            fileInfo.id ?? "files",
+            fileInfo.file,
+            fileInfo.originalName
+          );
+        }
+      }
+    }
+    return data;
+  }
+}

package/src/services/HttpClientS.ts

@@ -0,0 +1,188 @@
+import HttpEngine from "@/services/Axios";
+import FileInfo from "@/classes/FileInfo";
+import {
+  IBodilessParams,
+  IBodyfulParams,
+} from "@/interfaces/IHTTPTypes";
+
+import LocalStore from "../classes/LocalStore";
+import LocalStoreKeys from "../interfaces/LocalStoreKeys";
+import HttpHeaders, {
+  HttpHeadersKeys,
+  HttpHeadersValues,
+} from "../types/HttpHeaders";
+
+const baseUrl = import.meta.env.VITE_APP_BASE_URL ?? "";
+const apiVersion = import.meta.env.VITE_APP_API_V1 ?? "";
+const apiHost = import.meta.env.VITE_APP_API_HOST ?? "";
+
+export default abstract class HttpClient {
+  static headers: HttpHeaders = {
+    [HttpHeadersKeys.ContentType]: HttpHeadersValues.ApplicationJson,
+  };
+
+  newWebSocket(query: string): WebSocket {
+    const url = apiHost.replace("http", "ws") + "/ws" + "/" + query;
+    return new WebSocket(url);
+  }
+
+  private static download(clientFileName: string | undefined, res: unknown) {
+    const fileName = HttpClient.getDownloadFileName(
+      clientFileName,
+      res.headers
+    );
+    const url = URL.createObjectURL(res.data);
+
+    const link = document.createElement("a");
+    link.href = url;
+    link.setAttribute("download", fileName);
+    link.setAttribute("target", "_blank");
+    document.body.appendChild(link);
+    link.click();
+  }
+
+  // eslint-disable-next-line
+  private static getDownloadFileName(
+    clientFileName: string | undefined,
+    headers: any
+  ): string {
+    if (clientFileName) {
+      return clientFileName;
+    }
+    const headerLine = headers["content-disposition"];
+    const startFileNameIndex = headerLine.indexOf('"') + 1;
+    const endFileNameIndex = headerLine.lastIndexOf('"');
+    const serverFileName = headerLine.substring(
+      startFileNameIndex,
+      endFileNameIndex
+    );
+
+    if (serverFileName) {
+      return serverFileName;
+    }
+    return "file";
+  }
+
+  private static getHeaders(headers?: HttpHeaders): HttpHeaders {
+    const token = LocalStore.Get<string>(LocalStoreKeys.AccessToken);
+    if (!headers) {
+      headers = HttpClient.headers;
+    }
+    if (token) {
+      headers[HttpHeadersKeys.Token] = token;
+    }
+    return headers ?? HttpClient.headers;
+  }
+
+  private static returnResponse<ReturnType, PayloadType>(
+    params: IBodilessParams | IBodyfulParams<PayloadType> | undefined,
+    res: unknown
+  ): ReturnType | void {
+    if (!res) {
+      return;
+    }
+    return params?.isBlob
+      ? HttpClient.download(params.downloadFileName, res)
+      : res.data;
+  }
+
+  static async Get<ReturnType>(
+    params?: IBodilessParams
+  ): Promise<ReturnType | void> {
+    return HttpClient.returnResponse(
+      params,
+      await HttpEngine.Get(
+        HttpClient.buildUrl(params?.query ?? ""),
+        HttpClient.getHeaders(params?.headers),
+        HttpClient.getResponseType(params?.isBlob)
+      )
+    );
+  }
+
+  static async Post<PayloadType, ReturnType>(
+    params: IBodyfulParams<PayloadType>
+  ): Promise<ReturnType | void> {
+    return HttpClient.returnResponse(
+      params,
+      await HttpEngine.Post(
+        HttpClient.buildUrl(params?.query),
+        HttpClient.getHeaders(params?.headers),
+        HttpClient.getResponseType(params.isBlob),
+        HttpClient.createFormDataPayload<PayloadType>(
+          params?.payload,
+          params?.fileInfos
+        )
+      )
+    );
+  }
+
+  static async Put<PayloadType, ReturnType>(
+    params: IBodyfulParams<PayloadType>
+  ): Promise<ReturnType | void> {
+    return HttpClient.returnResponse(
+      params,
+      await HttpEngine.Put(
+        HttpClient.buildUrl(params?.query),
+        HttpClient.getHeaders(params?.headers),
+        HttpClient.createFormDataPayload<PayloadType>(
+          params?.payload,
+          params?.fileInfos
+        )
+      )
+    );
+  }
+
+  static async Delete<PayloadType, ReturnType>(
+    params: IBodyfulParams<PayloadType>
+  ): Promise<ReturnType | void> {
+    return HttpClient.returnResponse(
+      params,
+      await HttpEngine.Delete(
+        HttpClient.buildUrl(params?.query),
+        HttpClient.getHeaders(params?.headers)
+      )
+    );
+  }
+
+  static async Subscribe<PayloadType>(
+    params: IBodyfulParams<PayloadType>
+  ): Promise<EventSource> {
+    const { query } = params;
+
+    const source = new EventSource(HttpClient.buildUrl(query));
+    return source;
+  }
+
+  private static buildUrl(query: string): string {
+    const queryString = query ?? "";
+    return baseUrl + apiVersion + queryString;
+    // const queryString = query ? '/' + query : '';
+    // return baseUrl + '/' + apiVersion + '/' + queryString;
+  }
+
+  private static getResponseType(blob?: boolean): "blob" | "json" {
+    return blob ? "blob" : "json";
+  }
+
+  private static createFormDataPayload<PayloadType>(
+    payload?: PayloadType,
+    fileInfos?: FileInfo[]
+  ): FormData {
+    const data = new FormData();
+    data.append("form", JSON.stringify(payload));
+    console.log(data, payload, fileInfos);
+
+    if (fileInfos) {
+      for (const fileInfo of fileInfos) {
+        if (fileInfo.file) {
+          data.append(
+            fileInfo.id ?? "files",
+            fileInfo.file,
+            fileInfo.originalName
+          );
+        }
+      }
+    }
+    return data;
+  }
+}