@trafficgroup/knex-rel 0.0.29 → 0.1.1

package/src/dao/VideoMinuteResultDAO.ts

@@ -6,6 +6,68 @@ import {
 } from "../entities/VideoMinuteResult";
 import KnexManager from "../KnexConnection";
 
+// Type definitions for aggregated results
+interface ITMCTurnMovements {
+  straight: number;
+  left: number;
+  right: number;
+  "u-turn": number;
+  [key: string]: number; // Allow dynamic turn types
+}
+
+interface ITMCDirections {
+  [direction: string]: ITMCTurnMovements;
+}
+
+interface ITMCVehicles {
+  [vehicleClass: string]: ITMCDirections;
+}
+
+interface ITMCResult {
+  vehicles: ITMCVehicles;
+  counts: {
+    total_vehicles: number;
+    entry_vehicles: number;
+  };
+  total: number;
+  totalcount: number;
+  detected_classes: { [vehicleClass: string]: number };
+  study_type: "TMC";
+}
+
+interface IATRVehicles {
+  [vehicleClass: string]: { [lane: string]: number };
+}
+
+interface IATRResult {
+  vehicles: IATRVehicles;
+  lane_counts: { [lane: string]: number };
+  total_count: number;
+  detected_classes: { [vehicleClass: string]: number };
+  study_type: "ATR";
+}
+
+interface IGroupedResult {
+  groupIndex: number;
+  startMinute: number;
+  endMinute: number;
+  label: string;
+  results: ITMCResult | IATRResult;
+  minuteCount: number;
+}
+
+interface IGroupedResponse {
+  success: boolean;
+  data: IGroupedResult[];
+  groupingMinutes: number;
+  video: {
+    uuid: string;
+    name: string;
+    videoType: string;
+    status: string;
+  };
+}
+
 export class VideoMinuteResultDAO implements IBaseDAO<IVideoMinuteResult> {
   private knex = KnexManager.getConnection();
   private tableName = "video_minute_results";
@@ -268,6 +330,461 @@ export class VideoMinuteResultDAO implements IBaseDAO<IVideoMinuteResult> {
       totalPages: Math.ceil(totalCount / limit),
     };
   }
