comparing 4d7be0af7585424d6924622079c1b9d34825a74f and main on dunkirk.sh/thistle

+41

src/components/class-view.ts

···

       2
        
       import { customElement, state } from "lit/decorators.js";

     

       3
        
       import "./upload-recording-modal.ts";

     

       4
        
       import "./vtt-viewer.ts";

     

       0
        
       
     

       5
        
       

     

       6
        
       interface Class {

     

       7
        
       	id: string;

     
···

       492
        
       			);

     

       493
        
       		}

     

       494
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       495
        
       		return filtered;

     

       496
        
       	}

     

       497
        
       

     
···

       630
        
                 </button>

     

       631
        
               </div>

     

       632
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       633
        
               ${

     

       634
        
       					this.filteredTranscriptions.length === 0

     

       635
        
       						? html`

···

       2
        
       import { customElement, state } from "lit/decorators.js";

     

       3
        
       import "./upload-recording-modal.ts";

     

       4
        
       import "./vtt-viewer.ts";

     

       5
       +
       import "./pending-recordings-view.ts";

     

       6
        
       

     

       7
        
       interface Class {

     

       8
        
       	id: string;

     
···

       493
        
       			);

     

       494
        
       		}

     

       495
        
       

     

       496
       +
       		// Exclude pending recordings (they're shown in the voting section)

     

       497
       +
       		filtered = filtered.filter((t) => t.status !== "pending");

     

       498
       +
       

     

       499
        
       		return filtered;

     

       500
        
       	}

     

       501
        
       

     
···

       634
        
                 </button>

     

       635
        
               </div>

     

       636
        
       

     

       637
       +
               <!-- Pending Recordings for Voting -->

     

       638
       +
               ${

     

       639
       +
       					this.meetingTimes.map((meeting) => {

     

       640
       +
       						// Apply section filtering to pending recordings

     

       641
       +
       						const sectionFilter = this.selectedSectionFilter || this.userSection;

     

       642
       +
       						

     

       643
       +
       						const pendingCount = this.transcriptions.filter((t) => {

     

       644
       +
       							if (t.meeting_time_id !== meeting.id || t.status !== "pending") {

     

       645
       +
       								return false;

     

       646
       +
       							}

     

       647
       +
       							

     

       648
       +
       							// Filter by section if applicable

     

       649
       +
       							if (this.sections.length > 0 && sectionFilter) {

     

       650
       +
       								// Show recordings from user's section or no section (unassigned)

     

       651
       +
       								return t.section_id === sectionFilter || t.section_id === null;

     

       652
       +
       							}

     

       653
       +
       							

     

       654
       +
       							return true;

     

       655
       +
       						}).length;

     

       656
       +
       

     

       657
       +
       						// Only show if there are pending recordings

     

       658
       +
       						if (pendingCount === 0) return "";

     

       659
       +
       

     

       660
       +
       						return html`

     

       661
       +
                   <div style="margin-bottom: 2rem;">

     

       662
       +
                     <pending-recordings-view

     

       663
       +
                       .classId=${this.classId}

     

       664
       +
                       .meetingTimeId=${meeting.id}

     

       665
       +
                       .meetingTimeLabel=${meeting.label}

     

       666
       +
                       .sectionId=${sectionFilter}

     

       667
       +
                     ></pending-recordings-view>

     

       668
       +
                   </div>

     

       669
       +
                 `;

     

       670
       +
       					})

     

       671
       +
       				}

     

       672
       +
       

     

       673
       +
               <!-- Completed/Processing Transcriptions -->

     

       674
        
               ${

     

       675
        
       					this.filteredTranscriptions.length === 0

     

       676
        
       						? html`

+436

src/components/pending-recordings-view.ts

···

       1
       +
       import { css, html, LitElement } from "lit";

     

       2
       +
       import { customElement, property, state } from "lit/decorators.js";

     

       3
       +
       

     

       4
       +
       interface PendingRecording {

     

       5
       +
       	id: string;

     

       6
       +
       	user_id: number;

     

       7
       +
       	filename: string;

     

       8
       +
       	original_filename: string;

     

       9
       +
       	vote_count: number;

     

       10
       +
       	created_at: number;

     

       11
       +
       }

     

       12
       +
       

     

       13
       +
       interface RecordingsData {

     

       14
       +
       	recordings: PendingRecording[];

     

       15
       +
       	total_users: number;

     

       16
       +
       	user_vote: string | null;

     

       17
       +
       	vote_threshold: number;

     

       18
       +
       	winning_recording_id: string | null;

     

       19
       +
       }

     

       20
       +
       

     

       21
       +
       @customElement("pending-recordings-view")

     

       22
       +
       export class PendingRecordingsView extends LitElement {

     

       23
       +
       	@property({ type: String }) classId = "";

     

       24
       +
       	@property({ type: String }) meetingTimeId = "";

     

       25
       +
       	@property({ type: String }) meetingTimeLabel = "";

     

       26
       +
       	@property({ type: String }) sectionId: string | null = null;

     

       27
       +
       

     

       28
       +
       	@state() private recordings: PendingRecording[] = [];

     

       29
       +
       	@state() private userVote: string | null = null;

     

       30
       +
       	@state() private voteThreshold = 0;

     

       31
       +
       	@state() private winningRecordingId: string | null = null;

     

       32
       +
       	@state() private error: string | null = null;

     

       33
       +
       	@state() private timeRemaining = "";

     

       34
       +
       

     

       35
       +
       	private refreshInterval?: number;

     

       36
       +
       	private loadingInProgress = false;

     

       37
       +
       

     

       38
       +
       	static override styles = css`

     

       39
       +
           :host {

     

       40
       +
             display: block;

     

       41
       +
             padding: 1rem;

     

       42
       +
           }

     

       43
       +
       

     

       44
       +
           .container {

     

       45
       +
             max-width: 56rem;

     

       46
       +
             margin: 0 auto;

     

       47
       +
           }

     

       48
       +
       

     

       49
       +
           h2 {

     

       50
       +
             color: var(--text);

     

       51
       +
             margin-bottom: 0.5rem;

     

       52
       +
           }

     

       53
       +
       

     

       54
       +
           .info {

     

       55
       +
             color: var(--paynes-gray);

     

       56
       +
             font-size: 0.875rem;

     

       57
       +
             margin-bottom: 1.5rem;

     

       58
       +
           }

     

       59
       +
       

     

       60
       +
           .stats {

     

       61
       +
             display: flex;

     

       62
       +
             gap: 2rem;

     

       63
       +
             margin-bottom: 1.5rem;

     

       64
       +
             padding: 1rem;

     

       65
       +
             background: color-mix(in srgb, var(--primary) 5%, transparent);

     

       66
       +
             border-radius: 8px;

     

       67
       +
           }

     

       68
       +
       

     

       69
       +
           .stat {

     

       70
       +
             display: flex;

     

       71
       +
             flex-direction: column;

     

       72
       +
             gap: 0.25rem;

     

       73
       +
           }

     

       74
       +
       

     

       75
       +
           .stat-label {

     

       76
       +
             font-size: 0.75rem;

     

       77
       +
             color: var(--paynes-gray);

     

       78
       +
             text-transform: uppercase;

     

       79
       +
             letter-spacing: 0.05em;

     

       80
       +
           }

     

       81
       +
       

     

       82
       +
           .stat-value {

     

       83
       +
             font-size: 1.5rem;

     

       84
       +
             font-weight: 600;

     

       85
       +
             color: var(--text);

     

       86
       +
           }

     

       87
       +
       

     

       88
       +
           .recordings-list {

     

       89
       +
             display: flex;

     

       90
       +
             flex-direction: column;

     

       91
       +
             gap: 1rem;

     

       92
       +
           }

     

       93
       +
       

     

       94
       +
           .recording-card {

     

       95
       +
             border: 2px solid var(--secondary);

     

       96
       +
             border-radius: 8px;

     

       97
       +
             padding: 1rem;

     

       98
       +
             transition: all 0.2s;

     

       99
       +
           }

     

       100
       +
       

     

       101
       +
           .recording-card.voted {

     

       102
       +
             border-color: var(--accent);

     

       103
       +
             background: color-mix(in srgb, var(--accent) 5%, transparent);

     

       104
       +
           }

     

       105
       +
       

     

       106
       +
           .recording-card.winning {

     

       107
       +
             border-color: var(--accent);

     

       108
       +
             background: color-mix(in srgb, var(--accent) 10%, transparent);

     

       109
       +
           }

     

       110
       +
       

     

       111
       +
           .recording-header {

     

       112
       +
             display: flex;

     

       113
       +
             justify-content: space-between;

     

       114
       +
             align-items: center;

     

       115
       +
             margin-bottom: 0.75rem;

     

       116
       +
           }

     

       117
       +
       

     

       118
       +
           .recording-info {

     

       119
       +
             flex: 1;

     

       120
       +
           }

     

       121
       +
       

     

       122
       +
           .recording-name {

     

       123
       +
             font-weight: 600;

     

       124
       +
             color: var(--text);

     

       125
       +
             margin-bottom: 0.25rem;

     

       126
       +
           }

     

       127
       +
       

     

       128
       +
           .recording-meta {

     

       129
       +
             font-size: 0.75rem;

     

       130
       +
             color: var(--paynes-gray);

     

       131
       +
           }

     

       132
       +
       

     

       133
       +
           .vote-section {

     

       134
       +
             display: flex;

     

       135
       +
             align-items: center;

     

       136
       +
             gap: 1rem;

     

       137
       +
           }

     

       138
       +
       

     

       139
       +
           .vote-count {

     

       140
       +
             font-size: 1.25rem;

     

       141
       +
             font-weight: 600;

     

       142
       +
             color: var(--accent);

     

       143
       +
             min-width: 3rem;

     

       144
       +
             text-align: center;

     

       145
       +
           }

     

       146
       +
       

     

       147
       +
           .vote-button {

     

       148
       +
             padding: 0.5rem 1rem;

     

       149
       +
             border-radius: 6px;

     

       150
       +
             font-size: 0.875rem;

     

       151
       +
             font-weight: 500;

     

       152
       +
             cursor: pointer;

     

       153
       +
             transition: all 0.2s;

     

       154
       +
             border: 2px solid var(--secondary);

     

       155
       +
             background: var(--background);

     

       156
       +
             color: var(--text);

     

       157
       +
           }

     

       158
       +
       

     

       159
       +
           .vote-button:hover:not(:disabled) {

     

       160
       +
             border-color: var(--accent);

     

       161
       +
             background: color-mix(in srgb, var(--accent) 10%, transparent);

     

       162
       +
           }

     

       163
       +
       

     

       164
       +
           .vote-button.voted {

     

       165
       +
             border-color: var(--accent);

     

       166
       +
             background: var(--accent);

     

       167
       +
             color: var(--white);

     

       168
       +
           }

     

       169
       +
       

     

       170
       +
           .vote-button:disabled {

     

       171
       +
             opacity: 0.5;

     

       172
       +
             cursor: not-allowed;

     

       173
       +
           }

     

       174
       +
       

     

       175
       +
           .delete-button {

     

       176
       +
             padding: 0.5rem;

     

       177
       +
             border: none;

     

       178
       +
             background: transparent;

     

       179
       +
             color: var(--paynes-gray);

     

       180
       +
             cursor: pointer;

     

       181
       +
             border-radius: 4px;

     

       182
       +
             transition: all 0.2s;

     

       183
       +
           }

     

       184
       +
       

     

       185
       +
           .delete-button:hover {

     

       186
       +
             background: color-mix(in srgb, red 10%, transparent);

     

       187
       +
             color: red;

     

       188
       +
           }

     

       189
       +
       

     

       190
       +
           .winning-badge {

     

       191
       +
             background: var(--accent);

     

       192
       +
             color: var(--white);

     

       193
       +
             padding: 0.25rem 0.75rem;

     

       194
       +
             border-radius: 12px;

     

       195
       +
             font-size: 0.75rem;

     

       196
       +
             font-weight: 600;

     

       197
       +
           }

     

       198
       +
       

     

       199
       +
           .error {

     

       200
       +
             background: color-mix(in srgb, red 10%, transparent);

     

       201
       +
             border: 1px solid red;

     

       202
       +
             color: red;

     

       203
       +
             padding: 0.75rem;

     

       204
       +
             border-radius: 4px;

     

       205
       +
             margin-bottom: 1rem;

     

       206
       +
             font-size: 0.875rem;

     

       207
       +
           }

     

       208
       +
       

     

       209
       +
           .empty-state {

     

       210
       +
             text-align: center;

     

       211
       +
             padding: 3rem 1rem;

     

       212
       +
             color: var(--paynes-gray);

     

       213
       +
           }

     

       214
       +
       

     

       215
       +
           .audio-player {

     

       216
       +
             margin-top: 0.75rem;

     

       217
       +
           }

     

       218
       +
       

     

       219
       +
           audio {

     

       220
       +
             width: 100%;

     

       221
       +
             height: 2.5rem;

     

       222
       +
           }

     

       223
       +
         `;

     

       224
       +
       

     

       225
       +
       	override connectedCallback() {

     

       226
       +
       		super.connectedCallback();

     

       227
       +
       		this.loadRecordings();

     

       228
       +
       		// Refresh every 10 seconds

     

       229
       +
       		this.refreshInterval = setInterval(() => this.loadRecordings(), 10000);

     

       230
       +
       	}

     

       231
       +
       

     

       232
       +
       	override disconnectedCallback() {

     

       233
       +
       		super.disconnectedCallback();

     

       234
       +
       		if (this.refreshInterval) {

     

       235
       +
       			clearInterval(this.refreshInterval);

     

       236
       +
       		}

     

       237
       +
       	}

     

       238
       +
       

     

       239
       +
       	private async loadRecordings() {

     

       240
       +
       		if (this.loadingInProgress) return;

     

       241
       +
       

     

       242
       +
       		this.loadingInProgress = true;

     

       243
       +
       

     

       244
       +
       		try {

     

       245
       +
       			// Build URL with optional section_id parameter

     

       246
       +
       			const url = new URL(

     

       247
       +
       				`/api/classes/${this.classId}/meetings/${this.meetingTimeId}/recordings`,

     

       248
       +
       				window.location.origin,

     

       249
       +
       			);

     

       250
       +
       			if (this.sectionId !== null) {

     

       251
       +
       				url.searchParams.set("section_id", this.sectionId);

     

       252
       +
       			}

     

       253
       +
       

     

       254
       +
       			const response = await fetch(url.toString());

     

       255
       +
       

     

       256
       +
       			if (!response.ok) {

     

       257
       +
       				throw new Error("Failed to load recordings");

     

       258
       +
       			}

     

       259
       +
       

     

       260
       +
       			const data: RecordingsData = await response.json();

     

       261
       +
       			this.recordings = data.recordings;

     

       262
       +
       			this.userVote = data.user_vote;

     

       263
       +
       			this.voteThreshold = data.vote_threshold;

     

       264
       +
       			this.winningRecordingId = data.winning_recording_id;

     

       265
       +
       

     

       266
       +
       			// Calculate time remaining for first recording

     

       267
       +
       			if (this.recordings.length > 0 && this.recordings[0]) {

     

       268
       +
       				const uploadedAt = this.recordings[0].created_at;

     

       269
       +
       				const now = Date.now() / 1000;

     

       270
       +
       				const elapsed = now - uploadedAt;

     

       271
       +
       				const remaining = 30 * 60 - elapsed; // 30 minutes

     

       272
       +
       

     

       273
       +
       				if (remaining > 0) {

     

       274
       +
       					const minutes = Math.floor(remaining / 60);

     

       275
       +
       					const seconds = Math.floor(remaining % 60);

     

       276
       +
       					this.timeRemaining = `${minutes}:${seconds.toString().padStart(2, "0")}`;

     

       277
       +
       				} else {

     

       278
       +
       					this.timeRemaining = "Auto-submitting...";

     

       279
       +
       				}

     

       280
       +
       			}

     

       281
       +
       

     

       282
       +
       			this.error = null;

     

       283
       +
       		} catch (error) {

     

       284
       +
       			this.error =

     

       285
       +
       				error instanceof Error ? error.message : "Failed to load recordings";

     

       286
       +
       		} finally {

     

       287
       +
       			this.loadingInProgress = false;

     

       288
       +
       		}

     

       289
       +
       	}

     

       290
       +
       

     

       291
       +
       	private async handleVote(recordingId: string) {

     

       292
       +
       		try {

     

       293
       +
       			const response = await fetch(`/api/recordings/${recordingId}/vote`, {

     

       294
       +
       				method: "POST",

     

       295
       +
       			});

     

       296
       +
       

     

       297
       +
       			if (!response.ok) {

     

       298
       +
       				throw new Error("Failed to vote");

     

       299
       +
       			}

     

       300
       +
       

     

       301
       +
       			const data = await response.json();

     

       302
       +
       

     

       303
       +
       			// If a winner was selected, reload the page to show it in transcriptions

     

       304
       +
       			if (data.winning_recording_id) {

     

       305
       +
       				window.location.reload();

     

       306
       +
       			} else {

     

       307
       +
       				// Just reload recordings to show updated votes

     

       308
       +
       				await this.loadRecordings();

     

       309
       +
       			}

     

       310
       +
       		} catch (error) {

     

       311
       +
       			this.error =

     

       312
       +
       				error instanceof Error ? error.message : "Failed to vote";

     

       313
       +
       		}

     

       314
       +
       	}

     

       315
       +
       

     

       316
       +
       	private async handleDelete(recordingId: string) {

     

       317
       +
       		if (!confirm("Delete this recording?")) {

     

       318
       +
       			return;

     

       319
       +
       		}

     

       320
       +
       

     

       321
       +
       		try {

     

       322
       +
       			const response = await fetch(`/api/recordings/${recordingId}`, {

     

       323
       +
       				method: "DELETE",

     

       324
       +
       			});

     

       325
       +
       

     

       326
       +
       			if (!response.ok) {

     

       327
       +
       				throw new Error("Failed to delete recording");

     

       328
       +
       			}

     

       329
       +
       

     

       330
       +
       			await this.loadRecordings();

     

       331
       +
       		} catch (error) {

     

       332
       +
       			this.error =

     

       333
       +
       				error instanceof Error ? error.message : "Failed to delete recording";

     

       334
       +
       		}

     

       335
       +
       	}

     

       336
       +
       

     

       337
       +
       	private formatTimeAgo(timestamp: number): string {

     

       338
       +
       		const now = Date.now() / 1000;

     

       339
       +
       		const diff = now - timestamp;

     

       340
       +
       

     

       341
       +
       		if (diff < 60) return "just now";

     

       342
       +
       		if (diff < 3600) return `${Math.floor(diff / 60)}m ago`;

     

       343
       +
       		if (diff < 86400) return `${Math.floor(diff / 3600)}h ago`;

     

       344
       +
       		return `${Math.floor(diff / 86400)}d ago`;

     

       345
       +
       	}

     

       346
       +
       

     

       347
       +
       	override render() {

     

       348
       +
       		return html`

     

       349
       +
             <div class="container">

     

       350
       +
               <h2>Pending Recordings - ${this.meetingTimeLabel}</h2>

     

       351
       +
               <p class="info">

     

       352
       +
                 Vote for the best quality recording. The winner will be automatically transcribed when 40% of class votes or after 30 minutes.

     

       353
       +
               </p>

     

       354
       +
       

     

       355
       +
               ${this.error ? html`<div class="error">${this.error}</div>` : ""}

     

       356
       +
       

     

       357
       +
               ${

     

       358
       +
       					this.recordings.length > 0

     

       359
       +
       						? html`

     

       360
       +
                   <div class="stats">

     

       361
       +
                     <div class="stat">

     

       362
       +
                       <div class="stat-label">Recordings</div>

     

       363
       +
                       <div class="stat-value">${this.recordings.length}</div>

     

       364
       +
                     </div>

     

       365
       +
                     <div class="stat">

     

       366
       +
                       <div class="stat-label">Vote Threshold</div>

     

       367
       +
                       <div class="stat-value">${this.voteThreshold} votes</div>

     

       368
       +
                     </div>

     

       369
       +
                     <div class="stat">

     

       370
       +
                       <div class="stat-label">Time Remaining</div>

     

       371
       +
                       <div class="stat-value">${this.timeRemaining}</div>

     

       372
       +
                     </div>

     

       373
       +
                   </div>

     

       374
       +
       

     

       375
       +
                   <div class="recordings-list">

     

       376
       +
                     ${this.recordings.map(

     

       377
       +
       								(recording) => html`

     

       378
       +
                       <div class="recording-card ${this.userVote === recording.id ? "voted" : ""} ${this.winningRecordingId === recording.id ? "winning" : ""}">

     

       379
       +
                         <div class="recording-header">

     

       380
       +
                           <div class="recording-info">

     

       381
       +
                             <div class="recording-name">${recording.original_filename}</div>

     

       382
       +
                             <div class="recording-meta">

     

       383
       +
                               Uploaded ${this.formatTimeAgo(recording.created_at)}

     

       384
       +
                             </div>

     

       385
       +
                           </div>

     

       386
       +
       

     

       387
       +
                           <div class="vote-section">

     

       388
       +
                             ${

     

       389
       +
       												this.winningRecordingId === recording.id

     

       390
       +
       													? html`<span class="winning-badge">✨ Selected</span>`

     

       391
       +
       													: ""

     

       392
       +
       											}

     

       393
       +
                             

     

       394
       +
                             <div class="vote-count">

     

       395
       +
                               ${recording.vote_count} ${recording.vote_count === 1 ? "vote" : "votes"}

     

       396
       +
                             </div>

     

       397
       +
       

     

       398
       +
                             <button

     

       399
       +
                               class="vote-button ${this.userVote === recording.id ? "voted" : ""}"

     

       400
       +
                               @click=${() => this.handleVote(recording.id)}

     

       401
       +
                               ?disabled=${this.winningRecordingId !== null}

     

       402
       +
                             >

     

       403
       +
                               ${this.userVote === recording.id ? "✓ Voted" : "Vote"}

     

       404
       +
                             </button>

     

       405
       +
       

     

       406
       +
                             <button

     

       407
       +
                               class="delete-button"

     

       408
       +
                               @click=${() => this.handleDelete(recording.id)}

     

       409
       +
                               title="Delete recording"

     

       410
       +
                             >

     

       411
       +
                               🗑️

     

       412
       +
                             </button>

     

       413
       +
                           </div>

     

       414
       +
                         </div>

     

       415
       +
       

     

       416
       +
                         <div class="audio-player">

     

       417
       +
                           <audio controls preload="none">

     

       418
       +
                             <source src="/api/transcriptions/${recording.id}/audio" type="audio/mpeg">

     

       419
       +
                           </audio>

     

       420
       +
                         </div>

     

       421
       +
                       </div>

     

       422
       +
                     `,

     

       423
       +
       							)}

     

       424
       +
                   </div>

     

       425
       +
                 `

     

       426
       +
       						: html`

     

       427
       +
                   <div class="empty-state">

     

       428
       +
                     <p>No recordings uploaded yet for this meeting time.</p>

     

       429
       +
                     <p>Upload a recording to get started!</p>

     

       430
       +
                   </div>

     

       431
       +
                 `

     

       432
       +
       				}

     

       433
       +
             </div>

     

       434
       +
           `;

     

       435
       +
       	}

     

       436
       +
       }

+40

src/db/schema.ts

···

       253
        
       			CREATE INDEX IF NOT EXISTS idx_transcriptions_section_id ON transcriptions(section_id);

     

       254
        
       		`,

     

       255
        
       	},

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       256
        
       ];

     

       257
        
       

     

       258
        
       function getCurrentVersion(): number {

···

       253
        
       			CREATE INDEX IF NOT EXISTS idx_transcriptions_section_id ON transcriptions(section_id);

     

       254
        
       		`,

     

       255
        
       	},

     

       256
       +
       	{

     

       257
       +
       		version: 3,

     

       258
       +
       		name: "Add voting system for collaborative recording selection",

     

       259
       +
       		sql: `

     

       260
       +
       			-- Add vote count to transcriptions

     

       261
       +
       			ALTER TABLE transcriptions ADD COLUMN vote_count INTEGER NOT NULL DEFAULT 0;

     

       262
       +
       

     

       263
       +
       			-- Add auto-submitted flag to track if transcription was auto-selected

     

       264
       +
       			ALTER TABLE transcriptions ADD COLUMN auto_submitted BOOLEAN DEFAULT 0;

     

       265
       +
       

     

       266
       +
       			-- Create votes table to track who voted for which recording

     

       267
       +
       			CREATE TABLE IF NOT EXISTS recording_votes (

     

       268
       +
       				id TEXT PRIMARY KEY,

     

       269
       +
       				transcription_id TEXT NOT NULL,

     

       270
       +
       				user_id INTEGER NOT NULL,

     

       271
       +
       				created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now')),

     

       272
       +
       				FOREIGN KEY (transcription_id) REFERENCES transcriptions(id) ON DELETE CASCADE,

     

       273
       +
       				FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,

     

       274
       +
       				UNIQUE(transcription_id, user_id)

     

       275
       +
       			);

     

       276
       +
       

     

       277
       +
       			CREATE INDEX IF NOT EXISTS idx_recording_votes_transcription_id ON recording_votes(transcription_id);

     

       278
       +
       			CREATE INDEX IF NOT EXISTS idx_recording_votes_user_id ON recording_votes(user_id);

     

       279
       +
       		`,

     

       280
       +
       	},

     

       281
       +
       	{

     

       282
       +
       		version: 4,

     

       283
       +
       		name: "Add recording_date to transcriptions for chronological ordering",

     

       284
       +
       		sql: `

     

       285
       +
       			-- Add recording_date (timestamp when the recording was made, not uploaded)

     

       286
       +
       			-- Defaults to created_at for existing records

     

       287
       +
       			ALTER TABLE transcriptions ADD COLUMN recording_date INTEGER;

     

       288
       +
       			

     

       289
       +
       			-- Set recording_date to created_at for existing records

     

       290
       +
       			UPDATE transcriptions SET recording_date = created_at WHERE recording_date IS NULL;

     

       291
       +
       

     

       292
       +
       			-- Create index for ordering by recording date

     

       293
       +
       			CREATE INDEX IF NOT EXISTS idx_transcriptions_recording_date ON transcriptions(recording_date);

     

       294
       +
       		`,

     

       295
       +
       	},

     

       296
        
       ];

     

       297
        
       

     

       298
        
       function getCurrentVersion(): number {

+357 -5

src/index.ts

···

       92
        
       	WhisperServiceManager,

     

       93
        
       } from "./lib/transcription";

     

       94
        
       import {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       95
        
       	validateClassId,

     

       96
        
       	validateCourseCode,

     

       97
        
       	validateCourseName,

     
···

       2082
        
       				}

     

       2083
        
       			},

     

       2084
        
       		},

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2085
        
       		"/api/transcriptions": {

     

       2086
        
       			GET: async (req) => {

     

       2087
        
       				try {

     
···

       2224
        
       					const formData = await req.formData();

     

       2225
        
       					const file = formData.get("audio") as File;

     

       2226
        
       					const classId = formData.get("class_id") as string | null;

     

       2227
       -
       					const meetingTimeId = formData.get("meeting_time_id") as

     

       0
        
       
     

       2228
        
       						| string

     

       2229
        
       						| null;

     

       2230
       -
       					const sectionId = formData.get("section_id") as string | null;

     

       2231
        
       

     

       2232
        
       					if (!file) throw ValidationErrors.missingField("audio");

     

       2233
        
       

     
···

       2294
        
       					const uploadDir = "./uploads";

     

       2295
        
       					await Bun.write(`${uploadDir}/${filename}`, file);

     

       2296
        
       

     

       2297
       -
       					// Create database record

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2298
        
       					db.run(

     

       2299
       -
       						"INSERT INTO transcriptions (id, user_id, class_id, meeting_time_id, section_id, filename, original_filename, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",

     

       2300
        
       						[

     

       2301
        
       							transcriptionId,

     

       2302
        
       							user.id,

     

       2303
        
       							classId,

     

       2304
       -
       							meetingTimeId,

     

       2305
        
       							sectionId,

     

       2306
        
       							filename,

     

       2307
        
       							file.name,

     

       2308
        
       							"pending",

     

       0
        
       
     

       2309
        
       						],

     

       2310
        
       					);

     

       2311

···

       92
        
       	WhisperServiceManager,

     

       93
        
       } from "./lib/transcription";

     

       94
        
       import {

     

       95
       +
       	findMatchingMeetingTime,

     

       96
       +
       	getDayName,

     

       97
       +
       } from "./lib/audio-metadata";

     

       98
       +
       import {

     

       99
       +
       	checkAutoSubmit,

     

       100
       +
       	deletePendingRecording,

     

       101
       +
       	getEnrolledUserCount,

     

       102
       +
       	getPendingRecordings,

     

       103
       +
       	getUserVoteForMeeting,

     

       104
       +
       	markAsAutoSubmitted,

     

       105
       +
       	removeVote,

     

       106
       +
       	voteForRecording,

     

       107
       +
       } from "./lib/voting";

     

       108
       +
       import {

     

       109
        
       	validateClassId,

     

       110
        
       	validateCourseCode,

     

       111
        
       	validateCourseName,

     
···

       2096
        
       				}

     

       2097
        
       			},

     

       2098
        
       		},

     

       2099
       +
       		"/api/transcriptions/detect-meeting-time": {

     

       2100
       +
       			POST: async (req) => {

     

       2101
       +
       				try {

     

       2102
       +
       					const user = requireAuth(req);

     

       2103
       +
       

     

       2104
       +
       					const formData = await req.formData();

     

       2105
       +
       					const file = formData.get("audio") as File;

     

       2106
       +
       					const classId = formData.get("class_id") as string | null;

     

       2107
       +
       					const fileTimestampStr = formData.get("file_timestamp") as

     

       2108
       +
       						| string

     

       2109
       +
       						| null;

     

       2110
       +
       

     

       2111
       +
       					if (!file) throw ValidationErrors.missingField("audio");

     

       2112
       +
       					if (!classId) throw ValidationErrors.missingField("class_id");

     

       2113
       +
       

     

       2114
       +
       					// Verify user is enrolled in the class

     

       2115
       +
       					const enrolled = isUserEnrolledInClass(user.id, classId);

     

       2116
       +
       					if (!enrolled && user.role !== "admin") {

     

       2117
       +
       						return Response.json(

     

       2118
       +
       							{ error: "Not enrolled in this class" },

     

       2119
       +
       							{ status: 403 },

     

       2120
       +
       						);

     

       2121
       +
       					}

     

       2122
       +
       

     

       2123
       +
       					let creationDate: Date | null = null;

     

       2124
       +
       

     

       2125
       +
       					// Use client-provided timestamp (from File.lastModified)

     

       2126
       +
       					if (fileTimestampStr) {

     

       2127
       +
       						const timestamp = Number.parseInt(fileTimestampStr, 10);

     

       2128
       +
       						if (!Number.isNaN(timestamp)) {

     

       2129
       +
       							creationDate = new Date(timestamp);

     

       2130
       +
       							console.log(

     

       2131
       +
       								`[Upload] Using file timestamp: ${creationDate.toISOString()}`,

     

       2132
       +
       							);

     

       2133
       +
       						}

     

       2134
       +
       					}

     

       2135
       +
       

     

       2136
       +
       					if (!creationDate) {

     

       2137
       +
       						return Response.json({

     

       2138
       +
       							detected: false,

     

       2139
       +
       							meeting_time_id: null,

     

       2140
       +
       							message: "Could not extract creation date from file",

     

       2141
       +
       						});

     

       2142
       +
       					}

     

       2143
       +
       

     

       2144
       +
       					// Get meeting times for this class

     

       2145
       +
       					const meetingTimes = getMeetingTimesForClass(classId);

     

       2146
       +
       

     

       2147
       +
       					if (meetingTimes.length === 0) {

     

       2148
       +
       						return Response.json({

     

       2149
       +
       							detected: false,

     

       2150
       +
       							meeting_time_id: null,

     

       2151
       +
       							message: "No meeting times configured for this class",

     

       2152
       +
       						});

     

       2153
       +
       					}

     

       2154
       +
       

     

       2155
       +
       					// Find matching meeting time based on day of week

     

       2156
       +
       					const matchedId = findMatchingMeetingTime(

     

       2157
       +
       						creationDate,

     

       2158
       +
       						meetingTimes,

     

       2159
       +
       					);

     

       2160
       +
       

     

       2161
       +
       					if (matchedId) {

     

       2162
       +
       						const dayName = getDayName(creationDate);

     

       2163
       +
       						return Response.json({

     

       2164
       +
       							detected: true,

     

       2165
       +
       							meeting_time_id: matchedId,

     

       2166
       +
       							day: dayName,

     

       2167
       +
       							date: creationDate.toISOString(),

     

       2168
       +
       						});

     

       2169
       +
       					}

     

       2170
       +
       

     

       2171
       +
       					const dayName = getDayName(creationDate);

     

       2172
       +
       					return Response.json({

     

       2173
       +
       						detected: false,

     

       2174
       +
       						meeting_time_id: null,

     

       2175
       +
       						day: dayName,

     

       2176
       +
       						date: creationDate.toISOString(),

     

       2177
       +
       						message: `No meeting time matches ${dayName}`,

     

       2178
       +
       					});

     

       2179
       +
       				} catch (error) {

     

       2180
       +
       					return handleError(error);

     

       2181
       +
       				}

     

       2182
       +
       			},

     

       2183
       +
       		},

     

       2184
       +
       		"/api/transcriptions/:id/meeting-time": {

     

       2185
       +
       			PATCH: async (req) => {

     

       2186
       +
       				try {

     

       2187
       +
       					const user = requireAuth(req);

     

       2188
       +
       					const transcriptionId = req.params.id;

     

       2189
       +
       

     

       2190
       +
       					const body = await req.json();

     

       2191
       +
       					const meetingTimeId = body.meeting_time_id;

     

       2192
       +
       					const sectionId = body.section_id;

     

       2193
       +
       

     

       2194
       +
       					if (!meetingTimeId) {

     

       2195
       +
       						return Response.json(

     

       2196
       +
       							{ error: "meeting_time_id required" },

     

       2197
       +
       							{ status: 400 },

     

       2198
       +
       						);

     

       2199
       +
       					}

     

       2200
       +
       

     

       2201
       +
       					// Verify transcription ownership

     

       2202
       +
       					const transcription = db

     

       2203
       +
       						.query<

     

       2204
       +
       							{ id: string; user_id: number; class_id: string | null },

     

       2205
       +
       							[string]

     

       2206
       +
       						>("SELECT id, user_id, class_id FROM transcriptions WHERE id = ?")

     

       2207
       +
       						.get(transcriptionId);

     

       2208
       +
       

     

       2209
       +
       					if (!transcription) {

     

       2210
       +
       						return Response.json(

     

       2211
       +
       							{ error: "Transcription not found" },

     

       2212
       +
       							{ status: 404 },

     

       2213
       +
       						);

     

       2214
       +
       					}

     

       2215
       +
       

     

       2216
       +
       					if (transcription.user_id !== user.id && user.role !== "admin") {

     

       2217
       +
       						return Response.json({ error: "Forbidden" }, { status: 403 });

     

       2218
       +
       					}

     

       2219
       +
       

     

       2220
       +
       					// Verify meeting time belongs to the class

     

       2221
       +
       					if (transcription.class_id) {

     

       2222
       +
       						const meetingTime = db

     

       2223
       +
       							.query<{ id: string }, [string, string]>(

     

       2224
       +
       								"SELECT id FROM meeting_times WHERE id = ? AND class_id = ?",

     

       2225
       +
       							)

     

       2226
       +
       							.get(meetingTimeId, transcription.class_id);

     

       2227
       +
       

     

       2228
       +
       						if (!meetingTime) {

     

       2229
       +
       							return Response.json(

     

       2230
       +
       								{

     

       2231
       +
       									error:

     

       2232
       +
       										"Meeting time does not belong to the class for this transcription",

     

       2233
       +
       								},

     

       2234
       +
       								{ status: 400 },

     

       2235
       +
       							);

     

       2236
       +
       						}

     

       2237
       +
       					}

     

       2238
       +
       

     

       2239
       +
       					// Update meeting time and optionally section_id

     

       2240
       +
       					if (sectionId !== undefined) {

     

       2241
       +
       						db.run(

     

       2242
       +
       							"UPDATE transcriptions SET meeting_time_id = ?, section_id = ? WHERE id = ?",

     

       2243
       +
       							[meetingTimeId, sectionId, transcriptionId],

     

       2244
       +
       						);

     

       2245
       +
       					} else {

     

       2246
       +
       						db.run(

     

       2247
       +
       							"UPDATE transcriptions SET meeting_time_id = ? WHERE id = ?",

     

       2248
       +
       							[meetingTimeId, transcriptionId],

     

       2249
       +
       						);

     

       2250
       +
       					}

     

       2251
       +
       

     

       2252
       +
       					return Response.json({

     

       2253
       +
       						success: true,

     

       2254
       +
       						message: "Meeting time updated successfully",

     

       2255
       +
       					});

     

       2256
       +
       				} catch (error) {

     

       2257
       +
       					return handleError(error);

     

       2258
       +
       				}

     

       2259
       +
       			},

     

       2260
       +
       		},

     

       2261
       +
       		"/api/classes/:classId/meetings/:meetingTimeId/recordings": {

     

       2262
       +
       			GET: async (req) => {

     

       2263
       +
       				try {

     

       2264
       +
       					const user = requireAuth(req);

     

       2265
       +
       					const classId = req.params.classId;

     

       2266
       +
       					const meetingTimeId = req.params.meetingTimeId;

     

       2267
       +
       

     

       2268
       +
       					// Verify user is enrolled in the class

     

       2269
       +
       					const enrolled = isUserEnrolledInClass(user.id, classId);

     

       2270
       +
       					if (!enrolled && user.role !== "admin") {

     

       2271
       +
       						return Response.json(

     

       2272
       +
       							{ error: "Not enrolled in this class" },

     

       2273
       +
       							{ status: 403 },

     

       2274
       +
       						);

     

       2275
       +
       					}

     

       2276
       +
       

     

       2277
       +
       					// Get section filter from query params or use user's section

     

       2278
       +
       					const url = new URL(req.url);

     

       2279
       +
       					const sectionParam = url.searchParams.get("section_id");

     

       2280
       +
       					const sectionFilter =

     

       2281
       +
       						sectionParam !== null

     

       2282
       +
       							? sectionParam || null // empty string becomes null

     

       2283
       +
       							: user.role === "admin"

     

       2284
       +
       								? null

     

       2285
       +
       								: getUserSection(user.id, classId);

     

       2286
       +
       

     

       2287
       +
       					const recordings = getPendingRecordings(

     

       2288
       +
       						classId,

     

       2289
       +
       						meetingTimeId,

     

       2290
       +
       						sectionFilter,

     

       2291
       +
       					);

     

       2292
       +
       					const totalUsers = getEnrolledUserCount(classId);

     

       2293
       +
       					const userVote = getUserVoteForMeeting(

     

       2294
       +
       						user.id,

     

       2295
       +
       						classId,

     

       2296
       +
       						meetingTimeId,

     

       2297
       +
       					);

     

       2298
       +
       

     

       2299
       +
       					// Check if any recording should be auto-submitted

     

       2300
       +
       					const winningId = checkAutoSubmit(

     

       2301
       +
       						classId,

     

       2302
       +
       						meetingTimeId,

     

       2303
       +
       						sectionFilter,

     

       2304
       +
       					);

     

       2305
       +
       

     

       2306
       +
       					return Response.json({

     

       2307
       +
       						recordings,

     

       2308
       +
       						total_users: totalUsers,

     

       2309
       +
       						user_vote: userVote,

     

       2310
       +
       						vote_threshold: Math.ceil(totalUsers * 0.4),

     

       2311
       +
       						winning_recording_id: winningId,

     

       2312
       +
       					});

     

       2313
       +
       				} catch (error) {

     

       2314
       +
       					return handleError(error);

     

       2315
       +
       				}

     

       2316
       +
       			},

     

       2317
       +
       		},

     

       2318
       +
       		"/api/recordings/:id/vote": {

     

       2319
       +
       			POST: async (req) => {

     

       2320
       +
       				try {

     

       2321
       +
       					const user = requireAuth(req);

     

       2322
       +
       					const recordingId = req.params.id;

     

       2323
       +
       

     

       2324
       +
       					// Verify user is enrolled in the recording's class

     

       2325
       +
       					const recording = db

     

       2326
       +
       						.query<

     

       2327
       +
       							{ class_id: string; meeting_time_id: string; status: string },

     

       2328
       +
       							[string]

     

       2329
       +
       						>(

     

       2330
       +
       							"SELECT class_id, meeting_time_id, status FROM transcriptions WHERE id = ?",

     

       2331
       +
       						)

     

       2332
       +
       						.get(recordingId);

     

       2333
       +
       

     

       2334
       +
       					if (!recording) {

     

       2335
       +
       						return Response.json(

     

       2336
       +
       							{ error: "Recording not found" },

     

       2337
       +
       							{ status: 404 },

     

       2338
       +
       						);

     

       2339
       +
       					}

     

       2340
       +
       

     

       2341
       +
       					if (recording.status !== "pending") {

     

       2342
       +
       						return Response.json(

     

       2343
       +
       							{ error: "Can only vote on pending recordings" },

     

       2344
       +
       							{ status: 400 },

     

       2345
       +
       						);

     

       2346
       +
       					}

     

       2347
       +
       

     

       2348
       +
       					const enrolled = isUserEnrolledInClass(user.id, recording.class_id);

     

       2349
       +
       					if (!enrolled && user.role !== "admin") {

     

       2350
       +
       						return Response.json(

     

       2351
       +
       							{ error: "Not enrolled in this class" },

     

       2352
       +
       							{ status: 403 },

     

       2353
       +
       						);

     

       2354
       +
       					}

     

       2355
       +
       

     

       2356
       +
       					// Remove existing vote for this meeting time

     

       2357
       +
       					const existingVote = getUserVoteForMeeting(

     

       2358
       +
       						user.id,

     

       2359
       +
       						recording.class_id,

     

       2360
       +
       						recording.meeting_time_id,

     

       2361
       +
       					);

     

       2362
       +
       					if (existingVote) {

     

       2363
       +
       						removeVote(existingVote, user.id);

     

       2364
       +
       					}

     

       2365
       +
       

     

       2366
       +
       					// Add new vote

     

       2367
       +
       					const success = voteForRecording(recordingId, user.id);

     

       2368
       +
       

     

       2369
       +
       					// Get user's section for auto-submit check

     

       2370
       +
       					const userSection =

     

       2371
       +
       						user.role === "admin"

     

       2372
       +
       							? null

     

       2373
       +
       							: getUserSection(user.id, recording.class_id);

     

       2374
       +
       

     

       2375
       +
       					// Check if auto-submit threshold reached

     

       2376
       +
       					const winningId = checkAutoSubmit(

     

       2377
       +
       						recording.class_id,

     

       2378
       +
       						recording.meeting_time_id,

     

       2379
       +
       						userSection,

     

       2380
       +
       					);

     

       2381
       +
       					if (winningId) {

     

       2382
       +
       						markAsAutoSubmitted(winningId);

     

       2383
       +
       						// Start transcription

     

       2384
       +
       						const winningRecording = db

     

       2385
       +
       							.query<{ filename: string }, [string]>(

     

       2386
       +
       								"SELECT filename FROM transcriptions WHERE id = ?",

     

       2387
       +
       							)

     

       2388
       +
       							.get(winningId);

     

       2389
       +
       						if (winningRecording) {

     

       2390
       +
       							whisperService.startTranscription(

     

       2391
       +
       								winningId,

     

       2392
       +
       								winningRecording.filename,

     

       2393
       +
       							);

     

       2394
       +
       						}

     

       2395
       +
       					}

     

       2396
       +
       

     

       2397
       +
       					return Response.json({

     

       2398
       +
       						success,

     

       2399
       +
       						winning_recording_id: winningId,

     

       2400
       +
       					});

     

       2401
       +
       				} catch (error) {

     

       2402
       +
       					return handleError(error);

     

       2403
       +
       				}

     

       2404
       +
       			},

     

       2405
       +
       		},

     

       2406
       +
       		"/api/recordings/:id": {

     

       2407
       +
       			DELETE: async (req) => {

     

       2408
       +
       				try {

     

       2409
       +
       					const user = requireAuth(req);

     

       2410
       +
       					const recordingId = req.params.id;

     

       2411
       +
       

     

       2412
       +
       					const success = deletePendingRecording(

     

       2413
       +
       						recordingId,

     

       2414
       +
       						user.id,

     

       2415
       +
       						user.role === "admin",

     

       2416
       +
       					);

     

       2417
       +
       

     

       2418
       +
       					if (!success) {

     

       2419
       +
       						return Response.json(

     

       2420
       +
       							{ error: "Cannot delete this recording" },

     

       2421
       +
       							{ status: 403 },

     

       2422
       +
       						);

     

       2423
       +
       					}

     

       2424
       +
       

     

       2425
       +
       					return new Response(null, { status: 204 });

     

       2426
       +
       				} catch (error) {

     

       2427
       +
       					return handleError(error);

     

       2428
       +
       				}

     

       2429
       +
       			},

     

       2430
       +
       		},

     

       2431
        
       		"/api/transcriptions": {

     

       2432
        
       			GET: async (req) => {

     

       2433
        
       				try {

     
···

       2570
        
       					const formData = await req.formData();

     

       2571
        
       					const file = formData.get("audio") as File;

     

       2572
        
       					const classId = formData.get("class_id") as string | null;

     

       2573
       +
       					const sectionId = formData.get("section_id") as string | null;

     

       2574
       +
       					const recordingDateStr = formData.get("recording_date") as

     

       2575
        
       						| string

     

       2576
        
       						| null;

     

       0
        
       
     

       2577
        
       

     

       2578
        
       					if (!file) throw ValidationErrors.missingField("audio");

     

       2579
        
       

     
···

       2640
        
       					const uploadDir = "./uploads";

     

       2641
        
       					await Bun.write(`${uploadDir}/${filename}`, file);

     

       2642
        
       

     

       2643
       +
       					// Parse recording date (default to current time if not provided)

     

       2644
       +
       					const recordingDate = recordingDateStr

     

       2645
       +
       						? Number.parseInt(recordingDateStr, 10)

     

       2646
       +
       						: Math.floor(Date.now() / 1000);

     

       2647
       +
       

     

       2648
       +
       					// Create database record (without meeting_time_id - will be set later via PATCH)

     

       2649
        
       					db.run(

     

       2650
       +
       						"INSERT INTO transcriptions (id, user_id, class_id, meeting_time_id, section_id, filename, original_filename, status, recording_date) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",

     

       2651
        
       						[

     

       2652
        
       							transcriptionId,

     

       2653
        
       							user.id,

     

       2654
        
       							classId,

     

       2655
       +
       							null, // meeting_time_id will be set via PATCH endpoint

     

       2656
        
       							sectionId,

     

       2657
        
       							filename,

     

       2658
        
       							file.name,

     

       2659
        
       							"pending",

     

       2660
       +
       							recordingDate,

     

       2661
        
       						],

     

       2662
        
       					);

     

       2663

+55

src/lib/audio-metadata.integration.test.ts

···

       1
       +
       import { afterAll, describe, expect, test } from "bun:test";

     

       2
       +
       import { extractAudioCreationDate } from "./audio-metadata";

     

       3
       +
       

     

       4
       +
       describe("extractAudioCreationDate (integration)", () => {

     

       5
       +
       	const testAudioPath = "./test-audio-sample.m4a";

     

       6
       +
       

     

       7
       +
       	// Clean up test file after tests

     

       8
       +
       	afterAll(async () => {

     

       9
       +
       		try {

     

       10
       +
       			await Bun.file(testAudioPath).exists().then(async (exists) => {

     

       11
       +
       				if (exists) {

     

       12
       +
       					await Bun.$`rm ${testAudioPath}`;

     

       13
       +
       				}

     

       14
       +
       			});

     

       15
       +
       		} catch {

     

       16
       +
       			// Ignore cleanup errors

     

       17
       +
       		}

     

       18
       +
       	});

     

       19
       +
       

     

       20
       +
       	test("extracts creation date from audio file with metadata", async () => {

     

       21
       +
       		// Create a test audio file with metadata using ffmpeg

     

       22
       +
       		// 1 second silent audio with creation_time metadata

     

       23
       +
       		const creationTime = "2024-01-15T14:30:00.000000Z";

     

       24
       +
       

     

       25
       +
       		// Create the file with metadata

     

       26
       +
       		await Bun.$`ffmpeg -f lavfi -i anullsrc=r=44100:cl=mono -t 1 -metadata creation_time=${creationTime} -y ${testAudioPath}`.quiet();

     

       27
       +
       

     

       28
       +
       		const date = await extractAudioCreationDate(testAudioPath);

     

       29
       +
       

     

       30
       +
       		expect(date).not.toBeNull();

     

       31
       +
       		expect(date).toBeInstanceOf(Date);

     

       32
       +
       		// JavaScript Date.toISOString() uses 3 decimal places, not 6 like the input

     

       33
       +
       		expect(date?.toISOString()).toBe("2024-01-15T14:30:00.000Z");

     

       34
       +
       	});

     

       35
       +
       

     

       36
       +
       	test("returns null for audio file without creation_time metadata", async () => {

     

       37
       +
       		// Create audio file without metadata

     

       38
       +
       		await Bun.$`ffmpeg -f lavfi -i anullsrc=r=44100:cl=mono -t 1 -y ${testAudioPath}`.quiet();

     

       39
       +
       

     

       40
       +
       		const date = await extractAudioCreationDate(testAudioPath);

     

       41
       +
       

     

       42
       +
       		// Should use file modification time as fallback

     

       43
       +
       		expect(date).not.toBeNull();

     

       44
       +
       		expect(date).toBeInstanceOf(Date);

     

       45
       +
       		// Should be very recent (within last minute)

     

       46
       +
       		const now = new Date();

     

       47
       +
       		const diff = now.getTime() - (date?.getTime() ?? 0);

     

       48
       +
       		expect(diff).toBeLessThan(60000); // Less than 1 minute

     

       49
       +
       	});

     

       50
       +
       

     

       51
       +
       	test("returns null for non-existent file", async () => {

     

       52
       +
       		const date = await extractAudioCreationDate("./non-existent-file.m4a");

     

       53
       +
       		expect(date).toBeNull();

     

       54
       +
       	});

     

       55
       +
       });

+128

src/lib/audio-metadata.test.ts

···

       1
       +
       import { describe, expect, test } from "bun:test";

     

       2
       +
       import {

     

       3
       +
       	findMatchingMeetingTime,

     

       4
       +
       	getDayName,

     

       5
       +
       	getDayOfWeek,

     

       6
       +
       	meetingTimeLabelMatchesDay,

     

       7
       +
       } from "./audio-metadata";

     

       8
       +
       

     

       9
       +
       describe("getDayOfWeek", () => {

     

       10
       +
       	test("returns correct day number", () => {

     

       11
       +
       		// January 1, 2024 is a Monday (day 1)

     

       12
       +
       		const monday = new Date("2024-01-01T12:00:00Z");

     

       13
       +
       		expect(getDayOfWeek(monday)).toBe(1);

     

       14
       +
       

     

       15
       +
       		// January 7, 2024 is a Sunday (day 0)

     

       16
       +
       		const sunday = new Date("2024-01-07T12:00:00Z");

     

       17
       +
       		expect(getDayOfWeek(sunday)).toBe(0);

     

       18
       +
       

     

       19
       +
       		// January 6, 2024 is a Saturday (day 6)

     

       20
       +
       		const saturday = new Date("2024-01-06T12:00:00Z");

     

       21
       +
       		expect(getDayOfWeek(saturday)).toBe(6);

     

       22
       +
       	});

     

       23
       +
       });

     

       24
       +
       

     

       25
       +
       describe("getDayName", () => {

     

       26
       +
       	test("returns correct day name", () => {

     

       27
       +
       		expect(getDayName(new Date("2024-01-01T12:00:00Z"))).toBe("Monday");

     

       28
       +
       		expect(getDayName(new Date("2024-01-02T12:00:00Z"))).toBe("Tuesday");

     

       29
       +
       		expect(getDayName(new Date("2024-01-03T12:00:00Z"))).toBe("Wednesday");

     

       30
       +
       		expect(getDayName(new Date("2024-01-04T12:00:00Z"))).toBe("Thursday");

     

       31
       +
       		expect(getDayName(new Date("2024-01-05T12:00:00Z"))).toBe("Friday");

     

       32
       +
       		expect(getDayName(new Date("2024-01-06T12:00:00Z"))).toBe("Saturday");

     

       33
       +
       		expect(getDayName(new Date("2024-01-07T12:00:00Z"))).toBe("Sunday");

     

       34
       +
       	});

     

       35
       +
       });

     

       36
       +
       

     

       37
       +
       describe("meetingTimeLabelMatchesDay", () => {

     

       38
       +
       	test("matches full day names", () => {

     

       39
       +
       		expect(meetingTimeLabelMatchesDay("Monday Lecture", "Monday")).toBe(true);

     

       40
       +
       		expect(meetingTimeLabelMatchesDay("Tuesday Lab", "Tuesday")).toBe(true);

     

       41
       +
       		expect(meetingTimeLabelMatchesDay("Wednesday Discussion", "Wednesday")).toBe(

     

       42
       +
       			true,

     

       43
       +
       		);

     

       44
       +
       	});

     

       45
       +
       

     

       46
       +
       	test("matches 3-letter abbreviations", () => {

     

       47
       +
       		expect(meetingTimeLabelMatchesDay("Mon Lecture", "Monday")).toBe(true);

     

       48
       +
       		expect(meetingTimeLabelMatchesDay("Tue Lab", "Tuesday")).toBe(true);

     

       49
       +
       		expect(meetingTimeLabelMatchesDay("Wed Discussion", "Wednesday")).toBe(

     

       50
       +
       			true,

     

       51
       +
       		);

     

       52
       +
       		expect(meetingTimeLabelMatchesDay("Thu Seminar", "Thursday")).toBe(true);

     

       53
       +
       		expect(meetingTimeLabelMatchesDay("Fri Workshop", "Friday")).toBe(true);

     

       54
       +
       		expect(meetingTimeLabelMatchesDay("Sat Review", "Saturday")).toBe(true);

     

       55
       +
       		expect(meetingTimeLabelMatchesDay("Sun Study", "Sunday")).toBe(true);

     

       56
       +
       	});

     

       57
       +
       

     

       58
       +
       	test("is case insensitive", () => {

     

       59
       +
       		expect(meetingTimeLabelMatchesDay("MONDAY LECTURE", "Monday")).toBe(true);

     

       60
       +
       		expect(meetingTimeLabelMatchesDay("monday lecture", "Monday")).toBe(true);

     

       61
       +
       		expect(meetingTimeLabelMatchesDay("MoNdAy LeCTuRe", "Monday")).toBe(true);

     

       62
       +
       	});

     

       63
       +
       

     

       64
       +
       	test("does not match wrong days", () => {

     

       65
       +
       		expect(meetingTimeLabelMatchesDay("Monday Lecture", "Tuesday")).toBe(false);

     

       66
       +
       		expect(meetingTimeLabelMatchesDay("Wednesday Lab", "Thursday")).toBe(false);

     

       67
       +
       		expect(meetingTimeLabelMatchesDay("Lecture Hall A", "Monday")).toBe(false);

     

       68
       +
       	});

     

       69
       +
       

     

       70
       +
       	test("handles labels without day names", () => {

     

       71
       +
       		expect(meetingTimeLabelMatchesDay("Lecture", "Monday")).toBe(false);

     

       72
       +
       		expect(meetingTimeLabelMatchesDay("Lab Session", "Tuesday")).toBe(false);

     

       73
       +
       		expect(meetingTimeLabelMatchesDay("Section A", "Wednesday")).toBe(false);

     

       74
       +
       	});

     

       75
       +
       });

     

       76
       +
       

     

       77
       +
       describe("findMatchingMeetingTime", () => {

     

       78
       +
       	const meetingTimes = [

     

       79
       +
       		{ id: "mt1", label: "Monday Lecture" },

     

       80
       +
       		{ id: "mt2", label: "Wednesday Discussion" },

     

       81
       +
       		{ id: "mt3", label: "Friday Lab" },

     

       82
       +
       	];

     

       83
       +
       

     

       84
       +
       	test("finds correct meeting time for full day name", () => {

     

       85
       +
       		const monday = new Date("2024-01-01T12:00:00Z"); // Monday

     

       86
       +
       		expect(findMatchingMeetingTime(monday, meetingTimes)).toBe("mt1");

     

       87
       +
       

     

       88
       +
       		const wednesday = new Date("2024-01-03T12:00:00Z"); // Wednesday

     

       89
       +
       		expect(findMatchingMeetingTime(wednesday, meetingTimes)).toBe("mt2");

     

       90
       +
       

     

       91
       +
       		const friday = new Date("2024-01-05T12:00:00Z"); // Friday

     

       92
       +
       		expect(findMatchingMeetingTime(friday, meetingTimes)).toBe("mt3");

     

       93
       +
       	});

     

       94
       +
       

     

       95
       +
       	test("finds correct meeting time for abbreviated day name", () => {

     

       96
       +
       		const abbrevMeetingTimes = [

     

       97
       +
       			{ id: "mt1", label: "Mon Lecture" },

     

       98
       +
       			{ id: "mt2", label: "Wed Discussion" },

     

       99
       +
       			{ id: "mt3", label: "Fri Lab" },

     

       100
       +
       		];

     

       101
       +
       

     

       102
       +
       		const monday = new Date("2024-01-01T12:00:00Z");

     

       103
       +
       		expect(findMatchingMeetingTime(monday, abbrevMeetingTimes)).toBe("mt1");

     

       104
       +
       	});

     

       105
       +
       

     

       106
       +
       	test("returns null when no match found", () => {

     

       107
       +
       		const tuesday = new Date("2024-01-02T12:00:00Z"); // Tuesday

     

       108
       +
       		expect(findMatchingMeetingTime(tuesday, meetingTimes)).toBe(null);

     

       109
       +
       

     

       110
       +
       		const saturday = new Date("2024-01-06T12:00:00Z"); // Saturday

     

       111
       +
       		expect(findMatchingMeetingTime(saturday, meetingTimes)).toBe(null);

     

       112
       +
       	});

     

       113
       +
       

     

       114
       +
       	test("returns null for empty meeting times", () => {

     

       115
       +
       		const monday = new Date("2024-01-01T12:00:00Z");

     

       116
       +
       		expect(findMatchingMeetingTime(monday, [])).toBe(null);

     

       117
       +
       	});

     

       118
       +
       

     

       119
       +
       	test("returns first match when multiple matches exist", () => {

     

       120
       +
       		const duplicateMeetingTimes = [

     

       121
       +
       			{ id: "mt1", label: "Monday Lecture" },

     

       122
       +
       			{ id: "mt2", label: "Monday Lab" },

     

       123
       +
       		];

     

       124
       +
       

     

       125
       +
       		const monday = new Date("2024-01-01T12:00:00Z");

     

       126
       +
       		expect(findMatchingMeetingTime(monday, duplicateMeetingTimes)).toBe("mt1");

     

       127
       +
       	});

     

       128
       +
       });

+144

src/lib/audio-metadata.ts

···

       1
       +
       import { $ } from "bun";

     

       2
       +
       

     

       3
       +
       /**

     

       4
       +
        * Extracts creation date from audio file metadata using ffprobe

     

       5
       +
        * Falls back to file birth time (original creation) if no metadata found

     

       6
       +
        * @param filePath Path to audio file

     

       7
       +
        * @returns Date object or null if not found

     

       8
       +
        */

     

       9
       +
       export async function extractAudioCreationDate(

     

       10
       +
       	filePath: string,

     

       11
       +
       ): Promise<Date | null> {

     

       12
       +
       	try {

     

       13
       +
       		// Use ffprobe to extract creation_time metadata

     

       14
       +
       		// -v quiet: suppress verbose output

     

       15
       +
       		// -print_format json: output as JSON

     

       16
       +
       		// -show_entries format_tags: show all tags to search for date fields

     

       17
       +
       		const result =

     

       18
       +
       			await $`ffprobe -v quiet -print_format json -show_entries format_tags ${filePath}`.text();

     

       19
       +
       

     

       20
       +
       		const metadata = JSON.parse(result);

     

       21
       +
       		const tags = metadata?.format?.tags || {};

     

       22
       +
       

     

       23
       +
       		// Try multiple metadata fields that might contain creation date

     

       24
       +
       		const dateFields = [

     

       25
       +
       			tags.creation_time, // Standard creation_time

     

       26
       +
       			tags.date, // Common date field

     

       27
       +
       			tags.DATE, // Uppercase variant

     

       28
       +
       			tags.year, // Year field

     

       29
       +
       			tags.YEAR, // Uppercase variant

     

       30
       +
       			tags["com.apple.quicktime.creationdate"], // Apple QuickTime

     

       31
       +
       			tags.TDRC, // ID3v2 recording time

     

       32
       +
       			tags.TDRL, // ID3v2 release time

     

       33
       +
       		];

     

       34
       +
       

     

       35
       +
       		for (const dateField of dateFields) {

     

       36
       +
       			if (dateField) {

     

       37
       +
       				const date = new Date(dateField);

     

       38
       +
       				if (!Number.isNaN(date.getTime())) {

     

       39
       +
       					console.log(

     

       40
       +
       						`[AudioMetadata] Extracted creation date from metadata: ${date.toISOString()} from ${filePath}`,

     

       41
       +
       					);

     

       42
       +
       					return date;

     

       43
       +
       				}

     

       44
       +
       			}

     

       45
       +
       		}

     

       46
       +
       

     

       47
       +
       		// Fallback: use file birth time (original creation time on filesystem)

     

       48
       +
       		// This preserves the original file creation date better than mtime

     

       49
       +
       		console.log(

     

       50
       +
       			`[AudioMetadata] No creation_time metadata found, using file birth time`,

     

       51
       +
       		);

     

       52
       +
       		const file = Bun.file(filePath);

     

       53
       +
       		const stat = await file.stat();

     

       54
       +
       		const date = new Date(stat.birthtime || stat.mtime);

     

       55
       +
       		console.log(

     

       56
       +
       			`[AudioMetadata] Using file birth time: ${date.toISOString()} from ${filePath}`,

     

       57
       +
       		);

     

       58
       +
       		return date;

     

       59
       +
       	} catch (error) {

     

       60
       +
       		console.error(

     

       61
       +
       			`[AudioMetadata] Failed to extract metadata from ${filePath}:`,

     

       62
       +
       			error instanceof Error ? error.message : "Unknown error",

     

       63
       +
       		);

     

       64
       +
       		return null;

     

       65
       +
       	}

     

       66
       +
       }

     

       67
       +
       

     

       68
       +
       /**

     

       69
       +
        * Gets day of week from a date (0 = Sunday, 6 = Saturday)

     

       70
       +
        */

     

       71
       +
       export function getDayOfWeek(date: Date): number {

     

       72
       +
       	return date.getDay();

     

       73
       +
       }

     

       74
       +
       

     

       75
       +
       /**

     

       76
       +
        * Gets day name from a date

     

       77
       +
        */

     

       78
       +
       export function getDayName(date: Date): string {

     

       79
       +
       	const days = [

     

       80
       +
       		"Sunday",

     

       81
       +
       		"Monday",

     

       82
       +
       		"Tuesday",

     

       83
       +
       		"Wednesday",

     

       84
       +
       		"Thursday",

     

       85
       +
       		"Friday",

     

       86
       +
       		"Saturday",

     

       87
       +
       	];

     

       88
       +
       	return days[date.getDay()] || "Unknown";

     

       89
       +
       }

     

       90
       +
       

     

       91
       +
       /**

     

       92
       +
        * Checks if a meeting time label matches a specific day

     

       93
       +
        * Labels like "Monday Lecture", "Tuesday Lab", "Wed Discussion" should match

     

       94
       +
        */

     

       95
       +
       export function meetingTimeLabelMatchesDay(

     

       96
       +
       	label: string,

     

       97
       +
       	dayName: string,

     

       98
       +
       ): boolean {

     

       99
       +
       	const lowerLabel = label.toLowerCase();

     

       100
       +
       	const lowerDay = dayName.toLowerCase();

     

       101
       +
       

     

       102
       +
       	// Check for full day name

     

       103
       +
       	if (lowerLabel.includes(lowerDay)) {

     

       104
       +
       		return true;

     

       105
       +
       	}

     

       106
       +
       

     

       107
       +
       	// Check for 3-letter abbreviations

     

       108
       +
       	const abbrev = dayName.slice(0, 3).toLowerCase();

     

       109
       +
       	if (lowerLabel.includes(abbrev)) {

     

       110
       +
       		return true;

     

       111
       +
       	}

     

       112
       +
       

     

       113
       +
       	return false;

     

       114
       +
       }

     

       115
       +
       

     

       116
       +
       /**

     

       117
       +
        * Finds the best matching meeting time for a given date

     

       118
       +
        * @param date Date from audio metadata

     

       119
       +
        * @param meetingTimes Available meeting times for the class

     

       120
       +
        * @returns Meeting time ID or null if no match

     

       121
       +
        */

     

       122
       +
       export function findMatchingMeetingTime(

     

       123
       +
       	date: Date,

     

       124
       +
       	meetingTimes: Array<{ id: string; label: string }>,

     

       125
       +
       ): string | null {

     

       126
       +
       	const dayName = getDayName(date);

     

       127
       +
       

     

       128
       +
       	// Find meeting time that matches the day

     

       129
       +
       	const match = meetingTimes.find((mt) =>

     

       130
       +
       		meetingTimeLabelMatchesDay(mt.label, dayName),

     

       131
       +
       	);

     

       132
       +
       

     

       133
       +
       	if (match) {

     

       134
       +
       		console.log(

     

       135
       +
       			`[AudioMetadata] Matched ${dayName} to meeting time: ${match.label}`,

     

       136
       +
       		);

     

       137
       +
       		return match.id;

     

       138
       +
       	}

     

       139
       +
       

     

       140
       +
       	console.log(

     

       141
       +
       		`[AudioMetadata] No meeting time found matching ${dayName} in available options: ${meetingTimes.map((mt) => mt.label).join(", ")}`,

     

       142
       +
       	);

     

       143
       +
       	return null;

     

       144
       +
       }

+1 -1

src/lib/classes.ts

···

       406
        
       			`SELECT id, user_id, meeting_time_id, section_id, filename, original_filename, status, progress, error_message, created_at, updated_at

     

       407
        
              FROM transcriptions

     

       408
        
              WHERE class_id = ?

     

       409
       -
              ORDER BY created_at DESC`,

     

       410
        
       		)

     

       411
        
       		.all(classId);

     

       412
        
       }

···

       406
        
       			`SELECT id, user_id, meeting_time_id, section_id, filename, original_filename, status, progress, error_message, created_at, updated_at

     

       407
        
              FROM transcriptions

     

       408
        
              WHERE class_id = ?

     

       409
       +
              ORDER BY recording_date DESC, created_at DESC`,

     

       410
        
       		)

     

       411
        
       		.all(classId);

     

       412
        
       }

