@bd-innovations/abstract-section/lib/abstract-section/abstract-component/abstract-list/abstract-list.component.d.ts

A bunch of abstract logic for the section

import { OnDestroy } from '@angular/core';
import { MatDialog } from '@angular/material/dialog';
import { ActivatedRoute, Router } from '@angular/router';
import { AbstractComponent } from '../abstract.component';
import { AbstractService } from '../../providers/abstract.service';
import { ResponseTypeEnum } from '../../config/response-type.enum';
import { Observable } from 'rxjs';
import { ApiCallModel } from '../../config/api-call.model';
import { PaginationRequestModel } from '../../config/dynamic-table-models/api-request.model';
import { ComponentType } from '@angular/cdk/overlay';
import { AbstractEditComponent } from '../../abstract-dialog/abstract-edit/abstract-edit.component';
/**
 * @deprecated
 * */
export declare abstract class AbstractListComponent<T> extends AbstractComponent<T> implements OnDestroy {
    service: AbstractService<T>;
    dialog: MatDialog;
    router: Router;
    route: ActivatedRoute;
    /**
     * data: by default empty array, if Inputted from other component override ngOnInit, to disable get All request
     */
    data: T[];
    /**
     * parentUuId: if provided will call getAll API with request like GET 'model/{parentUuId}'
     * provide for child entities
     */
    parentUuId: string;
    /**
     * override for child entities used for list & details
     * @example
     * ```
     * get newElement() {
     *     return {someoneUuId: this.parentUuId}
     * }
     * ```
     */
    get newElement(): {};
    /**
     * listType: By default gets all, if need paginated override with ResponseTypeEnum.paginated/paginated_body/paginated_path
     */
    listType: ResponseTypeEnum;
    /**
     * filters - object {key: value} that will be mapped into request
     * for paginated: &key=value
     */
    filters: {
        [key: string]: any;
    };
    /**
     * TABLE SETTINGS
     * sort - true by default, if sort is available
     * apiable - true by default, if search & pages change will call API
     * search - true by default, if search is available in table
     * paginator - by default pageSize = 25, pageIndex = 0, length = null
     */
    sort: boolean;
    apiable: boolean;
    search: boolean;
    paginator: PaginationRequestModel;
    protected constructor(service: AbstractService<T>, dialog: MatDialog, router: Router, route: ActivatedRoute);
    ngOnDestroy(): void;
    returnNewComponentType(): ComponentType<AbstractEditComponent<T>>;
    /**
     * combines this.paginator, this filters & apiCallModel from arguments
     * @param obj - optional ApiCallModel
     */
    getApiCallModel(obj?: ApiCallModel | any): ApiCallModel;
    /**
     * use for dynamic table @Output(apiRequest)
     * @param apiCall: ApiCallModel
     */
    onApiRequestEmitted(apiCall: ApiCallModel | any): void;
    /**
     * calls getAllRequest() maps it with mapListResponse() and subscribes on result.
     * If request successful calls onSuccessfulDataInit(res),
     * on error calls onDataInitError(error)
     * @param apiCall: optional ApiCallModel
     */
    getData(apiCall?: ApiCallModel | any): void;
    /**
     * depending on listType calls service's getAll() or one of getAllPaginated()
     * @param apiCall: ApiCallModel better format throw getApiCallModel(apiCall) before
     */
    getAllRequest(apiCall: ApiCallModel): Observable<T[]>;
    /**
     * sets up length of received array & returns data list
     * is arrow function to survive this
     * @param pagination: Paginated Response Model
     * @param apiCall: Api call model
     */
    mapPaginatedResponse(pagination: any, apiCall: ApiCallModel): any;
    /**
     * puts API response into data;
     * then calls afterDataInit()
     * @param res - API response
     */
    onSuccessfulDataInit(res: T[]): void;
    /**
     * DETAILS
     */
    /**
     * navigates to this.route/{element[keyValue]}
     * @param t: list element
     */
    openDetails(t: T): void;
    /** NEW DIALOG */
    /**
     * calls onBeforeOpen(), opens dialog & subscribes on result. Result is send to afterNewClosed()
     * */
    openNew(): void;
    /**
     * calls from openNew()
     * setups dialog data, panelClasses & width
     * if newDialogWidth is undefined takes editDialogWidth
     * if newDialogPanelClass is undefined takes editDialogPanelClass
     */
    onBeforeNewOpen(): void;
    /**
     * if submit true calls onSuccessfulCreateNew()
     * when false onNewCreateNewCancel()
     * @param submit: true when created/false when canceled
     */
    afterNewClosed(submit: boolean): void;
    /**
     * calls getData()
     */
    onSuccessfulCreateNew(): void;
    onCreateNewCancel(): void;
    /** EDIT DIALOG */
    /**
     * calls onBeforeEditOpen()
     * opens dialog
     * subscribe on dialog afterClosed and emits value into afterEditClosed()
     * @param t: element
     */
    openEdit(t: T): void;
    /**
     * if submit true calls onSuccessfulCreateNew()
     * when false onNewCreateNewCancel()
     * @param submit: true when edited/false when canceled
     */
    afterEditClose(submit: boolean | any): void;
    /**
     * if submit true calls onSuccessfulDelete()
     * when false onDeleteCancel()
     * @param submit: true when edited/false when canceled
     * @param t: element to delete
     */
    afterDeleteClose(submit: boolean, t: T | any): void;
    /**
     * calls getData()
     * @param submit: true when edited/false when canceled
     * @param t: element to delete
     */
    onSuccessfulDelete(submit: any, t: any): void;
    /**
     * use for dynamic table @Output(actionRequest)
     * handles dynamic table events: edit, delete, open;
     * if do not need open override this way:
     * @example
     * > if ($event.type === 'open) return;
     * > super.actionHandler($event);
     * @param $event: dynamic table event: {type: string, entity: element}
     */
    actionHandler($event: {
        type: string;
        entity: T;
    }): void;
}