ax-common-ui-lib 1.0.0-beta.0

package/esm2020/lib/forms/page/widgets/child-record.mjs

@@ -0,0 +1,193 @@
+var ChildRecord_1;
+import { __decorate, __metadata } from "tslib";
+import { Widget } from './widget';
+import { JsonConvert, JsonObject, JsonProperty, PropertyConvertingMode } from 'json2typescript';
+import { Constants } from '../common/constants';
+import { RecordLimitType, RestrictionMode } from '../common/widget-enums';
+import { ChildRecordValue } from './widget-value/child-record-value';
+import { ParseIntConverter } from '../value-converters/parse-int-converter';
+import { RecordLimitTypeConverter } from '../value-converters/record-limit-type-converter';
+import { RestrictionModeConverter } from '../value-converters/restriction-mode-converter';
+import { ChildRecordComponent } from '../../../sculptor-lib/widgets/child-record/child-record.component';
+import { PropertyPanelField } from '../common/property-panel-field';
+let ChildRecord = ChildRecord_1 = class ChildRecord extends Widget {
+    constructor(field) {
+        super(field);
+        this.component = ChildRecordComponent;
+        this.value = [];
+        /* SubPage may have more than one widget so make this as group widget*/
+        this.childFormId = null;
+        this.recordLimit = null;
+        this.widgetIcon = 'axo_child_records';
+        if (field) {
+            this.childRecord(field);
+        }
+        else {
+            this.newChildRecord();
+        }
+    }
+    /**
+     * get widget value
+     *
+     * @returns
+     */
+    getWidgetValue() {
+        return this.value;
+    }
+    /**
+     * Set widget Value
+     *
+     * @param value
+     */
+    setWidgetValue(value) {
+        this.value = value;
+    }
+    /**
+     * this will return serialize of widget
+     */
+    getWidgetSerializedValue() {
+        if (this.value) {
+            const jsonConvert = new JsonConvert();
+            const value = this.value;
+            const newValue = jsonConvert.serialize(value, ChildRecordValue);
+            return JSON.stringify(newValue);
+        }
+        else {
+            return '';
+        }
+    }
+    // Function to create new report object
+    newChildRecord() {
+        //this.childForm = null;
+        this.isShowInlineList = null;
+        this.recordLimitType = null;
+        this.deleteSpecificRecord = '';
+        this.deleteSpecificRecord = '';
+        this.childShowInline = '';
+        this.recordLimitField = '';
+        this.childFormId = null;
+        this.restrictionMode = 1;
+        this.recordLimit = 1;
+        this.name = 'ChildRecord';
+    }
+    /**function to create report object with existing values
+    *
+    *@param Report
+    *
+    */
+    childRecord(field) {
+        //this.childForm = field.childForm;
+        this.recordLimitType = field.recordLimitType;
+        this.deleteSpecificRecord = field.deleteSpecificRecord;
+        this.recordLimitType = field.childForm;
+        this.deleteSpecificRecord = field.childForm;
+        this.isShowInlineList = field.childForm;
+        this.deleteSpecificRecord = field.childForm;
+        this.childShowInline = field.childShowInline;
+        this.recordLimitField = field.recordLimitField;
+        this.childFormId = field.childFormId;
+        this.restrictionMode = field.restrictionMode;
+        this.recordLimit = field.recordLimit;
+        this.name = 'ChildRecord';
+    }
+    /**
+     * Create FormControl for widget
+     */
+    createFormControl() {
+        throw new Error('Method not implemented.');
+    }
+    // Method to retrieve UI metadata for a property
+    static getPropertyPanelFieldMetadata(target, key) {
+        return Reflect.getMetadata(key, target);
+    }
+    // Method to retrieve UI metadata for all properties
+    getPropertyPanelFieldUIProperties() {
+        const properties = {};
+        const excludedProperties = ['widgetLayout', 'repopulateValue'];
+        // Get the list of property  names using Object.getOwnPropertyNames
+        const propertyNames = Object.getOwnPropertyNames(this);
+        let uiProperties = new Array(propertyNames.length); // to hold sorted property names
+        const commonProperties = []; // to hold property names without sortIndex
+        // Loop through each property name and retrieve the UI metadata using getUIPrPropertyPanelFieldMetadata
+        for (const propertyName of propertyNames) {
+            const metadata = ChildRecord_1.getPropertyPanelFieldMetadata(this, propertyName);
+            if (metadata && !excludedProperties.includes(propertyName)) {
+                properties[propertyName] = metadata;
+                if (metadata.sortIndex != null) {
+                    uiProperties.splice(metadata.sortIndex, 1, propertyName);
+                }
+                else {
+                    commonProperties.push(propertyName);
+                }
+            }
+        }
+        uiProperties = uiProperties.filter(a => a);
+        const data = {
+            properties: properties,
+            keys: uiProperties.concat(commonProperties)
+        };
+        return data;
+    }
+};
+__decorate([
+    JsonProperty(Constants.childForm, ParseIntConverter, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Number)
+], ChildRecord.prototype, "childFormId", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'toggle', label: 'Show Inline List',
+        helpText: 'Allow child form to show inline', sortIndex: 2
+    }),
+    JsonProperty(Constants.isShowInlineList, Boolean, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Boolean)
+], ChildRecord.prototype, "isShowInlineList", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'select', label: 'Record Limit Type', choices: [{ value: '', text: '' }, { value: 1, text: 'Fixed' }, { value: 2, text: 'Variable' }],
+        helpText: 'Record Limit Type', sortIndex: 3
+    }),
+    JsonProperty(Constants.recordLimitType, RecordLimitTypeConverter, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Number)
+], ChildRecord.prototype, "recordLimitType", void 0);
+__decorate([
+    JsonProperty(Constants.deleteSpecificRecord, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], ChildRecord.prototype, "deleteSpecificRecord", void 0);
+__decorate([
+    JsonProperty(Constants.showInlineList, Boolean, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Boolean)
+], ChildRecord.prototype, "showInlineList", void 0);
+__decorate([
+    JsonProperty(Constants.childShowInline, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], ChildRecord.prototype, "childShowInline", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'select', label: 'Record Limit Field', choices: [], conditionInputType: 'recordLimitType', conditionInputData: ['2'],
+        helpText: 'Record Limit Field', sortIndex: 5
+    }),
+    JsonProperty(Constants.recordLimitField, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], ChildRecord.prototype, "recordLimitField", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'select', label: 'Restriction Mode', choices: [{ value: 1, text: 'Disable' }, { value: 2, text: 'Hide' }], conditionInputType: 'recordLimitType', conditionInputData: ['1', '2'],
+        helpText: 'Maximum number of records user will be able to add', sortIndex: 6
+    }),
+    JsonProperty(Constants.restrictionMode, RestrictionModeConverter, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Number)
+], ChildRecord.prototype, "restrictionMode", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'number', label: 'Record Limit', conditionInputType: 'recordLimitType', conditionInputData: ['1'],
+        helpText: 'Record Limit', sortIndex: 4
+    }),
+    JsonProperty(Constants.recordLimit, ParseIntConverter, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Number)
+], ChildRecord.prototype, "recordLimit", void 0);
+ChildRecord = ChildRecord_1 = __decorate([
+    JsonObject('ChildRecord'),
+    __metadata("design:paramtypes", [Widget])
+], ChildRecord);
+export { ChildRecord };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"child-record.js","sourceRoot":"","sources":["../../../../../../../src/ax-common-ui-lib/src/lib/forms/page/widgets/child-record.ts"],"names":[],"mappings":"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","sourcesContent":["import { Type } from '@angular/core';\nimport { Widget } from './widget';\nimport { JsonConvert, JsonObject, JsonProperty, PropertyConvertingMode } from 'json2typescript';\nimport { Constants } from '../common/constants';\nimport { RecordLimitType, RestrictionMode } from '../common/widget-enums';\nimport { ChildRecordValue } from './widget-value/child-record-value';\nimport { ParseIntConverter } from '../value-converters/parse-int-converter';\nimport { RecordLimitTypeConverter } from '../value-converters/record-limit-type-converter';\nimport { RestrictionModeConverter } from '../value-converters/restriction-mode-converter';\nimport { ChildRecordComponent } from '../../../sculptor-lib/widgets/child-record/child-record.component';\nimport { PropertyPanelField, PropertyPanelFieldMetadata } from '../common/property-panel-field';\n\n@JsonObject('ChildRecord')\nexport class ChildRecord extends Widget{\n\n    component?: Type<ChildRecordComponent> = ChildRecordComponent ;\n\n    value: Array<ChildRecordValue> = [];\n    /* SubPage may have more than one widget so make this as group widget*/\n    @JsonProperty(Constants.childForm, ParseIntConverter, PropertyConvertingMode.IGNORE_NULLABLE)\n    childFormId: number = null;\n\n    @PropertyPanelField ({\n        inputType :'toggle' , label :'Show Inline List' , \n        helpText :'Allow child form to show inline' , sortIndex : 2\n    })\n    @JsonProperty(Constants.isShowInlineList, Boolean, PropertyConvertingMode.IGNORE_NULLABLE)\n    isShowInlineList: boolean;\n\n    @PropertyPanelField ({\n        inputType :'select' , label :'Record Limit Type' , choices :[ {value: '',text:''},{value: 1, text: 'Fixed'}, {value: 2, text: 'Variable'} ],\n        helpText :'Record Limit Type' ,  sortIndex : 3\n    })\n    @JsonProperty(Constants.recordLimitType, RecordLimitTypeConverter, PropertyConvertingMode.IGNORE_NULLABLE)\n    recordLimitType: RecordLimitType;\n    @JsonProperty(Constants.deleteSpecificRecord, String, PropertyConvertingMode.IGNORE_NULLABLE)\n    deleteSpecificRecord: string;\n    @JsonProperty(Constants.showInlineList, Boolean, PropertyConvertingMode.IGNORE_NULLABLE)\n    showInlineList: boolean;\n\n    @JsonProperty(Constants.childShowInline, String, PropertyConvertingMode.IGNORE_NULLABLE)\n    childShowInline: string;\n\n    @PropertyPanelField ({\n        inputType :'select' , label : 'Record Limit Field' , choices : [], conditionInputType :'recordLimitType' ,conditionInputData : ['2'],\n        helpText :'Record Limit Field' , sortIndex : 5\n    })\n    @JsonProperty(Constants.recordLimitField, String, PropertyConvertingMode.IGNORE_NULLABLE)\n    recordLimitField: string;\n    // @JsonProperty(Constants.childFormId, String, PropertyConvertingMode.IGNORE_NULLABLE)\n    // childFormId: string;\n    @PropertyPanelField ({\n        inputType :'select' , label :'Restriction Mode' , choices :[ {value: 1, text: 'Disable'}, {value: 2, text: 'Hide'} ] ,conditionInputType :'recordLimitType' ,conditionInputData : ['1' , '2'], \n        helpText :'Maximum number of records user will be able to add' , sortIndex :6\n    })\n    @JsonProperty(Constants.restrictionMode, RestrictionModeConverter, PropertyConvertingMode.IGNORE_NULLABLE)\n    restrictionMode: RestrictionMode;\n\n    @PropertyPanelField ({\n        inputType :'number' , label :'Record Limit' , conditionInputType :'recordLimitType' ,conditionInputData : ['1'],\n        helpText :'Record Limit' , sortIndex :4\n    })\n    @JsonProperty(Constants.recordLimit, ParseIntConverter, PropertyConvertingMode.IGNORE_NULLABLE)\n    recordLimit: number=null;\n    widgetIcon: string = 'axo_child_records';\n\n    constructor(field?: Widget){\n        super(field);\n        if(field){\n            this.childRecord(field);\n        }\n        else{\n            this.newChildRecord();\n        }\n    }\n\n    /**\n     * get widget value\n     *\n     * @returns\n     */\n    getWidgetValue(): any {\n        return this.value;\n    }\n\n    /**\n     * Set widget Value\n     *\n     * @param value\n     */\n    setWidgetValue(value: any) {\n        this.value = value;\n    }\n\n    /**\n     * this will return serialize of widget\n     */\n     getWidgetSerializedValue() {\n        if(this.value){\n            const jsonConvert: JsonConvert = new JsonConvert();\n            const value = this.value as Array<ChildRecordValue>;\n            const newValue = jsonConvert.serialize(value,ChildRecordValue);\n            return JSON.stringify(newValue);\n        }\n        else{\n            return '';\n        }\n\n    }\n\n    // Function to create new report object\n    newChildRecord(): void{\n\n        //this.childForm = null;\n        this.isShowInlineList=null;\n        this.recordLimitType=null;\n        this.deleteSpecificRecord ='';\n        this.deleteSpecificRecord = '';\n        this.childShowInline = '';\n        this.recordLimitField = '';\n        this.childFormId = null;\n        this.restrictionMode = 1;\n        this.recordLimit= 1;\n        this.name = 'ChildRecord';\n    }\n    /**function to create report object with existing values\n    *\n    *@param Report\n    *\n    */\n    childRecord(field): void{\n\n        //this.childForm = field.childForm;\n        this.recordLimitType=field.recordLimitType;\n        this.deleteSpecificRecord =field.deleteSpecificRecord;\n        this.recordLimitType=field.childForm;\n        this.deleteSpecificRecord = field.childForm;\n        this.isShowInlineList =  field.childForm;\n        this.deleteSpecificRecord = field.childForm;\n        this.childShowInline = field.childShowInline;\n        this.recordLimitField = field.recordLimitField;\n        this.childFormId = field.childFormId;\n        this.restrictionMode = field.restrictionMode;\n        this.recordLimit = field.recordLimit;\n        this.name = 'ChildRecord';\n    }\n\n    /**\n     * Create FormControl for widget\n     */\n    createFormControl() {\n        throw new Error('Method not implemented.');\n    }\n\n      // Method to retrieve UI metadata for a property\n  public static getPropertyPanelFieldMetadata(target: any, key: string): PropertyPanelFieldMetadata {\n    return Reflect.getMetadata(key, target);\n  }\n\n  // Method to retrieve UI metadata for all properties\n  public getPropertyPanelFieldUIProperties(): any {\n    const properties: { [key: string]: PropertyPanelFieldMetadata } = {};\n    const excludedProperties=['widgetLayout','repopulateValue'];\n    // Get the list of property  names using Object.getOwnPropertyNames\n    const propertyNames = Object.getOwnPropertyNames(this);\n    let uiProperties = new Array(propertyNames.length); // to hold sorted property names\n    const commonProperties = []; // to hold property names without sortIndex\n    // Loop through each property name and retrieve the UI metadata using getUIPrPropertyPanelFieldMetadata\n    for (const propertyName of propertyNames) {\n      const metadata = ChildRecord.getPropertyPanelFieldMetadata(this, propertyName);\n      if (metadata && !excludedProperties.includes(propertyName)) {\n        properties[propertyName] = metadata;\n        if (metadata.sortIndex != null) {\n          uiProperties.splice(metadata.sortIndex, 1, propertyName);\n        }\n        else {\n          commonProperties.push(propertyName);\n        }\n      }\n    }\n    uiProperties = uiProperties.filter(a => a);\n    const data = {\n      properties: properties,\n      keys: uiProperties.concat(commonProperties)\n    };\n    return data;\n  }\n\n\n}\n"]}