@trafficgroup/knex-rel 0.0.29 → 0.1.0

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/interfaces/video/video.interfaces.ts

@@ -16,6 +16,15 @@ export interface IVideo {
   remainingTime: string;
   results: Record<string, any>;
   durationSeconds?: number; // Add optional duration field
+
+  // HLS streaming support
+  isHlsEnabled: boolean;
+  hlsPlaylist: string | null;
+  videoSizeMB: number | null;
+
+  // Enhanced metadata for hybrid streaming
+  streamingMetadata: Record<string, any> | null;
+
   created_at: string;
   updated_at: string;
   folder?: IFolder;