sprof 0.0.1

package/src/classes/SearchModel.ts

@@ -0,0 +1,61 @@
+import Pagination from '@/classes/filters/Pagination';
+import SearchElement from '@/classes/SearchElement';
+import SearchGroup from '@/classes/SearchGroup';
+import ISearchObject from '@/interfaces/ISearchObject';
+
+export default class SearchModel {
+  query = '';
+  key = '';
+  params = '';
+  suggester = false;
+  mustBeTranslated = true;
+  options: SearchElement[] = [];
+  searchGroupId = '';
+  searchGroups: SearchGroup[] = [];
+  searchGroup: SearchGroup = new SearchGroup();
+  searchObjects: ISearchObject[] = [];
+  pagination: Pagination = new Pagination();
+  count = 0;
+
+  constructor(i?: SearchModel) {
+    if (!i) {
+      return;
+    }
+    this.query = i.query;
+    if (i.searchGroups) {
+      this.searchGroups = i.searchGroups.map((item: SearchGroup) => new SearchGroup(item));
+    }
+    if (i.searchGroup) {
+      this.searchGroup = new SearchGroup(i.searchGroup);
+    }
+    if (i.options) {
+      this.options = i.options.map((item: SearchElement) => new SearchElement(item));
+    }
+    this.count = i.count;
+  }
+
+  toUrl(): string {
+    return JSON.stringify(this);
+  }
+
+  async setSearchGroup(groupId: string | undefined): Promise<void> {
+    const g = this.searchGroups.find((group: SearchGroup) => group.id === groupId);
+    if (g) {
+      this.searchGroup = g;
+    } else {
+      this.searchGroup = new SearchGroup();
+    }
+  }
+
+  async reproduceFromRoute(): Promise<void> {
+    this.setQuery();
+    await this.setSearchGroup(Router.Route().query.groupId as string);
+  }
+
+  setQuery(): void {
+    const query = Router.Route().query.query;
+    if (query) {
+      this.query = query as string;
+    }
+  }
+}

package/src/classes/SortModel.ts

@@ -0,0 +1,57 @@
+import { Orders } from '@/interfaces/Orders';
+
+import ClassHelper from '../ClassHelper';
+import { ClassNameGetter } from '../interfaces/Class';
+
+export default class SortModel {
+  model = '';
+  col = '';
+  order: Orders | undefined;
+  label = '';
+  default = false;
+  selected = false;
+
+  constructor(i?: SortModel) {
+    ClassHelper.BuildClass(this, i);
+  }
+
+  static Create(model: ClassNameGetter, col: unknown, order: Orders = Orders.Asc, label?: string, defaultModel?: boolean): SortModel {
+    const m = new SortModel();
+    m.model = model.GetClassName();
+    m.col = (col as string) ?? '';
+    m.order = order ?? Orders.Asc;
+    m.label = label ?? '';
+    m.default = defaultModel ?? false;
+    return m;
+  }
+
+  isAsc(): boolean {
+    return this.order === Orders.Asc;
+  }
+
+  isDesc(): boolean {
+    return this.order === Orders.Desc;
+  }
+
+  eq(s: SortModel): boolean {
+    return s.model === this.model && s.col === this.col && s.order === this.order;
+  }
+  toUrlQuery(): string {
+    const model = this.model ? `"model":"${this.model}"` : '';
+    const col = this.col ? `"col":"${this.col}"` : '';
+    const order = this.order ? `"order":"${this.order}"` : '';
+
+    return [model, col, order].toString();
+  }
+  async fromUrlQuery(): Promise<void> {
+    const str = window.location.search;
+    const sormModelString = str.substring(str.indexOf('s=') + 2, str.indexOf('|'));
+    const params = new URLSearchParams(decodeURIComponent(sormModelString));
+    this.model = params.get('model') ?? '';
+    this.col = params.get('col') ?? '';
+    this.label = params.get('label') ?? '';
+    this.default = Boolean(params.get('default'));
+    // this.id = params.get('id') ?? '';
+    this.order = (params.get('order') as Orders) ?? ('' as Orders);
+  }
+}

package/src/classes/SubMenu.ts

