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

package/src/logger/console-logger.service.ts

@@ -0,0 +1,38 @@
+import { LoggerService } from './logger.service';
+
+export class ConsoleLoggerService implements LoggerService {
+
+    isErrorEnabled = (): boolean => true;
+
+    error(message?: any, optionalParams?: any[]): void {
+        if (this.isErrorEnabled()) { console.error.apply(console, optionalParams ? [message, optionalParams] : [message]); }
+    }
+
+    isWarnEnabled = (): boolean => true;
+
+    warn(message?: any, optionalParams?: any[]) {
+        if (this.isWarnEnabled()) { console.warn.apply(console, optionalParams ? [message, optionalParams] : [message]); }
+    }
+
+    isInfoEnabled = (): boolean => true;
+
+    info(message?: any, optionalParams?: any[]) {
+        // eslint-disable-next-line no-console
+        if (this.isInfoEnabled()) { console.info.apply(console, optionalParams ? [message, optionalParams] : [message]); }
+    }
+
+    isDebugEnabled = (): boolean => true;
+
+    debug(message?: any, optionalParams?: any[]) {
+        if (!this.isDebugEnabled()) { return; }
+        // For browsers that don't implement the debug method, log will be used instead.
+        // eslint-disable-next-line no-console
+        console[console['debug'] ? 'debug' : 'log'].apply(console, optionalParams ? [message, optionalParams] : [message]);
+    }
+
+    isLogEnabled = (): boolean => true;
+
+    log(message?: any, optionalParams?: any[]) {
+        if (this.isLogEnabled()) { console.log.apply(console, optionalParams ? [message, optionalParams] : [message]); }
+    }
+}

package/src/logger/logger.service.ts

@@ -0,0 +1,26 @@
+import { InjectionToken } from '@angular/core';
+
+export const LOGGER_SERVICE_TOKEN = new InjectionToken<LoggerService>('fc.gui.log');
+
+export interface LoggerService {
+
+    isErrorEnabled(): boolean;
+
+    error(message?: any, optionalParams?: any[]);
+
+    isWarnEnabled(): boolean;
+
+    warn(message?: any, optionalParams?: any[]);
+
+    isInfoEnabled(): boolean;
+
+    info(message?: any, optionalParams?: any[]);
+
+    isDebugEnabled(): boolean;
+
+    debug(message?: any, optionalParams?: any[]);
+
+    isLogEnabled(): boolean;
+
+    log(message?: any, optionalParams?: any[]);
+}

package/src/modal/alert/alert-modal.component.ts

@@ -0,0 +1,26 @@
+import { Component, Inject } from '@angular/core';
+import { LOCALIZATION, Localization } from '../../localization/localization.service';
+import { Subject } from 'rxjs/internal/Subject';
+import { Observable } from 'rxjs/internal/Observable';
+
+@Component({
+    selector: 'alertModal',
+    templateUrl: 'alert-modal.component.html',
+    styleUrls: ['alert-modal.component.less']
+})
+export class AlertModalComponent {
+
+    private _onClosed = new Subject<void>();
+    get onClosed(): Observable<void> {
+        return this._onClosed;
+    }
+
+    alermMessage: string;
+    constructor(@Inject(LOCALIZATION) public localization: Localization) {
+    }
+
+    close(): void {
+        this._onClosed.next();
+        this._onClosed.complete();
+    }
+}

package/src/modal/confirm-operation/confirm-operation-modal.component.ts

@@ -0,0 +1,28 @@
+import { Component, Inject } from '@angular/core';
+import { Observable, Subject } from 'rxjs';
+import { LOCALIZATION, Localization } from '../../localization/localization.service';
+
+@Component({
+    selector: 'confirmOperationModal',
+    templateUrl: 'confirm-operation-modal.component.html',
+    styleUrls: ['confirm-operation-modal.component.less']
+})
+export class ConfirmOperationModalComponent {
+
+    private _onClosed = new Subject<Boolean>();
+    get onClosed(): Observable<Boolean> {
+        return this._onClosed;
+    }
+
+    constructor(@Inject(LOCALIZATION) public localization: Localization) {
+    }
+
+    close(modalResult?: boolean): void {
+        this._onClosed.next(modalResult);
+        this._onClosed.complete();
+    }
+
+    confirm(): void {
+        this.close(true);
+    }
+}

package/src/modal/verify-password/verify-password-modal.component.ts

