@flexem/fc-gui 3.0.0-alpha.91 → 3.0.0-alpha.92

package/src/shared/disposable.ts

@@ -1,3 +0,0 @@
-export interface Disposable {
-    dispose();
-}

package/src/shared/gui-consts.ts

@@ -1,33 +0,0 @@
-export class GuiConsts {
-
-    static readonly components = {
-        imageKey: 'Image',
-        numericalDisplayKey: 'NumericalDisplay',
-        textKey: 'Text',
-        hyperlinkKey: 'Hyperlink',
-        meterKey: 'Meter',
-        pipeKey: 'Pipe',
-        switchIndicatorLightKey: 'SwitchIndicatorLight',
-        barGraphKey: 'BarGraph',
-        /**
-         * 切换画面已经改为画面操作
-         */
-        toggleViewKey: 'ToggleView',
-        characterKey: 'Character',
-        straightLineKey: 'StraightLine',
-        polyLineKey: 'PolyLine',
-        rectangleKey: 'Rectangle',
-        sectorkey: 'Sector',
-        ellipseKey: 'Ellipse',
-        datetimeDisplayKey: 'DatetimeDisplay',
-        historicalCurveKey: 'HistoricalCurve',
-        ringGraphKey: 'RingGraph',
-        viewOperationElement: 'ViewOperation',
-        polygonKey: 'Polygon',
-        videokey: 'Video',
-        tableKey: 'Table',
-        weatherKey: 'Weather',
-        airQualityKey: 'AirQualityIndex',
-        alarmKey: 'Alarm'
-    };
-}

package/src/shared/operation-helper.ts

@@ -1,42 +0,0 @@
-import { FCloudDataType } from '../model/shared/data-type/fcloud-data-Type';
-import { isNil } from 'lodash';
-
-export class OperationHelper {
-
-    static add(value: number, operand: number, dataType: number, maxValue: number) {
-        if (!dataType) {
-            return value + operand;
-        }
-        if (!isNil(maxValue)) {
-            return Math.min(value + operand, maxValue);
-        }
-        return Math.min(value + operand, OperationHelper.getMax(dataType));
-    }
-
-    static subtract(value: number, operand: number, dataType: number, minValue: number) {
-        if (!dataType) {
-            return value - operand;
-        }
-        if (!isNil(minValue)) {
-            return Math.max(value - operand, minValue);
-        }
-        return Math.max(value - operand, OperationHelper.getMin(dataType));
-    }
-
-    static getMax(dataType: number) {
-        switch (dataType) {
-            case FCloudDataType.Int32:
-                return 2147483647;
-            case FCloudDataType.Float:
-                return 3.402823E+38;
-        }
-    }
-    static getMin(dataType: number) {
-        switch (dataType) {
-            case FCloudDataType.Int32:
-                return -2147483648;
-            case FCloudDataType.Float:
-                return -3.402823E+38;
-        }
-    }
-}

package/src/tsconfig.json

@@ -1,33 +0,0 @@
-{
-  "compilerOptions": {
-    "outDir": "../dist",
-    "rootDir": "./",
-    "target": "es2015",
-    "module": "esnext",
-    "moduleResolution": "node",
-    "emitDecoratorMetadata": true,
-    "experimentalDecorators": true,
-    "sourceMap": false,
-    "declaration": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "lib": [
-      "dom",
-      "es6"
-    ],
-    "typeRoots": [
-      "../node_modules/@types"
-    ]
-  },
-  "exclude": [
-    "node_modules",
-    "./**/*.spec.ts"
-  ],
-  "angularCompilerOptions": {
-    "enableIvy": false,
-    "genDir": "../temp/factories",
-    "strictMetadataEmit": true,
-    "skipTemplateCodegen": true,
-    "fullTemplateTypeCheck": true
-  }
-}

package/src/typings.d.ts

@@ -1 +0,0 @@
-declare let Snap: any;

package/src/utils/access-permission.service.ts

