sprof 0.0.1

package/src/services/HttpError.ts

@@ -0,0 +1,58 @@
+import { AxiosInstance } from 'axios';
+
+import TokenService from '@/services/Token';
+
+import ClassHelper from './ClassHelper';
+import PHelp from './PHelp';
+
+export default class HttpError {
+  private code = 400;
+  private err = '';
+
+  constructor(i?: HttpError) {
+    ClassHelper.BuildClass(this, i);
+  }
+
+  getErr(): string {
+    return this.capitalizedErr();
+  }
+
+  private capitalizedErr(): string {
+    return this.err.charAt(0).toUpperCase() + this.err.slice(1);
+  }
+
+  // eslint-disable-next-line
+  static async Handle(error: any, axiosInstance: AxiosInstance) {
+    const originalRequest = error.config;
+    if (!error.response) {
+      return;
+    }
+    if (error.response.status === 401 && !originalRequest._retry) {
+      originalRequest._retry = true;
+      try {
+        // await AuthStore.RefreshToken();
+      } catch (e) {
+        // await AuthStore.Logout();
+        return;
+      }
+      axiosInstance.defaults.headers.common['token'] = TokenService.getAccessToken();
+      error.config.headers['token'] = TokenService.getAccessToken();
+      error.config.baseURL = undefined;
+      return axiosInstance.request(originalRequest);
+    }
+    if (error.response.status >= 500) {
+      if (error.response.data === 'неверный логин или пароль') {
+        PHelp.Notification.Error('Неверный логин или пароль');
+        return;
+      }
+      PHelp.Notification.Error('Ошибка на сервере, попробуйте позже');
+    }
+    if (error.response.status >= 400 && error.response.status < 500) {
+      const err = new HttpError(error.response.data).getErr();
+      if (err) {
+        PHelp.Notification.Error(err);
+      }
+    }
+    return Promise.reject(error);
+  }
+}

package/src/services/Loading.ts

@@ -0,0 +1,14 @@
+import Visible from './Visible';
+
+class LoadingC extends Visible {
+  Show() {
+    super.show();
+  }
+
+  Hide() {
+    super.hide();
+  }
+}
+
+const Loading: LoadingC = new LoadingC();
+export default Loading;

package/src/services/MakeCarousel.ts

@@ -0,0 +1,10 @@
+export default function makeCarousel<ArrayType>(array: ArrayType[], size: number): ArrayType[][] {
+  // size - number of banners in el-carousel-item
+  const subarray = [];
+  if (array) {
+    for (let i = 0; i < Math.ceil(array.length / size); i++) {
+      subarray[i] = array.slice(i * size, i * size + size);
+    }
+  }
+  return subarray;
+}

package/src/services/Menu.ts

