sprof 0.1.0

package/src/classes/Contact.ts

@@ -0,0 +1,96 @@
+import Email from '@/services/classes/Email';
+import Phone from '@/services/classes/Phone';
+import PostAddress from '@/services/classes/PostAddress';
+import Website from '@/services/classes/Website';
+import ClassHelper from '@/services/ClassHelper';
+
+export default class Contact {
+  id?: string;
+  description = '';
+  time = '';
+  latitude = '';
+  longitude = '';
+  @ClassHelper.GetClassConstructor(Email)
+  emails: Email[] = [];
+  @ClassHelper.GetClassConstructor(PostAddress)
+  postAddresses: PostAddress[] = [new PostAddress()];
+  @ClassHelper.GetClassConstructor(Phone)
+  phones: Phone[] = [];
+  @ClassHelper.GetClassConstructor(Website)
+  websites: Website[] = [];
+
+  constructor(i?: Contact) {
+    ClassHelper.BuildClass(this, i);
+  }
+
+  addEmail(): Email {
+    const item = Email.Create();
+    item.contactId = this.id;
+    this.emails.push(item);
+    return item;
+  }
+
+  addPhone(): Phone {
+    const item = Phone.Create();
+    item.contactId = this.id;
+    this.phones.push(item);
+    return item;
+  }
+
+  static Create(): Contact {
+    const item = new Contact();
+    item.id = ClassHelper.CreateUUID();
+    return item;
+  }
+
+  removeEmail(id: string): void {
+    ClassHelper.RemoveFromClassById(id, this.emails);
+  }
+
+  removePhone(id: string): void {
+    ClassHelper.RemoveFromClassById(id, this.phones);
+  }
+
+  addPostAddress(): void {
+    this.postAddresses.push(new PostAddress());
+  }
+  addWebsite(): void {
+    this.websites.push(new Website());
+  }
+  pushFirst(): void {
+    if (!this.emails.length) {
+      this.emails.push(new Email());
+    }
+    if (!this.phones.length) {
+      this.phones.push(new Phone());
+    }
+  }
+
+  getCoords(): number[] {
+    return [Number(this.latitude), Number(this.longitude)];
+  }
+
+  static CreateBufetContacts(): Contact {
+    const contact = new Contact();
+    const address = new PostAddress();
+    address.address = '4-й Добрынинский пер., 4, 1А корпус, 7й этаж';
+    contact.postAddresses[0] = address;
+    return contact;
+  }
+
+  updateDescription(e: string): void {
+    this.description = e;
+  }
+
+  updateTime(e: string): void {
+    this.time = e;
+  }
+
+  updateLatitude(e: string): void {
+    this.latitude = e;
+  }
+
+  updateLongitutde(e: string): void {
+    this.longitude = e;
+  }
+}

package/src/classes/Cropper.ts

@@ -0,0 +1,22 @@
+import ClassHelper from '@/services/ClassHelper';
+
+export default class Cropper {
+  id?: string;
+  ratio = 0;
+  src = '';
+  store = '';
+
+  constructor(i?: Cropper) {
+    ClassHelper.BuildClass(this, i);
+  }
+
+  static CreateCropper(src: string, ratio?: number, id?: string): Cropper {
+    const cropper = new Cropper();
+    cropper.src = src;
+    cropper.id = id;
+    if (ratio) {
+      cropper.ratio = ratio;
+    }
+    return cropper;
+  }
+}

package/src/classes/DateHelper.ts