+
+  /**
+   * Get grouped minute results by video UUID with time block aggregation
+   * @param videoUuid - The UUID of the video
+   * @param groupingMinutes - Number of minutes to group together (1, 5, 10, 15, 30, 60)
+   * @param startMinute - Optional start minute filter
+   * @param endMinute - Optional end minute filter
+   */
+  async getGroupedMinuteResultsByVideoUuid(
+    videoUuid: string,
+    groupingMinutes: number = 1,
+    startMinute?: number,
+    endMinute?: number,
+  ): Promise<IGroupedResponse> {
+    // First, get the video to ensure it exists and get metadata
+    const video = await this.knex("video").where("uuid", videoUuid).first();
+
+    if (!video) {
+      throw new Error(`Video with UUID ${videoUuid} not found`);
+    }
+
+    // Build the base query for minute results
+    const query = this.knex(this.tableName + " as vmr").where(
+      "vmr.video_id",
+      video.id,
+    );
+
+    if (startMinute !== undefined) {
+      query.where("vmr.minute_number", ">=", startMinute);
+    }
+
+    if (endMinute !== undefined) {
+      query.where("vmr.minute_number", "<=", endMinute);
+    }
+
+    // If grouping is 1 minute, just return the regular results
+    if (groupingMinutes === 1) {
+      const data = await query
+        .select("vmr.*")
+        .orderBy("vmr.minute_number", "asc");
+
+      return {
+        success: true,
+        data: data.map((row) => ({
+          groupIndex: row.minute_number,
+          startMinute: row.minute_number,
+          endMinute: row.minute_number,
+          label: this.formatTimeLabel(row.minute_number, row.minute_number),
+          results: row.results,
+          minuteCount: 1,
+        })),
+        groupingMinutes,
+        video: {
+          uuid: video.uuid,
+          name: video.name,
+          videoType: video.videoType,
+          status: video.status,
+        },
+      };
+    }
+
+    // Use Knex query builder for safe parameter binding
+    const groupingQuery = this.knex(this.tableName)
+      .select(
+        this.knex.raw("FLOOR(minute_number / ?) as group_index", [
+          groupingMinutes,
+        ]),
+        this.knex.raw("MIN(minute_number) as start_minute"),
+        this.knex.raw("MAX(minute_number) as end_minute"),
+        this.knex.raw("COUNT(*) as minute_count"),
+        this.knex.raw(
+          "array_agg(results ORDER BY minute_number) as all_results",
+        ),
+      )
+      .where("video_id", video.id);
+
+    if (startMinute !== undefined) {
+      groupingQuery.where("minute_number", ">=", startMinute);
+    }
+
+    if (endMinute !== undefined) {
+      groupingQuery.where("minute_number", "<=", endMinute);
+    }
+
+    const rows = await groupingQuery
+      .groupBy("group_index")
+      .orderBy("group_index");
+
+    // Aggregate the results in TypeScript based on video type
+    const aggregatedGroups: IGroupedResult[] = rows.map((row: any) => {
+      if (!row || typeof row !== "object") {
+        throw new Error("Invalid row data received from database query");
+      }
+
+      const allResults = Array.isArray(row.all_results) ? row.all_results : [];
+
+      // Determine video type based on multiple factors
+      let studyType = video.videoType || "ATR"; // Default fallback to ATR
+
+      // Check if minute data has study_type field (ATR usually does)
+      if (allResults.length > 0 && allResults[0].study_type) {
+        studyType = allResults[0].study_type;
+      } else if (allResults.length > 0) {
+        // Check data structure to determine type
+        const sampleResult = allResults[0];
+        if (sampleResult.vehicles) {
+          // Check if vehicles structure has directions (NORTH, SOUTH, etc.) - TMC pattern
+          const vehicleKeys = Object.keys(sampleResult.vehicles);
+          if (vehicleKeys.length > 0) {
+            const firstVehicleType = sampleResult.vehicles[vehicleKeys[0]];
+            if (firstVehicleType && typeof firstVehicleType === "object") {
+              const directions = Object.keys(firstVehicleType);
+              if (
+                directions.includes("NORTH") ||
+                directions.includes("SOUTH") ||
+                directions.includes("EAST") ||
+                directions.includes("WEST")
+              ) {
+                studyType = "TMC";
+              }
+            }
+          }
+        }
+      }
+
+      // Aggregate based on determined video type
+      let aggregatedResult;
+      if (studyType === "TMC") {
+        aggregatedResult = this.aggregateTMCResults(allResults);
+      } else {
+        aggregatedResult = this.aggregateATRResults(allResults);
+      }
+
+      return {
+        groupIndex: row.group_index,
+        startMinute: row.start_minute,
+        endMinute: row.end_minute,
+        label: this.formatTimeLabel(row.start_minute, row.end_minute),
+        results: aggregatedResult,
+        minuteCount: row.minute_count,
+      };
+    });
+
+    return {
+      success: true,
+      data: aggregatedGroups,
+      groupingMinutes,
+      video: {
+        uuid: video.uuid,
+        name: video.name,
+        videoType: video.videoType,
+        status: video.status,
+      },
+    };
+  }
+
+  /**
+   * Aggregate minute results based on video type (TMC or ATR)
+   */
+  private aggregateMinuteResults(minutes: any[], videoType: string): any {
+    if (minutes.length === 0) return {};
+
+    // Initialize the aggregated result structure based on the first minute
+    const firstMinuteResults = minutes[0].results;
+    const aggregated = this.deepCloneStructure(firstMinuteResults);
+
+    // For TMC videos, aggregate turning movements
+    if (videoType === "TMC") {
+      return this.aggregateTMCResults(minutes);
+    }
+
+    // For ATR videos, aggregate lane counts
+    if (videoType === "ATR" || videoType === "ATP") {
+      return this.aggregateATRResults(minutes);
+    }
+
+    // Default aggregation for other types
+    return this.aggregateGenericResults(minutes);
+  }
+
+  /**
+   * Aggregate TMC (Turning Movement Count) results
+   */
+  private aggregateTMCResults(minutes: any[]): ITMCResult {
+    const aggregated: ITMCResult = {
+      vehicles: {},
+      counts: {
+        total_vehicles: 0,
+        entry_vehicles: 0,
+      },
+      total: 0,
+      totalcount: 0,
+      detected_classes: {},
+      study_type: "TMC",
+    };
+
+    for (const minute of minutes) {
+      const results = minute; // minute is already the results object from array_agg
+
+      // Aggregate vehicle movements by class and direction
+      if (results.vehicles && typeof results.vehicles === "object") {
+        for (const [vehicleClass, directions] of Object.entries(
+          results.vehicles,
+        )) {
+          // Skip the 'total' pseudo vehicle class - validate it's actually aggregate data
+          if (vehicleClass === "total" && typeof directions === "number") {
+            continue; // This is aggregate total data, not a vehicle class
+          }
+
+          if (!aggregated.vehicles[vehicleClass]) {
+            aggregated.vehicles[vehicleClass] = {};
+          }
+
+          if (!aggregated.detected_classes[vehicleClass]) {
+            aggregated.detected_classes[vehicleClass] = 0;
+          }
+
+          for (const [direction, turns] of Object.entries(directions as any)) {
+            if (!aggregated.vehicles[vehicleClass][direction]) {
+              aggregated.vehicles[vehicleClass][direction] = {
+                straight: 0,
+                left: 0,
+                right: 0,
+                "u-turn": 0,
+              };
+            }
+
+            if (typeof turns === "object" && turns !== null) {
+              for (const [turnType, count] of Object.entries(turns)) {
+                const turnCount = (count as number) || 0;
+                aggregated.vehicles[vehicleClass][direction][turnType] =
+                  (aggregated.vehicles[vehicleClass][direction][turnType] ||
+                    0) + turnCount;
+
+                // Add to detected_classes count for this vehicle type
+                aggregated.detected_classes[vehicleClass] += turnCount;
+
+                // Add to total counts
+                aggregated.total += turnCount;
+                aggregated.totalcount += turnCount;
+              }
+            }
+          }
+        }
+
+        // Also process the 'total' entry for validation but don't count it as a vehicle class
+        if (results.vehicles.total) {
+          for (const [direction, turns] of Object.entries(
+            results.vehicles.total as any,
+          )) {
+            if (typeof turns === "object" && turns !== null) {
+              for (const [turnType, count] of Object.entries(turns)) {
+                const turnCount = (count as number) || 0;
+                aggregated.counts.total_vehicles += turnCount;
+              }
+            }
+          }
+        }
+      }
+    }
+
+    // Set entry_vehicles same as total_vehicles for TMC
+    aggregated.counts.entry_vehicles =
+      aggregated.counts.total_vehicles || aggregated.total;
+
+    return aggregated;
+  }
+
+  /**
+   * Aggregate ATR (Automatic Traffic Recorder) results
+   */
+  private aggregateATRResults(minutes: any[]): IATRResult {
+    const aggregated: IATRResult = {
+      vehicles: {},
+      lane_counts: {},
+      total_count: 0,
+      detected_classes: {},
+      study_type: "ATR",
+    };
+
+    for (const minute of minutes) {
+      const results = minute; // minute is already the results object from array_agg
+
+      // Aggregate vehicle counts by class and lane
+      if (results.vehicles) {
+        for (const [rawVehicleClass, lanes] of Object.entries(
+          results.vehicles,
+        )) {
+          // Normalize vehicle class names to standard format for frontend compatibility
+          const vehicleClass = this.normalizeATRVehicleClass(rawVehicleClass);
+
+          if (!aggregated.vehicles[vehicleClass]) {
+            aggregated.vehicles[vehicleClass] = {};
+          }
+
+          for (const [laneId, count] of Object.entries(lanes as any)) {
+            const numericCount =
+              typeof count === "number" ? count : parseInt(String(count)) || 0;
+            aggregated.vehicles[vehicleClass][laneId] =
+              (aggregated.vehicles[vehicleClass][laneId] || 0) + numericCount;
+          }
+        }
+      }
+
+      // Aggregate lane counts
+      if (results.lane_counts) {
+        for (const [laneId, count] of Object.entries(results.lane_counts)) {
+          aggregated.lane_counts[laneId] =
+            (aggregated.lane_counts[laneId] || 0) + ((count as number) || 0);
+        }
+      }
+
+      // Aggregate total count
+      aggregated.total_count += results.total_count || 0;
+
+      // Aggregate detected classes with normalized names
+      if (results.detected_classes) {
+        for (const [rawCls, count] of Object.entries(
+          results.detected_classes,
+        )) {
+          const cls = this.normalizeATRVehicleClass(rawCls);
+          aggregated.detected_classes[cls] =
+            (aggregated.detected_classes[cls] || 0) + ((count as number) || 0);
+        }
+      }
+    }
+
+    return aggregated;
+  }
+
+  /**
+   * Generic aggregation for other video types
+   */
+  private aggregateGenericResults(minutes: any[]): any {
+    if (minutes.length === 0) return {};
+
+    // For generic aggregation, sum all numeric values
+    const aggregated = JSON.parse(JSON.stringify(minutes[0].results));
+
+    for (let i = 1; i < minutes.length; i++) {
+      this.sumNumericValues(aggregated, minutes[i].results);
+    }
+
+    return aggregated;
+  }
+
+  /**
+   * Recursively sum numeric values in nested objects
+   */
+  private sumNumericValues(target: any, source: any): void {
+    for (const key in source) {
+      if (typeof source[key] === "number") {
+        target[key] = (target[key] || 0) + source[key];
+      } else if (
+        typeof source[key] === "object" &&
+        source[key] !== null &&
+        !Array.isArray(source[key])
+      ) {
+        if (!target[key]) {
+          target[key] = {};
+        }
+        this.sumNumericValues(target[key], source[key]);
+      }
+    }
+  }
+
+  /**
+   * Deep clone a result structure, setting all numeric values to 0
+   */
+  private deepCloneStructure(obj: any): any {
+    if (typeof obj !== "object" || obj === null) {
+      return typeof obj === "number" ? 0 : obj;
+    }
+
+    if (Array.isArray(obj)) {
+      return obj.map((item) => this.deepCloneStructure(item));
+    }
+
+    const cloned: any = {};
+    for (const key in obj) {
+      cloned[key] = this.deepCloneStructure(obj[key]);
+    }
+    return cloned;
+  }
+
+  /**
+   * Normalize ATR vehicle class names to standard format for frontend compatibility
+   */
+  private normalizeATRVehicleClass(rawVehicleClass: string): string {
+    const normalized = rawVehicleClass.toLowerCase().replace(/[_\s-]/g, "");
+
+    // Map raw vehicle classes to standard classes
+    if (
+      normalized.includes("car") ||
+      normalized === "vehicle" ||
+      normalized === "automobiles"
+    ) {
+      return "cars";
+    }
+    if (
+      normalized.includes("medium") ||
+      normalized.includes("pickup") ||
+      (normalized.includes("truck") && !normalized.includes("heavy"))
+    ) {
+      return "mediums";
+    }
+    if (
+      normalized.includes("heavy") ||
+      normalized.includes("largetruck") ||
+      normalized.includes("bigtruck")
+    ) {
+      return "heavy_trucks";
+    }
+    if (
+      normalized.includes("pedestrian") ||
+      normalized.includes("person") ||
+      normalized.includes("people")
+    ) {
+      return "pedestrians";
+    }
+    if (
+      normalized.includes("bicycle") ||
+      normalized.includes("bike") ||
+      normalized.includes("cyclist")
+    ) {
+      return "bicycles";
+    }
+    if (normalized.includes("total") || normalized.includes("all")) {
+      return "total";
+    }
+
+    // Handle specific known ATR classes
+    if (rawVehicleClass === "mediums") return "mediums";
+    if (rawVehicleClass === "heavy_trucks") return "heavy_trucks";
+
+    // Default fallback for unknown classes
+    return "cars";
+  }
+
+  /**
+   * Format time label for display (HH:MM:SS format)
+   */
+  private formatTimeLabel(startMinute: number, endMinute: number): string {
+    const formatMinute = (min: number): string => {
+      const hours = Math.floor(min / 60);
+      const minutes = min % 60;
+      return `${hours.toString().padStart(2, "0")}:${minutes.toString().padStart(2, "0")}`;
+    };
+
+    if (startMinute === endMinute) {
+      return `${formatMinute(startMinute)}:00 - ${formatMinute(startMinute)}:59`;
+    }
+
+    return `${formatMinute(startMinute)}:00 - ${formatMinute(endMinute)}:59`;
+  }
 }
 
 export default VideoMinuteResultDAO;

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