@@ -0,0 +1,102 @@
+import { v4 as uuidv4 } from 'uuid';
+
+// import IElementPlusFile from '@/interfaces/files/IElementPlusFile';
+import FileInfo from '@/classes/FileInfo';
+import Page from '@/classes/page/Page';
+import SubMenu from '@/classes/SubMenu';
+import ClassHelper from '@/services/ClassHelper';
+import IFile from '@/interfaces/IFile';
+
+export default class Menu {
+  id?: string;
+  name = '';
+  link = '';
+  top = true;
+  side = true;
+  show = false;
+  hide = false;
+  active = false;
+  order = 0;
+  selected = false;
+  editMode = false;
+
+  page = new Page();
+  pageId?: string;
+
+  @ClassHelper.GetClassConstructor(SubMenu)
+  subMenus: SubMenu[] = [];
+  subMenusForDelete: string[] = [];
+
+  iconId?: string;
+  icon = new FileInfo();
+
+  constructor(i?: Menu) {
+    ClassHelper.BuildClass(this, i);
+  }
+
+  getLink(): string {
+    if (this.isLink() && !this.isPageLink()) {
+      return this.link;
+    }
+    if (!this.isLink() && this.isPageLink()) {
+      return this.page.getLink();
+    }
+    return '';
+  }
+
+  withoutChildren(): boolean {
+    return this.subMenus.length === 0;
+  }
+
+  isLink(): boolean {
+    return this.link !== '';
+  }
+
+  isPageLink(): boolean {
+    return !!this.pageId && this.pageId !== '';
+  }
+
+  getFileInfos(): FileInfo[] {
+    const fileInfos: FileInfo[] = [];
+    fileInfos.push(this.icon);
+    this.subMenus.forEach((subMenu: SubMenu) => {
+      fileInfos.push(subMenu.icon);
+    });
+    return fileInfos;
+  }
+
+  addFile(file: File & IFile): void {
+    if (!this.icon.id) {
+      this.icon.id = uuidv4();
+    }
+    this.icon.originalName = file.name;
+    this.icon.file = file.raw;
+  }
+
+  addSubMenu(): void {
+    this.subMenus.push(new SubMenu());
+  }
+
+  removeSubMenu(index: number): void {
+    const idForDelete = this.subMenus[index].id;
+    if (idForDelete) {
+      this.subMenusForDelete.push(idForDelete);
+    }
+    this.subMenus.splice(index, 1);
+  }
+
+  setColorsForSubMenus(): void {
+    const colors: string[] = ['#00A248', '#E63021', '#006BB5', '#F3911F', '#6F6D6B'];
+    let i = 0;
+    this.subMenus.forEach((subMenu) => {
+      subMenu.color = colors[i];
+      i === colors.length - 1 ? (i = 0) : i++;
+    });
+  }
+  containPath(path: string): boolean {
+    return this.getLink() === path || !!this.subMenus.find((subMenu: SubMenu) => subMenu.getLink() === path);
+  }
+  static GetClassName(): string {
+    return 'menu';
+  }
+}

package/src/services/Message.ts

@@ -0,0 +1,66 @@
+import Statuses from "../types/Statuses";
+import Visible from "./Visible";
+
+export type MessageOpts = {
+  text: string;
+  title?: string;
+};
+
+export default class Message extends Visible {
+  private type: Statuses = Statuses.Success;
+  private text = "";
+  private title = "";
+
+  protected showMessage(m: string | MessageOpts, t: Statuses) {
+    this.hide();
+    this.type = t;
+    if (typeof m === "string") {
+      this.text = m;
+    } else {
+      this.text = m.text;
+      this.title = m.title ?? "";
+    }
+    super.show();
+  }
+
+  GetText(): string {
+    return this.text;
+  }
+
+  GetTitle(): string {
+    return this.title;
+  }
+
+  GetType(): Statuses {
+    return this.type;
+  }
+
+  Info(m: string | MessageOpts): void {
+    this.showMessage(m, Statuses.Info);
+  }
+
+  Success(m: string | MessageOpts): void {
+    this.showMessage(m, Statuses.Success);
+  }
+
+  Error(m: string | MessageOpts): void {
+    this.showMessage(m, Statuses.Error);
+  }
+
+  Warning(m: string | MessageOpts): void {
+    this.showMessage(m, Statuses.Warning);
+  }
+
+  // eslint-disable-next-line
+  FormMessage(errorFields: any): string {
+    let errorMessage =
+      "<strong>Проверьте правильность введенных данных:</strong><ul>";
+    for (const item of Object.keys(errorFields)) {
+      if (errorFields[item][0] && errorFields[item][0].message) {
+        errorMessage += `<li>${errorFields[item][0].message}</li>`;
+      }
+    }
+    errorMessage += "</ul>";
+    return errorMessage;
+  }
+}

package/src/services/Notification.ts

@@ -0,0 +1,37 @@
+import Message, { MessageOpts } from "./Message";
+import Time from "./Time";
+import Timer from "./Timer";
+import Statuses from "../types/Statuses";
+
+type NotificationOpts = MessageOpts & {
+  duration: number;
+};
+
+class NotificationConstructor extends Message {
+  private duration = Time.S(3);
+
+  protected showMessage(m: string | NotificationOpts, t: Statuses) {
+    super.showMessage(m, t);
+    if (typeof m !== "string") {
+      this.duration = m.duration ?? this.duration;
+    }
+    Timer.Wait(this.GetDuration()).then(() => super.hide());
+  }
+
+  private GetDuration(): number {
+    return this.duration;
+  }
+  Dev() {
+    const m = "В режиме разработки";
+    const t = Statuses.Warning;
+    super.showMessage(m, t);
+  }
+  Save() {
+    const m = "Изменения успешно сохранены";
+    const t = Statuses.Success;
+    super.showMessage(m, t);
+  }
+}
+
+const Notification: NotificationConstructor = new NotificationConstructor();
+export default Notification;