@@ -0,0 +1,59 @@
+import { Component, Inject, OnInit } from '@angular/core';
+import { Observable, Subject } from 'rxjs';
+import { isNil } from 'lodash';
+
+import { LOCALIZATION, Localization } from '../../localization';
+import { SecurityChecker } from '../../security';
+
+@Component({
+    selector: 'verify-password',
+    templateUrl: 'verify-password-modal.component.html',
+    styleUrls: ['verify-password-modal.component.less']
+})
+export class VerifyPasswordModalComponent implements OnInit {
+
+    private _onClosed = new Subject<Boolean>();
+    get onClosed(): Observable<Boolean> {
+        return this._onClosed;
+    }
+
+    passwordError = false;
+    password: string;
+    securityChecker: SecurityChecker;
+    validationErrorText: string;
+
+    constructor(@Inject(LOCALIZATION) public localization: Localization) {
+    }
+
+    ngOnInit(): void {
+        this.validate();
+    }
+
+    validate() {
+        if (isNil(this.password) || '' === this.password.trim()) {
+            this.passwordError = true;
+            this.validationErrorText = this.localization.passwordRequired;
+        } else {
+            this.passwordError = false;
+            this.validationErrorText = '';
+        }
+    }
+
+    checkSecurity() {
+        this.securityChecker.isValid(this.password).then(isValid => {
+            if (isValid) {
+                this.close(true);
+            } else {
+                this.passwordError = true;
+                this.validationErrorText = this.localization.passwordToolTip;
+            }
+        }).catch(() => {
+            throw new Error('Failure of the checkSecurity');
+        });
+    }
+
+    close(modalResult?: boolean): void {
+        this._onClosed.next(modalResult);
+        this._onClosed.complete();
+    }
+}

package/src/modal/write-character/write-character-modal-args.ts

@@ -0,0 +1,8 @@
+export class WriteCharacterModalArgs {
+    constructor(
+        public variableName: string,
+        public isPassword: boolean,
+        public charCount: number,
+        public originValue: any) {
+    }
+}

package/src/modal/write-character/write-character-modal.component.ts

@@ -0,0 +1,74 @@
+import { Component, Inject, OnInit, Output } from '@angular/core';
+import { Observable, Subject } from 'rxjs';
+import { LOCALIZATION, Localization } from '../../localization';
+import { WriteValueModelResult } from '../write-value/write-value-model-result';
+import { WriteCharacterModalArgs } from './write-character-modal-args';
+
+@Component({
+    selector: 'writeCharacterModal',
+    templateUrl: 'write-character-modal.component.html',
+    styleUrls: ['write-character-modal.component.less']
+})
+
+export class WriteCharacterModalComponent implements OnInit {
+
+    private _onClosed = new Subject<WriteValueModelResult>();
+    get onClosed(): Observable<WriteValueModelResult> {
+        return this._onClosed;
+    }
+
+    args: WriteCharacterModalArgs;
+
+    value: string;
+    variableName: string;
+    isPassword: boolean;
+    charCount: number;
+    validationError: boolean;
+    validationErrorText: string;
+
+    @Output()
+    get invalidErrorText(): string {
+        return this.localization.loadFailed;
+    }
+
+    constructor(@Inject(LOCALIZATION) public localization: Localization) {
+    }
+
+    ngOnInit(): void {
+        this.variableName = this.args.variableName;
+        this.isPassword = this.args.isPassword ? this.args.isPassword : false;
+        this.charCount = this.args.charCount;
+        this.value = '';
+        this.validate();
+    }
+
+    validate() {
+        // 校验数值必填
+        if (null == this.value || '' === this.value.trim()) {
+            return this.showValidationErrorInfo(this.localization.characterInputRequired);
+        }
+        if (this.value.length > this.charCount) {
+            return this.showValidationErrorInfo(this.localization.characterOutofRange);
+        }
+        this.hideValidationErrorInfo();
+    }
+
+    private showValidationErrorInfo(errorText: string) {
+        this.validationError = true;
+        this.validationErrorText = errorText;
+    }
+
+    private hideValidationErrorInfo() {
+        this.validationError = false;
+        this.validationErrorText = '';
+    }
+
+    save(): void {
+        this.close({ value: this.value });
+    }
+
+    close(modalResult?: WriteValueModelResult): void {
+        this._onClosed.next(modalResult);
+        this._onClosed.complete();
+    }
+}

