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

package/esm2020/lib/forms/page/widgets/choicelist.mjs

@@ -0,0 +1,375 @@
+var ChoiceList_1;
+import { __decorate, __metadata } from "tslib";
+import { Constants } from '../common/constants';
+import { Widget } from './widget';
+import { JsonConvert, JsonObject, JsonProperty, PropertyConvertingMode } from 'json2typescript';
+import { DataSource, WidgetSubType } from '../common/widget-enums';
+import { ReferenceListValue } from './widget-value/reference-list-object-value';
+import { ChoiceListOptionConverter } from './widget-value/choice-list-options';
+import { ParseIntConverter } from '../value-converters/parse-int-converter';
+import { StringToBooleanValueConverter } from '../value-converters/string-to-bool-value-converter';
+import { ScriptNode, ScriptNodeConverter } from './script-condition';
+import { ChoiceListComponent } from '../../../sculptor-lib/widgets/choice-list/choice-list.component';
+import { PropertyPanelField } from '../common/property-panel-field';
+let ChoiceList = ChoiceList_1 = class ChoiceList extends Widget {
+    /* Constructor */
+    constructor(field) {
+        super(field);
+        this.markup = '';
+        this.choices = [];
+        this.allowBarCodeQrCodeSearch = false;
+        this.multiSelect = false;
+        this.apiMethod = '';
+        this.applyGeoFence = false;
+        this.oldValue = '';
+        this.referenceForm = null;
+        this.filterConditions = null;
+        this.showLocation = false;
+        // @JsonProperty(Constants.imageFixedListJson, String, PropertyConvertingMode.IGNORE_NULLABLE)
+        // imageFixedListJson: string = '';//ImageFixedListJson
+        this.downloadWhenSelected = false;
+        // @JsonProperty(Constants.fieldMapJson, ChoiceListFieldMapConverter, PropertyConvertingMode.IGNORE_NULLABLE)
+        // fieldMap: Array<ChoiceListFieldMap> = [];//FieldMapJsonObject
+        this.username = '';
+        this.applyAccessLevels = true;
+        this.addReference = false;
+        this.choicesSource = '';
+        this.newValue = '';
+        this.password = '';
+        this.fontSize = '';
+        this.barQRSearch = '';
+        this.isStatus = false;
+        this.unit = '';
+        this.apiUrl = '';
+        this.widgetIcon = 'axo_choice_list';
+        this.validate = true;
+        this.component = ChoiceListComponent;
+        this.value = null;
+        //this.id = id;
+        if (field && field.identifier) {
+            this.choiceList(field);
+        }
+        else {
+            this.newChoiceList();
+        }
+        // this.dataSource = field[Constants.DATA_SOURCE];
+        // this.choices = field[Constants.CHOICES].split('\n');
+        this.createValidators();
+    }
+    /**
+     * get widget values
+     *
+     * @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) {
+            if (this.subType === WidgetSubType.fixedList || this.subType === WidgetSubType.imageFixedList) {
+                return JSON.stringify(this.value);
+            }
+            else if (this.subType === WidgetSubType.referenceList) {
+                const jsonConvert = new JsonConvert();
+                const value = this.value;
+                const newValue = jsonConvert.serialize(value, ReferenceListValue);
+                return JSON.stringify(newValue);
+            }
+        }
+        else {
+            return '';
+        }
+    }
+    // Function to create new choice-list object
+    newChoiceList() {
+        this.dataSource = DataSource.fixedList;
+        this.choices = null;
+        this.markup = '';
+        this.defaultChoice = null;
+        //this.allowBarCodeQrCodeSearch = null;
+        this.unit = null;
+        this.apiMethod = null;
+        this.applyGeoFence = null;
+        this.oldValue = null;
+        this.referenceForm = null;
+        this.filterConditions = null;
+        this.showLocation = null;
+        //this.imageFixedListJson= null;//ImageFixedListJson
+        this.downloadWhenSelected = null;
+        //this.fieldMapJson= null;//FieldMapJsonObject
+        this.username = null;
+        this.applyAccessLevels = true;
+        this.addReference = null;
+        this.choicesSource = null;
+        this.newValue = null;
+        this.password = null;
+        this.fontSize = null;
+        this.barQRSearch = null;
+        this.isStatus = true;
+        this.allowBarCodeQrCodeSearch = true;
+        this.apiUrl = '';
+        this.multiSelect = null;
+    }
+    /**function to create choice-list object with existing values
+    *
+    *@param Report
+    *
+    */
+    choiceList(field) {
+        this.markup = field.markup;
+        this.dataSource = field[Constants.DATA_SOURCE];
+        this.defaultChoice = field.defaultChoice;
+        //this.allowBarCodeQrCodeSearch = field.allowBarCodeQrCodeSearch;
+        this.unit = field.unit;
+        this.apiMethod = field.apiMethod;
+        this.applyGeoFence = field.applyGeoFence;
+        this.oldValue = field.oldValue;
+        this.referenceForm = field.referenceForm;
+        this.filterConditions = field.filterConditions;
+        this.showLocation = field.showLocation;
+        // this.imageFixedListJson= field.imageFixedListJson;//ImageFixedListJson
+        this.downloadWhenSelected = field.downloadWhenSelected;
+        //this.fieldMapJson= field.fieldMapJson;//FieldMapJsonObject
+        this.username = field.username;
+        this.applyAccessLevels = field.applyAccessLevels;
+        this.addReference = field.addReference;
+        this.choicesSource = field.choicesSource;
+        this.newValue = field.newValue;
+        this.password = field.password;
+        this.fontSize = field.fontSize;
+        this.barQRSearch = field.barQRSearch;
+        this.isStatus = field.isStatus;
+        this.allowBarCodeQrCodeSearch = field.allowBarCodeQrCodeSearch;
+        this.apiUrl = field.apiUrl;
+        this.multiSelect = field.multiSelect;
+    }
+    /*
+   * Override createValidators
+   * Create all Validators of  choice-list widget. ~(Required validator added from common widget)
+   */
+    createValidators() {
+        //super.createValidators();
+    }
+    /**
+     * Create FormControl for widget
+     */
+    createFormControl() {
+        //this.formControl = new FormControl(this.value,this.validators);
+    }
+    // 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 = {};
+        // 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 = ChoiceList_1.getPropertyPanelFieldMetadata(this, propertyName);
+            if (metadata) {
+                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([
+    PropertyPanelField({
+        inputType: 'select', label: 'Data source',
+        choices: [{ value: DataSource.fixedList, text: 'Fixed List' }, { value: DataSource.referenceList, text: 'Reference List' }, { value: DataSource.imageFixedList, text: 'Image Fixed List' }],
+        required: true, helpText: 'Select Source', sortIndex: 0
+    }),
+    JsonProperty(Constants.dataSource, DataSource, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Number)
+], ChoiceList.prototype, "dataSource", void 0);
+__decorate([
+    JsonProperty(Constants.markup, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], ChoiceList.prototype, "markup", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'text', label: 'Choices (default)', conditionInputType: 'dataSource', conditionInputData: [DataSource.fixedList],
+        helpText: 'Enter choices, one per line', sortIndex: 1
+    }),
+    JsonProperty('choices', ChoiceListOptionConverter, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Array)
+], ChoiceList.prototype, "choices", void 0);
+__decorate([
+    JsonProperty(Constants.defaultValue, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], ChoiceList.prototype, "defaultValue", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'select', label: 'Default Choice', choices: [{ value: 'choice1 ', text: 'Choice 1' }],
+        required: true, helpText: 'Select Source', sortIndex: 2
+    }),
+    JsonProperty(Constants.defaultChoice, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], ChoiceList.prototype, "defaultChoice", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'toggle', label: 'Allow Barcode/QR code search', conditionInputType: 'inputType',
+        helpText: 'Allow barcode or QR code scan for search option', sortIndex: 5
+    }),
+    JsonProperty(Constants.allowBarCodeQrCodeSearch, StringToBooleanValueConverter, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Boolean)
+], ChoiceList.prototype, "allowBarCodeQrCodeSearch", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'toggle', label: 'Multiple Selection',
+        helpText: 'Allow selecting multiple choices or only one?', sortIndex: 4
+    }),
+    __metadata("design:type", Boolean)
+], ChoiceList.prototype, "multiSelect", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'select', label: 'Method', choices: [{ value: 'get', text: 'GET' }, { value: 'post', text: 'POST' }, { value: 'put', text: 'PUT' }, { value: 'patch', text: 'PATCH' }],
+        helpText: 'Method', sortIndex: 13
+    }),
+    JsonProperty(Constants.apiMethod, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], ChoiceList.prototype, "apiMethod", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'toggle', label: 'Apply Geofence',
+        helpText: 'Apply geofence while submitting the form?', sortIndex: 10
+    }),
+    JsonProperty(Constants.applyGeoFence, StringToBooleanValueConverter, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Boolean)
+], ChoiceList.prototype, "applyGeoFence", void 0);
+__decorate([
+    JsonProperty(Constants.oldValue, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], ChoiceList.prototype, "oldValue", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'number', label: 'Reference to',
+        helpText: 'Reference to what type of objects?', sortIndex: 6
+    }),
+    JsonProperty(Constants.referenceForm, ParseIntConverter, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Number)
+], ChoiceList.prototype, "referenceForm", void 0);
+__decorate([
+    JsonProperty(Constants.filterConditions, ScriptNodeConverter, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", ScriptNode)
+], ChoiceList.prototype, "filterConditions", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'toggle', label: 'Show Location',
+        helpText: 'Allow Showing Location', sortIndex: 9
+    }),
+    JsonProperty(Constants.showLocation, StringToBooleanValueConverter, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Boolean)
+], ChoiceList.prototype, "showLocation", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'toggle', label: 'Download when selected',
+        helpText: 'Download reference form on selecting', sortIndex: 8
+    }),
+    JsonProperty(Constants.downloadWhenSelected, StringToBooleanValueConverter, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Boolean)
+], ChoiceList.prototype, "downloadWhenSelected", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'text', label: 'Username',
+        helpText: 'Username', sortIndex: 14
+    }),
+    JsonProperty(Constants.userName, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], ChoiceList.prototype, "username", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'toggle', label: 'Apply Access Levels',
+        helpText: 'Use Access Levels to filter search results', sortIndex: 11
+    }),
+    JsonProperty(Constants.applyAccessLevels, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Boolean)
+], ChoiceList.prototype, "applyAccessLevels", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'toggle', label: 'Adding reference',
+        helpText: 'Allow adding reference', sortIndex: 7
+    }),
+    JsonProperty(Constants.addReference, StringToBooleanValueConverter, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Boolean)
+], ChoiceList.prototype, "addReference", void 0);
+__decorate([
+    JsonProperty(Constants.choicesSource, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], ChoiceList.prototype, "choicesSource", void 0);
+__decorate([
+    JsonProperty(Constants.newValue, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], ChoiceList.prototype, "newValue", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'text', label: 'Password',
+        helpText: 'Password', sortIndex: 15
+    }),
+    JsonProperty(Constants.password, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], ChoiceList.prototype, "password", void 0);
+__decorate([
+    JsonProperty(Constants.fontSize, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], ChoiceList.prototype, "fontSize", void 0);
+__decorate([
+    JsonProperty(Constants.barQRSearch, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], ChoiceList.prototype, "barQRSearch", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'toggle', label: 'Is Status',
+        helpText: 'To specify whether this field will be available for setting as list view status or not', sortIndex: 16
+    }),
+    JsonProperty(Constants.isStatus, StringToBooleanValueConverter, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Boolean)
+], ChoiceList.prototype, "isStatus", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'text', label: 'Unit',
+        helpText: 'Select unit', sortIndex: 3
+    }),
+    JsonProperty(Constants.unit, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], ChoiceList.prototype, "unit", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'text', label: 'API URL',
+        helpText: 'API URL', sortIndex: 12
+    }),
+    JsonProperty(Constants.apiUrl, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], ChoiceList.prototype, "apiUrl", void 0);
+ChoiceList = ChoiceList_1 = __decorate([
+    JsonObject('ChoiceList'),
+    __metadata("design:paramtypes", [Widget])
+], ChoiceList);
+export { ChoiceList };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"choicelist.js","sourceRoot":"","sources":["../../../../../../../src/ax-app-common-lib/src/lib/forms/page/widgets/choicelist.ts"],"names":[],"mappings":"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","sourcesContent":["import { Type } from '@angular/core';\nimport { Constants } from '../common/constants';\nimport { Widget } from './widget';\nimport { JsonConvert, JsonObject, JsonProperty, PropertyConvertingMode } from 'json2typescript';\nimport { DataSource, WidgetSubType } from '../common/widget-enums';\nimport { ReferenceListValue } from './widget-value/reference-list-object-value';\nimport { ChoiceListOption, ChoiceListOptionConverter } from './widget-value/choice-list-options';\nimport { ParseIntConverter } from '../value-converters/parse-int-converter';\nimport { StringToBooleanValueConverter } from '../value-converters/string-to-bool-value-converter';\nimport { ScriptNode, ScriptNodeConverter } from './script-condition';\nimport { ChoiceListComponent } from '../../../sculptor-lib/widgets/choice-list/choice-list.component';\nimport { PropertyPanelField, PropertyPanelFieldMetadata } from '../common/property-panel-field';\n\n@JsonObject('ChoiceList')\nexport class ChoiceList extends Widget {\n    @PropertyPanelField({\n        inputType: 'select', label: 'Data source',\n        choices: [ {value: DataSource.fixedList, text: 'Fixed List'}, {value: DataSource.referenceList, text: 'Reference List'}, {value: DataSource.imageFixedList, text: 'Image Fixed List'}],\n        required: true, helpText: 'Select Source' , sortIndex :0\n      })\n    @JsonProperty(Constants.dataSource, DataSource, PropertyConvertingMode.IGNORE_NULLABLE)\n    dataSource: DataSource;\n\n    @JsonProperty(Constants.markup, String, PropertyConvertingMode.IGNORE_NULLABLE)\n    markup: string = '';\n\n    @PropertyPanelField({\n      inputType: 'text', label: 'Choices (default)', conditionInputType: 'dataSource', conditionInputData :[DataSource.fixedList],\n      helpText: 'Enter choices, one per line' , sortIndex : 1\n    })\n    @JsonProperty('choices',ChoiceListOptionConverter,PropertyConvertingMode.IGNORE_NULLABLE)\n    choices: Array<ChoiceListOption> = [];\n    @JsonProperty(Constants.defaultValue, String, PropertyConvertingMode.IGNORE_NULLABLE)\n    defaultValue: string;\n    @PropertyPanelField({\n      inputType: 'select', label: 'Default Choice',  choices :[ {value : 'choice1 ',text :'Choice 1'}] ,\n      required: true, helpText: 'Select Source' , sortIndex :2\n    })\n    @JsonProperty(Constants.defaultChoice, String, PropertyConvertingMode.IGNORE_NULLABLE)\n    defaultChoice: string;\n\n    @PropertyPanelField({\n      inputType: 'toggle', label: 'Allow Barcode/QR code search', conditionInputType: 'inputType',\n      helpText: 'Allow barcode or QR code scan for search option' , sortIndex : 5\n    })\n    @JsonProperty(Constants.allowBarCodeQrCodeSearch,StringToBooleanValueConverter, PropertyConvertingMode.IGNORE_NULLABLE)\n    allowBarCodeQrCodeSearch: boolean = false;\n\n    @PropertyPanelField ({\n      inputType : 'toggle' , label : 'Multiple Selection' , \n      helpText :'Allow selecting multiple choices or only one?' , sortIndex : 4\n    })\n    multiSelect : boolean = false;\n\n\n    @PropertyPanelField ({\n      inputType :'select' , label :'Method' , choices :[{value: 'get', text: 'GET'}, {value: 'post', text: 'POST'}, {value: 'put', text: 'PUT'}, {value: 'patch', text: 'PATCH'} ],\n      helpText : 'Method' , sortIndex : 13\n    })\n    @JsonProperty(Constants.apiMethod, String, PropertyConvertingMode.IGNORE_NULLABLE)\n    apiMethod: string = '';\n\n    @PropertyPanelField ({\n      inputType :'toggle' , label :'Apply Geofence' , \n      helpText : 'Apply geofence while submitting the form?' , sortIndex : 10\n    })\n    @JsonProperty(Constants.applyGeoFence, StringToBooleanValueConverter, PropertyConvertingMode.IGNORE_NULLABLE)\n    applyGeoFence: boolean = false;\n\n    @JsonProperty(Constants.oldValue, String, PropertyConvertingMode.IGNORE_NULLABLE)\n    oldValue: string = '';\n\n    @PropertyPanelField ({\n      inputType : 'number' , label : 'Reference to',\n      helpText :'Reference to what type of objects?' , sortIndex : 6\n    })\n    @JsonProperty(Constants.referenceForm, ParseIntConverter, PropertyConvertingMode.IGNORE_NULLABLE)\n    referenceForm: number = null;\n\n    @JsonProperty(Constants.filterConditions, ScriptNodeConverter, PropertyConvertingMode.IGNORE_NULLABLE)\n    filterConditions: ScriptNode = null;\n    \n    @PropertyPanelField ({\n      inputType :'toggle' , label :'Show Location' , \n      helpText : 'Allow Showing Location' , sortIndex : 9\n    })\n    @JsonProperty(Constants.showLocation, StringToBooleanValueConverter, PropertyConvertingMode.IGNORE_NULLABLE)\n    showLocation: boolean = false;\n    // @JsonProperty(Constants.imageFixedListJson, String, PropertyConvertingMode.IGNORE_NULLABLE)\n    // imageFixedListJson: string = '';//ImageFixedListJson\n\n    @PropertyPanelField({\n      inputType : 'toggle' , label:'Download when selected' , \n      helpText :'Download reference form on selecting' , sortIndex : 8\n    })\n    @JsonProperty(Constants.downloadWhenSelected, StringToBooleanValueConverter, PropertyConvertingMode.IGNORE_NULLABLE)\n    downloadWhenSelected: boolean = false;\n    // @JsonProperty(Constants.fieldMapJson, ChoiceListFieldMapConverter, PropertyConvertingMode.IGNORE_NULLABLE)\n    // fieldMap: Array<ChoiceListFieldMap> = [];//FieldMapJsonObject\n\n    @PropertyPanelField ({\n      inputType :'text' , label : 'Username' ,\n      helpText : 'Username' , sortIndex : 14\n    })\n    @JsonProperty(Constants.userName, String, PropertyConvertingMode.IGNORE_NULLABLE)\n    username: string = '';\n\n    @PropertyPanelField ({\n      inputType :'toggle' , label:'Apply Access Levels' , \n      helpText : 'Use Access Levels to filter search results' , sortIndex : 11\n    })\n    @JsonProperty(Constants.applyAccessLevels, String, PropertyConvertingMode.IGNORE_NULLABLE)\n    applyAccessLevels: boolean = true;\n\n    @PropertyPanelField ({\n      inputType : 'toggle' , label :'Adding reference' , \n      helpText : 'Allow adding reference' , sortIndex : 7\n    })\n    @JsonProperty(Constants.addReference, StringToBooleanValueConverter, PropertyConvertingMode.IGNORE_NULLABLE)\n    addReference: boolean = false;\n\n    @JsonProperty(Constants.choicesSource, String, PropertyConvertingMode.IGNORE_NULLABLE)\n    choicesSource: string = '';\n    @JsonProperty(Constants.newValue, String, PropertyConvertingMode.IGNORE_NULLABLE)\n    newValue: string = '';\n\n    @PropertyPanelField ({\n      inputType : 'text' , label : 'Password' , \n      helpText :'Password' , sortIndex : 15\n    })\n    @JsonProperty(Constants.password, String, PropertyConvertingMode.IGNORE_NULLABLE)\n    password: string = '';\n\n    @JsonProperty(Constants.fontSize, String, PropertyConvertingMode.IGNORE_NULLABLE)\n    fontSize: string = '';\n    @JsonProperty(Constants.barQRSearch, String, PropertyConvertingMode.IGNORE_NULLABLE)\n    barQRSearch: string = '';\n\n    @PropertyPanelField ({\n      inputType : 'toggle' , label : 'Is Status' , \n      helpText : 'To specify whether this field will be available for setting as list view status or not' , sortIndex : 16\n    })\n    @JsonProperty(Constants.isStatus, StringToBooleanValueConverter, PropertyConvertingMode.IGNORE_NULLABLE)\n    isStatus: boolean = false;\n\n    @PropertyPanelField ({\n      inputType : 'text' , label : 'Unit' , \n      helpText : 'Select unit' , sortIndex :3\n    })\n    @JsonProperty(Constants.unit, String, PropertyConvertingMode.IGNORE_NULLABLE)\n    unit: string = '';\n\n    @PropertyPanelField ({\n      inputType : 'text' , label : 'API URL' , \n      helpText :'API URL' , sortIndex : 12\n    })\n    @JsonProperty(Constants.apiUrl, String, PropertyConvertingMode.IGNORE_NULLABLE)\n    apiUrl: string = '';\n\n    widgetIcon: string = 'axo_choice_list';\n    validate: boolean = true;\n\n    component: Type<ChoiceListComponent>=ChoiceListComponent;\n\n    value: Array<ReferenceListValue> | Array<string> = null;\n\n\n\n    /* Constructor */\n    constructor(field?: Widget ){\n        super(field);\n        //this.id = id;\n        if(field && field.identifier){\n            this.choiceList(field);\n        }\n        else{\n            this.newChoiceList();\n        }\n        // this.dataSource = field[Constants.DATA_SOURCE];\n        // this.choices = field[Constants.CHOICES].split('\\n');\n\n        this.createValidators();\n    }\n    /**\n     * get widget values\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     * this will return serialize of widget\n     */\n     getWidgetSerializedValue() {\n\n        if (this.value){\n            if(this.subType === WidgetSubType.fixedList || this.subType === WidgetSubType.imageFixedList){\n                    return JSON.stringify(this.value);\n                }\n                else if(this.subType === WidgetSubType.referenceList){\n                    const jsonConvert: JsonConvert = new JsonConvert();\n                    const value = this.value as Array<ReferenceListValue>;\n                    const newValue = jsonConvert.serialize(value,ReferenceListValue);\n                    return JSON.stringify(newValue);\n            }\n        }\n        else{\n            return '';\n        }\n    }\n\n      // Function to create new choice-list object\n      newChoiceList(): void{\n\n        this.dataSource= DataSource.fixedList;\n        this.choices= null;\n        this.markup = '';\n        this.defaultChoice = null;\n        //this.allowBarCodeQrCodeSearch = null;\n        this.unit= null;\n        this.apiMethod= null;\n        this.applyGeoFence= null;\n        this.oldValue= null;\n        this.referenceForm= null;\n        this.filterConditions= null;\n        this.showLocation= null;\n        //this.imageFixedListJson= null;//ImageFixedListJson\n        this.downloadWhenSelected= null;\n        //this.fieldMapJson= null;//FieldMapJsonObject\n        this.username= null;\n        this.applyAccessLevels= true;\n        this.addReference= null;\n        this.choicesSource= null;\n        this.newValue= null;\n        this.password= null;\n        this.fontSize= null;\n        this.barQRSearch= null;\n        this.isStatus= true;\n        this.allowBarCodeQrCodeSearch=true;\n        this.apiUrl = '';\n        this.multiSelect = null;\n    }\n\n    /**function to create choice-list object with existing values\n    *\n    *@param Report\n    *\n    */\n    choiceList(field): void{\n        this.markup = field.markup;\n        this.dataSource = field[Constants.DATA_SOURCE];\n        this.defaultChoice = field.defaultChoice;\n        //this.allowBarCodeQrCodeSearch = field.allowBarCodeQrCodeSearch;\n        this.unit= field.unit;\n        this.apiMethod= field.apiMethod;\n        this.applyGeoFence= field.applyGeoFence;\n        this.oldValue= field.oldValue;\n        this.referenceForm= field.referenceForm;\n        this.filterConditions= field.filterConditions;\n        this.showLocation= field.showLocation;\n       // this.imageFixedListJson= field.imageFixedListJson;//ImageFixedListJson\n        this.downloadWhenSelected= field.downloadWhenSelected;\n        //this.fieldMapJson= field.fieldMapJson;//FieldMapJsonObject\n        this.username= field.username;\n        this.applyAccessLevels= field.applyAccessLevels;\n        this.addReference= field.addReference;\n        this.choicesSource= field.choicesSource;\n        this.newValue= field.newValue;\n        this.password= field.password;\n        this.fontSize= field.fontSize;\n        this.barQRSearch= field.barQRSearch;\n        this.isStatus= field.isStatus;\n        this.allowBarCodeQrCodeSearch=field.allowBarCodeQrCodeSearch;\n        this.apiUrl = field.apiUrl;\n        this.multiSelect = field.multiSelect;\n    }\n\n    /*\n   * Override createValidators\n   * Create all Validators of  choice-list widget. ~(Required validator added from common widget)\n   */\n   createValidators(): void{\n    //super.createValidators();\n   }\n\n\n\n    /**\n     * Create FormControl for widget\n     */\n   createFormControl(): void{\n        //this.formControl = new FormControl(this.value,this.validators);\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    // 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 = ChoiceList.getPropertyPanelFieldMetadata(this, propertyName);\n      if (metadata) {\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"]}

package/esm2020/lib/forms/page/widgets/counter.mjs

@@ -0,0 +1,69 @@
+import { __decorate, __metadata } from "tslib";
+import { Widget } from './widget';
+import { JsonObject } from 'json2typescript';
+let Counter = class Counter extends Widget {
+    constructor(field) {
+        super(field);
+        this.value = 0;
+        this.widgetIcon = 'axo_counter';
+        if (field) {
+            this.counter(field);
+        }
+        else {
+            this.newCounter();
+        }
+        this.createValidators();
+    }
+    /**
+     * 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) {
+            return this.value.toString();
+        }
+        else {
+            return '';
+        }
+    }
+    // Function to create new report object
+    newCounter() {
+    }
+    /**function to create counter object with existing values
+    *
+    *@param field
+    *
+    */
+    counter(field) {
+    }
+    /* Override Create Validators method */
+    createValidators() {
+    }
+    /**
+     * Create FormControl for widget
+     */
+    createFormControl() {
+        throw new Error('Method not implemented.');
+    }
+};
+Counter = __decorate([
+    JsonObject('Counter'),
+    __metadata("design:paramtypes", [Counter])
+], Counter);
+export { Counter };
+//# sourceMappingURL=data:application/json;base64,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