barsa-novin-ray-core 0.0.2

package/esm2020/lib/dynamic-component/base-form-toolbaritem-props.mjs

@@ -0,0 +1,50 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output } from '@angular/core';
+import { BaseComponent } from '../base.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../pipes";
+export class BaseFormToolbaritemPropsComponent extends BaseComponent {
+    constructor(_reportValuePipe, _cdr) {
+        super();
+        this._reportValuePipe = _reportValuePipe;
+        this._cdr = _cdr;
+        this.ulvClick = new EventEmitter();
+        this.commandClick = new EventEmitter();
+    }
+}
+BaseFormToolbaritemPropsComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: BaseFormToolbaritemPropsComponent, deps: [{ token: i1.MoReportValuePipe }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+BaseFormToolbaritemPropsComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.7", type: BaseFormToolbaritemPropsComponent, selector: "bnrc-form-toolbaritem-props", inputs: { deviceName: "deviceName", btn: "btn", context: "context", isEnable: "isEnable", inlineEditMode: "inlineEditMode", parameters: "parameters", mo: "mo", allColumns: "allColumns", index: "index", showText: "showText", conditionalFormats: "conditionalFormats" }, outputs: { ulvClick: "ulvClick", commandClick: "commandClick" }, usesInheritance: true, ngImport: i0, template: ``, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: BaseFormToolbaritemPropsComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bnrc-form-toolbaritem-props',
+                    template: ``,
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MoReportValuePipe }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { deviceName: [{
+                type: Input
+            }], btn: [{
+                type: Input
+            }], context: [{
+                type: Input
+            }], isEnable: [{
+                type: Input
+            }], inlineEditMode: [{
+                type: Input
+            }], parameters: [{
+                type: Input
+            }], ulvClick: [{
+                type: Output
+            }], mo: [{
+                type: Input
+            }], allColumns: [{
+                type: Input
+            }], index: [{
+                type: Input
+            }], showText: [{
+                type: Input
+            }], conditionalFormats: [{
+                type: Input
+            }], commandClick: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/dynamic-component/base-item-content-props.mjs

@@ -0,0 +1,70 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output } from '@angular/core';
+import { BaseComponent } from '../base.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../pipes";
+export class BaseItemContentPropsComponent extends BaseComponent {
+    constructor(_rval, _findColumnPipe, _cdr) {
+        super();
+        this._rval = _rval;
+        this._findColumnPipe = _findColumnPipe;
+        this._cdr = _cdr;
+        this.events = new EventEmitter();
+    }
+}
+BaseItemContentPropsComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: BaseItemContentPropsComponent, deps: [{ token: i1.MoReportValuePipe }, { token: i1.FindColumnByDbNamePipe }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+BaseItemContentPropsComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.7", type: BaseItemContentPropsComponent, selector: "bnrc-base-item-content-props", inputs: { mo: "mo", allColumns: "allColumns", column: "column", index: "index", deviceName: "deviceName", deviceSize: "deviceSize", rtl: "rtl", editMode: "editMode", setting: "setting", parameters: "parameters", contextMenuItems: "contextMenuItems", canView: "canView", conditionalFormats: "conditionalFormats", disableOverflowContextMenu: "disableOverflowContextMenu", navigationArrow: "navigationArrow", isCheckList: "isCheckList", fields: "fields", isChecked: "isChecked", layout94$: "layout94$", inlineEditMode: "inlineEditMode", allowInlineEdit: "allowInlineEdit", isNewInlineMo: "isNewInlineMo" }, outputs: { events: "events" }, usesInheritance: true, ngImport: i0, template: ``, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: BaseItemContentPropsComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bnrc-base-item-content-props',
+                    template: ``,
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MoReportValuePipe }, { type: i1.FindColumnByDbNamePipe }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { events: [{
+                type: Output
+            }], mo: [{
+                type: Input
+            }], allColumns: [{
+                type: Input
+            }], column: [{
+                type: Input
+            }], index: [{
+                type: Input
+            }], deviceName: [{
+                type: Input
+            }], deviceSize: [{
+                type: Input
+            }], rtl: [{
+                type: Input
+            }], editMode: [{
+                type: Input
+            }], setting: [{
+                type: Input
+            }], parameters: [{
+                type: Input
+            }], contextMenuItems: [{
+                type: Input
+            }], canView: [{
+                type: Input
+            }], conditionalFormats: [{
+                type: Input
+            }], disableOverflowContextMenu: [{
+                type: Input
+            }], navigationArrow: [{
+                type: Input
+            }], isCheckList: [{
+                type: Input
+            }], fields: [{
+                type: Input
+            }], isChecked: [{
+                type: Input
+            }], layout94$: [{
+                type: Input
+            }], inlineEditMode: [{
+                type: Input
+            }], allowInlineEdit: [{
+                type: Input
+            }], isNewInlineMo: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/dynamic-component/base-view-content-props.mjs

@@ -0,0 +1,26 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output } from '@angular/core';
+import { BaseViewPropsComponent } from './base-view-props';
+import * as i0 from "@angular/core";
+export class BaseViewContentPropsComponent extends BaseViewPropsComponent {
+    constructor() {
+        super(...arguments);
+        this.expandClick = new EventEmitter();
+    }
+}
+BaseViewContentPropsComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: BaseViewContentPropsComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
+BaseViewContentPropsComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.7", type: BaseViewContentPropsComponent, selector: "bnrc-base-view-content-props", inputs: { moDataList: "moDataList", setting: "setting" }, outputs: { expandClick: "expandClick" }, usesInheritance: true, ngImport: i0, template: ``, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: BaseViewContentPropsComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bnrc-base-view-content-props',
+                    template: ``,
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }], propDecorators: { moDataList: [{
+                type: Input
+            }], expandClick: [{
+                type: Output
+            }], setting: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS12aWV3LWNvbnRlbnQtcHJvcHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9iYXJzYS1ub3Zpbi1yYXktY29yZS9zcmMvbGliL2R5bmFtaWMtY29tcG9uZW50L2Jhc2Utdmlldy1jb250ZW50LXByb3BzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxTQUFTLEVBQUUsWUFBWSxFQUFFLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFaEcsT0FBTyxFQUFFLHNCQUFzQixFQUFFLE1BQU0sbUJBQW1CLENBQUM7O0FBTzNELE1BQU0sT0FBTyw2QkFBaUUsU0FBUSxzQkFBc0I7SUFMNUc7O1FBT2MsZ0JBQVcsR0FBRyxJQUFJLFlBQVksRUFBdUIsQ0FBQztLQUVuRTs7MEhBSlksNkJBQTZCOzhHQUE3Qiw2QkFBNkIsOExBSDVCLEVBQUU7MkZBR0gsNkJBQTZCO2tCQUx6QyxTQUFTO21CQUFDO29CQUNQLFFBQVEsRUFBRSw4QkFBOEI7b0JBQ3hDLFFBQVEsRUFBRSxFQUFFO29CQUNaLGVBQWUsRUFBRSx1QkFBdUIsQ0FBQyxNQUFNO2lCQUNsRDs4QkFFWSxVQUFVO3NCQUFsQixLQUFLO2dCQUNJLFdBQVc7c0JBQXBCLE1BQU07Z0JBQ0UsT0FBTztzQkFBZixLQUFLIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3ksIENvbXBvbmVudCwgRXZlbnRFbWl0dGVyLCBJbnB1dCwgT3V0cHV0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBNZXRhb2JqZWN0RGF0YU1vZGVsLCBVaVJlcG9ydFZpZXdCYXNlU2V0dGluZyB9IGZyb20gJy4uL2Fic3RyYWN0LWNsYXNzZXMnO1xuaW1wb3J0IHsgQmFzZVZpZXdQcm9wc0NvbXBvbmVudCB9IGZyb20gJy4vYmFzZS12aWV3LXByb3BzJztcblxuQENvbXBvbmVudCh7XG4gICAgc2VsZWN0b3I6ICdibnJjLWJhc2Utdmlldy1jb250ZW50LXByb3BzJyxcbiAgICB0ZW1wbGF0ZTogYGAsXG4gICAgY2hhbmdlRGV0ZWN0aW9uOiBDaGFuZ2VEZXRlY3Rpb25TdHJhdGVneS5PblB1c2hcbn0pXG5leHBvcnQgY2xhc3MgQmFzZVZpZXdDb250ZW50UHJvcHNDb21wb25lbnQ8VCBleHRlbmRzIFVpUmVwb3J0Vmlld0Jhc2VTZXR0aW5nPiBleHRlbmRzIEJhc2VWaWV3UHJvcHNDb21wb25lbnQge1xuICAgIEBJbnB1dCgpIG1vRGF0YUxpc3Q6IE1ldGFvYmplY3REYXRhTW9kZWxbXTtcbiAgICBAT3V0cHV0KCkgZXhwYW5kQ2xpY2sgPSBuZXcgRXZlbnRFbWl0dGVyPE1ldGFvYmplY3REYXRhTW9kZWw+KCk7XG4gICAgQElucHV0KCkgc2V0dGluZzogVDtcbn1cbiJdfQ==

package/esm2020/lib/dynamic-component/base-view-item-props.mjs

@@ -0,0 +1,374 @@
+import { ChangeDetectionStrategy, Component, Input, Optional, Self, SkipSelf } from '@angular/core';
+import { catchError, debounceTime, from, tap, Subject, switchMap, takeUntil, throwError } from 'rxjs';
+import { createGridEditorFormPanel } from '../constants';
+import { BaseViewPropsComponent } from './base-view-props';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/platform-browser";
+import * as i2 from "../services";
+export class BaseViewItemPropsComponent extends BaseViewPropsComponent {
+    constructor(_el, _domSanitizer, _cdr, _parentFormPanelService, _formPanelService, _ulvMainService) {
+        super();
+        this._el = _el;
+        this._domSanitizer = _domSanitizer;
+        this._cdr = _cdr;
+        this._parentFormPanelService = _parentFormPanelService;
+        this._formPanelService = _formPanelService;
+        this._ulvMainService = _ulvMainService;
+        this.hasError = false;
+        this.inlineEditInReport = true;
+        this.inRow = true;
+        this.hasCartableTemplate = false;
+        this.bruleActionMessage = null;
+        this._saveEditedMo$ = new Subject();
+        this._formpanelValueChanged$ = new Subject();
+        this._saveEditedMo$
+            .asObservable()
+            .pipe(takeUntil(this._onDestroy$), switchMap((reason) => this._inlineEditSaveFormPanel(reason)), catchError((err) => throwError(() => err)))
+            .subscribe((res) => {
+            if (res.saved) {
+                this._formpanelValueChanged$.next();
+                this._cdr.markForCheck();
+            }
+            if (res.reason === 'TAB' || res.reason === 'CTRL+ENTER') {
+                this.selectNextInlineRecord.emit(this.mo);
+            }
+        });
+        this._formpanelValueChanged$
+            .asObservable()
+            .pipe(takeUntil(this._onDestroy$), debounceTime(100), switchMap(() => this._syncMo()), tap(() => {
+            if (typeof this.mo.$InlineMoChanged === 'undefined') {
+                this.mo.$InlineMoChanged = true;
+            }
+        }))
+            .subscribe(() => {
+            this.editFormPanelValueChange.emit(this.mo);
+        });
+    }
+    set cartableTemplate(val) {
+        this._cartableTemplate = val;
+        this._createCartableParams();
+    }
+    set cartableMo(val) {
+        this._cartableMo = val;
+        this._createCartableParams();
+    }
+    set cartableWorkflowData(val) {
+        this._cartableWorkflowData = val;
+        this._createCartableParams();
+    }
+    get _hasFormPanelService() {
+        return this._formPanelService !== null && this.formSetting;
+    }
+    get _focusableControls() {
+        return this._el.nativeElement.querySelectorAll(`button,button:not([disabled]),[href],input:not([disabled]),input,
+            select,select:not([disabled]),textarea,textarea:not([disabled]),[tabindex]:not([tabindex="-1"])`);
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        if (this._hasFormPanelService) {
+            this._formPanelService.context$.pipe(takeUntil(this._onDestroy$)).subscribe();
+            this._formPanelService.view$.pipe(takeUntil(this._onDestroy$)).subscribe();
+            this.layout$ = this._formPanelService.layout$;
+        }
+    }
+    ngOnChanges(changes) {
+        super.ngOnChanges(changes);
+        const { isChecked } = changes;
+        if (this.inlineEditMode) {
+            if (isChecked) {
+                if (!isChecked.currentValue && isChecked.previousValue) {
+                    if (this._needToSave()) {
+                        this._saveEditedMo$.next('CHECK_CHANGED');
+                    }
+                }
+                else if (isChecked.currentValue) {
+                    this._loadAndCreateFormPanelCtrlr();
+                }
+            }
+        }
+        // if (mo && !mo.firstChange && this._hasFormPanelService && this.isChecked && this.inlineEditMode) {
+        //     //this.formPanelCtrlr.SetValue(changes.mo.currentValue);
+        // }
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        if (this.formPanelCtrlr) {
+            this.formPanelCtrlr.un('bruleShowMessageAction', this._handleBruleShowMessageAction);
+        }
+    }
+    OnCartableFormClick(e) {
+        if (this.isChecked) {
+            e.preventDefault();
+            e.stopPropagation();
+        }
+    }
+    onTabKeyDown() {
+        setTimeout(() => {
+            this._checkfocusOutFromRow(document.activeElement);
+        }, 0);
+    }
+    onRowCheck() {
+        this._rowCheck();
+    }
+    onRowClick() {
+        this.rowClick.emit({ mo: this.mo, index: this.index });
+    }
+    onEditFormPanelSave() {
+        this._saveEditedMo$.next('CTRL+ENTER');
+    }
+    onEditFormPanelCancel() {
+        this.editFormPanelCancel.emit(this.formPanelCtrlr.Mo);
+    }
+    onUlvCommand() {
+        this.ulvCommand.emit({ mo: this.mo, index: this.index });
+    }
+    onAction(commandBody) {
+        this.action.emit(commandBody);
+    }
+    onExpandClick() {
+        this.expandClick.emit(this.mo);
+    }
+    onDynamicComponentEvents(e) {
+        switch (e.title) {
+            case 'rowCheck':
+                this.onRowCheck();
+                break;
+            case 'rowClick':
+                this.onRowClick();
+                break;
+            case 'ulvCommand':
+                this.onUlvCommand();
+                break;
+        }
+    }
+    _trackByColumn(index, column) {
+        return `${column.Name}${index}`;
+    }
+    _createCartableParams() {
+        const cartableTemplate = this._cartableTemplate;
+        const cartableMo = this._cartableMo;
+        const cartableWorkflowData = this._cartableWorkflowData;
+        if (this.hasCartableTemplate) {
+            // TODO update cartable mo;
+            return;
+        }
+        if (cartableTemplate && cartableMo && typeof cartableWorkflowData !== 'undefined') {
+            const view = cartableTemplate.View;
+            cartableTemplate.Data = { Mo: { ...cartableMo } };
+            cartableTemplate.Workflow = cartableWorkflowData === '' ? null : JSON.parse(cartableWorkflowData);
+            if (!view.ExtraJsonProp) {
+                view.ExtraJsonProp = {};
+            }
+            view.ExtraJsonProp.IsSimple = true;
+            this.cartableParams = {
+                formSetting: cartableTemplate,
+                moId: cartableMo.Id,
+                typeDefId: cartableMo.$TypeDefId,
+                viewId: view.TypeViewId,
+                inDialog: false
+            };
+            this.hasCartableTemplate = true;
+            this._cdr.markForCheck();
+        }
+    }
+    _needToSave() {
+        // if (!this.isChecked) {
+        //     return false;
+        // }
+        // const isChildNode = (this._el.nativeElement as HTMLElement).contains(e.target);
+        // if (isChildNode) {
+        //     return false;
+        // }
+        const t = this.inlineEditMode && this._hasFormPanelService;
+        if (!t) {
+            return false;
+        }
+        return this.formPanelCtrlr && this.formPanelCtrlr.IsMoChanged();
+    }
+    _focustToFirstControl() {
+        const focusable = this._focusableControls;
+        const lastFocusable = focusable[0];
+        lastFocusable?.focus();
+    }
+    _checkfocusOutFromRow(target) {
+        const focusable = this._focusableControls;
+        let foundInFocusable = false;
+        focusable.forEach((c) => {
+            if (c === target) {
+                foundInFocusable = true;
+            }
+        });
+        if (!foundInFocusable) {
+            this._saveEditedMo$.next('TAB');
+        }
+    }
+    _rowCheck() {
+        // if (this.isChecked) {
+        //     return;
+        // }
+        this.rowCheck.emit({ mo: this.mo, index: this.index });
+    }
+    _handleValueChange() {
+        if (!this.isChecked) {
+            this.onRowCheck();
+        }
+        this._formpanelValueChanged$.next();
+    }
+    _syncMo() {
+        const syncWithFormpanelMo = this.mo;
+        const _isChecked = this.mo.$IsChecked;
+        const formPanelCtrlrMo = this.formPanelCtrlr.Mo;
+        Object.keys(formPanelCtrlrMo.$OriginalValues).forEach((c) => {
+            syncWithFormpanelMo[c] = formPanelCtrlrMo[c];
+            if (formPanelCtrlrMo[c + '$Caption']) {
+                syncWithFormpanelMo[c + '$Caption'] = formPanelCtrlrMo[c + '$Caption'];
+            }
+            if (formPanelCtrlrMo[c + '$Icon']) {
+                syncWithFormpanelMo[c + '$Icon'] = formPanelCtrlrMo[c + '$Icon'];
+            }
+        });
+        syncWithFormpanelMo['$State'] = formPanelCtrlrMo['$State']; // this add because if we edit unchanged mo it does not reflect to mo of ulv.
+        this.mo = { ...syncWithFormpanelMo };
+        this.mo.$IsChecked = _isChecked;
+        return from(Promise.resolve());
+    }
+    _raiseFormPanelValueChanged() {
+        this.editFormPanelValueChange.emit(this.mo);
+    }
+    _handleBruleShowMessageAction(action) {
+        action.MessageExpressionHtml = this._domSanitizer.bypassSecurityTrustHtml(action.MessageExpression);
+        this.bruleActionMessage = action;
+        // if (action.MessageType === BarsaApi.Common.Enums.ShowMessageRuleAction_Type.Information) {
+        //     if (action.EscapeCharacters) Ul.MsgBox.Info(action.MessageExpression, doReturn);
+        //     else Ul.MsgBox.Info_ShowHtml(action.MessageExpression, doReturn);
+        // } else if (action.MessageType === BarsaApi.Common.Enums.ShowMessageRuleAction_Type.Error) {
+        //     var doReturn0 = function () {
+        //         this._formPanel.RefocusCurrentField();
+        //         doReturn(new Common.SilentException());
+        //     };
+        //     if (action.EscapeCharacters) Ul.MsgBox.Error(action.MessageExpression, doReturn0.bind(this));
+        //     else Ul.MsgBox.Error_ShowHtml(action.MessageExpression, doReturn0.bind(this));
+        // } else if (action.MessageType === BarsaApi.Common.Enums.ShowMessageRuleAction_Type.OkCancel) {
+        //     Ul.MsgBox.ConfirmYesNo_Safe(true, action.MessageExpression, BBB.Select, action.EscapeCharacters, doReturn);
+        // }
+    }
+    _createFormPanelCtrlr(mo, typeDefId) {
+        if (!this.formPanelCtrlr) {
+            this.formPanelCtrlr = createGridEditorFormPanel(this.formSetting, { ...mo }, typeDefId, this.extraRelation, this.inRow
+            // BarsaApi.Common.Util.TryGetValue(this.context.Setting, 'Extra.Relation')
+            );
+        }
+        this.formPanelCtrlr.InlineEditInReport = true;
+        this.formPanelCtrlr.on({
+            bruleShowMessageAction: this._handleBruleShowMessageAction.bind(this),
+            valueChange: this._handleValueChange.bind(this)
+        });
+        return this.formPanelCtrlr;
+    }
+    _loadAndCreateFormPanelCtrlr() {
+        const formSettingData = this.formSetting.Data;
+        const formMo = {
+            ...this.mo,
+            $FieldDict: formSettingData.Mo.$FieldDict,
+            $TypeDefId: formSettingData.Mo.$TypeDefId,
+            $OriginalValues: {}
+        };
+        if (this._formPanelLoaded) {
+            this.formPanelCtrlr.SetValue(formMo);
+            return;
+        }
+        this._createFormPanelCtrlr(formMo, this.typeDefId);
+        this._formPanelLoaded = true;
+        const formPanelCtrlr = this.formPanelCtrlr;
+        this.formPanelCtrlr.UlvMoDataListCount = this.moDataListCount - 1;
+        formPanelCtrlr.LoadAndCreate(null, false, false, () => {
+            const customFormPanelUi = formPanelCtrlr.Adapter.Control;
+            const parentMo = this._parentFormPanelService ? this._parentFormPanelService.mo : null;
+            if (this.extraRelation && parentMo && this.extraRelation.RelationType === 'Composition') {
+                formPanelCtrlr.Mo.SetFValue(this.extraRelation.ParentFdName, parentMo);
+                // newFormSettings.Data.Mo[relation.ParentFdName] = parentMo.GetChangedObject();
+                // newFormSettings.Data.Mo[relation.ParentFdName].$State = parentMo.$State;
+            }
+            customFormPanelUi.Refresh = () => { };
+            this._formPanelService.context = formPanelCtrlr.Adapter.Control;
+            setTimeout(() => {
+                this._focustToFirstControl();
+            }, 0);
+        });
+    }
+    _resetSavingStates() {
+        this.hasError = false;
+        this.bruleActionMessage = null;
+        this.saved = false;
+        this._cdr.markForCheck();
+    }
+    _setSavingState(err) {
+        if (err) {
+            this.hasError = true;
+            return;
+        }
+        this.hasError = false;
+        this.saved = true;
+    }
+    _inlineEditSaveFormPanel(reason) {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        return new Promise((resolve, _) => {
+            if (!this.formPanelCtrlr.IsMoChanged()) {
+                // if state of mo is new or modidfied then it needs to update
+                resolve({ reason, succeed: true, saved: false });
+            }
+            const formPanelCtrlrMo = this.formPanelCtrlr.Mo;
+            delete formPanelCtrlrMo.json;
+            // this.saving = true;
+            this.mo.$InlineMoChanged = false;
+            this.editFormPanelSave.emit(this.mo);
+            this.formPanelCtrlr.Save(false, (err) => {
+                // this.saving = false;
+                this.formPanelCtrlr.SetIsChanged(false);
+                this._setSavingState(err);
+                resolve({ reason, succeed: true, saved: true });
+            });
+        });
+    }
+}
+BaseViewItemPropsComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: BaseViewItemPropsComponent, deps: [{ token: i0.ElementRef }, { token: i1.DomSanitizer }, { token: i0.ChangeDetectorRef }, { token: i2.FormPanelService, optional: true, skipSelf: true }, { token: i2.FormPanelService, optional: true, self: true }, { token: i2.UlvMainService, optional: true }], target: i0.ɵɵFactoryTarget.Component });
+BaseViewItemPropsComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.7", type: BaseViewItemPropsComponent, selector: "bnrc-base-view-item-props", inputs: { mo: "mo", moDataListCount: "moDataListCount", index: "index", isChecked: "isChecked", isNewInlineMo: "isNewInlineMo", extraRelation: "extraRelation", hideOpenIcon: "hideOpenIcon", cartableTemplate: "cartableTemplate", cartableMo: "cartableMo", cartableWorkflowData: "cartableWorkflowData" }, usesInheritance: true, usesOnChanges: true, ngImport: i0, template: ``, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: BaseViewItemPropsComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bnrc-base-view-item-props',
+                    template: ``,
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.DomSanitizer }, { type: i0.ChangeDetectorRef }, { type: i2.FormPanelService, decorators: [{
+                    type: Optional
+                }, {
+                    type: SkipSelf
+                }] }, { type: i2.FormPanelService, decorators: [{
+                    type: Optional
+                }, {
+                    type: Self
+                }] }, { type: i2.UlvMainService, decorators: [{
+                    type: Optional
+                }] }]; }, propDecorators: { mo: [{
+                type: Input
+            }], moDataListCount: [{
+                type: Input
+            }], index: [{
+                type: Input
+            }], isChecked: [{
+                type: Input
+            }], isNewInlineMo: [{
+                type: Input
+            }], extraRelation: [{
+                type: Input
+            }], hideOpenIcon: [{
+                type: Input
+            }], cartableTemplate: [{
+                type: Input
+            }], cartableMo: [{
+                type: Input
+            }], cartableWorkflowData: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-view-item-props.js","sourceRoot":"","sources":["../../../../../projects/barsa-novin-ray-core/src/lib/dynamic-component/base-view-item-props.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    ChangeDetectionStrategy,\n    ChangeDetectorRef,\n    Component,\n    ElementRef,\n    Input,\n    OnChanges,\n    OnInit,\n    Optional,\n    Self,\n    SimpleChanges,\n    SkipSelf\n} from '@angular/core';\nimport { DomSanitizer, SafeHtml } from '@angular/platform-browser';\nimport { catchError, debounceTime, from, tap, Observable, Subject, switchMap, takeUntil, throwError } from 'rxjs';\n\nimport { MetaobjectDataModel, ReportViewColumn, FormSetting } from '../abstract-classes';\nimport { createGridEditorFormPanel } from '../constants';\nimport { FormPanelService, UlvMainService } from '../services';\nimport { BaseViewPropsComponent } from './base-view-props';\ntype ReasonToSave = 'TAB' | 'CTRL+ENTER' | 'CHECK_CHANGED';\n@Component({\n    selector: 'bnrc-base-view-item-props',\n    template: ``,\n    changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class BaseViewItemPropsComponent extends BaseViewPropsComponent implements OnInit, OnChanges {\n    @Input() mo: MetaobjectDataModel;\n    @Input() moDataListCount: number;\n    @Input() index: number;\n    @Input() isChecked: boolean;\n    @Input() isNewInlineMo: boolean;\n    @Input() extraRelation: any;\n    @Input() hideOpenIcon: boolean;\n\n    @Input() set cartableTemplate(val: FormSetting) {\n        this._cartableTemplate = val;\n        this._createCartableParams();\n    }\n    @Input() set cartableMo(val: MetaobjectDataModel) {\n        this._cartableMo = val;\n        this._createCartableParams();\n    }\n    @Input() set cartableWorkflowData(val: string) {\n        this._cartableWorkflowData = val;\n        this._createCartableParams();\n    }\n    hasError = false;\n    inlineEditInReport = true;\n    layout$: Observable<any>;\n    formPanelCtrlr: any;\n    saving: boolean;\n    saved: boolean;\n    inRow = true;\n    hasCartableTemplate = false;\n    cartableParams: {\n        formSetting: FormSetting;\n        moId: string;\n        typeDefId: string | undefined;\n        viewId: any;\n        inDialog: boolean;\n    };\n    bruleActionMessage: BruleActionMessage | null = null;\n    private _saveEditedMo$ = new Subject<ReasonToSave>();\n    private _formpanelValueChanged$ = new Subject<void>();\n    private _formPanelLoaded: boolean;\n    private _cartableMo: MetaobjectDataModel;\n    private _cartableTemplate: FormSetting;\n    private _cartableWorkflowData: string;\n\n    constructor(\n        protected _el: ElementRef,\n        protected _domSanitizer: DomSanitizer,\n        protected _cdr: ChangeDetectorRef,\n        @Optional() @SkipSelf() protected _parentFormPanelService: FormPanelService,\n        @Optional() @Self() protected _formPanelService: FormPanelService,\n        @Optional() protected _ulvMainService: UlvMainService\n    ) {\n        super();\n        this._saveEditedMo$\n            .asObservable()\n            .pipe(\n                takeUntil(this._onDestroy$),\n                switchMap((reason: ReasonToSave) => this._inlineEditSaveFormPanel(reason)),\n                catchError((err) => throwError(() => err))\n            )\n            .subscribe((res: { reason: ReasonToSave; succeed: boolean; saved: boolean }) => {\n                if (res.saved) {\n                    this._formpanelValueChanged$.next();\n                    this._cdr.markForCheck();\n                }\n                if (res.reason === 'TAB' || res.reason === 'CTRL+ENTER') {\n                    this.selectNextInlineRecord.emit(this.mo);\n                }\n            });\n        this._formpanelValueChanged$\n            .asObservable()\n            .pipe(\n                takeUntil(this._onDestroy$),\n                debounceTime(100),\n                switchMap(() => this._syncMo()),\n                tap(() => {\n                    if (typeof this.mo.$InlineMoChanged === 'undefined') {\n                        this.mo.$InlineMoChanged = true;\n                    }\n                })\n            )\n            .subscribe(() => {\n                this.editFormPanelValueChange.emit(this.mo);\n            });\n    }\n    private get _hasFormPanelService(): boolean {\n        return this._formPanelService !== null && this.formSetting;\n    }\n    private get _focusableControls(): NodeList {\n        return this._el.nativeElement.querySelectorAll(\n            `button,button:not([disabled]),[href],input:not([disabled]),input,\n            select,select:not([disabled]),textarea,textarea:not([disabled]),[tabindex]:not([tabindex=\"-1\"])`\n        );\n    }\n\n    ngOnInit(): void {\n        super.ngOnInit();\n\n        if (this._hasFormPanelService) {\n            this._formPanelService.context$.pipe(takeUntil(this._onDestroy$)).subscribe();\n            this._formPanelService.view$.pipe(takeUntil(this._onDestroy$)).subscribe();\n            this.layout$ = this._formPanelService.layout$;\n        }\n    }\n    ngOnChanges(changes: SimpleChanges): void {\n        super.ngOnChanges(changes);\n        const { isChecked } = changes;\n        if (this.inlineEditMode) {\n            if (isChecked) {\n                if (!isChecked.currentValue && isChecked.previousValue) {\n                    if (this._needToSave()) {\n                        this._saveEditedMo$.next('CHECK_CHANGED');\n                    }\n                } else if (isChecked.currentValue) {\n                    this._loadAndCreateFormPanelCtrlr();\n                }\n            }\n        }\n        // if (mo && !mo.firstChange && this._hasFormPanelService && this.isChecked && this.inlineEditMode) {\n        //     //this.formPanelCtrlr.SetValue(changes.mo.currentValue);\n        // }\n    }\n    ngOnDestroy(): void {\n        super.ngOnDestroy();\n        if (this.formPanelCtrlr) {\n            this.formPanelCtrlr.un('bruleShowMessageAction', this._handleBruleShowMessageAction);\n        }\n    }\n    OnCartableFormClick(e): void {\n        if (this.isChecked) {\n            e.preventDefault();\n            e.stopPropagation();\n        }\n    }\n    onTabKeyDown(): void {\n        setTimeout(() => {\n            this._checkfocusOutFromRow(document.activeElement);\n        }, 0);\n    }\n\n    onRowCheck(): void {\n        this._rowCheck();\n    }\n\n    onRowClick(): void {\n        this.rowClick.emit({ mo: this.mo, index: this.index });\n    }\n    onEditFormPanelSave(): void {\n        this._saveEditedMo$.next('CTRL+ENTER');\n    }\n    onEditFormPanelCancel(): void {\n        this.editFormPanelCancel.emit(this.formPanelCtrlr.Mo);\n    }\n    onUlvCommand(): void {\n        this.ulvCommand.emit({ mo: this.mo, index: this.index });\n    }\n    onAction(commandBody: string): void {\n        this.action.emit(commandBody);\n    }\n    onExpandClick(): void {\n        this.expandClick.emit(this.mo);\n    }\n    onDynamicComponentEvents(e: { title: string; data?: any }): void {\n        switch (e.title) {\n            case 'rowCheck':\n                this.onRowCheck();\n                break;\n            case 'rowClick':\n                this.onRowClick();\n                break;\n            case 'ulvCommand':\n                this.onUlvCommand();\n                break;\n        }\n    }\n    _trackByColumn(index: number, column: ReportViewColumn): string {\n        return `${column.Name}${index}`;\n    }\n    protected _createCartableParams(): void {\n        const cartableTemplate = this._cartableTemplate;\n        const cartableMo = this._cartableMo;\n        const cartableWorkflowData = this._cartableWorkflowData;\n        if (this.hasCartableTemplate) {\n            // TODO update cartable mo;\n            return;\n        }\n        if (cartableTemplate && cartableMo && typeof cartableWorkflowData !== 'undefined') {\n            const view = cartableTemplate.View;\n            cartableTemplate.Data = { Mo: { ...cartableMo } };\n            cartableTemplate.Workflow = cartableWorkflowData === '' ? null : JSON.parse(cartableWorkflowData);\n            if (!view.ExtraJsonProp) {\n                view.ExtraJsonProp = {};\n            }\n            view.ExtraJsonProp.IsSimple = true;\n\n            this.cartableParams = {\n                formSetting: cartableTemplate,\n                moId: cartableMo.Id,\n                typeDefId: cartableMo.$TypeDefId,\n                viewId: view.TypeViewId,\n                inDialog: false\n            };\n            this.hasCartableTemplate = true;\n            this._cdr.markForCheck();\n        }\n    }\n    protected _needToSave(): boolean {\n        // if (!this.isChecked) {\n        //     return false;\n        // }\n        // const isChildNode = (this._el.nativeElement as HTMLElement).contains(e.target);\n        // if (isChildNode) {\n        //     return false;\n        // }\n        const t = this.inlineEditMode && this._hasFormPanelService;\n        if (!t) {\n            return false;\n        }\n\n        return this.formPanelCtrlr && this.formPanelCtrlr.IsMoChanged();\n    }\n    protected _focustToFirstControl(): void {\n        const focusable = this._focusableControls;\n        const lastFocusable = focusable[0];\n        (lastFocusable as HTMLElement)?.focus();\n    }\n    protected _checkfocusOutFromRow(target): void {\n        const focusable: NodeList = this._focusableControls;\n        let foundInFocusable = false;\n        focusable.forEach((c) => {\n            if (c === target) {\n                foundInFocusable = true;\n            }\n        });\n        if (!foundInFocusable) {\n            this._saveEditedMo$.next('TAB');\n        }\n    }\n    protected _rowCheck(): void {\n        // if (this.isChecked) {\n        //     return;\n        // }\n        this.rowCheck.emit({ mo: this.mo, index: this.index });\n    }\n\n    protected _handleValueChange(): void {\n        if (!this.isChecked) {\n            this.onRowCheck();\n        }\n        this._formpanelValueChanged$.next();\n    }\n    protected _syncMo(): Observable<void> {\n        const syncWithFormpanelMo = this.mo;\n        const _isChecked = this.mo.$IsChecked;\n        const formPanelCtrlrMo = this.formPanelCtrlr.Mo;\n        Object.keys(formPanelCtrlrMo.$OriginalValues).forEach((c: any) => {\n            syncWithFormpanelMo[c] = formPanelCtrlrMo[c];\n            if (formPanelCtrlrMo[c + '$Caption']) {\n                syncWithFormpanelMo[c + '$Caption'] = formPanelCtrlrMo[c + '$Caption'];\n            }\n            if (formPanelCtrlrMo[c + '$Icon']) {\n                syncWithFormpanelMo[c + '$Icon'] = formPanelCtrlrMo[c + '$Icon'];\n            }\n        });\n        syncWithFormpanelMo['$State'] = formPanelCtrlrMo['$State']; // this add because if we edit unchanged mo it does not reflect to mo of ulv.\n        this.mo = { ...syncWithFormpanelMo };\n        this.mo.$IsChecked = _isChecked;\n        return from(Promise.resolve());\n    }\n\n    protected _raiseFormPanelValueChanged(): void {\n        this.editFormPanelValueChange.emit(this.mo);\n    }\n\n    protected _handleBruleShowMessageAction(action: BruleActionMessage): void {\n        action.MessageExpressionHtml = this._domSanitizer.bypassSecurityTrustHtml(action.MessageExpression);\n        this.bruleActionMessage = action;\n        // if (action.MessageType === BarsaApi.Common.Enums.ShowMessageRuleAction_Type.Information) {\n        //     if (action.EscapeCharacters) Ul.MsgBox.Info(action.MessageExpression, doReturn);\n        //     else Ul.MsgBox.Info_ShowHtml(action.MessageExpression, doReturn);\n        // } else if (action.MessageType === BarsaApi.Common.Enums.ShowMessageRuleAction_Type.Error) {\n        //     var doReturn0 = function () {\n        //         this._formPanel.RefocusCurrentField();\n        //         doReturn(new Common.SilentException());\n        //     };\n        //     if (action.EscapeCharacters) Ul.MsgBox.Error(action.MessageExpression, doReturn0.bind(this));\n        //     else Ul.MsgBox.Error_ShowHtml(action.MessageExpression, doReturn0.bind(this));\n        // } else if (action.MessageType === BarsaApi.Common.Enums.ShowMessageRuleAction_Type.OkCancel) {\n        //     Ul.MsgBox.ConfirmYesNo_Safe(true, action.MessageExpression, BBB.Select, action.EscapeCharacters, doReturn);\n        // }\n    }\n    protected _createFormPanelCtrlr(mo: MetaobjectDataModel, typeDefId: string): any {\n        if (!this.formPanelCtrlr) {\n            this.formPanelCtrlr = createGridEditorFormPanel(\n                this.formSetting,\n                { ...mo },\n                typeDefId,\n                this.extraRelation,\n                this.inRow\n                // BarsaApi.Common.Util.TryGetValue(this.context.Setting, 'Extra.Relation')\n            );\n        }\n        this.formPanelCtrlr.InlineEditInReport = true;\n        this.formPanelCtrlr.on({\n            bruleShowMessageAction: this._handleBruleShowMessageAction.bind(this),\n            valueChange: this._handleValueChange.bind(this)\n        });\n\n        return this.formPanelCtrlr;\n    }\n\n    protected _loadAndCreateFormPanelCtrlr(): void {\n        const formSettingData = this.formSetting.Data;\n        const formMo = {\n            ...this.mo,\n            $FieldDict: formSettingData.Mo.$FieldDict,\n            $TypeDefId: formSettingData.Mo.$TypeDefId,\n            $OriginalValues: {}\n        };\n        if (this._formPanelLoaded) {\n            this.formPanelCtrlr.SetValue(formMo);\n            return;\n        }\n\n        this._createFormPanelCtrlr(formMo, this.typeDefId);\n        this._formPanelLoaded = true;\n        const formPanelCtrlr = this.formPanelCtrlr;\n        this.formPanelCtrlr.UlvMoDataListCount = this.moDataListCount - 1;\n        formPanelCtrlr.LoadAndCreate(null, false, false, () => {\n            const customFormPanelUi = formPanelCtrlr.Adapter.Control;\n            const parentMo = this._parentFormPanelService ? this._parentFormPanelService.mo : null;\n            if (this.extraRelation && parentMo && this.extraRelation.RelationType === 'Composition') {\n                formPanelCtrlr.Mo.SetFValue(this.extraRelation.ParentFdName, parentMo);\n                // newFormSettings.Data.Mo[relation.ParentFdName] = parentMo.GetChangedObject();\n                // newFormSettings.Data.Mo[relation.ParentFdName].$State = parentMo.$State;\n            }\n            customFormPanelUi.Refresh = () => {};\n            this._formPanelService.context = formPanelCtrlr.Adapter.Control;\n            setTimeout(() => {\n                this._focustToFirstControl();\n            }, 0);\n        });\n    }\n    protected _resetSavingStates(): void {\n        this.hasError = false;\n        this.bruleActionMessage = null;\n        this.saved = false;\n        this._cdr.markForCheck();\n    }\n    protected _setSavingState(err): void {\n        if (err) {\n            this.hasError = true;\n            return;\n        }\n        this.hasError = false;\n        this.saved = true;\n    }\n    protected _inlineEditSaveFormPanel(reason): Promise<{ reason: ReasonToSave; succeed: boolean; saved: boolean }> {\n        // eslint-disable-next-line @typescript-eslint/no-unused-vars\n        return new Promise<{ reason: ReasonToSave; succeed: boolean; saved: boolean }>((resolve, _) => {\n            if (!this.formPanelCtrlr.IsMoChanged()) {\n                // if state of mo is new or modidfied then it needs to update\n                resolve({ reason, succeed: true, saved: false });\n            }\n            const formPanelCtrlrMo = this.formPanelCtrlr.Mo;\n            delete formPanelCtrlrMo.json;\n            // this.saving = true;\n\n            this.mo.$InlineMoChanged = false;\n            this.editFormPanelSave.emit(this.mo);\n            this.formPanelCtrlr.Save(false, (err) => {\n                // this.saving = false;\n                this.formPanelCtrlr.SetIsChanged(false);\n                this._setSavingState(err);\n                resolve({ reason, succeed: true, saved: true });\n            });\n        });\n    }\n}\ninterface BruleActionMessage {\n    MessageType: number;\n    EscapeCharacters: boolean;\n    MessageExpression: string;\n    MessageExpressionHtml: SafeHtml;\n}\n"]}