@@ -0,0 +1,29 @@
+interface IWithDate {
+  date: Date;
+}
+export default abstract class DateHelper {
+  static GetDateOrToday(item?: IWithDate): Date {
+    return item ? item.date : new Date();
+  }
+  static InPeriod(date: Date, start: Date, end: Date): boolean {
+    return new Date(date) >= new Date(start) && new Date(date) <= new Date(end);
+  }
+  static GetDatesFromPeriod(start: Date, end: Date): Date[] {
+    const dates: Date[] = [new Date(start)];
+    let curDate = start;
+    while (curDate <= end) {
+      curDate = DateHelper.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/classes/Email.ts

@@ -0,0 +1,18 @@
+import ClassHelper from '@/services/ClassHelper';
+
+export default class Email {
+  id?: string;
+  address?: string;
+  description?: string;
+  contactId?: string;
+
+  constructor(i?: Email) {
+    ClassHelper.BuildClass(this, i);
+  }
+
+  static Create(): Email {
+    const item = new Email();
+    item.id = ClassHelper.CreateUUID();
+    return item;
+  }
+}

package/src/classes/EmailField.ts

@@ -0,0 +1,42 @@
+import AuthStatuses from '@/services/interfaces/AuthStatuses';
+type MyCallbackWithOptParam = (error?: Error) => void;
+
+export default class EmailField {
+  email = '';
+  private emailRef = ref();
+
+  rule(_: unknown, value: string, callback: MyCallbackWithOptParam) {
+    if (!value.trim().length) {
+      callback(new Error('Необходимо указать email'));
+      return;
+    }
+    callback();
+    return;
+  }
+
+  reset(): void {
+    this.email = '';
+  }
+
+  show(status: AuthStatuses): boolean {
+    return [AuthStatuses.Login, AuthStatuses.Register, AuthStatuses.Restore].includes(status);
+  }
+
+  getErrors(): string[] {
+    const errors: string[] = [];
+    if (this.email === '') {
+      errors.push('Заполните email');
+      return errors;
+    }
+    const re = /\S+@\S+\.\S+/;
+    if (!re.test(this.email)) {
+      errors.push('Некорректный email');
+      return errors;
+    }
+    return errors;
+  }
+
+  focus(): void {
+    this.emailRef.value.focus();
+  }
+}

package/src/classes/EmailRules.ts

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

package/src/classes/FTSPPreset.ts

@@ -0,0 +1,16 @@
+import ClassHelper from '@/services/ClassHelper';
+export default class FTSPPreset {
+  id?: string;
+  ftsp?: string;
+  name = '';
+  constructor(i?: FTSPPreset) {
+    ClassHelper.BuildClass(this, i);
+  }
+
+  static Create(ftsp: FTSP): FTSPPreset {
+    const item = new FTSPPreset();
+    item.id = ClassHelper.CreateUUID();
+    item.ftsp = JSON.stringify(ftsp);
+    return item;
+  }
+}

package/src/classes/FileInfo.ts

@@ -0,0 +1,86 @@
+export default class FileInfo {
+  name = '';
+  url = '';
+  src = '';
+  raw?: File;
+
+  blob?: Blob;
+  file?: Blob;
+
+  id?: string;
+  originalName = '';
+  fileSystemPath = '';
+
+  constructor(i?: FileInfo) {
+    ClassHelper.BuildClass(this, i);
+  }
+
+  getFileUrl(): string | URL {
+    const u = this.url ? this.url : `${import.meta.env.VITE_APP_STATIC_URL}/${this.fileSystemPath}`;
+    return new URL(u, import.meta.url);
+  }
+
+  getFileListObject(): { name: string; url: string } {
+    return { name: this.originalName, url: this.url };
+  }
+
+  static CreatePreviewFile(file: FileInfo, id?: string): FileInfo {
+    const fileInfo = new FileInfo();
+    fileInfo.id = id ?? ClassHelper.CreateUUID();
+    fileInfo.originalName = file.name;
+    fileInfo.file = file.blob;
+    fileInfo.fileSystemPath = ClassHelper.CreateUUID();
+    return fileInfo;
+  }
+
+  uploadNewFile(file: FileInfo): void {
+    if (!this.id) {
+      this.id = ClassHelper.CreateUUID();
+    }
+    this.originalName = file.name;
+    this.file = file.blob;
+    this.fileSystemPath = ClassHelper.CreateUUID();
+  }
+
+  setFile(file: FileInfo): void {
+    this.file = file;
+    this.url = file.src;
+    // var reader = new FileReader();
+  }
+
+  uploadAndSetFile(file: FileInfo): void {
+    this.uploadNewFile(file);
+    this.setFile(file);
+    // this.file = file.raw;
+    this.url = file.url;
+  }
+
+  clearFile(): void {
+    this.url = '';
+    this.file = undefined;
+    this.fileSystemPath = '';
+    this.originalName = '';
+  }
+
+  errorImg(event: Event, errorImgName?: string): void | URL {
+    if (event.target) {
+      let src = `/src/services/assets/img/avatar.webp`;
+      if (errorImgName) {
+        src = `@/assets/img/${errorImgName}`;
+      }
+      return new URL(src, import.meta.url);
+    }
+  }
+  getFileInfos(): FileInfo[] {
+    return [this];
+  }
+
+  isPdf(): boolean {
+    return this.getExtension(this.originalName) === 'pdf';
+  }
+
+  getExtension(filename: string): string {
+    const parts = filename.split('.');
+    return parts[parts.length - 1];
+  }
+}

package/src/classes/HttpResponse.ts

@@ -0,0 +1,22 @@
+import ClassHelper from '@/services/ClassHelper';
+
+import FTSP from './filters/FTSP';
+
+export default class HttpResponse<T> {
+  data?: T;
+  msg = '';
+  @ClassHelper.GetClassConstructor(FTSP)
+  ftsp?: FTSP;
+
+  constructor(i?: HttpResponse<T>) {
+    ClassHelper.BuildClass(this, i);
+  }
+
+  isEmpty(): boolean {
+    return !this;
+  }
+
+  withoutFTSP(): boolean {
+    return this.isEmpty() || !this.ftsp;
+  }
+}

package/src/classes/Human.ts

@@ -0,0 +1,106 @@
+import Contact from '@/services/classes/Contact';
+import FileInfo from '@/services/classes/FileInfo';
+import ClassHelper from '@/services/ClassHelper';
+import Strings from '@/services/Strings';
+
+export default class Human {
+  id?: string;
+  name = '';
+  surname = '';
+  patronymic = '';
+  citizenship = '';
+  placeBirth = '';
+  carNumber = '';
+  carModel = '';
+  snils = '';
+  photoId?: string;
+  photo: FileInfo = new FileInfo();
+  photoMiniId?: string;
+  photoMini: FileInfo = new FileInfo();
+  isMale = true;
+  dateBirth = new Date();
+  @ClassHelper.GetClassConstructor(Contact)
+  contact: Contact = new Contact();
+  contactId?: string;
+  slug = '';
+  postIndex = '';
+  address = '';
+
+  editNameMode = false;
+
+  constructor(i?: Human) {
+    ClassHelper.BuildClass(this, i);
+  }
+
+  getImageUrl(): string | URL {
+    if (this.photo.fileSystemPath) {
+      return this.photo.getFileUrl();
+    }
+    return new URL(`/src/services/assets/img/avatar.webp`, import.meta.url);
+  }
+
+  setEditNameMode(value: boolean): void {
+    this.editNameMode = value;
+  }
+
+  getFullName(): string {
+    if (!this.surname.length && !this.name.length && !this.patronymic.length) {
+      return '';
+    }
+    return `${this.surname} ${this.name} ${this.patronymic}`;
+  }
+
+  getInitialsName(): string {
+    return `${this.name.slice(0, 1)}.${this.patronymic.slice(0, 1)}. ${this.surname}`;
+  }
+  getGender(full?: boolean): string {
+    if (full) {
+      return this.isMale ? 'Мужской' : 'Женский';
+    }
+    return this.isMale ? 'М' : 'Ж';
+  }
+
+  capitalizeName(): void {
+    this.name = Strings.Capitalize(this.name);
+    this.surname = Strings.Capitalize(this.surname);
+    this.patronymic = Strings.Capitalize(this.patronymic);
+  }
+
+  trimName(): void {
+    this.name = this.name.trim();
+    this.surname = this.surname.trim();
+    this.patronymic = this.patronymic.trim();
+  }
+
+  sanitizeName(): void {
+    this.trimName();
+    this.capitalizeName();
+  }
+
+  getFileInfos(): FileInfo[] {
+    const fileInfos: FileInfo[] = [];
+    fileInfos.push(this.photo);
+    fileInfos.push(this.photoMini);
+    return fileInfos;
+  }
+
+  removePhoto(): void {
+    this.photo = new FileInfo();
+    this.photoId = undefined;
+  }
+  removePhotoMini(): void {
+    this.photoMini = new FileInfo();
+    this.photoMiniId = undefined;
+  }
+
+  setFullName(human: Human): void {
+    this.surname = human.surname;
+    this.name = human.name;
+    this.patronymic = human.patronymic;
+  }
+
+  initContact() {
+    this.contact = Contact.Create();
+    this.contactId = this.contact.id;
+  }
+}

package/src/classes/LabelValue.ts

@@ -0,0 +1,11 @@
+export default class LabelValue {
+  label = '';
+  value: unknown;
+
+  static Create(label = '', value = ''): LabelValue {
+    const item = new Option();
+    item.label = label;
+    item.value = value;
+    return item;
+  }
+}

package/src/classes/LocalStore.ts

@@ -0,0 +1,22 @@
+import LocalStoreKeys from '@/services/interfaces/LocalStoreKeys';
+
+export default abstract class LocalStore {
+  static Get<T>(key: LocalStoreKeys): T | undefined {
+    const item = localStorage.getItem(key);
+    if (!item) {
+      return undefined;
+    }
+    return JSON.parse(item);
+  }
+
+  static Set(key: LocalStoreKeys, item: unknown): void {
+    if (!item) {
+      return;
+    }
+    localStorage.setItem(key, JSON.stringify(item));
+  }
+
+  static Remove(key: LocalStoreKeys): void {
+    localStorage.removeItem(key);
+  }
+}

package/src/classes/M2M.ts

@@ -0,0 +1,25 @@
+import ClassHelper from '@/services/ClassHelper';
+
+class KeyValue {
+  field = '';
+  value = '';
+}
+
+export default class M2M {
+  model = '';
+  id1: KeyValue = new KeyValue();
+  id2: KeyValue = new KeyValue();
+  fields: KeyValue[] = [];
+
+  constructor(i?: M2M) {
+    ClassHelper.BuildClass(this, i);
+  }
+
+  static CreateV1(model: string, id1: KeyValue, id2: KeyValue): M2M {
+    const item = new M2M();
+    item.model = model;
+    item.id1 = id1;
+    item.id2 = id2;
+    return item;
+  }
+}

package/src/classes/Menu.ts

@@ -0,0 +1,102 @@
+import { v4 as uuidv4 } from 'uuid';
+
+// import IElementPlusFile from '@/interfaces/files/IElementPlusFile';
+import FileInfo from '@/services/classes/FileInfo';
+import Page from '@/services/classes/page/Page';
+import SubMenu from '@/services/classes/SubMenu';
+import ClassHelper from '@/services/ClassHelper';
+import IFile from '@/services/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/classes/PageSectionImage.ts

@@ -0,0 +1,19 @@
+import FileInfo from '@/services/classes/FileInfo';
+import PageSection from '@/services/classes/page/PageSection';
+import ClassHelper from '@/services/ClassHelper';
+
+export default class PageSectionImage {
+  id?: string;
+  documentType: PageSection = new PageSection();
+  documentTypeId?: string;
+  order = 0;
+  constructor(i?: PageSectionImage) {
+    ClassHelper.BuildClass(this, i);
+  }
+
+  getFileInfos(): FileInfo[] {
+    const fileInfos: FileInfo[] = [];
+    fileInfos.push(...this.documentType.getFileInfos());
+    return fileInfos;
+  }
+}

package/src/classes/PasswordField.ts

@@ -0,0 +1,39 @@
+import { ref } from 'vue';
+
+import AuthStatuses from '@/services/interfaces/AuthStatuses';
+type MyCallbackWithOptParam = (error?: Error) => void;
+
+export default class EmailPasswordForm {
+  password = '';
+  private passwordRef = ref();
+
+  rule(_: unknown, value: string, callback: MyCallbackWithOptParam) {
+    if (!value) {
+      callback(new Error('Необходимо ввести пароль'));
+    } else if (value.length < 6) {
+      callback(new Error('Пароль должен быть не менее 6 символов'));
+    }
+    callback();
+    return;
+  }
+
+  reset(): void {
+    this.password = '';
+  }
+
+  show(status: AuthStatuses): boolean {
+    return [AuthStatuses.Login, AuthStatuses.Register, AuthStatuses.Refresh].includes(status);
+  }
+
+  getErrors(): string[] {
+    const errors: string[] = [];
+    if (this.password === '') {
+      errors.push('Введите пароль');
+    }
+    return errors;
+  }
+
+  focus(): void {
+    this.passwordRef.value.focus();
+  }
+}