commit b8fed9380c0cf940429574a8227756d03faf4f3e · dunkirk.sh/thistle

+17 -2

src/components/classes-overview.ts

···

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

     

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

     

       3
       3
       +
       import "./class-registration-modal";

     

       3
       4
        
       

     

       4
       5
        
       interface Class {

     

       5
       6
        
       	id: string;

     
···

       20
       21
        
       	@state() classes: ClassesGrouped = {};

     

       21
       22
        
       	@state() isLoading = true;

     

       22
       23
        
       	@state() error: string | null = null;

     

       24
       24
       +
       	@state() showRegistrationModal = false;

     

       23
       25
        
       

     

       24
       26
        
       	static override styles = css`

     

       25
       27
        
           :host {

     
···

       205
       207
        
       	}

     

       206
       208
        
       

     

       207
       209
        
       	private handleRegisterClick() {

     

       208
       208
       -
       		// TODO: Open registration modal/form

     

       209
       209
       -
       		alert("Class registration coming soon!");

     

       210
       210
       +
       		this.showRegistrationModal = true;

     

       211
       211
       +
       	}

     

       212
       212
       +
       

     

       213
       213
       +
       	private handleModalClose() {

     

       214
       214
       +
       		this.showRegistrationModal = false;

     

       215
       215
       +
       	}

     

       216
       216
       +
       

     

       217
       217
       +
       	private async handleClassJoined() {

     

       218
       218
       +
       		await this.loadClasses();

     

       210
       219
        
       	}

     

       211
       220
        
       

     

       212
       221
        
       	override render() {

     
···

       274
       283
        
                 </div>

     

       275
       284
        
               `

     

       276
       285
        
       			}

     

       286
       286
       +
       

     

       287
       287
       +
             <class-registration-modal

     

       288
       288
       +
               ?open=${this.showRegistrationModal}

     

       289
       289
       +
               @close=${this.handleModalClose}

     

       290
       290
       +
               @class-joined=${this.handleClassJoined}

     

       291
       291
       +
             ></class-registration-modal>

     

       277
       292
        
           `;

     

       278
       293
        
       	}

     

       279
       294
        
       }

+27

src/index.ts

···

       37
       37
        
       	getMeetingTimesForClass,

     

       38
       38
        
       	getTranscriptionsForClass,

     

       39
       39
        
       	isUserEnrolledInClass,

     

       40
       40
       +
       	joinClassByCode,

     

       40
       41
        
       	removeUserFromClass,

     

       41
       42
        
       	toggleClassArchive,

     

       42
       43
        
       	updateMeetingTime,

     
···

       1489
       1490
        
       					});

     

       1490
       1491
        
       

     

       1491
       1492
        
       					return Response.json(newClass);

     

       1493
       1493
       +
       				} catch (error) {

     

       1494
       1494
       +
       					return handleError(error);

     

       1495
       1495
       +
       				}

     

       1496
       1496
       +
       			},

     

       1497
       1497
       +
       		},

     

       1498
       1498
       +
       		"/api/classes/join": {

     

       1499
       1499
       +
       			POST: async (req) => {

     

       1500
       1500
       +
       				try {

     

       1501
       1501
       +
       					const user = requireAuth(req);

     

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

     

       1503
       1503
       +
       					const classCode = body.class_code;

     

       1504
       1504
       +
       

     

       1505
       1505
       +
       					if (!classCode || typeof classCode !== "string") {

     

       1506
       1506
       +
       						return Response.json(

     

       1507
       1507
       +
       							{ error: "Class code required" },

     

       1508
       1508
       +
       							{ status: 400 },

     

       1509
       1509
       +
       						);

     

       1510
       1510
       +
       					}

     

       1511
       1511
       +
       

     

       1512
       1512
       +
       					const result = joinClassByCode(classCode.trim(), user.id);

     

       1513
       1513
       +
       

     

       1514
       1514
       +
       					if (!result.success) {

     

       1515
       1515
       +
       						return Response.json({ error: result.error }, { status: 400 });

     

       1516
       1516
       +
       					}

     

       1517
       1517
       +
       

     

       1518
       1518
       +
       					return Response.json({ success: true, class_id: result.classId });

     

       1492
       1519
        
       				} catch (error) {

     

       1493
       1520
        
       					return handleError(error);

     

       1494
       1521
        
       				}

+38

src/lib/classes.ts

···

       247
       247
        
       		)

     

       248
       248
        
       		.all(classId);

     

       249
       249
        
       }

     

       250
       250
       +
       

     

       251
       251
       +
       /**

     

       252
       252
       +
        * Join a class by class code

     

       253
       253
       +
        */

     

       254
       254
       +
       export function joinClassByCode(

     

       255
       255
       +
       	classCode: string,

     

       256
       256
       +
       	userId: number,

     

       257
       257
       +
       ): { success: boolean; classId?: string; error?: string } {

     

       258
       258
       +
       	// Find class by code (case-insensitive)

     

       259
       259
       +
       	const cls = db

     

       260
       260
       +
       		.query<Class, [string]>(

     

       261
       261
       +
       			"SELECT * FROM classes WHERE UPPER(id) = UPPER(?) AND archived = 0",

     

       262
       262
       +
       		)

     

       263
       263
       +
       		.get(classCode);

     

       264
       264
       +
       

     

       265
       265
       +
       	if (!cls) {

     

       266
       266
       +
       		return { success: false, error: "Class not found or is archived" };

     

       267
       267
       +
       	}

     

       268
       268
       +
       

     

       269
       269
       +
       	// Check if already enrolled

     

       270
       270
       +
       	const existing = db

     

       271
       271
       +
       		.query<ClassMember, [string, number]>(

     

       272
       272
       +
       			"SELECT * FROM class_members WHERE class_id = ? AND user_id = ?",

     

       273
       273
       +
       		)

     

       274
       274
       +
       		.get(cls.id, userId);

     

       275
       275
       +
       

     

       276
       276
       +
       	if (existing) {

     

       277
       277
       +
       		return { success: false, error: "Already enrolled in this class" };

     

       278
       278
       +
       	}

     

       279
       279
       +
       

     

       280
       280
       +
       	// Enroll user

     

       281
       281
       +
       	db.query(

     

       282
       282
       +
       		"INSERT INTO class_members (class_id, user_id, enrolled_at) VALUES (?, ?, ?)",

     

       283
       283
       +
       	).run(cls.id, userId, Math.floor(Date.now() / 1000));

     

       284
       284
       +
       

     

       285
       285
       +
       	return { success: true, classId: cls.id };

     

       286
       286
       +
       }

     

       287
       287
       +