@@ -0,0 +1,79 @@
+import { Knex } from "knex";
+import { IBaseDAO, IDataPaginator } from "../../d.types";
+import { ICamera } from "../../interfaces/camera/camera.interfaces";
+import KnexManager from "../../KnexConnection";
+
+export class CameraDAO implements IBaseDAO<ICamera> {
+  private _knex: Knex<any, unknown[]> = KnexManager.getConnection();
+
+  async create(item: ICamera): Promise<ICamera> {
+    const [createdCamera] = await this._knex("cameras")
+      .insert(item)
+      .returning("*");
+    return createdCamera;
+  }
+
+  async getById(id: number): Promise<ICamera | null> {
+    const camera = await this._knex("cameras").where({ id }).first();
+    return camera || null;
+  }
+
+  async getByUuid(uuid: string): Promise<ICamera | null> {
+    const camera = await this._knex("cameras").where({ uuid }).first();
+    return camera || null;
+  }
+
+  async update(id: number, item: Partial<ICamera>): Promise<ICamera | null> {
+    const [updatedCamera] = await this._knex("cameras")
+      .where({ id })
+      .update(item)
+      .returning("*");
+    return updatedCamera || null;
+  }
+
+  async delete(id: number): Promise<boolean> {
+    const result = await this._knex("cameras").where({ id }).del();
+    return result > 0;
+  }
+
+  async getAll(page: number, limit: number): Promise<IDataPaginator<ICamera>> {
+    const offset = (page - 1) * limit;
+
+    const [countResult] = await this._knex("cameras").count("* as count");
+    const totalCount = +countResult.count;
+    const cameras = await this._knex("cameras").limit(limit).offset(offset);
+
+    return {
+      success: true,
+      data: cameras,
+      page,
+      limit,
+      count: cameras.length,
+      totalCount,
+      totalPages: Math.ceil(totalCount / limit),
+    };
+  }
+
+  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,
+  ): 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;
+  }
+}

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

