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

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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,96 @@
+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

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

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

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

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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,7 @@
+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

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

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

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

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

@@ -0,0 +1,12 @@
+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

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

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

@@ -0,0 +1,158 @@
+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

@@ -0,0 +1,9 @@
+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

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

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

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

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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,8 @@
+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

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

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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,48 @@
+
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,11 @@
+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

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

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

@@ -0,0 +1,91 @@
+
+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

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

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

@@ -0,0 +1,15 @@
+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;
+}