package/src/modal/write-value/write-value-modal-args.ts

@@ -0,0 +1,16 @@
+import { NumericalOperation } from '../../model';
+import { ReleasedVariableService } from '../../service';
+
+export class WriteValueModalArgs {
+    constructor(
+        public variableName: string,
+        public dataType: number,
+        public fBoxDataType: number,
+        public integerDigits: number,
+        public fractionDigits: number,
+        public numericalOperation: NumericalOperation,
+        public version: number,
+        public enableDataParsed: boolean,
+        public releasedVariableService: ReleasedVariableService) {
+    }
+}

package/src/modal/write-value/write-value-modal.component.ts

@@ -0,0 +1,237 @@
+import { Component, Inject, OnInit, Output } from '@angular/core';
+import { LOCALIZATION, Localization } from '../../localization';
+import { NumericalOperation } from '../../model/numerical-display/numerical-operation';
+import { DataTypeService } from '../../utils/data-type/data-type.service';
+import { FractionDigitService } from '../../utils/fraction-digit.service';
+import { NumericalOperationService } from '../../utils/numerical-operation.service';
+import { WriteValueModalArgs } from './write-value-modal-args';
+import { isNil } from 'lodash';
+import { BsModalRef } from 'ngx-bootstrap/modal';
+
+@Component({
+    selector: 'writeValueModal',
+    templateUrl: 'write-value-modal.component.html',
+    styleUrls: ['write-value-modal.component.less']
+})
+export class WriteValueModalComponent implements OnInit {
+    public onClosed: any;
+
+    args: WriteValueModalArgs;
+
+    private dataType;
+    private fBoxDataType;
+    private pattern: string;
+    private fractionDigits: number;
+    private integerDigits: number;
+    private numericalLowerLimit: number;
+    private numericalUpperLimit: number;
+    private maxValueLimit: number;
+    private minValueLimit: number;
+    value: string;
+    valueType: string;
+    variableName: string;
+    enableNumericalOperation: boolean;
+    isNumericalOperation: boolean;
+    numericalOperation: NumericalOperation;
+    validationError: boolean;
+    validationErrorText: string;
+
+    writeMinValue: number;
+    writeMaxValue: number;
+    writeValueRangeText = '';
+
+    isSubmitting = false;
+
+    @Output()
+    get invalidErrorText(): string {
+        return this.localization.loadFailed;
+    }
+
+    constructor(
+        @Inject(LOCALIZATION) public localization: Localization,
+        private readonly dataTypeService: DataTypeService,
+        private readonly fractionDigitService: FractionDigitService,
+        private readonly numericalOperationService: NumericalOperationService,
+        private readonly bsModalRef: BsModalRef) {
+    }
+
+    ngOnInit(): void {
+        this.initData(this.args);
+        this.validate();
+    }
+
+    initData(option: WriteValueModalArgs) {
+        this.variableName = option.variableName;
+        this.dataType = option.dataType;
+        this.fBoxDataType = option.fBoxDataType;
+        this.integerDigits = option.integerDigits ? option.integerDigits : 0;
+        this.fractionDigits = option.fractionDigits ? option.fractionDigits : 0;
+        this.valueType = this.dataTypeService.getValueType(option.version, option.dataType);
+        this.pattern = this.dataTypeService.getValuePattern(option.version, option.dataType);
+        this.numericalOperation = option.numericalOperation;
+        this.enableNumericalOperation = this.numericalOperation.enableNumericalOperation ?
+            this.numericalOperation.enableNumericalOperation : false;
+        this.value = '';
+        if (this.args.enableDataParsed) {
+            this.setValueRangeAccordToDataParsed(option);
+        } else {
+            this.writeMaxValue = this.dataTypeService.getMaxValue(option.version, this.dataType, this.fBoxDataType);
+            this.writeMinValue = this.dataTypeService.getMinValue(option.version, this.dataType, this.fBoxDataType);
+        }
+
+        this.writeValueRangeText = this.getWriteValueRangeText();
+    }
+
+    private setValueRangeAccordToDataParsed(option: WriteValueModalArgs) {
+        if (this.dataTypeService.isFloat(option.version, this.dataType) || this.enableNumericalOperation) {
+            this.maxValueLimit = this.dataTypeService.getMaxValue(option.version, this.dataType, this.fBoxDataType);
+            this.minValueLimit = this.dataTypeService.getMinValue(option.version, this.dataType, this.fBoxDataType);
+            this.numericalLowerLimit = this.numericalOperation.numericalLowerLimit;
+            this.numericalUpperLimit = this.numericalOperation.numericalUpperLimit;
+        } else {
+            this.maxValueLimit = +this.fractionDigitService.movePoint(this.dataTypeService.getMaxValue(option.version, this.dataType, this.fBoxDataType), -this.fractionDigits);
+            this.minValueLimit = +this.fractionDigitService.movePoint(this.dataTypeService.getMinValue(option.version, this.dataType, this.fBoxDataType), -this.fractionDigits);
+            this.numericalLowerLimit = +this.fractionDigitService.movePoint(this.numericalOperation.numericalLowerLimit, -this.fractionDigits);
+            this.numericalUpperLimit = +this.fractionDigitService.movePoint(this.numericalOperation.numericalUpperLimit, -this.fractionDigits);
+        }
+        const minValue = this.numericalOperationService.getWriteMinValue(this.minValueLimit, this.numericalOperation);
+        const maxValue = this.numericalOperationService.getWriteMaxValue(this.maxValueLimit, this.numericalOperation);
+        const lowerLimitValue = this.numericalOperationService.getWriteMinValue(this.numericalLowerLimit, this.numericalOperation);
+        const upperLimitValue = this.numericalOperationService.getWriteMaxValue(this.numericalUpperLimit, this.numericalOperation);
+        const realMinValue = minValue < maxValue ? minValue : maxValue;
+        const realMaxValue = minValue < maxValue ? maxValue : minValue;
+        const realLowerLimitValue = lowerLimitValue < upperLimitValue ? lowerLimitValue : upperLimitValue;
+        const realUpperLimitValue = lowerLimitValue < upperLimitValue ? upperLimitValue : lowerLimitValue;
+
+        this.writeMinValue = realMinValue > realLowerLimitValue ? realMinValue : realLowerLimitValue;
+        this.writeMaxValue = realMaxValue < realUpperLimitValue ? realMaxValue : realUpperLimitValue;
+    }
+
+    getWriteValueRangeText(): string {
+        let minValue = '';
+        let maxValue = '';
+        if (this.dataTypeService.isHexOrBinaryType(this.args.version, this.dataType)) {
+            minValue = this.writeMinValue.toString(16);
+            maxValue = this.writeMaxValue.toString(16);
+        } else {
+            if (this.args.enableDataParsed && this.fractionDigits > 0) {
+                minValue = this.writeMinValue.toFixed(this.fractionDigits).toString();
+                maxValue = this.writeMaxValue.toFixed(this.fractionDigits).toString();
+            } else {
+                minValue = this.writeMinValue.toString();
+                maxValue = this.writeMaxValue.toString();
+            }
+        }
+
+        return minValue + '~' + maxValue;
+    }
+
+    save(): void {
+        this.isSubmitting = true;
+        let value = this.value;
+        const showValue = this.value;
+        if (this.args.enableDataParsed) {
+            if (this.enableNumericalOperation) {
+                value = this.numericalOperationService.getWriteValue(this.args.version, this.value, this.numericalOperation, this.dataType, this.fractionDigits);
+            } else {
+                value = this.formatWriteValue();
+            }
+        }
+
+        this.args.releasedVariableService.getVariableWithValueTransform(this.variableName).subscribe(result => {
+            const valueTransform = JSON.parse(result.valueTransform);
+            if (valueTransform.Type !== 0) {
+                this.isNumericalOperation = true;
+            }
+            this.onClosed({
+                value, showValue,
+                enableNumericalOperation: this.enableNumericalOperation,
+                isNumericalOperation: this.isNumericalOperation,
+                variableRwType: result.variableRwType
+            });
+        });
+    }
+
+    close(): void {
+        this.bsModalRef.hide();
+    }
+
+    validate(event = null) {
+        if (event && event.keyCode === 13 && !this.validationError) {
+            this.save();
+            return;
+        }
+        // 校验数值必填
+        if (null == this.value || '' === this.value.trim()) {
+            return this.showValidationErrorInfo(this.localization.numericalValueRequired);
+        }
+        // 校验格式
+        if (!new RegExp(this.pattern).test(this.value)) {
+            return this.showValidationErrorInfo(this.localization.invalidNumericalValue);
+        }
+        // 校验小数点位数
+        if (!this.enableNumericalOperation && this.dataTypeService.isSupportFractionDigit(this.args.version, this.dataType)
+            && this.getFractionDigits(this.value) > this.fractionDigits) {
+            return this.showValidationErrorInfo(`${this.localization.fractionDigitsMustLessThan}${this.fractionDigits}`);
+        }
+        // 校验负号
+        if (isNil(this.args.version) || (!isNil(this.args.version) && this.args.version < 5)) {
+            if (!this.enableNumericalOperation && !this.dataTypeService.isSignedType(this.args.version, this.dataType) && this.value.startsWith('-')) {
+                return this.showValidationErrorInfo(this.localization.canNotBeNegative);
+            }
+        }
+        if (this.dataTypeService.isBinaryType(this.args.version, this.dataType) || this.dataTypeService.isHexType(this.args.version, this.dataType)) {
+            // 校验数值最大长度
+            const valueMaxLength = this.dataTypeService.getValueMaxLength(this.args.version, this.dataType, this.fBoxDataType);
+            const maxLength = this.integerDigits ? Math.min(this.integerDigits, valueMaxLength) : valueMaxLength;
+            if (this.value.length > maxLength) {
+                return this.showValidationErrorInfo(this.localization.numericalValueTooLong);
+            }
+        }
+
+        let transportValue;
+        if (this.dataTypeService.isHexOrBinaryType(this.args.version, this.dataType)) {
+            transportValue = this.dataTypeService.formatToDecimal(this.args.version, this.value, this.dataType);
+        } else {
+            transportValue = Number(this.value);
+        }
+
+        if (Number(transportValue) > this.writeMaxValue || Number(transportValue) < this.writeMinValue) {
+            return this.showValidationErrorInfo(this.localization.valueOutOfRange);
+        }
+        // 没有错误则隐藏错误框
+        this.hideValidationErrorInfo();
+    }
+
+    private showValidationErrorInfo(errorText: string) {
+        this.validationError = true;
+        this.validationErrorText = errorText;
+    }
+
+    private hideValidationErrorInfo() {
+        this.validationError = false;
+        this.validationErrorText = '';
+    }
+
+    private getFractionDigits(number): number {
+        if (number && number.indexOf('.') > 0) {
+            return number.split('.')[1].length;
+        }
+        return 0;
+    }
+
+    /**
+     * 格式化写入的值
+     * 因为有小数点的数值类型，会被按照小数点位数移位，所以需要在修改前右移小数点位数
+     */
+    private formatWriteValue() {
+        if (this.dataTypeService.isSupportFractionDigit(this.args.version, this.dataType) &&
+            !this.dataTypeService.isFloat(this.args.version, this.dataType) && this.fractionDigits) {
+            return this.fractionDigitService.movePoint(this.value, this.fractionDigits);
+        }
+        if (this.dataTypeService.isSupportNumericalOperation(this.args.version, this.dataType)) {
+            this.value = Number(this.value).toString();
+        }
+        return this.value;
+    }
+}

