@trafficgroup/knex-rel 0.1.8 → 0.1.9

package/src/dao/location/location.dao.ts

@@ -0,0 +1,123 @@
+import { Knex } from "knex";
+import { IBaseDAO, IDataPaginator } from "../../d.types";
+import { ILocation } from "../../interfaces/location/location.interfaces";
+import { IVideo } from "../../interfaces/video/video.interfaces";
+import KnexManager from "../../KnexConnection";
+
+export class LocationDAO implements IBaseDAO<ILocation> {
+  private _knex: Knex<any, unknown[]> = KnexManager.getConnection();
+
+  async create(item: ILocation): Promise<ILocation> {
+    const [createdLocation] = await this._knex("locations")
+      .insert(item)
+      .returning("*");
+    return createdLocation;
+  }
+
+  async getById(id: number): Promise<ILocation | null> {
+    const location = await this._knex("locations").where({ id }).first();
+    return location || null;
+  }
+
+  async getByUuid(uuid: string): Promise<ILocation | null> {
+    const location = await this._knex("locations").where({ uuid }).first();
+    return location || null;
+  }
+
+  async update(
+    id: number,
+    item: Partial<ILocation>,
+  ): Promise<ILocation | null> {
+    const [updatedLocation] = await this._knex("locations")
+      .where({ id })
+      .update(item)
+      .returning("*");
+    return updatedLocation || null;
+  }
+
+  async delete(id: number): Promise<boolean> {
+    const result = await this._knex("locations").where({ id }).del();
+    return result > 0;
+  }
+
+  async getAll(
+    page: number,
+    limit: number,
+  ): Promise<IDataPaginator<ILocation>> {
+    const offset = (page - 1) * limit;
+
+    const [countResult] = await this._knex("locations").count("* as count");
+    const totalCount = +countResult.count;
+    const locations = await this._knex("locations").limit(limit).offset(offset);
+
+    return {
+      success: true,
+      data: locations,
+      page,
+      limit,
+      count: locations.length,
+      totalCount,
+      totalPages: Math.ceil(totalCount / limit),
+    };
+  }
+
+  async getByName(name: string): Promise<ILocation | null> {
+    const location = await this._knex("locations").where({ name }).first();
+    return location || null;
+  }
+
+  async getLocationsNearCoordinates(
+    longitude: number,
+    latitude: number,
+    radiusKm: number = 1,
+  ): Promise<ILocation[]> {
+    // Using ST_DWithin for geographic distance calculation
+    // This is a PostgreSQL-specific query for geospatial operations
+    const locations = await this._knex("locations").whereRaw(
+      `ST_DWithin(
+                    ST_MakePoint(longitude, latitude)::geography,
+                    ST_MakePoint(?, ?)::geography,
+                    ?
+                )`,
+      [longitude, latitude, radiusKm * 1000], // Convert km to meters
+    );
+    return locations;
+  }
+
+  /**
+   * Get all locations with optional search filter by name (case-insensitive partial match)
+   */
+  async getAllWithSearch(
+    page: number,
+    limit: number,
+    name?: string,
+  ): Promise<IDataPaginator<ILocation>> {
+    const offset = (page - 1) * limit;
+
+    let query = this._knex("locations");
+
+    // Apply search filter if name provided (escape special chars to prevent pattern injection)
+    if (name && name.trim().length > 0) {
+      const escapedName = name.trim().replace(/[%_\\]/g, "\\$&");
+      query = query.where("name", "ilike", `%${escapedName}%`);
+    }
+
+    const [countResult] = await query.clone().count("* as count");
+    const totalCount = +countResult.count;
+    const locations = await query
+      .clone()
+      .limit(limit)
+      .offset(offset)
+      .orderBy("name", "asc");
+
+    return {
+      success: true,
+      data: locations,
+      page,
+      limit,
+      count: locations.length,
+      totalCount,
+      totalPages: Math.ceil(totalCount / limit),
+    };
+  }
+}

