sprof 0.1.0

package/src/classes/calendar/Calendar.ts

@@ -0,0 +1,168 @@
+import Day from '@/services/classes/calendar/Day';
+import Month from '@/services/classes/calendar/Month';
+import Week from '@/services/classes/calendar/Week';
+import Year from '@/services/classes/calendar/Year';
+import { CalendarScale } from '@/services/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;
+  }
+}

package/src/classes/calendar/Month.ts

@@ -0,0 +1,144 @@
+import Day from '@/services/classes/calendar/Day';
+import Week from '@/services/classes/calendar/Week';
+
+export default class Month {
+  weeks: Week[] = [];
+  firstWeekActive = false;
+  lastWeekActive = false;
+  active = false;
+  number = 0;
+  constructor() {
+    // const now = d ? new Date(d) : new Date();
+    // if (!d) {
+    //   this.active = true;
+    // }
+    // const date = new Date(now.getFullYear(), now.getMonth(), 1);
+    // this.weeks.push(new Week());
+    // while (date.getMonth() === now.getMonth()) {
+    //   // monthDates.value.push(new Date(date));
+    //   if (date.getDay() === 1 || this.weeks.length === 0) {
+    //     this.weeks.push(new Week());
+    //   }
+    //   const day = new Day();
+    //   day.date = new Date(date);
+    //   this.weeks[this.weeks.length - 1].days.push(day);
+    //   if (date.getDate() === now.getDate()) {
+    //     day.selected = true;
+    //     this.weeks[this.weeks.length - 1].active = true;
+    //   }
+    //   date.setDate(date.getDate() + 1);
+    // }
+    // this.setActiveBorder();
+  }
+
+  static Init(): Month {
+    return new Month();
+  }
+
+  static InitFull(yearN: number, monthN: number): Month {
+    const month = Month.Init();
+    month.number = monthN;
+    const firstDay = new Date(yearN, monthN, 1);
+    const date = new Date(firstDay);
+    while (date.getMonth() === firstDay.getMonth()) {
+      if (date.getDay() === 1 || month.weeks.length === 0) {
+        month.weeks.push(new Week());
+      }
+      const day = new Day();
+      day.date = new Date(date);
+      month.weeks[month.weeks.length - 1].days.push(day);
+      date.setDate(date.getDate() + 1);
+    }
+    return month;
+  }
+
+  getActiveWeek(): Week {
+    const week = this.weeks.find((w: Week) => w.active);
+    return week ?? new Week();
+  }
+
+  getActiveWeekIndex(): number {
+    return this.weeks.findIndex((w: Week) => w.active);
+  }
+
+  getSelectedDay(): Day | undefined {
+    let selectedDay: Day | undefined = undefined;
+    this.weeks.some((w: Week) => {
+      const d = w.getSelectedDay();
+      if (d) {
+        selectedDay = d;
+        return true;
+      }
+    });
+    return selectedDay;
+  }
+
+  move(toForward: boolean): void {
+    const activeWeekIndex = this.weeks.findIndex((w: Week) => w.active);
+    if (activeWeekIndex === -1) {
+      return;
+    }
+    this.weeks[activeWeekIndex].active = false;
+    if (toForward && this.weeks[activeWeekIndex + 1]) {
+      this.weeks[activeWeekIndex + 1].active = true;
+    } else if (!toForward && this.weeks[activeWeekIndex - 1]) {
+      this.weeks[activeWeekIndex - 1].active = true;
+    }
+    this.setActiveBorder();
+  }
+  setActiveBorder(): void {
+    const activeWeekIndex = this.weeks.findIndex((w: Week) => w.active);
+    if (activeWeekIndex === 0) {
+      this.firstWeekActive = true;
+      this.lastWeekActive = false;
+    } else if (activeWeekIndex === this.weeks.length - 1) {
+      this.lastWeekActive = true;
+      this.firstWeekActive = false;
+    } else {
+      this.lastWeekActive = false;
+      this.firstWeekActive = false;
+    }
+  }
+
+  isLast(): boolean {
+    return this.number === 11;
+  }
+
+  isFirst(): boolean {
+    return this.number === 0;
+  }
+
+  dropActive(): void {
+    const activeWeek = this.weeks.find((w: Week) => w.active);
+    this.active = false;
+    this.firstWeekActive = false;
+    this.lastWeekActive = false;
+    if (activeWeek) {
+      activeWeek.dropActive();
+    }
+  }
+
+  initActive(fromStart: boolean): void {
+    this.active = true;
+    if (fromStart) {
+      this.firstWeekActive = true;
+      let week = this.getFirstWeek();
+      if (week.days.length < 7 && week.days[0].date.getDate() === 1) {
+        week = this.weeks[1];
+      }
+      week.initActive(fromStart);
+    }
+    if (!fromStart) {
+      this.lastWeekActive = true;
+      this.getLastWeek().initActive(fromStart);
+    }
+  }
+
+  getFirstWeek(): Week {
+    return this.weeks[0];
+  }
+
+  getLastWeek(): Week {
+    return this.weeks[this.weeks.length - 1];
+  }
+}

