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

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

@@ -0,0 +1,192 @@
+var GPS_1;
+import { __decorate, __metadata } from "tslib";
+import { Constants } from '../common/constants';
+import { Widget } from './widget';
+import { JsonConvert, JsonObject, JsonProperty, PropertyConvertingMode } from 'json2typescript';
+import { GPSWidgetValue } from './widget-value/gps-widget-value';
+import { StringToBooleanValueConverter } from '../value-converters/string-to-bool-value-converter';
+import { GpsComponent } from '../../../sculptor-lib/widgets/gps/gps.component';
+import { PropertyPanelField } from '../common/property-panel-field';
+let GPS = GPS_1 = class GPS extends Widget {
+    constructor(field) {
+        super(field);
+        this.component = GpsComponent;
+        this.allowPausing = false;
+        this.captureType = '';
+        this.showPointSelection = '';
+        this.showPolygonSelection = '';
+        this.showPolylineSelection = '';
+        this.mapZoomLevel = '';
+        this.changeField = '';
+        this.markup = '';
+        this.widgetIcon = 'axo_location';
+        this.validate = true;
+        if (field) {
+            this.gps(field);
+        }
+        else {
+            this.newGps();
+        }
+    }
+    /**
+     * 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, GPSWidgetValue);
+            if (Array.isArray(newValue)) {
+                return JSON.stringify(newValue[0].value[0]);
+            }
+            else {
+                return '';
+            }
+        }
+        else {
+            return '';
+        }
+    }
+    // Function to create new report object
+    newGps() {
+        this.captureType = 'manual';
+        this.showPointSelection = 'show';
+        this.allowPausing = null;
+        this.showPolygonSelection = 'show';
+        this.mapZoomLevel = '15';
+        this.changeField = null;
+        this.value = null;
+        this.showPolylineSelection = 'show';
+        this.name = 'GPS';
+    }
+    /**function to create counter object with existing values
+    *
+    *@param field
+    *
+    */
+    gps(field) {
+        this.captureType = field.captureType;
+        this.showPointSelection = field.showPointSelection;
+        this.allowPausing = field.allowPausing;
+        this.showPolygonSelection = field.showPolygonSelection;
+        this.mapZoomLevel = field.mapZoomLevel;
+        this.changeField = field.changeField;
+        this.value = field.value;
+        this.showPolylineSelection = field.showPolylineSelection;
+        this.name = 'GPS';
+    }
+    // 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 = GPS_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.allowPausing, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Boolean)
+], GPS.prototype, "allowPausing", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'select', label: 'Capture type', choices: [{ value: 'manual', text: 'Manual' }, { value: 'ontap', text: 'On Tap' }, { value: 'onsubmit', text: 'On Submit' }],
+        helpText: 'Capture type', sortIndex: 1
+    }),
+    JsonProperty(Constants.captureType, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], GPS.prototype, "captureType", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'select', label: 'Point Selection', choices: [{ value: 'show', text: 'Show' }, { value: 'hide', text: 'Hide' }], conditionInputType: 'captureType', conditionInputData: ['manual'],
+        helpText: 'Allow Point selection option while selecting location', sortIndex: 2
+    }),
+    JsonProperty(Constants.showPointSelection, StringToBooleanValueConverter, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], GPS.prototype, "showPointSelection", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'select', label: 'Polygon Selection', choices: [{ value: 'show', text: 'Show' }, { value: 'hide', text: 'Hide' }], conditionInputType: 'captureType', conditionInputData: ['manual'],
+        helpText: 'Allow Polygon selection option while selecting location', sortIndex: 3
+    }),
+    JsonProperty(Constants.showPolygonSelection, StringToBooleanValueConverter, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], GPS.prototype, "showPolygonSelection", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'select', label: 'Polyline Selection', choices: [{ value: 'show', text: 'Show' }, { value: 'hide', text: 'Hide' }], conditionInputType: 'captureType', conditionInputData: ['manual'],
+        helpText: 'Allow Polyline selection option while selecting location', sortIndex: 4
+    }),
+    JsonProperty(Constants.showPolylineSelection, StringToBooleanValueConverter, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], GPS.prototype, "showPolylineSelection", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'number', label: 'Map zoom level', conditionInputType: 'captureType', conditionInputData: ['manual'],
+        helpText: 'The default zoom level for map', sortIndex: 5
+    }),
+    JsonProperty(Constants.mapZoomLevel, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], GPS.prototype, "mapZoomLevel", void 0);
+__decorate([
+    JsonProperty(Constants.changeField, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], GPS.prototype, "changeField", void 0);
+__decorate([
+    JsonProperty(Constants.updateIdentifierCheck, Number, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Number)
+], GPS.prototype, "updateIdentifierCheck", void 0);
+__decorate([
+    JsonProperty(Constants.allowViewObject, Number, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Number)
+], GPS.prototype, "allowViewObject", void 0);
+__decorate([
+    JsonProperty(Constants.markup, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], GPS.prototype, "markup", void 0);
+GPS = GPS_1 = __decorate([
+    JsonObject('GPS'),
+    __metadata("design:paramtypes", [Widget])
+], GPS);
+export { GPS };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gps.js","sourceRoot":"","sources":["../../../../../../../src/ax-app-common-lib/src/lib/forms/page/widgets/gps.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 { GPSWidgetValue } from './widget-value/gps-widget-value';\nimport { StringToBooleanValueConverter } from '../value-converters/string-to-bool-value-converter';\nimport { GpsComponent } from '../../../sculptor-lib/widgets/gps/gps.component';\nimport { PropertyPanelField, PropertyPanelFieldMetadata } from '../common/property-panel-field';\n\ntype GPSValue = Type<Array<GPSWidgetValue>>;\n@JsonObject('GPS')\nexport class GPS extends Widget {\n    component: Type<GpsComponent>  = GpsComponent;\n\n    @JsonProperty(Constants.allowPausing, String, PropertyConvertingMode.IGNORE_NULLABLE)\n    allowPausing: boolean = false;\n\n    @PropertyPanelField ({\n        inputType : 'select' , label :'Capture type' , choices :[ {value: 'manual', text: 'Manual'}, {value: 'ontap', text: 'On Tap'} ,{value: 'onsubmit', text: 'On Submit'}],\n        helpText :'Capture type', sortIndex : 1\n    })\n    @JsonProperty(Constants.captureType , String, PropertyConvertingMode.IGNORE_NULLABLE)\n    captureType: string = '';\n\n    @PropertyPanelField ({\n        inputType : 'select' , label :'Point Selection' , choices :[ {value: 'show', text: 'Show'}, {value: 'hide', text: 'Hide'} ] , conditionInputType :'captureType' , conditionInputData :['manual'],\n        helpText :'Allow Point selection option while selecting location', sortIndex : 2\n    })\n    @JsonProperty(Constants.showPointSelection , StringToBooleanValueConverter, PropertyConvertingMode.IGNORE_NULLABLE)\n    showPointSelection: string = '';\n\n    @PropertyPanelField ({\n        inputType : 'select' , label :'Polygon Selection' , choices :[ {value: 'show', text: 'Show'}, {value: 'hide', text: 'Hide'} ] , conditionInputType :'captureType' , conditionInputData :['manual'],\n        helpText :'Allow Polygon selection option while selecting location', sortIndex : 3\n    })  \n    @JsonProperty(Constants.showPolygonSelection , StringToBooleanValueConverter, PropertyConvertingMode.IGNORE_NULLABLE)\n    showPolygonSelection: string = '';\n\n    @PropertyPanelField ({\n        inputType : 'select' , label :'Polyline Selection' , choices :[ {value: 'show', text: 'Show'}, {value: 'hide', text: 'Hide'} ] , conditionInputType :'captureType' , conditionInputData :['manual'],\n        helpText :'Allow Polyline selection option while selecting location', sortIndex : 4\n    }) \n    @JsonProperty(Constants.showPolylineSelection , StringToBooleanValueConverter, PropertyConvertingMode.IGNORE_NULLABLE)\n    showPolylineSelection: string = '';\n\n    @PropertyPanelField ({\n        inputType :'number' , label :'Map zoom level' , conditionInputType : 'captureType' , conditionInputData :['manual'],\n        helpText :'The default zoom level for map' , sortIndex : 5\n    })\n    @JsonProperty(Constants.mapZoomLevel , String, PropertyConvertingMode.IGNORE_NULLABLE)\n    mapZoomLevel: string = '';\n\n    @JsonProperty(Constants.changeField , String, PropertyConvertingMode.IGNORE_NULLABLE)\n    changeField: string = '';\n\n    @JsonProperty(Constants.updateIdentifierCheck , Number, PropertyConvertingMode.IGNORE_NULLABLE)\n    updateIdentifierCheck: number;\n\n    @JsonProperty(Constants.allowViewObject , Number, PropertyConvertingMode.IGNORE_NULLABLE)\n    allowViewObject: number;\n\n    @JsonProperty(Constants.markup , String, PropertyConvertingMode.IGNORE_NULLABLE)\n    markup: string = '';\n\n    widgetIcon: string ='axo_location';\n\n    value: GPSValue;\n    validate: boolean = true;\n\n    constructor(field?: Widget) {\n        super(field);\n        if (field) {\n            this.gps(field);\n        }\n        else {\n            this.newGps();\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 GPSValue;\n            const newValue = jsonConvert.serialize(value,GPSWidgetValue);\n            if(Array.isArray(newValue))\n                {return JSON.stringify(newValue[0].value[0]);}\n            else\n                {return '';}\n\n        }\n        else{\n            return '';\n        }\n\n    }\n    // Function to create new report object\n    newGps(): void {\n        this.captureType = 'manual';\n        this.showPointSelection = 'show';\n        this.allowPausing = null;\n        this.showPolygonSelection = 'show';\n        this.mapZoomLevel = '15';\n        this.changeField = null;\n        this.value = null;\n        this.showPolylineSelection = 'show'\n        this.name = 'GPS';\n    }\n\n    /**function to create counter object with existing values\n    *\n    *@param field\n    *\n    */\n    gps(field): void {\n        this.captureType = field.captureType;\n        this.showPointSelection = field.showPointSelection;\n        this.allowPausing = field.allowPausing;\n        this.showPolygonSelection = field.showPolygonSelection;\n        this.mapZoomLevel = field.mapZoomLevel;\n        this.changeField = field.changeField;\n        this.value = field.value;\n        this.showPolylineSelection = field.showPolylineSelection;\n        this.name = 'GPS';\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 = GPS.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"]}

package/esm2020/lib/forms/page/widgets/group-header.mjs

@@ -0,0 +1,200 @@
+var GroupHeader_1;
+import { __decorate, __metadata } from "tslib";
+import { Constants } from '../common/constants';
+import { Widget } from './widget';
+import { JsonObject, JsonProperty, PropertyConvertingMode } from 'json2typescript';
+import { StringToNumberConverter } from '../value-converters/string-to-number -converter';
+import { PropertyPanelField } from '../common/property-panel-field';
+import { GroupHeaderComponent } from '../../../sculptor-lib/widgets/group-header/group-header.component';
+let GroupHeader = GroupHeader_1 = class GroupHeader extends Widget {
+    constructor(field) {
+        super(field);
+        this.component = GroupHeaderComponent;
+        this.value = '';
+        this.widgetIcon = 'axo_square_text';
+        this.headerTitle = '';
+        this.integrationId = '';
+        this.initialDisplayMode = '';
+        this.subType = '';
+        this.helpMessage = '';
+        this.marPrompt = '';
+        this.hiPrompt = '';
+        this.ghSubType = '';
+        this.tePrompt = '';
+        this.formName = '';
+        if (field) {
+            this.groupHeader(field);
+        }
+        else {
+            this.newGroupHeader();
+        }
+        //this.clearValidators();
+    }
+    /**
+     * 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 Date-Time object
+    newGroupHeader() {
+        this.headerTitle = 'Group Header';
+        this.isStickyGroup = null;
+        this.initialDisplayMode = 'expand';
+        this.subType = '';
+        this.helpMessage = '';
+        this.marPrompt = null;
+        this.hiPrompt = null;
+        this.ghSubType = 'header';
+        this.tePrompt = null;
+        this.name = 'GroupHeader';
+    }
+    /**function to create Date-Time object with existing values
+    *
+    *@param field
+    *
+    */
+    groupHeader(field) {
+        this.headerTitle = field.headerTitle;
+        this.isStickyGroup = field.isStickyGroup;
+        this.initialDisplayMode = field.initialDisplayMode;
+        this.subType = field.subType;
+        this.helpMessage = field.helpMessage;
+        this.marPrompt = field.marPrompt;
+        this.hiPrompt = field.hiPrompt;
+        this.ghSubType = field.ghSubType;
+        this.tePrompt = field.tePrompt;
+        this.name = 'GroupHeader';
+    }
+    /*
+    * Override createValidators
+    */
+    createValidators() {
+        //super.createValidators();
+    }
+    /**
+     * 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 = GroupHeader_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: 'Header Title',
+        helpText: 'Group Title', sortIndex: 1
+    }),
+    JsonProperty(Constants.headerTitle, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], GroupHeader.prototype, "headerTitle", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'toggle', label: 'Sticky Group',
+        helpText: 'Allow Groupheader to Stick at top', sortIndex: 2
+    }),
+    JsonProperty(Constants.isStickyGroup, StringToNumberConverter, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Boolean)
+], GroupHeader.prototype, "isStickyGroup", void 0);
+__decorate([
+    JsonProperty(Constants.integrationId, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], GroupHeader.prototype, "integrationId", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'select', label: 'Initial Display Mode', choices: [{ value: 'expand', text: 'Expand' }, { value: 'collapse', text: 'Collapse' }], conditionInputData: ['header'], conditionInputType: 'ghSubType',
+        helpText: 'Select Initial Display Mode', sortIndex: 4
+    }),
+    JsonProperty(Constants.initialDisplayMode, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], GroupHeader.prototype, "initialDisplayMode", void 0);
+__decorate([
+    JsonProperty(Constants.subType, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], GroupHeader.prototype, "subType", void 0);
+__decorate([
+    JsonProperty(Constants.helpMessage, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], GroupHeader.prototype, "helpMessage", void 0);
+__decorate([
+    JsonProperty(Constants.marPrompt, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], GroupHeader.prototype, "marPrompt", void 0);
+__decorate([
+    JsonProperty(Constants.hiPrompt, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], GroupHeader.prototype, "hiPrompt", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'select', label: 'Subtype', choices: [{ value: 'header', text: 'Header' }, { value: 'label', text: 'Label' }],
+        helpText: 'Select subtype', sortIndex: 3
+    }),
+    JsonProperty(Constants.ghSubType, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], GroupHeader.prototype, "ghSubType", void 0);
+__decorate([
+    JsonProperty(Constants.tePrompt, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], GroupHeader.prototype, "tePrompt", void 0);
+__decorate([
+    JsonProperty(Constants.formName, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], GroupHeader.prototype, "formName", void 0);
+GroupHeader = GroupHeader_1 = __decorate([
+    JsonObject('GroupHeader'),
+    __metadata("design:paramtypes", [Widget])
+], GroupHeader);
+export { GroupHeader };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"group-header.js","sourceRoot":"","sources":["../../../../../../../src/ax-app-common-lib/src/lib/forms/page/widgets/group-header.ts"],"names":[],"mappings":"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","sourcesContent":["import { Type } from '@angular/core';\nimport { Constants } from '../common/constants';\nimport { Widget } from './widget';\nimport { JsonObject, JsonProperty, PropertyConvertingMode } from 'json2typescript';\nimport { StringToNumberConverter } from '../value-converters/string-to-number -converter';\nimport { PropertyPanelField, PropertyPanelFieldMetadata } from '../common/property-panel-field';\nimport { GroupHeaderComponent } from '../../../sculptor-lib/widgets/group-header/group-header.component';\n\n\n@JsonObject('GroupHeader')\nexport class GroupHeader extends Widget{\n\n    component: Type<GroupHeaderComponent> = GroupHeaderComponent;\n    value:  string ='';\n    widgetIcon: string = 'axo_square_text';\n\n    @PropertyPanelField ({\n        inputType : 'text', label :'Header Title',\n        helpText :'Group Title' , sortIndex : 1\n    })\n    @JsonProperty(Constants.headerTitle, String, PropertyConvertingMode.IGNORE_NULLABLE)\n    headerTitle: string = '';\n\n    @PropertyPanelField ({\n        inputType: 'toggle' , label :'Sticky Group' , \n        helpText :'Allow Groupheader to Stick at top' , sortIndex : 2 \n    })\n    @JsonProperty(Constants.isStickyGroup, StringToNumberConverter, PropertyConvertingMode.IGNORE_NULLABLE)\n    isStickyGroup: boolean ;\n\n    @JsonProperty(Constants.integrationId, String, PropertyConvertingMode.IGNORE_NULLABLE)\n    integrationId: string = '';\n\n    @PropertyPanelField ({\n        inputType : 'select' , label : 'Initial Display Mode' , choices: [ {value: 'expand', text: 'Expand'}, {value: 'collapse', text: 'Collapse'}] ,conditionInputData :['header'] , conditionInputType :'ghSubType',\n        helpText :'Select Initial Display Mode' ,  sortIndex : 4\n    })\n    @JsonProperty(Constants.initialDisplayMode, String, PropertyConvertingMode.IGNORE_NULLABLE)\n    initialDisplayMode: string = '';\n\n    @JsonProperty(Constants.subType, String, PropertyConvertingMode.IGNORE_NULLABLE)\n    subType: string = '';\n\n    @JsonProperty(Constants.helpMessage, String, PropertyConvertingMode.IGNORE_NULLABLE)\n    helpMessage: string = '';\n\n    @JsonProperty(Constants.marPrompt, String, PropertyConvertingMode.IGNORE_NULLABLE)\n    marPrompt: string = '';\n\n    @JsonProperty(Constants.hiPrompt, String, PropertyConvertingMode.IGNORE_NULLABLE)\n    hiPrompt: string = '';\n\n    @PropertyPanelField ({\n        inputType : 'select' , label : 'Subtype' , choices : [ {value: 'header', text: 'Header'}, {value: 'label', text: 'Label'}],\n        helpText :'Select subtype' , sortIndex : 3\n    })\n    @JsonProperty(Constants.ghSubType, String, PropertyConvertingMode.IGNORE_NULLABLE)\n    ghSubType: string = '';\n\n    @JsonProperty(Constants.tePrompt, String, PropertyConvertingMode.IGNORE_NULLABLE)\n    tePrompt: string = '';\n\n    @JsonProperty(Constants.formName, String, PropertyConvertingMode.IGNORE_NULLABLE)\n    formName: string = '';\n\n\n\n\n    constructor(field?: Widget){\n        super(field);\n        if(field){\n            this.groupHeader(field);\n        }\n        else{\n            this.newGroupHeader();\n        }\n        //this.clearValidators();\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            return this.value.toString();\n        }\n        else{\n            return '';\n        }\n    }\n    // Function to create new Date-Time object\n    newGroupHeader(): void{\n\n        this.headerTitle= 'Group Header';\n        this.isStickyGroup= null;\n        this.initialDisplayMode= 'expand';\n        this.subType='';\n        this.helpMessage= '';\n        this.marPrompt= null;\n        this.hiPrompt= null;\n        this.ghSubType= 'header';\n        this.tePrompt=  null;\n        this.name = 'GroupHeader';\n\n    }\n\n    /**function to create Date-Time object with existing values\n    *\n    *@param field\n    *\n    */\n    groupHeader(field): void{\n        this.headerTitle=  field.headerTitle;\n        this.isStickyGroup=  field.isStickyGroup;\n        this.initialDisplayMode=  field.initialDisplayMode;\n        this.subType= field.subType;\n        this.helpMessage=  field.helpMessage;\n        this.marPrompt=  field.marPrompt;\n        this.hiPrompt=  field.hiPrompt;\n        this.ghSubType=  field.ghSubType;\n        this.tePrompt=   field.tePrompt;\n        this.name = 'GroupHeader';\n    }\n    /*\n    * Override createValidators\n    */\n    createValidators(): void{\n        //super.createValidators();\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 = GroupHeader.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"]}

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

@@ -0,0 +1,129 @@
+var Language_1;
+import { __decorate, __metadata } from "tslib";
+import { Widget } from './widget';
+import { JsonConvert, JsonObject, JsonProperty, PropertyConvertingMode } from 'json2typescript';
+import { Constants } from '../common/constants';
+import { LanguageWidgetValue } from './widget-value/language-widget-value';
+import { LanguageSourceValueConverter } from '../value-converters/language-source-value-converter';
+import { PropertyPanelField } from '../common/property-panel-field';
+import { LanguageComponent } from '../../../sculptor-lib/widgets/language/language.component';
+let Language = Language_1 = class Language extends Widget {
+    constructor(field) {
+        super(field);
+        this.component = LanguageComponent;
+        this.widgetIcon = 'axo_square_text';
+        this.defaultValue = '';
+        this.languageSource = null;
+        this.langDefault = '';
+        if (field) {
+            this.language(field);
+        }
+        else {
+            this.newLanguage();
+        }
+        //this.clearValidators();
+    }
+    /**
+     * 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, LanguageWidgetValue);
+            return JSON.stringify(newValue);
+        }
+        else {
+            return '';
+        }
+    }
+    // Function to create new Date-Time object
+    newLanguage() {
+        this.defaultValue = 'English';
+        this.languageSource = null; //Array<LanguageObject>
+        this.langDefault = null;
+        this.name = 'Language';
+    }
+    /**function to create Date-Time object with existing values
+    *
+    *@param field
+    *
+    */
+    language(field) {
+        this.defaultValue = field.defaultValue;
+        this.languageSource = field.languageSource; //Array<LanguageObject>
+        this.langDefault = field.langDefault;
+        this.name = 'Language';
+    }
+    // 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'];
+        // 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 = Language_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: 'select', label: 'Default Langauge',
+        choices: [{ value: 'English', text: 'English' }],
+        required: false, helpText: 'Select Default Langauge'
+    }),
+    JsonProperty(Constants.langDefault, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], Language.prototype, "defaultValue", void 0);
+__decorate([
+    JsonProperty(Constants.languageSource, LanguageSourceValueConverter, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Array)
+], Language.prototype, "languageSource", void 0);
+__decorate([
+    JsonProperty(Constants.langDefault, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], Language.prototype, "langDefault", void 0);
+Language = Language_1 = __decorate([
+    JsonObject('Language'),
+    __metadata("design:paramtypes", [Language])
+], Language);
+export { Language };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"languages.js","sourceRoot":"","sources":["../../../../../../../src/ax-app-common-lib/src/lib/forms/page/widgets/languages.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 { LanguageWidgetValue } from './widget-value/language-widget-value';\nimport { LanguageSourceValueConverter } from '../value-converters/language-source-value-converter';\nimport { PropertyPanelField, PropertyPanelFieldMetadata } from '../common/property-panel-field';\nimport { LanguageComponent } from '../../../sculptor-lib/widgets/language/language.component';\n\ntype LanguageValue = Type<Array<LanguageWidgetValue>>;\n@JsonObject('Language')\nexport class Language extends Widget{\n    component: Type<LanguageComponent>= LanguageComponent;\n\n    value:  LanguageValue;\n    widgetIcon: string =  'axo_square_text';\n    @PropertyPanelField({\n        inputType: 'select', label: 'Default Langauge',\n        choices: [{ value: 'English', text: 'English' }],\n        required: false, helpText: 'Select Default Langauge'\n      })\n    @JsonProperty(Constants.langDefault ,String,PropertyConvertingMode.IGNORE_NULLABLE)\n    defaultValue: string ='';\n\n    @JsonProperty(Constants.languageSource ,LanguageSourceValueConverter,PropertyConvertingMode.IGNORE_NULLABLE)\n    languageSource: Array<LanguageWidgetValue> = null;\n\n    @JsonProperty(Constants.langDefault ,String,PropertyConvertingMode.IGNORE_NULLABLE)\n    langDefault: string='';\n\n\n\n\n\n    constructor(field?: Language){\n        super(field);\n        if(field){\n            this.language(field);\n        }\n        else{\n            this.newLanguage();\n        }\n        //this.clearValidators();\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 LanguageValue;\n            const newValue = jsonConvert.serialize(value,LanguageWidgetValue);\n            return JSON.stringify(newValue);\n        }\n        else{\n            return'';\n        }\n\n    }\n    // Function to create new Date-Time object\n    newLanguage(): void{\n        this.defaultValue= 'English';\n        this.languageSource= null ;//Array<LanguageObject>\n        this.langDefault= null;\n        this.name = 'Language';\n    }\n\n    /**function to create Date-Time object with existing values\n    *\n    *@param field\n    *\n    */\n    language(field): void{\n        this.defaultValue= field.defaultValue;\n        this.languageSource= field.languageSource ;//Array<LanguageObject>\n        this.langDefault= field.langDefault;\n        this.name = 'Language';\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'];\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 = Language.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}"]}