dt-common-device 7.6.3 → 7.6.5

package/dist/alerts/Alert.model.d.ts

@@ -13,7 +13,7 @@ interface IAlertModel extends Model<IAlertDocument, {}, IAlertMethods> {
     findSnoozed(includeDeleted?: boolean): Promise<IAlertDocument[]>;
     findExpiredSnooze(includeDeleted?: boolean): Promise<IAlertDocument[]>;
 }
-declare const AlertSchema: mongoose.Schema<IAlertDocument, IAlertModel, IAlertMethods, {}, {}, {}, mongoose.DefaultSchemaOptions, IAlertDocument, mongoose.Document<unknown, {}, mongoose.FlatRecord<IAlertDocument>, {}> & Omit<mongoose.FlatRecord<IAlertDocument> & Required<{
+declare const AlertSchema: mongoose.Schema<IAlertDocument, IAlertModel, IAlertMethods, {}, {}, {}, mongoose.DefaultSchemaOptions, IAlertDocument, mongoose.Document<unknown, {}, mongoose.FlatRecord<IAlertDocument>, {}, mongoose.ResolveSchemaOptions<mongoose.DefaultSchemaOptions>> & Omit<mongoose.FlatRecord<IAlertDocument> & Required<{
     _id: string;
 }> & {
     __v: number;

package/dist/alerts/Alert.service.d.ts

@@ -22,12 +22,9 @@ export declare class AlertService {
     raiseDoorLeftOpenAlert(device: IDevice, zone: any, openThreshold: number, source: Source): Promise<IAlertDocument | null>;
     raiseNewDeviceAlert(device: {
         deviceId: string;
-        deviceType: {
-            type: any;
-        };
-        propertyId: string;
+        deviceType: string;
         name: string;
-    }, source: Source, description?: string): Promise<IAlertDocument | null>;
+    }, propertyId: string, source: Source): Promise<IAlertDocument | null>;
     raiseDoorOpenFrequentAlert(device: IDevice, zone: any, accessTimes: number, openThreshold: number, source: Source): Promise<IAlertDocument | null>;
     raiseDoorOpenOutsideBusinessHoursAlert(device: IDevice, zone: any, source: Source): Promise<IAlertDocument | null>;
     /**
@@ -74,7 +71,7 @@ export declare class AlertService {
     /**
      * Deactivate an alert with business logic
      */
-    deactivateAlert(id: string, updatedBy: string): Promise<IAlertDocument | null>;
+    deactivateAlert(query: IAlertQuery, updatedBy: string): Promise<IAlertDocument | null>;
     /**
      * Snooze an alert with business logic
      */

package/dist/alerts/Alert.service.js

@@ -176,14 +176,14 @@ let AlertService = (() => {
                 type: alert_types_1.AlertType.DOOR_LEFT_OPEN,
             });
         }
