feat: add external time handling for exams from other faculties

Author: obcode

cmd/plan.go

@@ -6,6 +6,7 @@ import (
 	"log"
 	"os"
 	"strconv"
+	"time"
 
 	"github.com/spf13/cobra"
 )
@@ -18,6 +19,7 @@ var (
 	pre-plan-exam ancode day slot                  --- move [ancode] to [day number] [slot number]
 	pre-plan-room ancode roomname [mtknr/reserve]  --- plan [room name] for [ancode]
 	move-to ancode day slot                        --- move [ancode] to [day number] [slot number]
+	other-fk ancode time                           --- plan [ancode] from other faculty to [time]
 	change-room ancode oldroom newroom             --- change room for [ancode] from [oldroom] to [newroom]
 	lock-exam ancode                               --- lock exam to slot
 	unlock-exam ancode                             --- unlock / allow moving
@@ -80,6 +82,33 @@ var (
 					log.Fatalf("got error: %v\n", err)
 				}
 				fmt.Println(str)
+			case "other-fk":
+				if len(args) < 3 {
+					log.Fatal("need ancode, time")
+				}
+				ancode, err := strconv.Atoi(args[1])
+				if err != nil {
+					log.Fatalf("cannot convert %s to int", args[1])
+				}
+				slottime, err := time.ParseInLocation("02.01.06,15:04", args[2], time.Local)
+				if err != nil {
+					log.Fatalf("cannot convert \"%s\" to time, must be in format \"02.01.06,15:04\"\n", args[2])
+				}
+
+				success, err := plexams.AddExamToSlottime(context.Background(), ancode, slottime)
+
+				if err != nil {
+					fmt.Printf("error: %v\n", err)
+					os.Exit(1)
+				}
+				if success {
+					fmt.Printf("successfully moved exam %d to (%s)\n", ancode, slottime.String())
+				}
+				str, err := plexams.ExamInfo(ancode)
+				if err != nil {
+					log.Fatalf("got error: %v\n", err)
+				}
+				fmt.Println(str)
 
 			case "pre-plan-room":
 				if len(args) < 3 {

db/generatedExams.go

@@ -79,7 +79,7 @@ func (db *DB) GetGeneratedExam(ctx context.Context, ancode int) (*model.Generate
 
 	res := collection.FindOne(ctx, bson.D{{Key: "ancode", Value: ancode}})
 	if res.Err() != nil {
-		log.Error().Err(res.Err()).Int("ancode", ancode).Msg("cannot get generated exam")
+		log.Debug().Err(res.Err()).Int("ancode", ancode).Msg("cannot get generated exam")
 		return nil, res.Err()
 	}
 

graph/generated/generated.go

@@ -1,8 +1,11 @@
 package model
 
+import "time"
+
 type PlanEntry struct {
-	DayNumber  int  `json:"dayNumber"`
-	SlotNumber int  `json:"slotNumber"`
-	Ancode     int  `json:"ancode"`
-	Locked     bool `json:"locked"`
+	DayNumber    int        `json:"dayNumber"`
+	SlotNumber   int        `json:"slotNumber"`
+	ExternalTime *time.Time `json:"externalTime"`
+	Ancode       int        `json:"ancode"`
+	Locked       bool       `json:"locked"`
 }

graph/model/plan.go

@@ -57,6 +57,7 @@ type PlanEntry {
   dayNumber: Int!
   slotNumber: Int!
   starttime: Time!
+  externalTime: Time # only for exams from other faculties
   ancode: Int!
   locked: Boolean!
 }

graph/plan.graphqls

@@ -243,19 +243,44 @@ func (p *Plexams) ConnectExam(ancode int, program string) error {
 
 func (p *Plexams) ExamInfo(ancode int) (string, error) {
 	ctx := context.Background()
+	found := false
 	exam, err := p.PlannedExam(ctx, ancode)
+	module, mainExamer := "", ""
+	var planEntry *model.PlanEntry
 	if err != nil {
-		return "", err
+		exam, err := p.GetZpaExamByAncode(ctx, ancode)
+		if err != nil {
+			// TODO: maybe external exam?
+		} else {
+			found = true
+			module = exam.Module
+			mainExamer = exam.MainExamer
+			planEntry, err = p.dbClient.PlanEntry(ctx, ancode)
+			if err != nil {
+				log.Debug().Int("ancode", ancode).
+					Msg("not planned yet")
+			}
+		}
+	} else {
+		found = true
+		module = exam.ZpaExam.Module
+		mainExamer = exam.ZpaExam.MainExamer
+		planEntry = exam.PlanEntry
 	}
-	if exam == nil {
-		return "", fmt.Errorf("no planned exam for ancode %d", ancode)
+
+	if !found {
+		return fmt.Sprintf("no exam for ancode %d found", ancode), nil
 	}
+
 	var sb strings.Builder
 
-	fmt.Fprintf(&sb, "%5d. %s (%s)", exam.Ancode, exam.ZpaExam.Module, exam.ZpaExam.MainExamer)
-	if exam.PlanEntry != nil {
-		starttime := p.getSlotTime(exam.PlanEntry.DayNumber, exam.PlanEntry.SlotNumber)
-		fmt.Fprintf(&sb, "\n    Termin: %s (Tag %d / Slot %d)", starttime.Local().Format("02.01.06, 15:04 Uhr"), exam.PlanEntry.DayNumber, exam.PlanEntry.SlotNumber)
+	fmt.Fprintf(&sb, "%5d. %s (%s)", ancode, module, mainExamer)
+	if planEntry != nil {
+		starttime := p.getSlotTime(planEntry.DayNumber, planEntry.SlotNumber)
+		if planEntry.ExternalTime != nil {
+			starttime = *planEntry.ExternalTime
+		}
+		fmt.Fprintf(&sb, "\n    Termin: %s (Tag %d / Slot %d)", starttime.Local().Format("02.01.06, 15:04 Uhr"), planEntry.DayNumber, planEntry.SlotNumber)
 	} else {
 		sb.WriteString("\n    Termin: fehlt")
 	}

plexams/exam.go

@@ -11,6 +11,48 @@ import (
 	"github.com/rs/zerolog/log"
 )
 
+func (p *Plexams) AddExamToSlottime(ctx context.Context, ancode int, time time.Time) (bool, error) {
+	exam, err := p.GetZpaExamByAncode(ctx, ancode)
+	duration := 90 // good default
+	if err != nil {
+		// TODO: maybe external exam?
+	} else {
+		// ZPA exam
+		constraints, err := p.ConstraintForAncode(ctx, ancode)
+		if err != nil {
+			log.Error().Err(err).Int("ancode", ancode).
+				Msg("error while trying to get constraints")
+			return false, err
+		}
+		if !constraints.NotPlannedByMe {
+			err := fmt.Errorf("add exam to slot time is only allowed for exams not planned by me")
+			return false, err
+		}
+		duration = exam.Duration
+	}
+	if exam == nil {
+		err = fmt.Errorf("exam with ancode %d not found", ancode)
+		return false, err
+	}
+	log.Debug().Str("module", exam.Module).Str("main-examer", exam.MainExamer).
+		Msg("found exam")
+	slot, err := p.getSlotForTime(time, duration)
+	if err != nil {
+		log.Error().Err(err).Time("slottime", time).
+			Msg("no slot for slottime found")
+	}
+	log.Debug().Int("day", slot.DayNumber).Int("slot", slot.SlotNumber).
+		Msg("found slot")
+
+	return p.dbClient.AddExamToSlot(ctx, &model.PlanEntry{
+		DayNumber:    slot.DayNumber,
+		SlotNumber:   slot.SlotNumber,
+		ExternalTime: &time,
+		Ancode:       ancode,
+		Locked:       false,
+	})
+}
+
 func (p *Plexams) AddExamToSlot(ctx context.Context, ancode int, dayNumber int, timeNumber int, force bool) (bool, error) {
 	var slot *model.Slot
 
@@ -325,6 +367,13 @@ func (p *Plexams) PreExamsInSlot(ctx context.Context, day int, time int) ([]*mod
 
 	preExams := make([]*model.PreExam, 0, len(planEntries))
 	for _, planEntry := range planEntries {
+
+		if planEntry.ExternalTime != nil {
+			fmt.Printf("External Time = %s\n", planEntry.ExternalTime.String())
+		} else {
+			fmt.Println("no external time")
+		}
+
 		exam, err := p.GetZPAExam(ctx, planEntry.Ancode)
 		if err != nil {
 			log.Error().Err(err).Int("ancode", planEntry.Ancode).Msg("cannot get exam")

plexams/plan.go

@@ -28,7 +28,7 @@ func (p *Plexams) PlanEntries(ctx context.Context) ([]*model.PlanEntry, error) {
 func (p *Plexams) PlannedExam(ctx context.Context, ancode int) (*model.PlannedExam, error) {
 	exam, err := p.GeneratedExam(ctx, ancode)
 	if err != nil {
-		log.Error().Err(err).Int("ancode", ancode).Msg("cannot get generated exam")
+		log.Debug().Err(err).Int("ancode", ancode).Msg("cannot get generated exam")
 		return nil, err
 	}
 

plexams/plannedExams.go

@@ -337,6 +337,39 @@ func (p *Plexams) getSlotTime(dayNumber, slotNumber int) time.Time {
 	return time.Date(0, 0, 0, 0, 0, 0, 0, nil)
 }
 
+func (p *Plexams) getSlotForTime(starttime time.Time, duration int) (*model.Slot, error) {
+	var slotWithStarttimeInSlot, slotWithEndtimeInSlot *model.Slot
+	endtime := starttime.Add(time.Duration(duration) * time.Minute)
+	for _, slot := range p.semesterConfig.Slots {
+		if starttime.After(slot.Starttime.Add(-1*time.Minute)) &&
+			starttime.Before(slot.Starttime.Add(119*time.Minute)) {
+			slotWithStarttimeInSlot = slot
+		}
+		if endtime.After(slot.Starttime.Add(-1*time.Minute)) &&
+			endtime.Before(slot.Starttime.Add(119*time.Minute)) {
+			slotWithEndtimeInSlot = slot
+		}
+		if slotWithStarttimeInSlot != nil &&
+			slotWithEndtimeInSlot != nil {
+			break
+		}
+	}
+
+	if slotWithStarttimeInSlot == nil {
+		return slotWithEndtimeInSlot, nil
+	}
+	if slotWithEndtimeInSlot == nil {
+		return slotWithStarttimeInSlot, nil
+	}
+
+	minutesInEndtimeSlot := int(endtime.Sub(slotWithEndtimeInSlot.Starttime).Minutes())
+	if minutesInEndtimeSlot > duration/2 {
+		return slotWithEndtimeInSlot, nil
+	}
+
+	return slotWithStarttimeInSlot, nil
+}
+
 func (p *Plexams) PrintInfo() {
 	fmt.Println(aurora.Sprintf(aurora.Magenta(" ---   Planning Semester: %s   --- \n"), p.semester))
 }