package/src/dao/study/study.dao.ts

@@ -16,11 +16,11 @@ export class StudyDAO implements IBaseDAO<IStudy> {
   async getById(id: number): Promise<IStudy | null> {
     const study = await this._knex("study as s")
       .innerJoin("users as u", "s.createdBy", "u.id")
-      .leftJoin("cameras as c", "s.cameraId", "c.id")
+      .leftJoin("locations as l", "s.locationId", "l.id")
       .select(
         "s.*",
         this._knex.raw("to_jsonb(u.*) as user"),
-        this._knex.raw("to_jsonb(c.*) as camera"),
+        this._knex.raw("to_jsonb(l.*) as location"),
       )
       .where("s.id", id)
       .first();
@@ -30,11 +30,11 @@ export class StudyDAO implements IBaseDAO<IStudy> {
   async getByUuid(uuid: string): Promise<IStudy | null> {
     const study = await this._knex("study as s")
       .innerJoin("users as u", "s.createdBy", "u.id")
-      .leftJoin("cameras as c", "s.cameraId", "c.id")
+      .leftJoin("locations as l", "s.locationId", "l.id")
       .select(
         "s.*",
         this._knex.raw("to_jsonb(u.*) as user"),
-        this._knex.raw("to_jsonb(c.*) as camera"),
+        this._knex.raw("to_jsonb(l.*) as location"),
       )
       .where("s.uuid", uuid)
       .first();
@@ -63,11 +63,11 @@ export class StudyDAO implements IBaseDAO<IStudy> {
 
     const query = this._knex("study as s")
       .innerJoin("users as u", "s.createdBy", "u.id")
-      .leftJoin("cameras as c", "s.cameraId", "c.id")
+      .leftJoin("locations as l", "s.locationId", "l.id")
       .select(
         "s.*",
         this._knex.raw("to_jsonb(u.*) as user"),
-        this._knex.raw("to_jsonb(c.*) as camera"),
+        this._knex.raw("to_jsonb(l.*) as location"),
       );
     if (createdBy !== undefined && createdBy !== null) {
       query.where("s.createdBy", createdBy);
@@ -88,16 +88,16 @@ export class StudyDAO implements IBaseDAO<IStudy> {
     };
   }
 
-  async getStudiesByCamera(cameraId: number): Promise<IStudy[]> {
+  async getStudiesByLocation(locationId: number): Promise<IStudy[]> {
     const studies = await this._knex("study as s")
       .innerJoin("users as u", "s.createdBy", "u.id")
-      .leftJoin("cameras as c", "s.cameraId", "c.id")
+      .leftJoin("locations as l", "s.locationId", "l.id")
       .select(
         "s.*",
         this._knex.raw("to_jsonb(u.*) as user"),
-        this._knex.raw("to_jsonb(c.*) as camera"),
+        this._knex.raw("to_jsonb(l.*) as location"),
       )
-      .where("s.cameraId", cameraId)
+      .where("s.locationId", locationId)
       .orderBy("s.created_at", "desc")
       .limit(10);
 

package/src/dao/video/video.dao.ts

@@ -58,7 +58,13 @@ export class VideoDAO implements IBaseDAO<IVideo> {
 
     const query = this._knex("video as v")
       .innerJoin("folders as f", "v.folderId", "f.id")
-      .select("v.*", this._knex.raw("to_jsonb(f.*) as folder"));
+      .leftJoin("cameras as c", "v.cameraId", "c.id")
+      .select(
+        "v.*",
+        this._knex.raw("to_jsonb(f.*) as folder"),
+        "c.name as cameraName",
+        "c.uuid as cameraUuid",
+      );
     if (folderId !== undefined && folderId !== null) {
       query.where("v.folderId", folderId);
     }
@@ -347,4 +353,42 @@ export class VideoDAO implements IBaseDAO<IVideo> {
       .where("v.trimEnabled", true)
       .orderBy("v.recordingStartedAt", "asc");
   }
+
+  /**
+   * Get paginated videos for a specific camera
+   * @param cameraId - The camera ID
+   * @param page - Page number
+   * @param limit - Items per page
+   */
+  async getVideosByCameraId(
+    cameraId: number,
+    page: number,
+    limit: number,
+  ): Promise<IDataPaginator<IVideo>> {
+    const offset = (page - 1) * limit;
+
+    const query = this._knex("video as v")
+      .innerJoin("folders as f", "v.folderId", "f.id")
+      .select("v.*", this._knex.raw("to_jsonb(f.*) as folder"))
+      .where("v.cameraId", cameraId);
+
+    const [countResult] = await query.clone().clearSelect().count("* as count");
+    const totalCount = +countResult.count;
+
+    const videos = await query
+      .clone()
+      .limit(limit)
+      .offset(offset)
+      .orderBy("v.created_at", "desc");
+
+    return {
+      success: true,
+      data: videos,
+      page,
+      limit,
+      count: videos.length,
+      totalCount,
+      totalPages: Math.ceil(totalCount / limit),
+    };
+  }
 }

package/src/index.ts

@@ -4,6 +4,7 @@ export { BatchDAO } from "./dao/batch/batch.dao";
 export { CameraDAO } from "./dao/camera/camera.dao";
 export { ChatDAO } from "./dao/chat/chat.dao";
 export { FolderDAO } from "./dao/folder/folder.dao";
+export { LocationDAO } from "./dao/location/location.dao";
 export { MessageDAO } from "./dao/message/message.dao";
 export { ReportConfigurationDAO } from "./dao/report-configuration/report-configuration.dao";
 export { StudyDAO } from "./dao/study/study.dao";
@@ -23,6 +24,7 @@ export {
   IChatUpdate,
 } from "./interfaces/chat/chat.interfaces";
 export { IFolder } from "./interfaces/folder/folder.interfaces";
+export { ILocation } from "./interfaces/location/location.interfaces";
 export {
   IMessage,
   IMessageCreate,

package/src/interfaces/camera/camera.interfaces.ts

@@ -1,9 +1,11 @@
 export interface ICamera {
   id: number;
   uuid: string;
+  locationId: number;
   name: string;
-  longitude: number;
-  latitude: number;
+  description?: string;
+  status: "ACTIVE" | "INACTIVE" | "MAINTENANCE";
+  metadata: Record<string, any>;
   created_at: string;
   updated_at: string;
 }

package/src/interfaces/location/location.interfaces.ts

@@ -0,0 +1,9 @@
+export interface ILocation {
+  id: number;
+  uuid: string;
+  name: string;
+  longitude: number;
+  latitude: number;
+  created_at: string;
+  updated_at: string;
+}

package/src/interfaces/study/study.interfaces.ts

@@ -1,5 +1,5 @@
 import type { IUser } from "../user/user.interfaces";
-import type { ICamera } from "../camera/camera.interfaces";
+import type { ILocation } from "../location/location.interfaces";
 
 export interface IStudy {
   id: number;
@@ -8,10 +8,11 @@ export interface IStudy {
   description?: string;
   type: "TMC" | "ATR";
   createdBy: number;
-  cameraId?: number;
+  locationId?: number;
+  isMultiCamera: boolean;
   status: "COMPLETE" | "IN PROGRESS" | "FAILED";
   created_at: string;
   updated_at: string;
   user?: IUser;
-  camera?: ICamera;
+  location?: ILocation;
 }

package/src/interfaces/video/video.interfaces.ts

@@ -10,6 +10,7 @@ export interface IVideo {
   uuid: string;
   folderId: number;
   annotationSourceId?: number;
+  cameraId?: number;
   name: string;
   videoLocation: string;
   videoOutputLocation: string | null;