sprof 0.0.1

package/src/classes/Auth.ts

@@ -0,0 +1,63 @@
+import AuthTokens from '@/classes/AuthTokens';
+import AuthUser from '@/classes/AuthUser';
+import IWithId from '@/interfaces/IWithId';
+import { AuthInfo } from '@/services/types/AuthInfo';
+
+import { Constructable } from '../ClassHelper';
+
+class Auth {
+  private isAuth = false;
+  private user = new AuthUser();
+  private tokens = new AuthTokens();
+  private preventLogout = false;
+
+  DeprecateLogout() {
+    this.preventLogout = true;
+  }
+  AllowLogout() {
+    this.preventLogout = false;
+  }
+  IsAuth(): boolean {
+    return this.isAuth;
+  }
+
+  User(): AuthUser<IWithId> {
+    return this.user;
+  }
+
+  GetUser<UserT extends Constructable<IWithId>>(): UserT | undefined {
+    return this.user.get() as UserT;
+  }
+
+  SetUserConstructor(c: Constructable<IWithId>) {
+    this.user.setUserConstructor(c);
+  }
+
+  SetState<UserT extends IWithId>(authInfo: AuthInfo<UserT>) {
+    this.user.set(authInfo.user);
+    this.tokens.set(authInfo.tokens);
+    this.isAuth = true;
+  }
+
+  Logout() {
+    if (this.preventLogout) {
+      PHelp.Notification.Warning('В текущий момент Вы не можете выйти из системы');
+      return;
+    }
+    this.user.reset();
+    this.tokens.reset();
+    this.isAuth = false;
+  }
+
+  Actualize() {
+    this.user.actualize();
+    this.tokens.actualize();
+    if (this.user.get() && this.tokens.getAccessToken() && this.tokens.getRefreshToken()) {
+      this.isAuth = true;
+      return;
+    }
+    this.Logout();
+  }
+}
+
+export default new Auth();

package/src/classes/AuthButton.ts

@@ -0,0 +1,64 @@
+import AuthStatuses from '@/interfaces/AuthStatuses';
+
+export default class AuthButton {
+  label = '';
+  isSubmit = false;
+  disabled = false;
+  private readonly toStatus: AuthStatuses = AuthStatuses.Login;
+
+  constructor(label: string, toStatus: AuthStatuses, isSubmit = false) {
+    this.label = label;
+    this.toStatus = toStatus;
+    this.isSubmit = isSubmit;
+  }
+
+  static Login(isSubmit?: boolean): AuthButton {
+    return new AuthButton('Войти', AuthStatuses.Login, isSubmit);
+  }
+
+  static Register(isSubmit?: boolean): AuthButton {
+    return new AuthButton('Зарегистрироваться', AuthStatuses.Register, isSubmit);
+  }
+
+  static Restore(isSubmit?: boolean): AuthButton {
+    return new AuthButton('Восстановить пароль', AuthStatuses.Restore, isSubmit);
+  }
+
+  static Refresh(isSubmit?: boolean): AuthButton {
+    return new AuthButton('Обновить пароль', AuthStatuses.Refresh, isSubmit);
+  }
+
+  static LoginButtons(): AuthButton[] {
+    return [
+      AuthButton.Login(true),
+      // AuthButton.Register(),
+      AuthButton.Restore(),
+    ];
+  }
+
+  static RegisterButtons(): AuthButton[] {
+    return [AuthButton.Register(true), AuthButton.Login(), AuthButton.Restore()];
+  }
+
+  static RestoreButtons(): AuthButton[] {
+    return [
+      AuthButton.Restore(true),
+      AuthButton.Login(),
+      // AuthButton.Register()
+    ];
+  }
+
+  static RefreshButtons(): AuthButton[] {
+    return [AuthButton.Refresh(true)];
+  }
+
+  getStatus(): AuthStatuses {
+    return this.toStatus;
+  }
+  off(): void {
+    this.disabled = false;
+  }
+  on(): void {
+    this.disabled = true;
+  }
+}

