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

package/src/model/shared/condition/condition-item-observer.ts

@@ -1,22 +0,0 @@
-import { EventEmitter } from '@angular/core';
-
-import { ConditionModel } from './condition-model';
-import { RelationConditionResultState } from './relation-condition-result-state';
-import { VariableUtil } from '../../../utils/variable-util';
-import { VariableDefinition } from '../../../communication/variable/variable-definition';
-import { VariableStore } from '../../../config';
-
-export abstract class ConditionItemObserver {
-
-    isConditionEffective: boolean;
-    readonly conditionEffectiveChanged: EventEmitter<RelationConditionResultState> = new EventEmitter<RelationConditionResultState>();
-
-    constructor(protected readonly condition: ConditionModel, protected readonly variableStore: VariableStore) {
-    }
-
-    get variableName(): string {
-        const variable = new VariableDefinition(this.condition.variableName, this.condition.variableGroupName,
-            this.condition.dataSourceCode, this.condition.variableVersion);
-        return VariableUtil.getConvertedVariableName(this.variableStore, variable);
-    }
-}

package/src/model/shared/condition/condition-items-observer.ts

@@ -1,6 +0,0 @@
-import { EventEmitter } from '@angular/core';
-import { ConditionControlResultValue } from './condition-control-result-value';
-
-export interface ConditionItemsObserver {
-    readonly conditionResultChanged: EventEmitter<ConditionControlResultValue>;
-}

package/src/model/shared/condition/condition-items-result-observer.ts

@@ -1,96 +0,0 @@
-import { EventEmitter } from '@angular/core';
-import { sortBy } from 'lodash';
-import { ConditionItemModel } from './condition-item-model';
-import { ConditionItemsObserver } from './condition-items-observer';
-import { VariableCommunicator, VariableState } from '../../../communication';
-import { ConditionType } from './condition-type';
-import { BitConditionItemObserver } from './bit-condition-item-observer';
-import { BitConditionModel } from './bit-condition-model';
-import { RelationConditionResult } from './relation-condition-result';
-import { WordConditionItemObserver } from './word-condition-item-observer';
-import { WordConditionModel } from './word-condition-model';
-import { RelationType } from './relation-type';
-import { ConditionControlResultValue } from './condition-control-result-value';
-import { VariableStore } from '../../../config';
-import { ConvertConditionModel } from './convert-condition-model';
-
-export class ConditionItemsResultObserver implements ConditionItemsObserver {
-    readonly conditionResultChanged: EventEmitter<ConditionControlResultValue> = new EventEmitter<ConditionControlResultValue>();
-    private conditionResults = new Map<number, RelationConditionResult>();
-
-    constructor(private readonly sourceConditionItems: ConditionItemModel[],
-        private readonly variableCommunicator: VariableCommunicator,
-        private readonly variableStore: VariableStore) {
-    }
-
-    requestData(appId: string) {
-        if (null == this.sourceConditionItems || !this.sourceConditionItems.length) { return; }
-        const conditionItems = this.sourceConditionItems.sort(t => t.index);
-        conditionItems.forEach(item => {
-            switch (item.conditionType) {
-                case ConditionType.Bit:
-                    const bitItem = new BitConditionItemObserver(item.condition as BitConditionModel, this.variableCommunicator, this.variableStore);
-                    bitItem.conditionEffectiveChanged.subscribe(itemResult => {
-                        if (this.conditionResults.has(conditionItems.indexOf(item))) {
-                            this.conditionResults.delete(conditionItems.indexOf(item));
-                        }
-                        this.conditionResults.set(conditionItems.indexOf(item), new RelationConditionResult(conditionItems.indexOf(item), item.relationType, itemResult));
-                        this.emitConditionResult();
-                    });
-                    bitItem.requestData(appId);
-                    break;
-                case ConditionType.Word:
-                    const wordItem = new WordConditionItemObserver(item.condition as WordConditionModel, this.variableCommunicator, this.variableStore);
-                    wordItem.conditionEffectiveChanged.subscribe(itemResult => {
-                        if (this.conditionResults.has(conditionItems.indexOf(item))) {
-                            this.conditionResults.delete(conditionItems.indexOf(item));
-                        }
-                        this.conditionResults.set(conditionItems.indexOf(item), new RelationConditionResult(conditionItems.indexOf(item), item.relationType, itemResult));
-                        this.emitConditionResult();
-                    });
-                    wordItem.requestData(appId);
-                    break;
-                default:
-                    throw new Error(`Unknown ConditionType :${item.conditionType}`);
-            }
-        });
-    }
-
-    private emitConditionResult() {
-        let isControl = true;
-        const elementStates: Array<VariableState> = [];
-        const formatConditionResults: ConvertConditionModel[] = [];
-        this.conditionResults.forEach(t => {
-            formatConditionResults.push({
-                key: t.key,
-                result: t
-            } as ConvertConditionModel);
-            // eslint-disable-next-line eqeqeq
-            if (t.relationType == RelationType.None) {
-                isControl = t.result.value;
-                elementStates.push(t.result.state);
-            }
-        });
-        const formatResults = sortBy(formatConditionResults, data => {
-            return data.key;
-        });
-        formatResults.forEach(item => {
-            const relationCondition = item.result;
-            // eslint-disable-next-line eqeqeq
-            if (relationCondition.relationType == RelationType.Or) {
-                isControl = isControl || relationCondition.result.value;
-                elementStates.push(relationCondition.result.state);
-
-                // eslint-disable-next-line eqeqeq
-            } else if (relationCondition.relationType == RelationType.And) {
-                isControl = isControl && relationCondition.result.value;
-                elementStates.push(relationCondition.result.state);
-            }
-        });
-        const conditionControlResult = {
-            states: elementStates,
-            value: isControl
-        } as ConditionControlResultValue;
-        this.conditionResultChanged.emit(conditionControlResult);
-    }
-}