@@ -196,4 +196,53 @@ export class VideoDAO implements IBaseDAO<IVideo> {
       totalPages: Math.ceil(totalCount / limit),
     };
   }
+
+  /**
+   * Get videos from same folder with same type that have metadata and are COMPLETED
+   * Suitable for use as lane annotation templates
+   */
+  async getTemplateVideos(
+    folderId: number,
+    videoType: string,
+  ): Promise<IVideo[]> {
+    try {
+      let query = this._knex("video")
+        .where("folderId", folderId)
+        .where("videoType", videoType)
+        .where("status", "COMPLETED")
+        .whereNotNull("metadata")
+        .whereRaw("metadata != '{}'");
+
+      // Apply video type specific metadata validation
+      if (videoType === "ATR") {
+        // ATR videos use lanes array structure
+        query = query.whereRaw("jsonb_array_length(metadata->'lanes') > 0");
+      } else {
+        // TMC/JUNCTION/ROUNDABOUT/PATHWAY videos use objects with pt1/pt2 structure
+        // Check if metadata has at least one key with pt1 and pt2 properties
+        query = query.whereRaw(`
+                    EXISTS (
+                        SELECT 1 
+                        FROM jsonb_each(metadata) as entry(key, value)
+                        WHERE key != 'lanes' 
+                        AND key != 'finish_line'
+                        AND jsonb_typeof(value) = 'object'
+                        AND value ? 'pt1' 
+                        AND value ? 'pt2'
+                        AND jsonb_typeof(value->'pt1') = 'array'
+                        AND jsonb_typeof(value->'pt2') = 'array'
+                        AND jsonb_array_length(value->'pt1') = 2
+                        AND jsonb_array_length(value->'pt2') = 2
+                    )
+                `);
+      }
+
+      const videos = await query.orderBy("updated_at", "desc").select("*");
+
+      return videos;
+    } catch (error) {
+      console.error("Error fetching template videos:", error);
+      throw error;
+    }
+  }
 }

