@mediusinc/mng-commons 0.0.1-rc.3 → 0.2.1-rc

package/src/lib/services/action.service.ts

@@ -0,0 +1,310 @@
+import {Injectable, Injector} from '@angular/core';
+import {ActivatedRoute, Router, UrlTree} from '@angular/router';
+
+import {DialogService, DynamicDialogConfig} from 'primeng/dynamicdialog';
+import {Confirmation, ConfirmationService} from 'primeng/api';
+import {TranslateService} from '@ngx-translate/core';
+import {from, Observable, of} from 'rxjs';
+import {catchError, first, map} from 'rxjs/operators';
+
+import {ActionActivationResult, ActionData, ActionError, ActionExecContext, ActionRunResult, ActionTriggerResult, IActionConfirmationService} from '../components/action/models';
+import {ActionActivationTriggerEnum, ActionDescriptor, ActionEditorDescriptor, ActionTypeEnum} from '../descriptors';
+import {MngTableCellClickEvent} from '../components/tableview/models';
+import {TableviewComponentService} from '../components/tableview/services';
+import {IDataProvider, IEditorDataProvider} from '../data-providers';
+import {IdType} from '../types';
+import {I18nUtil, ToastUtil} from '../utils';
+import {MngActionDialogComponent} from '../components/action';
+
+@Injectable()
+export class MngActionService {
+
+    constructor(
+        private injector: Injector,
+        private router: Router,
+        private dialogService: DialogService,
+        private confirmationService: ConfirmationService,
+        private translate: TranslateService
+    ) {
+    }
+
+    public getActionExecContext<T, S>(action: ActionDescriptor<T>, itemId?: IdType, item?: T, dataProvider?: IDataProvider<T, S>,
+                                      tableview?: TableviewComponentService<T, S>, sourceComponent?: any, actionData?: ActionData): ActionExecContext<T, S, IDataProvider<T, S>> {
+        return new ActionExecContext<T, S, IDataProvider<T, S>>(
+            dataProvider,
+            this.getDataProviderService(dataProvider) ?? undefined,
+            {
+                item,
+                itemId,
+                actionData
+            },
+            sourceComponent,
+            tableview
+        );
+    }
+
+    public runAction<T, S>(action: ActionDescriptor<T>, itemId?: IdType, item?: T, dataProvider?: IDataProvider<T, S>,
+                           sourceComponent?: any, tableview?: TableviewComponentService<T, S>, actionData?: ActionData): Observable<ActionRunResult<T, S, IDataProvider<T, S>>> {
+        const context = this.getActionExecContext(action, itemId, item, dataProvider, tableview, sourceComponent, actionData);
+        if (action.hasRunConfirmation) {
+            if (typeof sourceComponent?.getConfirmationService !== 'function' || typeof sourceComponent?.getConfirmationServiceInstanceKey !== 'function') {
+                throw Error(`Source component ${sourceComponent} should be implementing IConfirmationService interface to be able to provide confirmation functionality.`);
+            }
+
+            const srcConfirmComponent = sourceComponent as IActionConfirmationService;
+            const confirmParams: Confirmation = {
+                key: srcConfirmComponent.getConfirmationServiceInstanceKey(action),
+                acceptVisible: false,
+                rejectVisible: false
+            };
+
+            if (action.runConfirmationTitle !== null) {
+                confirmParams.header = I18nUtil.instantActionTranslation(this.translate, action, 'confirm.title', action.runConfirmationTitle, item, 'general.confirmation') ?? undefined;
+            }
+            if (action.runConfirmationMessage !== null) {
+                confirmParams.message = I18nUtil.instantActionTranslation(this.translate, action, 'confirm.message', action.runConfirmationMessage, item, 'general.confirmation') ?? undefined;
+            }
+            if (action.runConfirmationIcon !== null) {
+                confirmParams.icon = action.runConfirmationIcon === undefined ? 'pi pi-exclamation-triangle' : action.runConfirmationIcon;
+            }
+            if (action.runConfirmationAcceptTitle !== null) {
+                confirmParams.acceptLabel = I18nUtil.instantActionTranslation(this.translate, action, 'confirm.accept', action.runConfirmationAcceptTitle, item, 'general.yes') ?? undefined;
+                confirmParams.acceptVisible = true;
+            }
+            if (action.runConfirmationRejectTitle !== null) {
+                confirmParams.rejectLabel = I18nUtil.instantActionTranslation(this.translate, action, 'confirm.reject', action.runConfirmationRejectTitle, item, 'general.no') ?? undefined;
+                confirmParams.rejectVisible = true;
+            }
+
+            const observable = new Observable<ActionRunResult<T, S, IDataProvider<T, S>>>(observer => {
+                confirmParams.accept = () => {
+                    action.runFunction(context).pipe(
+                        first(),
+                        map(res => new ActionRunResult(context, res)),
+                        map(value => {
+                            if (action.hasRunNotificationSuccess) {
+                                ToastUtil.actionNotificationSuccess(this.translate, action, 'run', action.runNotificationSuccessTitle, action.runNotificationSuccessMessage, tableview, item);
+                            }
+                            return value;
+                        }),
+                        catchError(err => {
+                            if (action.hasRunNotificationError) {
+                                ToastUtil.actionNotificationError(this.translate, action, err, 'run', tableview, item);
+                            }
+                            throw err;
+                        })
+                    ).subscribe(res => {
+                        observer.next(res);
+                    });
+                }
+
+                confirmParams.reject = () => {
+                    observer.error(new ActionRunResult(context, undefined, new ActionError(null, true)));
+                }
+
+                srcConfirmComponent.getConfirmationService().confirm(confirmParams);
+            });
+            return observable;
+        } else {
+            return action.runFunction(context).pipe(
+                map(res => new ActionRunResult(context, res)),
+                map(value => {
+                    if (action.hasRunNotificationSuccess) {
+                        ToastUtil.actionNotificationSuccess(this.translate, action, 'run', action.runNotificationSuccessTitle, action.runNotificationSuccessMessage, tableview, item);
+                    }
+                    return value;
+                }),
+                catchError(err => {
+                    if (action.hasRunNotificationError) {
+                        ToastUtil.actionNotificationError(this.translate, action, err, 'run', tableview, item);
+                    }
+                    throw err;
+                })
+            );
+        }
+    }
+
+    /**
+     * Runs editor action save function usually triggered on form submit.
+     *
+     * @param action Action descriptor.
+     * @param itemId Item id (if exists).
+     * @param formItem Item instance (from form).
+     * @param dataProvider Data provider
+     * @param sourceComponent Source component from where the fetch function was called.
+     * @param tableview Tableview component.
+     * @param actionData Additional action data.
+     */
+    public runEditorSave<T, S>(action: ActionEditorDescriptor<T>, itemId?: IdType, formItem?: T, dataProvider?: IEditorDataProvider<T, S>,
+                               sourceComponent?: any, tableview?: TableviewComponentService<T, S>, actionData?: ActionData): Observable<ActionRunResult<T, S, IEditorDataProvider<T, S>>> {
+        const context = this.prepareRunContextForEditor(formItem, itemId, dataProvider, sourceComponent, tableview, actionData);
+        if (typeof action.submitFunction !== 'function') {
+            throw new Error(`Submit function for action ${action.actionName} cannot be invoked.`);
+        }
+        return action.submitFunction(context).pipe(
+            map(res => new ActionRunResult(context, res)),
+            map(value => {
+                if (action.hasRunNotificationSuccess) {
+                    ToastUtil.actionNotificationSuccess(this.translate, action, 'submit', action.runNotificationSuccessTitle, action.runNotificationSuccessMessage, tableview, formItem);
+                }
+                return value;
+            }),
+            catchError(err => {
+                if (action.hasRunNotificationError) {
+                    ToastUtil.actionNotificationError(this.translate, action, err, 'submit', tableview, formItem);
+                }
+                throw err;
+            })
+        );
+    }
+
+    /**
+     * Runs editor action fetch function.
+     *
+     * @param action Action descriptor.
+     * @param itemId Item id.
+     * @param dataProvider Data provider
+     * @param sourceComponent Source component from where the fetch function was called.
+     * @param tableview Tableview component.
+     * @param actionData Additional action data.
+     */
+    public runEditorFetch<T, S>(action: ActionEditorDescriptor<T>, itemId?: IdType, dataProvider?: IEditorDataProvider<T, S>,
+                                sourceComponent?: any, tableview?: TableviewComponentService<T, S>, actionData?: ActionData): Observable<ActionRunResult<T, S, IEditorDataProvider<T, S>>> {
+        const context = this.prepareRunContextForEditor(undefined, itemId, dataProvider, sourceComponent, tableview, actionData);
+        return action.fetchFunction(context).pipe(map(res => new ActionRunResult(context, res)));
+        // TODO: error handling
+    }
+
+    /**
+     * Prepares action run context for action of type editor.
+     *
+     * @param item Item instance (if exists).
+     * @param itemId Item id (if exists).
+     * @param dataProvider Data provider.
+     * @param sourceComponent Source component from where the context preparation was called.
+     * @param tableview Tableview component.
+     * @param actionData Additional action data.
+     */
+    private prepareRunContextForEditor<T, S>(item?: T, itemId?: IdType, dataProvider?: IEditorDataProvider<T, S>,
+                                             sourceComponent?: any, tableview?: TableviewComponentService<T, S>, actionData?: ActionData): ActionExecContext<T, S, IEditorDataProvider<T, S>> {
+        const context = new ActionExecContext<T, S, IEditorDataProvider<T, S>>(
+            dataProvider,
+            this.getDataProviderService(dataProvider) ?? undefined,
+            {
+                item,
+                itemId,
+                actionData
+            },
+            sourceComponent,
+            tableview
+        );
+        return context;
+    }
+
+    /**
+     * Gets service instance of data provider.
+     *
+     * @param dataProvider Data provider instance.
+     */
+    private getDataProviderService<T, S>(dataProvider?: IDataProvider<T, S>): S|null {
+        if (dataProvider?.serviceType) {
+            return this.injector.get<S>(dataProvider.serviceType);
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * Activates action.
+     *
+     * @param action Action descriptor.
+     * @param item Item instance (if exists).
+     * @param itemId Item id (if exists).
+     * @param actionData Optional additional action data.
+     * @param tableview Tableview component.
+     * @param sourceComponent Source activation component.
+     */
+    public activateAction<T, S>(action: ActionDescriptor<T>, itemId?: IdType, item?: T, actionData?: ActionData, tableview?: TableviewComponentService<T, S>, sourceComponent?: any): Observable<ActionActivationResult<T, S, IDataProvider<T, S>>> {
+        if (action.type === ActionTypeEnum.Editor) {
+            const dialogConfig: DynamicDialogConfig = {
+                data: {
+                    action
+                },
+                styleClass: action.className
+            };
+            if (itemId) {
+                dialogConfig.data.itemId = itemId;
+            }
+            if (item) {
+                dialogConfig.data.item = item;
+            }
+            if (actionData) {
+                dialogConfig.data.actionData = actionData;
+            }
+            if (tableview) {
+                dialogConfig.data.tableview = tableview;
+            }
+            if (sourceComponent) {
+                dialogConfig.data.sourceComponent = sourceComponent;
+            }
+            const dialogRef = this.dialogService.open(MngActionDialogComponent, dialogConfig);
+            return of(new ActionActivationResult<T, S, IDataProvider<T, S>>(undefined, dialogRef));
+        } else {
+            // directly execute action
+            return this.runAction<T, S>(action, itemId, item, tableview?.dataProvider ?? undefined, sourceComponent, tableview, actionData)
+                .pipe(map(res => new ActionActivationResult<T, S, IDataProvider<T, S>>(res)));
+        }
+    }
+
+    /**
+     * Triggers action from table row click position.
+     *
+     * @param action Action descriptor.
+     * @param event Target table click event.
+     * @param route Currently activate route.
+     */
+    public triggerRowClickAction<T>(action: ActionDescriptor<T>, event: MngTableCellClickEvent<T>, route: ActivatedRoute) {
+        if (!action.model.idPropertyName) {
+            throw new Error(`Row click action ${action.actionName} can not be triggered, because model id property name is not defined.`);
+        }
+        const rowItem = event?.rowItem as any;
+        return this.triggerAction(action, rowItem[action.model.idPropertyName], event.rowItem, undefined, route);
+    }
+
+    /**
+     * Triggers action with optional data (item, itemId, ...) and currently activated route.
+     *
+     * @param action Action.
+     * @param actionData Optional action data.
+     * @param route Optional activated route.
+     */
+    public triggerAction<T, S>(action: ActionDescriptor<T>, itemId?: IdType, item?: T, actionData?: ActionData, route?: ActivatedRoute,
+                               tableview?: TableviewComponentService<T, S>, sourceComponent?: any): Observable<ActionTriggerResult<T, S, IDataProvider<T, S>>> {
+        if (action.activationTrigger === ActionActivationTriggerEnum.OnRoute) {
+            const baseUrl = this.router.url.split('?')[0];
+            const parsedUrl: UrlTree = this.router.parseUrl(this.router.url);
+            let actionUrl = action.routeUrl ?? '';
+            // TODO: dont strip '/', but use it accordingly with Angular's router patterns (/, ./, ../)
+            if (actionUrl.startsWith('/')) {
+                actionUrl = actionUrl.substring(1);
+            }
+            const itemAny = (item ?? {}) as any;
+            const actionUrlSegments = actionUrl.split('/')
+                .map(s => {
+                    if (s === ':itemId') {
+                        return itemId;
+                    } else if (s.startsWith(`:${action.model.typeName}.`)) {
+                        return itemAny[s.substring(action.model.typeName.length + 2)] ?? '';
+                    } else if (s.startsWith(':')) {
+                        return actionData?.[s.substring(1)] ?? '';
+                    } else {
+                        return s;
+                    }
+                });
+            return of(new ActionTriggerResult<T, S, IDataProvider<T, S>>(undefined, from(this.router.navigate([baseUrl, ...actionUrlSegments], {relativeTo: route, queryParams: parsedUrl.queryParams}))));
+        } else {
+            return this.activateAction(action, itemId, item, actionData, tableview, sourceComponent)
+                .pipe(map(res => new ActionTriggerResult<T, S, IDataProvider<T, S>>(res)));
+        }
+    }
+}