lavva.exalushome.extalife
Version:
Library implementing communication and abstraction layers for ExtaLife API in ExalusHome system
185 lines • 9.81 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 { BlindConfigService, BlindConfigurationErrorCode } from "../../../Common/BlindConfigurations/BlindConfigService";
import { BlindCalibrationState, BlindCalibrationStatusEnum, StateReliability } from "lavva.exalushome/build/js/Services/Devices/IDeviceState";
import { ResponseResult } from "lavva.exalushome/build/js/Services/FieldChangeResult";
import { DataFrame, Method, Status } from "lavva.exalushome/build/js/DataFrame";
import { BlindActionEnum, SetBlindPosition } from "lavva.exalushome/build/js/Services/Devices/Tasks/Tasks";
import { DeviceTaskExecutionResult } from "lavva.exalushome/build/js/Services/Devices/TaskExecutionResult";
export class Ssr_4_0_0_0 extends BlindConfigService {
constructor() {
super();
}
RunAutomaticCalibrationAsync(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 calibrate blind - invalid channel number: ${channel}`);
}
const task = new SetBlindPosition();
task.Action = BlindActionEnum.Stop;
switch (yield device.Channels.first(ch => ch.Number == channel).ExecuteTaskAsync(task)) {
case DeviceTaskExecutionResult.Executed:
break;
default:
return new ResponseResult(BlindConfigurationErrorCode.DeviceNotResponding, `Cannot calibrate blind - device is not responding.`);
}
const calibrationReq = yield ((_a = this._connection) === null || _a === void 0 ? void 0 : _a.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.`);
switch (calibrationReq.Status) {
case Status.OK:
{
var r = new BlindCalibrationState();
r.CalibrationStatus = BlindCalibrationStatusEnum.AutoLernInProgress;
r.Channel = channel;
r.StateReliability = StateReliability.Confident;
return r;
}
case Status.Error:
return new ResponseResult(BlindConfigurationErrorCode.CalibrationsIsCurrentlyRunning, `Cannot calibrate blind - calibration is currently running.`);
default:
return new ResponseResult(BlindConfigurationErrorCode.OtherError, `Cannot calibrate blind - calibration request failed - request status code: ${calibrationReq.Status}`);
}
}
catch (error) {
return new ResponseResult(BlindConfigurationErrorCode.OtherError, `Cannot calibrate blind - fatal error: ${error}`);
}
});
}
GetHeadSensorStatusAsync(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 head sensor status - invalid channel number: ${channel}`);
const result = yield ((_a = this._connection) === null || _a === void 0 ? void 0 : _a.SendAndWaitForResponseAsync(new GetHeadSensorStatusRequest(device.Guid, channel), 8000, false));
if (result == null || result.Status == null)
return new ResponseResult(BlindConfigurationErrorCode.OtherError, `Cannot get head sensor status - request failed for an unknown reason.`);
if (result.Status != Status.OK)
return new ResponseResult(BlindConfigurationErrorCode.OtherError, `Cannot get head sensor status - request failed - request status code: ${result.Status}`);
if (result.Data == null)
return new ResponseResult(BlindConfigurationErrorCode.NoData, `Cannot get head sensor status - request failed - no data received.`);
return result.Data;
}
catch (error) {
return new ResponseResult(BlindConfigurationErrorCode.OtherError, `Cannot get head sensor status - fatal error: ${error}`);
}
});
}
SwitchHeadSensorStatusAsync(enabled, 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 SwitchHeadSensorStatusRequest(device.Guid, channel, enabled), 8000, false));
if (result == null || result.Status == null)
return Status.FatalError;
return result.Status;
}
catch (error) {
return Status.FatalError;
}
});
}
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(device.Guid, channel), 8000, false));
if (result == null || result.Status == null)
return Status.FatalError;
return result.Status;
}
catch (error) {
return Status.FatalError;
}
});
}
GetWorkLogAsync(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 head sensor status - invalid channel number: ${channel}`);
const result = yield ((_a = this._connection) === null || _a === void 0 ? void 0 : _a.SendAndWaitForResponseAsync(new GetBlindWorkStats(device.Guid, channel), 8000, false));
if (result == null || result.Status == null)
return new ResponseResult(BlindConfigurationErrorCode.OtherError, `Cannot get work log - request failed for an unknown reason.`);
if (result.Status != Status.OK)
return new ResponseResult(BlindConfigurationErrorCode.OtherError, `Cannot get work log - request failed - request status code: ${result.Status}`);
if (result.Data == null)
return new ResponseResult(BlindConfigurationErrorCode.NoData, `Cannot get work log - request failed - no data received.`);
return result.Data;
}
catch (error) {
return new ResponseResult(BlindConfigurationErrorCode.OtherError, `Cannot get work log - fatal error: ${error}`);
}
});
}
}
//Auto calibration
class EnableAutoCalibraionRequest extends DataFrame {
constructor(guid) {
super();
this.Resource = "/extafree2/blind/calibration/auto";
this.Method = Method.Get;
this.Data = guid;
}
}
class GetHeadSensorStatusRequest extends DataFrame {
constructor(guid, channel) {
super();
this.Resource = "/extalife/device/blind/head/sensor/status";
this.Method = Method.Get;
this.Data = {
DeviceGuid: guid,
Channel: channel
};
}
}
class SwitchHeadSensorStatusRequest extends DataFrame {
constructor(guid, channel, enabled) {
super();
this.Resource = "/extalife/device/blind/head/sensor/switch";
this.Method = Method.Put;
this.Data = {
DeviceGuid: guid,
Channel: channel,
Enable: enabled
};
}
}
class ChangeMovementDirectionRequest extends DataFrame {
constructor(guid, channel) {
super();
this.Resource = "/extalife/device/blind/direction/reverse";
this.Method = Method.Post;
this.Data = {
DeviceGuid: guid,
Channel: channel
};
}
}
class GetBlindWorkStats extends DataFrame {
constructor(guid, channel) {
super();
this.Resource = "/extalife/device/blind/work/log";
this.Method = Method.Get;
this.Data = {
DeviceGuid: guid,
Channel: channel
};
}
}
//# sourceMappingURL=SsrVersionedService.js.map