package/src/modal/write-value/write-value-model-result.ts

@@ -0,0 +1,4 @@
+
+export interface WriteValueModelResult {
+    readonly value: string;
+}

package/src/model/air-quality/air-quality-info.ts

@@ -0,0 +1,25 @@
+import * as moment from 'moment';
+
+export class AirQualityInfo {
+      /** 有无地址 */
+      hasAddress!: boolean | undefined;
+      /** 是否获取地址中 */
+      gettingAddress!: boolean | undefined;
+      /** 是否支持 */
+      supported!: boolean | undefined;
+      airQuality!: AirQuality | undefined;
+}
+
+export class AirQuality {
+    city!: string | undefined;
+    aqi!: string | undefined;
+    level!: number | undefined;
+    category!: string | undefined;
+    pm10!: string | undefined;
+    pm25!: string | undefined;
+    no2!: string | undefined;
+    so2!: string | undefined;
+    co!: string | undefined;
+    o3!: string | undefined;
+    reportTime!: moment.Moment | undefined;
+}

package/src/model/air-quality/air-quality.model.ts

@@ -0,0 +1,8 @@
+import { Size } from '../shared';
+import { ConditionalDisplayModel } from '../base';
+
+export interface AirQualityModel extends ConditionalDisplayModel {
+    size: Size;
+    stroke: string;
+    fill: string;
+}

