@trafficgroup/knex-rel 0.1.7 → 0.1.9

package/src/dao/batch/batch.dao.ts

@@ -0,0 +1,121 @@
+import { Knex } from "knex";
+import { IBaseDAO, IDataPaginator } from "../../d.types";
+import { IBatch } from "../../interfaces/batch/batch.interfaces";
+import KnexManager from "../../KnexConnection";
+
+export class BatchDAO implements IBaseDAO<IBatch> {
+  private _knex: Knex<any, unknown[]> = KnexManager.getConnection();
+
+  async create(item: IBatch): Promise<IBatch> {
+    const [createdBatch] = await this._knex("video_batch")
+      .insert(item)
+      .returning("*");
+    return createdBatch;
+  }
+
+  async getById(id: number): Promise<IBatch | null> {
+    const batch = await this._knex("video_batch as b")
+      .innerJoin("folders as f", "b.folderId", "f.id")
+      .select("b.*", this._knex.raw("to_jsonb(f.*) as folder"))
+      .where("b.id", id)
+      .first();
+    return batch || null;
+  }
+
+  async getByUuid(uuid: string): Promise<IBatch | null> {
+    const batch = await this._knex("video_batch as b")
+      .innerJoin("folders as f", "b.folderId", "f.id")
+      .select("b.*", this._knex.raw("to_jsonb(f.*) as folder"))
+      .where("b.uuid", uuid)
+      .first();
+    return batch || null;
+  }
+
+  async update(id: number, item: Partial<IBatch>): Promise<IBatch | null> {
+    const [updatedBatch] = await this._knex("video_batch")
+      .where({ id })
+      .update(item)
+      .returning("*");
+    return updatedBatch || null;
+  }
+
+  async delete(id: number): Promise<boolean> {
+    const result = await this._knex("video_batch").where({ id }).del();
+    return result > 0;
+  }
+
+  async getAll(
+    page: number,
+    limit: number,
+    folderId?: number | null,
+  ): Promise<IDataPaginator<IBatch>> {
+    const offset = (page - 1) * limit;
+
+    const query = this._knex("video_batch as b")
+      .innerJoin("folders as f", "b.folderId", "f.id")
+      .select("b.*", this._knex.raw("to_jsonb(f.*) as folder"));
+    if (folderId !== undefined && folderId !== null) {
+      query.where("b.folderId", folderId);
+    }
+
+    const [countResult] = await query.clone().clearSelect().count("* as count");
+    const totalCount = +countResult.count;
+    const batches = await query.clone().limit(limit).offset(offset);
+
+    return {
+      success: true,
+      data: batches,
+      page,
+      limit,
+      count: batches.length,
+      totalCount,
+      totalPages: Math.ceil(totalCount / limit),
+    };
+  }
+
+  /**
+   * Get batches by folder ID
+   */
+  async getByFolderId(folderId: number): Promise<IBatch[]> {
+    return this._knex("video_batch as b")
+      .innerJoin("folders as f", "b.folderId", "f.id")
+      .select("b.*", this._knex.raw("to_jsonb(f.*) as folder"))
+      .where("b.folderId", folderId)
+      .orderBy("b.created_at", "desc");
+  }
+
+  /**
+   * Update batch progress
+   */
+  async updateProgress(
+    id: number,
+    completedVideos: number,
+    failedVideos: number,
+  ): Promise<void> {
+    await this._knex("video_batch").where({ id }).update({
+      completedVideos,
+      failedVideos,
+      updated_at: this._knex.fn.now(),
+    });
+  }
+
+  /**
+   * Mark batch as completed
+   */
+  async markCompleted(id: number): Promise<void> {
+    await this._knex("video_batch").where({ id }).update({
+      status: "COMPLETED",
+      updated_at: this._knex.fn.now(),
+    });
+  }
+
+  /**
+   * Mark batch as failed
+   */
+  async markFailed(id: number): Promise<void> {
+    await this._knex("video_batch").where({ id }).update({
+      status: "FAILED",
+      updated_at: this._knex.fn.now(),
+    });
+  }
+}

package/src/dao/camera/camera.dao.ts

@@ -1,7 +1,6 @@
 import { Knex } from "knex";
 import { IBaseDAO, IDataPaginator } from "../../d.types";
 import { ICamera } from "../../interfaces/camera/camera.interfaces";
