right-angled
Version:
Lightweight and easy to use angular data grids. Integrates with your markup and styles rather than generating its own.
370 lines • 47.1 kB
JavaScript
import { EventEmitter, Inject, Injectable, InjectionToken, Optional, SkipSelf } from '@angular/core';
import { BehaviorSubject } from 'rxjs';
import { RTFiltersService } from '../../filters/filters.service';
import { destroyAll } from '../../utilities';
import { RTSortingsService } from './sortings.service';
import { OperationStatus } from '../../core/operation-status';
import { AsyncSubscriber } from './async-subscriber';
import { NullObjectPager } from './null-object-pager';
import { map } from 'rxjs/operators';
import * as i0 from "@angular/core";
import * as i1 from "./async-subscriber";
import * as i2 from "./state.service";
import * as i3 from "./sortings.service";
import * as i4 from "../../filters/filters.service";
export const RTFilterTarget = new InjectionToken('RTFilterTarget');
export class OperationStatusStream {
}
export class RTList {
/**
* Global settings of list..
*
* These settings are static and their values are copied to the properties of the same name for each instance of {@link RTList} type.
*
* So, changing of this settings will affect all instances of {@link RTList} type that will be created after such changes.
* If you want to change settings of concrete object you can use it the same name properties.
*/
static { this.settings = {
/**
* @see {@link RTList.keepRecordsOnLoad}
*/
keepRecordsOnLoad: false
}; }
constructor(asyncSubscriber, stateServices, // | RTStateService[],
filterTargets, sortingsService, filtersService) {
this.asyncSubscriber = asyncSubscriber;
this.sortingsService = sortingsService;
this.filtersService = filtersService;
this.loadStarted = new EventEmitter();
this.loadSucceed = new EventEmitter();
this.loadFailed = new EventEmitter();
this.filterTargets = [];
/**
* Specifies that list must destroy previously loaded records immediately or keep them until data request is completed.
*/
this.keepRecordsOnLoad = RTList.settings.keepRecordsOnLoad;
/**
* Can be used with `Observable` data sourceto specify that list must keep previously loaded records or destroy them when new value published
*/
this.appendStreamedData = null;
/**
* Array of registered {@link RTStateService} instances.
*/
this.stateServices = new Array();
/**
* Async implementation of @see RTList.status
*/
this.status$ = new BehaviorSubject(OperationStatus.Initial);
/**
* Async implementation of @see RTList.destroyed
*/
this.destroyed$ = new BehaviorSubject(false);
/**
* Async implementation of @see RTList.inited
*/
this.inited$ = new BehaviorSubject(false);
/**
* Async implementation of @see RTList.items
*/
this.items$ = new BehaviorSubject([]);
/**
* Async implementation of @see RTList.busy
*/
this.busy$ = this.status$.pipe(map(status => status === OperationStatus.Progress));
/**
* Async implementation of @see RTList.ready
*/
this.ready$ = this.status$.pipe(map(status => status !== OperationStatus.Progress));
this.loadDataSuccessCallback = (response) => {
if (this.tryInterceptStatusResponse(response)) {
return response;
}
this.tryCleanItemsOnLoad(true);
return this.loadSuccessCallback(response);
};
this.reloadDataSuccessCallback = (response) => {
if (this.tryInterceptStatusResponse(response)) {
return response;
}
this.tryCleanItemsOnReload(true);
return this.loadSuccessCallback(response);
};
this.loadDataFailCallback = () => {
this.tryCleanItemsOnLoad(true);
this.loadFailCallback();
};
this.reloadDataFailCallback = () => {
this.tryCleanItemsOnReload(true);
this.loadFailCallback();
};
if (stateServices != null) {
if (Array.isArray(stateServices)) {
this.stateServices.push(...stateServices);
}
else {
this.stateServices.push(stateServices);
}
}
this.pager = new NullObjectPager();
if (filterTargets != null) {
if (Array.isArray(filterTargets)) {
this.filterTargets.push(...filterTargets);
}
else {
this.filterTargets.push(filterTargets);
}
}
}
/**
* Array of elements transferred in the {@link ListResponse.items} property.
*/
get items() {
return this.items$.getValue();
}
/**
* Configured {@link Pager} service.
*/
get pager() {
return this.pagerInternal;
}
set pager(value) {
this.filtersService.removeFilterTarget(this.pagerInternal);
this.pagerInternal = value;
this.filtersService.registerFilterTarget(this.pagerInternal);
}
/**
* True if the service was already destroyed via {@link destroy} call.
*/
get destroyed() {
return this.destroyed$.getValue();
}
/**
* True if the service was already initialized via {@link init} call.
*/
get inited() {
return this.inited$.getValue();
}
/**
* Current execution status of the list.
*/
get status() {
return this.status$.getValue();
}
/**
* returns `true`, if there is a data request executed at the moment (i.e. {@link state} is equal to {@link ProgressState.Progress})
*/
get busy() {
return this.status === OperationStatus.Progress;
}
/**
* returns `true`, if there is no data request executed at the moment (i.e. {@link state} is NOT equal to {@link ProgressState.Progress})
*/
get ready() {
return this.status !== OperationStatus.Progress;
}
/**
* Performs initialization logic of the service. This method must be called before first use of the service.
*/
init() {
if (this.inited) {
return;
}
this.filtersService.registerFilterTarget(...this.filterTargets);
this.filtersService.registerFilterTarget(this.pager, this.sortingsService);
const restoredState = {};
Object.assign(restoredState, ...this.stateServices.map((service) => service.getState() || {}));
this.filtersService.applyParams(restoredState);
this.inited$.next(true);
}
/**
* Performs destroy logic of the list itself and all of the inner services.
*/
destroy() {
this.asyncSubscriber.destroy();
this.filtersService.destroy();
this.sortingsService.destroy();
this.clearData();
this.destroyed$.next(true);
}
/**
* Registers passed object(s) as state service to manage the list state.
*/
registerStateService(...services) {
services.forEach((service) => {
this.stateServices.push(service);
});
}
/**
* Removes passed object(s) from state services collection of the list.
*/
removeStateService(...services) {
services.forEach((service) => {
const index = this.stateServices.findIndex((s) => s === service);
if (index !== -1) {
this.stateServices.splice(index, 1);
}
});
}
/**
* Registers passed object(s) as filter targets in underlying {@link FiltersService} to include their configured properties as parameters to the data request.
* @see {@link FiltersService.registerFilterTarget}
*/
registerFilterTarget(...targets) {
this.filtersService.registerFilterTarget(...targets);
}
/**
* @see {@link FiltersService.removeFilterTarget}
*/
removeFilterTarget(...targets) {
this.filtersService.removeFilterTarget(...targets);
}
/**
* @see {@link FiltersService.getRequestState}
*/
getRequestState(filterFn) {
return this.filtersService.getRequestState(filterFn);
}
/**
* Resets the list parameters (sortings, paging, filters) to their default values.
*/
resetSettings() {
this.asyncSubscriber.detach();
this.filtersService.resetValues();
this.pager.reset();
this.clearData();
this.status$.next(OperationStatus.Initial);
}
/**
* Cancels the request executed at the moment.
*/
cancelRequests() {
if (this.busy || this.appendStreamedData !== null) {
this.asyncSubscriber.detach();
this.status$.next(OperationStatus.Cancelled);
this.clearData();
}
}
/**
* Clears {@link items} array. Calls {@link destroyAll} method for {@link items} array to perform optional destroy logic of the elements.
* {@see destroyAll}
*/
clearData() {
destroyAll(this.items);
this.items$.next([]);
}
/**
* Performs data loading by calling specified {@link fetchMethod} delegate.
* @return result of {@link fetchMethod} execution.
*/
loadData() {
if (this.busy) {
return null;
}
this.loadStarted.emit();
const subscribable = this.beginRequest();
this.tryCleanItemsOnLoad(false);
this.asyncSubscriber.attach(subscribable, this.loadDataSuccessCallback, this.loadDataFailCallback);
this.stateServices.forEach((service) => {
service.persistState(this.filtersService);
});
return subscribable;
}
/**
* Resets paging parameters and performs data loading by calling {@link loadData} if list not in {@link OperationStatus.Progress} state.
* @return result of {@link fetchMethod} if it was called. `null` otherwise.
*/
reloadData() {
if (this.busy) {
return null;
}
this.loadStarted.emit();
this.pager.reset();
const subscribable = this.beginRequest();
this.tryCleanItemsOnReload(false);
this.asyncSubscriber.attach(subscribable, this.reloadDataSuccessCallback, this.reloadDataFailCallback);
this.stateServices.forEach((service) => {
service.persistState(this.filtersService);
});
return subscribable;
}
/**
* Callback which is executed if {@link fetchMethod} execution finished successfully.
*/
loadSuccessCallback(response) {
const items = Array.isArray(response) ? response : response.items;
this.items$.next(this.items.concat(items));
this.pager.processResponse(response);
// In case when filter changed from last request and there's no data now
// Don't do this for flat responses since we don't know real count items
if (!Array.isArray(response) && this.pager.totalCount === 0) {
this.clearData();
this.pager.reset();
}
this.status$.next(this.pager.totalCount === 0 && this.items.length === 0 ? OperationStatus.NoData : OperationStatus.Done);
this.loadSucceed.emit(response);
return response;
}
/**
* Callback which is executed if {@link fetchMethod} execution finished with error.
*/
loadFailCallback() {
this.tryCleanItemsOnLoad(true);
this.status$.next(OperationStatus.Fail);
this.loadFailed.emit();
}
tryInterceptStatusResponse(response) {
if (this.responseHasStatus(response)) {
switch (response.status) {
case OperationStatus.Fail:
this.reloadDataFailCallback();
return true;
case OperationStatus.Cancelled:
this.cancelRequests();
return true;
case OperationStatus.Progress:
return true;
}
}
return false;
}
tryCleanItemsOnLoad(requestCompleted) {
if (this.keepRecordsOnLoad === requestCompleted && this.pager.appendedOnLoad === false) {
this.clearData();
}
if (requestCompleted && this.appendStreamedData === false) {
this.clearData();
}
}
tryCleanItemsOnReload(requestCompleted) {
if (this.keepRecordsOnLoad === requestCompleted) {
this.clearData();
}
if (requestCompleted && this.appendStreamedData === false) {
this.clearData();
}
}
beginRequest() {
this.status$.next(OperationStatus.Progress);
const requestState = this.filtersService.getRequestState();
return this.fetchMethod(requestState);
}
responseHasStatus(response) {
return response.status !== null && typeof response.status !== 'undefined';
}
static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: RTList, deps: [{ token: i1.AsyncSubscriber }, { token: i2.RTStateService, optional: true }, { token: RTFilterTarget, optional: true, skipSelf: true }, { token: i3.RTSortingsService }, { token: i4.RTFiltersService }], target: i0.ɵɵFactoryTarget.Injectable }); }
static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: RTList }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: RTList, decorators: [{
type: Injectable
}], ctorParameters: function () { return [{ type: i1.AsyncSubscriber }, { type: i2.RTStateService, decorators: [{
type: Optional
}] }, { type: undefined, decorators: [{
type: SkipSelf
}, {
type: Optional
}, {
type: Inject,
args: [RTFilterTarget]
}] }, { type: i3.RTSortingsService }, { type: i4.RTFiltersService }]; } });
export const LIST_PROVIDERS = [AsyncSubscriber, RTList, RTFiltersService, RTSortingsService, { provide: OperationStatusStream, useExisting: RTList }];
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"list.js","sourceRoot":"","sources":["../../../../../../projects/right-angled/src/lib/lists/providers/list.ts"],"names":[],"mappings":"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","sourcesContent":["import { EventEmitter, Inject, Injectable, InjectionToken, Optional, SkipSelf } from '@angular/core';\r\nimport { Observable, BehaviorSubject } from 'rxjs';\r\nimport { RTFiltersService } from '../../filters/filters.service';\r\nimport { destroyAll } from '../../utilities';\r\nimport { RTStateService } from './state.service';\r\nimport { RTSortingsService } from './sortings.service';\r\nimport { OperationStatus } from '../../core/operation-status';\r\nimport { ListResponse } from '../../core/list-response';\r\nimport { AsyncSubscriber } from './async-subscriber';\r\nimport { NullObjectPager } from './null-object-pager';\r\nimport { Pager } from '../../core/pager';\r\nimport { FilterConfig } from '../../core/filter-config';\r\nimport { map } from 'rxjs/operators';\r\nexport const RTFilterTarget = new InjectionToken<any>('RTFilterTarget');\r\n\r\nexport class OperationStatusStream {\r\n  public status$: Observable<OperationStatus>;\r\n}\r\n\r\n@Injectable()\r\nexport class RTList {\r\n  /**\r\n   * Global settings of list..\r\n   *\r\n   * These settings are static and their values are copied to the properties of the same name for each instance of {@link RTList} type.\r\n   *\r\n   * So, changing of this settings will affect all instances of {@link RTList} type that will be created after such changes.\r\n   * If you want to change settings of concrete object you can use it the same name properties.\r\n   */\r\n  public static settings = {\r\n    /**\r\n     * @see {@link RTList.keepRecordsOnLoad}\r\n     */\r\n    keepRecordsOnLoad: false\r\n  };\r\n  public loadStarted: EventEmitter<void> = new EventEmitter<void>();\r\n  public loadSucceed: EventEmitter<ListResponse<any> | any[]> = new EventEmitter<ListResponse<any> | any[]>();\r\n  public loadFailed: EventEmitter<any> = new EventEmitter<any>();\r\n  private filterTargets: object[] = [];\r\n  constructor(\r\n    private asyncSubscriber: AsyncSubscriber,\r\n    @Optional() stateServices: RTStateService, // | RTStateService[],\r\n    @SkipSelf()\r\n    @Optional()\r\n    @Inject(RTFilterTarget)\r\n    filterTargets: any,\r\n    private sortingsService: RTSortingsService,\r\n    private filtersService: RTFiltersService\r\n  ) {\r\n    if (stateServices != null) {\r\n      if (Array.isArray(stateServices)) {\r\n        this.stateServices.push(...stateServices);\r\n      } else {\r\n        this.stateServices.push(stateServices);\r\n      }\r\n    }\r\n    this.pager = new NullObjectPager();\r\n    if (filterTargets != null) {\r\n      if (Array.isArray(filterTargets)) {\r\n        this.filterTargets.push(...filterTargets);\r\n      } else {\r\n        this.filterTargets.push(filterTargets);\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Specifies that list must destroy previously loaded records immediately or keep them until data request is completed.\r\n   */\r\n  public keepRecordsOnLoad: boolean = RTList.settings.keepRecordsOnLoad;\r\n  /**\r\n   * Can be used with `Observable` data sourceto specify that list must keep previously loaded records or destroy them when new value published\r\n   */\r\n  public appendStreamedData: boolean | null = null;\r\n  /**\r\n   * Method for getting data. This parameter is required and its configuration is necessary.\r\n   *\r\n   * This method get one parameter with the settings of the request implementing {@link ListRequest} contract for the simple lists and {@link PagedListRequest} one for the paged lists.\r\n   * The return value of this method should be any subscribable object which can be handled by {@link AsyncSubscriber}.\r\n   * For the simple lists the response should contain array with the records. As for the paged ones, it should implement {@link ListResponse} contract.\r\n   */\r\n  public fetchMethod: (requestParams: any) => any;\r\n  /**\r\n   * Array of elements transferred in the {@link ListResponse.items} property.\r\n   */\r\n  public get items(): any[] {\r\n    return (this.items$ as BehaviorSubject<any[]>).getValue();\r\n  }\r\n  /**\r\n   * Array of registered {@link RTStateService} instances.\r\n   */\r\n  public stateServices: RTStateService[] = new Array<RTStateService>();\r\n  /**\r\n   * Async implementation of @see RTList.status\r\n   */\r\n  public status$: Observable<OperationStatus> = new BehaviorSubject(OperationStatus.Initial);\r\n  /**\r\n   * Async implementation of @see RTList.destroyed\r\n   */\r\n  public destroyed$: Observable<boolean> = new BehaviorSubject(false);\r\n  /**\r\n   * Async implementation of @see RTList.inited\r\n   */\r\n  public inited$: Observable<boolean> = new BehaviorSubject(false);\r\n  /**\r\n   * Async implementation of @see RTList.items\r\n   */\r\n  public items$: Observable<any[]> = new BehaviorSubject([]);\r\n  /**\r\n   * Async implementation of @see RTList.busy\r\n   */\r\n  public busy$: Observable<boolean> = this.status$.pipe(map(status => status === OperationStatus.Progress));\r\n  /**\r\n   * Async implementation of @see RTList.ready\r\n   */\r\n  public ready$: Observable<boolean> = this.status$.pipe(map(status => status !== OperationStatus.Progress));\r\n\r\n  private pagerInternal: Pager;\r\n  /**\r\n   * Configured {@link Pager} service.\r\n   */\r\n  public get pager(): Pager {\r\n    return this.pagerInternal;\r\n  }\r\n  public set pager(value: Pager) {\r\n    this.filtersService.removeFilterTarget(this.pagerInternal);\r\n    this.pagerInternal = value;\r\n    this.filtersService.registerFilterTarget(this.pagerInternal);\r\n  }\r\n  /**\r\n   * True if the service was already destroyed via {@link destroy} call.\r\n   */\r\n  public get destroyed(): boolean {\r\n    return (this.destroyed$ as BehaviorSubject<boolean>).getValue();\r\n  }\r\n  /**\r\n   * True if the service was already initialized via {@link init} call.\r\n   */\r\n  public get inited(): boolean {\r\n    return (this.inited$ as BehaviorSubject<boolean>).getValue();\r\n  }\r\n  /**\r\n   * Current execution status of the list.\r\n   */\r\n  public get status(): OperationStatus {\r\n    return (this.status$ as BehaviorSubject<OperationStatus>).getValue();\r\n  }\r\n  /**\r\n   * returns `true`, if there is a data request executed at the moment (i.e. {@link state} is equal to {@link ProgressState.Progress})\r\n   */\r\n  public get busy(): boolean {\r\n    return this.status === OperationStatus.Progress;\r\n  }\r\n  /**\r\n   * returns `true`, if there is no data request executed at the moment (i.e. {@link state} is NOT equal to {@link ProgressState.Progress})\r\n   */\r\n  public get ready(): boolean {\r\n    return this.status !== OperationStatus.Progress;\r\n  }\r\n  /**\r\n   * Performs initialization logic of the service. This method must be called before first use of the service.\r\n   */\r\n  public init(): void {\r\n    if (this.inited) {\r\n      return;\r\n    }\r\n    this.filtersService.registerFilterTarget(...this.filterTargets);\r\n    this.filtersService.registerFilterTarget(this.pager, this.sortingsService);\r\n    const restoredState = {};\r\n    Object.assign(restoredState, ...this.stateServices.map((service: RTStateService) => service.getState() || {}));\r\n    this.filtersService.applyParams(restoredState);\r\n    (this.inited$ as BehaviorSubject<boolean>).next(true);\r\n  }\r\n  /**\r\n   * Performs destroy logic of the list itself and all of the inner services.\r\n   */\r\n  public destroy(): void {\r\n    this.asyncSubscriber.destroy();\r\n    this.filtersService.destroy();\r\n    this.sortingsService.destroy();\r\n    this.clearData();\r\n    (this.destroyed$ as BehaviorSubject<boolean>).next(true);\r\n  }\r\n  /**\r\n   * Registers passed object(s) as state service to manage the list state.\r\n   */\r\n  public registerStateService(...services: RTStateService[]): void {\r\n    services.forEach((service: RTStateService) => {\r\n      this.stateServices.push(service);\r\n    });\r\n  }\r\n  /**\r\n   * Removes passed object(s) from state services collection of the list.\r\n   */\r\n  public removeStateService(...services: RTStateService[]): void {\r\n    services.forEach((service: RTStateService) => {\r\n      const index = this.stateServices.findIndex((s: RTStateService) => s === service);\r\n      if (index !== -1) {\r\n        this.stateServices.splice(index, 1);\r\n      }\r\n    });\r\n  }\r\n  /**\r\n   * Registers passed object(s) as filter targets in underlying {@link FiltersService} to include their configured properties as parameters to the data request.\r\n   * @see {@link FiltersService.registerFilterTarget}\r\n   */\r\n  public registerFilterTarget(...targets: object[]): void {\r\n    this.filtersService.registerFilterTarget(...targets);\r\n  }\r\n  /**\r\n   * @see {@link FiltersService.removeFilterTarget}\r\n   */\r\n  public removeFilterTarget(...targets: object[]): void {\r\n    this.filtersService.removeFilterTarget(...targets);\r\n  }\r\n  /**\r\n   * @see {@link FiltersService.getRequestState}\r\n   */\r\n  public getRequestState(filterFn?: (config: FilterConfig, proposedValue: any, targetObject: object) => boolean): any {\r\n    return this.filtersService.getRequestState(filterFn);\r\n  }\r\n  /**\r\n   * Resets the list parameters (sortings, paging, filters) to their default values.\r\n   */\r\n  public resetSettings(): void {\r\n    this.asyncSubscriber.detach();\r\n    this.filtersService.resetValues();\r\n    this.pager.reset();\r\n    this.clearData();\r\n    (this.status$ as BehaviorSubject<OperationStatus>).next(OperationStatus.Initial);\r\n  }\r\n  /**\r\n   * Cancels the request executed at the moment.\r\n   */\r\n  public cancelRequests(): void {\r\n    if (this.busy || this.appendStreamedData !== null) {\r\n      this.asyncSubscriber.detach();\r\n      (this.status$ as BehaviorSubject<OperationStatus>).next(OperationStatus.Cancelled);\r\n      this.clearData();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Clears {@link items} array. Calls {@link destroyAll} method for {@link items} array to perform optional destroy logic of the elements.\r\n   * {@see destroyAll}\r\n   */\r\n  public clearData(): void {\r\n    destroyAll(this.items);\r\n    (this.items$ as BehaviorSubject<any[]>).next([]);\r\n  }\r\n\r\n  /**\r\n   * Performs data loading by calling specified {@link fetchMethod} delegate.\r\n   * @return result of {@link fetchMethod} execution.\r\n   */\r\n  public loadData(): Observable<any> | Promise<any> | EventEmitter<any> {\r\n    if (this.busy) {\r\n      return null;\r\n    }\r\n    this.loadStarted.emit();\r\n    const subscribable = this.beginRequest();\r\n    this.tryCleanItemsOnLoad(false);\r\n    this.asyncSubscriber.attach(subscribable, this.loadDataSuccessCallback, this.loadDataFailCallback);\r\n    this.stateServices.forEach((service: RTStateService) => {\r\n      service.persistState(this.filtersService);\r\n    });\r\n    return subscribable;\r\n  }\r\n  /**\r\n   * Resets paging parameters and performs data loading by calling {@link loadData} if list not in {@link OperationStatus.Progress} state.\r\n   * @return result of {@link fetchMethod} if it was called. `null` otherwise.\r\n   */\r\n  public reloadData(): Observable<any> | Promise<any> | EventEmitter<any> {\r\n    if (this.busy) {\r\n      return null;\r\n    }\r\n    this.loadStarted.emit();\r\n    this.pager.reset();\r\n    const subscribable = this.beginRequest();\r\n    this.tryCleanItemsOnReload(false);\r\n    this.asyncSubscriber.attach(subscribable, this.reloadDataSuccessCallback, this.reloadDataFailCallback);\r\n    this.stateServices.forEach((service: RTStateService) => {\r\n      service.persistState(this.filtersService);\r\n    });\r\n    return subscribable;\r\n  }\r\n  /**\r\n   * Callback which is executed if {@link fetchMethod} execution finished successfully.\r\n   */\r\n  public loadSuccessCallback(response: ListResponse<any> | any[]): ListResponse<any> | any[] {\r\n    const items = Array.isArray(response) ? response : response.items;\r\n    (this.items$ as BehaviorSubject<any[]>).next(this.items.concat(items));\r\n    this.pager.processResponse(response);\r\n    // In case when filter changed from last request and there's no data now\r\n    // Don't do this for flat responses since we don't know real count items\r\n    if (!Array.isArray(response) && this.pager.totalCount === 0) {\r\n      this.clearData();\r\n      this.pager.reset();\r\n    }\r\n    (this.status$ as BehaviorSubject<OperationStatus>).next(\r\n      this.pager.totalCount === 0 && this.items.length === 0 ? OperationStatus.NoData : OperationStatus.Done\r\n    );\r\n\r\n    this.loadSucceed.emit(response);\r\n    return response;\r\n  }\r\n  /**\r\n   * Callback which is executed if {@link fetchMethod} execution finished with error.\r\n   */\r\n  public loadFailCallback(): void {\r\n    this.tryCleanItemsOnLoad(true);\r\n    (this.status$ as BehaviorSubject<OperationStatus>).next(OperationStatus.Fail);\r\n    this.loadFailed.emit();\r\n  }\r\n\r\n  private loadDataSuccessCallback = (response: ListResponse<any> | any[]): ListResponse<any> | any[] => {\r\n    if (this.tryInterceptStatusResponse(response)) {\r\n      return response;\r\n    }\r\n    this.tryCleanItemsOnLoad(true);\r\n    return this.loadSuccessCallback(response);\r\n  };\r\n  private reloadDataSuccessCallback = (response: ListResponse<any> | any[]): ListResponse<any> | any[] => {\r\n    if (this.tryInterceptStatusResponse(response)) {\r\n      return response;\r\n    }\r\n    this.tryCleanItemsOnReload(true);\r\n    return this.loadSuccessCallback(response);\r\n  };\r\n  private loadDataFailCallback = (): void => {\r\n    this.tryCleanItemsOnLoad(true);\r\n    this.loadFailCallback();\r\n  };\r\n  private tryInterceptStatusResponse(response: any): boolean {\r\n    if (this.responseHasStatus(response)) {\r\n      switch (response.status) {\r\n        case OperationStatus.Fail:\r\n          this.reloadDataFailCallback();\r\n          return true;\r\n        case OperationStatus.Cancelled:\r\n          this.cancelRequests();\r\n          return true;\r\n        case OperationStatus.Progress:\r\n          return true;\r\n      }\r\n    }\r\n    return false;\r\n  }\r\n  private reloadDataFailCallback = (): void => {\r\n    this.tryCleanItemsOnReload(true);\r\n    this.loadFailCallback();\r\n  };\r\n  private tryCleanItemsOnLoad(requestCompleted: boolean): void {\r\n    if (this.keepRecordsOnLoad === requestCompleted && this.pager.appendedOnLoad === false) {\r\n      this.clearData();\r\n    }\r\n    if (requestCompleted && this.appendStreamedData === false) {\r\n      this.clearData();\r\n    }\r\n  }\r\n  private tryCleanItemsOnReload(requestCompleted: boolean): void {\r\n    if (this.keepRecordsOnLoad === requestCompleted) {\r\n      this.clearData();\r\n    }\r\n    if (requestCompleted && this.appendStreamedData === false) {\r\n      this.clearData();\r\n    }\r\n  }\r\n  private beginRequest(): any {\r\n    (this.status$ as BehaviorSubject<OperationStatus>).next(OperationStatus.Progress);\r\n    const requestState = this.filtersService.getRequestState();\r\n    return this.fetchMethod(requestState);\r\n  }\r\n  private responseHasStatus(response: ListResponse<any> | any[]): boolean {\r\n    return (response as ListResponse<any>).status !== null && typeof (response as ListResponse<any>).status !== 'undefined';\r\n  }\r\n}\r\n\r\nexport const LIST_PROVIDERS: any[] = [AsyncSubscriber, RTList, RTFiltersService, RTSortingsService, { provide: OperationStatusStream, useExisting: RTList }];\r\n"]}