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

package/esm2020/lib/forms/page/widgets/ax-document.mjs

@@ -0,0 +1,149 @@
+var AxDocument_1;
+import { __decorate, __metadata } from "tslib";
+import { Widget } from './widget';
+import { JsonConvert, JsonObject, JsonProperty, PropertyConvertingMode } from 'json2typescript';
+import { Constants } from '../common/constants';
+import { DocumentWidgetValue } from './widget-value/document-widget-value';
+import { StringToBooleanValueConverter } from '../value-converters/string-to-bool-value-converter';
+import { PublicUrlsStringToArrayConverter } from '../value-converters/publicUrls-string-to-array';
+import { DocumentComponent } from '../../../sculptor-lib/widgets/document/document.component';
+import { PropertyPanelField } from '../common/property-panel-field';
+let AxDocument = AxDocument_1 = class AxDocument extends Widget {
+    constructor(field) {
+        super(field);
+        this.fileSizeLimit = 0;
+        this.allowedFileTypeTemp = '';
+        this.allowPublicUrl = true;
+        this.values = null;
+        this.publicUrls = [];
+        this.value = null;
+        this.widgetIcon = 'axo_document';
+        this.component = DocumentComponent;
+        if (field) {
+            this.document(field);
+        }
+        else {
+            this.newDocument();
+        }
+    }
+    /**
+     * 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.values) {
+            const jsonConvert = new JsonConvert();
+            const value = this.values;
+            const newValue = jsonConvert.serialize(value, DocumentWidgetValue);
+            return JSON.stringify(newValue);
+        }
+        else if (this.value) {
+            return this.value.toString();
+        }
+        else {
+            return '';
+        }
+    }
+    // Function to create new document object
+    newDocument() {
+        this.fileSizeLimit = 0;
+        this.allowedFileTypeTemp = 'pdf';
+        this.allowPublicUrl = true;
+    }
+    /**
+     * function to create document object with existing values
+     *
+     *@param field
+     *
+     */
+    document(field) {
+        this.fileSizeLimit = field.fileSizeLimit;
+        this.allowedFileTypeTemp = field.allowedFileTypeTemp;
+        this.allowPublicUrl = field.allowPublicUrl;
+    }
+    // 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 = AxDocument_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: 'number', label: 'File size limit',
+        helpText: 'Set the file size limit while uploading in MB.', sortIndex: 3
+    }),
+    JsonProperty(Constants.fileSizeLimit, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Number)
+], AxDocument.prototype, "fileSizeLimit", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'text', label: 'Allowed file type',
+        helpText: 'enter the file extensions one on each line (doc, docx, pdf, xls, xlsx, ppt, pptx, odt, txt, html)', sortIndex: 2
+    }),
+    JsonProperty(Constants.allowedFileTypeTemp, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], AxDocument.prototype, "allowedFileTypeTemp", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'toggle', label: 'Generate public URL for accessing documents?',
+        helpText: 'Generate public URL for accessing documents?', sortIndex: 1
+    }),
+    JsonProperty(Constants.allowPublicUrl, StringToBooleanValueConverter, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Boolean)
+], AxDocument.prototype, "allowPublicUrl", void 0);
+__decorate([
+    JsonProperty('values', [DocumentWidgetValue], PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Array)
+], AxDocument.prototype, "values", void 0);
+__decorate([
+    JsonProperty(Constants.documentPublicUrls, PublicUrlsStringToArrayConverter, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Array)
+], AxDocument.prototype, "publicUrls", void 0);
+AxDocument = AxDocument_1 = __decorate([
+    JsonObject('AxDocument'),
+    __metadata("design:paramtypes", [Widget])
+], AxDocument);
+export { AxDocument };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ax-document.js","sourceRoot":"","sources":["../../../../../../../src/ax-app-common-lib/src/lib/forms/page/widgets/ax-document.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 { DocumentWidgetValue } from './widget-value/document-widget-value';\nimport { StringToBooleanValueConverter } from '../value-converters/string-to-bool-value-converter';\nimport { PublicUrlsStringToArrayConverter } from '../value-converters/publicUrls-string-to-array';\nimport { DocumentComponent } from '../../../sculptor-lib/widgets/document/document.component';\nimport { PropertyPanelField, PropertyPanelFieldMetadata } from '../common/property-panel-field';\n\ntype DocumentValue = Type<string | Array<DocumentWidgetValue>>;\n@JsonObject('AxDocument')\nexport class AxDocument extends Widget {\n\n    @PropertyPanelField({\n        inputType: 'number', label: 'File size limit',\n        helpText: 'Set the file size limit while uploading in MB.' , sortIndex :3\n      })\n    @JsonProperty(Constants.fileSizeLimit, String, PropertyConvertingMode.IGNORE_NULLABLE)\n    fileSizeLimit: number = 0;\n\n    @PropertyPanelField({\n        inputType: 'text', label: 'Allowed file type',\n        helpText: 'enter the file extensions one on each line (doc, docx, pdf, xls, xlsx, ppt, pptx, odt, txt, html)' , sortIndex :2\n      })\n    @JsonProperty(Constants.allowedFileTypeTemp, String, PropertyConvertingMode.IGNORE_NULLABLE)\n    allowedFileTypeTemp: string = '';\n\n    @PropertyPanelField({\n        inputType: 'toggle', label: 'Generate public URL for accessing documents?',\n        helpText: 'Generate public URL for accessing documents?',  sortIndex: 1\n    })\n    @JsonProperty(Constants.allowPublicUrl, StringToBooleanValueConverter, PropertyConvertingMode.IGNORE_NULLABLE)\n    allowPublicUrl: boolean = true;\n\n    @JsonProperty('values', [DocumentWidgetValue], PropertyConvertingMode.IGNORE_NULLABLE)\n    values: Array<DocumentWidgetValue> = null;\n\n    @JsonProperty(Constants.documentPublicUrls, PublicUrlsStringToArrayConverter, PropertyConvertingMode.IGNORE_NULLABLE)\n    publicUrls: string[] = [];\n\n    value: DocumentValue = null;\n    widgetIcon: string ='axo_document';\n\n    component: Type<DocumentComponent> = DocumentComponent;\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.values){\n            const jsonConvert: JsonConvert = new JsonConvert();\n            const value = this.values as Array<DocumentWidgetValue>;\n            const newValue = jsonConvert.serialize(value,DocumentWidgetValue);\n            return JSON.stringify(newValue);\n        }\n        else if(this.value){\n            return this.value.toString();\n        }\n        else{\n            return '';\n        }\n    }\n\n\n    constructor(field?: Widget) {\n        super(field);\n        if (field) {\n            this.document(field);\n        }\n        else {\n            this.newDocument();\n        }\n    }\n    // Function to create new document object\n    newDocument(): void {\n        this.fileSizeLimit = 0;\n        this.allowedFileTypeTemp = 'pdf';\n        this.allowPublicUrl = true;\n\n    }\n\n    /**\n     * function to create document object with existing values\n     *\n     *@param field\n     *\n     */\n    document(field): void {\n        this.fileSizeLimit = field.fileSizeLimit;\n        this.allowedFileTypeTemp = field.allowedFileTypeTemp;\n        this.allowPublicUrl = field.allowPublicUrl;\n\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 = AxDocument.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/ax-image.mjs