package/src/services/PHelp.ts

@@ -0,0 +1,20 @@
+import AdminUI from "./AdminUI";
+import Auth from "../classes/Auth";
+import AuthForm from "../classes/AuthForm";
+import AuthModal from "../classes/AuthModal";
+import Dialog from "./Dialog";
+import Loading from "./Loading";
+import Notification from "./Notification";
+import Paginator from "./Paginator";
+
+export default abstract class PHelp {
+  static Auth = reactive(Auth);
+  static AuthForm = reactive(AuthForm);
+  static AuthModal = reactive(AuthModal);
+
+  static AdminUI = reactive(AdminUI);
+  static Dialog = reactive(Dialog);
+  static Notification = reactive(Notification);
+  static Loading = reactive(Loading);
+  static Paginator = reactive(Paginator);
+}

package/src/services/Paginator.ts

@@ -0,0 +1,22 @@
+class Paginator {
+  limit = 25;
+
+  count = 0;
+  curPage = 1;
+  storeModule? = '';
+
+  setCurPage(page: number): void {
+    this.curPage = page;
+  }
+
+  pagesCount(): number {
+    return Math.ceil(this.count / this.limit) ?? 1;
+  }
+  reset(): void {
+    this.count = 0;
+    this.curPage = 1;
+  }
+}
+
+const s = new Paginator();
+export default s;

package/src/services/Period.ts

@@ -0,0 +1,29 @@
+type Comparable = number | string | Date;
+
+export default abstract class Period {
+  static Get(start: string, end: string, divider = '-'): string {
+    if (!start || !end) {
+      return '';
+    }
+    return `${start}${divider}${end}`;
+  }
+
+  static In(obj: Comparable, start: Comparable, end: Comparable): boolean {
+    return obj >= start && obj <= end;
+  }
+  static Intersects(p1Start: Comparable, p1End: Comparable, p2Start: Comparable, p2End: Comparable): boolean {
+    if (p1Start === p2Start || p1End === p2End) {
+      return true;
+    }
+    if (p1Start > p2Start && p1Start < p2End) {
+      return true;
+    }
+    if (p1End > p2Start && p1End < p2End) {
+      return true;
+    }
+    if (p1End > p2End && p1Start < p2Start) {
+      return true;
+    }
+    return false;
+  }
+}

package/src/services/PhoneService.ts

@@ -0,0 +1,46 @@
+export default class PhoneService {
+  static Format(phone: string): string {
+    let value = phone;
+    if (!value) {
+      phone = value;
+    } else {
+      if ((value[0] === '7' || value[0] === '8') && value.length !== 1) value = value.slice(1);
+      const phoneNumber = value.replace(/\+7|[^\d]/g, '');
+      const phoneNumberLength = phoneNumber.length;
+      switch (true) {
+        case phoneNumberLength === 0:
+          phone = '';
+          break;
+        case phoneNumberLength === 1 && value.length === 1 && phoneNumber === '7':
+        case phoneNumberLength === 1 && value.length === 1 && phoneNumber === '8':
+          phone = '+7 (';
+          break;
+        case phoneNumberLength < 4:
+          phone = `+7 (${phoneNumber}`;
+          break;
+        case phoneNumberLength < 7:
+          phone = `+7 (${phoneNumber.slice(0, 3)}) ${phoneNumber.slice(3)}`;
+          break;
+        case phoneNumberLength < 9:
+          phone = `+7 (${phoneNumber.slice(0, 3)}) ${phoneNumber.slice(3, 6)}-${phoneNumber.slice(6, 8)}`;
+          break;
+        default:
+          phone = `+7 (${phoneNumber.slice(0, 3)}) ${phoneNumber.slice(3, 6)}-${phoneNumber.slice(6, 8)}-${phoneNumber.slice(8, 10)}`;
+          break;
+      }
+    }
+    return phone;
+  }
+
+  private static getPhoneRegExp(): RegExp {
+    return /^(\s*)?(\+)?([- _():=+]?\d[- _():=+]?){10,14}(\s*)?$/;
+  }
+
+  static validatePhone = (_: unknown, value: string, callback: CallableFunction): void => {
+    if (PhoneService.getPhoneRegExp().test(value) || !value) {
+      callback();
+    } else {
+      callback(new Error('Пожалуйста, введите корректный номер телефона'));
+    }
+  };
+}

