lavva.exalushome.extalife
Version:
Library implementing communication and abstraction layers for ExtaLife API in ExalusHome system
689 lines • 41.4 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 { DataFrame, Method, Status } from 'lavva.exalushome/build/js/DataFrame';
import { DeviceResponseType } from 'lavva.exalushome/build/js/Services/Devices/IDevice';
import { ExalusConnectionService } from "lavva.exalushome/build/js/Services/ExalusConnectionService";
import { ResponseResult } from 'lavva.exalushome/build/js/Services/FieldChangeResult';
import { LoggerService } from 'lavva.exalushome/build/js/Services/Logging/LoggerService';
import { FacadeActionEnum, GetDeviceState, SetFacadePosition } from "lavva.exalushome/build/js/Services/Devices/Tasks/Tasks";
import { DeviceTaskExecutionResult } from "lavva.exalushome/build/js/Services/Devices/TaskExecutionResult";
import { ControllerConfigurationService } from "lavva.exalushome/build/js/Services/Controller/ControllerConfigurationService";
import { GetChannelParamsRequest, GetParamsRequest } from '../Common/DataRequest';
import { CalibrationProgress, FacadeDetection } from './ZfBidiConfigParams';
import { AppStateService } from "lavva.exalushome/build/js/Services/AppStateService";
export class ZfBidiConfigService {
constructor() {
this._connection = null;
this._lamelaCalibrationContext = new LamelaCalibrationContext();
this._connection = Api.Get(ExalusConnectionService.ServiceName);
this._controllerConfigurationService = Api.Get(ControllerConfigurationService.ServiceName);
this._logger = Api.Get(LoggerService.ServiceName);
}
GetServiceName() {
return ZfBidiConfigService.ServiceName;
}
RunAutomaticLamelaPositionCalibrationAsync(device, channel) {
return __awaiter(this, void 0, void 0, function* () {
var _a, _b, _c;
const appStateService = Api.Get(AppStateService.ServiceName);
try {
if (!device.Channels.any(ch => ch.Number === channel)) {
return new ResponseResult(FacadeConfigurationErrorCode.InvalidChannelNumber, `Cannot calibrate facade blind - invalid channel number: ${channel}`);
}
const currentCalibrationStatus = yield this.GetCalibrationStatusAsync(device, channel);
if (currentCalibrationStatus.Type != null)
return new ResponseResult(FacadeConfigurationErrorCode.OtherError, `Cannot calibrate facade blind - unable to get current calibration status.`);
else if (currentCalibrationStatus.CalibrationProgress != CalibrationProgress.Disabled)
return new ResponseResult(FacadeConfigurationErrorCode.CalibrationsIsCurrentlyRunning, `Cannot calibrate facade blind - calibration of device is currently running.`);
const task = new SetFacadePosition();
task.Position = FacadeActionEnum.Stop;
switch (yield device.Channels.first(ch => ch.Number == channel).ExecuteTaskAsync(task)) {
case DeviceTaskExecutionResult.Executed:
break;
default:
return new ResponseResult(FacadeConfigurationErrorCode.DeviceNotResponding, `Cannot calibrate facade blind - device is not responding.`);
}
yield ((_a = this._controllerConfigurationService) === null || _a === void 0 ? void 0 : _a.EnterConfigurationModeAsync());
const calibrationReq = yield ((_b = this._connection) === null || _b === void 0 ? void 0 : _b.SendAndWaitForResponseAsync(new EnableAutoCalibraionRequest(new GetChannelParamsRequest(device.Guid, channel)), 8000, false));
if (calibrationReq == null || calibrationReq.Status == null)
return new ResponseResult(FacadeConfigurationErrorCode.OtherError, `Cannot calibrate facade blind - calibration request failed for an unknown reason.`);
if (calibrationReq.Status !== Status.OK)
return new ResponseResult(FacadeConfigurationErrorCode.OtherError, `Cannot calibrate facade blind - calibration request failed - request status code: ${calibrationReq.Status}`);
appStateService.DisallowHibernation();
const currentCalibrationTask = new Promise((resolve, reject) => {
let failedCount = 0;
const calibrationStatusCheck = setInterval(() => __awaiter(this, void 0, void 0, function* () {
var currentStatus = yield this.GetCalibrationStatusAsync(device, channel);
if (currentStatus.Type != null) {
failedCount++;
if (failedCount > 6) {
clearInterval(calibrationStatusCheck);
resolve(FacadeConfigurationErrorCode.DeviceNotResponding);
}
}
else {
switch (currentStatus.CalibrationProgress) {
case CalibrationProgress.MovementTimeCalibration:
this._logger.Debug(`Facade blind calibration in progress...`);
failedCount = 0;
break;
case CalibrationProgress.LamellaTiltCalibration:
resolve(FacadeConfigurationErrorCode.CalibrationsIsCurrentlyRunning);
break;
default:
this._logger.Debug(`Facade blind calibration finished!`);
clearInterval(calibrationStatusCheck);
resolve(currentStatus);
break;
}
}
}), 2000);
});
const result = yield currentCalibrationTask;
yield this.StopCalibrationAsync(device, channel);
appStateService.AllowHibernation();
if (result.CalibrationProgress == null) {
switch (result) {
case FacadeConfigurationErrorCode.DeviceNotResponding:
return new ResponseResult(FacadeConfigurationErrorCode.DeviceNotResponding, `Facade calibration canceled - device not responding!`);
case FacadeConfigurationErrorCode.CalibrationsIsCurrentlyRunning:
return new ResponseResult(FacadeConfigurationErrorCode.CalibrationsIsCurrentlyRunning, `Cannot calibrate facade blind - calibration of device is currently running.`);
}
}
return result;
}
catch (error) {
this._logger.Error(ZfBidiConfigService.ServiceName, `EXIT CONFIGURATION MODE WILL BE FIRED! RunAutomaticLamelaPositionCalibrationAsync()`);
(_c = this._controllerConfigurationService) === null || _c === void 0 ? void 0 : _c.ExitConfigurationModeAsync();
appStateService.AllowHibernation();
this._logger.Error(ZfBidiConfigService.ServiceName, `Cannot calibrate facade blind. ${error}`);
return new ResponseResult(FacadeConfigurationErrorCode.OtherError, `Cannot calibrate facade blind - unknown error.`);
}
});
}
StopCalibrationAsync(device, channel) {
return __awaiter(this, void 0, void 0, function* () {
var _a, _b;
try {
if (!device.Channels.any(ch => ch.Number === channel))
return Status.WrongData;
const result = yield ((_a = this._connection) === null || _a === void 0 ? void 0 : _a.SendAndWaitForResponseAsync(new StopCalibrationRequest(new GetChannelParamsRequest(device.Guid, channel)), 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}`);
this._logger.Error(ZfBidiConfigService.ServiceName, `EXIT CONFIGURATION MODE WILL BE FIRED! StopCalibrationAsync()`);
(_b = this._controllerConfigurationService) === null || _b === void 0 ? void 0 : _b.ExitConfigurationModeAsync();
return result.Status;
}
catch (error) {
this._logger.Error(ZfBidiConfigService.ServiceName, `Cannot stop facade blind calibration. ${error}`);
return Status.FatalError;
}
});
}
LamelaTiltCalibration(device, channel) {
try {
if (!device.Channels.any(ch => ch.Number === channel))
return new ResponseResult(FacadeConfigurationErrorCode.InvalidChannelNumber, `Cannot get lamela tilt calibration functions - invalid channel number, channel: ${channel}`);
const calibrationFunctions = {
InitCalibrationAsync: () => __awaiter(this, void 0, void 0, function* () {
var _a, _b;
const maxSetPositionWaitTime = 120000;
const devChannel = device.Channels.first(ch => ch.Number == channel);
const currentCalibrationStatus = yield this.GetCalibrationStatusAsync(device, channel);
this._lamelaCalibrationContext = new LamelaCalibrationContext();
if (currentCalibrationStatus.Type != null)
return new ResponseResult(FacadeConfigurationErrorCode.OtherError, `Cannot calibrate facade blind - unable to get current calibration status.`);
else if (currentCalibrationStatus.CalibrationProgress != CalibrationProgress.Disabled)
return new ResponseResult(FacadeConfigurationErrorCode.CalibrationsIsCurrentlyRunning, `Cannot calibrate facade blind - calibration of device is currently running.`);
else if (currentCalibrationStatus.TravelTimeCalibration = false)
return new ResponseResult(FacadeConfigurationErrorCode.TravelTimeCalibrationNotValid, `Cannot calibrate facade blind - please preform travel time calibration first by running automatic position calibration.`);
const facadeStop = new SetFacadePosition();
facadeStop.FacadeAction = FacadeActionEnum.Stop;
if ((yield devChannel.ExecuteTaskAsync(facadeStop)) != DeviceTaskExecutionResult.Executed)
return new ResponseResult(FacadeConfigurationErrorCode.OtherError, `Cannot calibrate facade blind - unable to stop blind.`);
const facadePosition = new SetFacadePosition();
facadePosition.FacadeAction = FacadeActionEnum.TiltAndPercentage;
facadePosition.Position = 80;
facadePosition.Tilt = 100;
if ((yield devChannel.ExecuteTaskAsync(facadePosition)) != DeviceTaskExecutionResult.Executed)
return new ResponseResult(FacadeConfigurationErrorCode.OtherError, `Cannot calibrate facade blind - unable to set correct position.`);
const setPositionTask = new Promise((resolve, reject) => {
const timeout = Date.now() + maxSetPositionWaitTime;
const statusInterval = setInterval(() => {
this._logger.Debug(ZfBidiConfigService.ServiceName, `Lamela tilt calibration initialization - seting blind to calibration position...`);
if (Date.now() > timeout) {
device.OnDeviceStateRefreshedOrChangedEvent().Unsubscribe(PositionStateChangeHandler);
clearInterval(statusInterval);
reject(new ResponseResult(FacadeConfigurationErrorCode.DeviceNotResponding, `Cannot calibrate facade blind - unable to get correct blind position for calibration.`));
}
else
devChannel.ExecuteTaskAsync(new GetDeviceState());
}, 2000);
const PositionStateChangeHandler = (stateChange) => {
if (stateChange.TypeAsEnum == DeviceResponseType.FacadePosition) {
if (stateChange.Data.Position == 80) {
this._logger.Debug(ZfBidiConfigService.ServiceName, `Lamela tilt calibration initialization - correct position was set, position: 80%`);
device.OnDeviceStateRefreshedOrChangedEvent().Unsubscribe(PositionStateChangeHandler);
clearInterval(statusInterval);
resolve(stateChange.Data);
}
else if (stateChange.Data.Position == 255) {
device.OnDeviceStateRefreshedOrChangedEvent().Unsubscribe(PositionStateChangeHandler);
clearInterval(statusInterval);
reject(new ResponseResult(FacadeConfigurationErrorCode.TravelTimeCalibrationNotValid, `Cannot calibrate facade blind - please preform travel time calibration first by running automatic position calibration.`));
}
}
};
device.OnDeviceStateRefreshedOrChangedEvent().Subscribe(PositionStateChangeHandler);
});
try {
yield setPositionTask;
}
catch (error) {
return error;
}
yield ((_a = this._controllerConfigurationService) === null || _a === void 0 ? void 0 : _a.EnterConfigurationModeAsync());
const startCalibrationResult = yield ((_b = this._connection) === null || _b === void 0 ? void 0 : _b.SendAndWaitForResponseAsync(new StartTiltCalibrationRequest(new GetChannelParamsRequest(device.Guid, channel)), 8000, false));
if (startCalibrationResult == null || startCalibrationResult.Status == null)
return new ResponseResult(FacadeConfigurationErrorCode.OtherError, `Cannot calibrate facade blind - unable to start calibration.`);
if (startCalibrationResult.Status !== Status.OK)
return new ResponseResult(FacadeConfigurationErrorCode.OtherError, `Cannot calibrate facade blind - unable to start calibration - response status: ${startCalibrationResult.Status}`);
this._lamelaCalibrationContext.CalibrationInitialized = true;
return Status.OK;
}),
LamelaManualCalibration: {
MoveOneStepDownAsync: () => __awaiter(this, void 0, void 0, function* () {
var _a;
const result = yield ((_a = this._connection) === null || _a === void 0 ? void 0 : _a.SendAndWaitForResponseAsync(new OneStepDownRequest(new GetChannelParamsRequest(device.Guid, channel)), 8000, false));
if (result == null || result.Status == null)
return Status.FatalError;
return result.Status;
}),
MoveOneStepUpAsync: () => __awaiter(this, void 0, void 0, function* () {
var _a;
const result = yield ((_a = this._connection) === null || _a === void 0 ? void 0 : _a.SendAndWaitForResponseAsync(new OneStepUpRequest(new GetChannelParamsRequest(device.Guid, channel)), 8000, false));
if (result == null || result.Status == null)
return Status.FatalError;
return result.Status;
})
},
ConfirmFirstPositionAsync: () => __awaiter(this, void 0, void 0, function* () {
var _a;
try {
if (!this._lamelaCalibrationContext.CalibrationInitialized)
return Status.OperationNotPermitted;
const result = yield ((_a = this._connection) === null || _a === void 0 ? void 0 : _a.SendAndWaitForResponseAsync(new ConfirmFirstTiltPositionRequest(new GetChannelParamsRequest(device.Guid, channel)), 8000, false));
if (result == null || result.Status == null)
return Status.FatalError;
if (result.Status == Status.OK)
this._lamelaCalibrationContext.FirstPositionConfirmed = true;
return result.Status;
}
catch (error) {
this._logger.Error(ZfBidiConfigService.ServiceName, `Cannot confirm first tilt lamela position. ${error}`);
return Status.FatalError;
}
}),
ConfirmSecondPositionAsync: () => __awaiter(this, void 0, void 0, function* () {
var _a;
try {
if (!this._lamelaCalibrationContext.CalibrationInitialized || !this._lamelaCalibrationContext.FirstPositionConfirmed)
return Status.OperationNotPermitted;
const result = yield ((_a = this._connection) === null || _a === void 0 ? void 0 : _a.SendAndWaitForResponseAsync(new ConfirmSecondTiltPositionRequest(new GetChannelParamsRequest(device.Guid, channel)), 8000, false));
if (result == null || result.Status == null)
return Status.FatalError;
if (result.Status == Status.OK)
this._lamelaCalibrationContext.FirstPositionConfirmed = true;
return result.Status;
}
catch (error) {
this._logger.Error(ZfBidiConfigService.ServiceName, `Cannot confirm second tilt lamela position. ${error}`);
return Status.FatalError;
}
}),
EndCalibrationAsync: () => __awaiter(this, void 0, void 0, function* () {
var _a;
try {
this._lamelaCalibrationContext = new LamelaCalibrationContext();
const stopCalibrationResult = yield this.StopCalibrationAsync(device, channel);
if (stopCalibrationResult != Status.OK)
return Status.Error;
const facadeUp = new SetFacadePosition();
facadeUp.FacadeAction = FacadeActionEnum.Open;
device.ExecuteDeviceTaskAsync(facadeUp);
(_a = this._connection) === null || _a === void 0 ? void 0 : _a.SendAndWaitForResponseAsync(new GetCalibrationConfigurationRequest(new GetChannelParamsRequest(device.Guid, channel)), 8000, false);
return Status.OK;
}
catch (error) {
this._logger.Error(ZfBidiConfigService.ServiceName, `Cannot finish lamela tilt calibration. ${error}`);
return Status.FatalError;
}
})
};
return calibrationFunctions;
}
catch (error) {
return new ResponseResult(FacadeConfigurationErrorCode.OtherError, `Cannot get lamela tilt calibration functions - unknown error.`);
}
}
GetCalibrationStatusAsync(device, channel) {
return __awaiter(this, void 0, void 0, function* () {
var _a;
try {
if (!device.Channels.any(ch => ch.Number === channel))
return new ResponseResult(FacadeConfigurationErrorCode.InvalidChannelNumber, `Cannot get facade calibration status - invalid channel number: ${channel}`);
const result = yield ((_a = this._connection) === null || _a === void 0 ? void 0 : _a.SendAndWaitForResponseAsync(new GetCalibrationStatusRequest(new GetChannelParamsRequest(device.Guid, channel)), 8000, false));
if (result == null || result.Status == null)
return new ResponseResult(FacadeConfigurationErrorCode.OtherError, `Cannot get facade calibration status - unknown error.`);
if (result.Status !== Status.OK)
return new ResponseResult(FacadeConfigurationErrorCode.OtherError, `Cannot get facade calibration status - controller responded with error code: ${result.Status}.`);
if (result.Data == null)
return new ResponseResult(FacadeConfigurationErrorCode.NoData, `Cannot get facade calibration status - no data in response.`);
return result.Data;
}
catch (error) {
this._logger.Error(ZfBidiConfigService.ServiceName, `Cannot get facade calibration status. ${error}`);
return new ResponseResult(FacadeConfigurationErrorCode.OtherError, `Cannot get facade calibration status - unknown error.`);
}
});
}
ChangeMovementDirectionAsync(device, channel) {
return __awaiter(this, void 0, void 0, function* () {
var _a;
try {
if (!device.Channels.any(ch => ch.Number === channel))
return Status.WrongData;
const result = yield ((_a = this._connection) === null || _a === void 0 ? void 0 : _a.SendAndWaitForResponseAsync(new ChangeMovementDirectionRequest(new GetChannelParamsRequest(device.Guid, channel)), 8000, false));
if (result == null || result.Status == null) {
this._logger.Error(`Failed to change movement direction - unknow error.`);
return Status.FatalError;
}
if (result.Status !== Status.OK)
this._logger.Error(`Failed to change movement direction - response status: ${result.Status}`);
return result.Status;
}
catch (error) {
this._logger.Error(ZfBidiConfigService.ServiceName, `Cannot change movement direction. ${error}`);
return Status.FatalError;
}
});
}
IsWindSensorsPairedAsync(device, channel) {
return __awaiter(this, void 0, void 0, function* () {
var _a;
try {
const result = yield ((_a = this._connection) === null || _a === void 0 ? void 0 : _a.SendAndWaitForResponseAsync(new IsAnyWindSensorsPairedRequest(device.Guid), 8000, false));
if (result == null || result.Status == null)
return new ResponseResult(FacadeConfigurationErrorCode.OtherError, `Cannot check if any wind sensor is paired - unknown error.`);
if (result.Status !== Status.OK || result.Data == null)
return false;
return result.Data.IsPaired;
}
catch (error) {
this._logger.Error(ZfBidiConfigService.ServiceName, `Cannot check if any wind sensor is paired. ${error}`);
return new ResponseResult(FacadeConfigurationErrorCode.OtherError, `Cannot check if any wind sensor is paired - unknown error.`);
}
});
}
GetWindSensorActiveAsync(device, channel) {
return __awaiter(this, void 0, void 0, function* () {
var _a;
try {
if (!(yield this.IsWindSensorsPairedAsync(device, channel)))
return new ResponseResult(FacadeConfigurationErrorCode.WindSensorNotPaired, `Cannot get wind sensor lock time - wind sensor not paired.`);
const result = yield ((_a = this._connection) === null || _a === void 0 ? void 0 : _a.SendAndWaitForResponseAsync(new GetDetectionWindSensorActiveRequest(device.Guid), 8000, false));
if (result == null || result.Status == null)
return new ResponseResult(FacadeConfigurationErrorCode.OtherError, `Cannot check if 'wind detection lock' functionality is active - unknown error.`);
if (result.Status !== Status.OK)
return new ResponseResult(FacadeConfigurationErrorCode.OtherError, `Cannot check if 'wind detection lock' functionality is active - response status: ${result.Status}.`);
if (result.Data == null)
return new ResponseResult(FacadeConfigurationErrorCode.NoData, `Cannot check if 'wind detection lock' - no data in response.`);
return result.Data;
}
catch (error) {
this._logger.Error(ZfBidiConfigService.ServiceName, `Cannot check if 'wind detection lock' functionality is active. ${error}`);
return new ResponseResult(FacadeConfigurationErrorCode.OtherError, `Cannot check if 'wind detection lock' functionality is active - unknown error.`);
}
});
}
SetWindSensorActiveAsync(device, channel, windDetectionLockActive) {
return __awaiter(this, void 0, void 0, function* () {
var _a;
if (!(yield this.IsWindSensorsPairedAsync(device, channel)))
return Status.ResourceIsNotAvailable;
const result = yield ((_a = this._connection) === null || _a === void 0 ? void 0 : _a.SendAndWaitForResponseAsync(new SetDetectionWindSensorActiveRequest(device.Guid, windDetectionLockActive), 8000, false));
if (result == null || result.Status == null) {
this._logger.Error(ZfBidiConfigService.ServiceName, `Failed to change device parameters - unknow error.`);
return Status.FatalError;
}
if (result.Status !== Status.OK)
this._logger.Error(ZfBidiConfigService.ServiceName, `Failed to change device parameters, response status: ${result.Status}`);
return result.Status;
});
}
GetWindSensorLockTimeAsync(device, channel) {
return __awaiter(this, void 0, void 0, function* () {
var _a;
try {
if (!(yield this.IsWindSensorsPairedAsync(device, channel)))
return new ResponseResult(FacadeConfigurationErrorCode.WindSensorNotPaired, `Cannot get wind sensor lock time - wind sensor not paired.`);
const result = yield ((_a = this._connection) === null || _a === void 0 ? void 0 : _a.SendAndWaitForResponseAsync(new GetDetectionWindSensorLockTimeRequest(device.Guid), 8000, false));
if (result == null || result.Status == null)
return new ResponseResult(FacadeConfigurationErrorCode.OtherError, `Cannot get wind sensor lock time - unknown error.`);
if (result.Status !== Status.OK)
return new ResponseResult(FacadeConfigurationErrorCode.OtherError, `Cannot get wind sensor lock time - response status: ${result.Status}.`);
if (result.Data == null)
return new ResponseResult(FacadeConfigurationErrorCode.NoData, `Cannot get wind sensor lock time - no data in response.`);
return result.Data;
}
catch (error) {
this._logger.Error(ZfBidiConfigService.ServiceName, `Cannot get wind sensor lock time. ${error}`);
return new ResponseResult(FacadeConfigurationErrorCode.OtherError, `Cannot get wind sensor lock time - unknown error.`);
}
});
}
SetWindSensorLockTimeAsync(device, channel, lockTime) {
return __awaiter(this, void 0, void 0, function* () {
var _a;
try {
if (!(yield this.IsWindSensorsPairedAsync(device, channel)))
return Status.ResourceIsNotAvailable;
const result = yield ((_a = this._connection) === null || _a === void 0 ? void 0 : _a.SendAndWaitForResponseAsync(new SetDetectionWindSensorLockTimeRequest(new FacadeLockTimeFrame(device.Guid, lockTime)), 8000, false));
if (result == null || result.Status == null) {
this._logger.Error(ZfBidiConfigService.ServiceName, `Failed to set wind sensor lock time - unknow error.`);
return Status.FatalError;
}
if (result.Status !== Status.OK)
this._logger.Error(ZfBidiConfigService.ServiceName, `Failed to set wind sensor lock time, response status: ${result.Status}`);
return result.Status;
}
catch (error) {
this._logger.Error(ZfBidiConfigService.ServiceName, `Cannot set wind sensor lock time. ${error}`);
return Status.FatalError;
}
});
}
IsBlindLockedByWindSensorAsync(device, channel) {
return __awaiter(this, void 0, void 0, function* () {
var _a;
try {
if (!(yield this.IsWindSensorsPairedAsync(device, channel)))
return new ResponseResult(FacadeConfigurationErrorCode.WindSensorNotPaired, `Cannot check if blind is blocked - wind sensor not paired.`);
const result = yield ((_a = this._connection) === null || _a === void 0 ? void 0 : _a.SendAndWaitForResponseAsync(new IsBlockedByWindSensorRequest(device.Guid), 8000, false));
if (result == null || result.Status == null)
return new ResponseResult(FacadeConfigurationErrorCode.OtherError, `Cannot check if blind is blocked - unknown error.`);
if (result.Status !== Status.OK)
return new ResponseResult(FacadeConfigurationErrorCode.OtherError, `Cannot check if blind is blocked - response status: ${result.Status}.`);
if (result.Data == null)
return new ResponseResult(FacadeConfigurationErrorCode.NoData, `Cannot check if blind is blocked - no data in response.`);
return result.Data;
}
catch (error) {
this._logger.Error(ZfBidiConfigService.ServiceName, `Cannot check if blind is blocked. ${error}`);
return new ResponseResult(FacadeConfigurationErrorCode.OtherError, `Cannot check if blind is blocked - unknown error.`);
}
});
}
ClearBlindLockByWindSensorAsync(device, channel) {
return __awaiter(this, void 0, void 0, function* () {
var _a;
try {
if (!(yield this.IsWindSensorsPairedAsync(device, channel)))
Status.ResourceIsNotAvailable;
const result = yield ((_a = this._connection) === null || _a === void 0 ? void 0 : _a.SendAndWaitForResponseAsync(new ClearBlindLockByWindSensorRequest(device.Guid), 8000, false));
if (result == null || result.Status == null) {
this._logger.Error(ZfBidiConfigService.ServiceName, `Failed to change device parameters - unknow error.`);
return Status.FatalError;
}
if (result.Status !== Status.OK)
this._logger.Error(ZfBidiConfigService.ServiceName, `Failed to change device parameters, response status: ${result.Status}`);
return result.Status;
}
catch (error) {
this._logger.Error(ZfBidiConfigService.ServiceName, `Cannot clear wind blockade state. ${error}`);
return Status.FatalError;
}
});
}
GetFacadeTypeDetectionAsync(device, channel) {
return __awaiter(this, void 0, void 0, function* () {
var _a;
try {
const result = yield ((_a = this._connection) === null || _a === void 0 ? void 0 : _a.SendAndWaitForResponseAsync(new GetFacadeTypeDetectionRequest(new GetParamsRequest(device.Guid)), 8000, false));
if (result == null || result.Status == null)
return new ResponseResult(FacadeConfigurationErrorCode.OtherError, `Cannot get facade detection settings - unknown error.`);
if (result.Status !== Status.OK)
return new ResponseResult(FacadeConfigurationErrorCode.OtherError, `Cannot get facade detection settings - controller responded with error code: ${result.Status}.`);
if (result.Data == null)
return new ResponseResult(FacadeConfigurationErrorCode.NoData, `Cannot get facade detection settings - no data in response.`);
return result.Data.FacadeDetection;
}
catch (error) {
this._logger.Error(ZfBidiConfigService.ServiceName, `Cannot get facade detection settings. ${error}`);
return new ResponseResult(FacadeConfigurationErrorCode.OtherError, `Cannot get facade detection settings - unknown error.`);
}
});
}
SetFacadeTypeDetectionAsync(device, channel, detectionType) {
return __awaiter(this, void 0, void 0, function* () {
var _a;
try {
const result = yield ((_a = this._connection) === null || _a === void 0 ? void 0 : _a.SendAndWaitForResponseAsync(new SetFacadeTypeDetectionRequest(new FacadeTypeDetectionFrame(device.Guid, detectionType)), 8000, false));
if (result == null || result.Status == null) {
this._logger.Error(ZfBidiConfigService.ServiceName, `Failed to facade detection settings - unknow error.`);
return Status.FatalError;
}
if (result.Status !== Status.OK)
this._logger.Error(ZfBidiConfigService.ServiceName, `Failed to facade detection settings, response status: ${result.Status}`);
return result.Status;
}
catch (error) {
this._logger.Error(ZfBidiConfigService.ServiceName, `Cannot facade detection settings. ${error}`);
return Status.FatalError;
}
});
}
}
ZfBidiConfigService.ServiceName = "ZfBidiConfigService";
export var FacadeConfigurationErrorCode;
(function (FacadeConfigurationErrorCode) {
FacadeConfigurationErrorCode["InvalidChannelNumber"] = "InvalidChannelNumber";
FacadeConfigurationErrorCode["OtherError"] = "OtherError";
FacadeConfigurationErrorCode["CalibrationsIsCurrentlyRunning"] = "CalibrationsIsCurrentlyRunning";
FacadeConfigurationErrorCode["DeviceNotResponding"] = "DeviceNotResponding";
FacadeConfigurationErrorCode["WindSensorNotPaired"] = "WindSensorNotPaired";
FacadeConfigurationErrorCode["TravelTimeCalibrationNotValid"] = "TravelTimeCalibrationNotValid";
FacadeConfigurationErrorCode["NoData"] = "NoData";
})(FacadeConfigurationErrorCode || (FacadeConfigurationErrorCode = {}));
//change direction
class ChangeMovementDirectionRequest extends DataFrame {
constructor(data) {
super();
this.Resource = "/extalife/device/facade/direction/reverse";
this.Method = Method.Post;
this.Data = data;
}
}
//calibration
class GetCalibrationStatusRequest extends DataFrame {
constructor(data) {
super();
this.Resource = "/extalife/device/facade/calibration/status";
this.Method = Method.Get;
this.Data = data;
}
}
class EnableAutoCalibraionRequest extends DataFrame {
constructor(data) {
super();
this.Resource = "/extalife/device/facade/calibration/start";
this.Method = Method.Post;
this.Data = data;
}
}
class StopCalibrationRequest extends DataFrame {
constructor(data) {
super();
this.Resource = "/extalife/device/facade/calibration/stop";
this.Method = Method.Post;
this.Data = data;
}
}
class StartTiltCalibrationRequest extends DataFrame {
constructor(data) {
super();
this.Resource = "/extalife/device/facade/lamella/tilt/calibration/start";
this.Method = Method.Post;
this.Data = data;
}
}
class OneStepUpRequest extends DataFrame {
constructor(data) {
super();
this.Resource = "/extalife/device/facade/calibration/step/up";
this.Method = Method.Post;
this.Data = data;
}
}
class OneStepDownRequest extends DataFrame {
constructor(data) {
super();
this.Resource = "/extalife/device/facade/calibration/step/down";
this.Method = Method.Post;
this.Data = data;
}
}
class ConfirmFirstTiltPositionRequest extends DataFrame {
constructor(data) {
super();
this.Resource = "/extalife/device/facade/calibration/lamella/position/first/confirm";
this.Method = Method.Post;
this.Data = data;
}
}
class ConfirmSecondTiltPositionRequest extends DataFrame {
constructor(data) {
super();
this.Resource = "/extalife/device/facade/calibration/lamella/position/second/confirm";
this.Method = Method.Post;
this.Data = data;
}
}
class GetCalibrationConfigurationRequest extends DataFrame {
constructor(data) {
super();
this.Resource = "/extalife/device/facade/calibration/configuration";
this.Method = Method.Get;
this.Data = data;
}
}
class LamelaCalibrationContext {
constructor() {
this.CalibrationInitialized = false;
this.FirstPositionConfirmed = false;
this.SeconfPositionConfirmed = false;
}
}
//WindSensor
class IsAnyWindSensorsPairedRequest extends DataFrame {
constructor(guid) {
super();
this.Resource = "/extalife/device/parameters/facade/sensor/paired";
this.Method = Method.Get;
this.Data = guid;
}
}
class GetDetectionWindSensorActiveRequest extends DataFrame {
constructor(guid) {
super();
this.Resource = "/extalife/device/parameters/wind/sensor/status";
this.Method = Method.Get;
this.Data = guid;
}
}
class SetDetectionWindSensorActiveRequest extends DataFrame {
constructor(guid, activate) {
super();
this.Resource = activate ? "/extalife/device/parameters/wind/activate/" : "/extalife/device/parameters/wind/deactivate/";
this.Method = Method.Post;
this.Data = guid;
}
}
class GetDetectionWindSensorLockTimeRequest extends DataFrame {
constructor(guid) {
super();
this.Resource = "/extalife/device/parameters/wind/blockade/time";
this.Method = Method.Get;
this.Data = guid;
}
}
class FacadeLockTimeFrame {
constructor(guid, minutes) {
this.DeviceGuid = "";
this.Minutes = 0;
this.DeviceGuid = guid;
this.Minutes = minutes;
}
}
class SetDetectionWindSensorLockTimeRequest extends DataFrame {
constructor(data) {
super();
this.Resource = "/extalife/device/parameters/wind/blockade/time";
this.Method = Method.Put;
this.Data = data;
}
}
class IsBlockedByWindSensorRequest extends DataFrame {
constructor(guid) {
super();
this.Resource = "/extalife/device/parameters/wind/blockade/";
this.Method = Method.Get;
this.Data = guid;
}
}
class ClearBlindLockByWindSensorRequest extends DataFrame {
constructor(guid) {
super();
this.Resource = "/extalife/device/parameters/wind/blockade/";
this.Method = Method.Delete;
this.Data = guid;
}
}
//Facade type detection
class FacadeTypeDetectionFrame {
constructor(guid, detection) {
this.DeviceGuid = "";
this.FacadeDetection = FacadeDetection.Automatic;
this.DeviceGuid = guid;
this.FacadeDetection = detection;
}
}
class GetFacadeTypeDetectionRequest extends DataFrame {
constructor(data) {
super();
this.Resource = "/extalife/device/facade/type/detection";
this.Method = Method.Get;
this.Data = data;
}
}
class SetFacadeTypeDetectionRequest extends DataFrame {
constructor(data) {
super();
this.Resource = "/extalife/device/facade/type/detection";
this.Method = Method.Put;
this.Data = data;
}
}
//# sourceMappingURL=ZfBidiConfigService.js.map