@trafficgroup/knex-rel 0.1.6 → 0.1.8

package/src/dao/VideoMinuteResultDAO.ts

@@ -68,6 +68,33 @@ interface IGroupedResponse {
   };
 }
 
+interface IStudyTimeGroupResult {
+  absoluteTime: string; // ISO 8601 start of bucket
+  groupIndex: number;
+  label: string; // Formatted label
+  results: ITMCResult | IATRResult;
+  minuteCount: number;
+  videoCount: number;
+  contributingVideos: string[]; // Video UUIDs
+}
+
+interface IGroupedStudyResponse {
+  success: boolean;
+  data: IStudyTimeGroupResult[];
+  groupingMinutes: number;
+  study: {
+    uuid: string;
+    name: string;
+    type: "TMC" | "ATR";
+    status: string;
+  };
+  videoCount: number;
+  dateRange: {
+    earliest: string;
+    latest: string;
+  };
+}
+
 export class VideoMinuteResultDAO implements IBaseDAO<IVideoMinuteResult> {
   private knex = KnexManager.getConnection();
   private tableName = "video_minute_results";
@@ -486,6 +513,182 @@ export class VideoMinuteResultDAO implements IBaseDAO<IVideoMinuteResult> {
     };
   }
 
+  /**
+   * Get grouped minute results by study UUID with time block aggregation across all videos
+   * @param studyUuid - The UUID of the study
+   * @param groupingMinutes - Number of minutes to group together (default: 15)
+   */
+  async getGroupedMinuteResultsByStudyUuid(
+    studyUuid: string,
+    groupingMinutes: number = 15,
+  ): Promise<IGroupedStudyResponse> {
+    // Step 1: Fetch study and validate
+    const study = await this.knex("study").where("uuid", studyUuid).first();
+
+    if (!study) {
+      throw new Error(`Study with UUID ${studyUuid} not found`);
+    }
+
+    // Step 2: Fetch all COMPLETED videos in the study with recordingStartedAt
+    const videos = await this.knex("video as v")
+      .innerJoin("folders as f", "v.folderId", "f.id")
+      .select("v.id", "v.uuid", "v.name", "v.recordingStartedAt", "v.videoType")
+      .where("f.studyId", study.id)
+      .where("v.status", "COMPLETED")
+      .whereNotNull("v.recordingStartedAt")
+      .orderBy("v.recordingStartedAt", "asc");
+
+    // If no completed videos with recordingStartedAt, return empty result
+    if (videos.length === 0) {
+      return {
+        success: true,
+        data: [],
+        groupingMinutes,
+        study: {
+          uuid: study.uuid,
+          name: study.name,
+          type: study.type,
+          status: study.status,
+        },
+        videoCount: 0,
+        dateRange: {
+          earliest: "",
+          latest: "",
+        },
+      };
+    }
+
+    // Get video IDs for minute results query
+    const videoIds = videos.map((v) => v.id);
+
+    // Calculate date range
+    const earliestVideo = videos[0];
+    const latestVideo = videos[videos.length - 1];
+    const earliestTime = new Date(earliestVideo.recordingStartedAt);
+
+    // Step 3: Fetch and normalize all minute results with absolute times
+    const minuteResults = await this.knex("video_minute_results as vmr")
+      .innerJoin("video as v", "vmr.video_id", "v.id")
+      .select(
+        "vmr.minute_number",
+        "vmr.results",
+        "v.uuid as videoUuid",
+        "v.recordingStartedAt",
+        this.knex.raw(
+          '"v"."recordingStartedAt" + (vmr.minute_number || \' minutes\')::INTERVAL as "absoluteTime"',
+        ),
+      )
+      .whereIn("v.id", videoIds)
+      .orderBy("absoluteTime", "asc");
+
+    // If no minute results found, return empty result
+    if (minuteResults.length === 0) {
+      return {
+        success: true,
+        data: [],
+        groupingMinutes,
+        study: {
+          uuid: study.uuid,
+          name: study.name,
+          type: study.type,
+          status: study.status,
+        },
+        videoCount: videos.length,
+        dateRange: {
+          earliest: earliestVideo.recordingStartedAt.toISOString(),
+          latest: latestVideo.recordingStartedAt.toISOString(),
+        },
+      };
+    }
+
+    // Step 4: Group by time buckets in TypeScript
+    interface IBucket {
+      groupIndex: number;
+      absoluteTime: Date;
+      results: any[];
+      videoUuids: Set<string>;
+    }
+
+    const buckets = new Map<number, IBucket>();
+
+    for (const minute of minuteResults) {
+      const absoluteTime = new Date(minute.absoluteTime);
+      const minutesSinceEarliest = Math.floor(
+        (absoluteTime.getTime() - earliestTime.getTime()) / (1000 * 60),
+      );
+      const bucketIndex = Math.floor(minutesSinceEarliest / groupingMinutes);
+
+      if (!buckets.has(bucketIndex)) {
+        // Calculate bucket start time
+        const bucketStartMinutes = bucketIndex * groupingMinutes;
+        const bucketStartTime = new Date(
+          earliestTime.getTime() + bucketStartMinutes * 60 * 1000,
+        );
+
+        buckets.set(bucketIndex, {
+          groupIndex: bucketIndex,
+          absoluteTime: bucketStartTime,
+          results: [],
+          videoUuids: new Set<string>(),
+        });
+      }
+
+      const bucket = buckets.get(bucketIndex)!;
+      bucket.results.push(minute.results);
+      bucket.videoUuids.add(minute.videoUuid);
+    }
+
+    // Step 5: Aggregate using existing methods based on study type
+    const aggregatedGroups: IStudyTimeGroupResult[] = Array.from(
+      buckets.values(),
+    )
+      .sort((a, b) => a.groupIndex - b.groupIndex)
+      .map((bucket) => {
+        let aggregatedResult: ITMCResult | IATRResult;
+
+        if (study.type === "TMC") {
+          aggregatedResult = this.aggregateTMCResults(bucket.results);
+        } else {
+          aggregatedResult = this.aggregateATRResults(bucket.results);
+        }
+
+        return {
+          absoluteTime: bucket.absoluteTime.toISOString(),
+          groupIndex: bucket.groupIndex,
+          label: this.formatStudyTimeLabel(
+            bucket.absoluteTime,
+            groupingMinutes,
+          ),
+          results: aggregatedResult,
+          minuteCount: bucket.results.length,
+          videoCount: bucket.videoUuids.size,
+          contributingVideos: Array.from(bucket.videoUuids),
+        };
+      });
+
+    // Calculate latest time from last minute result
+    const lastMinute = minuteResults[minuteResults.length - 1];
+    const latestTime = new Date(lastMinute.absoluteTime);
+
+    // Step 6: Format response
+    return {
+      success: true,
+      data: aggregatedGroups,
+      groupingMinutes,
+      study: {
+        uuid: study.uuid,
+        name: study.name,
+        type: study.type,
+        status: study.status,
+      },
+      videoCount: videos.length,
+      dateRange: {
+        earliest: earliestTime.toISOString(),
+        latest: latestTime.toISOString(),
+      },
+    };
+  }
+
   /**
    * Aggregate minute results based on video type (TMC or ATR)
    */