package/src/model/shared/condition/condition-type.ts

@@ -1,4 +0,0 @@
-export enum ConditionType {
-    Bit,
-    Word
-}

package/src/model/shared/condition/convert-condition-model.ts

@@ -1,6 +0,0 @@
-import { RelationConditionResult } from './relation-condition-result';
-
-export interface ConvertConditionModel {
-    readonly key: number;
-    readonly result: RelationConditionResult;
-}

package/src/model/shared/condition/index.ts

@@ -1,18 +0,0 @@
-export { RelationalOperator } from './relational-operator';
-
-export { BitCondition } from './bit-condition';
-export { BitConditonLogic } from './bit-condition-logic';
-
-export { WordCondition } from './word-condition';
-
-import { BitCondition } from './bit-condition';
-import { WordCondition } from './word-condition';
-
-export { ConditionHelper } from './condition-helper';
-
-export declare type Condition = BitCondition | WordCondition;
-
-export { ConditionItemsResultObserver } from './condition-items-result-observer';
-export { ConditionItemModel } from './condition-item-model';
-
-export { ConditionControlResultValue } from './condition-control-result-value';

package/src/model/shared/condition/relation-condition-result-state.ts

@@ -1,8 +0,0 @@
-import { VariableState } from '../../../communication/variable/variable-state';
-
-export class RelationConditionResultState {
-    constructor(public readonly state: VariableState, public readonly value: boolean) {
-        this.state = state;
-        this.value = value;
-    }
-}

package/src/model/shared/condition/relation-condition-result.ts

@@ -1,7 +0,0 @@
-import { RelationType } from './relation-type';
-import { RelationConditionResultState } from './relation-condition-result-state';
-
-export class RelationConditionResult {
-    constructor(public readonly key: number, public readonly relationType: RelationType, public readonly result: RelationConditionResultState) {
-    }
-}

package/src/model/shared/condition/relation-type.ts

@@ -1,5 +0,0 @@
-export enum RelationType {
-    None,
-    And,
-    Or
-}

package/src/model/shared/condition/relational-operator.ts

@@ -1,8 +0,0 @@
-export enum RelationalOperator {
-    Equal,
-    NotEqual,
-    GreaterThan,
-    LessThan,
-    GreaterOrEqual,
-    LessOrEqual
-}

package/src/model/shared/condition/variable-value-logic-model.ts

@@ -1,12 +0,0 @@
-import { VariableValueType } from './variable-value-type';
-import { RelationalOperator } from './relational-operator';
-
-export interface VariableValueLogicModel {
-    readonly variableName?: string;
-    readonly variableGroupName?: string;
-    readonly dataSourceCode?: number;
-    readonly valueType: VariableValueType;
-    readonly constValue?: number;
-    readonly operator: RelationalOperator;
-    readonly variableVersion?: number;
-}

