lavva.exalushome
Version:
Library implementing communication and abstraction layers for ExalusHome system
476 lines • 25.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 "../../Api";
import { DataFrame, Method, Status } from "../../DataFrame";
import { Helpers } from "../../Helpers";
import { ExalusConnectionService } from "../ExalusConnectionService";
import { ResponseResult } from "../FieldChangeResult";
import { LoggerService } from "../Logging/LoggerService";
import { DeviceTokenMetadata, NotificationClientType, NotificationsServiceErrorCode } from "./IControllerNotificationsService";
export class ControllerNotificationsService {
constructor() {
this._connection = Api.Get(ExalusConnectionService.ServiceName);
this._logger = Api.Get(LoggerService.ServiceName);
}
GetServiceName() {
return ControllerNotificationsService.ServiceName;
}
RegisterNotificationsClientAsync(registration) {
return __awaiter(this, void 0, void 0, function* () {
var _a;
try {
const request = new RegisterNotificationsClientRequest({
ClientName: registration.ClientName,
DeviceToken: registration.DeviceToken,
LavvaUserName: registration.LavvaUserName,
ClientType: this.getClientType(),
NotificationsEnabledForToken: registration.EnableNotifications
});
const result = yield ((_a = this._connection) === null || _a === void 0 ? void 0 : _a.SendAndWaitForResponseAsync(request, 8000, false));
if (result == null || result.Status == null) {
return new ResponseResult(NotificationsServiceErrorCode.UnknownError, `Cannot register notifications client - unknown error!`);
}
switch (result.Status) {
case Status.WrongData: {
const errorCode = this.isValidErrorCode(result.Data) ? result.Data : NotificationsServiceErrorCode.UnknownError;
return new ResponseResult(errorCode, `Cannot register notifications client - wrong data!`);
}
case Status.ResourceDoesNotExists: {
return new ResponseResult(NotificationsServiceErrorCode.FeatureUnsupported, `Notifications feature not supported in controller!`);
}
case Status.OK: {
if (typeof result.Data === "string")
return result.Data;
else {
return new ResponseResult(NotificationsServiceErrorCode.NoData, `Cannot register notifications client - result status is OK, but no token guid presented in paylode, unknown error!`);
}
}
default:
return new ResponseResult(NotificationsServiceErrorCode.UnknownError, `Cannot register notifications client - unknown error!`);
}
}
catch (error) {
return new ResponseResult(NotificationsServiceErrorCode.UnknownError, `Cannot register notifications client - error: ${error}`);
}
});
}
UpdateNotificationsClientAsync(tokenGuid, registration) {
return __awaiter(this, void 0, void 0, function* () {
var _a;
try {
const request = new UpdateNotificationsClientRequest({
ClientName: registration.ClientName,
DeviceToken: registration.DeviceToken,
LavvaUserName: registration.LavvaUserName,
ClientType: this.getClientType(),
NotificationsEnabledForToken: registration.EnableNotifications,
Guid: tokenGuid
});
const result = yield ((_a = this._connection) === null || _a === void 0 ? void 0 : _a.SendAndWaitForResponseAsync(request, 8000, false));
if (result == null || result.Status == null) {
return new ResponseResult(NotificationsServiceErrorCode.UnknownError, `Cannot update notifications client - unknown error!`);
}
switch (result.Status) {
case Status.WrongData: {
const errorCode = this.isValidErrorCode(result.Data) ? result.Data : NotificationsServiceErrorCode.UnknownError;
return new ResponseResult(errorCode, `Cannot update notifications client - wrong data!`);
}
case Status.ResourceDoesNotExists: {
return new ResponseResult(NotificationsServiceErrorCode.FeatureUnsupported, `Notifications feature not supported in controller!`);
}
case Status.OK: {
if (typeof result.Data === "string")
if (result.Data == tokenGuid)
return Status.OK;
else {
return new ResponseResult(NotificationsServiceErrorCode.UnknownError, `Cannot update notifications client - result status is OK, but token guid is different! request guid ${tokenGuid}, response guid: ${result.Data}`);
}
else {
return new ResponseResult(NotificationsServiceErrorCode.NoData, `Cannot update notifications client - result status is OK, but no token guid presented in paylode, unknown error!`);
}
}
default:
return new ResponseResult(NotificationsServiceErrorCode.UnknownError, `Cannot update notifications client - unknown error!`);
}
}
catch (error) {
this._logger.Error(`Cannot update notifications client - error: ${error}`);
return new ResponseResult(NotificationsServiceErrorCode.UnknownError, `Cannot update notifications client - error: ${error}`);
}
});
}
GetRegisteredNotificationsClientsMetadataAsync(lavvaUserName) {
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 GetTokenMetadataRequest(), 8000, false));
if (result == null || result.Status == null) {
return new ResponseResult(NotificationsServiceErrorCode.UnknownError, `Cannot get notifications clients metadata - unknown error!`);
}
if (result.Status == Status.ResourceDoesNotExists)
return new ResponseResult(NotificationsServiceErrorCode.FeatureUnsupported, `Notifications feature not supported in controller!`);
if (result.Status != Status.OK)
return new ResponseResult(NotificationsServiceErrorCode.UnknownError, `Cannot get notifications clients metadata - response status: ${result.Status}}`);
if (result.Data == null)
return new ResponseResult(NotificationsServiceErrorCode.NoData, `Cannot get notifications clients metadata - response status is OK, but no data!`);
return result.Data.map((item) => {
const registration = new DeviceTokenMetadata();
registration.ClientName = item.ClientName;
registration.LavvaUserName = item.LavvaUserName;
registration.ClientType = item.ClientType;
registration.TokenGuid = item.TokenGuid;
registration.Token = item.Token;
registration.RegistrationDate = new Date(item.RegistrationDate);
return registration;
});
}
catch (error) {
this._logger.Error(`Cannot get notifications clients metadata - error: ${error}`);
return new ResponseResult(NotificationsServiceErrorCode.UnknownError, `Cannot get notifications clients metadata - error: ${error}`);
}
});
}
IsNotificationsEnabledForAllUserTokensAsync(lavvaUserName) {
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 IsNotificationsEnabledForAllUsersRequest(lavvaUserName), 8000, false));
if (result == null || result.Status == null) {
return new ResponseResult(NotificationsServiceErrorCode.UnknownError, `Cannot get notifications status - unknown error!`);
}
switch (result.Status) {
case Status.ResourceDoesNotExists:
case Status.WrongData: {
if (result.Data == null)
return new ResponseResult(NotificationsServiceErrorCode.FeatureUnsupported, `Notifications feature not supported in controller!`);
else {
const errorCode = this.isValidErrorCode(result.Data) ? result.Data : NotificationsServiceErrorCode.UnknownError;
return new ResponseResult(errorCode, `Cannot get notifications status!`);
}
}
case Status.OK: {
if (typeof result.Data === "boolean")
return result.Data;
else
return new ResponseResult(NotificationsServiceErrorCode.NoData, `Cannot get notifications status - result status is OK, but no data, or data type is wrong!`);
}
default:
return new ResponseResult(NotificationsServiceErrorCode.UnknownError, `Cannot get notifications - response code ${result.Status}}!`);
}
}
catch (error) {
this._logger.Error(`Cannot get notifications status - error: ${error}`);
return new ResponseResult(NotificationsServiceErrorCode.UnknownError, `Cannot get notifications status - error: ${error}`);
}
});
}
IsNotificationsEnabledAsync(tokenIdentity) {
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 IsNotificationsEnabledRequest(tokenIdentity), 8000, false));
if (result == null || result.Status == null) {
return new ResponseResult(NotificationsServiceErrorCode.UnknownError, `Cannot get notifications status - unknown error!`);
}
switch (result.Status) {
case Status.ResourceDoesNotExists: {
if (result.Data == null)
return new ResponseResult(NotificationsServiceErrorCode.FeatureUnsupported, `Notifications feature not supported in controller!`);
else {
const errorCode = this.isValidErrorCode(result.Data) ? result.Data : NotificationsServiceErrorCode.UnknownError;
return new ResponseResult(errorCode, `Cannot get notifications status - resource not exists!`);
}
}
case Status.OK: {
if (typeof result.Data === "boolean")
return result.Data;
else
return new ResponseResult(NotificationsServiceErrorCode.NoData, `Cannot get notifications status - result status is OK, but no data, or data type is wrong!`);
}
default:
return new ResponseResult(NotificationsServiceErrorCode.UnknownError, `Cannot get notifications - response code ${result.Status}}!`);
}
}
catch (error) {
this._logger.Error(`Cannot get notifications status - error: ${error}`);
return new ResponseResult(NotificationsServiceErrorCode.UnknownError, `Cannot get notifications status - error: ${error}`);
}
});
}
EnableNotificationsAsync(tokenIdentity) {
return __awaiter(this, void 0, void 0, function* () {
var _a;
try {
let tk = null;
if (tokenIdentity != undefined && tokenIdentity != "")
tk = tokenIdentity;
const result = yield ((_a = this._connection) === null || _a === void 0 ? void 0 : _a.SendAndWaitForResponseAsync(new EnableNotificationsRequest(tk), 8000, false));
if (result == null || result.Status == null) {
return new ResponseResult(NotificationsServiceErrorCode.UnknownError, `Cannot enable notifications - unknown error!`);
}
switch (result.Status) {
case Status.ResourceDoesNotExists: {
if (result.Data == null)
return new ResponseResult(NotificationsServiceErrorCode.FeatureUnsupported, `Notifications feature not supported in controller!`);
else {
const errorCode = this.isValidErrorCode(result.Data) ? result.Data : NotificationsServiceErrorCode.UnknownError;
return new ResponseResult(errorCode, `Cannot enable notifications - resource not exists!`);
}
}
case Status.OK: {
return Status.OK;
}
default:
return new ResponseResult(NotificationsServiceErrorCode.UnknownError, `Cannot enable notifications - response code ${result.Status}}!`);
}
}
catch (error) {
this._logger.Error(`Cannot enable notifications - error: ${error}`);
return new ResponseResult(NotificationsServiceErrorCode.UnknownError, `Cannot enable notifications - error: ${error}`);
}
});
}
EnableNotificationsForAllUserTokensAsync(lavvaUserName) {
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 EnableNotificationsForLavvaUserRequest(lavvaUserName), 8000, false));
if (result == null || result.Status == null) {
return new ResponseResult(NotificationsServiceErrorCode.UnknownError, `Cannot enable notifications - unknown error!`);
}
switch (result.Status) {
case Status.ResourceDoesNotExists:
case Status.WrongData: {
if (result.Data == null)
return new ResponseResult(NotificationsServiceErrorCode.FeatureUnsupported, `Notifications feature not supported in controller!`);
else {
const errorCode = this.isValidErrorCode(result.Data) ? result.Data : NotificationsServiceErrorCode.UnknownError;
return new ResponseResult(errorCode, `Cannot enable notifications!`);
}
}
case Status.OK: {
return Status.OK;
}
default:
return new ResponseResult(NotificationsServiceErrorCode.UnknownError, `Cannot enable notifications - response code ${result.Status}!`);
}
}
catch (error) {
this._logger.Error(`Cannot enable notifications for lavva user ${lavvaUserName} - error: ${error}`);
return new ResponseResult(NotificationsServiceErrorCode.UnknownError, `Cannot disable notifications for lavva user ${lavvaUserName} - error: ${error}`);
}
});
}
DisableNotificationsAsync(tokenIdentity) {
return __awaiter(this, void 0, void 0, function* () {
var _a;
try {
let tk = null;
if (tokenIdentity != undefined && tokenIdentity != "")
tk = tokenIdentity;
const result = yield ((_a = this._connection) === null || _a === void 0 ? void 0 : _a.SendAndWaitForResponseAsync(new DisableNotificationsRequest(tk), 8000, false));
if (result == null || result.Status == null) {
return new ResponseResult(NotificationsServiceErrorCode.UnknownError, `Cannot disable notifications - unknown error!`);
}
switch (result.Status) {
case Status.ResourceDoesNotExists: {
if (result.Data == null)
return new ResponseResult(NotificationsServiceErrorCode.FeatureUnsupported, `Notifications feature not supported in controller!`);
else {
const errorCode = this.isValidErrorCode(result.Data) ? result.Data : NotificationsServiceErrorCode.UnknownError;
return new ResponseResult(errorCode, `Cannot disable notifications - resource not exists!`);
}
}
case Status.OK: {
return Status.OK;
}
default:
return new ResponseResult(NotificationsServiceErrorCode.UnknownError, `Cannot disable notifications - response code ${result.Status}!`);
}
}
catch (error) {
this._logger.Error(`Cannot disable notifications - error: ${error}`);
return new ResponseResult(NotificationsServiceErrorCode.UnknownError, `Cannot disable notifications - error: ${error}`);
}
});
}
DisableNotificationsForAllUserTokensAsync(lavvaUserName) {
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 DisableNotificationsForLavvaUserRequest(lavvaUserName), 8000, false));
if (result == null || result.Status == null) {
return new ResponseResult(NotificationsServiceErrorCode.UnknownError, `Cannot disable notifications - unknown error!`);
}
switch (result.Status) {
case Status.ResourceDoesNotExists:
case Status.WrongData: {
if (result.Data == null)
return new ResponseResult(NotificationsServiceErrorCode.FeatureUnsupported, `Notifications feature not supported in controller!`);
else {
const errorCode = this.isValidErrorCode(result.Data) ? result.Data : NotificationsServiceErrorCode.UnknownError;
return new ResponseResult(errorCode, `Cannot disable notifications!`);
}
}
case Status.OK: {
return Status.OK;
}
default:
return new ResponseResult(NotificationsServiceErrorCode.UnknownError, `Cannot disable notifications - response code ${result.Status}!`);
}
}
catch (error) {
this._logger.Error(`Cannot disable notifications for lavva user ${lavvaUserName} - error: ${error}`);
return new ResponseResult(NotificationsServiceErrorCode.UnknownError, `Cannot disable notifications for lavva user ${lavvaUserName} - error: ${error}`);
}
});
}
DeleteNotificationsTokenAsync(tokenGuid) {
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 DeleteNotificationsTokenRequest(tokenGuid), 8000, false));
if (result == null || result.Status == null) {
return new ResponseResult(NotificationsServiceErrorCode.UnknownError, `Cannot delete notifications token - unknown error!`);
}
if (result.Status == Status.OK)
return Status.OK;
else
return new ResponseResult(NotificationsServiceErrorCode.UnknownError, `Cannot delete notifications token - response code ${result.Status}!`);
}
catch (error) {
this._logger.Error(`Cannot delete notifications token - error: ${error}`);
return new ResponseResult(NotificationsServiceErrorCode.UnknownError, `Cannot delete notifications token - error: ${error}`);
}
});
}
getClientType() {
if (Helpers.IsIosNative()) {
return NotificationClientType.iOS;
}
else if (navigator.userAgent.endsWith("LavvaAndroidNative")) {
return NotificationClientType.Android;
}
else {
return NotificationClientType.Web;
}
}
isValidErrorCode(value) {
return Object.values(NotificationsServiceErrorCode).includes(value);
}
}
ControllerNotificationsService.ServiceName = "NotificationsService";
class RegisterNotificationsClientRequest extends DataFrame {
constructor(data) {
super();
this.Resource = "/notifications/token";
this.Method = Method.Post;
this.Data = data;
}
}
class RegisterNotificationsClientFrame {
constructor() {
this.ClientName = "";
this.LavvaUserName = "";
this.DeviceToken = "";
this.ClientType = NotificationClientType.Unknown;
this.NotificationsEnabledForToken = true;
}
}
class UpdateNotificationsClientRequest extends DataFrame {
constructor(data) {
super();
this.Resource = "/notifications/token";
this.Method = Method.Put;
this.Data = data;
}
}
class UpdateNotificationsClientFrame extends RegisterNotificationsClientFrame {
constructor() {
super(...arguments);
this.Guid = "";
}
}
class GetTokenMetadataRequest extends DataFrame {
constructor() {
super();
this.Resource = "/notifications/tokens/metadata";
this.Method = Method.Get;
}
}
class DeviceTokenMetadataFrame {
constructor() {
this.ClientName = "";
this.LavvaUserName = "";
this.ClientType = NotificationClientType.Unknown;
this.TokenGuid = "";
this.Token = "";
this.RegistrationDate = "";
}
}
class IsNotificationsEnabledRequest extends DataFrame {
constructor(tokenIdentity) {
super();
this.Resource = "/notifications/status";
this.Method = Method.Get;
this.Data = {
TokenIdentity: tokenIdentity
};
}
}
class EnableNotificationsRequest extends DataFrame {
constructor(tokenIdentity) {
super();
this.Resource = "/notifications/enable";
this.Method = Method.Post;
this.Data = tokenIdentity;
}
}
class DisableNotificationsRequest extends DataFrame {
constructor(tokenIdentity) {
super();
this.Resource = "/notifications/disable";
this.Method = Method.Post;
this.Data = tokenIdentity;
}
}
class EnableNotificationsForLavvaUserRequest extends DataFrame {
constructor(lavvaUser) {
super();
this.Resource = "/notifications/enable/for/lavva/user";
this.Method = Method.Post;
this.Data = lavvaUser;
}
}
class DisableNotificationsForLavvaUserRequest extends DataFrame {
constructor(lavvaUser) {
super();
this.Resource = "/notifications/disable/for/lavva/user";
this.Method = Method.Post;
this.Data = lavvaUser;
}
}
class IsNotificationsEnabledForAllUsersRequest extends DataFrame {
constructor(lavvaUser) {
super();
this.Resource = "/notifications/status/for/lavva/user";
this.Method = Method.Get;
this.Data = lavvaUser;
}
}
class DeleteNotificationsTokenRequest extends DataFrame {
constructor(tokenGuid) {
super();
this.Resource = `/notifications/token`;
this.Method = Method.Delete;
this.Data = tokenGuid;
}
}
//# sourceMappingURL=ControllerNotificationsService.js.map