@@ -1,27 +0,0 @@
-import { Injectable } from '@angular/core';
-import { AccessPermission } from './access-permission';
-
-@Injectable()
-export class AccessPermissionService {
-
-    getAccessPermissions() {
-        return [{ key: AccessPermission.ReadOnly, value: 'ReadOnly' }, { key: AccessPermission.ReadWrite, value: 'ReadWrite' }];
-    }
-
-    isReadOnly(privilege) {
-        return privilege === AccessPermission.ReadOnly;
-    }
-
-    isReadWrite(privilege) {
-        // eslint-disable-next-line eqeqeq
-        return privilege == AccessPermission.ReadWrite;
-    }
-
-    canRead(privilege) {
-        return privilege === AccessPermission.ReadOnly;
-    }
-
-    canWrite(privilege) {
-        return privilege === AccessPermission.ReadWrite || privilege === AccessPermission.Write;
-    }
-}

package/src/utils/access-permission.ts

@@ -1,5 +0,0 @@
-export enum AccessPermission {
-    Write = 2,
-    ReadOnly = 4,
-    ReadWrite = 6,
-}

package/src/utils/auto-focus.directive.ts

@@ -1,16 +0,0 @@
-import { Directive, ElementRef, AfterViewInit } from '@angular/core';
-
-@Directive({
-    selector: '[autoFocus]'
-})
-export class AutoFocusDirective implements AfterViewInit {
-
-    constructor(private _element: ElementRef) {
-    }
-
-    ngAfterViewInit(): void {
-        setTimeout(() => {
-            $(this._element.nativeElement).focus();
-        }, 100);
-    }
-}

package/src/utils/bs-modal-drag.directive.ts

@@ -1,26 +0,0 @@
-import { Directive, ElementRef, AfterViewInit } from '@angular/core';
-
-@Directive({
-    selector: '[bs-modal-drag]'
-})
-export class BsModalDragDirective implements AfterViewInit {
-
-    constructor(private readonly _element: ElementRef) {
-    }
-
-    ngAfterViewInit() {
-        setTimeout(() => this.setDrag(), 1000);
-    }
-
-    private setDrag() {
-        const currentEle = $(this._element.nativeElement);
-        const targets = currentEle.parents('.modal-content');
-        if (targets.length === 0) { return; }
-        $(targets[0]).draggable({
-            cursor: 'pointer',
-            handle: '.modal-header',
-            containment: 'body',
-            scroll: false
-        });
-    }
-}

package/src/utils/data-type/data-type.service.ts

