sprof 0.1.0

package/src/classes/filters/FilterModel.ts

@@ -0,0 +1,263 @@
+import { v4 as uuidv4 } from 'uuid';
+import { Ref, ref } from 'vue';
+
+import ClassHelper from '@/services//ClassHelper';
+import Arrays from '@/services/Arrays';
+import { ClassNameGetter } from '@/services/interfaces/Class';
+import { DataTypes } from '@/services/interfaces/DataTypes';
+import { Operators } from '@/services/interfaces/Operators';
+import Strings from '@/services/Strings';
+
+export default class FilterModel {
+  id?: string;
+  model = '';
+  label = '';
+  col = '';
+  operator: Operators = Operators.Eq;
+  date1?: Date;
+  date2?: Date;
+  value1?: string = '';
+  boolean = false;
+  number = 0;
+  type: DataTypes = DataTypes.String;
+  @ClassHelper.GetClassConstructor(String)
+  set: string[] = [];
+  isSet = false;
+
+  joinTable = '';
+  joinTableModel = '';
+  joinTableFk = '';
+  joinTablePk = '';
+  joinTableId = '';
+  joinTableIdCol = '';
+
+  constructor(i?: FilterModel) {
+    ClassHelper.BuildClass(this, i);
+  }
+
+  eq(s?: FilterModel): boolean {
+    if (!s) {
+      return false;
+    }
+    if (this.type === DataTypes.Join) {
+      const eq = s.model === this.model && s.operator === this.operator && this.joinTableModel === s.joinTableModel;
+      if (s.operator === Operators.In) {
+        return eq && Arrays.Eq(this.set, s.set);
+      }
+      return eq;
+    }
+    return s.model === this.model && s.col === this.col && s.operator === this.operator;
+  }
+
+  valueEq(s?: FilterModel): boolean {
+    if (!this || !s || !this.eq(s)) {
+      return false;
+    }
+    if (this.type === DataTypes.Boolean) {
+      return this.boolean === s?.boolean;
+    }
+    if (this.type === DataTypes.String) {
+      return this.value1 === s?.value1;
+    }
+    if (this.type === DataTypes.Join) {
+      return this.set.length ? Arrays.Eq(this.set, s.set) : false;
+    }
+    return false;
+  }
+
+  toUrlQuery(): string {
+    const t = this.type ? `"type":"${this.type}"` : '';
+    const model = this.model ? `"model":"${this.model}"` : '';
+    const col = this.col ? `"col":"${this.col}"` : '';
+    const operator = this.operator ? `"operator":"${this.operator}"` : '';
+    const value1 = this.value1 ? `"value1":"${this.value1}"` : '';
+    const b = this.type === DataTypes.Boolean ? `"boolean":${this.boolean}` : '';
+    const date1 = this.type === DataTypes.Date && this.date1 ? `"date1":"${this.date1.toISOString()}"` : '';
+    const date2 = this.type === DataTypes.Date && this.date2 ? `"date2":"${this.date2.toISOString()}"` : '';
+    const n = this.type === DataTypes.Number ? `"number":${this.number}` : '';
+    const s = this.type === DataTypes.Set || this.operator === Operators.In ? `"set":${JSON.stringify(this.set)}` : '';
+    const joinTableModel = this.type === DataTypes.Join ? `"joinTableModel":"${this.joinTableModel}"` : '';
+
+    return [t, model, col, operator, value1, b, date1, date2, n, s, joinTableModel].filter((s) => s !== '').toString();
+  }
+
+  fromUrlQuery(params: URLSearchParams): void {
+    this.model = params.get('model') ?? '';
+    this.col = params.get('col') ?? '';
+    this.label = params.get('label') ?? '';
+    this.operator = (params.get('operator') as Operators) ?? '';
+    this.value1 = params.get('value1') ?? '';
+    this.type = (params.get('type') as DataTypes) ?? '';
+    this.boolean = Boolean(params.get('boolean') ?? '');
+    this.joinTableModel = params.get('joinTableModel') ?? '';
+    this.joinTableId = params.get('joinTableId') ?? '';
+    this.joinTableFk = params.get('joinTableFk') ?? '';
+    this.joinTableIdCol = params.get('joinTableIdCol') ?? '';
+    this.joinTablePk = params.get('joinTablePk') ?? '';
+  }
+
+  isUnaryFilter(): boolean {
+    return this.operator === Operators.Eq || this.operator === Operators.Gt || this.operator === Operators.Lt;
+  }
+
+  isBetweenFilter(): boolean {
+    return this.operator === Operators.Btw;
+  }
+
+  isSetFilter(): boolean {
+    return this.operator === Operators.In;
+  }
+
+  static Create(model: ClassNameGetter, col: unknown, type: DataTypes): FilterModel {
+    const filterModel = new FilterModel();
+    filterModel.model = model.GetClassName();
+    filterModel.col = (col as string) ?? '';
+    filterModel.type = type;
+    if (filterModel.type === DataTypes.Number) {
+      filterModel.value1 = '0';
+    }
+    if (filterModel.type === DataTypes.String) {
+      filterModel.value1 = '';
+    }
+    if (filterModel.type === DataTypes.Boolean) {
+      filterModel.value1 = 'false';
+      filterModel.operator = Operators.Eq;
+    }
+    return filterModel;
+  }
+
+  static CreateFilterModel(model: string | ClassNameGetter, col: unknown, type: DataTypes): FilterModel {
+    const filterModel = new FilterModel();
+    filterModel.id = uuidv4();
+    filterModel.model = typeof model === 'string' ? model : model.GetClassName();
+    filterModel.col = (col as string) ?? '';
+    filterModel.type = type;
+    if (filterModel.type === DataTypes.Number) {
+      filterModel.value1 = '0';
+    }
+    if (filterModel.type === DataTypes.String) {
+      filterModel.value1 = '';
+    }
+    if (filterModel.type === DataTypes.Boolean) {
+      filterModel.value1 = 'false';
+    }
+    return filterModel;
+  }
+
+  static CreateFilterModelWithJoin(
+    table: string,
+    col: string,
+    joinTable: string,
+    joinTablePk: string,
+    joinTableFk: string,
+    type: DataTypes,
+    joinTableId?: string,
+    joinTableIdCol?: string
+  ): FilterModel {
+    const filterModel = new FilterModel();
+    filterModel.id = uuidv4();
+    filterModel.joinTable = joinTable;
+    filterModel.joinTablePk = joinTablePk;
+    filterModel.joinTableFk = joinTableFk;
+    filterModel.col = col;
+    filterModel.type = type;
+    if (joinTableId) {
+      filterModel.joinTableId = joinTableId;
+    }
+    if (joinTableIdCol) {
+      filterModel.joinTableIdCol = joinTableIdCol;
+    }
+    return filterModel;
+  }
+
+  static CreateFilterModelWithJoinV2(
+    model: string,
+    col: string,
+    joinTableModel: string,
+    joinTablePk: string,
+    joinTableFk: string,
+    joinTableId?: string,
+    joinTableIdCol?: string
+  ): FilterModel {
+    const filterModel = new FilterModel();
+    filterModel.model = model;
+    filterModel.joinTableModel = joinTableModel;
+    filterModel.joinTablePk = joinTablePk;
+    filterModel.joinTableFk = joinTableFk;
+    filterModel.col = col;
+    filterModel.type = DataTypes.Join;
+    if (joinTableId) {
+      filterModel.joinTableId = joinTableId;
+    }
+    if (joinTableIdCol) {
+      filterModel.joinTableIdCol = joinTableIdCol;
+    }
+    return filterModel;
+  }
+
+  static OnlyIfSecondModelExists(firstClass: ClassNameGetter, secondClass: ClassNameGetter): FilterModel {
+    const filterModel = new FilterModel();
+    filterModel.id = uuidv4();
+
+    filterModel.model = Strings.ToCamelCase(firstClass.GetClassName());
+    filterModel.joinTableModel = Strings.ToCamelCase(secondClass.GetClassName());
+    filterModel.type = DataTypes.Join;
+    return filterModel;
+  }
+
+  addToSet(...setElements: string[]): void {
+    setElements.forEach((setElement) => {
+      if (this.set.indexOf(setElement) === -1) {
+        this.set.push(setElement);
+        return;
+      }
+      this.set = this.set.filter((s: string) => s !== setElement);
+    });
+  }
+
+  pushToSet(...setElements: string[]): void {
+    setElements.forEach((setElement) => {
+      if (this.set.indexOf(setElement) === -1) {
+        this.set.push(setElement);
+      }
+    });
+  }
+
+  replaceSet(...setElements: string[]): void {
+    this.set = setElements;
+  }
+
+  setBoolean(value: boolean): void {
+    this.boolean = value;
+  }
+
+  toRef(): Ref<FilterModel> {
+    return ref(this);
+  }
+
+  setDate1(date?: Date): void {
+    this.date1 = date;
+  }
+
+  setDate2(date?: Date): void {
+    this.date2 = date;
+  }
+
+  dropDates(): void {
+    this.setDate1();
+    this.setDate2();
+  }
+  setDatesRange(date1?: Date, date2?: Date): void {
+    if (!date1 && !date2) {
+      this.dropDates();
+      return;
+    }
+    if (!date2) {
+      this.setDate1(date1);
+      this.operator = Operators.Eq;
+      return;
+    }
+    this.setDate2(date2);
+    this.operator = Operators.Btw;
+  }
+}