@@ -0,0 +1,56 @@
+import { v4 as uuidv4 } from 'uuid';
+
+import FileInfo from '@/classes/FileInfo';
+import Page from '@/classes/page/Page';
+import ClassHelper from '@/services/ClassHelper';
+import IFile from '@/interfaces/IFile';
+
+export default class SubMenu {
+  id?: string;
+  name = '';
+  link = '';
+  selected = false;
+  hide = false;
+  editMode = false;
+  color = '';
+  background = '';
+
+  page = new Page();
+  pageId?: string;
+  order = 0;
+  menuId?: string;
+
+  iconId?: string;
+  icon = new FileInfo();
+  iconName = '';
+  svgCode = '';
+
+  constructor(i?: SubMenu) {
+    ClassHelper.BuildClass(this, i);
+  }
+
+  getLink(): string {
+    if (this.isLink() && !this.isPageLink()) {
+      return this.link;
+    }
+    if (!this.isLink() && this.isPageLink()) {
+      return this.page.getLink();
+    }
+    return '';
+  }
+
+  isLink(): boolean {
+    return this.link !== '';
+  }
+
+  isPageLink(): boolean {
+    return this.pageId !== undefined && this.pageId !== '';
+  }
+  addFile(file: File & IFile): void {
+    if (!this.icon.id) {
+      this.icon.id = uuidv4();
+    }
+    this.icon.originalName = file.name;
+    this.icon.file = file.raw;
+  }
+}

package/src/classes/TelephoneNumberRules.ts

@@ -0,0 +1,9 @@
+export default [
+  {
+    required: true,
+    // pattern: /(^\+7 \(\d{3}\) \d{3} \d{2} \d{2}$)|(^\d{3}$)/,
+    message: 'Введите телефон в формате: +7 (123) 456 78 90 или в формате 123',
+    trigger: 'blur',
+  },
+  // { type: 'tel', message: 'Укажите корректный номер телефона.', trigger: 'blur' },
+];

package/src/classes/User.ts

@@ -0,0 +1,17 @@
+import IWithId from '@/interfaces/IWithId';
+
+export default class User<TUser extends IWithId> {
+  private user: TUser | undefined;
+
+  get(): TUser | undefined {
+    return this.user;
+  }
+
+  getId(): string | undefined {
+    return this.getUser()?.id;
+  }
+
+  set(user: TUser): void {
+    this.user = user;
+  }
+}

package/src/classes/UserAccount.ts

@@ -0,0 +1,17 @@
+import ClassHelper from '@/services/ClassHelper';
+
+export default class UserAccount {
+  id?: string;
+  login = '';
+  email = '';
+  password = '';
+
+  constructor(i?: UserAccount) {
+    ClassHelper.BuildClass(this, i);
+  }
+  static Create(): UserAccount {
+    const item = new UserAccount();
+    item.id = ClassHelper.CreateUUID();
+    return item;
+  }
+}

package/src/classes/UserService.ts

@@ -0,0 +1,20 @@
+import IWithId from '@/interfaces/IWithId';
+
+export default class AuthUser<TUser extends IWithId> {
+  private user: TUser | undefined;
+
+  Get(): TUser | undefined {
+    return this.user;
+  }
+
+  GetId(): string | undefined {
+    return this.Get()?.id;
+  }
+
+  Set(user: TUser): void {
+    this.user = user;
+  }
+  Reset(): void {
+    this.user = undefined;
+  }
+}

package/src/classes/ValidationRules.ts

@@ -0,0 +1,15 @@
+enum Trigger {
+  Blur = 'blur',
+}
+
+export default class ValidationRule {
+  required = true;
+  message = '';
+  trigger: Trigger = Trigger.Blur;
+
+  static Create(message: string): ValidationRule {
+    const item = new ValidationRule();
+    item.message = message;
+    return item;
+  }
+}

package/src/classes/ValueType.ts

@@ -0,0 +1,69 @@
+import ClassHelper from '@/services/ClassHelper';
+import ValueRelation from '@/interfaces/ValueRelation';
+
+import ValueTypes from '../types/ValueTypes';
+
+export default class ValueType {
+  id?: string;
+  name: ValueTypes = ValueTypes.String;
+  valueRelation: ValueRelation = ValueRelation.simple;
+
+  constructor(i?: ValueType) {
+    ClassHelper.BuildClass(this, i);
+  }
+
+  isString(): boolean {
+    return this.name === 'string';
+  }
+
+  isNumber(): boolean {
+    return this.name === 'number';
+  }
+
+  isDate(): boolean {
+    return this.name === 'date';
+  }
+
+  isDateTime(): boolean {
+    return this.name === 'dateTime';
+  }
+
+  isRadio(): boolean {
+    return this.name === 'radio';
+  }
+
+  isSet(): boolean {
+    return this.name === 'set';
+  }
+
+  isText(): boolean {
+    return this.name === 'text';
+  }
+
+  isBoolean(): boolean {
+    return this.name === 'boolean';
+  }
+
+  isFile(): boolean {
+    return this.name === 'file';
+  }
+
+  isFiles(): boolean {
+    return this.name === 'files';
+  }
+  getComponentType(): string | undefined {
+    if (this.name === ValueTypes.Radio) {
+      return 'RadioProp';
+    }
+    if (this.name === ValueTypes.Set) {
+      return 'SetProp';
+    }
+    if (this.name === ValueTypes.Number) {
+      return 'NumberProp';
+    }
+    if (this.name === ValueTypes.String) {
+      return 'StringProp';
+    }
+    // return ValueTypesComponentMap[this.name].name;
+  }
+}