@@ -0,0 +1,183 @@
+var AxImage_1;
+import { __decorate, __metadata } from "tslib";
+import { Widget } from './widget';
+import { JsonConvert, JsonObject, JsonProperty, PropertyConvertingMode } from 'json2typescript';
+import { Constants } from '../common/constants';
+import { ImageWidgetValue } from './widget-value/image-widget-value';
+import { StringToBooleanValueConverter } from '../value-converters/string-to-bool-value-converter';
+import { ImageComponent } from '../../../sculptor-lib/widgets/image/image.component';
+import { PropertyPanelField } from '../common/property-panel-field';
+let AxImage = AxImage_1 = class AxImage extends Widget {
+    constructor(field) {
+        super(field);
+        this.component = ImageComponent;
+        this.value = [];
+        this.allowedImageTypes = [];
+        this.showTimeStamp = false;
+        this.generatePublicUrl = false;
+        this.allowBrowsing = false;
+        this.allowAnnotations = '';
+        this.includeNotes = false;
+        this.allowPublicUrl = false;
+        this.publicUrls = [];
+        this.widgetIcon = 'axo_image';
+        if (field) {
+            this.image(field);
+        }
+        else {
+            this.newImage();
+        }
+    }
+    /**
+     * get widget value
+     *
+     * @returns
+     */
+    getWidgetValue() {
+        return this.value;
+    }
+    /**
+     * this will return serialize of widget
+     */
+    getWidgetSerializedValue() {
+        if (this.value) {
+            const jsonConvert = new JsonConvert();
+            const value = this.value;
+            const newValue = jsonConvert.serialize(value, ImageWidgetValue);
+            return JSON.stringify(newValue);
+        }
+        else {
+            return '';
+        }
+    }
+    /**
+     * Set widget Value
+     *
+     * @param value
+     */
+    setWidgetValue(value) {
+        this.value = value;
+    }
+    // Function to create new Image object
+    newImage() {
+        this.allowedImageTypes = null;
+        this.maxSize = null;
+        this.minSize = null;
+        this.includeNotes = true;
+        this.showTimeStamp = false;
+        this.generatePublicUrl = null;
+        this.allowBrowsing = true;
+        this.allowAnnotations = null;
+        this.allowPublicUrl = true;
+    }
+    /**function to create Image object with existing values
+    *
+    *@param field
+    *
+    */
+    image(field) {
+        this.allowedImageTypes = ['png', 'jpg', 'jpeg', 'gif'];
+        this.maxSize = field.maxSize;
+        this.minSize = field.minSize;
+        this.showTimeStamp = field.showTimeStamp;
+        this.generatePublicUrl = field.generatePublicUrl;
+        this.allowBrowsing = field.allowBrowsing;
+        this.allowAnnotations = field.allowAnnotations;
+        this.includeNotes = field.includeNotes;
+        this.allowPublicUrl = field.allowPublicUrl;
+    }
+    // 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 = AxImage_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.allowedImageTypes, [String], PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Array)
+], AxImage.prototype, "allowedImageTypes", void 0);
+__decorate([
+    JsonProperty(),
+    __metadata("design:type", Number)
+], AxImage.prototype, "maxSize", void 0);
+__decorate([
+    JsonProperty(),
+    __metadata("design:type", Number)
+], AxImage.prototype, "minSize", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'toggle', label: 'Show Timestamp',
+        helpText: 'To show timestamp when image is captured', sortIndex: 4
+    }),
+    JsonProperty(Constants.showTimeStamp, Boolean, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Boolean)
+], AxImage.prototype, "showTimeStamp", void 0);
+__decorate([
+    JsonProperty(Constants.generatePublicUrl, Boolean, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Boolean)
+], AxImage.prototype, "generatePublicUrl", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'toggle', label: 'Allow browsing',
+        helpText: 'Allow browsing gallery?', sortIndex: 3
+    }),
+    JsonProperty(Constants.allowBrowsing, StringToBooleanValueConverter, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Boolean)
+], AxImage.prototype, "allowBrowsing", void 0);
+__decorate([
+    JsonProperty(Constants.allowAnnotations, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], AxImage.prototype, "allowAnnotations", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'toggle', label: 'Include Notes?',
+        helpText: 'Include note to each annotation by default?', sortIndex: 2
+    }),
+    JsonProperty(Constants.includeNotes, StringToBooleanValueConverter, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Boolean)
+], AxImage.prototype, "includeNotes", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'toggle', label: 'Generate public URL for accessing photos?',
+        helpText: 'Generate public URL for accessing photos?', sortIndex: 1
+    }),
+    JsonProperty(Constants.allowPublicUrl, StringToBooleanValueConverter, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Boolean)
+], AxImage.prototype, "allowPublicUrl", void 0);
+__decorate([
+    JsonProperty(Constants.imagePublicUrls, [String], PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Array)
+], AxImage.prototype, "publicUrls", void 0);
+AxImage = AxImage_1 = __decorate([
+    JsonObject('AxImage'),
+    __metadata("design:paramtypes", [Widget])
+], AxImage);
+export { AxImage };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ax-image.js","sourceRoot":"","sources":["../../../../../../../src/ax-app-common-lib/src/lib/forms/page/widgets/ax-image.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 { ImageWidgetValue } from './widget-value/image-widget-value';\nimport { StringToBooleanConverter } from '../value-converters/string-to-bool-converter';\nimport { StringToBooleanValueConverter } from '../value-converters/string-to-bool-value-converter';\nimport { ImageComponent } from '../../../sculptor-lib/widgets/image/image.component';\nimport { PropertyPanelField, PropertyPanelFieldMetadata } from '../common/property-panel-field';\n\n@JsonObject('AxImage')\nexport class AxImage extends Widget{\n    component: Type<ImageComponent> = ImageComponent;\n    value: Array<ImageWidgetValue> = [];\n\n\n    @JsonProperty(Constants.allowedImageTypes, [String], PropertyConvertingMode.IGNORE_NULLABLE)\n    allowedImageTypes: string[] = [];\n    @JsonProperty()\n    maxSize: number;\n    @JsonProperty()\n    minSize: number;\n\n    @PropertyPanelField ({\n        inputType: 'toggle', label: 'Show Timestamp',\n        helpText: 'To show timestamp when image is captured', sortIndex: 4\n    })\n    @JsonProperty(Constants.showTimeStamp, Boolean, PropertyConvertingMode.IGNORE_NULLABLE)\n    showTimeStamp: boolean = false;\n\n    @JsonProperty(Constants.generatePublicUrl, Boolean, PropertyConvertingMode.IGNORE_NULLABLE)\n    generatePublicUrl: boolean = false;\n\n    @PropertyPanelField ({\n        inputType: 'toggle', label: 'Allow browsing',\n        helpText: 'Allow browsing gallery?', sortIndex: 3\n    })\n    @JsonProperty(Constants.allowBrowsing, StringToBooleanValueConverter, PropertyConvertingMode.IGNORE_NULLABLE)\n    allowBrowsing: boolean = false;\n    \n    @JsonProperty(Constants.allowAnnotations, String, PropertyConvertingMode.IGNORE_NULLABLE)\n    allowAnnotations: string = '';\n\n    @PropertyPanelField ({\n        inputType: 'toggle', label: 'Include Notes?',\n        helpText: 'Include note to each annotation by default?', sortIndex: 2\n    })\n    @JsonProperty(Constants.includeNotes, StringToBooleanValueConverter, PropertyConvertingMode.IGNORE_NULLABLE)\n    includeNotes: boolean = false;\n\n    @PropertyPanelField ({\n        inputType: 'toggle', label: 'Generate public URL for accessing photos?',\n        helpText: 'Generate public URL for accessing photos?', sortIndex: 1\n    })\n    @JsonProperty(Constants.allowPublicUrl, StringToBooleanValueConverter, PropertyConvertingMode.IGNORE_NULLABLE)\n    allowPublicUrl: boolean = false;\n\n    @JsonProperty(Constants.imagePublicUrls, [String], PropertyConvertingMode.IGNORE_NULLABLE)\n    publicUrls: string[] = [];\n\n    widgetIcon: string = 'axo_image';\n\n    constructor(field?: Widget){\n        super(field);\n        if(field){\n            this.image(field);\n        }\n        else{\n            this.newImage();\n        }\n    }\n    /**\n     * get widget value\n     *\n     * @returns\n     */\n    getWidgetValue(): any {\n        return this.value;\n    }\n\n    /**\n     * this will return serialize of widget\n     */\n     getWidgetSerializedValue() {\n        if(this.value){\n            const jsonConvert: JsonConvert = new JsonConvert();\n            const value = this.value as Array<ImageWidgetValue>;\n            const newValue = jsonConvert.serialize(value,ImageWidgetValue);\n            return JSON.stringify(newValue);\n        }\n        else{\n            return'';\n        }\n\n    }\n\n    /**\n     * Set widget Value\n     *\n     * @param value\n     */\n    setWidgetValue(value: any) {\n        this.value = value;\n    }\n    // Function to create new Image object\n    newImage(): void{\n        this.allowedImageTypes = null;\n        this.maxSize=null;\n        this.minSize=null;\n        this.includeNotes= true;\n        this.showTimeStamp= false;\n        this.generatePublicUrl= null;\n        this.allowBrowsing= true;\n        this.allowAnnotations= null;\n        this.allowPublicUrl= true;\n    }\n\n    /**function to create Image object with existing values\n    *\n    *@param field\n    *\n    */\n    image(field): void{\n        this.allowedImageTypes = ['png','jpg','jpeg','gif'];\n        this.maxSize=field.maxSize;\n        this.minSize=field.minSize;\n        this.showTimeStamp=field.showTimeStamp;\n        this.generatePublicUrl= field.generatePublicUrl;\n        this.allowBrowsing= field.allowBrowsing;\n        this.allowAnnotations= field.allowAnnotations;\n        this.includeNotes= field.includeNotes;\n        this.allowPublicUrl= field.allowPublicUrl;\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 = AxImage.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/bar-code.mjs

@@ -0,0 +1,212 @@
+var BarCode_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 { PropertyPanelField } from '../common/property-panel-field';
+import { BarcodeComponent } from '../../../sculptor-lib/widgets/barcode/barcode.component';
+let BarCode = BarCode_1 = class BarCode extends Widget {
+    constructor(field) {
+        super(field);
+        this.component = BarcodeComponent;
+        this.value = '';
+        this.widgetIcon = 'axo_barcode';
+        this.barCodeSubType = '';
+        this.textEditable = false;
+        this.multiSelect = false;
+        this.teChoices = '';
+        this.scanQRCode = false;
+        this.deviceProfilesTemp = null; //DeviceProfilesTempObject
+        this.defaultDeviceProfileId = '';
+        this.deviceProfiles = []; //DeviceProfilesObject
+        /* SubPage may have more than one widget so make this as group widget*/
+        this.captureLocation = false;
+        if (field) {
+            this.barCode(field);
+        }
+        else {
+            this.newBarCode();
+        }
+    }
+    /**
+     * 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
+    newBarCode() {
+        this.barCodeSubType = 'number';
+        // this.textEditable = null;
+        // this.scanQRCode = 1;
+        // this.multipleSelection = null;
+        // this.deviceProfiles = null;
+        // this.deviceProfilesTemp = null;
+        // this.defaultDeviceProfileId= '';
+        this.captureLocation = true;
+        this.choices = '';
+        this.defaultChoice = '';
+    }
+    /**
+     * function to create report object with existing values
+     *
+     *@param Report
+     *
+     */
+    barCode(field) {
+        this.textEditable = field.textEditable;
+        this.scanQRCode = field.scanQRCode;
+        this.multiSelect = field.multiSelect;
+        this.deviceProfiles = field.deviceProfiles;
+        this.deviceProfilesTemp = field.deviceProfilesTemp;
+        this.defaultDeviceProfileId = field.defaultDeviceProfileId;
+        this.captureLocation = field.captureLocation;
+        this.choices = field.choices;
+        this.defaultChoice = field.defaultChoice;
+        this.barCodeSubType = field.barCodeSubType;
+    }
+    /**
+     * 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 = ['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 = BarCode_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: 'Subtype', choices: [{ value: 'number', text: 'Default' }, { value: 'scan_with_location', text: 'Scan With location' }],
+        helpText: 'Select Subtype', sortIndex: 0
+    }),
+    JsonProperty(Constants.barCodeSubType, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], BarCode.prototype, "barCodeSubType", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'toggle', label: 'Text Editable',
+        helpText: 'Allow entering barcode number manually', sortIndex: 1
+    }),
+    JsonProperty(Constants.textEditable, StringToBooleanValueConverter, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Boolean)
+], BarCode.prototype, "textEditable", void 0);
+__decorate([
+    PropertyPanelField({ inputType: 'toggle', label: 'Multiple Selection',
+        helpText: 'Allow selecting multiple choices or only one?', sortIndex: 7 }),
+    JsonProperty(Constants.multiSelect, StringToBooleanValueConverter, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Boolean)
+], BarCode.prototype, "multiSelect", void 0);
+__decorate([
+    JsonProperty(Constants.teChoices, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], BarCode.prototype, "teChoices", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'toggle', label: 'Scan QR Codes?',
+        helpText: 'Allow to scan QR codes', sortIndex: 2
+    }),
+    JsonProperty(Constants.scanQRCode, StringToBooleanValueConverter, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Boolean)
+], BarCode.prototype, "scanQRCode", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'text', label: 'Device Profiles',
+        helpText: 'Enter the Device profiles', sortIndex: 3
+    }),
+    JsonProperty(Constants.deviceProfilesTemp, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Array)
+], BarCode.prototype, "deviceProfilesTemp", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'select', label: 'Default Device Profile', choices: [{ value: 'builtin_camera', text: 'Build In Camera' }],
+        helpText: 'Select the Default Device profile', sortIndex: 4
+    }),
+    JsonProperty(Constants.defaultDeviceProfileId, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], BarCode.prototype, "defaultDeviceProfileId", void 0);
+__decorate([
+    JsonProperty(Constants.deviceProfiles, [], PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Array)
+], BarCode.prototype, "deviceProfiles", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'toggle', label: 'Capture GPS Location',
+        helpText: 'Capture GPS Location', conditionInputData: ['scan_with_location'], conditionInputType: 'barCodeSubType', sortIndex: 6
+    }),
+    JsonProperty(Constants.captureLocation, StringToBooleanValueConverter, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Boolean)
+], BarCode.prototype, "captureLocation", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'text', label: 'Choices (default)',
+        helpText: 'Enter choices, one per line', sortIndex: 5
+    }),
+    JsonProperty(Constants.defaultChoice, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], BarCode.prototype, "defaultChoice", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'text', label: 'Choices',
+        helpText: 'Enter choices, one per line', sortIndex: 8
+    }),
+    JsonProperty(Constants.choices, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], BarCode.prototype, "choices", void 0);
+BarCode = BarCode_1 = __decorate([
+    JsonObject('BarCode'),
+    __metadata("design:paramtypes", [BarCode])
+], BarCode);
+export { BarCode };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bar-code.js","sourceRoot":"","sources":["../../../../../../../src/ax-app-common-lib/src/lib/forms/page/widgets/bar-code.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 { DeviceProfilesTemp } from './widget-value/deviceProfilesTemp';\nimport { StringToBooleanValueConverter } from '../value-converters/string-to-bool-value-converter';\nimport { PropertyPanelField, PropertyPanelFieldMetadata } from '../common/property-panel-field';\nimport { BarcodeComponent } from '../../../sculptor-lib/widgets/barcode/barcode.component';\n\n@JsonObject('BarCode')\nexport class BarCode extends Widget{\n    component: Type<BarcodeComponent> = BarcodeComponent;\n\n\n    value: string = '';\n    widgetIcon: string ='axo_barcode';\n    @PropertyPanelField({\n        inputType: 'select', label: 'Subtype', choices: [{ value: 'number', text: 'Default' }, { value: 'scan_with_location', text: 'Scan With location' }],\n        helpText: 'Select Subtype', sortIndex: 0\n    })\n    @JsonProperty(Constants.barCodeSubType, String, PropertyConvertingMode.IGNORE_NULLABLE)\n    barCodeSubType: string = '';\n\n    @PropertyPanelField({\n        inputType: 'toggle', label: 'Text Editable',\n        helpText: 'Allow entering barcode number manually', sortIndex: 1\n    })\n    @JsonProperty(Constants.textEditable, StringToBooleanValueConverter, PropertyConvertingMode.IGNORE_NULLABLE)\n    textEditable: boolean = false;\n\n    @PropertyPanelField({ inputType: 'toggle', label: 'Multiple Selection',\n    helpText:'Allow selecting multiple choices or only one?' , sortIndex : 7 })\n    @JsonProperty(Constants.multiSelect, StringToBooleanValueConverter, PropertyConvertingMode.IGNORE_NULLABLE)\n    multiSelect: boolean = false;\n\n    @JsonProperty(Constants.teChoices, String, PropertyConvertingMode.IGNORE_NULLABLE)\n    teChoices: string = '';\n\n    @PropertyPanelField({\n        inputType: 'toggle', label: 'Scan QR Codes?',\n        helpText: 'Allow to scan QR codes', sortIndex: 2\n    })\n    @JsonProperty(Constants.scanQRCode, StringToBooleanValueConverter, PropertyConvertingMode.IGNORE_NULLABLE)\n    scanQRCode: boolean = false;\n\n    @PropertyPanelField({\n        inputType: 'text', label: 'Device Profiles',\n        helpText: 'Enter the Device profiles', sortIndex: 3\n    })\n    @JsonProperty(Constants.deviceProfilesTemp, String, PropertyConvertingMode.IGNORE_NULLABLE)\n    deviceProfilesTemp: Array<DeviceProfilesTemp> = null;//DeviceProfilesTempObject\n\n    @PropertyPanelField({\n        inputType: 'select', label: 'Default Device Profile', choices: [{ value: 'builtin_camera', text: 'Build In Camera' }],\n        helpText: 'Select the Default Device profile', sortIndex: 4\n    })\n    @JsonProperty(Constants.defaultDeviceProfileId, String, PropertyConvertingMode.IGNORE_NULLABLE)\n    defaultDeviceProfileId: string = '';\n\n    @JsonProperty(Constants.deviceProfiles, [], PropertyConvertingMode.IGNORE_NULLABLE)\n    deviceProfiles: Array<any> = [];//DeviceProfilesObject\n    /* SubPage may have more than one widget so make this as group widget*/\n    @PropertyPanelField({\n        inputType: 'toggle', label: 'Capture GPS Location',\n        helpText: 'Capture GPS Location', conditionInputData: ['scan_with_location'], conditionInputType: 'barCodeSubType', sortIndex: 6\n    })\n    @JsonProperty(Constants.captureLocation, StringToBooleanValueConverter, PropertyConvertingMode.IGNORE_NULLABLE)\n    captureLocation: boolean = false;\n\n    @PropertyPanelField({\n        inputType: 'text', label: 'Choices (default)', \n        helpText: 'Enter choices, one per line', sortIndex : 5\n      })\n    @JsonProperty(Constants.defaultChoice, String, PropertyConvertingMode.IGNORE_NULLABLE)\n      defaultChoice: string;\n\n    @PropertyPanelField({\n        inputType: 'text', label: 'Choices',\n        helpText: 'Enter choices, one per line' , sortIndex : 8\n        })\n    @JsonProperty(Constants.choices, String, PropertyConvertingMode.IGNORE_NULLABLE)\n    choices: string;\n\n    constructor(field?: BarCode) {\n        super(field);\n        if (field) {\n            this.barCode(field);\n        }\n        else {\n            this.newBarCode();\n        }\n    }\n\n    /**\n     * get widget value\n     *\n     * @returns\n     */\n    getWidgetValue(): any {\n        return this.value;\n    }\n\n    /**\n     * Set widget Value\n     *\n     * @param value\n     */\n    setWidgetValue(value: any) {\n        this.value = value;\n    }\n\n    /**\n     * this will return serialize of widget\n     */\n    getWidgetSerializedValue() {\n        if (this.value) {\n            return this.value.toString();\n        }\n        else {\n            return '';\n        }\n    }\n\n    // Function to create new report object\n    newBarCode(): void {\n        this.barCodeSubType = 'number';\n        // this.textEditable = null;\n        // this.scanQRCode = 1;\n        // this.multipleSelection = null;\n        // this.deviceProfiles = null;\n        // this.deviceProfilesTemp = null;\n        // this.defaultDeviceProfileId= '';\n        this.captureLocation = true;\n        this.choices='';\n        this.defaultChoice='';\n    }\n\n\n    /**\n     * function to create report object with existing values\n     *\n     *@param Report\n     *\n     */\n    barCode(field): void {\n\n        this.textEditable = field.textEditable;\n        this.scanQRCode = field.scanQRCode;\n        this.multiSelect = field.multiSelect;\n        this.deviceProfiles = field.deviceProfiles;\n        this.deviceProfilesTemp = field.deviceProfilesTemp;\n        this.defaultDeviceProfileId = field.defaultDeviceProfileId;\n        this.captureLocation = field.captureLocation;\n        this.choices=field.choices;\n        this.defaultChoice = field.defaultChoice;\n        this.barCodeSubType = field.barCodeSubType;\n    }\n    /**\n     * Create FormControl for widget\n     */\n    createFormControl() {\n        throw new Error('Method not implemented.');\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=['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 = BarCode.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        }\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}"]}