package/src/model/shared/condition/variable-value-type.ts

@@ -1,4 +0,0 @@
-export enum VariableValueType {
-    Constant,
-    Variable
-}

package/src/model/shared/condition/word-condition-item-observer.ts

@@ -1,158 +0,0 @@
-import { VariableValueType } from './variable-value-type';
-import { ConditionItemObserver } from './condition-item-observer';
-import { VariableValue, VariableCommunicator, VariableStateEnum, VariableState } from '../../../communication';
-import { WordConditionModel } from './word-condition-model';
-import { RelationType } from './relation-type';
-import { RelationalOperator } from './relational-operator';
-import { RelationConditionResultState } from './relation-condition-result-state';
-import { VariableUtil } from '../../../utils/variable-util';
-import { VariableDefinition } from '../../../communication/variable/variable-definition';
-import { VariableStore } from '../../../config';
-
-export class WordConditionItemObserver extends ConditionItemObserver {
-
-    isConditionEffective: boolean;
-
-    private currentValue: VariableValue;
-    private baseVariableValue: VariableValue;
-    private realtionVariableValue?: VariableValue;
-
-    get baseVariable(): string {
-        const variableValue = this.wordCondition.baseVariableValue;
-        if (!variableValue || !variableValue.variableName) { return; }
-        const variable = new VariableDefinition(variableValue.variableName, variableValue.variableGroupName,
-            variableValue.dataSourceCode, variableValue.variableVersion);
-        return VariableUtil.getConvertedVariableName(this.variableStore, variable);
-    }
-
-    get realtionVariable(): string {
-        const variableValue = this.wordCondition.realtionVariableValue;
-        if (!variableValue || !variableValue.variableName) { return; }
-        const variable = new VariableDefinition(variableValue.variableName, variableValue.variableGroupName,
-            variableValue.dataSourceCode, variableValue.variableVersion);
-        return VariableUtil.getConvertedVariableName(this.variableStore, variable);
-    }
-
-    constructor(protected readonly wordCondition: WordConditionModel,
-        private readonly variableCommunicator: VariableCommunicator,
-        variableStore: VariableStore) {
-        super(wordCondition, variableStore);
-    }
-
-    requestData(appId: string) {
-        if (!this.wordCondition) { throw new Error('WordConditionModel cannot be null.'); }
-        if (!this.wordCondition.baseVariableValue) { throw new Error('WordConditionModel.baseVariableValue cannot be null.'); }
-        // eslint-disable-next-line eqeqeq
-        if (this.wordCondition.baseVariableValue.valueType == VariableValueType.Constant) {
-            this.baseVariableValue = new VariableValue(undefined, VariableStateEnum.DataNormal, this.wordCondition.baseVariableValue.constValue);
-        } else {
-            if (this.variableName) {
-                this.variableCommunicator.subscribeVariableState(this.variableName).subscribe(variableValue => {
-                    if (variableValue.state === VariableStateEnum.Normal) {
-                        this.requestconditionEffectiveBaseValue(this.variableCommunicator, appId);
-                    } else {
-                        this.conditionEffectiveChanged.emit(new RelationConditionResultState(new VariableState(this.variableName, variableValue.state), false));
-                    }
-                });
-            }
-        }
-
-        if (+this.wordCondition.relationType !== 0) {
-            if (!this.wordCondition.baseVariableValue) { throw new Error('WordConditionModel.realtionVariableValue cannot be null.'); }
-
-            // eslint-disable-next-line eqeqeq
-            if (this.wordCondition.realtionVariableValue.valueType == VariableValueType.Constant) {
-                this.realtionVariableValue = new VariableValue(undefined, VariableStateEnum.DataNormal, this.wordCondition.realtionVariableValue.constValue);
-            } else {
-                if (this.variableName) {
-                    this.variableCommunicator.subscribeVariableState(this.variableName).subscribe(variableState => {
-                        if (variableState.state === VariableStateEnum.Normal) {
-                            this.requestconditionEffectiveRealtionValue(this.variableCommunicator, appId);
-                        } else {
-                            this.conditionEffectiveChanged.emit(new RelationConditionResultState(new VariableState(this.variableName, variableState.state), false));
-                        }
-                    });
-                } else {
-                    this.requestconditionEffectiveRealtionValue(this.variableCommunicator, appId);
-                }
-            }
-        }
-        if (this.variableName) {
-            this.variableCommunicator.subscribeVariableState(this.variableName).subscribe(variableValue => {
-                if (variableValue.state === VariableStateEnum.Normal) {
-                    this.requestconditionEffectiveValue(this.variableCommunicator, appId);
-                } else {
-                    this.conditionEffectiveChanged.emit(new RelationConditionResultState(new VariableState(this.variableName, variableValue.state), false));
-                }
-            });
-        }
-    }
-
-    private requestconditionEffectiveValue(variableCommunicator: VariableCommunicator, appId = '') {
-        variableCommunicator.openVariable(this.variableName, appId).subscribe(variableValue => {
-            this.currentValue = variableValue;
-            this.isConditionEffective = this.getIsConditionEffective();
-            this.conditionEffectiveChanged.emit(new RelationConditionResultState(new VariableState(this.variableName, variableValue.state), this.isConditionEffective));
-        });
-    }
-
-    private requestconditionEffectiveBaseValue(variableCommunicator: VariableCommunicator, appId = '') {
-        variableCommunicator.openVariable(this.baseVariable, appId).subscribe(variableValue => {
-            this.baseVariableValue = variableValue;
-            this.isConditionEffective = this.getIsConditionEffective();
-            this.conditionEffectiveChanged.emit(new RelationConditionResultState(new VariableState(this.variableName, variableValue.state), this.isConditionEffective));
-        });
-    }
-
-    private requestconditionEffectiveRealtionValue(variableCommunicator: VariableCommunicator, appId = '') {
-        variableCommunicator.openVariable(this.realtionVariable, appId).subscribe(variableValue => {
-            this.realtionVariableValue = variableValue;
-            this.isConditionEffective = this.getIsConditionEffective();
-            this.conditionEffectiveChanged.emit(new RelationConditionResultState(new VariableState(this.variableName, variableValue.state), this.isConditionEffective));
-        });
-    }
-
-    getIsConditionEffective(): boolean {
-        // eslint-disable-next-line eqeqeq
-        if (this.wordCondition.relationType == RelationType.None) {
-            return this.comparator(this.baseVariableValue, this.wordCondition.baseVariableValue.operator);
-            // eslint-disable-next-line eqeqeq
-        } else if (this.wordCondition.relationType == RelationType.And) {
-            return this.comparator(this.baseVariableValue, this.wordCondition.baseVariableValue.operator)
-                && this.comparator(this.realtionVariableValue, this.wordCondition.realtionVariableValue.operator);
-            // eslint-disable-next-line eqeqeq
-        } else if (this.wordCondition.relationType == RelationType.Or) {
-            return this.comparator(this.baseVariableValue, this.wordCondition.baseVariableValue.operator)
-                || this.comparator(this.realtionVariableValue, this.wordCondition.realtionVariableValue.operator);
-        }
-    }
-
-    private comparator(comparatorValue: VariableValue, relationalOperator: RelationalOperator): boolean {
-        if (comparatorValue == null) { return false; }
-        if (this.currentValue == null) { return false; }
-        if (comparatorValue.state !== VariableStateEnum.DataNormal || (this.currentValue.state !== VariableStateEnum.DataNormal)) { return false; }
-        // eslint-disable-next-line eqeqeq
-        if (relationalOperator == RelationalOperator.Equal) {
-            // eslint-disable-next-line eqeqeq
-            return (+this.currentValue.value) == (+comparatorValue.value);
-            // eslint-disable-next-line eqeqeq
-        } else if (relationalOperator == RelationalOperator.GreaterOrEqual) {
-            // eslint-disable-next-line eqeqeq
-            return (+this.currentValue.value) > (+comparatorValue.value) || (+this.currentValue.value) == (+comparatorValue.value);
-            // eslint-disable-next-line eqeqeq
-        } else if (relationalOperator == RelationalOperator.GreaterThan) {
-            return (+this.currentValue.value) > (+comparatorValue.value);
-            // eslint-disable-next-line eqeqeq
-        } else if (relationalOperator == RelationalOperator.LessOrEqual) {
-            // eslint-disable-next-line eqeqeq
-            return (+this.currentValue.value) < (+comparatorValue.value) || (+this.currentValue.value) == (+comparatorValue.value);
-            // eslint-disable-next-line eqeqeq
-        } else if (relationalOperator == RelationalOperator.LessThan) {
-            return (+this.currentValue.value) < (+comparatorValue.value);
-            // eslint-disable-next-line eqeqeq
-        } else if (relationalOperator == RelationalOperator.NotEqual) {
-            // eslint-disable-next-line eqeqeq
-            return (+this.currentValue.value) != (+comparatorValue.value);
-        }
-    }
-}