package/src/services/Router.ts

@@ -0,0 +1,85 @@
+import { RouteLocationNormalizedLoaded } from 'vue-router';
+import { RouteLocation } from 'vue-router';
+
+import router from '@/router';
+
+import PHelp from './PHelp';
+
+export default abstract class Router {
+  static async To(route: string) {
+    PHelp.Loading.Show();
+    await router.push(route);
+    PHelp.Loading.Hide();
+  }
+
+  static async ToHome() {
+    PHelp.Loading.Show();
+    const home = import.meta.env.VITE_HOME_PAGE;
+    await router.push(home);
+    PHelp.Loading.Hide();
+  }
+  static async Replace(route: string) {
+    await router.replace(route);
+  }
+
+  static Id(): string {
+    return Router.GetStringParam('id');
+  }
+
+  static Slug(): string {
+    return Router.GetStringParam('slug');
+  }
+
+  static async Back() {
+    PHelp.Loading.Show();
+    router.go(-1);
+    PHelp.Loading.Hide();
+  }
+
+  static GetQid() {
+    return Router.GetStringQueryParam('qid');
+  }
+
+  static Route(): RouteLocationNormalizedLoaded {
+    return router.currentRoute.value;
+  }
+
+  static RouterPushBlank(path: string): void {
+    const route = router.resolve({ path: path });
+    window.open(route.href, '_blank');
+  }
+
+  static GetPath(): string {
+    const arr = Router.Route().path.split('/');
+    return arr[arr.length - 1];
+  }
+
+  static async ToAdmin(path?: string): Promise<void> {
+    if (!path) {
+      await router.push(`/admin`);
+      return;
+    }
+    let safePath = path;
+    if (safePath[0] === '/') {
+      safePath = path.substring(1);
+    }
+    await Router.To(`/admin/${safePath}`);
+  }
+  static GetStringQueryParam(param: string): string {
+    return String(Router.Route().query[param]);
+  }
+
+  static GetNumberQueryParam(param: string): number {
+    return Number(Router.Route().query[param] ?? 0);
+  }
+  static GetStringParam(param: string): string {
+    return Router.Route().params[param] as string;
+  }
+
+  static Resolve(link: string): RouteLocation {
+    return router.resolve(link);
+  }
+  static GetRouter() {
+    return router;
+  }
+}

package/src/services/RouterGuard.ts

@@ -0,0 +1,15 @@
+import { NavigationGuardNext } from 'vue-router';
+
+export default abstract class RouterGuard {
+  static async Auth(next?: NavigationGuardNext): Promise<void> {
+    if (next) {
+      next();
+    }
+  }
+
+  static Dev(): void {
+    // if (!UserService.isAdmin()) {
+    //   router.push('/dev');
+    // }
+  }
+}

package/src/services/Scheduler.ts

@@ -0,0 +1,66 @@
+import Time, { TimelineMinutes, TimelineSteps } from "@/services/Time";
+
+import Arrays from "./Arrays";
+import IWithId from "../interfaces/IWithId";
+interface IWithTimePeriod {
+  startTime: string;
+  endTime: string;
+}
+export default class Scheduler {
+  startHour = 9;
+  startHM = `${this.startHour}:00`;
+  endHour = 19;
+  endHM = `${this.endHour}:00`;
+
+  timelinePxHeight = 50;
+
+  timelineStep: TimelineSteps = TimelineSteps.FiveMinutes;
+
+  timelines: string[] = TimelineMinutes[TimelineSteps.FiveMinutes];
+
+  periodIsCorrect(t1: string, t2: string): boolean {
+    return Time.GtOrEq(t1, this.startHM) && Time.GtOrEq(this.endHM, t2);
+  }
+
+  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);
+  }
+
+  timeIsFree(
+    t1: string,
+    t2: string,
+    movedObjectId: string,
+    scheduleItems: (IWithTimePeriod & IWithId)[]
+  ): boolean {
+    return scheduleItems
+      .filter((i: IWithId) => i.id !== movedObjectId)
+      .every(
+        (i: IWithTimePeriod) =>
+          !Time.PeriodsIntersects(t1, t2, i.startTime, i.endTime)
+      );
+  }
+
+  sortByStartTime(scheduleItems: IWithTimePeriod[]): void {
+    scheduleItems.sort(
+      (s1: IWithTimePeriod, s2: IWithTimePeriod) =>
+        Time.HMtoM(s1.startTime) - Time.HMtoM(s2.startTime)
+    );
+  }
+}