package/src/classes/calendar/Week.ts

@@ -0,0 +1,44 @@
+import Day from '@/services/classes/calendar/Day';
+
+export default class Week {
+  days: Day[] = [];
+  active = false;
+  constructor() {
+    return;
+  }
+
+  getDays(fullWeek?: boolean) {
+    if (!fullWeek) {
+      return this.days;
+    }
+  }
+  getSelectedDay(): Day | undefined {
+    return this.days.find((d: Day) => d.selected);
+  }
+
+  dropActive(): void {
+    this.active = false;
+    const activeDay = this.days.find((w: Day) => w.active);
+    if (activeDay) {
+      activeDay.active = false;
+    }
+  }
+
+  initActive(fromStart: boolean): void {
+    this.active = true;
+    if (fromStart) {
+      this.getFirstDay().active = true;
+    }
+    if (fromStart) {
+      this.getLastDay().active = true;
+    }
+  }
+
+  getFirstDay(): Day {
+    return this.days[0];
+  }
+
+  getLastDay(): Day {
+    return this.days[this.days.length - 1];
+  }
+}

package/src/classes/calendar/Year.ts

@@ -0,0 +1,130 @@
+import Day from '@/services/classes/calendar/Day';
+import Month from '@/services/classes/calendar/Month';
+
+export default class Year {
+  months: Month[] = [];
+  number = 0;
+  active = false;
+  lastMonthActive = false;
+  firstMonthActive = false;
+
+  getActiveMonth(): Month {
+    const month = this.months.find((m: Month) => m.active);
+    return month ?? new Month();
+  }
+
+  getActiveMonthIndex(): number {
+    return this.months.findIndex((m: Month) => m.active);
+  }
+
+  static Init(number?: number): Year {
+    const year = new Year();
+    year.number = number ?? 0;
+    return year;
+  }
+
+  static InitFull(yearN?: number): Year {
+    const year = Year.Init(yearN);
+    for (let i = 0; i < 12; i++) {
+      year.months.push(Month.InitFull(year.number, i));
+    }
+    return year;
+  }
+
+  static InitCurrent(): Year {
+    const year = Year.Init();
+    year.number = new Date().getFullYear();
+    year.active = true;
+    return year;
+  }
+
+  static InitFilled(): Year {
+    return Year.Init();
+  }
+
+  getFirstDay(): Date {
+    return new Date(this.number, 0, 1);
+  }
+
+  move(toForward: boolean): void {
+    const activeMonth = this.getActiveMonth();
+    if ((activeMonth.lastWeekActive && toForward) || (activeMonth.firstWeekActive && !toForward)) {
+      this.moveMonth(toForward);
+      return;
+    }
+    activeMonth.move(toForward);
+  }
+
+  moveMonth(toForward: boolean): void {
+    const activeMonthIndex = this.getActiveMonthIndex();
+    if (activeMonthIndex === -1 || activeMonthIndex > 11) {
+      this.lastMonthActive = false;
+      this.firstMonthActive = false;
+      return;
+    }
+    if (activeMonthIndex === 11) {
+      this.lastMonthActive = true;
+      this.firstMonthActive = false;
+    } else if (activeMonthIndex === 0) {
+      this.lastMonthActive = false;
+      this.firstMonthActive = true;
+    } else {
+      this.lastMonthActive = false;
+      this.firstMonthActive = false;
+    }
+    this.months[activeMonthIndex].active = false;
+    this.months[activeMonthIndex].getActiveWeek().active = false;
+    this.months[activeMonthIndex].firstWeekActive = false;
+    this.months[activeMonthIndex].lastWeekActive = false;
+    const nextIndex = toForward ? activeMonthIndex + 1 : activeMonthIndex - 1;
+
+    const newActiveMonth = this.months[nextIndex];
+    newActiveMonth.active = true;
+    const week = newActiveMonth.weeks[toForward ? 0 : newActiveMonth.weeks.length - 1];
+    if (week.days.length < 7) {
+      newActiveMonth.weeks[toForward ? 1 : newActiveMonth.weeks.length - 2].active = true;
+    } else {
+      week.active = true;
+    }
+    newActiveMonth.setActiveBorder();
+  }
+
+  getSelectedDay(): Day | undefined {
+    let selectedDay = undefined;
+    this.months.some((m: Month) => {
+      const day = m.getSelectedDay();
+      if (day) {
+        selectedDay = day;
+        return true;
+      }
+    });
+    return selectedDay;
+  }
+
+  dropActive(): void {
+    this.active = false;
+    this.firstMonthActive = false;
+    this.lastMonthActive = false;
+    this.getActiveMonth().dropActive();
+  }
+
+  initActive(fromStart: boolean): void {
+    this.active = true;
+    if (fromStart) {
+      this.firstMonthActive = true;
+      this.getFirstMonth().initActive(fromStart);
+    }
+    if (!fromStart) {
+      this.lastMonthActive = true;
+      this.getLastMonth().initActive(fromStart);
+    }
+  }
+
+  getFirstMonth(): Month {
+    return this.months[0];
+  }
+
+  getLastMonth(): Month {
+    return this.months[11];
+  }
+}

