@trafficgroup/knex-rel 0.1.4 → 0.1.6

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

@@ -1,6 +1,7 @@
 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> {
@@ -76,4 +77,78 @@ export class CameraDAO implements IBaseDAO<ICamera> {
     );
     return cameras;
   }
+
+  /**
+   * Get all cameras with optional search filter by name (case-insensitive partial match)
+   */
+  async getAllWithSearch(
+    page: number,
+    limit: number,
+    name?: string,
+  ): Promise<IDataPaginator<ICamera>> {
+    const offset = (page - 1) * limit;
+
+    let query = this._knex("cameras");
+
+    // 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 cameras = await query
+      .clone()
+      .limit(limit)
+      .offset(offset)
+      .orderBy("name", "asc");
+
+    return {
+      success: true,
+      data: cameras,
+      page,
+      limit,
+      count: cameras.length,
+      totalCount,
+      totalPages: Math.ceil(totalCount / limit),
+    };
+  }
+
+  /**
+   * Get paginated videos for a specific camera with folder data included
+   */
+  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");
+
+    return {
+      success: true,
+      data: videos,
+      page,
+      limit,
+      count: videos.length,
+      totalCount,
+      totalPages: Math.ceil(totalCount / limit),
+    };
+  }
 }

package/src/dao/report-configuration/report-configuration.dao.ts

@@ -200,6 +200,11 @@ export class ReportConfigurationDAO implements IBaseDAO<IReportConfiguration> {
       if (!cls.name || cls.name.length === 0) {
         errors.push(`Custom class ${idx + 1}: name cannot be empty`);
       }
+      if (cls.name && cls.name.toLowerCase() === "total") {
+        errors.push(
+          `Custom class ${idx + 1}: "Total" is a reserved name and cannot be used`,
+        );
+      }
       if (cls.name && cls.name.length > 30) {
         errors.push(`Custom class ${idx + 1}: name exceeds 30 characters`);
       }
@@ -336,6 +341,9 @@ export class ReportConfigurationDAO implements IBaseDAO<IReportConfiguration> {
       );
     }
 
+    // Add "Total" class that aggregates all custom classes
+    result["Total"] = this._createTotalClass(result);
+
     return result;
   }
 
@@ -374,6 +382,23 @@ export class ReportConfigurationDAO implements IBaseDAO<IReportConfiguration> {
     return target;
   }
 
+  /**
+   * Create "Total" vehicle class by summing all custom classes
+   * Works for both ATR and TMC formats through structure-agnostic deep merge
+   *
+   * @param customClassesData - Object with custom class names as keys
+   * @returns Aggregated nested structure summing all classes
+   */
+  private _createTotalClass(customClassesData: Record<string, any>): any {
+    let total: any = {};
+
+    for (const [className, nestedData] of Object.entries(customClassesData)) {
+      total = this._deepMergeNumericData(total, nestedData);
+    }
+
+    return total;
+  }
+
   /**
    * Get the FHWA mapping constant (for reference/debugging)
    */

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

@@ -245,4 +245,79 @@ export class VideoDAO implements IBaseDAO<IVideo> {
       throw error;
     }
   }
+
+  /**
+   * Get all video IDs for a specific folder (used for cascade operations)
+   */
+  async getVideoIdsByFolderId(folderId: number): Promise<number[]> {
+    const rows = await this._knex("video")
+      .where({ folderId })
+      .select("id")
+      .orderBy("id", "asc");
+
+    return rows.map((row) => row.id);
+  }
+
+  /**
+   * Bulk update camera assignment for multiple videos
+   * Supports optional transaction for service-level transaction management
+   */
+  async bulkUpdateCamera(
+    videoIds: number[],
+    cameraId: number | null,
+    trx?: Knex.Transaction,
+  ): Promise<number> {
+    if (!videoIds || videoIds.length === 0) {
+      return 0;
+    }
+
+    const query = trx || this._knex;
+
+    const result = await query("video")
+      .whereIn("id", videoIds)
+      .update({
+        cameraId: cameraId,
+        updated_at: query.fn.now(),
+      })
+      .returning("id");
+
+    return result.length;
+  }
+
+  /**
+   * Get videos by camera ID with folder information (paginated)
+   */
+  async getVideosByCameraIdWithFolder(
+    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");
+
+    return {
+      success: true,
+      data: videos,
+      page,
+      limit,
+      count: videos.length,
+      totalCount,
+      totalPages: Math.ceil(totalCount / limit),
+    };
+  }
 }