package/src/model/alarm/alarm.model.ts

@@ -0,0 +1,14 @@
+import { ConditionalDisplayModel } from '../base/conditional-display-model';
+import { Point, Size } from '../shared';
+
+export interface AlarmModel extends ConditionalDisplayModel {
+    readonly version: number;
+    readonly size: Size;
+    readonly location: Point;
+    readonly generalSetting?: any;
+    readonly filterSetting?: any;
+    readonly widths: number[];
+    readonly heights: number[];
+    readonly columLabels: string[];
+    readonly levelText: string[];
+}

package/src/model/bar-graph/bar-graph-direction.ts

@@ -0,0 +1,6 @@
+export enum BarGraphDirection {
+    DownToUp,
+    UpToDown,
+    LeftToRight,
+    RightToLeft
+}

package/src/model/bar-graph/bar-graph.ts

@@ -0,0 +1,28 @@
+import { ReadableModel } from '../base';
+import { BarGraphDirection } from './bar-graph-direction';
+import { FontStyleData } from './FontStyleData';
+
+export interface BarGraph extends ReadableModel {
+    /**
+     * 版本1：修复棒图刻度错位问题,bug#5521、#5533、#5576
+     *
+     * 版本2：废弃掉variableName，改用variable表示变量定义
+     */
+    readonly version?: number;
+    readonly max: number;
+    readonly min: number;
+    readonly direction: BarGraphDirection;
+    readonly useAlarmLimit: boolean;
+    readonly upperLimit: number;
+    readonly lowerLimit: number;
+    readonly barColor?: string;
+    readonly backgroundColor?: string;
+    readonly upperLimitColor?: string;
+    readonly lowerLimitColor?: string;
+    readonly percentageFont?: FontStyleData;
+
+    readonly masterDivisionNumber: number;
+    readonly subDivisionNumber: number;
+    readonly integerDigits: number;
+    readonly fractionDigits: number;
+}