package/src/classes/Website.ts

@@ -0,0 +1,11 @@
+import ClassHelper from '@/services/ClassHelper';
+
+export default class Website {
+  id?: string;
+  address?: string;
+  description?: string;
+
+  constructor(i?: Website) {
+    ClassHelper.BuildClass(this, i);
+  }
+}

package/src/classes/WebsiteRules.ts

@@ -0,0 +1,4 @@
+export default [
+  { required: true, message: 'Необходимо указать адрес.', trigger: 'blur' },
+  { type: 'url', message: 'Введите корректный URL-адрес.', trigger: 'blur' },
+];

package/src/classes/admin/AdminButtonParams.ts

@@ -0,0 +1,27 @@
+import { ComputedRef, Ref } from 'vue';
+import { NavigationGuardNext } from 'vue-router';
+
+type actionFunction = ((next?: NavigationGuardNext | undefined) => Promise<void>) | (() => Promise<void>) | (() => void);
+export type buttonAction = undefined | actionFunction | ComputedRef<actionFunction>;
+export default class AdminButtonParams {
+  text?: string | ComputedRef<string> = 'Сохранить';
+  type?: string = 'success';
+  condition?: boolean | ComputedRef<boolean> | Ref<boolean> = true;
+  action?: buttonAction;
+
+  constructor(adminButtonParams?: AdminButtonParams) {
+    if (!adminButtonParams) {
+      return;
+    }
+    if (adminButtonParams.text) {
+      this.text = adminButtonParams.text;
+    }
+    if (adminButtonParams.type) {
+      this.type = adminButtonParams.type;
+    }
+    if (adminButtonParams.condition !== undefined) {
+      this.condition = adminButtonParams.condition;
+    }
+    this.action = adminButtonParams.action;
+  }
+}

package/src/classes/admin/AdminHeaderParams.ts

@@ -0,0 +1,34 @@
+import { ComputedRef } from 'vue';
+
+import AdminButtonParams from './AdminButtonParams';
+
+type f = () => string;
+export default class AdminHeaderParams {
+  title: string | f | ComputedRef = '';
+  showBackButton? = false;
+  buttons: AdminButtonParams[] = [];
+  applicationsCount? = 0;
+
+  constructor(adminHeaderParams?: AdminHeaderParams) {
+    if (!adminHeaderParams) {
+      return;
+    }
+    if (typeof adminHeaderParams.title === 'function') {
+      this.title = adminHeaderParams.title();
+    } else if (typeof adminHeaderParams.title === 'string') {
+      this.title = adminHeaderParams.title;
+    } else {
+      this.title = adminHeaderParams.title.value;
+    }
+
+    if (adminHeaderParams.applicationsCount) {
+      this.applicationsCount = adminHeaderParams.applicationsCount;
+    }
+    if (adminHeaderParams.showBackButton !== undefined) {
+      this.showBackButton = adminHeaderParams.showBackButton;
+    }
+    if (adminHeaderParams.buttons) {
+      this.buttons = adminHeaderParams.buttons.map((item: AdminButtonParams) => new AdminButtonParams(item));
+    }
+  }
+}

package/src/classes/calendar/Calendar.ts

