lavva.exalushome.extalife
Version:
Library implementing communication and abstraction layers for ExtaLife API in ExalusHome system
609 lines • 36.6 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, DeviceTaskType } from 'lavva.exalushome/build/js/Services/Devices/IDevice';
import { ResponseResult } from 'lavva.exalushome/build/js/Services/FieldChangeResult';
import { DeviceType, RemoteDevice, RemoteMode } from './RemoteParams';
import { DataFrame, Method, Status } from 'lavva.exalushome/build/js/DataFrame';
import { GetChannelParamsRequest } from '../Common/DataRequest';
import { DevicesService } from 'lavva.exalushome/build/js/Services/Devices/DevicesService';
import { DeviceType as GeneralDeviceType } from 'lavva.exalushome/build/js/Services/Devices/IDevice';
export class RemotesService {
constructor() {
this._connection = Api.Get(ExalusConnectionService.ServiceName);
}
GetServiceName() {
return RemotesService.ServiceName;
}
GetPairedRemotesAsync(device, channel) {
return __awaiter(this, void 0, void 0, function* () {
var _a;
if (!device.Channels.any(ch => ch.Number === channel))
return new ResponseResult(RemoteServiceErrorCode.InvalidChannelNumber, `Cannot get paired remotes - invalid channel number, channel: ${channel}`);
const result = yield ((_a = this._connection) === null || _a === void 0 ? void 0 : _a.SendAndWaitForResponseAsync(new GetRemoteRequest(new GetChannelParamsRequest(device.Guid, channel)), 16000, false));
if (result == null || result.Status == null)
return new ResponseResult(RemoteServiceErrorCode.OtherError, `Cannot get paired remotes - unknown error.`);
switch (result.Status) {
case Status.OK:
break;
case Status.NoData:
return new ResponseResult(RemoteServiceErrorCode.NoPairedRemotes, `Cannot get paired remotes - no remote controls are paired with the device.`);
default:
return new ResponseResult(RemoteServiceErrorCode.OtherError, `Cannot get paired remotes - controller responded with error code: ${result.Status}.`);
}
if (result.Data == null)
return new ResponseResult(RemoteServiceErrorCode.NoData, `Cannot get paired remotes - no data in response.`);
const remotes = [];
for (var remote of result.Data) {
if (device.AvailableTaskTypes.any(task => task.Type == DeviceTaskType.SetBlindPosition || task.Type == DeviceTaskType.SetFacadePosition))
remotes.push(new RemoteDevice(remote));
//For non-blind remotes, 'channels' oprions indicates the channel number of the device, not the channel number of the remote control!
else if (remote.Channel == channel || remote.PairingOption.Channel == channel)
remotes.push(new RemoteDevice(remote));
}
RemotesService._pairedRemoteCache.set(device.Guid, remotes);
return remotes;
});
}
GetAvailableRemotesForDeviceAsync(deviceToControl, channelToControll) {
return __awaiter(this, void 0, void 0, function* () {
/**
* All strange filters based on devices or other conditions should be placed there
* Returns true if remote pass the filter
* @param deviceToControl
* @param channelToControll
*/
const applyCustomFilter = (deviceToControl, remoteDevice) => {
//Exclude different protocols
if (deviceToControl.ProtocolGuid != remoteDevice.ProtocolGuid)
return false;
//Exclude P457/P456 series for all blinds/facades
if (deviceToControl.AvailableResponseTypes.any(respType => respType.Type == DeviceResponseType.BlindRemoteButtonState || respType.Type == DeviceResponseType.FacadeRemoteButtonState)) {
switch (remoteDevice.ModelGuid) {
case "1d69f5c5-1a1b-47c6-adb7-1349334c3c2f":
case "31e4e5f6-f727-4249-b601-d5ba7ca75239":
case "a789447a-e6c5-48f6-8414-c1f9555c22ec":
case "a2adc7e0-00c6-4b67-9608-6f75f368f5e8":
return false;
}
}
return true;
};
const currentRemoteDevices = (yield Api.Get(DevicesService.ServiceName).GetDevicesAsync())
.where(dev => dev.DeviceType == GeneralDeviceType.Remote && dev.AvailableResponseTypes.all(respType => respType.Type != DeviceResponseType.MeasuredTemperature)).toArray();
const result = [];
//Adding wind sensors to remotes in case of facade blind
if (deviceToControl.AvailableTaskTypes.any(task => task.Type == DeviceTaskType.SetFacadePosition))
currentRemoteDevices.push(...(yield Api.Get(DevicesService.ServiceName).GetDevicesAsync())
.where(dev => dev.ModelGuid == "f48eab61-047a-4241-a1e6-aee89062cd69").toArray());
currentRemoteDevices.forEach(remoteDev => {
const deviceToControlAvaliableTasks = deviceToControl.AvailableTaskTypes;
const isBlindRemote = remoteDev.AvailableResponseTypes.any(respType => respType.Type == DeviceResponseType.BlindRemoteButtonState
|| respType.Type == DeviceResponseType.FacadeRemoteButtonState);
////////Per device remotes configuration
//
//
switch (deviceToControl.ModelGuid) {
//SLR-21
case "813d930e-4220-4a5f-b348-b0f731a07e5f":
{
if (!isBlindRemote)
if (applyCustomFilter(deviceToControl, remoteDev))
result.push(this.GenerateRemoteInitConfig(remoteDev, deviceToControl, channelToControll, RemoteTypeInit.OnOffMultiple));
}
return;
//VB-BiDi - its partial configuration, so we do not return, break only!
case "42015ac8-4a84-47b2-855d-795ee8edc06f":
{
//RNK22 or RNK24
if (remoteDev.ModelGuid == "90e73979-f0eb-40af-9879-5a73b65e2532" || remoteDev.ModelGuid == "d19efeee-4b76-47d2-8dc9-6f6a1b810ecb")
result.push(this.GenerateRemoteInitConfig(remoteDev, deviceToControl, channelToControll, RemoteTypeInit.FacadeSingle));
}
break;
//EX-BiDi - its partial configuration, so we do not return, break only!
case "d1b4cfc7-e92c-47d1-9c7c-9c9dd3351832":
{
//RNK22 or RNK24
if (remoteDev.ModelGuid == "90e73979-f0eb-40af-9879-5a73b65e2532" || remoteDev.ModelGuid == "d19efeee-4b76-47d2-8dc9-6f6a1b810ecb")
result.push(this.GenerateRemoteInitConfig(remoteDev, deviceToControl, channelToControll, RemoteTypeInit.BlindsSingle));
}
break;
//SBR_BiDi - its full configuration, return
case "824560d9-f83c-4ff6-99b7-0187bfda5d4e": {
//P457/P456 series
switch (remoteDev.ModelGuid) {
case "1d69f5c5-1a1b-47c6-adb7-1349334c3c2f":
case "31e4e5f6-f727-4249-b601-d5ba7ca75239":
case "a789447a-e6c5-48f6-8414-c1f9555c22ec":
case "a2adc7e0-00c6-4b67-9608-6f75f368f5e8":
if (applyCustomFilter(deviceToControl, remoteDev)) {
result.push(this.GenerateRemoteInitConfig(remoteDev, deviceToControl, channelToControll, RemoteTypeInit.OnOffSingle));
return;
}
}
if (remoteDev.ChannelsAmount > 1) {
if (applyCustomFilter(deviceToControl, remoteDev))
result.push(this.GenerateRemoteInitConfig(remoteDev, deviceToControl, channelToControll, RemoteTypeInit.BlindsMultiple));
}
else {
if (applyCustomFilter(deviceToControl, remoteDev))
result.push(this.GenerateRemoteInitConfig(remoteDev, deviceToControl, channelToControll, RemoteTypeInit.BlindsSingle));
}
return;
}
default:
break;
}
////////Per functionality remotes configuration
//
//
//Blinds
if (deviceToControlAvaliableTasks.any(task => task.Type == DeviceTaskType.SetBlindPosition)) {
if (remoteDev.ChannelsAmount > 1 && remoteDev.AvailableResponseTypes.any(resp => resp.Type == DeviceResponseType.BlindRemoteButtonState || resp.Type == DeviceResponseType.FacadeRemoteButtonState)) {
if (applyCustomFilter(deviceToControl, remoteDev))
result.push(this.GenerateRemoteInitConfig(remoteDev, deviceToControl, channelToControll, RemoteTypeInit.BlindsMultiple));
}
else if (remoteDev.AvailableResponseTypes.any(resp => resp.Type == DeviceResponseType.BlindRemoteButtonState || resp.Type == DeviceResponseType.FacadeRemoteButtonState)) {
if (applyCustomFilter(deviceToControl, remoteDev))
result.push(this.GenerateRemoteInitConfig(remoteDev, deviceToControl, channelToControll, RemoteTypeInit.BlindsSingle));
}
}
//Facade
else if (deviceToControlAvaliableTasks.any(task => task.Type == DeviceTaskType.SetFacadePosition)) {
if (remoteDev.ChannelsAmount > 1 && remoteDev.AvailableResponseTypes.any(resp => resp.Type == DeviceResponseType.FacadeRemoteButtonState || resp.Type == DeviceResponseType.BlindRemoteButtonState)) {
if (applyCustomFilter(deviceToControl, remoteDev))
result.push(this.GenerateRemoteInitConfig(remoteDev, deviceToControl, channelToControll, RemoteTypeInit.FacadeMultiple));
}
else if (remoteDev.AvailableResponseTypes.any(resp => resp.Type == DeviceResponseType.WindThreshold)) {
if (applyCustomFilter(deviceToControl, remoteDev))
result.push(this.GenerateRemoteInitConfig(remoteDev, deviceToControl, channelToControll, RemoteTypeInit.FacadeWindSensor));
}
else if (remoteDev.AvailableResponseTypes.any(resp => resp.Type == DeviceResponseType.FacadeRemoteButtonState || resp.Type == DeviceResponseType.BlindRemoteButtonState)) {
if (applyCustomFilter(deviceToControl, remoteDev))
result.push(this.GenerateRemoteInitConfig(remoteDev, deviceToControl, channelToControll, RemoteTypeInit.FacadeSingle));
}
}
//Dimmers
else if (deviceToControlAvaliableTasks.any(task => task.Type == DeviceTaskType.SetLightBrightness) && !isBlindRemote) {
if (remoteDev.ChannelsAmount > 1) {
if (applyCustomFilter(deviceToControl, remoteDev))
result.push(this.GenerateRemoteInitConfig(remoteDev, deviceToControl, channelToControll, RemoteTypeInit.DimmerMultiple));
}
else {
if (applyCustomFilter(deviceToControl, remoteDev))
result.push(this.GenerateRemoteInitConfig(remoteDev, deviceToControl, channelToControll, RemoteTypeInit.DimmerSingle));
}
}
//Gate
else if (deviceToControlAvaliableTasks.any(task => task.Type == DeviceTaskType.ChangeGatePositionPulse) && !isBlindRemote) {
if (applyCustomFilter(deviceToControl, remoteDev))
result.push(this.GenerateRemoteInitConfig(remoteDev, deviceToControl, channelToControll, RemoteTypeInit.GateSingle));
}
//Gateway
else if (deviceToControlAvaliableTasks.any(task => task.Type == DeviceTaskType.ChangeGatewayPositionPulse) && !isBlindRemote) {
if (applyCustomFilter(deviceToControl, remoteDev))
result.push(this.GenerateRemoteInitConfig(remoteDev, deviceToControl, channelToControll, RemoteTypeInit.GatewaySingle));
}
//OnOff
else if (!isBlindRemote) {
if (remoteDev.ChannelsAmount > 1) {
if (applyCustomFilter(deviceToControl, remoteDev))
result.push(this.GenerateRemoteInitConfig(remoteDev, deviceToControl, channelToControll, RemoteTypeInit.OnOffMultiple));
}
else {
if (applyCustomFilter(deviceToControl, remoteDev))
result.push(this.GenerateRemoteInitConfig(remoteDev, deviceToControl, channelToControll, RemoteTypeInit.OnOffSingle));
}
}
});
const remotesAlreadyAssigned = RemotesService._pairedRemoteCache.get(deviceToControl.Guid);
//Filter currently assigned, when it is not possible - return all remotes.
if (remotesAlreadyAssigned != null) {
return result.filter(remote => { return !remotesAlreadyAssigned.any(rAssigned => (remote.Guid == rAssigned.Guid && remote.RemoteChannelAmount == 1) || (remote.RemoteMode == 17 && rAssigned.RemoteMode == 17)); });
}
else {
yield this.GetPairedRemotesAsync(deviceToControl, channelToControll);
const remotesAlreadyAssigned = RemotesService._pairedRemoteCache.get(deviceToControl.Guid);
if (remotesAlreadyAssigned != null)
return result.filter(remote => { return !remotesAlreadyAssigned.any(rAssigned => remote.Guid == rAssigned.Guid && remote.RemoteChannelAmount == 1); });
}
return result;
});
}
EditRemoteOptionsAsync(remote) {
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 EditRemoteRequest(this.GenerateRemoteRawObject(remote)), 8000, false));
if (result == null || result.Status == null)
return new ResponseResult(RemoteServiceErrorCode.OtherError, `Cannot edit remote - unknown error.`);
if (result.Status !== Status.OK)
return new ResponseResult(RemoteServiceErrorCode.OtherError, `Cannot edit remote - controller responded with error code: ${result.Status}.`);
return result.Status;
}
catch (err) {
switch (err.constructor) {
case IllegalButtonNumber:
return new ResponseResult(RemoteServiceErrorCode.IllegalButtonNumber, `Cannot assign remote options - ${err.message}.`);
case ButtonAlreadyAssigned:
return new ResponseResult(RemoteServiceErrorCode.ButtonAlreadyAssigned, `Cannot assign remote options - ${err.message}.`);
case IllegalTimeValue:
return new ResponseResult(RemoteServiceErrorCode.IllegalTimeValue, `Cannot assign remote options - ${err.message}.`);
default:
throw err;
}
}
});
}
AssingRemoteToDeviceAsync(remote) {
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 AddRemoteRequest(this.GenerateRemoteRawObject(remote)), 8000, false));
if (result == null || result.Status == null)
return new ResponseResult(RemoteServiceErrorCode.OtherError, `Cannot assign remote - unknown error.`);
if (result.Status !== Status.OK)
return new ResponseResult(RemoteServiceErrorCode.OtherError, `Cannot assign remote - controller responded with error code: ${result.Status}.`);
return result.Status;
}
catch (err) {
switch (err.constructor) {
case IllegalButtonNumber:
return new ResponseResult(RemoteServiceErrorCode.IllegalButtonNumber, `Cannot assign remote options - ${err.message}.`);
case ButtonAlreadyAssigned:
return new ResponseResult(RemoteServiceErrorCode.ButtonAlreadyAssigned, `Cannot assign remote options - ${err.message}.`);
case IllegalTimeValue:
return new ResponseResult(RemoteServiceErrorCode.IllegalTimeValue, `Cannot assign remote options - ${err.message}.`);
default:
throw err;
}
}
});
}
RemoveRemoteFromDeviceAsync(remote) {
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 RemoveRemoteRequest(this.GenerateRemoteRawObject(remote)), 8000, false));
if (result == null || result.Status == null) {
Api.Get(RemotesService.ServiceName).Debug("Cannot delete remote - controler response is empty!");
return Status.FatalError;
}
return result.Status;
});
}
GenerateRemoteInitConfig(remoteDev, deviceToControl, channelToControll, remoteTypeInit) {
let deviceType = DeviceType.OnOff;
const pairingOption = new PairingOption();
switch (remoteTypeInit) {
case RemoteTypeInit.FacadeWindSensor:
pairingOption.Mode = RemoteMode.WSZFBidi;
pairingOption.KeyOn = 1;
pairingOption.KeyOff = 3;
pairingOption.TimeOn = 5;
pairingOption.Channel = 1;
deviceType = DeviceType.Facade;
break;
case RemoteTypeInit.FacadeSingle:
pairingOption.Mode = RemoteMode.PXZFBidi;
pairingOption.KeyOn = 1;
pairingOption.KeyOff = 3;
pairingOption.TimeOn = 5;
pairingOption.Channel = 1;
deviceType = DeviceType.Facade;
break;
case RemoteTypeInit.FacadeMultiple:
pairingOption.Mode = RemoteMode.NXZFBidi;
pairingOption.Channel = 1;
deviceType = DeviceType.Facade;
break;
case RemoteTypeInit.BlindsSingle:
pairingOption.Mode = RemoteMode.PixoBidi_1;
pairingOption.KeyOn = 1;
pairingOption.KeyOff = 3;
pairingOption.TimeOn = 5;
pairingOption.Channel = 1;
deviceType = DeviceType.Blind;
break;
case RemoteTypeInit.BlindsMultiple:
pairingOption.Mode = RemoteMode.PixoBidi_12;
pairingOption.Channel = 1;
deviceType = DeviceType.Blind;
break;
case RemoteTypeInit.DimmerSingle:
case RemoteTypeInit.DimmerMultiple:
pairingOption.Mode = RemoteMode.TimerDimmer;
pairingOption.TimeOn = 10;
pairingOption.KeyOn = 1;
deviceType = DeviceType.Dimmer;
break;
case RemoteTypeInit.OnOffSingle:
case RemoteTypeInit.OnOffMultiple:
pairingOption.Mode = RemoteMode.Bistable;
pairingOption.KeyOn = 1;
deviceType = DeviceType.OnOff;
break;
case RemoteTypeInit.GateSingle:
case RemoteTypeInit.GateMultiple:
pairingOption.Mode = RemoteMode.Gate;
deviceType = DeviceType.Gate;
break;
case RemoteTypeInit.GatewaySingle:
case RemoteTypeInit.GatewayMultiple:
pairingOption.Mode = RemoteMode.GateWay;
deviceType = DeviceType.Gateway;
break;
default:
break;
}
const remote = new RemoteDeviceRawObject();
remote.Name = remoteDev.Name;
remote.Guid = remoteDev.Guid;
remote.DeviceGuid = deviceToControl.Guid;
remote.Channel = channelToControll;
remote.RemoteChannelAmount = remoteDev.ChannelsAmount;
remote.PairingOption = pairingOption;
remote.DeviceType = deviceType;
return new RemoteDevice(remote);
}
GenerateRemoteRawObject(remote) {
const remoteDeviceObj = new RemoteDeviceRawObject();
remoteDeviceObj.DeviceGuid = remote.DeviceGuid;
remoteDeviceObj.Channel = remote.Channel;
remoteDeviceObj.Guid = remote.Guid;
remoteDeviceObj.Name = remote.Name;
remoteDeviceObj.RemoteChannelAmount = remote.RemoteChannelAmount;
remoteDeviceObj.DeviceChannelAmount = remote.DeviceChannelAmount;
remoteDeviceObj.OldSettingsOptional = Object.assign({}, remote.RawCurrentRemoteOptions);
remoteDeviceObj.DeviceType = remote.DeviceType;
//Map options values to appropriate device and mode
remoteDeviceObj.PairingOption = remote.RawCurrentRemoteOptions;
switch (remote.DeviceType) {
case DeviceType.OnOff:
switch (remote.RemoteMode) {
case RemoteMode.OnOff:
remoteDeviceObj.PairingOption.KeyOn = remote.CurrentRemotePairingOptions[remote.DeviceType].ModeParams[remote.RemoteMode].KeyOn;
remoteDeviceObj.PairingOption.KeyOff = remote.CurrentRemotePairingOptions[remote.DeviceType].ModeParams[remote.RemoteMode].KeyOff;
if (remoteDeviceObj.PairingOption.KeyOff == remoteDeviceObj.PairingOption.KeyOn) {
throw new ButtonAlreadyAssigned(`KeyOn and KeyOff are assigned to the same button!`);
}
if (remoteDeviceObj.PairingOption.KeyOff > remote.RemoteChannelAmount || remoteDeviceObj.PairingOption.KeyOn > remote.RemoteChannelAmount) {
throw new IllegalButtonNumber(`KeyOn and KeyOff number should be between 0 and ${remote.RemoteChannelAmount}`);
}
break;
case RemoteMode.Monostable:
case RemoteMode.Bistable:
remoteDeviceObj.PairingOption.KeyOn = remote.CurrentRemotePairingOptions[remote.DeviceType].ModeParams[remote.RemoteMode].KeyOn;
if (remoteDeviceObj.PairingOption.KeyOn > remote.RemoteChannelAmount) {
throw new IllegalButtonNumber(`KeyOn number should be between 0 and ${remote.RemoteChannelAmount}`);
}
break;
case RemoteMode.Timer:
remoteDeviceObj.PairingOption.KeyOn = remote.CurrentRemotePairingOptions[remote.DeviceType].ModeParams[remote.RemoteMode].KeyOn;
remoteDeviceObj.PairingOption.TimeOn = remote.CurrentRemotePairingOptions[remote.DeviceType].ModeParams[remote.RemoteMode].TimeOn;
if (remoteDeviceObj.PairingOption.KeyOn > remote.RemoteChannelAmount) {
throw new IllegalButtonNumber(`KeyOn number should be between 0 and ${remote.RemoteChannelAmount}`);
}
if (remoteDeviceObj.PairingOption.TimeOn > 0xFFFF || remoteDeviceObj.PairingOption.TimeOn < 1) {
throw new IllegalTimeValue(`TimeOn must be in range between 0 and 65535 seconds`);
}
break;
}
break;
case DeviceType.Blind:
switch (remote.RemoteMode) {
case RemoteMode.PixoBidi_1:
case RemoteMode.PixoBidi_12:
remoteDeviceObj.PairingOption.Channel = remote.CurrentRemotePairingOptions[remote.DeviceType].ModeParams[remote.RemoteMode].Channel;
remoteDeviceObj.Channel = remote.CurrentRemotePairingOptions[remote.DeviceType].ModeParams[remote.RemoteMode].Channel;
if (remoteDeviceObj.PairingOption.Channel > remote.RemoteChannelAmount) {
throw new IllegalButtonNumber(`Channel number should be between 0 and ${remote.RemoteChannelAmount}`);
}
break;
}
break;
case DeviceType.Dimmer:
switch (remote.RemoteMode) {
case RemoteMode.TwoButton:
remoteDeviceObj.PairingOption.KeyOn = remote.CurrentRemotePairingOptions[remote.DeviceType].ModeParams[remote.RemoteMode].KeyOn;
remoteDeviceObj.PairingOption.KeyOff = remote.CurrentRemotePairingOptions[remote.DeviceType].ModeParams[remote.RemoteMode].KeyOff;
if (remoteDeviceObj.PairingOption.KeyOff == remoteDeviceObj.PairingOption.KeyOn) {
throw new ButtonAlreadyAssigned(`KeyOn and KeyOff are assigned to the same button!`);
}
if (remoteDeviceObj.PairingOption.KeyOff > remote.RemoteChannelAmount || remoteDeviceObj.PairingOption.KeyOn > remote.RemoteChannelAmount) {
throw new IllegalButtonNumber(`KeyOn and KeyOff number should be between 0 and ${remote.RemoteChannelAmount}`);
}
break;
case RemoteMode.OneButton:
remoteDeviceObj.PairingOption.KeyOn = remote.CurrentRemotePairingOptions[remote.DeviceType].ModeParams[remote.RemoteMode].KeyOn;
if (remoteDeviceObj.PairingOption.KeyOn > remote.RemoteChannelAmount) {
throw new IllegalButtonNumber(`KeyOn number should be between 0 and ${remote.RemoteChannelAmount}`);
}
break;
case RemoteMode.Comfort:
remoteDeviceObj.PairingOption.KeyOn = remote.CurrentRemotePairingOptions[remote.DeviceType].ModeParams[remote.RemoteMode].KeyOn;
remoteDeviceObj.PairingOption.KeyOff = remote.CurrentRemotePairingOptions[remote.DeviceType].ModeParams[remote.RemoteMode].KeyOff;
remoteDeviceObj.PairingOption.KeyDimmer = remote.CurrentRemotePairingOptions[remote.DeviceType].ModeParams[remote.RemoteMode].KeyDimmer;
remoteDeviceObj.PairingOption.KeyBrightening = remote.CurrentRemotePairingOptions[remote.DeviceType].ModeParams[remote.RemoteMode].KeyBrightening;
const valuesToValidate = [];
valuesToValidate.push(remoteDeviceObj.PairingOption.KeyOn);
valuesToValidate.push(remoteDeviceObj.PairingOption.KeyOff);
valuesToValidate.push(remoteDeviceObj.PairingOption.KeyDimmer);
valuesToValidate.push(remoteDeviceObj.PairingOption.KeyBrightening);
if (valuesToValidate.filter((element, index, arr) => arr.indexOf(element) !== index).length > 0) {
throw new ButtonAlreadyAssigned(`KeyOn, KeyOff, KeyDimmer or KeyBrightening are assigned to the same button!`);
}
if (valuesToValidate.any(val => val > remote.RemoteChannelAmount)) {
throw new IllegalButtonNumber(`KeyOn number should be between 0 and ${remote.RemoteChannelAmount}`);
}
break;
case RemoteMode.TimerDimmer:
remoteDeviceObj.PairingOption.KeyOn = remote.CurrentRemotePairingOptions[remote.DeviceType].ModeParams[remote.RemoteMode].KeyOn;
remoteDeviceObj.PairingOption.TimeOn = remote.CurrentRemotePairingOptions[remote.DeviceType].ModeParams[remote.RemoteMode].TimeOn;
if (remoteDeviceObj.PairingOption.KeyOn > remote.RemoteChannelAmount) {
throw new IllegalButtonNumber(`KeyOn number should be between 0 and ${remote.RemoteChannelAmount}`);
}
if (remoteDeviceObj.PairingOption.TimeOn > 0xFFFF || remoteDeviceObj.PairingOption.TimeOn < 1) {
throw new IllegalTimeValue(`TimeOn must be in range between 0 and 65535 seconds`);
}
break;
}
break;
case DeviceType.Gate:
switch (remote.RemoteMode) {
case RemoteMode.Gate:
case RemoteMode.Bistable:
remoteDeviceObj.PairingOption.KeyOn = remote.CurrentRemotePairingOptions[remote.DeviceType].ModeParams[remote.RemoteMode].KeyOn;
if (remoteDeviceObj.PairingOption.KeyOn > remote.RemoteChannelAmount) {
throw new IllegalButtonNumber(`KeyOn number should be between 0 and ${remote.RemoteChannelAmount}`);
}
break;
}
break;
case DeviceType.Gateway:
switch (remote.RemoteMode) {
case RemoteMode.GateWay:
case RemoteMode.Bistable:
remoteDeviceObj.PairingOption.KeyOn = remote.CurrentRemotePairingOptions[remote.DeviceType].ModeParams[remote.RemoteMode].KeyOn;
if (remoteDeviceObj.PairingOption.KeyOn > remote.RemoteChannelAmount) {
throw new IllegalButtonNumber(`KeyOn number should be between 0 and ${remote.RemoteChannelAmount}`);
}
break;
}
break;
case DeviceType.Facade:
switch (remote.RemoteMode) {
case RemoteMode.NXZFBidi:
case RemoteMode.PXZFBidi:
remoteDeviceObj.PairingOption.Channel = remote.CurrentRemotePairingOptions[remote.DeviceType].ModeParams[remote.RemoteMode].Channel;
remoteDeviceObj.Channel = remote.CurrentRemotePairingOptions[remote.DeviceType].ModeParams[remote.RemoteMode].Channel;
if (remoteDeviceObj.PairingOption.Channel > remote.RemoteChannelAmount) {
throw new IllegalButtonNumber(`Channel number should be between 0 and ${remote.RemoteChannelAmount}`);
}
break;
}
break;
default:
break;
}
return remoteDeviceObj;
}
}
RemotesService._pairedRemoteCache = new Map();
RemotesService.ServiceName = "RemotesService";
export var RemoteServiceErrorCode;
(function (RemoteServiceErrorCode) {
RemoteServiceErrorCode["OtherError"] = "OtherError";
RemoteServiceErrorCode["InvalidChannelNumber"] = "InvalidChannelNumber";
RemoteServiceErrorCode["NoData"] = "NoData";
RemoteServiceErrorCode["IllegalButtonNumber"] = "IllegalButtonNumber";
RemoteServiceErrorCode["ButtonAlreadyAssigned"] = "ButtonAlreadyAssigned";
RemoteServiceErrorCode["IllegalTimeValue"] = "IllegalTimeValue";
RemoteServiceErrorCode["NoPairedRemotes"] = "NoPairedRemotes";
})(RemoteServiceErrorCode || (RemoteServiceErrorCode = {}));
var RemoteTypeInit;
(function (RemoteTypeInit) {
RemoteTypeInit[RemoteTypeInit["FacadeWindSensor"] = -1] = "FacadeWindSensor";
RemoteTypeInit[RemoteTypeInit["FacadeSingle"] = 0] = "FacadeSingle";
RemoteTypeInit[RemoteTypeInit["FacadeMultiple"] = 1] = "FacadeMultiple";
RemoteTypeInit[RemoteTypeInit["BlindsSingle"] = 2] = "BlindsSingle";
RemoteTypeInit[RemoteTypeInit["BlindsMultiple"] = 3] = "BlindsMultiple";
RemoteTypeInit[RemoteTypeInit["DimmerSingle"] = 4] = "DimmerSingle";
RemoteTypeInit[RemoteTypeInit["DimmerMultiple"] = 5] = "DimmerMultiple";
RemoteTypeInit[RemoteTypeInit["OnOffSingle"] = 6] = "OnOffSingle";
RemoteTypeInit[RemoteTypeInit["OnOffMultiple"] = 7] = "OnOffMultiple";
RemoteTypeInit[RemoteTypeInit["GateSingle"] = 8] = "GateSingle";
RemoteTypeInit[RemoteTypeInit["GateMultiple"] = 9] = "GateMultiple";
RemoteTypeInit[RemoteTypeInit["GatewaySingle"] = 10] = "GatewaySingle";
RemoteTypeInit[RemoteTypeInit["GatewayMultiple"] = 11] = "GatewayMultiple";
})(RemoteTypeInit || (RemoteTypeInit = {}));
class RemoteDeviceRawObject {
constructor() {
this.DeviceGuid = "";
this.Channel = 0;
this.Guid = "";
this.Name = "";
this.RemoteChannelAmount = 0;
this.DeviceChannelAmount = 0;
this.PairingOption = new PairingOption();
this.OldSettingsOptional = new PairingOption();
this.DeviceType = DeviceType.OnOff;
}
}
class PairingOption {
constructor() {
this.Mode = RemoteMode.Bistable;
this.KeyOn = 0;
this.KeyOff = 0;
this.KeyBrightening = 0;
this.KeyDimmer = 0;
this.TimeOn = 0;
this.Channel = 0;
}
}
//GetRemoteRequest
class GetRemoteRequest extends DataFrame {
constructor(data) {
super();
this.Resource = "/extalife/device/remote/list";
this.Method = Method.Get;
this.Data = data;
}
}
//EditRemoteRequest
class EditRemoteRequest extends DataFrame {
constructor(data) {
super();
this.Resource = "/extalife/device/remote/editNew";
this.Method = Method.Post;
this.Data = data;
}
}
//AddRemoteRequest
class AddRemoteRequest extends DataFrame {
constructor(data) {
super();
this.Resource = "/extalife/device/remote/add";
this.Method = Method.Post;
this.Data = data;
}
}
//RemoveRemoteRequest
class RemoveRemoteRequest extends DataFrame {
constructor(data) {
super();
this.Resource = "/extalife/device/remote/delate";
this.Method = Method.Delete;
this.Data = data;
}
}
//Errors
class IllegalButtonNumber extends Error {
constructor(message) {
super(message);
this.message = message;
this.name = "IllegalButtonNumber";
}
}
class ButtonAlreadyAssigned extends Error {
constructor(message) {
super(message);
this.message = message;
this.name = "ButtonAlreadyAssigned";
}
}
class IllegalTimeValue extends Error {
constructor(message) {
super(message);
this.message = message;
this.name = "IllegalTimeValue";
}
}
//# sourceMappingURL=RemotesService.js.map