package/src/model/base/base-element-model.ts

@@ -0,0 +1,5 @@
+export class BaseElementModel {
+    readonly id: number;
+    readonly category: string;
+    readonly version?: number;
+}

package/src/model/base/conditional-control-model.ts

@@ -0,0 +1,7 @@
+import { ConditionItemModel } from '../shared/condition';
+import { ReadableModel } from './readable-model';
+
+export interface ConditionalControlModel extends ReadableModel {
+    readonly isControl: boolean;
+    controlItems: Array<ConditionItemModel>;
+}

package/src/model/base/conditional-display-model.ts

@@ -0,0 +1,10 @@
+import { ConditionItemModel } from '../shared/condition';
+import { BaseElementModel } from './base-element-model';
+
+export interface ConditionalDisplayModel extends BaseElementModel {
+    readonly isAwaysDisplay?: boolean;
+    readonly isDisplayControl?: boolean;
+    readonly conditionItems?: Array<ConditionItemModel>;
+    readonly isDisplayPermission?: boolean;
+    readonly displayPermissionCodes?: Array<string>;
+}

package/src/model/base/conditional-dynamic-display-model.ts

@@ -0,0 +1,22 @@
+import { ConditionalDisplayModel } from './conditional-display-model';
+import { Point } from '../../model/shared/point.model';
+import { Size } from '../../model/shared/size.model';
+import { DynamicDisplayModel } from '../shared/dynamic-display/dynamic-display-model';
+
+export interface ConditionalDynamicDisplayModel extends ConditionalDisplayModel {
+
+    readonly version?: number;
+
+    readonly dynamicSetting?: DynamicDisplayModel;
+
+    readonly fixedPositionType?: number;
+
+    readonly location: Point;
+
+    readonly size: Size;
+
+    readonly angle?: number;
+
+    readonly strokeWidth?: number;
+
+}

package/src/model/base/conditional-enable-model.ts

@@ -0,0 +1,10 @@
+import { ConditionalDynamicDisplayModel } from './conditional-dynamic-display-model';
+import { ConditionItemModel } from '../shared/condition';
+
+export interface ConditionalEnableModel extends ConditionalDynamicDisplayModel {
+    readonly isAwaysEnable?: boolean;
+    readonly isEnableControl?: boolean;
+    readonly enableItems?: Array<ConditionItemModel>;
+    readonly isEnablePermission?: boolean;
+    readonly enablePermissionCodes?: Array<string>;
+}