-        async raiseNewDeviceAlert(device, source, description) {
+        async raiseNewDeviceAlert(device, propertyId, source) {
             return await this.createAlert({
                 entityId: device.deviceId,
                 entityType: alert_types_1.EntityType.DEVICE,
-                entitySubType: device?.deviceType?.type,
-                propertyId: device?.propertyId,
+                entitySubType: device?.deviceType,
+                propertyId: propertyId,
                 title: "New Device Detected",
-                description: description || `New device ${device?.name} has been detected.`,
+                description: `New device ${device.name} has been detected.`,
                 createdBy: source,
                 category: alert_types_1.AlertCategory.OPERATIONS,
                 severity: alert_types_1.AlertSeverity.INFO,
@@ -483,15 +483,20 @@ let AlertService = (() => {
         /**
          * Deactivate an alert with business logic
          */
-        async deactivateAlert(id, updatedBy) {
-            if (!id || !updatedBy) {
-                throw new Error("Alert ID and updated by user are required");
+        async deactivateAlert(query, updatedBy) {
+            if (!query || !updatedBy)
+                throw new Error("Alert query and updated by user are required");
+            const alerts = await this.queryAlerts(query);
+            if (!alerts.length)
+                return null;
+            if (alerts.length > 1) {
+                throw new Error("Multiple alerts found, please specify a more specific query");
             }
-            const alertModel = await Alert_model_1.AlertModel.findById(id);
-            if (!alertModel)
+            const alert = await Alert_model_1.AlertModel.findById(alerts[0]._id);
+            if (!alert)
                 return null;
-            alertModel.deactivate(updatedBy);
-            return await alertModel.save();
+            alert.deactivate(updatedBy);
+            return await alert.save();
         }
         /**
          * Snooze an alert with business logic

package/dist/constants/Event.d.ts

@@ -46,14 +46,7 @@ export declare const DT_EVENT_TYPES: {
         };
         BATTERY: {
             REPLACED: string;
-            STATE: {
-                REPLACE: string;
-            };
             LEVEL: {
-                ATTEMPT: {
-                    SUCCESS: string;
-                    FAILED: string;
-                };
                 UNKNOWN: string;
                 NORMAL: string;
                 LOW: string;
@@ -83,13 +76,6 @@ export declare const DT_EVENT_TYPES: {
             UNPROCESSED: string;
             UNHANDLED: string;
         };
-        ISSUE: {
-            CREATED: string;
-            CANCELLED: string;
-            RESOLVED: string;
-            UPDATED: string;
-            DELETED: string;
-        };
     };
     CONNECTION: {
         CREATE: {
@@ -189,6 +175,30 @@ export declare const DT_EVENT_TYPES: {
             SUCCESS: string;
             FAILED: string;
         };
+        CANCEL: {
+            SUCCESS: string;
+            FAILED: string;
+        };
+        RESOLVE: {
+            SUCCESS: string;
+            FAILED: string;
+        };
+        IGNORE: {
+            SUCCESS: string;
+            FAILED: string;
+        };
+        CLOSE: {
+            SUCCESS: string;
+            FAILED: string;
+        };
+        IN_PROGRESS: {
+            SUCCESS: string;
+            FAILED: string;
+        };
+        ON_HOLD: {
+            SUCCESS: string;
+            FAILED: string;
+        };
     };
     ALERT: {
         CREATE: {
@@ -204,5 +214,29 @@ export declare const DT_EVENT_TYPES: {
             SUCCESS: string;
             FAILED: string;
         };
+        ACTIVATE: {
+            SUCCESS: string;
+            FAILED: string;
+        };
+        DEACTIVATE: {
+            SUCCESS: string;
+            FAILED: string;
+        };
+        SNOOZE: {
+            SUCCESS: string;
+            FAILED: string;
+        };
+        UNSNOOZE: {
+            SUCCESS: string;
+            FAILED: string;
+        };
+        MARK_AS_READ: {
+            SUCCESS: string;
+            FAILED: string;
+        };
+        MARK_AS_UNREAD: {
+            SUCCESS: string;
+            FAILED: string;
+        };
     };
 };

package/dist/constants/Event.js

@@ -49,14 +49,7 @@ exports.DT_EVENT_TYPES = {
         },
         BATTERY: {
             REPLACED: "device.battery.replaced",
-            STATE: {
-                REPLACE: "device.battery.state.replace",
-            },
             LEVEL: {
-                ATTEMPT: {
-                    SUCCESS: "device.battery.level.attempt.success",
-                    FAILED: "device.battery.level.attempt.failed",
-                },
                 UNKNOWN: "device.battery.level.unknown",
                 NORMAL: "device.battery.level.normal",
                 LOW: "device.battery.level.low",
@@ -86,13 +79,6 @@ exports.DT_EVENT_TYPES = {
             UNPROCESSED: "device.webhook.unprocessed",
             UNHANDLED: "device.webhook.unhandled",
         },
-        ISSUE: {
-            CREATED: "device.issue.created",
-            CANCELLED: "device.issue.cancelled",
-            RESOLVED: "device.issue.resolved",
-            UPDATED: "device.issue.updated",
-            DELETED: "device.issue.deleted",
-        },
     },
     CONNECTION: {
         CREATE: {
@@ -192,6 +178,30 @@ exports.DT_EVENT_TYPES = {
             SUCCESS: "issue.delete.success",
             FAILED: "issue.delete.failed",
         },
+        CANCEL: {
+            SUCCESS: "issue.cancel.success",
+            FAILED: "issue.cancel.failed",
+        },
+        RESOLVE: {
+            SUCCESS: "issue.resolve.success",
+            FAILED: "issue.resolve.failed",
+        },
+        IGNORE: {
+            SUCCESS: "issue.ignore.success",
+            FAILED: "issue.ignore.failed",
+        },
+        CLOSE: {
+            SUCCESS: "issue.close.success",
+            FAILED: "issue.close.failed",
+        },
+        IN_PROGRESS: {
+            SUCCESS: "issue.in_progress.success",
+            FAILED: "issue.in_progress.failed",
+        },
+        ON_HOLD: {
+            SUCCESS: "issue.on_hold.success",
+            FAILED: "issue.on_hold.failed",
+        },
     },
     ALERT: {
         CREATE: {
@@ -207,5 +217,29 @@ exports.DT_EVENT_TYPES = {
             SUCCESS: "alert.delete.success",
             FAILED: "alert.delete.failed",
         },
+        ACTIVATE: {
+            SUCCESS: "alert.activate.success",
+            FAILED: "alert.activate.failed",
+        },
+        DEACTIVATE: {
+            SUCCESS: "alert.deactivate.success",
+            FAILED: "alert.deactivate.failed",
+        },
+        SNOOZE: {
+            SUCCESS: "alert.snooze.success",
+            FAILED: "alert.snooze.failed",
+        },
+        UNSNOOZE: {
+            SUCCESS: "alert.unsnooze.success",
+            FAILED: "alert.unsnooze.failed",
+        },
+        MARK_AS_READ: {
+            SUCCESS: "alert.mark_as_read.success",
+            FAILED: "alert.mark_as_read.failed",
+        },
+        MARK_AS_UNREAD: {
+            SUCCESS: "alert.mark_as_unread.success",
+            FAILED: "alert.mark_as_unread.failed",
+        },
     },
 };

package/dist/entities/accessGroup/AccessGroup.repository.d.ts

@@ -1,5 +1,6 @@
+import { IAccessGroup } from "./IAccessGroup";
 export declare class AccessGroupRepository {
     private readonly postgres;
     constructor();
-    getAccessGroup(accessGroupId: string): Promise<any>;
+    getAccessGroup(accessGroupId: string): Promise<IAccessGroup | null>;
 }

package/dist/entities/accessGroup/AccessGroup.repository.js

@@ -56,7 +56,10 @@ let AccessGroupRepository = (() => {
       WHERE "id" = $1
     `;
             const result = await this.postgres.query(query, [accessGroupId]);
-            return result.rows[0];
+            if (result.rows.length > 0) {
+                return result.rows[0];
+            }
+            return null;
         }
     };
     __setFunctionName(_classThis, "AccessGroupRepository");

package/dist/entities/accessGroup/AccessGroup.service.d.ts

@@ -1,5 +1,6 @@
+import { IAccessGroup } from "./IAccessGroup";
 export declare class AccessGroupService {
     private readonly accessGroupRepository;
     constructor();
-    getAccessGroup(accessGroupId: string): Promise<any>;
+    getAccessGroup(accessGroupId: string): Promise<IAccessGroup | null>;
 }

package/dist/entities/accessGroup/AccessGroup.service.js

@@ -87,7 +87,10 @@ let AccessGroupService = (() => {
             if (!accessGroupId) {
                 throw new Error("Access Group ID is required");
             }
-            return await this.accessGroupRepository.getAccessGroup(accessGroupId);
+            const accessGroup = await this.accessGroupRepository.getAccessGroup(accessGroupId);
+            if (!accessGroup)
+                return null;
+            return accessGroup;
         }
     };
     __setFunctionName(_classThis, "AccessGroupService");
@@ -101,5 +104,3 @@ let AccessGroupService = (() => {
     return AccessGroupService = _classThis;
 })();
 exports.AccessGroupService = AccessGroupService;
-// Accessgroup.getAccessGroup(accessGroupId)
-// GetAccessGroup()

package/dist/entities/guest/Guest.repository.d.ts

@@ -2,5 +2,5 @@ import { IGuest } from "./IGuest";
 export declare class GuestRepository {
     private readonly pmsPostgres;
     constructor();
-    getGuest(guestId: string): Promise<IGuest>;
+    getGuest(guestId: string): Promise<IGuest | null>;
 }

package/dist/entities/guest/Guest.repository.js

@@ -52,8 +52,11 @@ let GuestRepository = (() => {
         }
         async getGuest(guestId) {
             try {
-                const guest = await this.pmsPostgres.query(`SELECT * FROM dt_guests WHERE "id" = $1`, [guestId]);
-                return guest.rows[0];
+                const guest = await this.pmsPostgres.query(`SELECT * FROM dt_guest WHERE "id" = $1`, [guestId]);
+                if (guest.rows.length > 0) {
+                    return guest.rows[0];
+                }
+                return null;
             }
             catch (error) {
                 console.error("Error in getGuest:", error);

package/dist/entities/guest/Guest.service.d.ts

@@ -2,5 +2,5 @@ import { IGuest } from "./IGuest";
 export declare class GuestService {
     private readonly guestRepository;
     constructor();
-    getGuest(guestId: string): Promise<IGuest>;
+    getGuest(guestId: string): Promise<IGuest | null>;
 }

package/dist/entities/guest/Guest.service.js

@@ -88,7 +88,10 @@ let GuestService = (() => {
             if (!guestId) {
                 throw new Error("Guest ID is required");
             }
-            return await this.guestRepository.getGuest(guestId);
+            const guest = await this.guestRepository.getGuest(guestId);
+            if (!guest)
+                return null;
+            return guest;
         }
     };
     __setFunctionName(_classThis, "GuestService");

package/dist/entities/schedules/Schedule.repository.d.ts

@@ -2,5 +2,5 @@ import { ISchedule } from "./ISchedule";
 export declare class ScheduleRepository {
     private readonly pmsPostgres;
     constructor();
-    getSchedule(scheduleId: string): Promise<ISchedule>;
+    getSchedule(scheduleId: string): Promise<ISchedule | null>;
 }

package/dist/entities/schedules/Schedule.repository.js

@@ -52,8 +52,11 @@ let ScheduleRepository = (() => {
         }
         async getSchedule(scheduleId) {
             try {
-                const schedule = await this.pmsPostgres.query(`SELECT * FROM dt_schedules WHERE "id" = $1`, [scheduleId]);
-                return schedule.rows[0];
+                const schedule = await this.pmsPostgres.query(`SELECT * FROM dt_schedule WHERE "id" = $1`, [scheduleId]);
+                if (schedule.rows.length > 0) {
+                    return schedule.rows[0];
+                }
+                return null;
             }
             catch (error) {
                 console.error("Error in getSchedule:", error);

package/dist/entities/schedules/Schedule.service.d.ts

@@ -2,5 +2,5 @@ import { ISchedule } from "./ISchedule";
 export declare class ScheduleService {
     private readonly scheduleRepository;
     constructor();
-    getSchedule(scheduleId: string): Promise<ISchedule>;
+    getSchedule(scheduleId: string): Promise<ISchedule | null>;
 }

package/dist/entities/schedules/Schedule.service.js

@@ -88,7 +88,10 @@ let ScheduleService = (() => {
             if (!scheduleId) {
                 throw new Error("Schedule ID is required");
             }
-            return await this.scheduleRepository.getSchedule(scheduleId);
+            const schedule = await this.scheduleRepository.getSchedule(scheduleId);
+            if (!schedule)
+                return null;
+            return schedule;
         }
     };
     __setFunctionName(_classThis, "ScheduleService");

package/dist/entities/user/User.repository.js

@@ -52,7 +52,10 @@ let UserRepository = (() => {
         }
         async getUser(userId) {
             const user = await this.postgres.query(`SELECT * FROM dt_users WHERE "id" = $1`, [userId]);
-            return user.rows[0];
+            if (user.rows.length > 0) {
+                return user.rows[0];
+            }
+            return null;
         }
     };
     __setFunctionName(_classThis, "UserRepository");

package/dist/entities/user/User.service.d.ts

@@ -2,5 +2,5 @@ import { IUser } from "./IUser";
 export declare class UserService {
     private readonly userRepository;
     constructor();
-    getUser(userId: string): Promise<IUser>;
+    getUser(userId: string): Promise<IUser | null>;
 }

package/dist/entities/user/User.service.js

@@ -87,7 +87,10 @@ let UserService = (() => {
             if (!userId) {
                 throw new Error("User ID is required");
             }
-            return await this.userRepository.getUser(userId);
+            const user = await this.userRepository.getUser(userId);
+            if (!user)
+                return null;
+            return user;
         }
     };
     __setFunctionName(_classThis, "UserService");

package/dist/entities/zone/Zone.service.js

@@ -88,7 +88,10 @@ let ZoneService = (() => {
             if (!zoneId) {
                 throw new Error("Zone ID is required");
             }
-            return await this.zoneRepository.getZone(zoneId);
+            const zone = await this.zoneRepository.getZone(zoneId);
+            if (!zone)
+                return null;
+            return zone;
         }
     };
     __setFunctionName(_classThis, "ZoneService");

package/dist/events/DeviceEventHandler.js

@@ -90,7 +90,7 @@ let DeviceEventHandler = (() => {
                 Event_1.DT_EVENT_TYPES.DEVICE.STATUS.ONLINE,
                 Event_1.DT_EVENT_TYPES.DEVICE.STATUS.OFFLINE,
                 Event_1.DT_EVENT_TYPES.DEVICE.STATUS.UNKNOWN,
-                Event_1.DT_EVENT_TYPES.DEVICE.BATTERY.STATE.REPLACE,
+                Event_1.DT_EVENT_TYPES.DEVICE.BATTERY.REPLACED,
                 Event_1.DT_EVENT_TYPES.DEVICE.BATTERY.LEVEL.UNKNOWN,
                 Event_1.DT_EVENT_TYPES.DEVICE.BATTERY.LEVEL.LOW,
                 Event_1.DT_EVENT_TYPES.DEVICE.BATTERY.LEVEL.CRITICAL,

package/dist/issues/Issue.model.d.ts

@@ -14,7 +14,7 @@ interface IIssueModel extends Model<IIssueDocument, {}, IIssueMethods> {
     findOverdue(includeDeleted?: boolean): Promise<IIssueDocument[]>;
     findUpcoming(days?: number, includeDeleted?: boolean): Promise<IIssueDocument[]>;
 }
-declare const IssueSchema: mongoose.Schema<IIssueDocument, IIssueModel, IIssueMethods, {}, {}, {}, mongoose.DefaultSchemaOptions, IIssueDocument, mongoose.Document<unknown, {}, mongoose.FlatRecord<IIssueDocument>, {}> & Omit<mongoose.FlatRecord<IIssueDocument> & Required<{
+declare const IssueSchema: mongoose.Schema<IIssueDocument, IIssueModel, IIssueMethods, {}, {}, {}, mongoose.DefaultSchemaOptions, IIssueDocument, mongoose.Document<unknown, {}, mongoose.FlatRecord<IIssueDocument>, {}, mongoose.ResolveSchemaOptions<mongoose.DefaultSchemaOptions>> & Omit<mongoose.FlatRecord<IIssueDocument> & Required<{
     _id: string;
 }> & {
     __v: number;

package/dist/issues/Issue.service.d.ts

@@ -49,12 +49,9 @@ export declare class IssueService {
     createDeviceBatteryIssue(device: IDevice, batteryLevel: number, threshold: number, priority: IssuePriority, source: Source): Promise<IIssueDocument | null>;
     createAccountMissingDeviceIssue(device: {
         deviceId: string;
-        deviceType: {
-            type: any;
-        };
-        propertyId: string;
+        deviceType: string;
         name: string;
-    }, source: Source, reason?: string): Promise<IIssueDocument | null>;
+    }, propertyId: string, source: Source): Promise<IIssueDocument | null>;
     createAccountUnauthorizedIssue(account: {
         accountId: string;
         accountType: EntitySubType;

package/dist/issues/Issue.service.js

@@ -273,14 +273,14 @@ let IssueService = (() => {
                 type: issue_types_1.IssueType.BATTERY_LOW,
             });
         }
-        async createAccountMissingDeviceIssue(device, source, reason) {
+        async createAccountMissingDeviceIssue(device, propertyId, source) {
             return await this.createIssue({
                 entityId: device.deviceId,
                 entityType: issue_types_1.EntityType.DEVICE,
-                entitySubType: device.deviceType.type,
-                propertyId: device.propertyId,
+                entitySubType: device.deviceType,
+                propertyId: propertyId,
                 title: "Device Missing",
-                description: `${device.name} is missing from the account. ${reason ? `Reason: ${reason}.` : ""}`,
+                description: `${device.name} is missing from the account. Requires Attention.`,
                 createdBy: source,
                 category: issue_types_1.IssuesCategory.OPERATIONS,
                 priority: issue_types_1.IssuePriority.CRITICAL,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dt-common-device",
-  "version": "7.6.3",
+  "version": "7.6.5",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [

package/dist/admin/Admin.repository.d.ts

@@ -1,7 +0,0 @@
-export declare class AdminRepository {
-    private readonly axiosInstance;
-    private readonly deviceRepository;
-    private readonly postgres;
-    constructor();
-    getZonesByAccessGroupIds(accessGroupIds: string[]): Promise<any[]>;
-}