package/src/classes/AuthForm.ts

@@ -0,0 +1,114 @@
+import AuthButton from '@/classes/AuthButton';
+import { AuthStatusesObjects } from '@/classes/AuthStatusesObjects';
+import EmailField from '@/classes/EmailField';
+import PasswordField from '@/classes/PasswordField';
+import PasswordRepeatField from '@/classes/PasswordRepeatField';
+import AuthStatuses from '@/interfaces/AuthStatuses';
+import IEmailPassword from '@/interfaces/IEmailPassword';
+
+class AuthForm {
+  private status: AuthStatuses = AuthStatuses.Login;
+  private email = new EmailField();
+  private password = new PasswordField();
+  private passwordRepeat = new PasswordRepeatField();
+
+  Status(): AuthStatuses {
+    return this.status;
+  }
+
+  Email(): EmailField {
+    return this.email;
+  }
+  Password(): PasswordField {
+    return this.password;
+  }
+
+  PasswordRepeat(): PasswordRepeatField {
+    return this.passwordRepeat;
+  }
+
+  GetErrors(): string[] {
+    if (this.IsRefresh()) {
+      if (!this.ComparePasswords()) {
+        return ['Пароли не совпадают, проверьте ввод!'];
+      }
+      return this.password.getErrors();
+    }
+    if (this.IsRestore()) {
+      return this.email.getErrors();
+    }
+
+    if (this.IsRegister()) {
+      if (!this.ComparePasswords()) {
+        return ['Пароли не совпадают, проверьте ввод!'];
+      }
+      return this.email.getErrors();
+    }
+
+    return [...this.email.getErrors(), ...this.password.getErrors()];
+  }
+
+  ComparePasswords(): boolean {
+    return this.password.password === this.passwordRepeat.text ? true : false;
+  }
+
+  ToEmailPassword(): IEmailPassword {
+    return { email: this.email.email, password: this.password.password };
+  }
+
+  IsLogin(): boolean {
+    return this.status === AuthStatuses.Login;
+  }
+
+  IsRegister(): boolean {
+    return this.status === AuthStatuses.Register;
+  }
+
+  IsRestore(): boolean {
+    return this.status === AuthStatuses.Restore;
+  }
+
+  IsRefresh(): boolean {
+    return this.status === AuthStatuses.Refresh;
+  }
+
+  SetStatus(status: AuthStatuses): void {
+    this.status = status;
+  }
+
+  GetTitle(): string {
+    return AuthStatusesObjects[this.status].title as string;
+  }
+
+  GetComponent(): string {
+    return AuthStatusesObjects[this.status].component as string;
+  }
+
+  GetAuthButtons(): AuthButton[] {
+    return AuthStatusesObjects[this.status].buttons as AuthButton[];
+  }
+
+  GetSuccessMessage(): string {
+    return AuthStatusesObjects[this.status].successMessage as string;
+  }
+
+  GetErrorMessage(): string {
+    return AuthStatusesObjects[this.status].errorMessage as string;
+  }
+
+  GetAction(): string {
+    return AuthStatusesObjects[this.status].action as string;
+  }
+
+  Reset(): void {
+    this.email.reset();
+    this.password.reset();
+    this.status = AuthStatuses.Login;
+  }
+
+  Focus(): void {
+    this.email.focus();
+  }
+}
+
+export default new AuthForm();

package/src/classes/AuthModal.ts

@@ -0,0 +1,32 @@
+import AuthStatuses from '@/interfaces/AuthStatuses';
+
+class AuthModal {
+  private visible = false;
+  private closable = false;
+  private status: AuthStatuses = AuthStatuses.Login;
+
+  Status(): AuthStatuses {
+    return this.status;
+  }
+
+  IsClosable(): boolean {
+    return this.closable;
+  }
+
+  IsVisible(): boolean {
+    return this.visible;
+  }
+
+  Close(): void {
+    this.visible = false;
+  }
+
+  Open(closable?: boolean): void {
+    if (closable) {
+      this.closable = true;
+    }
+    this.visible = true;
+  }
+}
+
+export default new AuthModal();