@@ -728,6 +931,35 @@ export class VideoMinuteResultDAO implements IBaseDAO<IVideoMinuteResult> {
 
     return `${formatMinute(startMinute)}:00 - ${formatMinute(endMinute)}:59`;
   }
+
+  /**
+   * Format time label for study-level results (time only, no dates)
+   * Used when results are already grouped by date in the UI
+   */
+  private formatStudyTimeLabel(
+    startTime: Date,
+    durationMinutes: number,
+  ): string {
+    const endTime = new Date(startTime.getTime() + durationMinutes * 60 * 1000);
+
+    const formatTime = (date: Date): string => {
+      const hours = date.getHours().toString().padStart(2, "0");
+      const minutes = date.getMinutes().toString().padStart(2, "0");
+      return `${hours}:${minutes}`;
+    };
+
+    return `${formatTime(startTime)} - ${formatTime(endTime)}`;
+  }
 }
 
+// Export interfaces for external use
+export type {
+  IStudyTimeGroupResult,
+  IGroupedStudyResponse,
+  IGroupedResponse,
+  IGroupedResult,
+  ITMCResult,
+  IATRResult,
+};
+
 export default VideoMinuteResultDAO;

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/folder/folder.dao.ts

@@ -16,12 +16,7 @@ export class FolderDAO implements IBaseDAO<IFolder> {
   async getById(id: number): Promise<IFolder | null> {
     const folder = await this._knex("folders as f")
       .innerJoin("study as s", "f.studyId", "s.id")
-      .leftJoin("cameras as c", "f.cameraId", "c.id")
-      .select(
-        "f.*",
-        this._knex.raw("to_jsonb(s.*) as study"),
-        this._knex.raw("to_jsonb(c.*) as camera"),
-      )
+      .select("f.*", this._knex.raw("to_jsonb(s.*) as study"))
       .where("f.id", id)
       .first();
     return folder || null;
@@ -30,12 +25,7 @@ export class FolderDAO implements IBaseDAO<IFolder> {
   async getByUuid(uuid: string): Promise<IFolder | null> {
     const folder = await this._knex("folders as f")
       .innerJoin("study as s", "f.studyId", "s.id")
-      .leftJoin("cameras as c", "f.cameraId", "c.id")
-      .select(
-        "f.*",
-        this._knex.raw("to_jsonb(s.*) as study"),
-        this._knex.raw("to_jsonb(c.*) as camera"),
-      )
+      .select("f.*", this._knex.raw("to_jsonb(s.*) as study"))
       .where("f.uuid", uuid)
       .first();
     return folder || null;
@@ -63,12 +53,7 @@ export class FolderDAO implements IBaseDAO<IFolder> {
 
     const query = this._knex("folders as f")
       .innerJoin("study as s", "f.studyId", "s.id")
-      .leftJoin("cameras as c", "f.cameraId", "c.id")
-      .select(
-        "f.*",
-        this._knex.raw("to_jsonb(s.*) as study"),
-        this._knex.raw("to_jsonb(c.*) as camera"),
-      );
+      .select("f.*", this._knex.raw("to_jsonb(s.*) as study"));
     if (studyId !== undefined && studyId !== null) {
       query.where("f.studyId", studyId);
     }

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

@@ -16,7 +16,12 @@ 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")
-      .select("s.*", this._knex.raw("to_jsonb(u.*) as user"))
+      .leftJoin("cameras as c", "s.cameraId", "c.id")
+      .select(
+        "s.*",
+        this._knex.raw("to_jsonb(u.*) as user"),
+        this._knex.raw("to_jsonb(c.*) as camera"),
+      )
       .where("s.id", id)
       .first();
     return study || null;
@@ -25,7 +30,12 @@ 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")
-      .select("s.*", this._knex.raw("to_jsonb(u.*) as user"))
+      .leftJoin("cameras as c", "s.cameraId", "c.id")
+      .select(
+        "s.*",
+        this._knex.raw("to_jsonb(u.*) as user"),
+        this._knex.raw("to_jsonb(c.*) as camera"),
+      )
       .where("s.uuid", uuid)
       .first();
     return study || null;
@@ -53,7 +63,12 @@ export class StudyDAO implements IBaseDAO<IStudy> {
 
     const query = this._knex("study as s")
       .innerJoin("users as u", "s.createdBy", "u.id")
-      .select("s.*", this._knex.raw("to_jsonb(u.*) as user"));
+      .leftJoin("cameras as c", "s.cameraId", "c.id")
+      .select(
+        "s.*",
+        this._knex.raw("to_jsonb(u.*) as user"),
+        this._knex.raw("to_jsonb(c.*) as camera"),
+      );
     if (createdBy !== undefined && createdBy !== null) {
       query.where("s.createdBy", createdBy);
     }
@@ -72,4 +87,20 @@ export class StudyDAO implements IBaseDAO<IStudy> {
       totalPages: Math.ceil(totalCount / limit),
     };
   }
+
+  async getStudiesByCamera(cameraId: 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")
+      .select(
+        "s.*",
+        this._knex.raw("to_jsonb(u.*) as user"),
+        this._knex.raw("to_jsonb(c.*) as camera"),
+      )
+      .where("s.cameraId", cameraId)
+      .orderBy("s.created_at", "desc")
+      .limit(10);
+
+    return studies;
+  }
 }

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

@@ -259,65 +259,92 @@ export class VideoDAO implements IBaseDAO<IVideo> {
   }
 
   /**
-   * Bulk update camera assignment for multiple videos
-   * Supports optional transaction for service-level transaction management
+   * Get videos by batch ID
    */
-  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;
+  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 by camera ID with folder information (paginated)
+   * Get videos sorted chronologically by recording start time for a study
    */
-  async getVideosByCameraIdWithFolder(
-    cameraId: number,
-    page: number,
-    limit: number,
+  async getChronologicalVideos(
+    studyId: number,
+    startDate?: Date,
+    endDate?: Date,
   ): Promise<IDataPaginator<IVideo>> {
-    const offset = (page - 1) * limit;
-
-    const query = this._knex("video as v")
+    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("v.cameraId", cameraId);
+      .where("f.studyId", studyId)
+      .whereNotNull("v.recordingStartedAt");
+
+    if (startDate) {
+      query = query.where("v.recordingStartedAt", ">=", startDate);
+    }
 
-    // Optimized count query without JOIN
-    const [countResult] = await this._knex("video as v")
-      .where("v.cameraId", cameraId)
-      .count("* as count");
+    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()
-      .limit(limit)
-      .offset(offset)
-      .orderBy("v.created_at", "desc");
+    const videos = await query.clone().orderBy("v.recordingStartedAt", "asc");
 
     return {
       success: true,
       data: videos,
-      page,
-      limit,
+      page: 1,
+      limit: totalCount,
       count: videos.length,
       totalCount,
-      totalPages: Math.ceil(totalCount / limit),
+      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");
+  }
 }

package/src/index.ts

@@ -1,5 +1,6 @@
 // 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";
@@ -14,6 +15,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,
@@ -36,12 +38,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/folder/folder.interfaces.ts

@@ -1,5 +1,4 @@
 import type { IStudy } from "../study/study.interfaces";
-import type { ICamera } from "../camera/camera.interfaces";
 
 export interface IFolder {
   id: number;
@@ -8,9 +7,7 @@ export interface IFolder {
   createdBy: number; // user.id
   status: "UPLOADING" | "COMPLETE";
   studyId: number; // study.id
-  cameraId?: number; // camera.id
   created_at: string;
   updated_at: string;
   study?: IStudy;
-  camera?: ICamera;
 }