package/src/classes/filters/FilterQuery.ts

@@ -0,0 +1,187 @@
+import { LocationQuery } from 'vue-router';
+
+import FilterModel from '@/services/classes/filters/FilterModel';
+import Pagination from '@/services/classes/filters/Pagination';
+import { Operators } from '@/services/interfaces/Operators';
+
+import SortModel from '../SortModel';
+
+export default class FilterQuery {
+  id?: string;
+  col = '';
+  value = '';
+  filterModels: FilterModel[] = [];
+  sortModels: SortModel[] = [];
+  sortModel: SortModel | undefined;
+  pagination: Pagination = new Pagination();
+  withDeleted = false;
+
+  f: FilterModel[] = [];
+  s: SortModel[] = [];
+  p: Pagination = new Pagination();
+
+  static Create(filters: FilterModel[], sortModels: SortModel[], pagination?: Pagination): FilterQuery {
+    const item = new FilterQuery();
+    item.filterModels = filters;
+    item.sortModels = sortModels;
+    if (pagination) {
+      item.pagination = pagination;
+    }
+    return item;
+  }
+
+  setQid(qid: string) {
+    this.id = qid;
+  }
+
+  toFTSP(): void {
+    this.f = this.filterModels;
+    this.s = this.sortModels;
+    this.p = this.pagination;
+  }
+
+  toUrl(): string {
+    const filterModels = this.filterModels?.map((filterModel: FilterModel) => {
+      return `filterModel={${filterModel.toUrlQuery()}}`;
+    });
+    const sortModels = this.sortModels.map((sortModels: SortModel) => {
+      return `sortModel={${sortModels.toUrlQuery()}}`;
+    });
+    if (this.sortModel) {
+      sortModels.push(`sortModel={${this.sortModel.toUrlQuery()}}`);
+    }
+    const pagination = `pagination={${this.pagination.toUrlQuery()}}`;
+
+    const withDeleted = `withDeleted=${this.withDeleted}`;
+    const all = [...filterModels, ...sortModels, withDeleted, pagination];
+    if (this.col) {
+      all.push(`col=${this.col}`);
+    }
+    if (this.value) {
+      all.push(`value=${this.value}`);
+    }
+    let url = `?${all.join('&')}`;
+    if (this.id) {
+      url = `${this.id}${url}`;
+    }
+    return url;
+  }
+
+  toUrlQuery(): string {
+    let url = '';
+    url += 's=';
+    url += this.sortModel?.toUrlQuery();
+    url += 'p=';
+    url += this.pagination.toUrlQuery();
+
+    let filterModelsUrlQuery = 'f=';
+    this.filterModels.forEach((fm, i) => {
+      if (i !== 0) {
+        filterModelsUrlQuery += ',';
+      }
+      filterModelsUrlQuery += fm.toUrlQuery();
+    });
+    url += filterModelsUrlQuery;
+    return url;
+  }
+
+  async fromUrlQuery(obj: LocationQuery): Promise<void> {
+    this.pagination.fromUrlQuery(obj);
+    if (!this.pagination.limit || !this.pagination.offset) {
+      this.pagination.limit = 25;
+    }
+
+    const sortModel = new SortModel();
+    if (sortModel.model) {
+      this.setSortModel(sortModel);
+    }
+
+    const str = window.location.search;
+    const filterModels = str.substring(str.indexOf('f=') + 2, str.lastIndexOf('|'));
+    const modelsStrings = filterModels.split(',');
+    const params = modelsStrings.map((m) => new URLSearchParams(decodeURIComponent(m)));
+
+    params.forEach((p: URLSearchParams) => {
+      const fm = new FilterModel();
+      fm.fromUrlQuery(p);
+      if (fm.col) {
+        this.filterModels.push(fm);
+      }
+    });
+  }
+
+  setParams(col: unknown, value: string): void {
+    this.col = (col as string) ?? '';
+    this.value = value;
+  }
+
+  setCursorPagination(schema: unknown, object: Record<string, unknown>): void {
+    const s = schema as Record<string, unknown>;
+    // const sortModel = this.sortModels.find((s: SortModel) => s.id);
+    if (!this.sortModel) {
+      return;
+    }
+    for (const p in s) {
+      if (s[p] === this.sortModel.col) {
+        if (p === 'sortColumn') {
+          continue;
+        }
+        this.pagination.cursor.column = this.sortModel.col;
+        this.pagination.cursor.value = String(object[p]);
+        this.pagination.cursor.operation = this.sortModel.isAsc() ? Operators.Gt : Operators.Lt;
+        this.pagination.cursorMode = true;
+        this.pagination.cursor.initial = false;
+        break;
+      }
+    }
+  }
+
+  setSortModel(sortModel: SortModel) {
+    if (this.sortModel) {
+      return;
+    }
+    this.sortModel = sortModel;
+  }
+
+  findFilterModel(m: FilterModel): FilterModel | undefined {
+    return this.filterModels.find((f: FilterModel) => {
+      if (f.model === m.model && f.label === m.label && f.col === m.col && f.operator === m.operator) {
+        if (f.value1 === m.value1 || f.boolean === m.boolean) {
+          return true;
+        }
+      }
+    });
+  }
+
+  setFilterModel(filterModel: FilterModel) {
+    filterModel.isSet = true;
+    let item = this.filterModels.find((i: FilterModel) => i.id === filterModel.id);
+    if (item) {
+      item = filterModel;
+    } else {
+      this.filterModels.push(filterModel);
+    }
+  }
+
+  spliceFilterModel(id: string | undefined) {
+    const index = this.filterModels.findIndex((i: FilterModel) => i.id === id);
+    if (index > -1) {
+      this.filterModels.splice(index, 1);
+    }
+  }
+
+  reset(): void {
+    this.filterModels.forEach((filterModel: FilterModel) => {
+      filterModel.isSet = false;
+      filterModel.value1 = '';
+      filterModel.date1 = undefined;
+      filterModel.date2 = undefined;
+      filterModel.boolean = false;
+      filterModel.set = [];
+    });
+    this.pagination = new Pagination();
+    this.filterModels = [];
+    this.sortModels = [];
+    this.sortModel = undefined;
+  }
+}