@@ -0,0 +1,168 @@
+import Day from '@/classes/calendar/Day';
+import Month from '@/classes/calendar/Month';
+import Week from '@/classes/calendar/Week';
+import Year from '@/classes/calendar/Year';
+import { CalendarScale } from '@/interfaces/CalendarScale';
+
+export default class Calendar {
+  years: Year[] = [];
+  scale: CalendarScale = CalendarScale.Week;
+
+  static Init(): Calendar {
+    return new Calendar();
+  }
+
+  static InitFull(): Calendar {
+    const calendar = Calendar.Init();
+    for (let i = 2022; i < 2025; i++) {
+      calendar.years.push(Year.InitFull(i));
+    }
+    calendar.initActive();
+    return calendar;
+  }
+
+  initActive(): void {
+    const now = new Date();
+    const activeYear = this.years.find((i: Year) => i.number === now.getFullYear());
+    if (!activeYear) {
+      return;
+    }
+    activeYear.active = true;
+    const activeMonth = activeYear.months.find((i: Month) => i.number === now.getMonth());
+    if (!activeMonth) {
+      return;
+    }
+    activeMonth.active = true;
+    const activeWeek = activeMonth.weeks.find((i: Week) => i.days.some((d: Day) => d.date.getDate() === now.getDate()));
+    if (!activeWeek) {
+      return;
+    }
+    activeWeek.active = true;
+    activeMonth.setActiveBorder();
+  }
+
+  getActiveYear(): Year {
+    const year = this.years.find((i: Year) => i.active);
+    return year ?? new Year();
+  }
+
+  getActiveYearIndex(): number {
+    return this.years.findIndex((i: Year) => i.active);
+  }
+
+  getActivePeriod(): Day[] {
+    if (this.scale === CalendarScale.Week) {
+      const activeYearIndex = this.getActiveYearIndex();
+      const mi = this.years[activeYearIndex].months.findIndex((m: Month) => m.active);
+      const m = this.years[activeYearIndex].months[mi];
+      const days = m.getActiveWeek().days;
+      if (days.length === 7) {
+        return days;
+      }
+      const lostDays = 7 - days.length;
+      if (m.isLast() && m.lastWeekActive) {
+        const d = this.years[activeYearIndex + 1].months[0].weeks[0].days.slice(0, lostDays);
+        return days.concat(d);
+      }
+      if (m.isFirst() && m.firstWeekActive) {
+        const d = this.years[activeYearIndex - 1].getLastMonth().getLastWeek().days.slice(0, lostDays);
+        return d.concat(days);
+      }
+      if (m.lastWeekActive) {
+        const d = this.years[activeYearIndex].months[mi + 1].weeks[0].days.slice(0, lostDays);
+        return days.concat(d);
+      }
+      if (m.firstWeekActive) {
+        const d = this.years[activeYearIndex].months[mi - 1].weeks[this.years[activeYearIndex].months[mi - 1].weeks.length - 1].days.slice(
+          0,
+          lostDays
+        );
+        return d.concat(days);
+      }
+    }
+    return [];
+  }
+
+  move(toForward: boolean): void {
+    if (this.scale === CalendarScale.Week) {
+      const previousPeriod = this.getActivePeriod();
+      const activeYear = this.getActiveYear();
+      const activeMonth = activeYear.getActiveMonth();
+      if (toForward && activeMonth.isLast() && activeMonth.lastWeekActive) {
+        this.moveYear(toForward);
+        const nowPeriod = this.getActivePeriod();
+        if (this.periodsIsEqual(previousPeriod, nowPeriod)) {
+          this.move(toForward);
+        }
+        return;
+      }
+      if (!toForward && activeMonth.isFirst() && activeMonth.firstWeekActive) {
+        this.moveYear(toForward);
+        const nowPeriod = this.getActivePeriod();
+        if (this.periodsIsEqual(previousPeriod, nowPeriod)) {
+          this.move(toForward);
+        }
+        return;
+      }
+      activeYear.move(toForward);
+      const nowPeriod = this.getActivePeriod();
+      if (this.periodsIsEqual(previousPeriod, nowPeriod)) {
+        this.move(toForward);
+      }
+    }
+  }
+
+  moveYear(toForward: boolean): void {
+    const activeIndex = this.getActiveYearIndex();
+    if (activeIndex === -1) {
+      return;
+    }
+    this.years[activeIndex].dropActive();
+    const newActiveYear = this.years[toForward ? activeIndex + 1 : activeIndex - 1];
+    newActiveYear.initActive(toForward);
+  }
+
+  getToday(): Day {
+    const now = new Date();
+    const year = this.years.find((i: Year) => i.number === now.getFullYear());
+    if (!year) {
+      return new Day();
+    }
+    const month = year.months.find((i: Month) => i.number === now.getMonth());
+    if (!month) {
+      return new Day();
+    }
+    const week = month.weeks.find((i: Week) => i.days.some((d: Day) => d.date.getDate() === now.getDate()));
+    if (!week) {
+      return new Day();
+    }
+    const day = week.days.find((i: Day) => i.date.getDate() === now.getDate());
+    return day ?? new Day();
+  }
+
+  getSelectedDay(): Day {
+    let selectedDay = new Day();
+    this.years.some((y: Year) => {
+      const day = y.getSelectedDay();
+      if (day) {
+        selectedDay = day;
+        return true;
+      }
+    });
+    return selectedDay;
+  }
+
+  selectDay(day: Day): void {
+    const previousSelectedDay = this.getSelectedDay();
+    previousSelectedDay.selected = false;
+    day.selected = true;
+  }
+
+  periodsIsEqual(activePeriod1: Day[], activePeriod2: Day[]): boolean {
+    return activePeriod1.every((day: Day, i: number) => day.date.getDate() === activePeriod2[i].date.getDate());
+  }
+
+  getDateWithOffset() {
+    return new Date(this.getSelectedDay().date.getTime() - new Date().getTimezoneOffset() * 60000);
+  }
+}

package/src/classes/calendar/Day.ts

@@ -0,0 +1,15 @@
+export default class Day {
+  date: Date = new Date();
+  shortName = '';
+  selected = false;
+  active = false;
+
+  constructor() {
+    return;
+  }
+
+  isWeekend(): boolean {
+    const d = this.date.getDay();
+    return d === 6 || d === 0;
+  }
+}