package/src/model/shared/condition/word-condition-model.ts

@@ -1,9 +0,0 @@
-import { RelationType } from './relation-type';
-import { ConditionModel } from './condition-model';
-import { VariableValueLogicModel } from './variable-value-logic-model';
-
-export interface WordConditionModel extends ConditionModel {
-    readonly relationType: RelationType;
-    readonly baseVariableValue: VariableValueLogicModel;
-    readonly realtionVariableValue?: VariableValueLogicModel;
-}

package/src/model/shared/condition/word-condition.ts

@@ -1,6 +0,0 @@
-import { RelationalOperator } from './relational-operator';
-
-export interface WordCondition {
-    readonly operator: RelationalOperator;
-    readonly operand: number;
-}

package/src/model/shared/data-type/display-data-type.ts

@@ -1,5 +0,0 @@
-export enum DisplayDataType {
-    Decimal = 0,
-    Hex = 1,
-    Binary = 2
-}

package/src/model/shared/data-type/fbox-data-type.ts

@@ -1,15 +0,0 @@
-export enum FBoxDataType {
-    Bit = 0,
-    UInt16 = 1,
-    Int16 = 2,
-    Bcd16 = 3,
-    Hex16 = 4,
-    Binary16 = 5,
-    UInt32 = 11,
-    Int32 = 12,
-    Bcd32 = 13,
-    Hex32 = 14,
-    Binary32 = 15,
-    Single = 16,
-    String = 30,
-}