package/src/services/Scroll.ts

@@ -0,0 +1,19 @@
+// height 58 - margin
+const HeaderHeight = -58 - 10;
+
+export default function scroll(query?: string, yOffset?: number): void {
+  if (!query) {
+    document.body.scrollTo({ top: 0, behavior: 'smooth' });
+    return;
+  }
+  const el = document.querySelector(query);
+  const offset = yOffset ?? HeaderHeight;
+  let y = 0;
+  if (el) {
+    const elRect = el.getBoundingClientRect();
+    y = elRect.top + offset + document.body.scrollTop;
+  }
+  if (y) {
+    document.body.scrollTo({ top: y, behavior: 'smooth' });
+  }
+}

package/src/services/SortList.ts

@@ -0,0 +1,44 @@
+import createSortModels from "@/services/CreateSortModels";
+import { SortModelBuildersLib } from "@/interfaces/Sort";
+
+import SortModel from "../classes/SortModel";
+
+class SortListC {
+  private list: SortModel[] = [];
+  private defaultSortModel: SortModel | undefined;
+  changeFlag = false;
+
+  Set(sorts?: SortModelBuildersLib | SortModel[]): void {
+    this.Reset();
+    if (!sorts) {
+      return;
+    }
+    if (Array.isArray(sorts)) {
+      this.list = sorts;
+    } else {
+      this.list = createSortModels(sorts);
+    }
+    this.SetDefault();
+  }
+
+  SetDefault() {
+    this.defaultSortModel =
+      this.list.find((s: SortModel) => s.default) ?? this.list[0];
+    this.changeFlag = !this.changeFlag;
+  }
+
+  Get(): SortModel[] {
+    return this.list;
+  }
+
+  GetDefault(): SortModel | undefined {
+    return this.defaultSortModel;
+  }
+  Reset(): void {
+    this.list = [];
+    this.defaultSortModel = undefined;
+  }
+}
+
+const SortList = new SortListC();
+export default SortList;

package/src/services/Sorter.ts

@@ -0,0 +1,6 @@
+import IOrdered from '@/interfaces/IOrdered';
+export default class Sorter {
+  static Sort(ordered: IOrdered[]) {
+    ordered.forEach((o: IOrdered, i: number) => (o.order = i));
+  }
+}

package/src/services/Strings.test.ts

@@ -0,0 +1,30 @@
+describe('Strings', () => {
+  test('CapitalizeFirstLetter', () => {
+    const str = 'str';
+    const res = Strings.Capitalize(str);
+    expect(res).toEqual('Str');
+  });
+
+  test('Capitalize empty string return empty string', () => {
+    const res = Strings.Capitalize('');
+    expect(res).toEqual('');
+  });
+
+  test('JoinSnake', () => {
+    const res = Strings.JoinSnake('a', 'b');
+    expect(res).toEqual('a_b');
+  });
+
+  describe('ToCamelCase', () => {
+    const words: Record<string, string> = { a_b: 'aB', 'a b': 'aB', 'a-b': 'aB', а_я: 'аЯ', CAP: 'cap', АЯ: 'ая', 'а-Я': 'аЯ' };
+
+    for (const key in words) {
+      describe(`When given ${key}`, () => {
+        test(`Then given ${words[key]}`, () => {
+          const res = Strings.ToCamelCase(key);
+          expect(res).toEqual(words[key]);
+        });
+      });
+    }
+  });
+});