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

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

@@ -0,0 +1,247 @@
+var DateTime_1;
+import { __decorate, __metadata } from "tslib";
+import { Constants } from '../common/constants';
+import { Widget } from './widget';
+import { JsonObject, JsonProperty, PropertyConvertingMode } from 'json2typescript';
+import { StringToBooleanValueConverter } from '../value-converters/string-to-bool-value-converter';
+import { DateTimeComponent } from '../../../sculptor-lib/widgets/date-time/date-time.component';
+import { PropertyPanelField } from '../common/property-panel-field';
+let DateTime = DateTime_1 = class DateTime extends Widget {
+    constructor(field) {
+        super(field);
+        this.component = DateTimeComponent;
+        // eslint-disable-next-line @typescript-eslint/member-ordering
+        this.value = null;
+        // eslint-disable-next-line @typescript-eslint/member-ordering
+        this.datePickerType = '';
+        this.dateFormat = '';
+        this.allowPast = false;
+        this.allowFuture = false;
+        this.toDatelabel = '';
+        this.displayDateFormat = '';
+        this.fromDateLabel = '';
+        // display date time format
+        this.displayDateTimeFormat = "";
+        // display time format
+        this.displayTimeFormat = "";
+        this.otherDisplayDateTimeFormat = '';
+        this.widgetIcon = 'axo_datetime';
+        if (field) {
+            this.dateTimeObject(field);
+        }
+        else {
+            this.newDateTime();
+        }
+        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) {
+            if (typeof (this.value) === 'object') {
+                const value = this.value;
+                return JSON.stringify(value.from + ',' + value.to);
+            }
+            else {
+                const value = this.value;
+                return JSON.stringify(value.toString());
+            }
+        }
+        else {
+            return '';
+        }
+    }
+    // Function to create new Date-Time object
+    newDateTime() {
+        this.datePickerType = '';
+        this.dateFormat = '';
+        this.allowPast = true;
+        this.allowFuture = true;
+        this.toDatelabel = null;
+        this.displayDateFormat = null;
+        this.fromDateLabel = null;
+        this.name = 'DateTime';
+    }
+    /**function to create Date-Time object with existing values
+    *
+    *@param field
+    *
+    */
+    dateTimeObject(field) {
+        this.datePickerType = field.datePickerType;
+        this.dateFormat = field.dateFormat;
+        this.allowPast = field.allowPast;
+        this.allowFuture = field.allowFuture;
+        this.toDatelabel = field.toDatelabel;
+        this.displayDateFormat = field.displayDateFormat;
+        this.fromDateLabel = field.fromDateLabel;
+        this.name = 'DateTime';
+    }
+    /*
+  * Override createValidators
+  * Create all Validators of  text-box widget. ~(Required validator added from common widget)
+  */
+    createValidators() {
+        //super.createValidators();
+    }
+    /*
+    * Get input type of datetime widget.
+    */
+    getInputType(inputType) {
+        if (inputType === 'both') {
+            return 'datetime-local';
+        }
+        else if (inputType === 'date') {
+            return 'date';
+        }
+        else if (inputType === 'time') {
+            return 'time';
+        }
+        else if (inputType === 'date-range') {
+            return 'date-range';
+        }
+        return 'text';
+    }
+    /**
+     * Create FormControl for widget
+     */
+    createFormControl() {
+    }
+    // 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 = DateTime_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([
+    JsonProperty('value', String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Object)
+], DateTime.prototype, "value", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'select', label: 'Date picker type',
+        choices: [{ value: 'date', text: 'Date' },
+            { value: 'time', text: 'Time' }, { value: 'both', text: 'Date time both' },
+            { value: 'date-range', text: 'Date Range' }],
+        required: true, helpText: 'Date picker type?', sortIndex: 1
+    }),
+    JsonProperty(Constants.datePickerType, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], DateTime.prototype, "datePickerType", void 0);
+__decorate([
+    JsonProperty(Constants.dateFormat, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], DateTime.prototype, "dateFormat", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'toggle', label: 'Allow past', conditionInputType: 'datePickerType', conditionInputData: ['date', 'both'],
+        helpText: 'Allow past', sortIndex: 9
+    }),
+    JsonProperty(Constants.allowPost, StringToBooleanValueConverter, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Boolean)
+], DateTime.prototype, "allowPast", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'toggle', label: 'Allow future', conditionInputType: 'datePickerType', conditionInputData: ['date', 'both'],
+        helpText: 'Allow future', sortIndex: 8
+    }),
+    JsonProperty(Constants.allowFuture, StringToBooleanValueConverter, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Boolean)
+], DateTime.prototype, "allowFuture", void 0);
+__decorate([
+    PropertyPanelField({ inputType: 'text', label: 'Label for ending date',
+        conditionInputType: 'datePickerType', conditionInputData: ['date-range'], helpText: 'Label for ending date',
+        sortIndex: 7
+    }),
+    JsonProperty(Constants.toDatelabel, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], DateTime.prototype, "toDatelabel", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'select', label: 'Date format',
+        choices: [{ value: 'MM/dd/YYYY', text: 'MM/dd/YYYY (02/21/2018)' }, { value: 'MM/dd/YY', text: 'MM/dd/YY (02/21/18)' }, { value: 'dd/MM/YYYY', text: 'dd/MM/YYYY (21/02/2018)' }, { value: 'dd/MM/YY', text: 'dd/MM/YY (21/02/18)' }, { value: 'dd-MM-YYYY', text: 'dd-MM-YYYY (21-02-2018)' }, { value: 'dd-MM-YY', text: 'dd-MM-YY (21-02-18)' }, { value: 'MM-dd-YYYY', text: 'MM-dd-YYYY (02-21-2018)' }, { value: 'MM-dd-YY', text: 'MM-dd-YY (02-21-18)' }, { value: 'YYYY-MM-dd', text: 'YYYY-MM-dd (2018-02-21)' }, { value: 'M/dd/YYYY', text: 'M/dd/YYYY (2/21/2018)' }, { value: 'M/dd/YY', text: 'M/dd/YY (2/21/18)' }, { value: 'd/M/YYYY', text: 'd/M/YYYY (21/2/2018)' }, { value: 'd/M/YY', text: 'd/M/YY (21/2/18)' }, { value: 'M-d-YYYY', text: 'M-d-YYYY (2-21-2018)' }, { value: 'M-d-YY', text: 'M-d-YY (2-21-18)' }, { value: 'd-M-YYYY', text: 'd-M-YYYY (21-2-2018)' }, { value: 'd-M-YY', text: 'd-M-YY (21-2-18)' }, { value: 'MMM d, YYYY', text: 'MMM d, YYYY (Feb 21, 2018)' }, { value: 'MMMM d, YYYY', text: 'MMMM d, YYYY (February 21, 2018)' }, { value: 'other', text: 'Other' }],
+        conditionInputType: 'datePickerType', conditionInputData: ['date'],
+        required: true, helpText: 'Date picker type?', sortIndex: 2
+    }),
+    JsonProperty(Constants.displayDateFormat, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], DateTime.prototype, "displayDateFormat", void 0);
+__decorate([
+    PropertyPanelField({ inputType: 'text', label: 'Label for starting date',
+        conditionInputType: 'datePickerType', conditionInputData: ['date-range'], helpText: 'Label for starting date',
+        sortIndex: 6
+    }),
+    JsonProperty(Constants.fromDateLabel, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], DateTime.prototype, "fromDateLabel", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'select', label: 'Date Time format', conditionInputType: 'datePickerType', conditionInputData: ['both'],
+        choices: [{ value: 'YYYY-MM-dd HH:mm:ss', text: 'YYYY-MM-dd HH:mm:ss (2018-02-21 12:00:00)' }, { value: 'YYYY-MM-dd hh:mm:ss a', text: 'YYYY-MM-dd hh:mm:ss a (2018-10-29 10:02:48 AM)' }, { value: 'other', text: 'Other' }],
+        helpText: 'Set the Date Time format', sortIndex: 4
+    }),
+    __metadata("design:type", String)
+], DateTime.prototype, "displayDateTimeFormat", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'select', label: 'Time format', conditionInputType: 'datePickerType', conditionInputData: ['time'],
+        choices: [{ value: 'HH:mm:ss', text: 'HH:mm:ss (12:00:00)' }, { value: 'HH:mm', text: 'HH:mm (12:00)' }, { value: 'other', text: 'Other' }],
+        helpText: 'Set the time format', sortIndex: 3
+    }),
+    __metadata("design:type", String)
+], DateTime.prototype, "displayTimeFormat", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'text', label: 'Other Datetime Format', conditionInputType: 'displayTimeFormat', conditionInputData: ['other'], helpText: 'Set custom date time format', sortIndex: 5
+    }),
+    __metadata("design:type", String)
+], DateTime.prototype, "otherDisplayDateTimeFormat", void 0);
+DateTime = DateTime_1 = __decorate([
+    JsonObject('DateTime'),
+    __metadata("design:paramtypes", [DateTime])
+], DateTime);
+export { DateTime };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datetime.js","sourceRoot":"","sources":["../../../../../../../src/ax-app-common-lib/src/lib/forms/page/widgets/datetime.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 { DateRangeValue } from './widget-value/dateRangeValue';\nimport { StringToBooleanValueConverter } from '../value-converters/string-to-bool-value-converter';\nimport { DateTimeComponent } from '../../../sculptor-lib/widgets/date-time/date-time.component';\nimport { PropertyPanelField, PropertyPanelFieldMetadata } from '../common/property-panel-field';\n\ntype DateTimeValue = Type<string | number>;\n\n@JsonObject('DateTime')\nexport class DateTime extends Widget {\n    component: Type<DateTimeComponent>= DateTimeComponent;\n\n    // eslint-disable-next-line @typescript-eslint/member-ordering\n    @JsonProperty('value', String,PropertyConvertingMode.IGNORE_NULLABLE)\n    value: DateTimeValue = null;\n\n\n    // eslint-disable-next-line @typescript-eslint/member-ordering\n    @PropertyPanelField({\n        inputType: 'select', label: 'Date picker type',\n        choices: [{ value: 'date', text: 'Date' },\n        { value: 'time', text: 'Time' }, { value: 'both', text: 'Date time both' },\n        { value: 'date-range', text: 'Date Range' }],\n        required: true, helpText: 'Date picker type?',sortIndex: 1\n      })\n    @JsonProperty(Constants.datePickerType ,String,PropertyConvertingMode.IGNORE_NULLABLE)\n    datePickerType: string='';\n\n    @JsonProperty(Constants.dateFormat ,String,PropertyConvertingMode.IGNORE_NULLABLE)\n    dateFormat: string='';\n\n    @PropertyPanelField({\n        inputType: 'toggle', label: 'Allow past', conditionInputType: 'datePickerType', conditionInputData: ['date','both'],\n        helpText: 'Allow past' , sortIndex :9\n      })\n    @JsonProperty(Constants.allowPost,StringToBooleanValueConverter,PropertyConvertingMode.IGNORE_NULLABLE)\n    allowPast: boolean=false;\n\n    @PropertyPanelField({\n        inputType: 'toggle', label: 'Allow future', conditionInputType: 'datePickerType',conditionInputData: ['date','both'],\n        helpText: 'Allow future' , sortIndex : 8\n      })\n    @JsonProperty(Constants.allowFuture,StringToBooleanValueConverter,PropertyConvertingMode.IGNORE_NULLABLE)\n    allowFuture: boolean=false;\n\n    @PropertyPanelField({ inputType: 'text', label: 'Label for ending date', \n      conditionInputType : 'datePickerType' , conditionInputData : ['date-range'] , helpText: 'Label for ending date',\n      sortIndex : 7\n    })\n    @JsonProperty(Constants.toDatelabel,String,PropertyConvertingMode.IGNORE_NULLABLE)\n    toDatelabel: string='';\n    \n    @PropertyPanelField({\n        inputType: 'select', label: 'Date format',\n        choices: [  {value: 'MM/dd/YYYY', text: 'MM/dd/YYYY (02/21/2018)'}, {value: 'MM/dd/YY',text: 'MM/dd/YY (02/21/18)'}, {value: 'dd/MM/YYYY', text: 'dd/MM/YYYY (21/02/2018)'},{value: 'dd/MM/YY', text: 'dd/MM/YY (21/02/18)'}, {value: 'dd-MM-YYYY', text: 'dd-MM-YYYY (21-02-2018)'}, {value: 'dd-MM-YY', text: 'dd-MM-YY (21-02-18)'}, {value: 'MM-dd-YYYY', text: 'MM-dd-YYYY (02-21-2018)'}, {value: 'MM-dd-YY', text: 'MM-dd-YY (02-21-18)'}, {value: 'YYYY-MM-dd', text: 'YYYY-MM-dd (2018-02-21)'}, {value: 'M/dd/YYYY', text: 'M/dd/YYYY (2/21/2018)'},{value: 'M/dd/YY', text: 'M/dd/YY (2/21/18)'}, {value: 'd/M/YYYY', text: 'd/M/YYYY (21/2/2018)'},{value: 'd/M/YY', text: 'd/M/YY (21/2/18)'}, {value: 'M-d-YYYY', text: 'M-d-YYYY (2-21-2018)'},{value: 'M-d-YY', text: 'M-d-YY (2-21-18)'}, {value: 'd-M-YYYY', text: 'd-M-YYYY (21-2-2018)'}, {value: 'd-M-YY', text: 'd-M-YY (21-2-18)'}, {value: 'MMM d, YYYY', text: 'MMM d, YYYY (Feb 21, 2018)'},{value: 'MMMM d, YYYY', text: 'MMMM d, YYYY (February 21, 2018)'}, { value : 'other' , text:'Other'} ] ,\n        conditionInputType : 'datePickerType', conditionInputData : ['date'] ,\n        required: true, helpText: 'Date picker type?' , sortIndex : 2\n      })\n    @JsonProperty(Constants.displayDateFormat,String,PropertyConvertingMode.IGNORE_NULLABLE)\n    displayDateFormat: string='';\n\n    @PropertyPanelField({ inputType: 'text', label: 'Label for starting date', \n    conditionInputType : 'datePickerType' , conditionInputData :['date-range'] , helpText: 'Label for starting date',\n    sortIndex:6\n    })\n    @JsonProperty(Constants.fromDateLabel,String,PropertyConvertingMode.IGNORE_NULLABLE)\n    fromDateLabel: string='';\n\n    // display date time format\n    @PropertyPanelField({\n      inputType :'select' , label:'Date Time format' , conditionInputType:'datePickerType', conditionInputData : ['both'] ,\n      choices : [ {value: 'YYYY-MM-dd HH:mm:ss', text: 'YYYY-MM-dd HH:mm:ss (2018-02-21 12:00:00)'},{value: 'YYYY-MM-dd hh:mm:ss a', text: 'YYYY-MM-dd hh:mm:ss a (2018-10-29 10:02:48 AM)'} , {value: 'other' , text : 'Other'}] ,\n      helpText:'Set the Date Time format' , sortIndex : 4\n    })\n    displayDateTimeFormat: string=\"\"\n    \n    // display time format\n    @PropertyPanelField({\n      inputType :'select' , label:'Time format' , conditionInputType:'datePickerType',conditionInputData : ['time'] ,\n      choices : [ {value: 'HH:mm:ss', text: 'HH:mm:ss (12:00:00)'}, {value: 'HH:mm', text: 'HH:mm (12:00)'}, {value : 'other' , text : 'Other'} ],\n      helpText : 'Set the time format', sortIndex : 3\n    })\n    displayTimeFormat: string=\"\"\n\n    @PropertyPanelField({\n      inputType:'text' , label : 'Other Datetime Format' , conditionInputType:'displayTimeFormat' , conditionInputData : ['other'] , helpText:'Set custom date time format', sortIndex:5\n    })\n    otherDisplayDateTimeFormat : string =''\n    widgetIcon: string = 'axo_datetime';\n\n\n    constructor(field?: DateTime){\n        super(field);\n        if(field){\n            this.dateTimeObject(field);\n        }\n        else{\n            this.newDateTime();\n        }\n        this.createValidators();\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     * this will return serialize of widget\n     */\n     getWidgetSerializedValue() {\n        if(this.value){\n            if(typeof(this.value)==='object'){\n                const value = this.value as DateRangeValue;\n                return JSON.stringify(value.from+','+value.to);\n            }\n            else{\n                const value = this.value as DateTimeValue;\n                return JSON.stringify(value.toString());\n            }\n        }\n        else{\n            return '';\n        }\n\n    }\n\n\n    // Function to create new Date-Time object\n    newDateTime(): void{\n\n        this.datePickerType='';\n        this.dateFormat= '';\n        this.allowPast=true;\n        this.allowFuture=true;\n\n        this.toDatelabel= null;\n\n        this.displayDateFormat= null;\n\n        this.fromDateLabel= null;\n        this.name = 'DateTime';\n    }\n\n    /**function to create Date-Time object with existing values\n    *\n    *@param field\n    *\n    */\n    dateTimeObject(field): void{\n        this.datePickerType = field.datePickerType;\n        this.dateFormat = field.dateFormat;\n        this.allowPast = field.allowPast;\n        this.allowFuture = field.allowFuture;\n        this.toDatelabel= field.toDatelabel;\n\n        this.displayDateFormat= field.displayDateFormat;\n\n        this.fromDateLabel= field.fromDateLabel;\n        this.name = 'DateTime';\n    }\n\n     /*\n   * Override createValidators\n   * Create all Validators of  text-box widget. ~(Required validator added from common widget)\n   */\n   createValidators(): void{\n       //super.createValidators();\n   }\n\n   /*\n   * Get input type of datetime widget.\n   */\n   getInputType(inputType): string {\n       if(inputType === 'both'){\n           return 'datetime-local';\n       }else if (inputType === 'date'){\n            return 'date';\n       }else if (inputType === 'time'){\n            return 'time';\n       }else if (inputType === 'date-range'){\n\n           return 'date-range';\n        }\n        return 'text';\n    }\n    /**\n     * Create FormControl for widget\n     */\n    createFormControl() {\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 = DateTime.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}"]}

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

@@ -0,0 +1,106 @@
+import { __decorate, __metadata } from "tslib";
+import { JsonObject, JsonProperty, PropertyConvertingMode } from 'json2typescript';
+import { Constants } from '../common/constants';
+import { Widget } from './widget';
+import { OutputType } from '../common/widget-enums';
+let Formula = class Formula extends Widget {
+    constructor(field) {
+        super(field);
+        /* SubPage may have more than one widget so make this as group widget*/
+        // @JsonProperty(Constants.outPutType, OutputType, PropertyConvertingMode.IGNORE_NULLABLE)
+        // outPutType: OutputType = null;
+        this.computationLogic = '';
+        // @JsonProperty(Constants.unit, String, PropertyConvertingMode.IGNORE_NULLABLE)
+        // unit: number = 0;
+        this.oldValue = '';
+        this.computation = '';
+        this.outputType = null;
+        this.computationalLogic = '';
+        this.unit = '';
+        this.value = '';
+        this.widgetIcon = 'axo_square_text';
+        if (field) {
+            this.formula(field);
+        }
+        else {
+            this.newFormula();
+        }
+    }
+    /**
+     * 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
+    newFormula() {
+        this.outputType = null;
+        this.computationalLogic = null;
+        this.unit = null;
+        this.oldValue = null;
+        this.computation = null;
+    }
+    /**function to create report object with existing values
+    *
+    *@param Report
+    *
+    */
+    formula(field) {
+        this.outputType = field.outputType;
+        this.computationalLogic = field.computationalLogic;
+        this.unit = field.unit;
+        this.oldValue = field.oldValue;
+        this.computation = field.computation;
+    }
+};
+__decorate([
+    JsonProperty(Constants.computationLogic, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], Formula.prototype, "computationLogic", void 0);
+__decorate([
+    JsonProperty(Constants.oldValue, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], Formula.prototype, "oldValue", void 0);
+__decorate([
+    JsonProperty(Constants.computation, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], Formula.prototype, "computation", void 0);
+__decorate([
+    JsonProperty(Constants.outPutType, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Number)
+], Formula.prototype, "outputType", void 0);
+__decorate([
+    JsonProperty(Constants.computationLogic, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], Formula.prototype, "computationalLogic", void 0);
+__decorate([
+    JsonProperty(Constants.unit, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], Formula.prototype, "unit", void 0);
+Formula = __decorate([
+    JsonObject('Formula'),
+    __metadata("design:paramtypes", [Formula])
+], Formula);
+export { Formula };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,127 @@
+var GeoFence_1;
+import { __decorate, __metadata } from "tslib";
+import { Widget } from './widget';
+import { JsonConvert, JsonObject, JsonProperty, PropertyConvertingMode } from 'json2typescript';
+import { Constants } from '../common/constants';
+import { GeoFenceWidgetValue } from './widget-value/geo-fence-widget-value';
+import { ParseFloatConverter } from '../value-converters/parse-float-converter';
+import { GeofenceComponent } from '../../../sculptor-lib/widgets/geofence/geofence.component';
+import { PropertyPanelField } from '../common/property-panel-field';
+let GeoFence = GeoFence_1 = class GeoFence extends Widget {
+    constructor(field) {
+        super(field);
+        this.component = GeofenceComponent;
+        this.centre = '';
+        this.radius = null;
+        this.widgetIcon = 'axo_location';
+        if (field) {
+            this.geoFence(field);
+        }
+        else {
+            this.newGeoFence();
+        }
+    }
+    /**
+     * 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, GeoFenceWidgetValue);
+            return JSON.stringify(newValue.value[0].value[0]);
+        }
+        else {
+            return '';
+        }
+    }
+    // Function to create new link object
+    newGeoFence() {
+        this.centre = null;
+        this.radius = null;
+        this.value = null;
+        this.name = 'GeoFence';
+    }
+    /**
+     * function to create link object with existing values
+     *
+     *@param field
+     *
+     */
+    geoFence(field) {
+        this.centre = field.center;
+        this.radius = field.radius;
+        this.value = field.value;
+        this.name = 'GeoFence';
+    }
+    // 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 = GeoFence_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([
+    PropertyPanelField({
+        inputType: 'text', label: 'Centre',
+        helpText: 'Select Centre'
+    }),
+    JsonProperty('centre', String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], GeoFence.prototype, "centre", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'text', label: 'Radius',
+        helpText: 'Enter radius'
+    }),
+    JsonProperty(Constants.Radius, ParseFloatConverter, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Number)
+], GeoFence.prototype, "radius", void 0);
+GeoFence = GeoFence_1 = __decorate([
+    JsonObject('GeoFence'),
+    __metadata("design:paramtypes", [Widget])
+], GeoFence);
+export { GeoFence };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"geofence.js","sourceRoot":"","sources":["../../../../../../../src/ax-app-common-lib/src/lib/forms/page/widgets/geofence.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 { GeoFenceWidgetValue } from './widget-value/geo-fence-widget-value';\nimport { ParseFloatConverter } from '../value-converters/parse-float-converter';\nimport { GeofenceComponent } from '../../../sculptor-lib/widgets/geofence/geofence.component';\nimport { PropertyPanelField, PropertyPanelFieldMetadata } from '../common/property-panel-field';\n\ntype GeoFenceValue = Type<Array<GeoFenceWidgetValue>>;\n@JsonObject('GeoFence')\nexport class GeoFence extends Widget {\n    component: Type<GeofenceComponent> = GeofenceComponent;\n\n    @PropertyPanelField ({\n        inputType : 'text' , label : 'Centre' , \n        helpText : 'Select Centre'\n    })\n    @JsonProperty('centre',String, PropertyConvertingMode.IGNORE_NULLABLE)\n    centre: string = '';\n\n    @PropertyPanelField ({\n        inputType : 'text' , label : 'Radius' , \n        helpText : 'Enter radius'\n    })\n    @JsonProperty(Constants.Radius,ParseFloatConverter,PropertyConvertingMode.IGNORE_NULLABLE)\n    radius: number= null;\n    widgetIcon: string ='axo_location';\n\n\n    value:  GeoFenceValue;\n\n    constructor(field?: Widget){\n        super(field);\n        if(field){\n            this.geoFence(field);\n        }\n        else{\n            this.newGeoFence();\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     * 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 GeoFenceValue;\n            const newValue = jsonConvert.serialize(value,GeoFenceWidgetValue);\n            return JSON.stringify(newValue.value[0].value[0]);\n        }\n        else{\n            return '';\n        }\n\n    }\n    // Function to create new link object\n    newGeoFence(): void{\n        this.centre= null;\n        this.radius= null;\n        this.value= null;\n        this.name ='GeoFence';\n    }\n\n    /**\n     * function to create link object with existing values\n     *\n     *@param field\n     *\n     */\n    geoFence(field): void{\n        this.centre = field.center;\n        this.radius= field.radius;\n        this.value= field.value;\n        this.name ='GeoFence';\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 = GeoFence.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"]}