package/src/model/shared/data-type/fcloud-data-Type.ts

@@ -1,8 +0,0 @@
-export enum FCloudDataType {
-    Int32 = 1,
-    Float = 2,
-    Bool = 4,
-    String = 8,
-    Binary = 90,
-    Hex = 99
-}

package/src/model/shared/dynamic-display/dynamic-behavior-type.ts

@@ -1,5 +0,0 @@
-export enum DynamicBehaviorType {
-    HorizontalTranslation,
-    VerticalTranslation,
-    Rotation
-}

package/src/model/shared/dynamic-display/dynamic-display-behavior-model.ts

@@ -1,6 +0,0 @@
-import { DynamicDisplayResultModel } from './dynamic-display-result-model';
-import { EventEmitter } from '@angular/core';
-
-export interface DynamicDisplayBehaviorModel {
-    readonly doBehavior: EventEmitter<DynamicDisplayResultModel>;
-}

package/src/model/shared/dynamic-display/dynamic-display-result-model.ts

@@ -1,6 +0,0 @@
-import { DynamicBehaviorType } from './dynamic-behavior-type';
-
-export class DynamicDisplayResultModel {
-    constructor(readonly translation: number, readonly angel: number, readonly behaviorType: DynamicBehaviorType) {
-    }
-}

package/src/model/shared/dynamic-display/dynamic-display.ts