@@ -1,156 +0,0 @@
-import { Injectable } from '@angular/core';
-import { isNil, isNumber } from 'lodash';
-import { FCloudDataTypeService } from './fcloud-data-type.service';
-import { FBoxDataTypeService } from './fbox-data-type.service';
-
-@Injectable()
-export class DataTypeService {
-
-    constructor(
-        private fcloudDataTypeService: FCloudDataTypeService,
-        private fboxDataTypeService: FBoxDataTypeService) {
-    }
-
-    getValueType(version: number, id: number): string {
-        if (!isNil(version) && version > 4) {
-            return this.fcloudDataTypeService.getValueType(id);
-        }
-        return this.fboxDataTypeService.getValueType(id);
-    }
-
-    getValuePattern(version: number, id: number) {
-        if (!isNil(version) && version > 4) {
-            return this.fcloudDataTypeService.getValuePattern(id);
-        }
-        return this.fboxDataTypeService.getValuePattern(id);
-    }
-
-    isHexType(version: number, id: number): boolean {
-        if (!isNil(version) && version > 4) {
-            return this.fcloudDataTypeService.isHexType(id);
-        }
-        return this.fboxDataTypeService.isHexType(id);
-    }
-
-    isBinaryType(version: number, id: number): boolean {
-        if (!isNil(version) && version > 4) {
-            return this.fcloudDataTypeService.isBinaryType(id);
-        }
-        return this.fboxDataTypeService.isBinaryType(id);
-    }
-
-    isHexOrBinaryType(version: number, id: number): boolean {
-        if (!isNil(version) && version > 4) {
-            return this.fcloudDataTypeService.isHexOrBinaryType(id);
-        }
-        return this.fboxDataTypeService.isHexOrBinaryType(id);
-    }
-
-    isFloat(version: number, id: number): boolean {
-        if (!isNil(version) && version > 4) {
-            return this.fcloudDataTypeService.isFloat(id);
-        }
-        return this.fboxDataTypeService.isFloat(id);
-    }
-
-    /**
-     * 获取数据型号最大长度
-     * @param id fbox数据类型
-     */
-    getValueMaxLength(version: number,  dataType: number, fBoxDataType: number): number {
-        if (isNumber(fBoxDataType)) {
-            return this.fboxDataTypeService.getValueMaxLength(fBoxDataType);
-        } else {
-            if (!isNil(version) && version > 4) {
-                return this.fcloudDataTypeService.getValueMaxLength(dataType);
-            }
-
-            return this.fboxDataTypeService.getValueMaxLength(dataType);
-        }
-    }
-
-    /**
-     * 是否支持小数位
-     * @param version
-     * @param id
-     */
-    isSupportFractionDigit(version: number, id: number): boolean {
-        if (!isNil(version) && version > 4) {
-            return this.fcloudDataTypeService.isSupportFractionDigit(id);
-        }
-        return this.fboxDataTypeService.isSupportFractionDigit(id);
-    }
-
-    /**
-     * 是否为有符号数
-     * @param version
-     * @param id
-     */
-    isSignedType(version: number, id: number): boolean {
-        if (!isNil(version) && version > 4) {
-            return this.fcloudDataTypeService.isSignedType(id);
-        }
-        return this.fboxDataTypeService.isSignedType(id);
-    }
-
-    /**
-     * 是否支持数值运算
-     * @param version
-     * @param id
-     */
-    isSupportNumericalOperation(version: number, id: number): boolean {
-        if (!isNil(version) && version > 4) {
-            return this.fcloudDataTypeService.isSupportNumericalOperation(id);
-        }
-        return this.fboxDataTypeService.isSupportNumericalOperation(id);
-    }
-
-    /**
-    * 数据转换成10进制
-    * @param version
-    * @param value
-    * @param id
-    */
-    formatToDecimal(version: number, value: any, id: number) {
-        if (!isNil(version) && version > 4) {
-            return this.fcloudDataTypeService.formatToDecimal(value, id);
-        }
-        return this.fboxDataTypeService.formatToDecimal(value, id);
-    }
-
-    /**
-       * 获取数据型号最小值
-       * @param id
-       * @param? integerDigits
-       * @param? fractionDigits
-       */
-    getMinValue(version: number, dataType: number, fBoxDataType: number, integerDigits?: number, fractionDigits?: number): number {
-        if (isNumber(fBoxDataType)) {
-            return this.fboxDataTypeService.getMinValue(fBoxDataType, integerDigits, fractionDigits);
-        } else {
-            if (!isNil(version) && version > 4) {
-                return this.fcloudDataTypeService.getMinValue(dataType);
-            }
-
-            return this.fboxDataTypeService.getMinValue(dataType);
-        }
-    }
-
-    /**
-       * 获取数据型号最大值
-       * @param id
-       * @param? integerDigits
-       * @param? fractionDigits
-       */
-    getMaxValue(version: number, dataType: number, fBoxDataType: number, integerDigits?: number, fractionDigits?: number): number {
-        if (isNumber(fBoxDataType)) {
-            return this.fboxDataTypeService.getMaxValue(fBoxDataType, integerDigits, fractionDigits);
-        } else {
-            if (!isNil(version) && version > 4) {
-                return this.fcloudDataTypeService.getMaxValue(dataType);
-            }
-
-            return this.fboxDataTypeService.getMaxValue(dataType);
-        }
-    }
-}

package/src/utils/data-type/fbox-data-type.service.ts