package/src/index.ts

@@ -1,32 +1,34 @@
 // DAOs
-export { UserDAO } from "./dao/user/user.dao";
-export { StudyDAO } from "./dao/study/study.dao";
-export { FolderDAO } from "./dao/folder/folder.dao";
-export { VideoDAO } from "./dao/video/video.dao";
 export { AuthDAO } from "./dao/auth/auth.dao";
-export { UserPushNotificationTokenDAO } from "./dao/user-push-notification-token/user-push-notification-token.dao";
+export { CameraDAO } from "./dao/camera/camera.dao";
 export { ChatDAO } from "./dao/chat/chat.dao";
+export { FolderDAO } from "./dao/folder/folder.dao";
 export { MessageDAO } from "./dao/message/message.dao";
+export { StudyDAO } from "./dao/study/study.dao";
+export { UserDAO } from "./dao/user/user.dao";
+export { UserPushNotificationTokenDAO } from "./dao/user-push-notification-token/user-push-notification-token.dao";
+export { VideoDAO } from "./dao/video/video.dao";
 export { VideoMinuteResultDAO } from "./dao/VideoMinuteResultDAO";
 
 // Interfaces
 export { IDataPaginator } from "./d.types";
-export { IUser } from "./interfaces/user/user.interfaces";
-export { IStudy } from "./interfaces/study/study.interfaces";
-export { IFolder } from "./interfaces/folder/folder.interfaces";
-export { IVideo } from "./interfaces/video/video.interfaces";
 export { IAuth } from "./interfaces/auth/auth.interfaces";
-export { IUserPushNotificationToken } from "./interfaces/user-push-notification-token/user-push-notification-token.interfaces";
+export { ICamera } from "./interfaces/camera/camera.interfaces";
 export {
   IChat,
   IChatCreate,
   IChatUpdate,
 } from "./interfaces/chat/chat.interfaces";
+export { IFolder } from "./interfaces/folder/folder.interfaces";
 export {
   IMessage,
   IMessageCreate,
   IMessageUpdate,
 } from "./interfaces/message/message.interfaces";
+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 {
   IVideoMinuteResult,
   IVideoMinuteResultInput,