package/src/classes/filters/OperatorsOptions.ts

@@ -0,0 +1,8 @@
+import { Operators } from '@/services/interfaces/Operators';
+
+export default [
+  { label: 'Равна', value: Operators.Eq },
+  { label: 'Больше чем', value: Operators.Gt },
+  { label: 'Меньше чем', value: Operators.Lt },
+  { label: 'Между', value: Operators.Btw },
+];

package/src/classes/filters/OperatorsTextOptions.ts

@@ -0,0 +1,3 @@
+import { Operators } from '@/services/interfaces/Operators';
+
+export default [{ label: 'Содержит', value: Operators.Like }];

package/src/classes/filters/Pagination.ts

@@ -0,0 +1,78 @@
+import Cursor from '@/services/classes/filters/Cursor';
+import ClassHelper from '@/services/ClassHelper';
+import { Operators } from '@/services/interfaces/Operators';
+
+export default class Pagination {
+  offset = 0;
+  limit = 25;
+  cursor: Cursor = new Cursor();
+  cursorMode = false;
+  append = false;
+  allLoaded = false;
+  version = '';
+
+  constructor(i?: Pagination) {
+    ClassHelper.BuildClass(this, i);
+  }
+
+  setLoadMore(lastCursor: string, column: string, table: string): void {
+    this.cursor.value = lastCursor;
+    this.cursor.initial = false;
+    this.cursor.operation = Operators.Gt;
+    this.cursor.column = column;
+    this.cursor.tableName = table;
+    this.cursorMode = true;
+    return;
+  }
+
+  setLoadMoreV2(lastCursor: string, column: string, model: string): void {
+    this.cursor.value = lastCursor;
+    this.cursor.initial = false;
+    this.cursor.operation = Operators.Gt;
+    this.cursor.column = column;
+    this.cursor.model = model;
+    this.cursorMode = true;
+    this.version = 'v2';
+    return;
+  }
+
+  setOffset(itemsLen: number): void {
+    this.offset = itemsLen;
+  }
+
+  toUrlQuery(): string {
+    const offset = `"offset":${this.offset}`;
+    const limit = `"limit":${this.limit}`;
+    const cursorMode = `"cursorMode":${this.cursorMode}`;
+    const append = `"append":${this.append}`;
+    const allLoaded = `"allLoaded":${this.allLoaded}`;
+    const cursor = `"cursor":{${this.cursor.toUrlQuery()}}`;
+    return [offset, limit, cursorMode, append, allLoaded, cursor].toString();
+  }
+
+  fromUrlQuery(): void {
+    const str = window.location.search;
+    const sormModelString = str.substring(str.indexOf('p=') + 2, str.lastIndexOf('|'));
+    const params = new URLSearchParams(decodeURIComponent(sormModelString));
+    this.offset = Number(params.get('offset'));
+    this.limit = Number(params.get('col'));
+  }
+
+  setAllLoaded(loadedItemsLength: number): void {
+    this.allLoaded = !(loadedItemsLength >= this.limit);
+  }
+  resetAllLoaded(): void {
+    this.allLoaded = false;
+  }
+  getPageNum(): number {
+    return this.offset / this.limit + 1;
+  }
+
+  drop() {
+    this.offset = 0;
+    this.limit = 25;
+    //TODO: Переделать,когда FTSP станет реактивным
+    // Store.Commit('pagination/setCurPage', 1);
+    ClassHelper.BuildClass(this);
+  }
+}

