@mediusinc/mng-commons 0.2.0 → 0.2.1-rc

package/src/lib/descriptors/action.descriptor.ts

@@ -0,0 +1,439 @@
+import {Observable, of, throwError} from 'rxjs';
+
+import {ClassType} from '../types';
+import {EditorDescriptor, ModelDescriptor} from './';
+import {IDataProvider, IEditorDataProvider} from '../data-providers';
+import {ActionExecContext} from '../components/action/models';
+import {TypeUtil} from '../utils';
+
+export class ActionDescriptor<T> {
+    protected readonly _model: ModelDescriptor<T>;
+    protected readonly _actionName: string;
+    protected readonly _parentType?: ClassType<any>;
+    protected readonly _parentTypeName?: string;
+    protected readonly _parentProperty?: string;
+    protected readonly _i18nModelActionBaseKey: string;
+
+    protected _type: ActionTypeEnum = ActionTypeEnum.Direct;
+    protected _activationTrigger: ActionActivationTriggerEnum = ActionActivationTriggerEnum.OnClick;
+    protected _position: ActionPositionEnum = ActionPositionEnum.ToolbarRight;
+    protected _level: ActionLevelEnum = ActionLevelEnum.Default;
+
+    protected _routeUrl: string|null = null;
+
+    protected _title?: string|null;
+    protected _icon?: string;
+    protected _className: string = '';
+    protected _tooltip?: string|null;
+
+    protected _runFunction?: (ctx: ActionExecContext<T, any, IDataProvider<T, any>>) => Observable<T>;
+    protected _isVisibleFunction?: (ctx: ActionExecContext<T, any, IDataProvider<T, any>>) => Observable<boolean>;
+    protected _isEnabledFunction?: (ctx: ActionExecContext<T, any, IDataProvider<T, any>>) => Observable<boolean>;
+
+    private _hasRunConfirmation: boolean = false;
+    private _runConfirmationIcon?: string;
+    private _runConfirmationTitle?: string;
+    private _runConfirmationMessage?: string;
+    private _runConfirmationAcceptTitle?: string;
+    private _runConfirmationRejectTitle?: string;
+
+    protected _hasRunNotificationSuccess: boolean = true;
+    private _runNotificationSuccessTitle?: string;
+    private _runNotificationSuccessMessage?: string;
+
+    private _hasRunNotificationError: boolean = true;
+    private _runNotificationErrorTitle?: string;
+    private _runNotificationErrorMessage?: string;
+
+    constructor(model: ModelDescriptor<T>, actionName: string, parentType?: ClassType<any>, parentProperty?: string) {
+        this._model = model;
+        this._actionName = actionName;
+
+        if ((parentType && !parentProperty) || (!parentProperty && parentProperty)) {
+            throw new Error(`Provide both the parent type and parent property or none: ${parentType}, ${parentProperty}.`);
+        }
+        this._parentType = parentType;
+        this._parentTypeName = parentType ? TypeUtil.findTypeName(parentType) : undefined;
+        this._parentProperty = parentProperty;
+
+        this._i18nModelActionBaseKey = this._parentTypeName
+            ? `${this._parentTypeName}.actions.${this._parentProperty}_${actionName}`
+            : `${this._model.typeName}.actions.${actionName}`;
+    }
+
+    public get model() {
+        return this._model;
+    }
+
+    public get parentTypeName() {
+        return this._parentTypeName;
+    }
+
+    public get parentProperty() {
+        return this._parentProperty;
+    }
+
+    public get i18nModelActionBaseKey() {
+        return this._i18nModelActionBaseKey;
+    }
+
+    public get type() {
+        return this._type;
+    }
+
+    public get activationTrigger() {
+        return this._activationTrigger;
+    }
+
+    public get position() {
+        return this._position;
+    }
+
+    public get level() {
+        return this._level;
+    }
+
+    public get routeUrl() {
+        return this._routeUrl;
+    }
+
+    public get title() {
+        return this._title;
+    }
+
+    public get icon() {
+        return this._icon;
+    }
+
+    public get tooltip() {
+        return this._tooltip;
+    }
+
+    public get runFunction(): (ctx: ActionExecContext<T, any, IDataProvider<T, any>>) => Observable<T> {
+        if (!this._runFunction) {
+            throw new Error('Run function is not defined and cannot be invoked');
+        }
+        return this._runFunction;
+    }
+
+    public get isVisibleFunction() {
+        return this._isVisibleFunction;
+    }
+
+    public get isEnabledFunction() {
+        return this._isEnabledFunction;
+    }
+
+    public get actionName() {
+        return this._actionName;
+    }
+
+    public get className() {
+        return this._className;
+    }
+
+    get hasRunConfirmation() {
+        return this._hasRunConfirmation;
+    }
+
+    get runConfirmationIcon() {
+        return this._runConfirmationIcon;
+    }
+
+    get runConfirmationTitle() {
+        return this._runConfirmationTitle;
+    }
+
+    get runConfirmationMessage() {
+        return this._runConfirmationMessage;
+    }
+
+    get runConfirmationAcceptTitle() {
+        return this._runConfirmationAcceptTitle;
+    }
+
+    get runConfirmationRejectTitle() {
+        return this._runConfirmationRejectTitle;
+    }
+
+    get hasRunNotificationSuccess() {
+        return this._hasRunNotificationSuccess;
+    }
+
+    get runNotificationSuccessTitle() {
+        return this._runNotificationSuccessTitle;
+    }
+
+    get runNotificationSuccessMessage() {
+        return this._runNotificationSuccessMessage;
+    }
+
+    get hasRunNotificationError() {
+        return this._hasRunNotificationError;
+    }
+
+    get runNotificationErrorTitle() {
+        return this._runNotificationErrorTitle;
+    }
+
+    get runNotificationErrorMessage() {
+        return this._runNotificationErrorMessage;
+    }
+
+    public withRunFunction<S>(fn: (ctx: ActionExecContext<T, S, IDataProvider<T, S>>) => Observable<T>): this {
+        this._runFunction = fn;
+        return this;
+    }
+
+    public withIsVisibleFunction<S>(fn: (ctx: ActionExecContext<T, S, IDataProvider<T, S>>) => Observable<boolean>): this {
+        this._isVisibleFunction = fn;
+        return this;
+    }
+
+    public withIsEnabledFunction<S>(fn: (ctx: ActionExecContext<T, S, IDataProvider<T, S>>) => Observable<boolean>): this {
+        this._isEnabledFunction = fn;
+        return this;
+    }
+
+    public withRouteTrigger(routeUrl: string): this {
+        this._activationTrigger = ActionActivationTriggerEnum.OnRoute;
+        this._routeUrl = routeUrl;
+        return this;
+    }
+
+    public withLevel(level: ActionLevelEnum): this {
+        this._level = level;
+        return this;
+    }
+
+    /**
+     * Overrides default title key with model action key (${model.typeName}.actions.${actionName}). Not relevant if parentType name is provided.
+     */
+    public withModelTitle(): this {
+        this._title = `${this._i18nModelActionBaseKey}.title`;
+        return this;
+    }
+
+    /**
+     * Overrides default title key (${actionName}.title). If null, no title will be shown.
+     * @param title Title i18n key or title.
+     */
+    public withTitle(title: string|null): this {
+        this._title = title;
+        return this;
+    }
+
+    public withIcon(icon: string): this {
+        this._icon = icon;
+        return this;
+    }
+
+    public withTooltip(tooltip: string|null): this {
+        this._title = tooltip;
+        return this;
+    }
+
+    public withClassName(className: string): this {
+        this._className = className;
+        return this;
+    }
+
+    public withPosition(position: ActionPositionEnum): this {
+        this._position = position;
+        return this;
+    }
+
+    public withRunConfirmation(icon: string = 'pi pi-exclamation-triangle', title?: string, message?: string, acceptTitle?: string, rejectTitle?: string): this {
+        this._hasRunConfirmation = true;
+        this._runConfirmationIcon = icon;
+        this._runConfirmationTitle = title;
+        this._runConfirmationMessage = message;
+        this._runConfirmationAcceptTitle = acceptTitle;
+        this._runConfirmationRejectTitle = rejectTitle;
+        return this;
+    }
+
+    public withRunNotificationSuccess(title?: string, message?: string, hasNotification: boolean = true) {
+        this._hasRunNotificationSuccess = hasNotification;
+        this._runNotificationSuccessTitle = title;
+        this._runNotificationSuccessMessage = message;
+    }
+
+    public withRunNotificationError(title?: string, message?: string, hasNotification: boolean = true) {
+        this._hasRunNotificationError = hasNotification;
+        this._runNotificationErrorTitle = title;
+        this._runNotificationErrorMessage = message;
+    }
+}
+
+export class ActionEditorDescriptor<T> extends ActionDescriptor<T> {
+
+    private readonly _editorDescriptor: EditorDescriptor<T>;
+
+    protected _editorTitle?: string = undefined;
+
+    private _hasFetchNotificationSuccess: boolean = false;
+    private _fetchNotificationSuccessTitle?: string;
+    private _fetchNotificationSuccessMessage?: string;
+
+    protected _fetchFunction?: (ctx: ActionExecContext<T, any, IEditorDataProvider<T, any>>) => Observable<T>;
+    protected _submitFunction?: (ctx: ActionExecContext<T, any, IEditorDataProvider<T, any>>) => Observable<T>;
+
+    constructor(editorDescriptor: EditorDescriptor<T>, actionName: string, parentType?: ClassType<any>, parentProperty?: string) {
+        super(editorDescriptor.model, actionName, parentType, parentProperty);
+        this._type = ActionTypeEnum.Editor;
+        this._editorDescriptor = editorDescriptor;
+    }
+
+    public get editorTitle() {
+        return this._editorTitle;
+    }
+
+    public get editorDescriptor() {
+        return this._editorDescriptor;
+    }
+
+    get hasFetchNotificationSuccess() {
+        return this._hasFetchNotificationSuccess;
+    }
+
+    get fetchNotificationSuccessTitle() {
+        return this._fetchNotificationSuccessTitle;
+    }
+
+    get fetchNotificationSuccessMessage() {
+        return this._fetchNotificationSuccessMessage;
+    }
+
+    public override get runFunction(): (ctx: ActionExecContext<T, any, IDataProvider<T, any>>) => Observable<T> {
+        throw new Error('Run function cannot be used in editor action. Use submit function instead!');
+    }
+
+    public get fetchFunction(): (ctx: ActionExecContext<T, any, IEditorDataProvider<T, any>>) => Observable<T> {
+        if (!this._fetchFunction) {
+            return (ctx) => {
+                console.warn(`Fetch function is not provided for function ${this._actionName}, using default and returning context item`, ctx.data?.item);
+                return of(ctx.data?.item ? ctx.data.item : {} as T);
+            }
+        }
+        return this._fetchFunction;
+    }
+
+    public get submitFunction() {
+        return this._submitFunction;
+    }
+
+    public withEditorTitle(title: string): this {
+        this._editorTitle = title;
+        return this;
+    }
+
+    public override withRunFunction<S>(fn: (ctx: ActionExecContext<T, S, IDataProvider<T, S>>) => Observable<T>): this {
+        return this.withSubmitFunction(fn as (ctx: ActionExecContext<T, S, IEditorDataProvider<T, S>>) => Observable<T>);
+    }
+
+    public withFetchFunction<S>(fn: (ctx: ActionExecContext<T, S, IEditorDataProvider<T, S>>) => Observable<T>): this {
+        this._fetchFunction = fn;
+        return this;
+    }
+
+    public withSubmitFunction<S>(fn: (ctx: ActionExecContext<T, S, IEditorDataProvider<T, S>>) => Observable<T>): this {
+        this._submitFunction = fn;
+        return this;
+    }
+
+    public withFetchNotificationError(title?: string, message?: string, hasNotification: boolean = true) {
+        this._hasFetchNotificationSuccess = hasNotification;
+        this._fetchNotificationSuccessTitle = title;
+        this._fetchNotificationSuccessMessage = message;
+    }
+}
+
+export class ActionEditorDetailsDescriptor<T> extends ActionEditorDescriptor<T> {
+    constructor(editorDescriptor: EditorDescriptor<T>) {
+        super(editorDescriptor, 'details');
+        this.withPosition(ActionPositionEnum.RowClick);
+        this.withRouteTrigger(':itemId');
+        this.withFetchFunction(ctx => ctx.dataProvider?.fetch && ctx.data?.itemId
+            ? ctx.dataProvider.fetch(ctx.data?.itemId, ctx.serviceInstance)
+            : throwError(new Error(`Data provider fetch function or item id ${ctx.data?.itemId} is missing.`)));
+        this.withClassName('mng-details-dynamic-dialog');
+    }
+}
+
+export class ActionEditorAddDescriptor<T> extends ActionEditorDescriptor<T> {
+    constructor(editorDescriptor: EditorDescriptor<T>) {
+        super(editorDescriptor, 'add');
+        this.withPosition(ActionPositionEnum.ToolbarLeft);
+        this.withRouteTrigger('add');
+        this.withSubmitFunction(ctx => ctx.dataProvider?.create
+            ? ctx.dataProvider.create(ctx.data?.item, ctx.serviceInstance)
+            : throwError(new Error(`Data provider create function is missing.`)));
+        this.withLevel(ActionLevelEnum.Success);
+        this.withIcon('pi pi-plus');
+        this.withClassName('mng-details-dynamic-dialog');
+    }
+}
+
+export class ActionEditorEditDescriptor<T> extends ActionEditorDescriptor<T> {
+    constructor(editorDescriptor: EditorDescriptor<T>) {
+        super(editorDescriptor, 'edit');
+        this.withPosition(ActionPositionEnum.RowInline);
+        this.withTitle(null);
+        this.withRouteTrigger(':itemId/edit');
+        this.withFetchFunction(ctx => ctx.dataProvider?.fetch && ctx.data?.itemId
+            ? ctx.dataProvider.fetch(ctx.data.itemId, ctx.serviceInstance)
+            : throwError(new Error(`Data provider fetch function or item id ${ctx.data?.itemId} is missing.`)));
+        this.withSubmitFunction(ctx => ctx.dataProvider?.update && ctx.data?.itemId
+            ? ctx.dataProvider.update(ctx.data.itemId, ctx.data?.item, ctx.serviceInstance)
+            : throwError(new Error(`Data provider update function or item id ${ctx.data?.itemId} is missing.`)));
+        this.withIcon('pi pi-pencil');
+        this.withClassName('mng-details-dynamic-dialog');
+    }
+}
+
+export class ActionDeleteDescriptor<T> extends ActionDescriptor<T> {
+    constructor(model: ModelDescriptor<T>) {
+        super(model, 'delete');
+        this.withPosition(ActionPositionEnum.RowInline);
+        this.withTitle(null);
+        this.withRunFunction(ctx => {
+            const editorDataProvider = ctx.dataProvider as IEditorDataProvider<T, any>;
+            return editorDataProvider?.delete && ctx.data?.itemId
+                ? editorDataProvider.delete(ctx.data.itemId, ctx.data.item, ctx.serviceInstance)
+                : throwError(new Error(`Data provider delete function or item id ${ctx.data?.itemId} is missing.`))
+        });
+        this.withLevel(ActionLevelEnum.Danger);
+        this.withIcon('pi pi-trash');
+        this.withRunConfirmation(undefined);
+    }
+}
+
+export enum ActionPositionEnum {
+    ToolbarLeft,
+    ToolbarRight,
+    TableHeader,
+    RowInline,
+    RowClick
+}
+
+export enum ActionActivationTriggerEnum {
+    OnClick, // action is triggered for activation on click
+    OnRoute // action is triggered for activation by route url
+}
+
+export enum ActionTypeEnum {
+    Direct, // action is directly activated and executed
+    Editor // editor providing middle step for activation
+}
+
+export enum ActionLevelEnum {
+    Default,
+    Primary,
+    Secondary,
+    Info,
+    Help,
+    Success,
+    Warning,
+    Danger
+}