lavva.exalushome.extalife
Version:
Library implementing communication and abstraction layers for ExtaLife API in ExalusHome system
698 lines • 40.8 kB
JavaScript
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
import { Api } from "lavva.exalushome";
import { ExalusConnectionService } from "lavva.exalushome/build/js/Services/ExalusConnectionService";
import { DeviceResponseType } from "lavva.exalushome/build/js/Services/Devices/IDevice";
import { DependencyContainer } from "lavva.exalushome/build/js/DependencyContainer";
import { LoggerService } from "lavva.exalushome/build/js/Services/Logging/LoggerService";
import { ResponseResult } from "lavva.exalushome/build/js/Services/FieldChangeResult";
import { ControllerConfigurationService } from "lavva.exalushome/build/js/Services/Controller/ControllerConfigurationService";
import { BlindActionEnum, SetBlindOpenCloseTime, SetBlindPosition } from "lavva.exalushome/build/js/Services/Devices/Tasks/Tasks";
import { DeviceTaskExecutionResult } from "lavva.exalushome/build/js/Services/Devices/TaskExecutionResult";
import { DataFrame, Method, Status } from "lavva.exalushome/build/js/DataFrame";
import { BlindCalibrationStatusEnum } from "lavva.exalushome/build/js/Services/Devices/IDeviceState";
import { ComfortPositionParameters, CorrectionSteps, InputOutputBlindParameters, StateOfTurnOnBlindDeviceParameters } from "./BlindConfigParameters";
import { GetChannelParamsRequest } from "../DataRequest";
import { AppStateService } from "lavva.exalushome/build/js/Services/AppStateService";
export class BlindConfigService {
constructor() {
this._connection = null;
this._controllerConfigurationService = null;
this._manualCalibrationContext = new ManualCalibrationContext();
this._connection = Api.Get(ExalusConnectionService.ServiceName);
this._controllerConfigurationService = Api.Get(ControllerConfigurationService.ServiceName);
this._logger = Api.Get(LoggerService.ServiceName);
}
static Init() {
DependencyContainer.Instance.RegisterService(new BlindConfigService());
Api.Get(LoggerService.ServiceName).Debug("Initialized BlindConfigService");
}
GetServiceName() {
return BlindConfigService.ServiceName;
}
ManualCalibration(device, channel) {
try {
if (!device.Channels.any(ch => ch.Number === channel))
return new ResponseResult(BlindConfigurationErrorCode.InvalidChannelNumber, `Cannot get manual calibration functions - invalid channel number, channel: ${channel}`);
let manualCalibrationFunctions = {
StepAOpenBlindAsync: () => __awaiter(this, void 0, void 0, function* () {
const openCloseTime = new SetBlindOpenCloseTime();
openCloseTime.Data.Channel = channel;
openCloseTime.Data.CloseTime = 65535;
openCloseTime.Data.OpenTime = 65535;
this._logger.Debug(`Manual calibration start, STEP A - clearing context data.`);
this._manualCalibrationContext = new ManualCalibrationContext();
switch (yield device.Channels.first(ch => ch.Number == channel).ExecuteTaskAsync(openCloseTime)) {
case DeviceTaskExecutionResult.Executed:
break;
default:
this._logger.Debug(`Manual calibration failed - cannot set open/close time to max values.`);
return Status.Error;
}
const blindPosition = new SetBlindPosition();
blindPosition.Action = BlindActionEnum.Open;
switch (yield device.Channels.first(ch => ch.Number == channel).ExecuteTaskAsync(blindPosition)) {
case DeviceTaskExecutionResult.Executed:
break;
default:
this._logger.Debug(`Manual calibration failed - unable to open blind.`);
return Status.Error;
}
this._manualCalibrationContext.StepAFinished = true;
return Status.OK;
}),
StepBCalibrateOpeningTime: () => {
if (!this._manualCalibrationContext.StepAFinished)
return new ResponseResult(BlindConfigurationErrorCode.WrongStepOfOperation, 'Unable to run step "StepBCalibrateOpeningTime" - make sure previous steps have been completed.');
let stepBCalibrateOpeningTimeFunctions = {
StepAInitBlindMoveAsync: () => __awaiter(this, void 0, void 0, function* () {
const blindPosition = new SetBlindPosition();
blindPosition.Action = BlindActionEnum.Close;
switch (yield device.Channels.first(ch => ch.Number == channel).ExecuteTaskAsync(blindPosition)) {
case DeviceTaskExecutionResult.Executed:
this._manualCalibrationContext.OpeningStartTime = Date.now();
this._manualCalibrationContext.StepBAFinished = true;
return Status.OK;
default:
return Status.Error;
}
}),
StepBConfirmBlindPositionAsync: () => __awaiter(this, void 0, void 0, function* () {
if (!this._manualCalibrationContext.StepBAFinished)
return Status.NoPermissionToPerformThisOperation;
const blindPosition = new SetBlindPosition();
blindPosition.Action = BlindActionEnum.Stop;
switch (yield device.Channels.first(ch => ch.Number == channel).ExecuteTaskAsync(blindPosition)) {
case DeviceTaskExecutionResult.Executed:
this._manualCalibrationContext.OpeningEndTime = Date.now();
this._manualCalibrationContext.StepBFinished = true;
return Status.OK;
default:
return Status.Error;
}
})
};
return stepBCalibrateOpeningTimeFunctions;
},
StepCCalibrateClosingTime: () => {
if (!this._manualCalibrationContext.StepAFinished || !this._manualCalibrationContext.StepBFinished)
return new ResponseResult(BlindConfigurationErrorCode.WrongStepOfOperation, 'Unable to run step "StepCCalibrateClosingTime" - make sure previous steps have been completed.');
let stepCCalibrateClosingTimeFunctions = {
StepAInitBlindMoveAsync: () => __awaiter(this, void 0, void 0, function* () {
const blindPosition = new SetBlindPosition();
blindPosition.Action = BlindActionEnum.Open;
switch (yield device.Channels.first(ch => ch.Number == channel).ExecuteTaskAsync(blindPosition)) {
case DeviceTaskExecutionResult.Executed:
this._manualCalibrationContext.ClosingStartTime = Date.now();
this._manualCalibrationContext.StepCAFinished = true;
return Status.OK;
default:
return Status.Error;
}
}),
StepBConfirmBlindPositionAsync: () => __awaiter(this, void 0, void 0, function* () {
if (!this._manualCalibrationContext.StepCAFinished)
return Status.NoPermissionToPerformThisOperation;
const blindPosition = new SetBlindPosition();
blindPosition.Action = BlindActionEnum.Stop;
switch (yield device.Channels.first(ch => ch.Number == channel).ExecuteTaskAsync(blindPosition)) {
case DeviceTaskExecutionResult.Executed:
this._manualCalibrationContext.ClosingEndTime = Date.now();
this._manualCalibrationContext.StepCFinished = true;
return Status.OK;
default:
return Status.Error;
}
})
};
return stepCCalibrateClosingTimeFunctions;
},
StepDSaveCalibrationAsync: () => __awaiter(this, void 0, void 0, function* () {
if (!this._manualCalibrationContext.StepAFinished || !this._manualCalibrationContext.StepBFinished || !this._manualCalibrationContext.StepCFinished)
return Status.NoPermissionToPerformThisOperation;
const openCloseTime = new SetBlindOpenCloseTime();
openCloseTime.Data.Channel = channel;
openCloseTime.Data.OpenTime = Math.ceil((this._manualCalibrationContext.OpeningEndTime - this._manualCalibrationContext.OpeningStartTime) / 10);
openCloseTime.Data.CloseTime = Math.ceil((this._manualCalibrationContext.ClosingEndTime - this._manualCalibrationContext.ClosingStartTime) / 10);
this._logger.Debug(`Mamual calibration finished - OpenTime: ${openCloseTime.Data.OpenTime}, CloseTime: ${openCloseTime.Data.CloseTime}.`);
switch (yield device.Channels.first(ch => ch.Number == channel).ExecuteTaskAsync(openCloseTime)) {
case DeviceTaskExecutionResult.Executed:
this._manualCalibrationContext = new ManualCalibrationContext();
this._logger.Debug(`Manual calibration - clearing context data.`);
return Status.OK;
default:
this._manualCalibrationContext = new ManualCalibrationContext();
this._logger.Debug(`Manual calibration failed, cannot save open/close time - clearing context data.`);
return Status.Error;
}
})
};
return manualCalibrationFunctions;
}
catch (error) {
return new ResponseResult(BlindConfigurationErrorCode.OtherError, `Failed to get manual calibration functions - unknown error.`);
}
}
RunAutomaticCalibrationAsync(device, channel) {
return __awaiter(this, void 0, void 0, function* () {
var _a, _b, _c, _d, _e, _f;
try {
if (!device.Channels.any(ch => ch.Number === channel)) {
return new ResponseResult(BlindConfigurationErrorCode.InvalidChannelNumber, `Cannot calibrate blind - invalid channel number: ${channel}`);
}
const currentCalibration = yield this.IsCalibrationRunningAsync();
if (currentCalibration.Type == BlindConfigurationErrorCode.CannotCheckIfCalibrationsIsRunning)
return currentCalibration;
else if (currentCalibration)
return new ResponseResult(BlindConfigurationErrorCode.CalibrationsIsCurrentlyRunning, `Cannot calibrate blind - calibration is currently running - make sure no blind is currently calibrated and try again.`);
yield ((_a = this._controllerConfigurationService) === null || _a === void 0 ? void 0 : _a.EnterConfigurationModeAsync());
const task = new SetBlindPosition();
task.Action = BlindActionEnum.Stop;
switch (yield device.Channels.first(ch => ch.Number == channel).ExecuteTaskAsync(task)) {
case DeviceTaskExecutionResult.Executed:
break;
default:
this._logger.Error(BlindConfigService.ServiceName, `EXIT CONFIGURATION MODE WILL BE FIRED! RunAutomaticCalibrationAsync()`);
(_b = this._controllerConfigurationService) === null || _b === void 0 ? void 0 : _b.ExitConfigurationModeAsync();
return new ResponseResult(BlindConfigurationErrorCode.DeviceNotResponding, `Cannot calibrate blind - device is not responding.`);
}
const calibrationReq = yield ((_c = this._connection) === null || _c === void 0 ? void 0 : _c.SendAndWaitForResponseAsync(new EnableAutoCalibraionRequest(device.Guid), 8000, false));
if (calibrationReq == null || calibrationReq.Status == null)
return new ResponseResult(BlindConfigurationErrorCode.OtherError, `Cannot calibrate blind - calibration request failed for an unknown reason.`);
if (calibrationReq.Status !== Status.OK)
return new ResponseResult(BlindConfigurationErrorCode.OtherError, `Cannot calibrate blind - calibration request failed - request status code: ${calibrationReq.Status}`);
const calibrationTask = new Promise((resolve, reject) => {
let calibrationInProgress = false;
let keepAlive;
const AutoCalibrationStateHandler = (stateChange) => {
if (stateChange.TypeAsEnum == DeviceResponseType.BlindCalibration) {
switch (stateChange.Data.CalibrationStatus) {
case BlindCalibrationStatusEnum.AutoLernCancelled:
device.OnDeviceStateRefreshedOrChangedEvent().Unsubscribe(AutoCalibrationStateHandler);
calibrationInProgress = false;
clearTimeout(keepAlive);
reject(new ResponseResult(BlindConfigurationErrorCode.CalibrationCancelled, `Calibration canceled - recived AutoLernCancelled message.`));
break;
case BlindCalibrationStatusEnum.AutoLernSuccessfull:
this._logger.Debug("Calibration finished - recived AutoLernSuccessfull message.");
device.OnDeviceStateRefreshedOrChangedEvent().Unsubscribe(AutoCalibrationStateHandler);
calibrationInProgress = false;
clearTimeout(keepAlive);
resolve(stateChange.Data);
break;
case BlindCalibrationStatusEnum.AutoLernInProgress:
this._logger.Debug("Recived AutoLernInProgress message.");
calibrationInProgress = true;
if (keepAlive == null) {
this._logger.Debug("Calibration start - recived AutoLernInProgress message.");
keepAlive = setTimeout(() => {
device.OnDeviceStateRefreshedOrChangedEvent().Unsubscribe(AutoCalibrationStateHandler);
reject(new ResponseResult(BlindConfigurationErrorCode.Timeout, `Calibration failed - calibration status message timeout has been reached.`));
}, 8000);
}
break;
case BlindCalibrationStatusEnum.AutoLernIdle:
calibrationInProgress = false;
device.OnDeviceStateRefreshedOrChangedEvent().Unsubscribe(AutoCalibrationStateHandler);
clearTimeout(keepAlive);
reject(new ResponseResult(BlindConfigurationErrorCode.IncorrectResponse, `Calibration failed - recived AutoLernIdle message received before completion of calibration.`));
}
}
else if (calibrationInProgress && stateChange.TypeAsEnum == DeviceResponseType.BlindPosition) {
this._logger.Debug("Calibration in progress - recived BlindPosition message.");
clearTimeout(keepAlive);
keepAlive = setTimeout(() => {
device.OnDeviceStateRefreshedOrChangedEvent().Unsubscribe(AutoCalibrationStateHandler);
reject(new ResponseResult(BlindConfigurationErrorCode.Timeout, `Calibration failed - calibration status message timeout has been reached.`));
}, 8000);
}
};
device.OnDeviceStateRefreshedOrChangedEvent().Subscribe(AutoCalibrationStateHandler);
});
const appStateService = Api.Get(AppStateService.ServiceName);
try {
appStateService.DisallowHibernation();
const result = yield calibrationTask;
this._logger.Error(BlindConfigService.ServiceName, `EXIT CONFIGURATION MODE WILL BE FIRED! RunAutomaticCalibrationAsync()`);
(_d = this._controllerConfigurationService) === null || _d === void 0 ? void 0 : _d.ExitConfigurationModeAsync();
return result;
}
catch (error) {
this._logger.Error(BlindConfigService.ServiceName, `EXIT CONFIGURATION MODE WILL BE FIRED! RunAutomaticCalibrationAsync()`);
(_e = this._controllerConfigurationService) === null || _e === void 0 ? void 0 : _e.ExitConfigurationModeAsync();
return error;
}
finally {
appStateService.AllowHibernation();
}
}
catch (error) {
this._logger.Error(BlindConfigService.ServiceName, `EXIT CONFIGURATION MODE WILL BE FIRED! RunAutomaticCalibrationAsync()`);
(_f = this._controllerConfigurationService) === null || _f === void 0 ? void 0 : _f.ExitConfigurationModeAsync();
return new ResponseResult(BlindConfigurationErrorCode.OtherError, `Cannot calibrate blind - unknown error.`);
}
});
}
StopAutomaticCalibrationAsync(device) {
return __awaiter(this, void 0, void 0, function* () {
var _a;
try {
const currentCalibration = yield this.IsCalibrationRunningAsync();
if (currentCalibration.Type == BlindConfigurationErrorCode.CannotCheckIfCalibrationsIsRunning)
return Status.Error;
else if (!currentCalibration)
return Status.OperationNotPermitted;
const task = new SetBlindPosition();
task.Action = BlindActionEnum.Stop;
for (let i = 0; i < device.Channels.length; i++) {
yield device.Channels[i].ExecuteTaskAsync(task);
}
const result = yield ((_a = this._connection) === null || _a === void 0 ? void 0 : _a.SendAndWaitForResponseAsync(new StopAutoCalibraionRequest(device.Guid), 8000, false));
if (result == null || result.Status == null) {
this._logger.Error(`Failed to stop calibration - unknow error.`);
return Status.FatalError;
}
if (result.Status !== Status.OK)
this._logger.Error(`Failed to stop calibration - response status: ${result.Status}`);
return result.Status;
}
catch (error) {
return Status.FatalError;
}
});
}
GetCorrectionStepAsync(device, channel, correctionType) {
return __awaiter(this, void 0, void 0, function* () {
var _a;
const result = yield ((_a = this._connection) === null || _a === void 0 ? void 0 : _a.SendAndWaitForResponseAsync(new GetCorrectionStepsRequest(device.Guid, correctionType), 8000, false));
if (result === null || result === undefined)
return new ResponseResult(BlindConfigurationErrorCode.OtherError, `Failed to retrieve parameters - unknow error.`);
switch (result.Status) {
case Status.OK:
if (result.Data != null) {
const param = result.Data;
const correction = new CorrectionSteps();
correction.Correction = param.Correction;
correction.CorrectionType = correctionType;
for (var i = param.Min; i <= param.Max; i += param.Step)
correction.AvaliableCorrections.push(i);
return correction;
}
break;
default:
return new ResponseResult(BlindConfigurationErrorCode.OtherError, `Failed to retrieve parameters - controller responded with error code: ${result.Status}.`);
}
return new ResponseResult(BlindConfigurationErrorCode.OtherError, `Failed to retrieve parameters - unknown error.`);
});
}
SetCorrectionStepAsync(device, channel, correction, correctionType) {
return __awaiter(this, void 0, void 0, function* () {
var _a, _b;
const result = yield ((_a = this._connection) === null || _a === void 0 ? void 0 : _a.SendAndWaitForResponseAsync(new GetCorrectionStepsRequest(device.Guid, correctionType), 8000, false));
if (result == null)
return Status.ResourceIsNotAvailable;
switch (result.Status) {
case Status.OK:
if (result.Data != null) {
const param = result.Data;
let correctionInAvailableSteps = false;
for (var i = param.Min; i <= param.Max; i += param.Step) {
if (correction == i) {
correctionInAvailableSteps = true;
break;
}
}
if (!correctionInAvailableSteps)
return Status.WrongData;
const newCorrection = new CorrectionStepsFrame();
newCorrection.Correction = correction;
newCorrection.DeviceGuid = device.Guid;
const setDataResult = yield ((_b = this._connection) === null || _b === void 0 ? void 0 : _b.SendAndWaitForResponseAsync(new SetCorrectionStepsRequest(newCorrection, correctionType), 8000, false));
if (setDataResult == null)
return Status.FatalError;
else
return setDataResult.Status != null ? setDataResult.Status : Status.UnknownError;
}
break;
default:
return result.Status != null ? result.Status : Status.UnknownError;
}
return result.Status;
});
}
GetComfortPositionsAsync(device, channel) {
return __awaiter(this, void 0, void 0, function* () {
var _a;
try {
if (!device.Channels.any(ch => ch.Number === channel))
return new ResponseResult(BlindConfigurationErrorCode.InvalidChannelNumber, `Cannot get comfort position - invalid channel number, channel: ${channel}`);
const result = yield ((_a = this._connection) === null || _a === void 0 ? void 0 : _a.SendAndWaitForResponseAsync(new GetComfortPositionsParamsRequest(new GetChannelParamsRequest(device.Guid, channel)), 8000, false));
if (result == null || result.Status == null)
return new ResponseResult(BlindConfigurationErrorCode.OtherError, `Cannot get comfort position - unknown error.`);
if (result.Status !== Status.OK)
return new ResponseResult(BlindConfigurationErrorCode.OtherError, `Cannot get comfort position - controller responded with error code: ${result.Status}.`);
if (result.Data == null)
return new ResponseResult(BlindConfigurationErrorCode.NoData, `Cannot get comfort position - no data in response.`);
const data = new ComfortPositionParameters();
data.Channel = result.Data.Channel;
data.Position1 = result.Data.Position1;
data.Position2 = result.Data.Position2;
return data;
}
catch (error) {
return new ResponseResult(BlindConfigurationErrorCode.OtherError, `Failed to retrieve comfort position - unknown error.`);
}
});
}
SetComfortPositionAsync(device, params) {
return __awaiter(this, void 0, void 0, function* () {
var _a;
try {
const currentPositions = yield this.GetComfortPositionsAsync(device, params.Channel);
if (currentPositions.Type != null)
return Status.ResourceIsNotAvailable;
const frame = new ComfortPositionParametersFrame();
frame.Channel = params.Channel;
frame.DeviceGuid = device.Guid;
frame.Position1 = params.Position1;
frame.Position2 = params.Position2;
const result = yield ((_a = this._connection) === null || _a === void 0 ? void 0 : _a.SendAndWaitForResponseAsync(new SetComfortPositionsParamsRequest(frame), 8000, false));
if (result == null || result.Status == null) {
this._logger.Error(`Failed to set comfort position - unknow error.`);
return Status.FatalError;
}
if (result.Status !== Status.OK)
this._logger.Error(`Failed to set comfort position, response status: ${result.Status}`);
return result.Status;
}
catch (error) {
return Status.FatalError;
}
});
}
SwapRelaysAsync(device, channel) {
return __awaiter(this, void 0, void 0, function* () {
var _a;
try {
const task = new SetBlindPosition();
task.Action = BlindActionEnum.Stop;
switch (yield device.Channels.first(ch => ch.Number == channel).ExecuteTaskAsync(task)) {
case DeviceTaskExecutionResult.Executed:
break;
default:
this._logger.Error(`Failed to swap relays - cannot execute 'blind stop' task.`);
return Status.Error;
}
yield new Promise(resolve => setTimeout(resolve, 500));
const result = yield ((_a = this._connection) === null || _a === void 0 ? void 0 : _a.SendAndWaitForResponseAsync(new SwapRelaysRequest(device.Guid), 8000, false));
if (result == null || result.Status == null) {
this._logger.Error(`Failed to swap relays - unknow error.`);
return Status.FatalError;
}
if (result.Status !== Status.OK)
this._logger.Error(`Failed to swap relays - response status: ${result.Status}`);
return result.Status;
}
catch (error) {
return Status.FatalError;
}
});
}
GetBlindInputOutputParamAsync(device, channel) {
return __awaiter(this, void 0, void 0, function* () {
var _a;
try {
if (!device.Channels.any(ch => ch.Number === channel))
return new ResponseResult(BlindConfigurationErrorCode.InvalidChannelNumber, `Cannot get input/output parameters - invalid channel number, channel: ${channel}`);
const result = yield ((_a = this._connection) === null || _a === void 0 ? void 0 : _a.SendAndWaitForResponseAsync(new InputOutputBlindParametersRequest(new GetChannelParamsRequest(device.Guid, channel)), 8000, false));
if (result == null || result.Status == null)
return new ResponseResult(BlindConfigurationErrorCode.OtherError, `Cannot get input/output parameters - unknown error.`);
if (result.Status !== Status.OK)
return new ResponseResult(BlindConfigurationErrorCode.OtherError, `Cannot get input/output parameters - controller responded with error code: ${result.Status}.`);
if (result.Data == null)
return new ResponseResult(BlindConfigurationErrorCode.NoData, `Cannot get input/output parameters - no data in response.`);
const firstResult = result.Data.firstOrDefault();
if (firstResult == null)
return new ResponseResult(BlindConfigurationErrorCode.InputOutputNotFound, `Cannot get input/output parameters - input/output not exists.`);
const params = new InputOutputBlindParameters();
params.Channel = firstResult.Channel;
params.ButtonTypeBlind = firstResult.ButtonTypeBlind;
params.InputModeBlind = firstResult.InputModeBlind;
return params;
}
catch (error) {
return new ResponseResult(BlindConfigurationErrorCode.OtherError, `Failed to retrieve input/output parameters - unknown error.`);
}
});
}
SetBlindInputOutputParamAsync(device, params) {
return __awaiter(this, void 0, void 0, function* () {
var _a;
try {
const request = new InputOutputBlindParametersFrame();
request.DeviceGuid = device.Guid;
request.ButtonTypeBlind = params.ButtonTypeBlind;
request.InputModeBlind = params.InputModeBlind;
request.Channel = params.Channel;
const result = yield ((_a = this._connection) === null || _a === void 0 ? void 0 : _a.SendAndWaitForResponseAsync(new SetInputOutputBlindParametersRequest(request), 8000, false));
if (result == null || result.Status == null) {
this._logger.Error(`Failed to set input/output parameters - unknow error.`);
return Status.FatalError;
}
if (result.Status !== Status.OK)
this._logger.Error(`Failed to set input/output parameters, response status: ${result.Status}`);
return result.Status;
}
catch (error) {
return Status.FatalError;
}
});
}
GetTurnOnBehaviourAsync(device, channel) {
return __awaiter(this, void 0, void 0, function* () {
var _a;
try {
if (!device.Channels.any(ch => ch.Number === channel))
return new ResponseResult(BlindConfigurationErrorCode.InvalidChannelNumber, `Cannot get turn on behaviour - invalid channel number, channel: ${channel}`);
const result = yield ((_a = this._connection) === null || _a === void 0 ? void 0 : _a.SendAndWaitForResponseAsync(new GetTurnOffBehaviourRequest(new GetChannelParamsRequest(device.Guid, channel)), 8000, false));
if (result == null || result.Status == null)
return new ResponseResult(BlindConfigurationErrorCode.OtherError, `Cannot get turn on behaviour - unknown error.`);
if (result.Status !== Status.OK)
return new ResponseResult(BlindConfigurationErrorCode.OtherError, `Cannot get turn on behaviour - controller responded with error code: ${result.Status}.`);
if (result.Data == null)
return new ResponseResult(BlindConfigurationErrorCode.NoData, `Cannot get turn on behaviour - no data in response.`);
const data = new StateOfTurnOnBlindDeviceParameters();
data.BlindPosition = result.Data.BlindPosition;
data.Channel = result.Data.Channel;
data.State = result.Data.State;
return data;
}
catch (error) {
return new ResponseResult(BlindConfigurationErrorCode.OtherError, `Failed to retrieve turn on behaviour - unknown error.`);
}
});
}
SetTurnOnBehaviourAsync(device, params) {
return __awaiter(this, void 0, void 0, function* () {
var _a;
try {
const request = new StateOfTurnOnDeviceParametersFrame();
request.DeviceGuid = device.Guid;
request.Channel = params.Channel;
request.BlindPosition = params.BlindPosition;
request.State = params.State;
const result = yield ((_a = this._connection) === null || _a === void 0 ? void 0 : _a.SendAndWaitForResponseAsync(new SetTurnOffBehaviourRequest(request), 8000, false));
if (result == null || result.Status == null) {
this._logger.Error(`Failed to set turn on behaviour - unknow error.`);
return Status.FatalError;
}
if (result.Status !== Status.OK)
this._logger.Error(`Failed to set turn on behaviour, response status: ${result.Status}`);
return result.Status;
}
catch (error) {
return Status.FatalError;
}
});
}
IsCalibrationRunningAsync() {
return __awaiter(this, void 0, void 0, function* () {
var _a;
const result = yield ((_a = this._connection) === null || _a === void 0 ? void 0 : _a.SendAndWaitForResponseAsync(new IsCalibrationRunningRequest(), 8000, false));
if (result == null || result.Status == null || result.Status !== Status.OK || result.Data == null)
return new ResponseResult(BlindConfigurationErrorCode.CannotCheckIfCalibrationsIsRunning, `Calibration failed - it is not possible to check whether any cabling is running.`);
return result.Data;
});
}
}
BlindConfigService.ServiceName = "BlindConfigService";
export var BlindConfigurationErrorCode;
(function (BlindConfigurationErrorCode) {
BlindConfigurationErrorCode["OtherError"] = "OtherError";
BlindConfigurationErrorCode["InvalidChannelNumber"] = "InvalidChannelNumber";
BlindConfigurationErrorCode["DeviceNotResponding"] = "DeviceNotResponding";
BlindConfigurationErrorCode["CalibrationCancelled"] = "CalibrationCancelled";
BlindConfigurationErrorCode["Timeout"] = "Timeout";
BlindConfigurationErrorCode["IncorrectResponse"] = "IncorrectResponse";
BlindConfigurationErrorCode["CannotCheckIfCalibrationsIsRunning"] = "CannotCheckIfCalibrationsIsRunning";
BlindConfigurationErrorCode["CalibrationsIsCurrentlyRunning"] = "CalibrationsIsCurrentlyRunning";
BlindConfigurationErrorCode["InputOutputNotFound"] = "InputOutputNotFound";
BlindConfigurationErrorCode["NoData"] = "NoData";
BlindConfigurationErrorCode["WrongStepOfOperation"] = "WrongStepOfOperation";
})(BlindConfigurationErrorCode || (BlindConfigurationErrorCode = {}));
//Auto calibration
class EnableAutoCalibraionRequest extends DataFrame {
constructor(guid) {
super();
this.Resource = "/extafree2/blind/calibration/auto";
this.Method = Method.Get;
this.Data = guid;
}
}
class StopAutoCalibraionRequest extends DataFrame {
constructor(guid) {
super();
this.Resource = "/extafree2/blind/calibration/stop";
this.Method = Method.Get;
this.Data = guid;
}
}
class IsCalibrationRunningRequest extends DataFrame {
constructor() {
super();
this.Resource = "/extafree2/blind/calibration/isrunning";
this.Method = Method.Get;
this.Data = null;
}
}
//ManualCalibration
class ManualCalibrationContext {
constructor() {
this.StepAFinished = false;
this.StepBFinished = false;
this.StepCFinished = false;
this.StepBAFinished = false;
this.StepCAFinished = false;
this.OpeningStartTime = 0;
this.OpeningEndTime = 0;
this.ClosingStartTime = 0;
this.ClosingEndTime = 0;
}
}
//Correction steps
class BlindCorrectionParameters {
constructor() {
this.Correction = 0;
this.Min = 0;
this.Max = 0;
this.Step = 0;
}
}
class CorrectionStepsFrame {
constructor() {
this.DeviceGuid = "";
this.Correction = 0;
}
}
class GetCorrectionStepsRequest extends DataFrame {
constructor(guid, stepType) {
super();
this.Resource = stepType == "LOWER" ? "/extalife/device/blind/correction/lower" : "/extalife/device/blind/correction/upper";
this.Method = Method.Get;
this.Data = guid;
}
}
class SetCorrectionStepsRequest extends DataFrame {
constructor(data, stepType) {
super();
this.Resource = stepType == "LOWER" ? "/extalife/device/blind/correction/lower" : "/extalife/device/blind/correction/upper";
this.Method = Method.Put;
this.Data = data;
}
}
//Comfort positions
class ComfortPositionParametersFrame extends ComfortPositionParameters {
constructor() {
super(...arguments);
this.DeviceGuid = "";
}
}
class GetComfortPositionsParamsRequest extends DataFrame {
constructor(data) {
super();
this.Resource = "/extalife/device/parameters/comfort/position";
this.Method = Method.Get;
this.Data = data;
}
}
class SetComfortPositionsParamsRequest extends DataFrame {
constructor(data) {
super();
this.Resource = "/extalife/device/parameters/comfort/position";
this.Method = Method.Put;
this.Data = data;
}
}
//Swap relays
class SwapRelaysRequest extends DataFrame {
constructor(guid) {
super();
this.Resource = "/extalife/device/blind/relays/swap";
this.Method = Method.Get;
this.Data = guid;
}
}
//Input output
class InputOutputBlindParametersRequest extends DataFrame {
constructor(data) {
super();
this.Resource = "/extalife/device/parameters/input/output";
this.Method = Method.Get;
this.Data = data;
}
}
class InputOutputBlindParametersFrame extends InputOutputBlindParameters {
constructor() {
super(...arguments);
this.DeviceGuid = "";
}
}
class SetInputOutputBlindParametersRequest extends DataFrame {
constructor(data) {
super();
this.Resource = "/extalife/device/parameters/input/output";
this.Method = Method.Put;
this.Data = data;
}
}
//TurnOn behaviour
class GetTurnOffBehaviourRequest extends DataFrame {
constructor(data) {
super();
this.Resource = "/extalife/device/parameters/state/turnon";
this.Method = Method.Get;
this.Data = data;
}
}
class SetTurnOffBehaviourRequest extends DataFrame {
constructor(data) {
super();
this.Resource = "/extalife/device/parameters/state/turnon";
this.Method = Method.Put;
this.Data = data;
}
}
class StateOfTurnOnDeviceParametersFrame extends StateOfTurnOnBlindDeviceParameters {
constructor() {
super(...arguments);
this.DeviceGuid = "";
}
}
//# sourceMappingURL=BlindConfigService.js.map