package/src/classes/AuthStatusesObjects.ts

@@ -0,0 +1,37 @@
+import AuthButton from '@/classes/AuthButton';
+import AuthStatuses from '@/interfaces/AuthStatuses';
+
+export const AuthStatusesObjects: Record<AuthStatuses, Record<string, string | AuthButton[]>> = {
+  [AuthStatuses.Login]: {
+    title: 'Авторизация',
+    action: 'login',
+    component: 'LoginChunk',
+    buttons: AuthButton.LoginButtons(),
+    errorMessage: 'Неверно указан email или пароль',
+    successMessage: 'Вы успешно вошли в систему',
+  },
+  [AuthStatuses.Register]: {
+    title: 'Регистрация',
+    action: 'register',
+    component: 'RegisterChunk',
+    buttons: AuthButton.RegisterButtons(),
+    errorMessage: 'Неверно указан email или пароль',
+    successMessage: 'Вы успешно зарегистрировались в системе, войдите под своим паролем',
+  },
+  [AuthStatuses.Restore]: {
+    title: 'Восстановление пароля',
+    component: 'ForgotPasswordChunk',
+    action: 'restorePassword',
+    successMessage: 'Ссылка для восстановления пароля отправлена на Вашу почту',
+    errorMessage: 'Неверно указан email',
+    buttons: AuthButton.RestoreButtons(),
+  },
+  [AuthStatuses.Refresh]: {
+    title: 'Создание нового пароля',
+    action: 'passwordChange',
+    component: 'PasswordChangeChunk',
+    successMessage: 'Воспользуйтесь новым паролем для входа',
+    errorMessage: 'Неверно указан email',
+    buttons: AuthButton.RefreshButtons(),
+  },
+};

package/src/classes/AuthTokens.ts

@@ -0,0 +1,43 @@
+import ITokens from '@/interfaces/ITokens';
+
+import LocalStoreKeys from '../interfaces/LocalStoreKeys';
+import LocalStore from './LocalStore';
+
+export default class AuthTokens {
+  //   private accessToken?: string;
+  // private  refreshToken?: string;
+
+  set(tokenObj: ITokens) {
+    this.setAccessToken(tokenObj.accessToken);
+    this.setRefreshToken(tokenObj.refreshToken);
+  }
+
+  getAccessToken(): string | undefined {
+    return LocalStore.Get(LocalStoreKeys.AccessToken);
+  }
+  getRefreshToken(): string | undefined {
+    return LocalStore.Get(LocalStoreKeys.RefreshToken);
+  }
+
+  setAccessToken(token?: string) {
+    // this.accessToken = token;
+    LocalStore.Set(LocalStoreKeys.AccessToken, token);
+  }
+
+  setRefreshToken(token?: string) {
+    // this.refreshToken = token;
+    LocalStore.Set(LocalStoreKeys.RefreshToken, token);
+  }
+
+  reset() {
+    // this.accessToken = undefined;
+    // this.refreshToken = undefined;
+    LocalStore.Remove(LocalStoreKeys.AccessToken);
+    LocalStore.Remove(LocalStoreKeys.RefreshToken);
+  }
+
+  actualize() {
+    this.setAccessToken(this.getAccessToken());
+    this.setRefreshToken(this.getAccessToken());
+  }
+}

package/src/classes/AuthUser.ts