package/src/classes/filters/SelectFilter.ts

@@ -0,0 +1,15 @@
+import IOption from '@/services/interfaces/IOption';
+import ISelectFilter from '@/services/interfaces/ISelectFilter';
+
+export default class SelectFilter implements ISelectFilter {
+  title = '';
+  options: IOption[] = [];
+
+  constructor(selectFilter?: ISelectFilter) {
+    if (!selectFilter) {
+      return;
+    }
+    this.title = selectFilter.title;
+    this.options = selectFilter.options;
+  }
+}

package/src/classes/filters/TreeModel.ts

@@ -0,0 +1,14 @@
+import { ClassNameGetter } from '../../interfaces/Class';
+
+export default class TreeModel {
+  model = '';
+  cols: string[] = [];
+  models: TreeModel[] = [];
+
+  static Create(model: ClassNameGetter, cols: string[]): TreeModel {
+    const m = new TreeModel();
+    m.model = model.GetClassName();
+    m.cols = cols;
+    return m;
+  }
+}

package/src/classes/page/CustomSection.ts

@@ -0,0 +1,24 @@
+import ClassHelper from '@/services/ClassHelper';
+
+export default class CustomSection {
+  id = '';
+  name = '';
+  component = '';
+  order?: number;
+  active = false;
+  key = 0;
+
+  constructor(i?: CustomSection) {
+    ClassHelper.BuildClass(this, i);
+  }
+
+  static Create(id: string, name: string, componentName: string, order?: number, active?: boolean): CustomSection {
+    const item = new CustomSection();
+    item.id = id;
+    item.name = name;
+    item.component = componentName;
+    item.order = order;
+    item.active = !!active;
+    return item;
+  }
+}