Jeffn/cohort plans

src/api/ceCohortService.ts

@@ -17,12 +17,13 @@ class CECohortService extends EntityService<Cohort> {
     async create(): Promise<Cohort> {
         return studentService.findUnenrolled()
             .then(students => {
-                return cohortService.insert(
-                    {
-                        id: uuidv4(),
-                        name: `(New) Cohort`,
-                    } as Cohort
-                )
+                return cohortService
+                    .insert(
+                        {
+                            id: uuidv4(),
+                            name: `(New) Cohort`,
+                        } as Cohort
+                    )
                     .then(cohort => {
                         const enrollments = students.map(student => {
                             return {
@@ -38,9 +39,9 @@ class CECohortService extends EntityService<Cohort> {
 
     async getById(entityId: string | number, select?: string): Promise<Cohort | null> {
         try {
-            const cohort = await super.getById(entityId, select ?? '*, plan(*)')
+            const cohort = await super.getById(entityId, select ?? '*, enrollment(*), plan(*)');
+            console.log(cohort);
             if (cohort) {
-                console.log(cohort)
                 return {
                     ...cohort,
                     plans: []   // TODO join into plans

src/api/ceEnrollmentService.ts

@@ -14,11 +14,15 @@ class CEEnrollmentService extends EntityService<Enrollment> {
 
     async getStudents(cohort: Cohort): Promise<Student[]> {
         return await supabaseClient
-            .from('enrollment')
+            .from(this.tableName)
             .select('student(*)')
             .eq('cohort_id', cohort.id)
-            .then(resp => resp.data as unknown as Student[]);
+            .then(resp => {
+                const objects = resp.data as unknown as any[];
+                return objects.map(ss => ss.student) as Student[];
+            });
     }
+
 }
 
 const enrollmentService = new CEEnrollmentService('enrollment')

src/api/cePlacementService.ts

@@ -0,0 +1,26 @@
+/**
+ *  ceCohortService.ts
+ *
+ *  @copyright 2025 Digital Aid Seattle
+ *
+ */
+
+import { supabaseClient } from "@digitalaidseattle/supabase";
+import { EntityService } from "./entityService";
+import { Identifier, Placement } from "./types";
+
+
+class CEPlacementService extends EntityService<Placement> {
+
+    async findByPlanId(planId: Identifier): Promise<Placement[]> {
+        return await supabaseClient
+            .from(this.tableName)
+            .select('*, student(*)')
+            .eq('plan_id', planId)
+            .then(resp => resp.data as Placement[]);
+    }    
+}
+
+const placementService = new CEPlacementService('placement')
+export { placementService };
+

src/api/cePlanService.ts

@@ -5,104 +5,69 @@
  *
  */
 
-import { Placement, Plan } from "./types";
+import { supabaseClient } from "@digitalaidseattle/supabase";
+import { v4 as uuidv4 } from 'uuid';
+import { placementService } from "./cePlacementService";
+import { EntityService } from "./entityService";
+import { Cohort, Identifier, Placement, Plan } from "./types";
+import { enrollmentService } from "./ceEnrollmentService";
 
-const TEST_PLAN = {
-    id: '1',
-    name: 'Plan1',
-    rating: 0,
-    notes: '',
-    cohort_id: "sess1",
-    placements: [
-        {
-            id: '1',
-            cohort_id: '1',
-            student_id: 's1',
-            student: {
-                id: '',
-                name: 'Student 1',
-                age: null,
-                email: '',
-                city: '',
-                state: '',
-                country: '',
-                availabilities: []
-            },
-            anchor: true,
-            availabilities: []
-        } ,
-        {
-            id: '2',
-            cohort_id: '1',
-            student_id: 's2',
-            student: {
-                id: '',
-                name: 'Student 2',
-                age: null,
-                email: '',
-                city: '',
-                state: '',
-                country: '',
-                availabilities: []
-            },
-            anchor: false,
-            availabilities: []
-        },
-        {
-            id: '3',
-            cohort_id: '1',
-            student_id: 's3',
-            student: {
-                id: '',
-                name: 'Student 3',
-                age: null,
-                email: '',
-                city: '',
-                state: '',
-                country: '',
-                availabilities: []
-            },
-            anchor: false,
-            availabilities: []
-        }
-    ]  as Placement[],
-    groups: [
-        {
-            id: undefined,
-            groupNo: 'Group 1',
-            studentIds: ['s1']
-        },
-        {
-            id: undefined,
-            groupNo: 'Group 2',
-            studentIds: ['s2', 's3']
-        },
-        {
-            id: undefined,
-            groupNo: 'Group 3',
-            studentIds: []
-        }
-    ],
-} as Plan;
-
-class CEPlanService {
-    async getById(id: string): Promise<Plan> {
-        console.log("get plan", id);
-        return TEST_PLAN;
+class CEPlanService extends EntityService<Plan> {
+    async create(cohort: Cohort): Promise<Plan> {
+        const proposed: Plan = {
+            id: uuidv4(),
+            name: 'New Plan',
+            note: '',
+            cohort_id: cohort.id
+        } as Plan
+        // 
+        return enrollmentService.getStudents(cohort)
+            .then(students => {
+                return this.insert(proposed)
+                    .then(plan => {
+                        const placements = students.map(student => {
+                            return {
+                                plan_id: plan.id,
+                                student_id: student.id,
+                                anchor: false,
+                                priority: 0
+                            } as Placement
+                        })
+                        return placementService
+                            .batchInsert(placements)
+                            .then(createdPlacements => {
+                                plan.placements = createdPlacements;
+                                return plan;
+                            })
+                    })
+            });
     }
 
-    async findByCohortId(cohortId: string): Promise<Plan[]> {
-        console.log("get plans for cohort ", cohortId);
-        return [TEST_PLAN]
+    async duplicate(plan: Plan): Promise<Plan> {
+        const proposed: Plan = {
+            id: uuidv4(),
+            name: plan.name + ' (copy)',
+            note: '',
+            cohort_id: plan.cohort_id
+        } as Plan
+        return this.insert(proposed)
+            .then(plan => {
+                // TODO copy placements
+                // TODO copy groups? 
+                return plan;
+            })
     }
 
-    async duplicate(plan: Plan): Promise<Plan[]> {
-        alert(`  '${plan.name}' would be duplicated  ${plan.name}`)
-        return [{ ...TEST_PLAN }]
+    async findByCohortId(cohort_id: Identifier): Promise<Plan[]> {
+        return await supabaseClient
+            .from(this.tableName)
+            .select('*')
+            .eq('cohort_id', cohort_id)
+            .then(resp => resp.data as Plan[]);
     }
 
 }
 
-const planService = new CEPlanService()
+const planService = new CEPlanService('plan')
 export { planService };
 

src/api/entityService.ts

@@ -6,7 +6,7 @@
  */
 
 import { PageInfo, QueryModel, supabaseClient } from "@digitalaidseattle/supabase";
-import { Entity } from "./types";
+import { Entity, Identifier } from "./types";
 
 abstract class EntityService<T extends Entity> {
 
@@ -88,7 +88,7 @@ abstract class EntityService<T extends Entity> {
         }
     }
 
-    async batchInsert(entities: T[], select?: string): Promise<T> {
+    async batchInsert(entities: T[], select?: string): Promise<T[]> {
         try {
             const { data, error } = await supabaseClient
                 .from(this.tableName)
@@ -98,7 +98,7 @@ abstract class EntityService<T extends Entity> {
                 console.error('Error inserting entity:', error.message);
                 throw new Error('Failed to insert entity');
             }
-            return data as unknown as T;
+            return data as unknown as T[];
         } catch (err) {
             console.error('Unexpected error during insertion:', err);
             throw err;
@@ -141,7 +141,7 @@ abstract class EntityService<T extends Entity> {
         }
     }
 
-    async delete(entityId: string): Promise<void> {
+    async delete(entityId: Identifier): Promise<void> {
         try {
             const { error } = await supabaseClient
                 .from(this.tableName)

src/api/types.ts

@@ -4,8 +4,10 @@
  * @copyright 2025 Digital Aid Seattle
  *
  */
+type Identifier = string | number;
+
 type Entity = {
-    id: string | number;
+    id: Identifier;
 }
 
 type Availability = {
@@ -54,32 +56,35 @@ type Group = {
 }
 
 type Enrollment = Entity & {
-    cohort_id: string | number;
-    student_id: string | number;
+    cohort_id: Identifier;
+    student_id: Identifier;
 }
 
-type Placement = Entity &  {
-    cohort_id: string;
-    student_id: string;
+type Placement = Entity & {
+    plan_id: Identifier;
+    student_id: Identifier;
     student: Student;
     anchor: boolean;
+    priority: number;
     availabilities: Availability[];
 }
 
 type Plan = Entity & {
     name: string;
-    cohort_id: string;
-    placements: Placement[]
+    cohort_id: Identifier;
+    numberOfGroups: number;
+    placements: Placement[];
     groups: Group[];
     rating: number;
-    notes: string;
+    note: string;
 }
 
 export type {
     Availability,
     Enrollment,
     Entity,
     FailedStudent,
+    Identifier,
     Student,
     StudentField,
     SelectAvailability,