@@ -0,0 +1,53 @@
+import { Constructable } from '@/services/ClassHelper';
+import IWithId from '@/interfaces/IWithId';
+
+import LocalStoreKeys from '../interfaces/LocalStoreKeys';
+import LocalStore from './LocalStore';
+
+interface IWithUser<UserT> {
+  user?: UserT;
+}
+
+export default class AuthUser<UserT extends IWithId> {
+  private user: UserT | undefined;
+  userConstructor?: Constructable<UserT>;
+
+  AssignTo(item: IWithUser<UserT>) {
+    item.user = this.get();
+  }
+  setUserConstructor(userConstructor: Constructable<UserT>) {
+    this.userConstructor = userConstructor;
+  }
+
+  get(): UserT | undefined {
+    if (!this.userConstructor) {
+      return;
+    }
+    this.user = new this.userConstructor(LocalStore.Get(LocalStoreKeys.User));
+    return this.user;
+  }
+
+  getId(): string | undefined {
+    return this.get()?.id;
+  }
+
+  set(user: UserT): void {
+    if (!this.userConstructor) {
+      return;
+    }
+    this.user = new this.userConstructor(user);
+    LocalStore.Set(LocalStoreKeys.User, this.user);
+  }
+  reset(): void {
+    this.user = undefined;
+    LocalStore.Remove(LocalStoreKeys.User);
+  }
+
+  actualize() {
+    const user = LocalStore.Get<UserT>(LocalStoreKeys.User);
+    if (!user) {
+      return;
+    }
+    this.set(user);
+  }
+}

package/src/classes/CallbackRequest.ts

@@ -0,0 +1,12 @@
+import ClassHelper from '@/services/ClassHelper';
+
+export default class CallbackRequest {
+  id?: string;
+  name = '';
+  description = '';
+  phone = '';
+
+  constructor(i?: CallbackRequest) {
+    ClassHelper.BuildClass(this, i);
+  }
+}

package/src/classes/Chat.ts

@@ -0,0 +1,18 @@
+import ChatMessage from '@/classes/ChatMessage';
+import ClassHelper from '@/services/ClassHelper';
+
+export default class Chat {
+  id?: string;
+  @ClassHelper.GetClassConstructor(ChatMessage)
+  chatMessages: ChatMessage[] = [];
+  constructor(i?: Chat) {
+    ClassHelper.BuildClass(this, i);
+  }
+
+  addChatMessages(message: ChatMessage): void {
+    if (this.chatMessages.find((m: ChatMessage) => m.id === message.id)) {
+      return;
+    }
+    this.chatMessages.push(message);
+  }
+}

package/src/classes/ChatMessage.ts

@@ -0,0 +1,48 @@
+import { v4 as uuidv4 } from 'uuid';
+
+// import User from '@/classes/User';
+import ClassHelper from '@/services/ClassHelper';
+export enum ChateMessageTypes {
+  Ping = 'ping',
+  Enter = 'enter',
+  Exit = 'exit',
+  Message = 'message',
+  Write = 'write',
+  Empty = '',
+}
+
+export default class ChatMessage {
+  id?: string;
+  message = '';
+  // user: User = new User();
+  // userId?: string;
+  userName?: string;
+  createdOn = new Date();
+  chatId?: string;
+  type: ChateMessageTypes = ChateMessageTypes.Message;
+
+  constructor(i?: ChatMessage) {
+    ClassHelper.BuildClass(this, i);
+  }
+
+  static Create(chatId: string, userId: string | undefined, messageText: string, userName: string | undefined): ChatMessage {
+    const item = new ChatMessage();
+    item.id = uuidv4();
+    item.chatId = chatId;
+    // item.userId = userId;
+    item.message = messageText;
+    item.userName = userName;
+    return item;
+  }
+
+  static CreatePingMessage(): ChatMessage {
+    const item = new ChatMessage();
+    item.type = ChateMessageTypes.Ping;
+    item.id = uuidv4();
+    return item;
+  }
+
+  isMessage(): boolean {
+    return this.type === ChateMessageTypes.Message || this.type === ChateMessageTypes.Empty;
+  }
+}

package/src/classes/Contact.ts

@@ -0,0 +1,96 @@
+import Email from '@/classes/Email';
+import Phone from '@/classes/Phone';
+import PostAddress from '@/classes/PostAddress';
+import Website from '@/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 '@/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();
+  }
+}