@@ -1,48 +0,0 @@
-
-import { EventEmitter } from '@angular/core';
-
-import { RotationBehavior } from '../rotation/rotation-behavior';
-import { DynamicDisplayBehaviorModel } from './dynamic-display-behavior-model';
-import { TranslationDirectionType } from '../translation/translation-direction-type';
-import { TranslationBehavior } from '../translation/translation-behavior';
-import { DynamicDisplayModel } from './dynamic-display-model';
-import { DynamicDisplayResultModel } from './dynamic-display-result-model';
-import { DynamicBehaviorType } from './dynamic-behavior-type';
-import { VariableCommunicator } from '../../../communication';
-import { Point } from '../point.model';
-import { VariableStore } from '../../../config';
-
-export class DynamicDisplay implements DynamicDisplayBehaviorModel {
-
-    readonly doBehavior: EventEmitter<DynamicDisplayResultModel> = new EventEmitter<DynamicDisplayResultModel>();
-
-    constructor(dynamicDisplay: DynamicDisplayModel, variableCommunicator: VariableCommunicator, variableStore: VariableStore,
-        location: Point, signalRAppId: string) {
-        if (dynamicDisplay.isHorizontalTranslation && dynamicDisplay.horizontalTranslation != null) {
-            // tslint:disable-next-line:max-line-length
-            const horizontalBehavior = new TranslationBehavior(dynamicDisplay.horizontalTranslation,
-                variableCommunicator, variableStore, TranslationDirectionType.Horizontal, location, signalRAppId);
-            horizontalBehavior.doTranslation.subscribe(tanslation => {
-                // tslint:disable-next-line:max-line-length
-                const dynamicDisplayResult = new DynamicDisplayResultModel(tanslation, undefined, DynamicBehaviorType.HorizontalTranslation);
-                this.doBehavior.emit(dynamicDisplayResult);
-            });
-        }
-        if (dynamicDisplay.isVerticalTranslation && dynamicDisplay.verticalTranslation != null) {
-            // tslint:disable-next-line:max-line-length
-            const verticalBehavior = new TranslationBehavior(dynamicDisplay.verticalTranslation, variableCommunicator, variableStore,
-                TranslationDirectionType.Vertical, location, signalRAppId);
-            verticalBehavior.doTranslation.subscribe(tanslation => {
-                const dynamicDisplayResult = new DynamicDisplayResultModel(tanslation, undefined, DynamicBehaviorType.VerticalTranslation);
-                this.doBehavior.emit(dynamicDisplayResult);
-            });
-        }
-        if (dynamicDisplay.isRotation && dynamicDisplay.rotation != null) {
-            const rotationBehavior = new RotationBehavior(dynamicDisplay.rotation, variableCommunicator, variableStore, signalRAppId);
-            rotationBehavior.doRotation.subscribe(angel => {
-                const dynamicDisplayResult = new DynamicDisplayResultModel(undefined, angel, DynamicBehaviorType.Rotation);
-                this.doBehavior.emit(dynamicDisplayResult);
-            });
-        }
-    }
-}

package/src/model/shared/graph/custom-style.ts

@@ -1,17 +0,0 @@
-export interface CustomStyle {
-    /**
-     * 版本1：废弃掉state、stateId。改用stateIndex表示状态索引。
-     */
-    version?: number;
-
-    state?: string;
-
-    stateId?: number;
-
-    stateIndex: number;
-    /**
-     * CustomStyle
-     */
-    stroke?: string;
-    fill?: string;
-}

package/src/model/shared/graph/graph-setting.ts

@@ -1,11 +0,0 @@
-import { CustomStyle } from './custom-style';
-
-export interface GraphSetting {
-    /**
-     * @type {(string | number)}
-     * @memberof GraphSetting
-     * @description 旧版本使用的string指向系统图库.新版本使用的number指向当前工程图库。
-     */
-    readonly id: string | number;
-    readonly styles?: CustomStyle[];
-}

package/src/model/shared/rotation/rotation-behavior-model.ts

@@ -1,5 +0,0 @@
-import { EventEmitter } from '@angular/core';
-
-export interface RotationBehaviorModel {
-    readonly doRotation: EventEmitter<number>;
-}

package/src/model/shared/rotation/rotation-behavior.ts

