@pepperi-addons/ngx-lib 0.4.2-beta.137 → 0.4.2-beta.139

package/esm2020/form/internal-form.component.mjs

@@ -0,0 +1,1216 @@
+import { Component, ChangeDetectionStrategy, Input, Output, EventEmitter, } from '@angular/core';
+import { Validators, } from '@angular/forms';
+import { PepDialogData, } from '@pepperi-addons/ngx-lib/dialog';
+import { FIELD_TYPE, PepCustomizationService, PepTextboxField, PepSelectField, PepInternalMenuField, PepQuantitySelectorField, PepAddressField, PepIndicatorsField, PepInternalPageField, PepInternalCaruselField, PepInternalButtonField, PepAttachmentField, PepSignatureField, PepImageField, PepImagesField, PepLinkField, PepTextareaField, PepRichHtmlTextareaField, PepDateField, PepCheckboxField, PepSeparatorField, PepPlaceholderField, X_ALIGNMENT_TYPE, Y_ALIGNMENT_TYPE, DEFAULT_VERTICAL_ALIGNMENT, DEFAULT_HORIZONTAL_ALIGNMENT, } from '@pepperi-addons/ngx-lib';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@pepperi-addons/ngx-lib/dialog";
+import * as i2 from "@pepperi-addons/ngx-lib";
+import * as i3 from "@angular/forms";
+import * as i4 from "@ngx-translate/core";
+import * as i5 from "@angular/common";
+import * as i6 from "@angular/material/grid-list";
+import * as i7 from "@pepperi-addons/ngx-lib/checkbox";
+import * as i8 from "@pepperi-addons/ngx-lib/date";
+import * as i9 from "@pepperi-addons/ngx-lib/image";
+import * as i10 from "@pepperi-addons/ngx-lib/quantity-selector";
+import * as i11 from "@pepperi-addons/ngx-lib/signature";
+import * as i12 from "@pepperi-addons/ngx-lib/textarea";
+import * as i13 from "./internal-field-generator.component";
+import * as i14 from "./internal-button.component";
+export class PepInternalFormComponent {
+    // eventServiceSub: Subscription;
+    // public jsonLib = JSON;
+    constructor(dialogService, customizationService, layoutService, fb, differs, translate) {
+        this.dialogService = dialogService;
+        this.customizationService = customizationService;
+        this.layoutService = layoutService;
+        this.fb = fb;
+        this.translate = translate;
+        this.isInternal = true;
+        this.isReport = false;
+        this.lockEvents = false;
+        this.canEditObject = true;
+        this._data = null;
+        this.isActive = false;
+        this.layoutType = 'card';
+        // @Input() listType = '';
+        this.objectId = '0';
+        this.parentId = '0';
+        this.searchCode = '0';
+        this.showTitle = true;
+        this.firstFieldAsLink = false;
+        this.checkForChanges = null;
+        this.valueChange = new EventEmitter();
+        this.formValidationChange = new EventEmitter();
+        this.fieldClick = new EventEmitter();
+        // @Output() internalFormFieldClick: EventEmitter<any> = new EventEmitter<any>();
+        // @Output() internalFormFieldChange: EventEmitter<any> = new EventEmitter<any>();
+        this.isLocked = false;
+        // payLoad = '';
+        this.rows = [];
+        this.fields = [];
+        this._fieldsSubject = new BehaviorSubject([]);
+        this.columns = 1;
+        this.hasMenuFloatingOnOtherField = false;
+        this.indicatorsDataField = null;
+        this._shouldReloadForm = false;
+        // store the initial value to compare with
+        this.differ = differs.find({}).create();
+    }
+    set data(value) {
+        const shouldReload = this.shouldReloadForm || !this._data;
+        this._data = value;
+        if (shouldReload) {
+            this._shouldReloadForm = false;
+            this.initForm();
+        }
+        else {
+            this.updateForm();
+        }
+    }
+    get data() {
+        return this._data;
+    }
+    set lockFields(value) {
+        this.isLocked = value;
+    }
+    get fields$() {
+        return this._fieldsSubject.asObservable();
+    }
+    get shouldReloadForm() {
+        return this._shouldReloadForm;
+    }
+    convertXAlignToHorizontalAlign(xAlign) {
+        let res = DEFAULT_HORIZONTAL_ALIGNMENT;
+        if (xAlign === X_ALIGNMENT_TYPE.None ||
+            xAlign === X_ALIGNMENT_TYPE.Left) {
+            res = 'left';
+        }
+        else if (xAlign === X_ALIGNMENT_TYPE.Right) {
+            res = 'right';
+        }
+        else {
+            res = 'center';
+        }
+        return res;
+    }
+    convertYAlignToVerticalAlign(yAlign) {
+        let res = DEFAULT_VERTICAL_ALIGNMENT;
+        if (yAlign === Y_ALIGNMENT_TYPE.None ||
+            yAlign === Y_ALIGNMENT_TYPE.Top) {
+            res = 'top';
+        }
+        else if (yAlign === Y_ALIGNMENT_TYPE.Bottom) {
+            res = 'bottom';
+        }
+        else {
+            res = 'middle';
+        }
+        return res;
+    }
+    convertOptionalValues(optionalValues) {
+        if (optionalValues && optionalValues.length > 0) {
+            return optionalValues.map((ov) => {
+                return { key: ov.Key, value: ov.Value };
+            });
+        }
+        else {
+            return [];
+        }
+    }
+    convertAddressFields(controlField, addressFields, canEditObject) {
+        const fields = [];
+        addressFields.forEach((field) => {
+            let customField;
+            const placeholder = field.ApiName;
+            if (field.ApiName.toLowerCase().indexOf('street') >= 0) {
+                customField = new PepTextboxField({
+                    key: field.ApiName,
+                    label: field.ApiName,
+                    type: 'text',
+                    placeholder,
+                    readonly: !canEditObject,
+                    disabled: !field.Enabled || !canEditObject,
+                    hidden: false,
+                    mandatory: false,
+                    value: field.Value,
+                    formattedValue: field.FormattedValue,
+                    row: 0,
+                    rowSpan: 1,
+                    col: 0,
+                    colSpan: 2,
+                    xAlignment: this.convertXAlignToHorizontalAlign(controlField.Layout.XAlignment),
+                    yAlignment: this.convertYAlignToVerticalAlign(controlField.Layout.YAlignment),
+                    order: 0,
+                });
+            }
+            else if (field.ApiName.toLowerCase().indexOf('city') >= 0) {
+                customField = new PepTextboxField({
+                    key: field.ApiName,
+                    label: field.ApiName,
+                    type: 'text',
+                    placeholder,
+                    readonly: !canEditObject,
+                    disabled: !field.Enabled || !canEditObject,
+                    hidden: false,
+                    mandatory: false,
+                    value: field.Value,
+                    formattedValue: field.FormattedValue,
+                    row: 0,
+                    rowSpan: 1,
+                    col: 2,
+                    colSpan: 1,
+                    xAlignment: this.convertXAlignToHorizontalAlign(controlField.Layout.XAlignment),
+                    yAlignment: this.convertYAlignToVerticalAlign(controlField.Layout.YAlignment),
+                    order: 1,
+                });
+            }
+            else if (field.ApiName.toLowerCase().indexOf('state') >= 0) {
+                customField = new PepSelectField({
+                    key: field.ApiName,
+                    label: field.ApiName,
+                    placeholder,
+                    options: this.convertOptionalValues(field.OptionalValues),
+                    readonly: !canEditObject,
+                    disabled: !field.Enabled || !canEditObject,
+                    hidden: false,
+                    mandatory: false,
+                    value: field.Value,
+                    formattedValue: field.FormattedValue,
+                    row: 1,
+                    rowSpan: 1,
+                    col: 0,
+                    colSpan: 1,
+                    xAlignment: this.convertXAlignToHorizontalAlign(controlField.Layout.XAlignment),
+                    yAlignment: this.convertYAlignToVerticalAlign(controlField.Layout.YAlignment),
+                    order: 2,
+                });
+            }
+            else if (field.ApiName.toLowerCase().indexOf('zipcode') >= 0) {
+                customField = new PepTextboxField({
+                    key: field.ApiName,
+                    label: field.ApiName,
+                    type: 'text',
+                    placeholder,
+                    readonly: !canEditObject,
+                    disabled: !field.Enabled || !canEditObject,
+                    hidden: false,
+                    mandatory: false,
+                    value: field.Value,
+                    formattedValue: field.FormattedValue,
+                    row: 1,
+                    rowSpan: 1,
+                    col: 1,
+                    colSpan: 1,
+                    xAlignment: this.convertXAlignToHorizontalAlign(controlField.Layout.XAlignment),
+                    yAlignment: this.convertYAlignToVerticalAlign(controlField.Layout.YAlignment),
+                    order: 3,
+                });
+            }
+            else if (field.ApiName.toLowerCase().indexOf('country') >= 0) {
+                customField = new PepSelectField({
+                    key: field.ApiName,
+                    label: field.ApiName,
+                    placeholder,
+                    options: this.convertOptionalValues(field.OptionalValues),
+                    readonly: !canEditObject,
+                    disabled: !field.Enabled || !canEditObject,
+                    hidden: false,
+                    mandatory: false,
+                    value: field.Value,
+                    formattedValue: field.FormattedValue,
+                    row: 2,
+                    rowSpan: 1,
+                    col: 2,
+                    colSpan: 1,
+                    xAlignment: this.convertXAlignToHorizontalAlign(controlField.Layout.XAlignment),
+                    yAlignment: this.convertYAlignToVerticalAlign(controlField.Layout.YAlignment),
+                    order: 4,
+                });
+            }
+            fields.push(customField);
+        });
+        return fields.sort((n1, n2) => n1.order > n2.order ? 1 : n1.order < n2.order ? -1 : 0);
+    }
+    isMatrixField(apiNameToCheck) {
+        return apiNameToCheck.indexOf('Matrix') >= 0;
+    }
+    doesFieldHavaFloatingField(controlField, floatingField) {
+        let hasFloatingField = false;
+        if (floatingField.Layout.Y >= controlField.Layout.Y &&
+            floatingField.Layout.Y <
+                controlField.Layout.Y + controlField.Layout.Height &&
+            floatingField.Layout.X >= controlField.Layout.X &&
+            floatingField.Layout.X <
+                controlField.Layout.X + controlField.Layout.Width) {
+            hasFloatingField = true;
+        }
+        return hasFloatingField;
+    }
+    getOptionsForCustomField(controlField, dataField, canEditObject) {
+        if (!controlField || !dataField) {
+            return;
+        }
+        const placeholder = controlField.ReadOnly || !canEditObject ? '' : controlField.Title;
+        return {
+            key: controlField.ApiName,
+            label: controlField.Title,
+            accessory: dataField.Accessory,
+            placeholder,
+            readonly: controlField.ReadOnly || !canEditObject,
+            disabled: !dataField.Enabled || !canEditObject,
+            hidden: controlField.Hidden,
+            mandatory: controlField.Mandatory,
+            value: dataField.Value,
+            formattedValue: dataField.FormattedValue,
+            additionalValue: dataField.AdditionalValue,
+            row: controlField.Layout.Y,
+            rowSpan: controlField.Layout.Height,
+            col: controlField.Layout.X,
+            colSpan: controlField.Layout.Width,
+            xAlignment: this.convertXAlignToHorizontalAlign(controlField.Layout.XAlignment),
+            yAlignment: this.convertYAlignToVerticalAlign(controlField.Layout.YAlignment),
+            options: this.convertOptionalValues(dataField.OptionalValues),
+            groupFields: undefined,
+            maxFieldCharacters: controlField.MaxFieldCharacters,
+            minValue: controlField.MinValue,
+            maxValue: controlField.MaxValue,
+            // hasMenu: hasMenu,
+            // hasCampaign: hasCampaign,
+            // hasIndicators: hasIndicators,
+            textColor: dataField.TextColor,
+            visible: dataField.Visible,
+            digitsNumberAfterDecimalPoint: dataField.DigitsNumberAfterDecimalPoint,
+        };
+    }
+    convertToCustomField(controlField, dataField, canEditObject, menuField, hasCampaignField, indicatorsField, objectId, parentId, searchCode) {
+        let customField;
+        const options = this.getOptionsForCustomField(controlField, dataField, canEditObject);
+        if (controlField.ApiName === 'ObjectMenu') {
+            options.type = 'menu';
+            customField = new PepInternalMenuField(options);
+        }
+        else if (controlField.FieldType === FIELD_TYPE.NumberRealQuantitySelector ||
+            controlField.FieldType ===
+                FIELD_TYPE.NumberIntegerQuantitySelector ||
+            controlField.ApiName === 'QuantitySelector' ||
+            controlField.ApiName === 'UnitsQuantity' ||
+            controlField.ApiName.indexOf('size_') === 0) {
+            if (dataField.FieldType === FIELD_TYPE.InternalLink) {
+                options.type = 'button';
+            }
+            else if (dataField.FieldType === FIELD_TYPE.Package) {
+                options.type = 'packageButton';
+            }
+            else if (dataField.FieldType === FIELD_TYPE.NumberRealQuantitySelector ||
+                dataField.FieldType === FIELD_TYPE.NumberReal) {
+                options.type = 'qs';
+                options.allowDecimal = true;
+            }
+            else if (dataField.FieldType ===
+                FIELD_TYPE.NumberIntegerQuantitySelector ||
+                dataField.FieldType === FIELD_TYPE.NumberInteger) {
+                options.type = 'qs';
+                options.allowDecimal = false;
+            }
+            else if (dataField.FieldType === FIELD_TYPE.NumberIntegerForMatrix) {
+                options.type = 'qsForMatrix';
+                options.allowDecimal = false;
+            }
+            else if (dataField.FieldType === FIELD_TYPE.NumberRealForMatrix) {
+                options.type = 'qsForMatrix';
+                options.allowDecimal = true;
+            }
+            options.notificationInfo = dataField.NotificationInfo;
+            customField = new PepQuantitySelectorField(options);
+        }
+        else {
+            // HACK: need to remove this..
+            if (dataField.FieldType === FIELD_TYPE.Indicators &&
+                this.isMatrixField(dataField.ApiName)) {
+                dataField.FieldType = FIELD_TYPE.InternalPage;
+            }
+            switch (dataField.FieldType) {
+                case FIELD_TYPE.Address: {
+                    const canEditGroupObject = controlField.ReadOnly
+                        ? false
+                        : canEditObject;
+                    options.groupFields = this.convertAddressFields(controlField, dataField.GroupFields, canEditGroupObject);
+                    customField = new PepAddressField(options);
+                    break;
+                }
+                case FIELD_TYPE.Indicators: {
+                    // options['type'] = 'indicators'; // Not needed this is PepIndicatorsField.
+                    customField = new PepIndicatorsField(options);
+                    break;
+                }
+                case FIELD_TYPE.InternalPage: {
+                    if (this.isMatrixField(controlField.ApiName)) {
+                        options.rowSpan = controlField.Layout.Height;
+                        options.objectId = objectId;
+                        options.parentId = parentId;
+                        options.searchCode = searchCode;
+                        customField = new PepInternalPageField(options);
+                    }
+                    else {
+                        // Not supported
+                    }
+                    break;
+                }
+                case FIELD_TYPE.RelatedObjectsCards: {
+                    options.rowSpan = controlField.Layout.Height;
+                    options.searchCode = searchCode;
+                    options.pageInfo = dataField.UIPageInfo;
+                    customField = new PepInternalCaruselField(options);
+                    break;
+                }
+                case FIELD_TYPE.Link: {
+                    options.type = 'link';
+                    customField = new PepLinkField(options);
+                    break;
+                }
+                case FIELD_TYPE.InternalLink:
+                case FIELD_TYPE.Button: {
+                    options.type = 'button';
+                    customField = new PepInternalButtonField(options);
+                    break;
+                }
+                case FIELD_TYPE.Attachment: {
+                    // options.type = 'attachment';
+                    customField = new PepAttachmentField(options);
+                    break;
+                }
+                case FIELD_TYPE.Signature: {
+                    // options.type = 'signature';
+                    customField = new PepSignatureField(options);
+                    break;
+                }
+                case FIELD_TYPE.Image:
+                case FIELD_TYPE.ImageURL: {
+                    // options.type = 'image';
+                    options.menuField =
+                        menuField &&
+                            this.doesFieldHavaFloatingField(controlField, menuField)
+                            ? menuField
+                            : null;
+                    options.hasCampaignField =
+                        hasCampaignField &&
+                            this.doesFieldHavaFloatingField(controlField, hasCampaignField)
+                            ? hasCampaignField
+                            : null;
+                    options.indicatorsField =
+                        indicatorsField &&
+                            this.doesFieldHavaFloatingField(controlField, indicatorsField)
+                            ? indicatorsField
+                            : null;
+                    customField = new PepImageField(options);
+                    break;
+                }
+                case FIELD_TYPE.Images: {
+                    // options.type = 'images';
+                    customField = new PepImagesField(options);
+                    break;
+                }
+                case FIELD_TYPE.Email: {
+                    options.type = 'email';
+                    customField = new PepLinkField(options);
+                    break;
+                }
+                case FIELD_TYPE.Phone: {
+                    options.type = 'phone';
+                    customField = new PepLinkField(options);
+                    break;
+                }
+                case FIELD_TYPE.Duration: {
+                    options.type = 'duration';
+                    customField = new PepTextboxField(options);
+                    break;
+                }
+                case FIELD_TYPE.Default:
+                case FIELD_TYPE.TextBox:
+                case FIELD_TYPE.LimitedLengthTextBox:
+                case FIELD_TYPE.TextHeader:
+                case FIELD_TYPE.CalculatedString:
+                case FIELD_TYPE.MapDataString: {
+                    customField = new PepTextboxField(options);
+                    break;
+                }
+                case FIELD_TYPE.TextArea: {
+                    customField = new PepTextareaField(options);
+                    break;
+                }
+                case FIELD_TYPE.RichTextHTML: {
+                    customField = new PepRichHtmlTextareaField(options);
+                    break;
+                }
+                case FIELD_TYPE.Date:
+                case FIELD_TYPE.LimitedDate:
+                case FIELD_TYPE.CalculatedDate:
+                case FIELD_TYPE.DateAndTime: {
+                    options.type =
+                        dataField.FieldType === FIELD_TYPE.DateAndTime
+                            ? 'datetime'
+                            : 'date';
+                    customField = new PepDateField(options);
+                    break;
+                }
+                case FIELD_TYPE.NumberInteger:
+                case FIELD_TYPE.CalculatedInt:
+                case FIELD_TYPE.MapDataInt: {
+                    options.type = 'int';
+                    customField = new PepTextboxField(options);
+                    break;
+                }
+                case FIELD_TYPE.Percentage: {
+                    options.type = 'percentage';
+                    customField = new PepTextboxField(options);
+                    break;
+                }
+                case FIELD_TYPE.Currency: {
+                    options.type = 'currency';
+                    customField = new PepTextboxField(options);
+                    break;
+                }
+                case FIELD_TYPE.NumberReal:
+                case FIELD_TYPE.CalculatedReal:
+                case FIELD_TYPE.MapDataReal:
+                case FIELD_TYPE.Sum:
+                case FIELD_TYPE.Totals: {
+                    options.type = 'real';
+                    customField = new PepTextboxField(options);
+                    break;
+                }
+                case FIELD_TYPE.Boolean:
+                case FIELD_TYPE.CalculatedBool: {
+                    customField = new PepCheckboxField(options);
+                    break;
+                }
+                case FIELD_TYPE.BooleanText: {
+                    options.type = 'booleanText';
+                    customField = new PepCheckboxField(options);
+                    break;
+                }
+                case FIELD_TYPE.ComboBox:
+                case FIELD_TYPE.EmptyComboBox:
+                case FIELD_TYPE.MapDataDropDown: {
+                    // options.type = 'select';
+                    customField = new PepSelectField(options);
+                    break;
+                }
+                case FIELD_TYPE.MultiTickBox:
+                case FIELD_TYPE.MultiTickBoxToComboBox:
+                case FIELD_TYPE.EmptyMultiTickBox: {
+                    options.type = 'multi';
+                    customField = new PepSelectField(options);
+                    break;
+                }
+                case FIELD_TYPE.GuidReferenceType: {
+                    options.type = 'reference';
+                    options.referenceObjectType = dataField.ReferenceObjectType;
+                    options.referenceObjectSubType =
+                        dataField.ReferenceObjectSubType;
+                    options.referenceObjectInternalType =
+                        dataField.ReferenceObjectInternalType;
+                    customField = new PepInternalButtonField(options);
+                    break;
+                }
+                case FIELD_TYPE.ListOfObjects: {
+                    options.type = 'listofobjects';
+                    customField = new PepInternalButtonField(options);
+                    break;
+                }
+                case FIELD_TYPE.Separator: {
+                    customField = new PepSeparatorField(options);
+                    break;
+                }
+                /*
+                    case FIELD_TYPE.Images: return that.field(value);
+                */
+                case FIELD_TYPE.NumberRealQuantitySelector:
+                case FIELD_TYPE.NumberIntegerQuantitySelector: {
+                    options.type = 'qs';
+                    options.allowDecimal =
+                        dataField.FieldType ===
+                            FIELD_TYPE.NumberRealQuantitySelector;
+                    options.notificationInfo = dataField.NotificationInfo;
+                    customField = new PepQuantitySelectorField(options);
+                    break;
+                }
+                case FIELD_TYPE.Package: {
+                    options.type = 'packageButton';
+                    options.notificationInfo = dataField.NotificationInfo;
+                    customField = new PepQuantitySelectorField(options);
+                    break;
+                }
+            }
+        }
+        if (!customField) {
+            options.label = controlField.ApiName + ' is not supported!!!';
+            customField = new PepSeparatorField(options);
+        }
+        return customField;
+    }
+    getFieldFormattedValue(field) {
+        let fieldFormattedValue = field.formattedValue || field.value;
+        // Fix for the custom check box component.
+        if (field.controlType === 'checkbox') {
+            fieldFormattedValue = fieldFormattedValue === 'true';
+        }
+        // Fix for the custom button component.
+        if (field.controlType === 'button') {
+            fieldFormattedValue =
+                fieldFormattedValue === '0' ? '' : fieldFormattedValue;
+        }
+        return fieldFormattedValue;
+    }
+    toControlGroup(fields) {
+        const group = {};
+        if (fields && fields.length > 0) {
+            fields.forEach((field) => {
+                if (field.groupFields && field.groupFields.length > 0) {
+                    const subGroup = {};
+                    field.groupFields.forEach((groupField) => {
+                        if (groupField.mandatory &&
+                            !field.readonly &&
+                            !field.disabled) {
+                            subGroup[groupField.key] = [
+                                {
+                                    value: groupField.formattedValue || '',
+                                    disabled: field.readonly ||
+                                        field.disabled ||
+                                        groupField.disabled,
+                                },
+                                [Validators.required],
+                            ];
+                        }
+                        else {
+                            subGroup[groupField.key] = [
+                                {
+                                    value: groupField.formattedValue || '',
+                                    disabled: field.readonly ||
+                                        field.disabled ||
+                                        groupField.disabled,
+                                },
+                                [Validators.nullValidator],
+                            ];
+                        }
+                    });
+                    group[field.key] = this.fb.group(subGroup);
+                }
+                else {
+                    const validators = field.getValidators();
+                    const fieldFormattedValue = this.getFieldFormattedValue(field);
+                    group[field.key] = [
+                        {
+                            value: fieldFormattedValue || '',
+                            disabled: field.disabled,
+                        },
+                        validators,
+                    ];
+                }
+            });
+        }
+        return this.fb.group(group);
+    }
+    createBaseField(uiControlField, dataField) {
+        const customField = this.convertToCustomField(uiControlField, dataField, this.canEditObject, this.menuDataField, this.hasCampaignDataField, this.indicatorsDataField, this.objectId, this.parentId, this.searchCode);
+        return customField;
+    }
+    showFormValidationMessage() {
+        const fields = this.fields;
+        let emptyMandatoryFieldsMsg = '';
+        let notValidFieldsMsg = '';
+        // for (let i: number = 0; i < fields.length; i++) {
+        //     let field = fields[i];
+        for (const field of fields) {
+            const formControl = this.form && this.form.get(field.key);
+            if (formControl) {
+                // Mandatory is empty.
+                if (field.mandatory &&
+                    formControl.value.toString().trim().length === 0) {
+                    emptyMandatoryFieldsMsg +=
+                        '<li><small>' + field.label + '</small></li>';
+                }
+                else if (!field.disabled && !formControl.valid) {
+                    notValidFieldsMsg +=
+                        '<li><small>' + field.label + '</small></li>';
+                }
+            }
+        }
+        // Add the header message of the empty mandatory fields
+        if (emptyMandatoryFieldsMsg.length > 0) {
+            emptyMandatoryFieldsMsg =
+                '<div>' +
+                    this.translate.instant('MESSAGES.ERROR_MANDATORY_FIELDS') +
+                    "</div><ul style='padding: 0 20px;'>" +
+                    emptyMandatoryFieldsMsg +
+                    '</ul><br/>';
+        }
+        // Add the header message of the empty mandatory fields
+        if (notValidFieldsMsg.length > 0) {
+            notValidFieldsMsg =
+                '<div>' +
+                    this.translate.instant('MESSAGES.ERROR_INVALID_FIELDS') +
+                    "</div><ul style='padding: 0 20px;'>" +
+                    notValidFieldsMsg +
+                    '</ul>';
+        }
+        const title = this.translate.instant('MESSAGES.TITLE_NOTICE');
+        const data = new PepDialogData({
+            title,
+            content: emptyMandatoryFieldsMsg + notValidFieldsMsg,
+        });
+        this.dialogService.openDefaultDialog(data);
+    }
+    ngOnInit() {
+        const themeVars = this.customizationService.getThemeVariables();
+        // convert rem to pixel
+        const RemToPixel = 16;
+        this.formGutterSize =
+            this.customizationService.getNumberThemeVariable(themeVars, PepCustomizationService.FORM_SPACEING_KEY) * RemToPixel;
+        this.cardGutterSize =
+            this.customizationService.getNumberThemeVariable(themeVars, PepCustomizationService.CARD_SPACEING_KEY) * RemToPixel;
+    }
+    ngDoCheck() {
+        const changes = this.differ.diff(this.data); // check for changes
+        if (changes) {
+            this.updateForm();
+            this.checkForChanges = new Date();
+        }
+    }
+    ngOnChanges(changes) {
+        // if (changes.data && changes.data.currentValue) {
+        //     // Load changes
+        //     if (!this.shouldReloadForm && changes.data.previousValue) {
+        //         this.data = changes.data.currentValue;
+        //         this.updateForm();
+        //     } else {
+        //         this._shouldReloadForm = false;
+        //         this.initForm();
+        //     }
+        // }
+        // if (this.shouldReloadForm || !changes?.data?.previousValue) {
+        //     this._shouldReloadForm = false;
+        //     this.initForm();
+        //     this.checkForChanges = new Date();
+        // }
+    }
+    ngOnDestroy() {
+        //
+    }
+    getUiControlFields() {
+        return this.layout ? this.layout.ControlFields : [];
+    }
+    initFieldsStructure(fields, maxRow) {
+        const themeVars = this.customizationService.getThemeVariables();
+        // Set form row height.
+        if (this.layoutType === 'card') {
+            const cardFieldHeight = this.customizationService.getNumberThemeVariable(themeVars, PepCustomizationService.CARD_FIELD_HEIGHT_KEY);
+            this.rowHeight = cardFieldHeight;
+        }
+        else {
+            const rowFieldHeight = this.customizationService.getNumberThemeVariable(themeVars, PepCustomizationService.FORM_FIELD_HEIGHT_KEY);
+            const rowFieldTitleHeight = this.customizationService.getNumberThemeVariable(themeVars, PepCustomizationService.FORM_FIELD_TITLE_HEIGHT_KEY);
+            this.rowHeight = rowFieldHeight + rowFieldTitleHeight;
+        }
+        // Create the fields structure (the fields must be sorted!!!).
+        if (fields.length > 0) {
+            // Init the layout.
+            if (
+            // this.layoutType === 'form' ||
+            this.layoutType === 'table') {
+                this.fields = fields;
+                this._fieldsSubject.next(fields);
+                this.rows = [];
+                for (let i = 0; i <= maxRow; i++) {
+                    this.rows[i] = [];
+                }
+                // for (let i = 0; i < fields.length; i++) {
+                // const field = fields[i]
+                for (const field of fields) {
+                    this.rows[field.row].push(field);
+                }
+            }
+            else {
+                const doesfieldExistIn = new Array(maxRow);
+                for (let i = 0; i < doesfieldExistIn.length; i++) {
+                    doesfieldExistIn[i] = new Array(this.columns);
+                    for (let j = 0; j < doesfieldExistIn[i].length; j++) {
+                        doesfieldExistIn[i][j] = false;
+                    }
+                }
+                // Run in squere (row - colspan, col - rowspan) and put true where it should.
+                // for (let index = 0; index < fields.length; index++) {
+                //     const currentField = fields[index];
+                for (const currentField of fields) {
+                    if (currentField.rowSpan > 1) {
+                        for (let row = currentField.row; row < currentField.row + currentField.rowSpan; row++) {
+                            if (currentField.colSpan > 1) {
+                                for (let col = currentField.col; col <
+                                    currentField.col + currentField.colSpan; col++) {
+                                    if (doesfieldExistIn.length > row &&
+                                        doesfieldExistIn[0].length > col) {
+                                        doesfieldExistIn[row][col] = true;
+                                    }
+                                }
+                            }
+                            else {
+                                if (doesfieldExistIn.length > row &&
+                                    doesfieldExistIn[0].length >
+                                        currentField.col) {
+                                    doesfieldExistIn[row][currentField.col] = true;
+                                }
+                            }
+                        }
+                    }
+                    else if (currentField.colSpan > 1) {
+                        for (let col = currentField.col; col < currentField.col + currentField.colSpan; col++) {
+                            if (doesfieldExistIn.length > currentField.row &&
+                                doesfieldExistIn[0].length > col) {
+                                doesfieldExistIn[currentField.row][col] = true;
+                            }
+                        }
+                    }
+                    else {
+                        if (doesfieldExistIn.length > currentField.row &&
+                            doesfieldExistIn[0].length > currentField.col) {
+                            doesfieldExistIn[currentField.row][currentField.col] = true;
+                        }
+                    }
+                }
+                // Create empty fields where doesfieldExistIn is false (For the md-grid-list UI Component).
+                for (let i = 0; i < doesfieldExistIn.length; i++) {
+                    for (let j = 0; j < doesfieldExistIn[i].length; j++) {
+                        if (!doesfieldExistIn[i][j]) {
+                            // Create empty field and add it to the fields list.
+                            fields.push(new PepPlaceholderField({
+                                key: i + '_' + j,
+                                label: '',
+                                placeholder: '',
+                                readonly: false,
+                                disabled: false,
+                                hidden: false,
+                                mandatory: false,
+                                value: '',
+                                formattedValue: '',
+                                row: i,
+                                rowSpan: 1,
+                                col: j,
+                                colSpan: 1,
+                                order: 1,
+                            }));
+                        }
+                    }
+                }
+                // Sort the fields again.
+                this.fields = fields.sort((f1, f2) => f1.row > f2.row
+                    ? 1
+                    : f1.row < f2.row
+                        ? -1
+                        : f1.col > f2.col
+                            ? 1
+                            : f1.col < f2.col
+                                ? -1
+                                : 0);
+                this._fieldsSubject.next(fields);
+            }
+        }
+    }
+    setForm(isForUpdate = false) {
+        let allFieldsAreReadOnly = true;
+        if (!isForUpdate) {
+            const fields = [];
+            for (const currentField of this.fields) {
+                // Add all fields except 'internalPage' (for children).
+                if (currentField.controlType !== 'internalPage') {
+                    fields.push(currentField);
+                }
+                if (!currentField.readonly) {
+                    allFieldsAreReadOnly = false;
+                }
+            }
+            this.form = this.toControlGroup(fields);
+        }
+        else {
+            // Update form values if changed by calculated fields.
+            for (let i = 0; i < this.fields.length; i++) {
+                let currentField = this.fields[i];
+                if (currentField.controlType === 'internalCarusel') {
+                    // Hack to override (update) the field.
+                    const uiControlField = this.getUiControlFields().find(cf => cf.ApiName === currentField.key);
+                    const dataField = this.data.Fields.find(df => df.ApiName === currentField.key);
+                    currentField = this.createBaseField(uiControlField, dataField);
+                    this._fieldsSubject.value[i] = currentField;
+                }
+                else if (currentField.controlType !== 'internalPage') {
+                    if (currentField.groupFields &&
+                        currentField.groupFields.length > 0) {
+                        // for (let j = 0; j < currentField.groupFields.length; j++) {
+                        //     let currentGroupField = currentField.groupFields[j];
+                        for (const currentGroupField of currentField.groupFields) {
+                            const fieldFormattedValue = this.getFieldFormattedValue(currentGroupField);
+                            this.customizationService.updateFormField(this.form, currentGroupField, fieldFormattedValue, currentField);
+                        }
+                    }
+                    else {
+                        const fieldFormattedValue = this.getFieldFormattedValue(currentField);
+                        // this.form.controls[currentField.key].setValue(fieldFormattedValue);
+                        this.customizationService.updateFormField(this.form, currentField, fieldFormattedValue);
+                    }
+                }
+                if (!currentField.readonly) {
+                    allFieldsAreReadOnly = false;
+                }
+            }
+        }
+        let isFormValid = this.form?.valid;
+        // Change validation to true if all fields are read only.
+        if (!isFormValid && allFieldsAreReadOnly) {
+            isFormValid = true;
+        }
+        this.onFormValidationChanged(isFormValid);
+        // Set it to false to enable all fields.
+        if (this.isInternal && this.isLocked) {
+            this.isLocked = false;
+        }
+    }
+    initForm() {
+        if (this.data && this.data.Fields) {
+            const fields = this.convertCustomFields(this.getUiControlFields(), this.data.Fields);
+            const maxRow = Math.max(...fields.map((f) => {
+                return f.row + f.rowSpan;
+            }));
+            this.columns = Math.max(...fields.map((f) => {
+                return f.col + f.colSpan;
+            }));
+            this.initFieldsStructure(fields, maxRow);
+            this.setForm();
+        }
+    }
+    updateField(customField, updatedField) {
+        const options = {
+            disabled: !updatedField.Enabled || !this.canEditObject,
+            readonly: !updatedField.Enabled || !this.canEditObject,
+            visible: updatedField.Visible,
+            value: updatedField.Value,
+            additionalValue: updatedField.AdditionalValue,
+            formattedValue: updatedField.FormattedValue,
+            textColor: updatedField.TextColor,
+            digitsNumberAfterDecimalPoint: updatedField.DigitsNumberAfterDecimalPoint,
+        };
+        if (customField instanceof PepQuantitySelectorField) {
+            const notificationInfo = updatedField.NotificationInfo;
+            options.notificationInfo = notificationInfo;
+            // Change type if it's change (only for allowDecimal).
+            let allowDecimal = false;
+            if (updatedField.FieldType === FIELD_TYPE.NumberRealQuantitySelector ||
+                updatedField.FieldType === FIELD_TYPE.NumberReal ||
+                updatedField.FieldType === FIELD_TYPE.NumberRealForMatrix) {
+                allowDecimal = true;
+            }
+            options.allowDecimal = allowDecimal;
+        }
+        else if (customField instanceof PepSelectField) {
+            options.options = this.convertOptionalValues(updatedField.OptionalValues);
+            if (!options.options || options.options.length === 0) {
+                options.options.push({
+                    key: options.value,
+                    value: options.formattedValue,
+                });
+            }
+        }
+        else if (customField instanceof PepInternalCaruselField) {
+            options.pageInfo = updatedField.UIPageInfo;
+        }
+        customField.update(options);
+    }
+    updateForm() {
+        if (this.data && this.data.Fields) {
+            for (const currentField of this.data.Fields) {
+                const customField = this.fields.filter((f) => f.key === currentField.ApiName)[0];
+                // Update all fields except 'internalPage' type (for children).
+                if (customField && customField.controlType !== 'internalPage') {
+                    this.updateField(customField, currentField);
+                    // Update the group fields.
+                    if (customField.controlType === 'address' &&
+                        currentField.GroupFields) {
+                        // for (let j = 0; j < currentField.GroupFields.length; j++) {
+                        // let currentGroupField = currentField.GroupFields[j];
+                        for (const currentGroupField of currentField.GroupFields) {
+                            currentGroupField.Enabled = !currentField.Enabled
+                                ? false
+                                : currentGroupField.Enabled;
+                            const customGroupField = customField.groupFields.filter((f) => f.key === currentGroupField.ApiName)[0];
+                            this.updateField(customGroupField, currentGroupField);
+                        }
+                    }
+                }
+            }
+            this.setForm(true);
+        }
+    }
+    ReloadForm() {
+        this._shouldReloadForm = true;
+    }
+    // onSubmit() {
+    //     if (this.form.valid) {
+    //         this.payLoad = JSON.stringify(this.form.value);
+    //         //this.submitted.emit(this.form.value);
+    //     }
+    // }
+    getFormControlById(key) {
+        let formControl = null;
+        this.fields.forEach((field) => {
+            if (field.key === key) {
+                formControl = this.form.get(field.key);
+                return;
+            }
+            else if (field.groupFields && field.groupFields.length > 0) {
+                field.groupFields.forEach((groupField) => {
+                    if (groupField.key === key) {
+                        formControl = this.form.get(field.key + '.' + groupField.key);
+                        return;
+                    }
+                });
+            }
+        });
+        return formControl;
+    }
+    setSpecialFields(controlFields, dataFields) {
+        // let cf;
+        // for (let index = 0; index < controlFields.length; index++) {
+        //     cf = controlFields[index];
+        for (const cf of controlFields) {
+            if (cf.ApiName === 'ObjectMenu') {
+                this.menuField = cf;
+            }
+            else if (cf.ApiName === 'ItemHasActiveCampaign') {
+                this.hasCampaignField = cf;
+            }
+            else if (cf.ApiName === 'ItemIndicatorsWithoutCampaign') {
+                this.indicatorsField = cf;
+            }
+        }
+        // let df;
+        // for (let index = 0; index < dataFields.length; index++) {
+        //     df = dataFields[index];
+        for (const df of dataFields) {
+            if (df.ApiName === 'ObjectMenu') {
+                this.menuDataField = df;
+            }
+            else if (df.ApiName === 'ItemHasActiveCampaign') {
+                this.hasCampaignDataField = df;
+            }
+            else if (df.ApiName === 'ItemIndicatorsWithoutCampaign') {
+                this.indicatorsDataField = df;
+            }
+        }
+        if (this.menuField && this.menuDataField) {
+            this.menuDataField.Layout = this.menuField.Layout;
+        }
+        if (this.hasCampaignField && this.hasCampaignDataField) {
+            this.hasCampaignDataField.Layout = this.hasCampaignField.Layout;
+        }
+        if (this.indicatorsField && this.indicatorsDataField) {
+            this.indicatorsDataField.Layout = this.indicatorsField.Layout;
+        }
+        // Check if menu is floating on other field.
+        // for (let index = 0; index < controlFields.length; index++) {
+        //     cf = controlFields[index];
+        for (const cf of controlFields) {
+            if (this.menuField && cf.ApiName !== 'ObjectMenu') {
+                this.hasMenuFloatingOnOtherField = this.doesFieldHavaFloatingField(cf, this.menuField);
+                if (this.hasMenuFloatingOnOtherField) {
+                    break;
+                }
+            }
+        }
+    }
+    convertCustomFields(controlFields, dataFields) {
+        if (this.layoutType !== 'table') {
+            this.setSpecialFields(controlFields, dataFields);
+        }
+        else {
+            // HACK: convert to center alignment if table view & special fields)
+            controlFields.forEach((field, index) => {
+                if (field.ApiName === 'UnitsQuantity' ||
+                    field.ApiName === 'QuantitySelector' ||
+                    field.ApiName === 'ObjectMenu' ||
+                    field.FieldType === FIELD_TYPE.Image ||
+                    field.FieldType === FIELD_TYPE.ImageURL ||
+                    field.FieldType === FIELD_TYPE.Indicators ||
+                    field.FieldType === FIELD_TYPE.Boolean ||
+                    field.FieldType === FIELD_TYPE.CalculatedBool ||
+                    field.FieldType === FIELD_TYPE.Signature ||
+                    field.FieldType ===
+                        FIELD_TYPE.NumberIntegerQuantitySelector ||
+                    field.FieldType === FIELD_TYPE.NumberRealQuantitySelector ||
+                    field.FieldType === FIELD_TYPE.Package ||
+                    field.FieldType === FIELD_TYPE.NumberIntegerForMatrix ||
+                    field.FieldType === FIELD_TYPE.NumberRealForMatrix) {
+                    field.Layout.XAlignment = X_ALIGNMENT_TYPE.Center;
+                }
+                else {
+                    // HACK: align the rest of the fields by the culture.
+                    // field.Layout.XAlignment = this.layoutService.isRtl() ? X_ALIGNMENT_TYPE.Right : X_ALIGNMENT_TYPE.Left;
+                }
+            });
+        }
+        const fields = [];
+        controlFields.forEach((field, index) => {
+            const dataField = dataFields.filter((df) => df.ApiName === field.ApiName)[0];
+            if (!dataField) {
+                return;
+            }
+            // If current view is not table view and those fields are special.
+            if (this.layoutType !== 'table' &&
+                ((this.hasMenuFloatingOnOtherField &&
+                    this.menuField &&
+                    this.menuField.ApiName === field.ApiName) ||
+                    (this.indicatorsField &&
+                        this.indicatorsField.ApiName === field.ApiName) ||
+                    (this.hasCampaignField &&
+                        this.hasCampaignField.ApiName === field.ApiName))) {
+                return;
+            }
+            // Set type to link
+            if (index === 0 && this.firstFieldAsLink) {
+                dataField.FieldType = FIELD_TYPE.InternalLink;
+                // dataField.Value = this.getInternalLinkHref();
+            }
+            if (field.ApiName === 'ObjectMenu') {
+                dataField.Enabled = true;
+                // HACK : Until "Enabled" returns from the server, we set PepMenu to be
+                //        Disabled in cart on regular items and not campign items.
+            }
+            const customField = this.createBaseField(field, dataField);
+            fields.push(customField);
+        });
+        return fields.sort((f1, f2) => f1.row > f2.row
+            ? 1
+            : f1.row < f2.row
+                ? -1
+                : f1.col > f2.col
+                    ? 1
+                    : f1.col < f2.col
+                        ? -1
+                        : 0);
+    }
+    onFormValidationChanged(formValidationChange) {
+        this.formValidationChange.emit(formValidationChange);
+    }
+    onValueChanged(event) {
+        this.onFormValidationChanged(this.form.valid);
+        const formControl = this.getFormControlById(event.key);
+        const isValid = formControl ? formControl.valid : true;
+        // const isValid = true;
+        if (isValid) {
+            // Set it to false to disable all fields.
+            if (this.isInternal && this.layoutType === 'form') {
+                this.isLocked = true;
+            }
+            // Update the current field value.
+            const currentField = this.fields.find((f) => f.key === event.key);
+            if (currentField) {
+                currentField.formattedValue = currentField.value = event.value;
+            }
+            this.valueChange.emit({
+                id: this.data.UID.toString(),
+                uiObjectKey: this.data.Key,
+                key: event.key,
+                value: event.value,
+                controlType: event.controlType,
+            });
+        }
+    }
+    onClick(fieldClickEvent) {
+        const clickedUiControlField = this.data.Fields.filter((f) => f.ApiName === fieldClickEvent.key)[0];
+        const idType = this.data.Type ? this.data.Type.toString() : '';
+        if (clickedUiControlField) {
+            this.fieldClick.emit({
+                id: this.data.UID.toString(),
+                uiObjectKey: this.data.Key,
+                key: fieldClickEvent.key,
+                idType,
+                which: fieldClickEvent.eventWhich,
+                value: fieldClickEvent.value,
+                controlType: fieldClickEvent.controlType,
+                fieldType: clickedUiControlField.FieldType,
+                otherData: fieldClickEvent.otherData,
+            });
+        }
+        else {
+            // For other api names (like enter children etc).
+            this.fieldClick.emit({
+                id: this.data.UID.toString(),
+                uiObjectKey: this.data.Key,
+                key: fieldClickEvent.key,
+                idType,
+                which: fieldClickEvent.eventWhich,
+                value: fieldClickEvent.value,
+                controlType: fieldClickEvent.controlType,
+                otherData: fieldClickEvent.otherData,
+            });
+        }
+    }
+    // // This event is for handle the internal page events.
+    // onInternalFormFieldClicked(internalFormFieldClick: any): void {
+    //     this.internalFormFieldClick.emit(internalFormFieldClick);
+    // }
+    // // This event is for handle the internal page events.
+    // onInternalFormFieldChanged(internalFormFieldChange: any): void {
+    //     this.internalFormFieldChange.emit(internalFormFieldChange);
+    // }
+    // This event is for handle the related items change events.
+    onFormValueChanged(event) {
+        // this.valueChange.emit(event);
+    }
+    // This event is for handle the related items change events.
+    onFormFieldClick(event) {
+        this.fieldClick.emit(event);
+    }
+}
+PepInternalFormComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.2", ngImport: i0, type: PepInternalFormComponent, deps: [{ token: i1.PepDialogService }, { token: i2.PepCustomizationService }, { token: i2.PepLayoutService }, { token: i3.FormBuilder }, { token: i0.KeyValueDiffers }, { token: i4.TranslateService }], target: i0.ɵɵFactoryTarget.Component });
+PepInternalFormComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.0.2", type: PepInternalFormComponent, selector: "pep-internal-form", inputs: { isInternal: "isInternal", isReport: "isReport", layout: "layout", lockEvents: "lockEvents", canEditObject: "canEditObject", data: "data", lockFields: "lockFields", isActive: "isActive", layoutType: "layoutType", objectId: "objectId", parentId: "parentId", searchCode: "searchCode", showTitle: "showTitle", firstFieldAsLink: "firstFieldAsLink", checkForChanges: "checkForChanges" }, outputs: { valueChange: "valueChange", formValidationChange: "formValidationChange", fieldClick: "fieldClick" }, usesOnChanges: true, ngImport: i0, template: "<fieldset *ngIf=\"form\" [formGroup]=\"form\" [disabled]=\"isLocked\" class=\"pep-form\"\n    [ngStyle]=\"{ 'background-color': layoutType == 'card' && data?.BackgroundColor }\">\n    <!-- New Form -->\n    <mat-grid-list *ngIf=\"layoutType == 'form'\" [cols]=\"columns\" [rowHeight]=\"rowHeight + 'rem'\"\n        [gutterSize]=\"formGutterSize\">\n        <mat-grid-tile *ngFor=\"let field of fields$ | async\" [rowspan]=\"field.rowSpan\" [colspan]=\"field.colSpan\">\n            <pep-internal-field-generator *ngIf=\"field.controlType != 'placeholder'\" [form]=\"form\" [layoutType]=\"layoutType\"\n                [checkForChanges]=\"checkForChanges\" [uid]=\"data?.UID\" [field]=\"field\" [showTitle]=\"showTitle\"\n                (valueChange)=\"onValueChanged($event)\" (elementClick)=\"onClick($event)\"\n                (formValueChange)=\"onFormValueChanged($event)\" (formFieldClick)=\"onFormFieldClick($event)\"\n                >\n            </pep-internal-field-generator>\n            <!-- (formValidationChange)=\"onFormValidationChanged($event)\" -->\n        </mat-grid-tile>\n    </mat-grid-list>\n\n    <!-- Thumbnails -->\n    <mat-grid-list *ngIf=\"layoutType == 'card'\" [cols]=\"columns\" [rowHeight]=\"rowHeight + 'rem'\"\n        [gutterSize]=\"cardGutterSize\" class=\"card-spacing\">\n        <mat-grid-tile *ngFor=\"let field of fields$ | async\" [rowspan]=\"field.rowSpan\" [colspan]=\"field.colSpan\"\n            [ngStyle]=\"{ overflow: field.type == 'qs' ? 'unset' : 'hidden' }\">\n            <pep-internal-field-generator *ngIf=\"field.controlType != 'placeholder'\" [form]=\"form\" [layoutType]=\"layoutType\"\n                [ngClass]=\"{ 'lock-events': lockEvents }\" [isActive]=\"isActive\" [checkForChanges]=\"checkForChanges\"\n                [uid]=\"data?.UID\" [field]=\"field\" [showTitle]=\"showTitle\" (valueChange)=\"onValueChanged($event)\"\n                (elementClick)=\"onClick($event)\" (formValueChange)=\"onFormValueChanged($event)\" (formFieldClick)=\"onFormFieldClick($event)\">\n            </pep-internal-field-generator>\n        </mat-grid-tile>\n    </mat-grid-list>\n\n    <ng-container *ngIf=\"layoutType == 'table'\">\n        <ng-container *ngIf=\"isReport; then reportBlock; else notReportBlock\"></ng-container>\n        <ng-template #reportBlock>\n            <ng-container *ngTemplateOutlet=\"report\"></ng-container>\n        </ng-template>\n        <ng-template #notReportBlock>\n            <div *ngFor=\"let field of fields$ | async; let j = index\" class=\"pull-left flip table-cell \"\n                [ngClass]=\"['text-align-' + field.xAlignment]\" style=\"height: 100%\"\n                [ngStyle]=\"{ width: (layout?.ControlFields)[j]?.calcColumnWidthString}\">\n                <pep-internal-field-generator *ngIf=\"field.controlType != 'placeholder'\" [checkForChanges]=\"checkForChanges\"\n                    [uid]=\"data?.UID\" [field]=\"field\" [form]=\"form\" [layoutType]=\"layoutType\" [showTitle]=\"false\"\n                    (elementClick)=\"onClick($event)\" (valueChange)=\"onValueChanged($event)\"\n                    (formValueChange)=\"onFormValueChanged($event)\" (formFieldClick)=\"onFormFieldClick($event)\"\n                    [isActive]=\"isActive\">\n                </pep-internal-field-generator>\n            </div>\n        </ng-template>\n    </ng-container>\n\n    <!------- For testing ------------\n    {{ form.value | json }}\n    {{ form.valid }}\n    ---------------------------------->\n</fieldset>\n\n<ng-template #report>\n    <div *ngFor=\"let field of fields$ | async; let j = index\" class=\"pull-left flip pep-report-fields\"\n        [ngStyle]=\"{ width: (layout?.ControlFields)[j]?.calcColumnWidthString }\"\n        [ngClass]=\"['text-align-' + field.xAlignment]\">\n        <ng-container [ngSwitch]=\"field.controlType\">\n            <pep-image *ngSwitchCase=\"'image'\" [uid]=\"data?.UID\" [form]=\"form\" [key]=\"field.key\"\n                [src]=\"field.formattedValue\" [srcLarge]=\"field.value\" [options]=\"field.options\" [label]=\"field.label\"\n                [mandatory]=\"field.mandatory\" [disabled]=\"field.disabled\" [readonly]=\"field.readonly\"\n                [xAlignment]=\"field.xAlignment\" [rowSpan]=\"field.rowSpan\" [layoutType]=\"layoutType\"\n                (elementClick)=\"onClick($event)\">\n            </pep-image>\n\n            <pep-signature *ngSwitchCase=\"'signature'\" [form]=\"form\" [key]=\"field.key\" [src]=\"field.value\"\n                [label]=\"field.label\" [mandatory]=\"field.mandatory\" [disabled]=\"field.disabled\"\n                [readonly]=\"field.readonly\" [xAlignment]=\"field.xAlignment\" [rowSpan]=\"field.rowSpan\"\n                [layoutType]=\"layoutType\">\n            </pep-signature>\n\n            <pep-checkbox *ngSwitchCase=\"'checkbox'\" [form]=\"form\" [key]=\"field.key\"\n                [value]=\"(field.value | lowercase) == 'true' || field.value == '1' ? true : false\" [label]=\"field.label\"\n                [type]=\"field.type\" [mandatory]=\"field.mandatory\" [disabled]=\"field.disabled\"\n                [readonly]=\"field.readonly\" [xAlignment]=\"field.xAlignment\" [rowSpan]=\"field.rowSpan\"\n                [additionalValue]=\"field.additionalValue\" [layoutType]=\"layoutType\">\n            </pep-checkbox>\n\n            <pep-date *ngSwitchCase=\"'date'\" [form]=\"form\" [key]=\"field.key\" [value]=\"field.value\"\n                [label]=\"field.label\" [type]=\"field.type\"\n                [mandatory]=\"field.mandatory\" [disabled]=\"field.disabled\" [readonly]=\"field.readonly\"\n                [textColor]=\"field.textColor\" [xAlignment]=\"field.xAlignment\" [rowSpan]=\"field.rowSpan\"\n                [minValue]=\"field.minValue\" [maxValue]=\"field.maxValue\" [layoutType]=\"layoutType\">\n            </pep-date>\n\n            <pep-internal-button *ngSwitchCase=\"'button'\" [form]=\"form\" [key]=\"field.key\" [value]=\"field.value\"\n                [formattedValue]=\"field.formattedValue\" [label]=\"field.label\" [type]=\"field.type\"\n                [disabled]=\"field.disabled\" [readonly]=\"field.readonly\" [xAlignment]=\"field.xAlignment\"\n                [layoutType]=\"layoutType\" (elementClick)=\"onClick($event)\">\n            </pep-internal-button>\n\n            <pep-textarea *ngSwitchCase=\"'textarea'\" [form]=\"form\" [key]=\"field.key\" [value]=\"field.value\"\n                [label]=\"field.label\" [mandatory]=\"field.mandatory\" [disabled]=\"field.disabled\"\n                [readonly]=\"field.readonly\" [maxFieldCharacters]=\"field.maxFieldCharacters\"\n                [textColor]=\"field.textColor\" [xAlignment]=\"field.xAlignment\" [rowSpan]=\"field.rowSpan\"\n                [layoutType]=\"layoutType\">\n            </pep-textarea>\n\n            <pep-quantity-selector *ngSwitchCase=\"'qs'\" [id]=\"field.key\" [form]=\"form\" [key]=\"field.key\"\n                [value]=\"field.value\" [label]=\"field.label\" [type]=\"field.type\"\n                [mandatory]=\"field.mandatory\" [disabled]=\"field.disabled\" [readonly]=\"field.readonly\"\n                [textColor]=\"field.textColor\" [xAlignment]=\"field.xAlignment\" [rowSpan]=\"field.rowSpan\"\n                [layoutType]=\"layoutType\" (valueChange)=\"onValueChanged($event)\" (elementClick)=\"onClick($event)\">\n            </pep-quantity-selector>\n\n            <ng-container *ngSwitchDefault>\n                <ng-container *ngIf=\"field.formattedValue?.length > 0; then notEmptyBlock; else emptyBlock\">\n                </ng-container>\n                <ng-template #notEmptyBlock>\n                    <ng-container\n                        *ngIf=\"field.controlType === 'attachment' || field.type === 'link'; then linkBlock; else notLinkBlock\">\n                    </ng-container>\n                    <ng-template #linkBlock>\n                        <a [id]=\"field.key\" class=\"color-link body-sm pep-report-input readonly\"\n                            *ngIf=\"field.formattedValue != null\" title=\"{{ field.formattedValue }}\" target=\"_blank\"\n                            href=\"{{ field.value }}\">{{ field.formattedValue }}</a>\n                    </ng-template>\n                    <ng-template #notLinkBlock>\n                        <span [id]=\"field.key\" class=\"body-sm pep-report-input readonly\"\n                            title=\"{{ field.formattedValue }}\" [ngStyle]=\"{ color: field.textColor }\">{{\n                            field.formattedValue }}</span>\n                    </ng-template>\n                </ng-template>\n                <ng-template #emptyBlock>\n                    <span>&nbsp;</span>\n                </ng-template>\n            </ng-container>\n        </ng-container>\n    </div>\n</ng-template>", styles: [":host{display:grid}\n"], dependencies: [{ kind: "directive", type: i5.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i5.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i5.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "directive", type: i5.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { kind: "directive", type: i5.NgSwitch, selector: "[ngSwitch]", inputs: ["ngSwitch"] }, { kind: "directive", type: i5.NgSwitchCase, selector: "[ngSwitchCase]", inputs: ["ngSwitchCase"] }, { kind: "directive", type: i5.NgSwitchDefault, selector: "[ngSwitchDefault]" }, { kind: "directive", type: i3.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i3.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "component", type: i6.MatGridList, selector: "mat-grid-list", inputs: ["cols", "gutterSize", "rowHeight"], exportAs: ["matGridList"] }, { kind: "component", type: i6.MatGridTile, selector: "mat-grid-tile", inputs: ["rowspan", "colspan"], exportAs: ["matGridTile"] }, { kind: "component", type: i7.PepCheckboxComponent, selector: "pep-checkbox", inputs: ["key", "value", "label", "type", "mandatory", "disabled", "readonly", "xAlignment", "rowSpan", "additionalValue", "form", "isActive", "showTitle", "renderTitle", "layoutType", "visible"], outputs: ["valueChange"] }, { kind: "component", type: i8.PepDateComponent, selector: "pep-date", inputs: ["key", "value", "label", "type", "mandatory", "disabled", "readonly", "textColor", "xAlignment", "rowSpan", "visible", "minValue", "maxValue", "minDateValue", "maxDateValue", "form", "isActive", "showTitle", "renderTitle", "renderError", "renderSymbol", "layoutType"], outputs: ["valueChange"] }, { kind: "component", type: i9.PepImageComponent, selector: "pep-image", inputs: ["key", "srcLarge", "src", "options", "label", "mandatory", "disabled", "readonly", "xAlignment", "rowSpan", "indicatorsField", "menuField", "hasCampaignField", "visible", "form", "uid", "showTitle", "renderTitle", "layoutType", "isActive", "sizeLimitMB", "acceptImagesType", "handleActions", "hint"], outputs: ["chooseFile", "fileChange", "elementClick"] }, { kind: "component", type: i10.PepQuantitySelectorComponent, selector: "pep-quantity-selector", inputs: ["key", "value", "minFractionDigits", "maxFractionDigits", "label", "type", "mandatory", "disabled", "readonly", "textColor", "xAlignment", "rowSpan", "allowDecimal", "additionalValue", "notificationInfo", "visible", "form", "showTitle", "renderTitle", "layoutType", "isActive", "styleType", "isInFocus"], outputs: ["valueChange", "elementClick"] }, { kind: "component", type: i11.PepSignatureComponent, selector: "pep-signature", inputs: ["key", "src", "label", "mandatory", "disabled", "readonly", "xAlignment", "rowSpan", "signatureURL", "visible", "form", "showTitle", "renderTitle", "layoutType", "isActive", "handleActions"], outputs: ["chooseFile", "fileChange", "elementClick"] }, { kind: "component", type: i12.PepTextareaComponent, selector: "pep-textarea", inputs: ["key", "value", "label", "mandatory", "disabled", "readonly", "maxFieldCharacters", "textColor", "xAlignment", "rowSpan", "visible", "form", "isActive", "showTitle", "renderTitle", "layoutType"], outputs: ["valueChange", "keyup"] }, { kind: "component", type: i13.PepInternalFieldGeneratorComponent, selector: "pep-internal-field-generator", inputs: ["field", "isActive", "uid", "form", "layoutType", "showTitle", "checkForChanges"], outputs: ["valueChange", "elementClick", "formValueChange", "formFieldClick"] }, { kind: "component", type: i14.PepInternalButtonComponent, selector: "pep-internal-button", inputs: ["key", "value", "formattedValue", "label", "referenceObjectInternalType", "type", "mandatory", "disabled", "readonly", "xAlignment", "rowSpan", "visible", "form", "showTitle", "layoutType"], outputs: ["elementClick", "valueChange"] }, { kind: "pipe", type: i5.AsyncPipe, name: "async" }, { kind: "pipe", type: i5.LowerCasePipe, name: "lowercase" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.2", ngImport: i0, type: PepInternalFormComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'pep-internal-form', changeDetection: ChangeDetectionStrategy.OnPush, template: "<fieldset *ngIf=\"form\" [formGroup]=\"form\" [disabled]=\"isLocked\" class=\"pep-form\"\n    [ngStyle]=\"{ 'background-color': layoutType == 'card' && data?.BackgroundColor }\">\n    <!-- New Form -->\n    <mat-grid-list *ngIf=\"layoutType == 'form'\" [cols]=\"columns\" [rowHeight]=\"rowHeight + 'rem'\"\n        [gutterSize]=\"formGutterSize\">\n        <mat-grid-tile *ngFor=\"let field of fields$ | async\" [rowspan]=\"field.rowSpan\" [colspan]=\"field.colSpan\">\n            <pep-internal-field-generator *ngIf=\"field.controlType != 'placeholder'\" [form]=\"form\" [layoutType]=\"layoutType\"\n                [checkForChanges]=\"checkForChanges\" [uid]=\"data?.UID\" [field]=\"field\" [showTitle]=\"showTitle\"\n                (valueChange)=\"onValueChanged($event)\" (elementClick)=\"onClick($event)\"\n                (formValueChange)=\"onFormValueChanged($event)\" (formFieldClick)=\"onFormFieldClick($event)\"\n                >\n            </pep-internal-field-generator>\n            <!-- (formValidationChange)=\"onFormValidationChanged($event)\" -->\n        </mat-grid-tile>\n    </mat-grid-list>\n\n    <!-- Thumbnails -->\n    <mat-grid-list *ngIf=\"layoutType == 'card'\" [cols]=\"columns\" [rowHeight]=\"rowHeight + 'rem'\"\n        [gutterSize]=\"cardGutterSize\" class=\"card-spacing\">\n        <mat-grid-tile *ngFor=\"let field of fields$ | async\" [rowspan]=\"field.rowSpan\" [colspan]=\"field.colSpan\"\n            [ngStyle]=\"{ overflow: field.type == 'qs' ? 'unset' : 'hidden' }\">\n            <pep-internal-field-generator *ngIf=\"field.controlType != 'placeholder'\" [form]=\"form\" [layoutType]=\"layoutType\"\n                [ngClass]=\"{ 'lock-events': lockEvents }\" [isActive]=\"isActive\" [checkForChanges]=\"checkForChanges\"\n                [uid]=\"data?.UID\" [field]=\"field\" [showTitle]=\"showTitle\" (valueChange)=\"onValueChanged($event)\"\n                (elementClick)=\"onClick($event)\" (formValueChange)=\"onFormValueChanged($event)\" (formFieldClick)=\"onFormFieldClick($event)\">\n            </pep-internal-field-generator>\n        </mat-grid-tile>\n    </mat-grid-list>\n\n    <ng-container *ngIf=\"layoutType == 'table'\">\n        <ng-container *ngIf=\"isReport; then reportBlock; else notReportBlock\"></ng-container>\n        <ng-template #reportBlock>\n            <ng-container *ngTemplateOutlet=\"report\"></ng-container>\n        </ng-template>\n        <ng-template #notReportBlock>\n            <div *ngFor=\"let field of fields$ | async; let j = index\" class=\"pull-left flip table-cell \"\n                [ngClass]=\"['text-align-' + field.xAlignment]\" style=\"height: 100%\"\n                [ngStyle]=\"{ width: (layout?.ControlFields)[j]?.calcColumnWidthString}\">\n                <pep-internal-field-generator *ngIf=\"field.controlType != 'placeholder'\" [checkForChanges]=\"checkForChanges\"\n                    [uid]=\"data?.UID\" [field]=\"field\" [form]=\"form\" [layoutType]=\"layoutType\" [showTitle]=\"false\"\n                    (elementClick)=\"onClick($event)\" (valueChange)=\"onValueChanged($event)\"\n                    (formValueChange)=\"onFormValueChanged($event)\" (formFieldClick)=\"onFormFieldClick($event)\"\n                    [isActive]=\"isActive\">\n                </pep-internal-field-generator>\n            </div>\n        </ng-template>\n    </ng-container>\n\n    <!------- For testing ------------\n    {{ form.value | json }}\n    {{ form.valid }}\n    ---------------------------------->\n</fieldset>\n\n<ng-template #report>\n    <div *ngFor=\"let field of fields$ | async; let j = index\" class=\"pull-left flip pep-report-fields\"\n        [ngStyle]=\"{ width: (layout?.ControlFields)[j]?.calcColumnWidthString }\"\n        [ngClass]=\"['text-align-' + field.xAlignment]\">\n        <ng-container [ngSwitch]=\"field.controlType\">\n            <pep-image *ngSwitchCase=\"'image'\" [uid]=\"data?.UID\" [form]=\"form\" [key]=\"field.key\"\n                [src]=\"field.formattedValue\" [srcLarge]=\"field.value\" [options]=\"field.options\" [label]=\"field.label\"\n                [mandatory]=\"field.mandatory\" [disabled]=\"field.disabled\" [readonly]=\"field.readonly\"\n                [xAlignment]=\"field.xAlignment\" [rowSpan]=\"field.rowSpan\" [layoutType]=\"layoutType\"\n                (elementClick)=\"onClick($event)\">\n            </pep-image>\n\n            <pep-signature *ngSwitchCase=\"'signature'\" [form]=\"form\" [key]=\"field.key\" [src]=\"field.value\"\n                [label]=\"field.label\" [mandatory]=\"field.mandatory\" [disabled]=\"field.disabled\"\n                [readonly]=\"field.readonly\" [xAlignment]=\"field.xAlignment\" [rowSpan]=\"field.rowSpan\"\n                [layoutType]=\"layoutType\">\n            </pep-signature>\n\n            <pep-checkbox *ngSwitchCase=\"'checkbox'\" [form]=\"form\" [key]=\"field.key\"\n                [value]=\"(field.value | lowercase) == 'true' || field.value == '1' ? true : false\" [label]=\"field.label\"\n                [type]=\"field.type\" [mandatory]=\"field.mandatory\" [disabled]=\"field.disabled\"\n                [readonly]=\"field.readonly\" [xAlignment]=\"field.xAlignment\" [rowSpan]=\"field.rowSpan\"\n                [additionalValue]=\"field.additionalValue\" [layoutType]=\"layoutType\">\n            </pep-checkbox>\n\n            <pep-date *ngSwitchCase=\"'date'\" [form]=\"form\" [key]=\"field.key\" [value]=\"field.value\"\n                [label]=\"field.label\" [type]=\"field.type\"\n                [mandatory]=\"field.mandatory\" [disabled]=\"field.disabled\" [readonly]=\"field.readonly\"\n                [textColor]=\"field.textColor\" [xAlignment]=\"field.xAlignment\" [rowSpan]=\"field.rowSpan\"\n                [minValue]=\"field.minValue\" [maxValue]=\"field.maxValue\" [layoutType]=\"layoutType\">\n            </pep-date>\n\n            <pep-internal-button *ngSwitchCase=\"'button'\" [form]=\"form\" [key]=\"field.key\" [value]=\"field.value\"\n                [formattedValue]=\"field.formattedValue\" [label]=\"field.label\" [type]=\"field.type\"\n                [disabled]=\"field.disabled\" [readonly]=\"field.readonly\" [xAlignment]=\"field.xAlignment\"\n                [layoutType]=\"layoutType\" (elementClick)=\"onClick($event)\">\n            </pep-internal-button>\n\n            <pep-textarea *ngSwitchCase=\"'textarea'\" [form]=\"form\" [key]=\"field.key\" [value]=\"field.value\"\n                [label]=\"field.label\" [mandatory]=\"field.mandatory\" [disabled]=\"field.disabled\"\n                [readonly]=\"field.readonly\" [maxFieldCharacters]=\"field.maxFieldCharacters\"\n                [textColor]=\"field.textColor\" [xAlignment]=\"field.xAlignment\" [rowSpan]=\"field.rowSpan\"\n                [layoutType]=\"layoutType\">\n            </pep-textarea>\n\n            <pep-quantity-selector *ngSwitchCase=\"'qs'\" [id]=\"field.key\" [form]=\"form\" [key]=\"field.key\"\n                [value]=\"field.value\" [label]=\"field.label\" [type]=\"field.type\"\n                [mandatory]=\"field.mandatory\" [disabled]=\"field.disabled\" [readonly]=\"field.readonly\"\n                [textColor]=\"field.textColor\" [xAlignment]=\"field.xAlignment\" [rowSpan]=\"field.rowSpan\"\n                [layoutType]=\"layoutType\" (valueChange)=\"onValueChanged($event)\" (elementClick)=\"onClick($event)\">\n            </pep-quantity-selector>\n\n            <ng-container *ngSwitchDefault>\n                <ng-container *ngIf=\"field.formattedValue?.length > 0; then notEmptyBlock; else emptyBlock\">\n                </ng-container>\n                <ng-template #notEmptyBlock>\n                    <ng-container\n                        *ngIf=\"field.controlType === 'attachment' || field.type === 'link'; then linkBlock; else notLinkBlock\">\n                    </ng-container>\n                    <ng-template #linkBlock>\n                        <a [id]=\"field.key\" class=\"color-link body-sm pep-report-input readonly\"\n                            *ngIf=\"field.formattedValue != null\" title=\"{{ field.formattedValue }}\" target=\"_blank\"\n                            href=\"{{ field.value }}\">{{ field.formattedValue }}</a>\n                    </ng-template>\n                    <ng-template #notLinkBlock>\n                        <span [id]=\"field.key\" class=\"body-sm pep-report-input readonly\"\n                            title=\"{{ field.formattedValue }}\" [ngStyle]=\"{ color: field.textColor }\">{{\n                            field.formattedValue }}</span>\n                    </ng-template>\n                </ng-template>\n                <ng-template #emptyBlock>\n                    <span>&nbsp;</span>\n                </ng-template>\n            </ng-container>\n        </ng-container>\n    </div>\n</ng-template>", styles: [":host{display:grid}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.PepDialogService }, { type: i2.PepCustomizationService }, { type: i2.PepLayoutService }, { type: i3.FormBuilder }, { type: i0.KeyValueDiffers }, { type: i4.TranslateService }]; }, propDecorators: { isInternal: [{
+                type: Input
+            }], isReport: [{
+                type: Input
+            }], layout: [{
+                type: Input
+            }], lockEvents: [{
+                type: Input
+            }], canEditObject: [{
+                type: Input
+            }], data: [{
+                type: Input
+            }], lockFields: [{
+                type: Input
+            }], isActive: [{
+                type: Input
+            }], layoutType: [{
+                type: Input
+            }], objectId: [{
+                type: Input
+            }], parentId: [{
+                type: Input
+            }], searchCode: [{
+                type: Input
+            }], showTitle: [{
+                type: Input
+            }], firstFieldAsLink: [{
+                type: Input
+            }], checkForChanges: [{
+                type: Input
+            }], valueChange: [{
+                type: Output
+            }], formValidationChange: [{
+                type: Output
+            }], fieldClick: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"internal-form.component.js","sourceRoot":"","sources":["../../../../projects/ngx-lib/form/internal-form.component.ts","../../../../projects/ngx-lib/form/internal-form.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n    Component,\n    ChangeDetectionStrategy,\n    OnInit,\n    OnDestroy,\n    Input,\n    KeyValueDiffers,\n    Output,\n    EventEmitter,\n    OnChanges,\n    DoCheck,\n    Optional,\n} from '@angular/core';\nimport {\n    FormGroup,\n    FormBuilder,\n    Validators,\n    AbstractControl,\n} from '@angular/forms';\nimport { TranslateService } from '@ngx-translate/core';\nimport {\n    PepDialogService,\n    PepDialogData,\n} from '@pepperi-addons/ngx-lib/dialog';\nimport {\n    IPepFieldValueChangeEvent,\n    IPepFieldClickEvent,\n    PepLayoutType,\n    FIELD_TYPE,\n    PepCustomizationService,\n    PepLayoutService,\n    UIControl,\n    UIControlField,\n    ObjectsDataRow,\n    ObjectsDataRowCell,\n    PepFieldBase,\n    PepTextboxField,\n    PepSelectField,\n    PepInternalMenuField,\n    PepQuantitySelectorField,\n    PepAddressField,\n    PepIndicatorsField,\n    PepInternalPageField,\n    PepInternalCaruselField,\n    PepInternalButtonField,\n    PepAttachmentField,\n    PepSignatureField,\n    PepImageField,\n    PepImagesField,\n    PepLinkField,\n    PepTextareaField,\n    PepRichHtmlTextareaField,\n    PepDateField,\n    PepCheckboxField,\n    PepSeparatorField,\n    PepPlaceholderField,\n    PepHorizontalAlignment,\n    PepVerticalAlignment,\n    X_ALIGNMENT_TYPE,\n    Y_ALIGNMENT_TYPE,\n    DEFAULT_VERTICAL_ALIGNMENT,\n    DEFAULT_HORIZONTAL_ALIGNMENT,\n    KeyValuePair,\n    IPepOption,\n} from '@pepperi-addons/ngx-lib';\nimport { BehaviorSubject, Observable } from 'rxjs';\nimport { IPepFormFieldValueChangeEvent, IPepFormFieldClickEvent } from './form.model';\n\n@Component({\n    selector: 'pep-internal-form',\n    templateUrl: './internal-form.component.html',\n    styleUrls: ['./internal-form.component.scss'],\n    changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class PepInternalFormComponent implements OnInit, DoCheck, OnChanges, OnDestroy {\n    @Input() isInternal = true;\n    @Input() isReport = false;\n    @Input() layout: UIControl;\n    @Input() lockEvents = false;   \n    @Input() canEditObject = true;\n\n    private _data: ObjectsDataRow = null;\n    @Input()\n    set data(value: ObjectsDataRow) {\n        const shouldReload = this.shouldReloadForm || !this._data;\n        this._data = value;\n\n        if (shouldReload) {\n            this._shouldReloadForm = false;\n            this.initForm();\n        } else {\n            this.updateForm();\n        }\n    }\n    get data(): ObjectsDataRow {\n        return this._data;\n    }\n\n    @Input()\n    set lockFields(value: boolean) {\n        this.isLocked = value;\n    }\n\n    @Input() isActive = false;\n    @Input() layoutType: PepLayoutType = 'card';\n    // @Input() listType = '';\n    @Input() objectId = '0';\n    @Input() parentId = '0';\n    @Input() searchCode = '0';\n    @Input() showTitle = true;\n    @Input() firstFieldAsLink = false;\n    @Input() checkForChanges: any = null;\n\n    @Output()\n    valueChange: EventEmitter<IPepFormFieldValueChangeEvent> = new EventEmitter<IPepFormFieldValueChangeEvent>();\n    @Output()\n    formValidationChange: EventEmitter<boolean> = new EventEmitter<boolean>();\n\n    @Output()\n    fieldClick: EventEmitter<IPepFormFieldClickEvent> = new EventEmitter<IPepFormFieldClickEvent>();\n\n    // @Output() internalFormFieldClick: EventEmitter<any> = new EventEmitter<any>();\n    // @Output() internalFormFieldChange: EventEmitter<any> = new EventEmitter<any>();\n\n    isLocked = false;\n    formGutterSize;\n    cardGutterSize;\n    rowHeight;\n    // private matrixIsLast = false;\n    // lastUpdatedFieldApiName: string = '';\n    form: FormGroup;\n    differ: any;\n\n    // payLoad = '';\n    private rows: Array<PepFieldBase[]> = [];\n    fields: PepFieldBase[] = [];\n\n    private _fieldsSubject: BehaviorSubject<PepFieldBase[]> = new BehaviorSubject<PepFieldBase[]>([]);\n    get fields$(): Observable<PepFieldBase[]> {\n        return this._fieldsSubject.asObservable();\n    }\n\n    columns = 1;\n\n    private hasMenuFloatingOnOtherField = false;\n    private menuField: any;\n    private menuDataField: any;\n    private hasCampaignField: any;\n    private hasCampaignDataField: any;\n    private indicatorsField: any;\n    private indicatorsDataField: any = null;\n\n    private _shouldReloadForm = false;\n    get shouldReloadForm(): boolean {\n        return this._shouldReloadForm;\n    }\n\n    // eventServiceSub: Subscription;\n    // public jsonLib = JSON;\n\n    constructor(\n        private dialogService: PepDialogService,\n        private customizationService: PepCustomizationService,\n        private layoutService: PepLayoutService,\n        private fb: FormBuilder,\n        differs: KeyValueDiffers,\n        private translate: TranslateService\n    ) {\n        // store the initial value to compare with\n        this.differ = differs.find({}).create();\n    }\n\n    convertXAlignToHorizontalAlign(\n        xAlign: X_ALIGNMENT_TYPE\n    ): PepHorizontalAlignment {\n        let res = DEFAULT_HORIZONTAL_ALIGNMENT;\n\n        if (\n            xAlign === X_ALIGNMENT_TYPE.None ||\n            xAlign === X_ALIGNMENT_TYPE.Left\n        ) {\n            res = 'left';\n        } else if (xAlign === X_ALIGNMENT_TYPE.Right) {\n            res = 'right';\n        } else {\n            res = 'center';\n        }\n\n        return res;\n    }\n\n    convertYAlignToVerticalAlign(\n        yAlign: Y_ALIGNMENT_TYPE\n    ): PepVerticalAlignment {\n        let res = DEFAULT_VERTICAL_ALIGNMENT;\n\n        if (\n            yAlign === Y_ALIGNMENT_TYPE.None ||\n            yAlign === Y_ALIGNMENT_TYPE.Top\n        ) {\n            res = 'top';\n        } else if (yAlign === Y_ALIGNMENT_TYPE.Bottom) {\n            res = 'bottom';\n        } else {\n            res = 'middle';\n        }\n\n        return res;\n    }\n\n    convertOptionalValues(\n        optionalValues: Array<KeyValuePair<string>>\n    ): IPepOption[] {\n        if (optionalValues && optionalValues.length > 0) {\n            return optionalValues.map((ov) => {\n                return { key: ov.Key, value: ov.Value };\n            });\n        } else {\n            return [];\n        }\n    }\n\n    convertAddressFields(\n        controlField: UIControlField,\n        addressFields: Array<ObjectsDataRowCell>,\n        canEditObject: boolean\n    ): PepFieldBase[] {\n        const fields: PepFieldBase[] = [];\n\n        addressFields.forEach((field) => {\n            let customField: PepFieldBase;\n            const placeholder = field.ApiName;\n\n            if (field.ApiName.toLowerCase().indexOf('street') >= 0) {\n                customField = new PepTextboxField({\n                    key: field.ApiName,\n                    label: field.ApiName,\n                    type: 'text',\n                    placeholder,\n                    readonly: !canEditObject,\n                    disabled: !field.Enabled || !canEditObject,\n                    hidden: false,\n                    mandatory: false,\n                    value: field.Value,\n                    formattedValue: field.FormattedValue,\n                    row: 0,\n                    rowSpan: 1,\n                    col: 0,\n                    colSpan: 2,\n                    xAlignment: this.convertXAlignToHorizontalAlign(\n                        controlField.Layout.XAlignment\n                    ),\n                    yAlignment: this.convertYAlignToVerticalAlign(\n                        controlField.Layout.YAlignment\n                    ),\n                    order: 0,\n                });\n            } else if (field.ApiName.toLowerCase().indexOf('city') >= 0) {\n                customField = new PepTextboxField({\n                    key: field.ApiName,\n                    label: field.ApiName,\n                    type: 'text',\n                    placeholder,\n                    readonly: !canEditObject,\n                    disabled: !field.Enabled || !canEditObject,\n                    hidden: false,\n                    mandatory: false,\n                    value: field.Value,\n                    formattedValue: field.FormattedValue,\n                    row: 0,\n                    rowSpan: 1,\n                    col: 2,\n                    colSpan: 1,\n                    xAlignment: this.convertXAlignToHorizontalAlign(\n                        controlField.Layout.XAlignment\n                    ),\n                    yAlignment: this.convertYAlignToVerticalAlign(\n                        controlField.Layout.YAlignment\n                    ),\n                    order: 1,\n                });\n            } else if (field.ApiName.toLowerCase().indexOf('state') >= 0) {\n                customField = new PepSelectField({\n                    key: field.ApiName,\n                    label: field.ApiName,\n                    placeholder,\n                    options: this.convertOptionalValues(field.OptionalValues),\n                    readonly: !canEditObject,\n                    disabled: !field.Enabled || !canEditObject,\n                    hidden: false,\n                    mandatory: false,\n                    value: field.Value,\n                    formattedValue: field.FormattedValue,\n                    row: 1,\n                    rowSpan: 1,\n                    col: 0,\n                    colSpan: 1,\n                    xAlignment: this.convertXAlignToHorizontalAlign(\n                        controlField.Layout.XAlignment\n                    ),\n                    yAlignment: this.convertYAlignToVerticalAlign(\n                        controlField.Layout.YAlignment\n                    ),\n                    order: 2,\n                });\n            } else if (field.ApiName.toLowerCase().indexOf('zipcode') >= 0) {\n                customField = new PepTextboxField({\n                    key: field.ApiName,\n                    label: field.ApiName,\n                    type: 'text',\n                    placeholder,\n                    readonly: !canEditObject,\n                    disabled: !field.Enabled || !canEditObject,\n                    hidden: false,\n                    mandatory: false,\n                    value: field.Value,\n                    formattedValue: field.FormattedValue,\n                    row: 1,\n                    rowSpan: 1,\n                    col: 1,\n                    colSpan: 1,\n                    xAlignment: this.convertXAlignToHorizontalAlign(\n                        controlField.Layout.XAlignment\n                    ),\n                    yAlignment: this.convertYAlignToVerticalAlign(\n                        controlField.Layout.YAlignment\n                    ),\n                    order: 3,\n                });\n            } else if (field.ApiName.toLowerCase().indexOf('country') >= 0) {\n                customField = new PepSelectField({\n                    key: field.ApiName,\n                    label: field.ApiName,\n                    placeholder,\n                    options: this.convertOptionalValues(field.OptionalValues),\n                    readonly: !canEditObject,\n                    disabled: !field.Enabled || !canEditObject,\n                    hidden: false,\n                    mandatory: false,\n                    value: field.Value,\n                    formattedValue: field.FormattedValue,\n                    row: 2,\n                    rowSpan: 1,\n                    col: 2,\n                    colSpan: 1,\n                    xAlignment: this.convertXAlignToHorizontalAlign(\n                        controlField.Layout.XAlignment\n                    ),\n                    yAlignment: this.convertYAlignToVerticalAlign(\n                        controlField.Layout.YAlignment\n                    ),\n                    order: 4,\n                });\n            }\n\n            fields.push(customField);\n        });\n\n        return fields.sort((n1, n2) =>\n            n1.order > n2.order ? 1 : n1.order < n2.order ? -1 : 0\n        );\n    }\n\n    isMatrixField(apiNameToCheck: string): boolean {\n        return apiNameToCheck.indexOf('Matrix') >= 0;\n    }\n\n    doesFieldHavaFloatingField(\n        controlField: UIControlField,\n        floatingField: any\n    ): boolean {\n        let hasFloatingField = false;\n        if (\n            floatingField.Layout.Y >= controlField.Layout.Y &&\n            floatingField.Layout.Y <\n            controlField.Layout.Y + controlField.Layout.Height &&\n            floatingField.Layout.X >= controlField.Layout.X &&\n            floatingField.Layout.X <\n            controlField.Layout.X + controlField.Layout.Width\n        ) {\n            hasFloatingField = true;\n        }\n\n        return hasFloatingField;\n    }\n\n    getOptionsForCustomField(\n        controlField: UIControlField,\n        dataField: any,\n        canEditObject: boolean\n    ): any {\n        if (!controlField || !dataField) {\n            return;\n        }\n\n        const placeholder =\n            controlField.ReadOnly || !canEditObject ? '' : controlField.Title;\n\n        return {\n            key: controlField.ApiName,\n            label: controlField.Title,\n            accessory: dataField.Accessory,\n            placeholder,\n            readonly: controlField.ReadOnly || !canEditObject,\n            disabled: !dataField.Enabled || !canEditObject,\n            hidden: controlField.Hidden,\n            mandatory: controlField.Mandatory,\n            value: dataField.Value,\n            formattedValue: dataField.FormattedValue,\n            additionalValue: dataField.AdditionalValue,\n            row: controlField.Layout.Y,\n            rowSpan: controlField.Layout.Height,\n            col: controlField.Layout.X,\n            colSpan: controlField.Layout.Width,\n            xAlignment: this.convertXAlignToHorizontalAlign(\n                controlField.Layout.XAlignment\n            ),\n            yAlignment: this.convertYAlignToVerticalAlign(\n                controlField.Layout.YAlignment\n            ),\n            options: this.convertOptionalValues(dataField.OptionalValues),\n            groupFields: undefined,\n            maxFieldCharacters: controlField.MaxFieldCharacters,\n            minValue: controlField.MinValue,\n            maxValue: controlField.MaxValue,\n            // hasMenu: hasMenu,\n            // hasCampaign: hasCampaign,\n            // hasIndicators: hasIndicators,\n            textColor: dataField.TextColor,\n            visible: dataField.Visible,\n            digitsNumberAfterDecimalPoint: dataField.DigitsNumberAfterDecimalPoint,\n        };\n    }\n\n    convertToCustomField(\n        controlField: UIControlField,\n        dataField: any,\n        canEditObject: boolean,\n        menuField: any,\n        hasCampaignField: any,\n        indicatorsField: any,\n        objectId: any,\n        parentId: any,\n        searchCode: any\n    ): PepFieldBase {\n        let customField: PepFieldBase;\n        const options = this.getOptionsForCustomField(\n            controlField,\n            dataField,\n            canEditObject\n        );\n\n        if (controlField.ApiName === 'ObjectMenu') {\n            options.type = 'menu';\n            customField = new PepInternalMenuField(options);\n        } else if (\n            controlField.FieldType === FIELD_TYPE.NumberRealQuantitySelector ||\n            controlField.FieldType ===\n            FIELD_TYPE.NumberIntegerQuantitySelector ||\n            controlField.ApiName === 'QuantitySelector' ||\n            controlField.ApiName === 'UnitsQuantity' ||\n            controlField.ApiName.indexOf('size_') === 0\n        ) {\n            if (dataField.FieldType === FIELD_TYPE.InternalLink) {\n                options.type = 'button';\n            } else if (dataField.FieldType === FIELD_TYPE.Package) {\n                options.type = 'packageButton';\n            } else if (\n                dataField.FieldType === FIELD_TYPE.NumberRealQuantitySelector ||\n                dataField.FieldType === FIELD_TYPE.NumberReal\n            ) {\n                options.type = 'qs';\n                options.allowDecimal = true;\n            } else if (\n                dataField.FieldType ===\n                FIELD_TYPE.NumberIntegerQuantitySelector ||\n                dataField.FieldType === FIELD_TYPE.NumberInteger\n            ) {\n                options.type = 'qs';\n                options.allowDecimal = false;\n            } else if (\n                dataField.FieldType === FIELD_TYPE.NumberIntegerForMatrix\n            ) {\n                options.type = 'qsForMatrix';\n                options.allowDecimal = false;\n            } else if (dataField.FieldType === FIELD_TYPE.NumberRealForMatrix) {\n                options.type = 'qsForMatrix';\n                options.allowDecimal = true;\n            }\n\n            options.notificationInfo = dataField.NotificationInfo;\n            customField = new PepQuantitySelectorField(options);\n        } else {\n            // HACK: need to remove this..\n            if (\n                dataField.FieldType === FIELD_TYPE.Indicators &&\n                this.isMatrixField(dataField.ApiName)\n            ) {\n                dataField.FieldType = FIELD_TYPE.InternalPage;\n            }\n\n            switch (dataField.FieldType) {\n                case FIELD_TYPE.Address: {\n                    const canEditGroupObject = controlField.ReadOnly\n                        ? false\n                        : canEditObject;\n                    options.groupFields = this.convertAddressFields(\n                        controlField,\n                        dataField.GroupFields,\n                        canEditGroupObject\n                    );\n                    customField = new PepAddressField(options);\n                    break;\n                }\n                case FIELD_TYPE.Indicators: {\n                    // options['type'] = 'indicators'; // Not needed this is PepIndicatorsField.\n                    customField = new PepIndicatorsField(options);\n                    break;\n                }\n                case FIELD_TYPE.InternalPage: {\n                    if (this.isMatrixField(controlField.ApiName)) {\n                        options.rowSpan = controlField.Layout.Height;\n                        options.objectId = objectId;\n                        options.parentId = parentId;\n                        options.searchCode = searchCode;\n\n                        customField = new PepInternalPageField(options);\n                    } else {\n                        // Not supported\n                    }\n                    break;\n                }\n                case FIELD_TYPE.RelatedObjectsCards: {\n                    options.rowSpan = controlField.Layout.Height;\n                    options.searchCode = searchCode;\n                    options.pageInfo = dataField.UIPageInfo;\n\n                    customField = new PepInternalCaruselField(options);\n                    break;\n                }\n                case FIELD_TYPE.Link: {\n                    options.type = 'link';\n                    customField = new PepLinkField(options);\n                    break;\n                }\n                case FIELD_TYPE.InternalLink:\n                case FIELD_TYPE.Button: {\n                    options.type = 'button';\n                    customField = new PepInternalButtonField(options);\n                    break;\n                }\n                case FIELD_TYPE.Attachment: {\n                    // options.type = 'attachment';\n                    customField = new PepAttachmentField(options);\n                    break;\n                }\n                case FIELD_TYPE.Signature: {\n                    // options.type = 'signature';\n                    customField = new PepSignatureField(options);\n                    break;\n                }\n                case FIELD_TYPE.Image:\n                case FIELD_TYPE.ImageURL: {\n                    // options.type = 'image';\n                    options.menuField =\n                        menuField &&\n                            this.doesFieldHavaFloatingField(controlField, menuField)\n                            ? menuField\n                            : null;\n                    options.hasCampaignField =\n                        hasCampaignField &&\n                            this.doesFieldHavaFloatingField(\n                                controlField,\n                                hasCampaignField\n                            )\n                            ? hasCampaignField\n                            : null;\n                    options.indicatorsField =\n                        indicatorsField &&\n                            this.doesFieldHavaFloatingField(\n                                controlField,\n                                indicatorsField\n                            )\n                            ? indicatorsField\n                            : null;\n\n                    customField = new PepImageField(options);\n                    break;\n                }\n                case FIELD_TYPE.Images: {\n                    // options.type = 'images';\n                    customField = new PepImagesField(options);\n                    break;\n                }\n                case FIELD_TYPE.Email: {\n                    options.type = 'email';\n                    customField = new PepLinkField(options);\n                    break;\n                }\n                case FIELD_TYPE.Phone: {\n                    options.type = 'phone';\n                    customField = new PepLinkField(options);\n                    break;\n                }\n                case FIELD_TYPE.Duration: {\n                    options.type = 'duration';\n                    customField = new PepTextboxField(options);\n                    break;\n                }\n                case FIELD_TYPE.Default:\n                case FIELD_TYPE.TextBox:\n                case FIELD_TYPE.LimitedLengthTextBox:\n                case FIELD_TYPE.TextHeader:\n                case FIELD_TYPE.CalculatedString:\n                case FIELD_TYPE.MapDataString: {\n                    customField = new PepTextboxField(options);\n                    break;\n                }\n                case FIELD_TYPE.TextArea: {\n                    customField = new PepTextareaField(options);\n                    break;\n                }\n\n                case FIELD_TYPE.RichTextHTML: {\n                    customField = new PepRichHtmlTextareaField(options);\n                    break;\n                }\n                case FIELD_TYPE.Date:\n                case FIELD_TYPE.LimitedDate:\n                case FIELD_TYPE.CalculatedDate:\n                case FIELD_TYPE.DateAndTime: {\n                    options.type =\n                        dataField.FieldType === FIELD_TYPE.DateAndTime\n                            ? 'datetime'\n                            : 'date';\n                    customField = new PepDateField(options);\n                    break;\n                }\n                case FIELD_TYPE.NumberInteger:\n                case FIELD_TYPE.CalculatedInt:\n                case FIELD_TYPE.MapDataInt: {\n                    options.type = 'int';\n                    customField = new PepTextboxField(options);\n                    break;\n                }\n                case FIELD_TYPE.Percentage: {\n                    options.type = 'percentage';\n                    customField = new PepTextboxField(options);\n                    break;\n                }\n                case FIELD_TYPE.Currency: {\n                    options.type = 'currency';\n                    customField = new PepTextboxField(options);\n                    break;\n                }\n                case FIELD_TYPE.NumberReal:\n                case FIELD_TYPE.CalculatedReal:\n                case FIELD_TYPE.MapDataReal:\n                case FIELD_TYPE.Sum:\n                case FIELD_TYPE.Totals: {\n                    options.type = 'real';\n                    customField = new PepTextboxField(options);\n                    break;\n                }\n                case FIELD_TYPE.Boolean:\n                case FIELD_TYPE.CalculatedBool: {\n                    customField = new PepCheckboxField(options);\n                    break;\n                }\n                case FIELD_TYPE.BooleanText: {\n                    options.type = 'booleanText';\n                    customField = new PepCheckboxField(options);\n                    break;\n                }\n                case FIELD_TYPE.ComboBox:\n                case FIELD_TYPE.EmptyComboBox:\n                case FIELD_TYPE.MapDataDropDown: {\n                    // options.type = 'select';\n                    customField = new PepSelectField(options);\n                    break;\n                }\n                case FIELD_TYPE.MultiTickBox:\n                case FIELD_TYPE.MultiTickBoxToComboBox:\n                case FIELD_TYPE.EmptyMultiTickBox: {\n                    options.type = 'multi';\n                    customField = new PepSelectField(options);\n                    break;\n                }\n                case FIELD_TYPE.GuidReferenceType: {\n                    options.type = 'reference';\n                    options.referenceObjectType = dataField.ReferenceObjectType;\n                    options.referenceObjectSubType =\n                        dataField.ReferenceObjectSubType;\n                    options.referenceObjectInternalType =\n                        dataField.ReferenceObjectInternalType;\n                    customField = new PepInternalButtonField(options);\n                    break;\n                }\n                case FIELD_TYPE.ListOfObjects: {\n                    options.type = 'listofobjects';\n                    customField = new PepInternalButtonField(options);\n                    break;\n                }\n                case FIELD_TYPE.Separator: {\n                    customField = new PepSeparatorField(options);\n                    break;\n                }\n                /*\n                    case FIELD_TYPE.Images: return that.field(value);\n                */\n                case FIELD_TYPE.NumberRealQuantitySelector:\n                case FIELD_TYPE.NumberIntegerQuantitySelector: {\n                    options.type = 'qs';\n                    options.allowDecimal =\n                        dataField.FieldType ===\n                        FIELD_TYPE.NumberRealQuantitySelector;\n                    options.notificationInfo = dataField.NotificationInfo;\n\n                    customField = new PepQuantitySelectorField(options);\n                    break;\n                }\n                case FIELD_TYPE.Package: {\n                    options.type = 'packageButton';\n                    options.notificationInfo = dataField.NotificationInfo;\n\n                    customField = new PepQuantitySelectorField(options);\n                    break;\n                }\n            }\n        }\n\n        if (!customField) {\n            options.label = controlField.ApiName + ' is not supported!!!';\n            customField = new PepSeparatorField(options);\n        }\n\n        return customField;\n    }\n\n    getFieldFormattedValue(field: PepFieldBase): string {\n        let fieldFormattedValue = field.formattedValue || field.value;\n\n        // Fix for the custom check box component.\n        if (field.controlType === 'checkbox') {\n            fieldFormattedValue = fieldFormattedValue === 'true';\n        }\n\n        // Fix for the custom button component.\n        if (field.controlType === 'button') {\n            fieldFormattedValue =\n                fieldFormattedValue === '0' ? '' : fieldFormattedValue;\n        }\n\n        return fieldFormattedValue;\n    }\n\n    private toControlGroup(fields: PepFieldBase[]): FormGroup {\n        const group = {};\n        if (fields && fields.length > 0) {\n            fields.forEach((field) => {\n                if (field.groupFields && field.groupFields.length > 0) {\n                    const subGroup = {};\n\n                    field.groupFields.forEach((groupField) => {\n                        if (\n                            groupField.mandatory &&\n                            !field.readonly &&\n                            !field.disabled\n                        ) {\n                            subGroup[groupField.key] = [\n                                {\n                                    value: groupField.formattedValue || '',\n                                    disabled:\n                                        field.readonly ||\n                                        field.disabled ||\n                                        groupField.disabled,\n                                },\n                                [Validators.required],\n                            ];\n                        } else {\n                            subGroup[groupField.key] = [\n                                {\n                                    value: groupField.formattedValue || '',\n                                    disabled:\n                                        field.readonly ||\n                                        field.disabled ||\n                                        groupField.disabled,\n                                },\n                                [Validators.nullValidator],\n                            ];\n                        }\n                    });\n\n                    group[field.key] = this.fb.group(subGroup);\n                } else {\n                    const validators = field.getValidators();\n                    const fieldFormattedValue = this.getFieldFormattedValue(\n                        field\n                    );\n\n                    group[field.key] = [\n                        {\n                            value: fieldFormattedValue || '',\n                            disabled: field.disabled,\n                        },\n                        validators,\n                    ];\n                }\n            });\n        }\n\n        return this.fb.group(group);\n    }\n\n    private createBaseField(uiControlField: UIControlField, dataField: any) {\n        const customField: PepFieldBase = this.convertToCustomField(\n            uiControlField,\n            dataField,\n            this.canEditObject,\n            this.menuDataField,\n            this.hasCampaignDataField,\n            this.indicatorsDataField,\n            this.objectId,\n            this.parentId,\n            this.searchCode\n        );\n\n        return customField;\n    }\n\n    public showFormValidationMessage(): void {\n        const fields: PepFieldBase[] = this.fields;\n        let emptyMandatoryFieldsMsg = '';\n        let notValidFieldsMsg = '';\n\n        // for (let i: number = 0; i < fields.length; i++) {\n        //     let field = fields[i];\n        for (const field of fields) {\n            const formControl = this.form && this.form.get(field.key);\n\n            if (formControl) {\n                // Mandatory is empty.\n                if (\n                    field.mandatory &&\n                    formControl.value.toString().trim().length === 0\n                ) {\n                    emptyMandatoryFieldsMsg +=\n                        '<li><small>' + field.label + '</small></li>';\n                } else if (!field.disabled && !formControl.valid) {\n                    notValidFieldsMsg +=\n                        '<li><small>' + field.label + '</small></li>';\n                }\n            }\n        }\n\n        // Add the header message of the empty mandatory fields\n        if (emptyMandatoryFieldsMsg.length > 0) {\n            emptyMandatoryFieldsMsg =\n                '<div>' +\n                this.translate.instant('MESSAGES.ERROR_MANDATORY_FIELDS') +\n                \"</div><ul style='padding: 0 20px;'>\" +\n                emptyMandatoryFieldsMsg +\n                '</ul><br/>';\n        }\n\n        // Add the header message of the empty mandatory fields\n        if (notValidFieldsMsg.length > 0) {\n            notValidFieldsMsg =\n                '<div>' +\n                this.translate.instant('MESSAGES.ERROR_INVALID_FIELDS') +\n                \"</div><ul style='padding: 0 20px;'>\" +\n                notValidFieldsMsg +\n                '</ul>';\n        }\n\n        const title = this.translate.instant('MESSAGES.TITLE_NOTICE');\n        const data = new PepDialogData({\n            title,\n            content: emptyMandatoryFieldsMsg + notValidFieldsMsg,\n        });\n        this.dialogService.openDefaultDialog(data);\n    }\n\n    ngOnInit(): void {\n        const themeVars = this.customizationService.getThemeVariables();\n        // convert rem to pixel\n        const RemToPixel = 16;\n        this.formGutterSize =\n            this.customizationService.getNumberThemeVariable(\n                themeVars,\n                PepCustomizationService.FORM_SPACEING_KEY\n            ) * RemToPixel;\n        this.cardGutterSize =\n            this.customizationService.getNumberThemeVariable(\n                themeVars,\n                PepCustomizationService.CARD_SPACEING_KEY\n            ) * RemToPixel;\n    }\n\n    ngDoCheck(): void {\n        const changes = this.differ.diff(this.data); // check for changes\n        if (changes) {\n            this.updateForm();\n            this.checkForChanges = new Date();\n        }\n    }\n\n    ngOnChanges(changes): void {\n        // if (changes.data && changes.data.currentValue) {\n        //     // Load changes\n        //     if (!this.shouldReloadForm && changes.data.previousValue) {\n        //         this.data = changes.data.currentValue;\n        //         this.updateForm();\n        //     } else {\n        //         this._shouldReloadForm = false;\n        //         this.initForm();\n        //     }\n        // }\n        // if (this.shouldReloadForm || !changes?.data?.previousValue) {\n        //     this._shouldReloadForm = false;\n        //     this.initForm();\n        //     this.checkForChanges = new Date();\n        // }\n    }\n\n    ngOnDestroy(): void {\n        //\n    }\n\n    getUiControlFields(): Array<UIControlField> {\n        return this.layout ? this.layout.ControlFields : [];\n    }\n\n    initFieldsStructure(fields: PepFieldBase[], maxRow: number): void {\n        const themeVars = this.customizationService.getThemeVariables();\n\n        // Set form row height.\n        if (this.layoutType === 'card') {\n            const cardFieldHeight = this.customizationService.getNumberThemeVariable(\n                themeVars,\n                PepCustomizationService.CARD_FIELD_HEIGHT_KEY\n            );\n            this.rowHeight = cardFieldHeight;\n        } else {\n            const rowFieldHeight = this.customizationService.getNumberThemeVariable(\n                themeVars,\n                PepCustomizationService.FORM_FIELD_HEIGHT_KEY\n            );\n            const rowFieldTitleHeight = this.customizationService.getNumberThemeVariable(\n                themeVars,\n                PepCustomizationService.FORM_FIELD_TITLE_HEIGHT_KEY\n            );\n            this.rowHeight = rowFieldHeight + rowFieldTitleHeight;\n        }\n\n        // Create the fields structure (the fields must be sorted!!!).\n        if (fields.length > 0) {\n            // Init the layout.\n            if (\n                // this.layoutType === 'form' ||\n                this.layoutType === 'table'\n            ) {\n                this.fields = fields;\n                this._fieldsSubject.next(fields);\n\n                this.rows = [];\n\n                for (let i = 0; i <= maxRow; i++) {\n                    this.rows[i] = [];\n                }\n\n                // for (let i = 0; i < fields.length; i++) {\n                // const field = fields[i]\n                for (const field of fields) {\n                    this.rows[field.row].push(field);\n                }\n            } else {\n                const doesfieldExistIn: boolean[][] = new Array(maxRow);\n\n                for (let i = 0; i < doesfieldExistIn.length; i++) {\n                    doesfieldExistIn[i] = new Array(this.columns);\n\n                    for (let j = 0; j < doesfieldExistIn[i].length; j++) {\n                        doesfieldExistIn[i][j] = false;\n                    }\n                }\n\n                // Run in squere (row - colspan, col - rowspan) and put true where it should.\n                // for (let index = 0; index < fields.length; index++) {\n                //     const currentField = fields[index];\n                for (const currentField of fields) {\n                    if (currentField.rowSpan > 1) {\n                        for (\n                            let row: number = currentField.row;\n                            row < currentField.row + currentField.rowSpan;\n                            row++\n                        ) {\n                            if (currentField.colSpan > 1) {\n                                for (\n                                    let col: number = currentField.col;\n                                    col <\n                                    currentField.col + currentField.colSpan;\n                                    col++\n                                ) {\n                                    if (\n                                        doesfieldExistIn.length > row &&\n                                        doesfieldExistIn[0].length > col\n                                    ) {\n                                        doesfieldExistIn[row][col] = true;\n                                    }\n                                }\n                            } else {\n                                if (\n                                    doesfieldExistIn.length > row &&\n                                    doesfieldExistIn[0].length >\n                                    currentField.col\n                                ) {\n                                    doesfieldExistIn[row][\n                                        currentField.col\n                                    ] = true;\n                                }\n                            }\n                        }\n                    } else if (currentField.colSpan > 1) {\n                        for (\n                            let col: number = currentField.col;\n                            col < currentField.col + currentField.colSpan;\n                            col++\n                        ) {\n                            if (\n                                doesfieldExistIn.length > currentField.row &&\n                                doesfieldExistIn[0].length > col\n                            ) {\n                                doesfieldExistIn[currentField.row][col] = true;\n                            }\n                        }\n                    } else {\n                        if (\n                            doesfieldExistIn.length > currentField.row &&\n                            doesfieldExistIn[0].length > currentField.col\n                        ) {\n                            doesfieldExistIn[currentField.row][\n                                currentField.col\n                            ] = true;\n                        }\n                    }\n                }\n\n                // Create empty fields where doesfieldExistIn is false (For the md-grid-list UI Component).\n                for (let i = 0; i < doesfieldExistIn.length; i++) {\n                    for (let j = 0; j < doesfieldExistIn[i].length; j++) {\n                        if (!doesfieldExistIn[i][j]) {\n                            // Create empty field and add it to the fields list.\n                            fields.push(\n                                new PepPlaceholderField({\n                                    key: i + '_' + j,\n                                    label: '',\n                                    placeholder: '',\n                                    readonly: false,\n                                    disabled: false,\n                                    hidden: false,\n                                    mandatory: false,\n                                    value: '',\n                                    formattedValue: '',\n                                    row: i,\n                                    rowSpan: 1,\n                                    col: j,\n                                    colSpan: 1,\n                                    order: 1,\n                                })\n                            );\n                        }\n                    }\n                }\n\n                // Sort the fields again.\n                this.fields = fields.sort((f1, f2) =>\n                    f1.row > f2.row\n                        ? 1\n                        : f1.row < f2.row\n                            ? -1\n                            : f1.col > f2.col\n                                ? 1\n                                : f1.col < f2.col\n                                    ? -1\n                                    : 0\n                );\n                this._fieldsSubject.next(fields);\n            }\n        }\n    }\n\n    setForm(isForUpdate = false): void {\n        let allFieldsAreReadOnly = true;\n\n        if (!isForUpdate) {\n            const fields = [];\n            for (const currentField of this.fields) {\n                // Add all fields except 'internalPage' (for children).\n                if (currentField.controlType !== 'internalPage') {\n                    fields.push(currentField);\n                }\n\n                if (!currentField.readonly) {\n                    allFieldsAreReadOnly = false;\n                }\n            }\n\n            this.form = this.toControlGroup(fields);\n        } else {\n            // Update form values if changed by calculated fields.\n            for (let i = 0; i < this.fields.length; i++) {\n                let currentField = this.fields[i];\n\n                if (currentField.controlType === 'internalCarusel') {\n                    // Hack to override (update) the field.\n                    const uiControlField = this.getUiControlFields().find(cf => cf.ApiName === currentField.key);\n                    const dataField = this.data.Fields.find(df => df.ApiName === currentField.key);\n                    currentField = this.createBaseField(uiControlField, dataField);\n                    this._fieldsSubject.value[i] = currentField;\n                } else if (currentField.controlType !== 'internalPage') {\n                    if (\n                        currentField.groupFields &&\n                        currentField.groupFields.length > 0\n                    ) {\n                        // for (let j = 0; j < currentField.groupFields.length; j++) {\n                        //     let currentGroupField = currentField.groupFields[j];\n                        for (const currentGroupField of currentField.groupFields) {\n                            const fieldFormattedValue = this.getFieldFormattedValue(\n                                currentGroupField\n                            );\n                            this.customizationService.updateFormField(\n                                this.form,\n                                currentGroupField,\n                                fieldFormattedValue,\n                                currentField\n                            );\n                        }\n                    } else {\n                        const fieldFormattedValue = this.getFieldFormattedValue(\n                            currentField\n                        );\n                        // this.form.controls[currentField.key].setValue(fieldFormattedValue);\n                        this.customizationService.updateFormField(\n                            this.form,\n                            currentField,\n                            fieldFormattedValue\n                        );\n                    }\n                }\n\n                if (!currentField.readonly) {\n                    allFieldsAreReadOnly = false;\n                }\n            }\n        }\n\n        let isFormValid = this.form?.valid;\n\n        // Change validation to true if all fields are read only.\n        if (!isFormValid && allFieldsAreReadOnly) {\n            isFormValid = true;\n        }\n\n        this.onFormValidationChanged(isFormValid);\n\n        // Set it to false to enable all fields.\n        if (this.isInternal && this.isLocked) {\n            this.isLocked = false; \n        }\n    }\n\n    initForm(): void {\n        if (this.data && this.data.Fields) {\n            const fields: PepFieldBase[] = this.convertCustomFields(\n                this.getUiControlFields(),\n                this.data.Fields\n            );\n\n            const maxRow = Math.max(\n                ...fields.map((f) => {\n                    return f.row + f.rowSpan;\n                })\n            );\n            this.columns = Math.max(\n                ...fields.map((f) => {\n                    return f.col + f.colSpan;\n                })\n            );\n\n            this.initFieldsStructure(fields, maxRow);\n            this.setForm();\n        }\n    }\n\n    private updateField(\n        customField: PepFieldBase,\n        updatedField: ObjectsDataRowCell\n    ): void {\n        const options: any = {\n            disabled: !updatedField.Enabled || !this.canEditObject,\n            readonly: !updatedField.Enabled || !this.canEditObject,\n            visible: updatedField.Visible,\n            value: updatedField.Value,\n            additionalValue: updatedField.AdditionalValue,\n            formattedValue: updatedField.FormattedValue,\n            textColor: updatedField.TextColor,\n            digitsNumberAfterDecimalPoint: updatedField.DigitsNumberAfterDecimalPoint,\n        };\n\n        if (customField instanceof PepQuantitySelectorField) {\n            const notificationInfo = updatedField.NotificationInfo;\n            options.notificationInfo = notificationInfo;\n\n            // Change type if it's change (only for allowDecimal).\n            let allowDecimal = false;\n            if (updatedField.FieldType === FIELD_TYPE.NumberRealQuantitySelector ||\n                updatedField.FieldType === FIELD_TYPE.NumberReal ||\n                updatedField.FieldType === FIELD_TYPE.NumberRealForMatrix\n            ) {\n                allowDecimal = true;\n            } \n            \n            options.allowDecimal = allowDecimal;\n\n        } else if (customField instanceof PepSelectField) {\n            options.options = this.convertOptionalValues(\n                updatedField.OptionalValues\n            );\n\n            if (!options.options || options.options.length === 0) {\n                options.options.push({\n                    key: options.value,\n                    value: options.formattedValue,\n                });\n            }\n        } else if (customField instanceof PepInternalCaruselField) {\n            options.pageInfo = updatedField.UIPageInfo;\n        }\n\n        customField.update(options);\n    }\n\n    updateForm(): void {\n        if (this.data && this.data.Fields) {\n            for (const currentField of this.data.Fields) {\n                const customField = this.fields.filter(\n                    (f) => f.key === currentField.ApiName\n                )[0];\n                // Update all fields except 'internalPage' type (for children).\n                if (customField && customField.controlType !== 'internalPage') {\n                    this.updateField(customField, currentField);\n\n                    // Update the group fields.\n                    if (\n                        customField.controlType === 'address' &&\n                        currentField.GroupFields\n                    ) {\n                        // for (let j = 0; j < currentField.GroupFields.length; j++) {\n                        // let currentGroupField = currentField.GroupFields[j];\n                        for (const currentGroupField of currentField.GroupFields) {\n                            currentGroupField.Enabled = !currentField.Enabled\n                                ? false\n                                : currentGroupField.Enabled;\n\n                            const customGroupField = customField.groupFields.filter(\n                                (f) => f.key === currentGroupField.ApiName\n                            )[0];\n                            this.updateField(\n                                customGroupField,\n                                currentGroupField\n                            );\n                        }\n                    }\n                }\n            }\n\n            this.setForm(true);\n        }\n    }\n\n    public ReloadForm(): void {\n        this._shouldReloadForm = true;\n    }\n\n    // onSubmit() {\n    //     if (this.form.valid) {\n    //         this.payLoad = JSON.stringify(this.form.value);\n    //         //this.submitted.emit(this.form.value);\n    //     }\n    // }\n\n    private getFormControlById(key: string): AbstractControl | null {\n        let formControl = null;\n\n        this.fields.forEach((field) => {\n            if (field.key === key) {\n                formControl = this.form.get(field.key);\n                return;\n            } else if (field.groupFields && field.groupFields.length > 0) {\n                field.groupFields.forEach((groupField) => {\n                    if (groupField.key === key) {\n                        formControl = this.form.get(\n                            field.key + '.' + groupField.key\n                        );\n                        return;\n                    }\n                });\n            }\n        });\n\n        return formControl;\n    }\n\n    private setSpecialFields(\n        controlFields: Array<any>,\n        dataFields: Array<any>\n    ): void {\n        // let cf;\n        // for (let index = 0; index < controlFields.length; index++) {\n        //     cf = controlFields[index];\n        for (const cf of controlFields) {\n            if (cf.ApiName === 'ObjectMenu') {\n                this.menuField = cf;\n            } else if (cf.ApiName === 'ItemHasActiveCampaign') {\n                this.hasCampaignField = cf;\n            } else if (cf.ApiName === 'ItemIndicatorsWithoutCampaign') {\n                this.indicatorsField = cf;\n            }\n        }\n\n        // let df;\n        // for (let index = 0; index < dataFields.length; index++) {\n        //     df = dataFields[index];\n        for (const df of dataFields) {\n            if (df.ApiName === 'ObjectMenu') {\n                this.menuDataField = df;\n            } else if (df.ApiName === 'ItemHasActiveCampaign') {\n                this.hasCampaignDataField = df;\n            } else if (df.ApiName === 'ItemIndicatorsWithoutCampaign') {\n                this.indicatorsDataField = df;\n            }\n        }\n\n        if (this.menuField && this.menuDataField) {\n            this.menuDataField.Layout = this.menuField.Layout;\n        }\n\n        if (this.hasCampaignField && this.hasCampaignDataField) {\n            this.hasCampaignDataField.Layout = this.hasCampaignField.Layout;\n        }\n\n        if (this.indicatorsField && this.indicatorsDataField) {\n            this.indicatorsDataField.Layout = this.indicatorsField.Layout;\n        }\n\n        // Check if menu is floating on other field.\n        // for (let index = 0; index < controlFields.length; index++) {\n        //     cf = controlFields[index];\n        for (const cf of controlFields) {\n            if (this.menuField && cf.ApiName !== 'ObjectMenu') {\n                this.hasMenuFloatingOnOtherField = this.doesFieldHavaFloatingField(\n                    cf,\n                    this.menuField\n                );\n\n                if (this.hasMenuFloatingOnOtherField) {\n                    break;\n                }\n            }\n        }\n    }\n\n    convertCustomFields(\n        controlFields: Array<any>,\n        dataFields: Array<any>\n    ): PepFieldBase[] {\n        if (this.layoutType !== 'table') {\n            this.setSpecialFields(controlFields, dataFields);\n        } else {\n            // HACK: convert to center alignment if table view & special fields)\n            controlFields.forEach((field, index) => {\n                if (\n                    field.ApiName === 'UnitsQuantity' ||\n                    field.ApiName === 'QuantitySelector' ||\n                    field.ApiName === 'ObjectMenu' ||\n                    field.FieldType === FIELD_TYPE.Image ||\n                    field.FieldType === FIELD_TYPE.ImageURL ||\n                    field.FieldType === FIELD_TYPE.Indicators ||\n                    field.FieldType === FIELD_TYPE.Boolean ||\n                    field.FieldType === FIELD_TYPE.CalculatedBool ||\n                    field.FieldType === FIELD_TYPE.Signature ||\n                    field.FieldType ===\n                    FIELD_TYPE.NumberIntegerQuantitySelector ||\n                    field.FieldType === FIELD_TYPE.NumberRealQuantitySelector ||\n                    field.FieldType === FIELD_TYPE.Package ||\n                    field.FieldType === FIELD_TYPE.NumberIntegerForMatrix ||\n                    field.FieldType === FIELD_TYPE.NumberRealForMatrix\n                ) {\n                    field.Layout.XAlignment = X_ALIGNMENT_TYPE.Center;\n                } else {\n                    // HACK: align the rest of the fields by the culture.\n                    // field.Layout.XAlignment = this.layoutService.isRtl() ? X_ALIGNMENT_TYPE.Right : X_ALIGNMENT_TYPE.Left;\n                }\n            });\n        }\n\n        const fields: PepFieldBase[] = [];\n\n        controlFields.forEach((field, index) => {\n            const dataField = dataFields.filter(\n                (df) => df.ApiName === field.ApiName\n            )[0];\n\n            if (!dataField) {\n                return;\n            }\n\n            // If current view is not table view and those fields are special.\n            if (\n                this.layoutType !== 'table' &&\n                ((this.hasMenuFloatingOnOtherField &&\n                    this.menuField &&\n                    this.menuField.ApiName === field.ApiName) ||\n                    (this.indicatorsField &&\n                        this.indicatorsField.ApiName === field.ApiName) ||\n                    (this.hasCampaignField &&\n                        this.hasCampaignField.ApiName === field.ApiName))\n            ) {\n                return;\n            }\n\n            // Set type to link\n            if (index === 0 && this.firstFieldAsLink) {\n                dataField.FieldType = FIELD_TYPE.InternalLink;\n                // dataField.Value = this.getInternalLinkHref();\n            }\n\n            if (field.ApiName === 'ObjectMenu') {\n                dataField.Enabled = true;\n                // HACK : Until \"Enabled\" returns from the server, we set PepMenu to be\n                //        Disabled in cart on regular items and not campign items.\n            }\n            const customField: PepFieldBase = this.createBaseField(field, dataField);\n            fields.push(customField);\n        });\n\n        return fields.sort((f1, f2) =>\n            f1.row > f2.row\n                ? 1\n                : f1.row < f2.row\n                    ? -1\n                    : f1.col > f2.col\n                        ? 1\n                        : f1.col < f2.col\n                            ? -1\n                            : 0\n        );\n    }\n\n    private onFormValidationChanged(formValidationChange: any): void {\n        this.formValidationChange.emit(formValidationChange);\n    }\n\n    onValueChanged(event: IPepFieldValueChangeEvent): void {\n        this.onFormValidationChanged(this.form.valid);\n\n        const formControl = this.getFormControlById(event.key);\n\n        const isValid = formControl ? formControl.valid : true;\n        // const isValid = true;\n\n        if (isValid) {\n            // Set it to false to disable all fields.\n            if (this.isInternal && this.layoutType === 'form') {\n                this.isLocked = true;\n            }\n\n            // Update the current field value.\n            const currentField = this.fields.find((f) => f.key === event.key);\n            if (currentField) {\n                currentField.formattedValue = currentField.value = event.value;\n            }\n\n            this.valueChange.emit({\n                id: this.data.UID.toString(),\n                uiObjectKey: this.data.Key,\n                key: event.key,\n                value: event.value,\n                controlType: event.controlType,\n            });\n        }\n    }\n\n    onClick(fieldClickEvent: IPepFieldClickEvent): void {\n        const clickedUiControlField = this.data.Fields.filter(\n            (f) => f.ApiName === fieldClickEvent.key\n        )[0];\n        const idType = this.data.Type ? this.data.Type.toString() : '';\n\n        if (clickedUiControlField) {\n            this.fieldClick.emit({\n                id: this.data.UID.toString(),\n                uiObjectKey: this.data.Key,\n                key: fieldClickEvent.key,\n                idType,\n                which: fieldClickEvent.eventWhich,\n                value: fieldClickEvent.value,\n                controlType: fieldClickEvent.controlType,\n                fieldType: clickedUiControlField.FieldType,\n                otherData: fieldClickEvent.otherData,\n            });\n        } else {\n            // For other api names (like enter children etc).\n            this.fieldClick.emit({\n                id: this.data.UID.toString(),\n                uiObjectKey: this.data.Key,\n                key: fieldClickEvent.key,\n                idType,\n                which: fieldClickEvent.eventWhich,\n                value: fieldClickEvent.value,\n                controlType: fieldClickEvent.controlType,\n                otherData: fieldClickEvent.otherData,\n            });\n        }\n    }\n\n    // // This event is for handle the internal page events.\n    // onInternalFormFieldClicked(internalFormFieldClick: any): void {\n    //     this.internalFormFieldClick.emit(internalFormFieldClick);\n    // }\n\n    // // This event is for handle the internal page events.\n    // onInternalFormFieldChanged(internalFormFieldChange: any): void {\n    //     this.internalFormFieldChange.emit(internalFormFieldChange);\n    // }\n\n    // This event is for handle the related items change events.\n    onFormValueChanged(event: IPepFormFieldValueChangeEvent): void {\n        // this.valueChange.emit(event);\n    }\n\n    // This event is for handle the related items change events.\n    onFormFieldClick(event: IPepFormFieldClickEvent): void {\n        this.fieldClick.emit(event);\n    }\n}\n","<fieldset *ngIf=\"form\" [formGroup]=\"form\" [disabled]=\"isLocked\" class=\"pep-form\"\n    [ngStyle]=\"{ 'background-color': layoutType == 'card' && data?.BackgroundColor }\">\n    <!-- New Form -->\n    <mat-grid-list *ngIf=\"layoutType == 'form'\" [cols]=\"columns\" [rowHeight]=\"rowHeight + 'rem'\"\n        [gutterSize]=\"formGutterSize\">\n        <mat-grid-tile *ngFor=\"let field of fields$ | async\" [rowspan]=\"field.rowSpan\" [colspan]=\"field.colSpan\">\n            <pep-internal-field-generator *ngIf=\"field.controlType != 'placeholder'\" [form]=\"form\" [layoutType]=\"layoutType\"\n                [checkForChanges]=\"checkForChanges\" [uid]=\"data?.UID\" [field]=\"field\" [showTitle]=\"showTitle\"\n                (valueChange)=\"onValueChanged($event)\" (elementClick)=\"onClick($event)\"\n                (formValueChange)=\"onFormValueChanged($event)\" (formFieldClick)=\"onFormFieldClick($event)\"\n                >\n            </pep-internal-field-generator>\n            <!-- (formValidationChange)=\"onFormValidationChanged($event)\" -->\n        </mat-grid-tile>\n    </mat-grid-list>\n\n    <!-- Thumbnails -->\n    <mat-grid-list *ngIf=\"layoutType == 'card'\" [cols]=\"columns\" [rowHeight]=\"rowHeight + 'rem'\"\n        [gutterSize]=\"cardGutterSize\" class=\"card-spacing\">\n        <mat-grid-tile *ngFor=\"let field of fields$ | async\" [rowspan]=\"field.rowSpan\" [colspan]=\"field.colSpan\"\n            [ngStyle]=\"{ overflow: field.type == 'qs' ? 'unset' : 'hidden' }\">\n            <pep-internal-field-generator *ngIf=\"field.controlType != 'placeholder'\" [form]=\"form\" [layoutType]=\"layoutType\"\n                [ngClass]=\"{ 'lock-events': lockEvents }\" [isActive]=\"isActive\" [checkForChanges]=\"checkForChanges\"\n                [uid]=\"data?.UID\" [field]=\"field\" [showTitle]=\"showTitle\" (valueChange)=\"onValueChanged($event)\"\n                (elementClick)=\"onClick($event)\" (formValueChange)=\"onFormValueChanged($event)\" (formFieldClick)=\"onFormFieldClick($event)\">\n            </pep-internal-field-generator>\n        </mat-grid-tile>\n    </mat-grid-list>\n\n    <ng-container *ngIf=\"layoutType == 'table'\">\n        <ng-container *ngIf=\"isReport; then reportBlock; else notReportBlock\"></ng-container>\n        <ng-template #reportBlock>\n            <ng-container *ngTemplateOutlet=\"report\"></ng-container>\n        </ng-template>\n        <ng-template #notReportBlock>\n            <div *ngFor=\"let field of fields$ | async; let j = index\" class=\"pull-left flip table-cell \"\n                [ngClass]=\"['text-align-' + field.xAlignment]\" style=\"height: 100%\"\n                [ngStyle]=\"{ width: (layout?.ControlFields)[j]?.calcColumnWidthString}\">\n                <pep-internal-field-generator *ngIf=\"field.controlType != 'placeholder'\" [checkForChanges]=\"checkForChanges\"\n                    [uid]=\"data?.UID\" [field]=\"field\" [form]=\"form\" [layoutType]=\"layoutType\" [showTitle]=\"false\"\n                    (elementClick)=\"onClick($event)\" (valueChange)=\"onValueChanged($event)\"\n                    (formValueChange)=\"onFormValueChanged($event)\" (formFieldClick)=\"onFormFieldClick($event)\"\n                    [isActive]=\"isActive\">\n                </pep-internal-field-generator>\n            </div>\n        </ng-template>\n    </ng-container>\n\n    <!------- For testing ------------\n    {{ form.value | json }}\n    {{ form.valid }}\n    ---------------------------------->\n</fieldset>\n\n<ng-template #report>\n    <div *ngFor=\"let field of fields$ | async; let j = index\" class=\"pull-left flip pep-report-fields\"\n        [ngStyle]=\"{ width: (layout?.ControlFields)[j]?.calcColumnWidthString }\"\n        [ngClass]=\"['text-align-' + field.xAlignment]\">\n        <ng-container [ngSwitch]=\"field.controlType\">\n            <pep-image *ngSwitchCase=\"'image'\" [uid]=\"data?.UID\" [form]=\"form\" [key]=\"field.key\"\n                [src]=\"field.formattedValue\" [srcLarge]=\"field.value\" [options]=\"field.options\" [label]=\"field.label\"\n                [mandatory]=\"field.mandatory\" [disabled]=\"field.disabled\" [readonly]=\"field.readonly\"\n                [xAlignment]=\"field.xAlignment\" [rowSpan]=\"field.rowSpan\" [layoutType]=\"layoutType\"\n                (elementClick)=\"onClick($event)\">\n            </pep-image>\n\n            <pep-signature *ngSwitchCase=\"'signature'\" [form]=\"form\" [key]=\"field.key\" [src]=\"field.value\"\n                [label]=\"field.label\" [mandatory]=\"field.mandatory\" [disabled]=\"field.disabled\"\n                [readonly]=\"field.readonly\" [xAlignment]=\"field.xAlignment\" [rowSpan]=\"field.rowSpan\"\n                [layoutType]=\"layoutType\">\n            </pep-signature>\n\n            <pep-checkbox *ngSwitchCase=\"'checkbox'\" [form]=\"form\" [key]=\"field.key\"\n                [value]=\"(field.value | lowercase) == 'true' || field.value == '1' ? true : false\" [label]=\"field.label\"\n                [type]=\"field.type\" [mandatory]=\"field.mandatory\" [disabled]=\"field.disabled\"\n                [readonly]=\"field.readonly\" [xAlignment]=\"field.xAlignment\" [rowSpan]=\"field.rowSpan\"\n                [additionalValue]=\"field.additionalValue\" [layoutType]=\"layoutType\">\n            </pep-checkbox>\n\n            <pep-date *ngSwitchCase=\"'date'\" [form]=\"form\" [key]=\"field.key\" [value]=\"field.value\"\n                [label]=\"field.label\" [type]=\"field.type\"\n                [mandatory]=\"field.mandatory\" [disabled]=\"field.disabled\" [readonly]=\"field.readonly\"\n                [textColor]=\"field.textColor\" [xAlignment]=\"field.xAlignment\" [rowSpan]=\"field.rowSpan\"\n                [minValue]=\"field.minValue\" [maxValue]=\"field.maxValue\" [layoutType]=\"layoutType\">\n            </pep-date>\n\n            <pep-internal-button *ngSwitchCase=\"'button'\" [form]=\"form\" [key]=\"field.key\" [value]=\"field.value\"\n                [formattedValue]=\"field.formattedValue\" [label]=\"field.label\" [type]=\"field.type\"\n                [disabled]=\"field.disabled\" [readonly]=\"field.readonly\" [xAlignment]=\"field.xAlignment\"\n                [layoutType]=\"layoutType\" (elementClick)=\"onClick($event)\">\n            </pep-internal-button>\n\n            <pep-textarea *ngSwitchCase=\"'textarea'\" [form]=\"form\" [key]=\"field.key\" [value]=\"field.value\"\n                [label]=\"field.label\" [mandatory]=\"field.mandatory\" [disabled]=\"field.disabled\"\n                [readonly]=\"field.readonly\" [maxFieldCharacters]=\"field.maxFieldCharacters\"\n                [textColor]=\"field.textColor\" [xAlignment]=\"field.xAlignment\" [rowSpan]=\"field.rowSpan\"\n                [layoutType]=\"layoutType\">\n            </pep-textarea>\n\n            <pep-quantity-selector *ngSwitchCase=\"'qs'\" [id]=\"field.key\" [form]=\"form\" [key]=\"field.key\"\n                [value]=\"field.value\" [label]=\"field.label\" [type]=\"field.type\"\n                [mandatory]=\"field.mandatory\" [disabled]=\"field.disabled\" [readonly]=\"field.readonly\"\n                [textColor]=\"field.textColor\" [xAlignment]=\"field.xAlignment\" [rowSpan]=\"field.rowSpan\"\n                [layoutType]=\"layoutType\" (valueChange)=\"onValueChanged($event)\" (elementClick)=\"onClick($event)\">\n            </pep-quantity-selector>\n\n            <ng-container *ngSwitchDefault>\n                <ng-container *ngIf=\"field.formattedValue?.length > 0; then notEmptyBlock; else emptyBlock\">\n                </ng-container>\n                <ng-template #notEmptyBlock>\n                    <ng-container\n                        *ngIf=\"field.controlType === 'attachment' || field.type === 'link'; then linkBlock; else notLinkBlock\">\n                    </ng-container>\n                    <ng-template #linkBlock>\n                        <a [id]=\"field.key\" class=\"color-link body-sm pep-report-input readonly\"\n                            *ngIf=\"field.formattedValue != null\" title=\"{{ field.formattedValue }}\" target=\"_blank\"\n                            href=\"{{ field.value }}\">{{ field.formattedValue }}</a>\n                    </ng-template>\n                    <ng-template #notLinkBlock>\n                        <span [id]=\"field.key\" class=\"body-sm pep-report-input readonly\"\n                            title=\"{{ field.formattedValue }}\" [ngStyle]=\"{ color: field.textColor }\">{{\n                            field.formattedValue }}</span>\n                    </ng-template>\n                </ng-template>\n                <ng-template #emptyBlock>\n                    <span>&nbsp;</span>\n                </ng-template>\n            </ng-container>\n        </ng-container>\n    </div>\n</ng-template>"]}