-import { IVideo } from "../../interfaces/video/video.interfaces";
 import KnexManager from "../../KnexConnection";
 
 export class CameraDAO implements IBaseDAO<ICamera> {
@@ -55,45 +54,43 @@ export class CameraDAO implements IBaseDAO<ICamera> {
     };
   }
 
-  async getByName(name: string): Promise<ICamera | null> {
-    const camera = await this._knex("cameras").where({ name }).first();
-    return camera || null;
-  }
-
-  async getCamerasNearCoordinates(
-    longitude: number,
-    latitude: number,
-    radiusKm: number = 1,
+  /**
+   * Get cameras for a specific location
+   * @param locationId - The location ID
+   * @param status - Optional filter by camera status
+   */
+  async getCamerasByLocationId(
+    locationId: number,
+    status?: string,
   ): Promise<ICamera[]> {
-    // Using ST_DWithin for geographic distance calculation
-    // This is a PostgreSQL-specific query for geospatial operations
-    const cameras = await this._knex("cameras").whereRaw(
-      `ST_DWithin(
-                    ST_MakePoint(longitude, latitude)::geography,
-                    ST_MakePoint(?, ?)::geography,
-                    ?
-                )`,
-      [longitude, latitude, radiusKm * 1000], // Convert km to meters
-    );
-    return cameras;
+    let query = this._knex("cameras").where("locationId", locationId);
+
+    if (status) {
+      query = query.where("status", status);
+    }
+
+    return query.orderBy("name", "asc");
   }
 
   /**
-   * Get all cameras with optional search filter by name (case-insensitive partial match)
+   * Get cameras for a specific location with pagination
+   * @param locationId - The location ID
+   * @param page - Page number
+   * @param limit - Items per page
+   * @param status - Optional filter by camera status
    */
-  async getAllWithSearch(
+  async getCamerasByLocationIdPaginated(
+    locationId: number,
     page: number,
     limit: number,
-    name?: string,
+    status?: string,
   ): Promise<IDataPaginator<ICamera>> {
     const offset = (page - 1) * limit;
 
-    let query = this._knex("cameras");
+    let query = this._knex("cameras").where("locationId", locationId);
 
-    // 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}%`);
+    if (status) {
+      query = query.where("status", status);
     }
 
     const [countResult] = await query.clone().count("* as count");
@@ -116,39 +113,25 @@ export class CameraDAO implements IBaseDAO<ICamera> {
   }
 
   /**
-   * Get paginated videos for a specific camera with folder data included
+   * Check if a camera name already exists for a location
+   * @param name - Camera name
+   * @param locationId - Location ID
+   * @param excludeId - Optional camera ID to exclude (for update operations)
    */
-  async getVideosByCamera(
-    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);
-
-    // Optimized count query without JOIN
-    const [countResult] = await this._knex("video as v")
-      .where("v.cameraId", cameraId)
-      .count("* as count");
-    const totalCount = +countResult.count;
-    const videos = await query
-      .clone()
-      .limit(limit)
-      .offset(offset)
-      .orderBy("v.created_at", "desc");
+  async existsByNameAndLocation(
+    name: string,
+    locationId: number,
+    excludeId?: number,
+  ): Promise<boolean> {
+    let query = this._knex("cameras")
+      .where("locationId", locationId)
+      .where("name", name);
+
+    if (excludeId !== undefined) {
+      query = query.whereNot("id", excludeId);
+    }
 
-    return {
-      success: true,
-      data: videos,
-      page,
-      limit,
-      count: videos.length,
-      totalCount,
-      totalPages: Math.ceil(totalCount / limit),
-    };
+    const result = await query.first();
+    return result !== null && result !== undefined;
   }
 }

package/src/dao/folder/folder.dao.ts

@@ -53,7 +53,13 @@ export class FolderDAO implements IBaseDAO<IFolder> {
 
     const query = this._knex("folders as f")
       .innerJoin("study as s", "f.studyId", "s.id")
-      .select("f.*", this._knex.raw("to_jsonb(s.*) as study"));
+      .leftJoin("locations as l", "s.locationId", "l.id")
+      .select(
+        "f.*",
+        this._knex.raw("to_jsonb(s.*) as study"),
+        "l.name as locationName",
+        "l.uuid as locationUuid",
+      );
     if (studyId !== undefined && studyId !== null) {
       query.where("f.studyId", studyId);
     }

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);
     }
@@ -257,4 +263,132 @@ export class VideoDAO implements IBaseDAO<IVideo> {
 
     return rows.map((row) => row.id);
   }
+
+  /**
+   * Get videos by batch ID
+   */
+  async getByBatchId(batchId: number): Promise<IVideo[]> {
+    return 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.batchId", batchId)
+      .orderBy("v.created_at", "asc");
+  }
+
+  /**
+   * Get videos sorted chronologically by recording start time for a study
+   */
+  async getChronologicalVideos(
+    studyId: number,
+    startDate?: Date,
+    endDate?: Date,
+  ): Promise<IDataPaginator<IVideo>> {
+    let 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("f.studyId", studyId)
+      .whereNotNull("v.recordingStartedAt");
+
+    if (startDate) {
+      query = query.where("v.recordingStartedAt", ">=", startDate);
+    }
+
+    if (endDate) {
+      query = query.where("v.recordingStartedAt", "<=", endDate);
+    }
+
+    const [countResult] = await query.clone().clearSelect().count("* as count");
+    const totalCount = +countResult.count;
+    const videos = await query.clone().orderBy("v.recordingStartedAt", "asc");
+
+    return {
+      success: true,
+      data: videos,
+      page: 1,
+      limit: totalCount,
+      count: videos.length,
+      totalCount,
+      totalPages: 1,
+    };
+  }
+
+  /**
+   * Update recording start time for a video
+   */
+  async updateRecordingStartTime(
+    id: number,
+    recordingStartedAt: Date,
+  ): Promise<void> {
+    await this._knex("video").where({ id }).update({
+      recordingStartedAt,
+      updated_at: this._knex.fn.now(),
+    });
+  }
+
+  /**
+   * Update trim settings for a video
+   */
+  async updateTrimSettings(
+    id: number,
+    trimEnabled: boolean,
+    trimPeriods: { startTime: string; endTime: string }[] | null,
+  ): Promise<void> {
+    await this._knex("video")
+      .where({ id })
+      .update({
+        trimEnabled,
+        trimPeriods: trimPeriods ? JSON.stringify(trimPeriods) : null,
+        updated_at: this._knex.fn.now(),
+      });
+  }
+
+  /**
+   * Get videos with trimming enabled for a folder
+   */
+  async getVideosWithTrimming(folderId: number): Promise<IVideo[]> {
+    return 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.folderId", folderId)
+      .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

@@ -1,8 +1,10 @@
 // DAOs
 export { AuthDAO } from "./dao/auth/auth.dao";
+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";
@@ -14,6 +16,7 @@ export { VideoMinuteResultDAO } from "./dao/VideoMinuteResultDAO";
 // Interfaces
 export { IDataPaginator } from "./d.types";
 export { IAuth } from "./interfaces/auth/auth.interfaces";
+export { IBatch } from "./interfaces/batch/batch.interfaces";
 export { ICamera } from "./interfaces/camera/camera.interfaces";
 export {
   IChat,
@@ -21,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,
@@ -36,12 +40,20 @@ export {
 export { IStudy } from "./interfaces/study/study.interfaces";
 export { IUser } from "./interfaces/user/user.interfaces";
 export { IUserPushNotificationToken } from "./interfaces/user-push-notification-token/user-push-notification-token.interfaces";
-export { IVideo } from "./interfaces/video/video.interfaces";
+export { IVideo, ITrimPeriod } from "./interfaces/video/video.interfaces";
 export {
   IVideoMinuteResult,
   IVideoMinuteResultInput,
   IVideoMinuteBatch,
 } from "./entities/VideoMinuteResult";
+export type {
+  IStudyTimeGroupResult,
+  IGroupedStudyResponse,
+  IGroupedResponse,
+  IGroupedResult,
+  ITMCResult,
+  IATRResult,
+} from "./dao/VideoMinuteResultDAO";
 
 import KnexManager from "./KnexConnection";
 export { KnexManager };

package/src/interfaces/batch/batch.interfaces.ts

@@ -0,0 +1,14 @@
+import type { IFolder } from "../folder/folder.interfaces";
+
+export interface IBatch {
+  id: number;
+  uuid: string;
+  folderId: number;
+  status: "PENDING" | "IN_PROGRESS" | "COMPLETED" | "FAILED";
+  totalVideos: number;
+  completedVideos: number;
+  failedVideos: number;
+  created_at: string;
+  updated_at: string;
+  folder?: IFolder;
+}

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;
 }