package/src/classes/filters/Cursor.ts

@@ -0,0 +1,43 @@
+import { LocationQuery } from 'vue-router';
+
+import { Operators } from '@/services/interfaces/Operators';
+
+export default class Cursor {
+  operation: Operators = Operators.Lt;
+  column = '';
+  value?: unknown;
+  initial = true;
+  tableName = '';
+  version = '';
+  model = '';
+
+  toUrlQuery(): string {
+    const operation = this.operation ? `"operation":"${this.operation}"` : '';
+    const column = this.column ? `"column":"${this.column}"` : '';
+    const v = this.value && typeof (this.value as Date).toISOString === 'function' ? (this.value as Date).toISOString() : this.value;
+
+    const value = v ? `"value":"${v}"` : '';
+    const model = this.model ? `"model":"${this.model}"` : '';
+    const initial = `"initial":${this.initial}`;
+
+    return [operation, column, value, model, initial].filter((s: string) => s !== '').toString();
+  }
+
+  fromUrlQuery(obj: LocationQuery): void {
+    if (obj.cursvalue) {
+      this.value = obj.cursvalue;
+    }
+    if (obj.curscolumn) {
+      this.column = String(obj.curscolumn);
+    }
+    if (obj.cursinitial !== undefined) {
+      this.initial = Boolean(obj.cursinitial);
+    }
+    if (obj.curstableName) {
+      this.tableName = String(obj.curstableName);
+    }
+    if (obj.cursoperation) {
+      this.operation = obj.cursoperation as Operators;
+    }
+  }
+}

package/src/classes/filters/FTSP.ts

@@ -0,0 +1,99 @@
+import Arrays from '@/services/Arrays';
+import FilterModel from '@/services/classes/filters/FilterModel';
+import Pagination from '@/services/classes/filters/Pagination';
+import TreeModel from '@/services/classes/filters/TreeModel';
+import ClassHelper from '@/services/ClassHelper';
+
+import SortModel from '../SortModel';
+
+export default class FTSP {
+  private static instance: FTSP;
+  id?: string;
+  @ClassHelper.GetClassConstructor(FilterModel)
+  f: FilterModel[] = [];
+  @ClassHelper.GetClassConstructor(SortModel)
+  s: SortModel[] = [];
+  @ClassHelper.GetClassConstructor(Pagination)
+  p: Pagination = new Pagination();
+
+  @ClassHelper.GetClassConstructor(TreeModel)
+  t: TreeModel = new TreeModel();
+
+  constructor(i?: FTSP) {
+    ClassHelper.BuildClass(this, i);
+  }
+
+  static Get(): FTSP {
+    if (!this.instance) {
+      this.instance = new FTSP();
+    }
+    return this.instance;
+  }
+
+  createFrom(ftsp: string): void {
+    const restored = new FTSP(JSON.parse(ftsp));
+    this.f = restored.f;
+  }
+
+  clearForHTTP(): FTSP {
+    const f = new FTSP(this);
+    f.f = this.f.map((fm: FilterModel) => FTSP.EmptyEntiries(fm) as FilterModel);
+    f.s = this.s.map((sm: SortModel) => FTSP.EmptyEntiries(sm) as SortModel);
+    f.p = FTSP.EmptyEntiries(this.p) as Pagination;
+    f.t = FTSP.EmptyEntiries(this.t) as TreeModel;
+    return f;
+  }
+
+  private static EmptyEntiries(sm: unknown): unknown {
+    if (!sm) {
+      return;
+    }
+    const entries = Object.entries(sm);
+    const nonEmptyOrNull = entries.filter(([key, val]) => key !== 'label' && val !== '' && val !== null); // 2️⃣
+    return Object.fromEntries(nonEmptyOrNull);
+  }
+
+  findFilterModel(m: FilterModel): FilterModel | undefined {
+    return this.f.find((f: FilterModel) => m.id === f.id);
+  }
+
+  getFirstSortModel(): SortModel | undefined {
+    return Arrays.GetLast(this.s);
+  }
+
+  setSortModel(sortModel?: SortModel): void {
+    if (!sortModel) {
+      return;
+    }
+    this.s[0] = sortModel;
+  }
+
+  setS(sortModel: SortModel): void {
+    this.s[0] = sortModel;
+  }
+
+  setF(model: FilterModel): void {
+    this.f.push(model);
+  }
+
+  replaceF(curF?: FilterModel, prevF?: FilterModel): void {
+    this.removeF(prevF);
+    if (curF) {
+      this.setF(curF);
+    }
+  }
+
+  removeF(model?: FilterModel): void {
+    const index = this.f.findIndex((f: FilterModel) => f.eq(model));
+    ClassHelper.RemoveFromClassByIndex(index, this.f);
+  }
+
+  reset(): void {
+    this.f = [];
+    this.s = [];
+    this.p = new Pagination();
+  }
+  resetF(): void {
+    this.f = [];
+  }
+}