@@ -1,302 +0,0 @@
-import { Injectable, Inject } from '@angular/core';
-import { LOCALIZATION, Localization } from '../../localization';
-
-@Injectable()
-export class FBoxDataTypeService {
-
-    defaultIntegerDigits = 4;
-    defaultFractionDigits = 0;
-
-    constructor(@Inject(LOCALIZATION) private localization: Localization) {
-        // 0, 'Bit'
-        // 1, 'UInt16'
-        // 2, 'Int16'
-        // 3, 'Bcd16'
-        // 4, 'Hex16'
-        // 5, 'Binary16'
-        // 11, 'UInt32'
-        // 12, 'Int32'
-        // 13, 'Bcd32'
-        // 14, 'Hex32'
-        // 15, 'Binary32'
-        // 16, 'Single'
-        // 30, 'String'
-    }
-
-    getValueType(id: number): string {
-        switch (id) {
-            case 0:
-            case 5:
-            case 15:
-                return this.localization.binaryType;
-            case 1:
-            case 2:
-            case 3:
-            case 11:
-            case 12:
-            case 13:
-            case 16:
-                return this.localization.decimalType;
-            case 4:
-            case 14:
-                return this.localization.hexadecimalType;
-            case 30:
-                return this.localization.stringType;
-        }
-    }
-
-    getValuePattern(id: number) {
-        switch (id) {
-            case 0:
-            case 5:
-            case 15:
-                return '^[01]+$';
-            case 1:
-            case 2:
-            case 3:
-            case 11:
-            case 12:
-            case 13:
-            case 16:
-                return '^[+-]?[0-9]*(\\.[0-9]*)?$';
-            case 4:
-            case 14:
-                return '^[0-9a-fA-F]+$';
-        }
-    }
-
-    isHexType(id: number): boolean {
-        return id === 4 || id === 14;
-    }
-
-    isBinaryType(id: number): boolean {
-        return id === 5 || id === 15;
-    }
-
-    isHexOrBinaryType(id: number): boolean {
-        return id === 4 || id === 14 || id === 5 || id === 15;
-    }
-
-    isFloat(id: number): boolean {
-        return id === 16;
-    }
-
-    /**
-     * 获取数据型号最大长度
-     * @param id
-     */
-    getValueMaxLength(id: number): number {
-        switch (id) {
-            case 1: // UInt16
-                return 5;
-            case 2: // Int16
-                return 6;
-            case 3: // Bcd16
-            case 4: // Hex16
-                return 4;
-            case 5: // Binary16
-                return 16;
-            case 11: // UInt32
-                return 10;
-            case 12: // Int32
-            case 16: // Single
-                return 11;
-            case 13: // Bcd32
-                return 8;
-            case 14: // Hex32
-                return 8;
-            case 15: // Binary32
-                return 32;
-            case 21: // UInt64
-                return 16;
-            case 22: // Int64
-                return 16;
-            case 23: // Bcd64
-                return 16;
-            case 24: // Hex64
-                return 8;
-            case 25: // Binary64
-                return 32;
-            default:
-                return 0;
-        }
-    }
-
-    /**
-     * 是否支持小数位
-     * @param id
-     */
-    isSupportFractionDigit(id: number): boolean {
-        return id !== 0 && id !== 4 && id !== 5 && id !== 14 && id !== 15 && id !== 30;
-    }
-
-    /**
-     * 是否为有符号数
-     * @param id
-     */
-    isSignedType(id: number): boolean {
-        return id === 2 || id === 12 || id === 16;
-    }
-
-    /**
-     * 是否支持数值运算
-     * @param id
-     */
-    isSupportNumericalOperation(id: number): boolean {
-        return id !== 0 && id !== 4 && id !== 5 && id !== 14 && id !== 15 && id !== 30;
-    }
-
-    /**
-    * 数据转换成10进制
-    * @param value
-    * @param id
-    */
-    formatToDecimal(value: any, id: number) {
-        if (this.isBinaryType(id)) {
-            return parseInt(value, 2);
-        }
-        if (this.isHexType(id)) {
-            return parseInt(value, 16);
-        }
-        return value;
-    }
-
-    /**
-       * 获取数据型号最小值
-       * @param id
-       * @param? integerDigits
-       * @param? fractionDigits
-       */
-    getMinValue(id: number, integerDigits?: number, fractionDigits?: number): number {
-        let minValue;
-        switch (id) {
-            case 1: // UInt16
-            case 3: // Bcd16
-            case 4: // Hex16
-            case 5: // Binary16
-            case 11: // UInt32
-            case 13: // Bcd32
-            case 14: // Hex32
-            case 15: // Binary32
-            case 21: // UInt64
-            case 23: // Bcd64
-            case 14: // Hex32
-            case 15: // Binary32
-            case 24: // Hex64
-            case 25: // Binary64
-                minValue = 0;
-                break;
-            case 2: // Int16
-                minValue = -32768;
-                break;
-            case 12: // Int32
-                minValue = -2147483648;
-                break;
-            case 16: // Single
-                minValue = -1000000000;
-                break;
-            case 22: // Int64
-                // minValue = -9223372036854775808;
-                minValue = Number.MIN_SAFE_INTEGER;
-                break;
-            case 26: // Double
-                minValue = -Number.MAX_VALUE;
-                break;
-        }
-        if (integerDigits) {
-            let digitsLength = integerDigits;
-            if (fractionDigits) {
-                digitsLength = digitsLength + fractionDigits;
-            }
-
-            if (digitsLength) {
-                if (minValue.toString().length - 1 > digitsLength) {
-                    minValue = -this.getFillNine(digitsLength);
-                }
-            }
-            if (this.isFloat(id) && fractionDigits) {
-                minValue = minValue / Math.pow(10, fractionDigits);
-            }
-        }
-
-        return minValue;
-    }
-
-    /**
-       * 获取数据型号最大值
-       * @param id
-       * @param? integerDigits
-       * @param? fractionDigits
-       */
-    getMaxValue(id: number, integerDigits?: number, fractionDigits?: number): number {
-        let maxValue;
-        switch (id) {
-            case 1: // UInt16
-            case 4: // Hex16
-            case 5: // Binary16
-                maxValue = 65535;
-                break;
-            case 2: // Int16
-                maxValue = 32767;
-                break;
-            case 3: // Bcd16
-                maxValue = 9999;
-                break;
-            case 11: // UInt32
-            case 14: // Hex32
-            case 15: // Binary32
-                maxValue = 4294967295;
-                break;
-            case 12: // Int32
-                maxValue = 2147483647;
-                break;
-            case 13: // Bcd32
-                maxValue = 99999999;
-                break;
-            case 16: // Single
-                maxValue = 1000000000;
-                break;
-            case 21: // UInt64
-            case 24: // Hex64
-            case 25: // Binary64
-                // maxValue = 18446744073709551615;
-                maxValue = Number.MAX_SAFE_INTEGER;
-                break;
-            case 22: // Int64
-                // maxValue = 9223372036854775807;
-                maxValue = Number.MAX_SAFE_INTEGER;
-                break;
-            case 23: // Bcd64
-                // maxValue = 9999999999999999;
-                maxValue = Number.MAX_SAFE_INTEGER;
-                break;
-            case 26: // Double
-                maxValue = Number.MAX_VALUE;
-                break;
-        }
-        if (integerDigits) {
-            let digitsLength = integerDigits;
-            if (fractionDigits) {
-                digitsLength = digitsLength + fractionDigits;
-            }
-            if (digitsLength) {
-                if (maxValue.toString().length > digitsLength) {
-                    maxValue = this.getFillNine(digitsLength);
-                }
-            }
-            if (this.isFloat(id) && fractionDigits) {
-                maxValue = maxValue / Math.pow(10, fractionDigits);
-            }
-        }
-
-        return maxValue;
-    }
-
-    getFillNine(num: number) {
-        let text = '9';
-        for (let i = 1; i < num; i++) {
-            text = `9${text}`;
-        }
-        return text;
-    }
-}