@@ -1,91 +0,0 @@
-
-import { EventEmitter } from '@angular/core';
-import { RotationDirectionType } from './rotation-direction-type';
-import { RotationBehaviorModel } from './rotation-behavior-model';
-import { VariableCommunicator } from '../../../communication';
-import { RotationModel } from './rotation-model';
-import { RotationObserver } from './rotation-observer';
-import { VariableStore } from '../../../config';
-
-export class RotationBehavior implements RotationBehaviorModel {
-
-    readonly doRotation: EventEmitter<number> = new EventEmitter<number>();
-
-    constructor(rotationModel: RotationModel, variableCommunicator: VariableCommunicator, variableStore: VariableStore, signalRAppId: string) {
-        const rotationObserver = new RotationObserver(rotationModel, variableCommunicator, variableStore, signalRAppId);
-        rotationObserver.rotationValueChanged.subscribe(rotationValue => {
-            if (+rotationModel.rotationDirection === RotationDirectionType.ClockWise) {
-                let newRotation: number;
-                if (rotationModel.isProportion === true) {
-                    const proportion = (rotationModel.maxAngle - rotationModel.minAngle)
-                        / (rotationModel.maxProportionScale - rotationModel.minProportionScale);
-                    if (rotationModel.isReverseProportion === true) {
-                        if (rotationValue > rotationModel.maxProportionScale) {
-                            newRotation = rotationModel.minAngle;
-                        } else if (rotationValue < rotationModel.minProportionScale) {
-                            newRotation = rotationModel.maxAngle;
-                        } else {
-                            newRotation = rotationModel.maxAngle - (rotationValue - rotationModel.minProportionScale) * proportion;
-                        }
-                    } else {
-                        if (rotationValue > rotationModel.maxProportionScale) {
-                            newRotation = rotationModel.maxAngle;
-                        } else if (rotationValue < rotationModel.minProportionScale) {
-                            newRotation = rotationModel.minAngle;
-                        } else {
-                            newRotation = rotationModel.minAngle + (rotationValue - rotationModel.minProportionScale) * proportion;
-                        }
-                    }
-                    this.doRotation.emit(newRotation);
-                } else {
-                    if (rotationValue < rotationModel.minAngle) {
-                        this.doRotation.emit(rotationModel.minAngle);
-                    } else if (rotationValue > rotationModel.maxAngle) {
-                        this.doRotation.emit(rotationModel.maxAngle);
-                    } else {
-                        this.doRotation.emit(rotationValue);
-                    }
-                }
-            } else if (+rotationModel.rotationDirection === RotationDirectionType.ReverseClockWise) {
-                let newRotation: number;
-                const nowMin = 360 - rotationModel.maxAngle;
-                const nowMax = 360 - rotationModel.minAngle;
-                if (rotationModel.isProportion === true) {
-                    const proportion = (nowMax - nowMin) / (rotationModel.maxProportionScale - rotationModel.minProportionScale);
-                    if (rotationModel.isReverseProportion === true) {
-                        if (rotationValue > rotationModel.maxProportionScale) {
-                            newRotation = nowMax;
-                        } else if (rotationValue < rotationModel.minProportionScale) {
-                            newRotation = nowMin;
-                        } else {
-                            newRotation = nowMin + (rotationValue - rotationModel.minProportionScale) * proportion;
-                        }
-                    } else {
-                        if (rotationValue > rotationModel.maxProportionScale) {
-                            newRotation = nowMin;
-                        } else if (rotationValue < rotationModel.minProportionScale) {
-                            newRotation = nowMax;
-                        } else {
-                            newRotation = nowMax - (rotationValue - rotationModel.minProportionScale) * proportion;
-                        }
-                        if (newRotation > nowMax) {
-                            newRotation = nowMax;
-                        } else if (newRotation < nowMin) {
-                            newRotation = nowMin;
-                        }
-                    }
-                    this.doRotation.emit(newRotation);
-                } else {
-                    newRotation = 360 - rotationValue;
-                    if (newRotation < nowMin) {
-                        this.doRotation.emit(nowMin);
-                    } else if (newRotation > nowMax) {
-                        this.doRotation.emit(nowMax);
-                    } else {
-                        this.doRotation.emit(newRotation);
-                    }
-                }
-            }
-        });
-    }
-}

package/src/model/shared/rotation/rotation-direction-type.ts

@@ -1,4 +0,0 @@
-export enum RotationDirectionType {
-    ClockWise,
-    ReverseClockWise
-}

package/src/model/shared/rotation/rotation-model.ts

@@ -1,15 +0,0 @@
-import { RotationDirectionType } from './rotation-direction-type';
-
-export interface RotationModel {
-    readonly rotationDirection: RotationDirectionType;
-    readonly variableName: string;
-    readonly minAngle: number;
-    readonly maxAngle: number;
-    readonly isProportion: boolean;
-    readonly minProportionScale: number;
-    readonly maxProportionScale: number;
-    readonly isReverseProportion: boolean;
-    readonly variableGroupName: string;
-    readonly dataSourceCode?: number;
-    readonly variableVersion?: number;
-}