refactor appointment date provider and filter strategies (DevExpress#29536)

Co-authored-by: Vladimir Bushmanov <[email protected]>

Author: Ambrozy

packages/devextreme/js/__internal/scheduler/appointments/data_provider/m_appointment_data_provider.ts

@@ -3,11 +3,18 @@ import { combineRemoteFilter } from '@ts/scheduler/r1/filterting/index';
 import type { AppointmentDataAccessor } from '@ts/scheduler/utils';
 
 import { AppointmentDataSource } from './m_appointment_data_source';
-import { AppointmentFilterBaseStrategy, AppointmentFilterVirtualStrategy } from './m_appointment_filter';
+import { AppointmentFilterBaseStrategy } from './m_appointment_filter';
+import { AppointmentFilterVirtualStrategy } from './m_appointment_filter_virtual';
 
-const FilterStrategies = {
-  virtual: 'virtual',
-  standard: 'standard',
+type FilterStrategy = (AppointmentFilterBaseStrategy | AppointmentFilterVirtualStrategy) & {
+  constructor: (AppointmentFilterBaseStrategy | AppointmentFilterVirtualStrategy)['constructor'] & {
+    strategyName: string;
+  };
+};
+
+const FilterStrategyMap = {
+  [AppointmentFilterVirtualStrategy.strategyName]: AppointmentFilterVirtualStrategy,
+  [AppointmentFilterBaseStrategy.strategyName]: AppointmentFilterBaseStrategy,
 };
 
 export class AppointmentDataProvider {
@@ -21,7 +28,7 @@ export class AppointmentDataProvider {
 
   appointmentDataSource: AppointmentDataSource;
 
-  filterStrategy: any;
+  filterStrategy!: FilterStrategy;
 
   constructor(options) {
     this.options = options;
@@ -30,7 +37,6 @@ export class AppointmentDataProvider {
     this.timeZoneCalculator = this.options.timeZoneCalculator;
 
     this.appointmentDataSource = new AppointmentDataSource(this.dataSource);
-
     this.initFilterStrategy();
   }
 
@@ -42,21 +48,24 @@ export class AppointmentDataProvider {
     return !!this.dataSource;
   }
 
-  get filterStrategyName() {
+  get filterStrategyName(): string {
     return this.options.getIsVirtualScrolling()
-      ? FilterStrategies.virtual
-      : FilterStrategies.standard;
+      ? AppointmentFilterVirtualStrategy.strategyName
+      : AppointmentFilterBaseStrategy.strategyName;
   }
 
-  getFilterStrategy() {
-    if (!this.filterStrategy || this.filterStrategy.strategyName !== this.filterStrategyName) {
+  getFilterStrategy(): AppointmentFilterBaseStrategy | AppointmentFilterVirtualStrategy {
+    if (
+      !this.filterStrategy
+      || this.filterStrategy.constructor.strategyName !== this.filterStrategyName
+    ) {
       this.initFilterStrategy();
     }
 
     return this.filterStrategy;
   }
 
-  initFilterStrategy() {
+  initFilterStrategy(): void {
     const filterOptions = {
       resources: this.options.resources,
       dataAccessors: this.dataAccessors,
@@ -75,19 +84,18 @@ export class AppointmentDataProvider {
       viewDataProvider: this.options.getViewDataProvider,
       allDayPanelMode: this.options.allDayPanelMode,
     };
+    const strategy = new FilterStrategyMap[this.filterStrategyName](filterOptions);
 
-    this.filterStrategy = this.filterStrategyName === FilterStrategies.virtual
-      ? new AppointmentFilterVirtualStrategy(filterOptions)
-      : new AppointmentFilterBaseStrategy(filterOptions);
+    this.filterStrategy = strategy as FilterStrategy;
   }
 
-  setDataSource(dataSource) {
+  setDataSource(dataSource): void {
     this.dataSource = dataSource;
     this.initFilterStrategy();
     this.appointmentDataSource.setDataSource(this.dataSource);
   }
 
-  updateDataAccessors(dataAccessors) {
+  updateDataAccessors(dataAccessors): void {
     this.dataAccessors = dataAccessors;
     this.initFilterStrategy();
   }
@@ -124,10 +132,6 @@ export class AppointmentDataProvider {
     return this.getFilterStrategy().filterLoadedAppointments(filterOption, preparedItems);
   }
 
-  calculateAppointmentEndDate(isAllDay, startDate) {
-    return this.getFilterStrategy().calculateAppointmentEndDate(isAllDay, startDate);
-  }
-
   // Appointment data source mappings
   cleanState() { this.appointmentDataSource.cleanState(); }
 

packages/devextreme/js/__internal/scheduler/appointments/data_provider/m_appointment_filter.ts

@@ -1,21 +1,18 @@
 /* eslint-disable max-classes-per-file */
 import { wrapToArray } from '@js/core/utils/array';
 import dateUtils from '@js/core/utils/date';
-import { each, map } from '@js/core/utils/iterator';
+import { map } from '@js/core/utils/iterator';
 import { isDefined, isFunction } from '@js/core/utils/type';
 import query from '@js/data/query';
 import { dateUtilsTs } from '@ts/core/utils/date';
+import type { AppointmentDataItem } from '@ts/scheduler/r1/types';
 import {
-  getAppointmentTakesAllDay, getDatesWithoutTime, hasResourceValue, isDateAndTimeView,
-  isTimelineView,
+  getDatesWithoutTime, hasResourceValue, isAppointmentTakesAllDay, isTimelineView,
 } from '@ts/scheduler/r1/utils/index';
 import type { AppointmentDataAccessor } from '@ts/scheduler/utils';
 
 import { createAppointmentAdapter } from '../../m_appointment_adapter';
 import { getRecurrenceProcessor } from '../../m_recurrence';
-import {
-  getResourcesDataByGroups,
-} from '../../resources/m_utils';
 import {
   _appointmentPartInInterval,
   compareDateWithEndDayHour,
@@ -28,25 +25,18 @@ import {
 
 const toMs = dateUtils.dateToMilliseconds;
 
-const FilterStrategies = {
-  virtual: 'virtual',
-  standard: 'standard',
-};
-
 export class AppointmentFilterBaseStrategy {
+  public static readonly strategyName: string = 'standard';
+
   options: any;
 
   dataAccessors: AppointmentDataAccessor;
 
   constructor(options) {
     this.options = options;
     this.dataAccessors = this.options.dataAccessors;
-
-    this._init();
   }
 
-  get strategyName() { return FilterStrategies.standard; }
-
   get timeZoneCalculator() { return this.options.timeZoneCalculator; }
 
   get viewStartDayHour() { return this.options.startDayHour; }
@@ -82,11 +72,7 @@ export class AppointmentFilterBaseStrategy {
       : result;
   }
 
-  _init() {
-    this.setDataAccessors(this.dataAccessors);
-  }
-
-  filter(preparedItems) {
+  filter(preparedItems: AppointmentDataItem[]) {
     const [min, max] = this.dateRange;
     const { viewOffset } = this.options;
     const allDay = !this.showAllDayPanel && this.supportAllDayRow
@@ -109,36 +95,19 @@ export class AppointmentFilterBaseStrategy {
   }
 
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  hasAllDayAppointments(filteredItems, preparedItems) {
-    const adapters = filteredItems.map((item) => createAppointmentAdapter(
-      item,
-      this.dataAccessors,
-      this.timeZoneCalculator,
-    ));
-
-    let result = false;
-
-    // @ts-expect-error
-    each(adapters, (_, item) => {
-      if (getAppointmentTakesAllDay(
+  hasAllDayAppointments(filteredItems, preparedItems: AppointmentDataItem[]): boolean {
+    return filteredItems
+      .map((item) => createAppointmentAdapter(
         item,
-        this.allDayPanelMode,
-      )) {
-        result = true;
-        return false;
-      }
-    });
-
-    return result;
-  }
-
-  setDataAccessors(dataAccessors) {
-    this.dataAccessors = dataAccessors;
+        this.dataAccessors,
+        this.timeZoneCalculator,
+      ))
+      .some((item) => isAppointmentTakesAllDay(item, this.allDayPanelMode));
   }
 
   private _createAllDayAppointmentFilter() {
     return [[
-      (appointment) => getAppointmentTakesAllDay(
+      (appointment) => isAppointmentTakesAllDay(
         appointment,
         this.allDayPanelMode,
       ),
@@ -178,7 +147,7 @@ export class AppointmentFilterBaseStrategy {
       const startDate = dateUtilsTs.addOffsets(appointment.startDate, [-viewOffset]);
       const endDate = dateUtilsTs.addOffsets(appointment.endDate, [-viewOffset]);
 
-      const appointmentTakesAllDay = getAppointmentTakesAllDay(
+      const appointmentTakesAllDay = isAppointmentTakesAllDay(
         appointment,
         this.allDayPanelMode,
       );
@@ -336,134 +305,24 @@ export class AppointmentFilterBaseStrategy {
     return result;
   }
 
-  filterLoadedAppointments(filterOptions, preparedItems) {
+  filterLoadedAppointments(filterOptions, preparedItems: AppointmentDataItem[]) {
     const filteredItems = this.filterPreparedItems(filterOptions, preparedItems);
     return filteredItems.map(({ rawAppointment }) => rawAppointment);
   }
 
-  filterPreparedItems(filterOptions, preparedItems) {
+  filterPreparedItems(filterOptions, preparedItems: AppointmentDataItem[]) {
     const combinedFilter = this._createCombinedFilter(filterOptions);
 
     return query(preparedItems)
       .filter(combinedFilter)
       .toArray();
   }
 
-  filterAllDayAppointments(preparedItems) {
+  filterAllDayAppointments(preparedItems: AppointmentDataItem[]) {
     const combinedFilter = this._createAllDayAppointmentFilter();
     return query(preparedItems)
       .filter(combinedFilter)
       .toArray()
       .map(({ rawAppointment }) => rawAppointment);
   }
 }
-
-export class AppointmentFilterVirtualStrategy extends AppointmentFilterBaseStrategy {
-  get strategyName() { return FilterStrategies.virtual; }
-
-  get resources() { return this.options.resources; }
-
-  filter(preparedItems) {
-    const { viewOffset } = this.options;
-    const hourMs = toMs('hour');
-    const isCalculateStartAndEndDayHour = isDateAndTimeView(this.viewType);
-    const checkIntersectViewport = isCalculateStartAndEndDayHour && this.viewDirection === 'horizontal';
-
-    const isAllDayWorkspace = !this.supportAllDayRow;
-    const showAllDayAppointments = this.showAllDayPanel || isAllDayWorkspace;
-
-    const endViewDate = this.viewDataProvider.getLastViewDateByEndDayHour(this.viewEndDayHour);
-    const shiftedEndViewDate = dateUtilsTs.addOffsets(endViewDate, [viewOffset]);
-    const filterOptions: any = [];
-
-    const groupsInfo = this.viewDataProvider.getCompletedGroupsInfo();
-    groupsInfo.forEach((item) => {
-      const { groupIndex } = item;
-      const groupStartDate: Date = item.startDate;
-      const groupEndDate: Date = new Date(
-        Math.min(
-          item.endDate.getTime(),
-          shiftedEndViewDate.getTime(),
-        ),
-      );
-
-      const startDayHour = isCalculateStartAndEndDayHour
-        ? groupStartDate.getHours()
-        : this.viewStartDayHour;
-      const endDayHour = isCalculateStartAndEndDayHour
-        ? startDayHour + groupStartDate.getMinutes() / 60 + (groupEndDate.getTime() - groupStartDate.getTime()) / hourMs
-        : this.viewEndDayHour;
-
-      const resources = this._getPrerenderFilterResources(groupIndex);
-
-      const hasAllDayPanel = this.viewDataProvider.hasGroupAllDayPanel(groupIndex);
-
-      const supportAllDayAppointment = isAllDayWorkspace || (!!showAllDayAppointments && hasAllDayPanel);
-
-      filterOptions.push({
-        isVirtualScrolling: true,
-        startDayHour,
-        endDayHour,
-        viewOffset,
-        viewStartDayHour: this.viewStartDayHour,
-        viewEndDayHour: this.viewEndDayHour,
-        min: dateUtilsTs.addOffsets(groupStartDate, [-viewOffset]),
-        max: dateUtilsTs.addOffsets(groupEndDate, [-viewOffset]),
-        supportMultiDayAppointments: isTimelineView(this.viewType),
-        allDay: supportAllDayAppointment,
-        resources,
-        firstDayOfWeek: this.firstDayOfWeek,
-        checkIntersectViewport,
-      });
-    });
-
-    return this.filterLoadedAppointments({
-      filterOptions,
-      groupCount: this.groupCount,
-    }, preparedItems);
-  }
-
-  filterPreparedItems({ filterOptions, groupCount }, preparedItems) {
-    const combinedFilters: any = [];
-
-    let itemsToFilter = preparedItems;
-    const needPreFilter = groupCount > 0;
-    if (needPreFilter) {
-      // @ts-expect-error
-      itemsToFilter = itemsToFilter.filter(({ rawAppointment }) => {
-        for (let i = 0; i < filterOptions.length; ++i) {
-          const { resources } = filterOptions[i];
-          if (this._filterAppointmentByResources(rawAppointment, resources)) {
-            return true;
-          }
-        }
-      });
-    }
-
-    filterOptions.forEach((option) => {
-      combinedFilters.length && combinedFilters.push('or');
-
-      const filter = this._createCombinedFilter(option);
-
-      combinedFilters.push(filter);
-    });
-
-    return query(itemsToFilter)
-      .filter(combinedFilters)
-      .toArray();
-  }
-
-  hasAllDayAppointments(filteredItems, preparedItems) {
-    return this.filterAllDayAppointments(preparedItems).length > 0;
-  }
-
-  _getPrerenderFilterResources(groupIndex) {
-    const cellGroup = this.viewDataProvider.getCellsGroup(groupIndex);
-
-    return getResourcesDataByGroups(
-      this.loadedResources,
-      this.resources,
-      [cellGroup],
-    );
-  }
-}