+227

src/lib/voting.ts

···

       1
       +
       import { nanoid } from "nanoid";

     

       2
       +
       import db from "../db/schema";

     

       3
       +
       

     

       4
       +
       /**

     

       5
       +
        * Vote for a recording

     

       6
       +
        * Returns true if vote was recorded, false if already voted

     

       7
       +
        */

     

       8
       +
       export function voteForRecording(

     

       9
       +
       	transcriptionId: string,

     

       10
       +
       	userId: number,

     

       11
       +
       ): boolean {

     

       12
       +
       	try {

     

       13
       +
       		const voteId = nanoid();

     

       14
       +
       		db.run(

     

       15
       +
       			"INSERT INTO recording_votes (id, transcription_id, user_id) VALUES (?, ?, ?)",

     

       16
       +
       			[voteId, transcriptionId, userId],

     

       17
       +
       		);

     

       18
       +
       

     

       19
       +
       		// Increment vote count on transcription

     

       20
       +
       		db.run(

     

       21
       +
       			"UPDATE transcriptions SET vote_count = vote_count + 1 WHERE id = ?",

     

       22
       +
       			[transcriptionId],

     

       23
       +
       		);

     

       24
       +
       

     

       25
       +
       		return true;

     

       26
       +
       	} catch (error) {

     

       27
       +
       		// Unique constraint violation means user already voted

     

       28
       +
       		if (

     

       29
       +
       			error instanceof Error &&

     

       30
       +
       			error.message.includes("UNIQUE constraint failed")

     

       31
       +
       		) {

     

       32
       +
       			return false;

     

       33
       +
       		}

     

       34
       +
       		throw error;

     

       35
       +
       	}

     

       36
       +
       }

     

       37
       +
       

     

       38
       +
       /**

     

       39
       +
        * Remove vote for a recording

     

       40
       +
        */

     

       41
       +
       export function removeVote(transcriptionId: string, userId: number): boolean {

     

       42
       +
       	const result = db.run(

     

       43
       +
       		"DELETE FROM recording_votes WHERE transcription_id = ? AND user_id = ?",

     

       44
       +
       		[transcriptionId, userId],

     

       45
       +
       	);

     

       46
       +
       

     

       47
       +
       	if (result.changes > 0) {

     

       48
       +
       		// Decrement vote count on transcription

     

       49
       +
       		db.run(

     

       50
       +
       			"UPDATE transcriptions SET vote_count = vote_count - 1 WHERE id = ?",

     

       51
       +
       			[transcriptionId],

     

       52
       +
       		);

     

       53
       +
       		return true;

     

       54
       +
       	}

     

       55
       +
       

     

       56
       +
       	return false;

     

       57
       +
       }

     

       58
       +
       

     

       59
       +
       /**

     

       60
       +
        * Get user's vote for a specific class meeting time

     

       61
       +
        */

     

       62
       +
       export function getUserVoteForMeeting(

     

       63
       +
       	userId: number,

     

       64
       +
       	classId: string,

     

       65
       +
       	meetingTimeId: string,

     

       66
       +
       ): string | null {

     

       67
       +
       	const result = db

     

       68
       +
       		.query<

     

       69
       +
       			{ transcription_id: string },

     

       70
       +
       			[number, string, string]

     

       71
       +
       		>(

     

       72
       +
       			`SELECT rv.transcription_id 

     

       73
       +
              FROM recording_votes rv

     

       74
       +
              JOIN transcriptions t ON rv.transcription_id = t.id

     

       75
       +
              WHERE rv.user_id = ? 

     

       76
       +
                AND t.class_id = ? 

     

       77
       +
                AND t.meeting_time_id = ?

     

       78
       +
                AND t.status = 'pending'`,

     

       79
       +
       		)

     

       80
       +
       		.get(userId, classId, meetingTimeId);

     

       81
       +
       

     

       82
       +
       	return result?.transcription_id || null;

     

       83
       +
       }

     

       84
       +
       

     

       85
       +
       /**

     

       86
       +
        * Get all pending recordings for a class meeting time (filtered by section)

     

       87
       +
        */

     

       88
       +
       export function getPendingRecordings(

     

       89
       +
       	classId: string,

     

       90
       +
       	meetingTimeId: string,

     

       91
       +
       	sectionId?: string | null,

     

       92
       +
       ) {

     

       93
       +
       	// Build query based on whether section filtering is needed

     

       94
       +
       	let query = `SELECT id, user_id, filename, original_filename, vote_count, created_at, section_id

     

       95
       +
              FROM transcriptions

     

       96
       +
              WHERE class_id = ? 

     

       97
       +
                AND meeting_time_id = ?

     

       98
       +
                AND status = 'pending'`;

     

       99
       +
       

     

       100
       +
       	const params: (string | null)[] = [classId, meetingTimeId];

     

       101
       +
       

     

       102
       +
       	// Filter by section if provided (for voting - section-specific)

     

       103
       +
       	if (sectionId !== undefined) {

     

       104
       +
       		query += " AND (section_id = ? OR section_id IS NULL)";

     

       105
       +
       		params.push(sectionId);

     

       106
       +
       	}

     

       107
       +
       

     

       108
       +
       	query += " ORDER BY vote_count DESC, created_at ASC";

     

       109
       +
       

     

       110
       +
       	return db

     

       111
       +
       		.query<

     

       112
       +
       			{

     

       113
       +
       				id: string;

     

       114
       +
       				user_id: number;

     

       115
       +
       				filename: string;

     

       116
       +
       				original_filename: string;

     

       117
       +
       				vote_count: number;

     

       118
       +
       				created_at: number;

     

       119
       +
       				section_id: string | null;

     

       120
       +
       			},

     

       121
       +
       			(string | null)[]

     

       122
       +
       		>(query)

     

       123
       +
       		.all(...params);

     

       124
       +
       }

     

       125
       +
       

     

       126
       +
       /**

     

       127
       +
        * Get total enrolled users count for a class

     

       128
       +
        */

     

       129
       +
       export function getEnrolledUserCount(classId: string): number {

     

       130
       +
       	const result = db

     

       131
       +
       		.query<{ count: number }, [string]>(

     

       132
       +
       			"SELECT COUNT(*) as count FROM class_members WHERE class_id = ?",

     

       133
       +
       		)

     

       134
       +
       		.get(classId);

     

       135
       +
       

     

       136
       +
       	return result?.count || 0;

     

       137
       +
       }

     

       138
       +
       

     

       139
       +
       /**

     

       140
       +
        * Check if recording should be auto-submitted

     

       141
       +
        * Returns winning recording ID if ready, null otherwise

     

       142
       +
        */

     

       143
       +
       export function checkAutoSubmit(

     

       144
       +
       	classId: string,

     

       145
       +
       	meetingTimeId: string,

     

       146
       +
       	sectionId?: string | null,

     

       147
       +
       ): string | null {

     

       148
       +
       	const recordings = getPendingRecordings(classId, meetingTimeId, sectionId);

     

       149
       +
       

     

       150
       +
       	if (recordings.length === 0) {

     

       151
       +
       		return null;

     

       152
       +
       	}

     

       153
       +
       

     

       154
       +
       	const totalUsers = getEnrolledUserCount(classId);

     

       155
       +
       	const now = Date.now() / 1000; // Current time in seconds

     

       156
       +
       

     

       157
       +
       	// Get the recording with most votes

     

       158
       +
       	const topRecording = recordings[0];

     

       159
       +
       	if (!topRecording) return null;

     

       160
       +
       

     

       161
       +
       	const uploadedAt = topRecording.created_at;

     

       162
       +
       	const timeSinceUpload = now - uploadedAt;

     

       163
       +
       

     

       164
       +
       	// Auto-submit if:

     

       165
       +
       	// 1. 30 minutes have passed since first upload, OR

     

       166
       +
       	// 2. 40% of enrolled users have voted for the top recording

     

       167
       +
       	const thirtyMinutes = 30 * 60; // 30 minutes in seconds

     

       168
       +
       	const voteThreshold = Math.ceil(totalUsers * 0.4);

     

       169
       +
       

     

       170
       +
       	if (timeSinceUpload >= thirtyMinutes) {

     

       171
       +
       		console.log(

     

       172
       +
       			`[Voting] Auto-submitting ${topRecording.id} - 30 minutes elapsed`,

     

       173
       +
       		);

     

       174
       +
       		return topRecording.id;

     

       175
       +
       	}

     

       176
       +
       

     

       177
       +
       	if (topRecording.vote_count >= voteThreshold) {

     

       178
       +
       		console.log(

     

       179
       +
       			`[Voting] Auto-submitting ${topRecording.id} - reached ${topRecording.vote_count}/${voteThreshold} votes (40% threshold)`,

     

       180
       +
       		);

     

       181
       +
       		return topRecording.id;

     

       182
       +
       	}

     

       183
       +
       

     

       184
       +
       	return null;

     

       185
       +
       }

     

       186
       +
       

     

       187
       +
       /**

     

       188
       +
        * Mark a recording as auto-submitted and start transcription

     

       189
       +
        */

     

       190
       +
       export function markAsAutoSubmitted(transcriptionId: string): void {

     

       191
       +
       	db.run(

     

       192
       +
       		"UPDATE transcriptions SET auto_submitted = 1 WHERE id = ?",

     

       193
       +
       		[transcriptionId],

     

       194
       +
       	);

     

       195
       +
       }

     

       196
       +
       

     

       197
       +
       /**

     

       198
       +
        * Delete a pending recording (only allowed by uploader or admin)

     

       199
       +
        */

     

       200
       +
       export function deletePendingRecording(

     

       201
       +
       	transcriptionId: string,

     

       202
       +
       	userId: number,

     

       203
       +
       	isAdmin: boolean,

     

       204
       +
       ): boolean {

     

       205
       +
       	// Check ownership if not admin

     

       206
       +
       	if (!isAdmin) {

     

       207
       +
       		const recording = db

     

       208
       +
       			.query<{ user_id: number; status: string }, [string]>(

     

       209
       +
       				"SELECT user_id, status FROM transcriptions WHERE id = ?",

     

       210
       +
       			)

     

       211
       +
       			.get(transcriptionId);

     

       212
       +
       

     

       213
       +
       		if (!recording || recording.user_id !== userId) {

     

       214
       +
       			return false;

     

       215
       +
       		}

     

       216
       +
       

     

       217
       +
       		// Only allow deleting pending recordings

     

       218
       +
       		if (recording.status !== "pending") {

     

       219
       +
       			return false;

     

       220
       +
       		}

     

       221
       +
       	}

     

       222
       +
       

     

       223
       +
       	// Delete the recording (cascades to votes)

     

       224
       +
       	db.run("DELETE FROM transcriptions WHERE id = ?", [transcriptionId]);

     

       225
       +
       

     

       226
       +
       	return true;

     

       227
       +
       }

Compare changes