added control tables (s_*) + working on implementing absence and booking types

Backend/models/absence.go

@@ -1,52 +1,65 @@
 package models
 
 import (
+	"errors"
 	"log"
 	"time"
 )
 
 type AbsenceType struct {
-	Value int8
-	Label string
+	Id   int8
+	Name string
 }
 
-const (
-	AbsenceNone int8 = iota
-	AbsenceUrlaub
-	AbsenceKurzarbeit
-	AbsenceKrank
-	AbsenceKindkrank
-)
+// const (
+// 	AbsenceNone int8 = iota
+// 	AbsenceUrlaub
+// 	AbsenceKurzarbeit
+// 	AbsenceKrank
+// 	AbsenceKindkrank
+// )
 
-var AbsenceTypes = []AbsenceType{
-	// {Value: AbsenceNone, Label: "Abwesenheit"},
-	{Value: AbsenceUrlaub, Label: "Urlaub"},
-	{Value: AbsenceKurzarbeit, Label: "Kurzarbeit"},
-	{Value: AbsenceKrank, Label: "Krank"},
-	{Value: AbsenceKindkrank, Label: "Kindkrank"},
-}
+// var AbsenceTypes = []AbsenceType{
+// 	// {Value: AbsenceNone, Label: "Abwesenheit"},
+// 	{Id: AbsenceUrlaub, Name: "Urlaub"},
+// 	{Id: AbsenceKurzarbeit, Name: "Kurzarbeit"},
+// 	{Id: AbsenceKrank, Name: "Krank"},
+// 	{Id: AbsenceKindkrank, Name: "Kindkrank"},
+// }
 
-var AbsenceTypesLabel = map[int8]string{
-	0:                 "None",
-	AbsenceUrlaub:     "Urlaub",
-	AbsenceKurzarbeit: "Kurzarbeit",
-	AbsenceKrank:      "Krank",
-	AbsenceKindkrank:  "Kindkrank",
-}
+// var AbsenceTypesLabel = map[int8]string{
+// 	0:                 "None",
+// 	AbsenceUrlaub:     "Urlaub",
+// 	AbsenceKurzarbeit: "Kurzarbeit",
+// 	AbsenceKrank:      "Krank",
+// 	AbsenceKindkrank:  "Kindkrank",
+// }
 
 type Absence struct {
 	CounterId      int
 	CardUID        string
-	AbwesenheitTyp int8
+	AbwesenheitTyp AbsenceType
 	Datum          time.Time
+	// Comment        string
 }
 
-func NewAbsence(card_uid string, abwesenheit_typ int8, datum time.Time) Absence {
+func NewAbsence(card_uid string, abwesenheit_typ int, datum time.Time) (Absence, error) {
+	if abwesenheit_typ < 0 {
+		return Absence{
+			CardUID:        card_uid,
+			AbwesenheitTyp: AbsenceType{0, "Custom absence"},
+			Datum:          datum,
+		}, nil
+	}
+	_absenceType, ok := GetAbsenceTypesCached()[int8(abwesenheit_typ)]
+	if !ok {
+		return Absence{}, errors.New("Invalid absencetype")
+	}
 	return Absence{
 		CardUID:        card_uid,
-		AbwesenheitTyp: abwesenheit_typ,
+		AbwesenheitTyp: _absenceType,
 		Datum:          datum,
-	}
+	}, nil
 }
 
 func (a *Absence) Insert() error {
@@ -63,6 +76,37 @@ func (a *Absence) Insert() error {
 	return nil
 }
 
-func (a *Absence) GetStringType() string {
-	return AbsenceTypesLabel[a.AbwesenheitTyp]
+// func (a *Absence) GetStringType() string {
+// 	return AbsenceTypesLabel[a.AbwesenheitTyp]
+// }
+
+func GetAbsenceTypes() (map[int8]AbsenceType, error) {
+	var types = make(map[int8]AbsenceType)
+	qStr, err := DB.Prepare("SELECT abwesenheit_id, abwesenheit_name FROM s_abwesenheit_typen;")
+	if err != nil {
+		return types, err
+	}
+	defer qStr.Close()
+	rows, err := qStr.Query()
+	if err != nil {
+		log.Println("Error getting abwesenheit rows!", err)
+		return types, err
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var absenceType AbsenceType
+		if err := rows.Scan(&absenceType.Id, &absenceType.Name); err != nil {
+			log.Println("Error scanning absence row!", err)
+		}
+		types[absenceType.Id] = absenceType
+	}
+	return types, nil
+}
+
+func GetAbsenceTypesCached() map[int8]AbsenceType {
+	types, err := definedTypes.Get("s_abwesenheit_typen")
+	if err != nil {
+		return map[int8]AbsenceType{}
+	}
+	return types.(map[int8]AbsenceType)
 }

Backend/models/booking.go

@@ -13,6 +13,11 @@ import (
 
 type SameBookingError struct{}
 
+type BookingType struct {
+	Id   int8
+	Name string
+}
+
 func (e SameBookingError) Error() string {
 	return "the same booking already exists!"
 }
@@ -261,3 +266,34 @@ func (b *Booking) UpdateTime(newTime time.Time) {
 func (b *Booking) ToString() string {
 	return fmt.Sprintf("Booking %d: at: %s, as type: %d", b.CounterId, b.Timestamp.Format("15:04"), b.CheckInOut)
 }
+
+func GetBokkingTypes() ([]BookingType, error) {
+	var types []BookingType
+	qStr, err := DB.Prepare("SELECT anwesenheit_id, anwesenheit_name FROM s_anwesenheit_typen;")
+	if err != nil {
+		return types, err
+	}
+	defer qStr.Close()
+	rows, err := qStr.Query()
+	if err != nil {
+		log.Println("Error getting anwesenheit rows!", err)
+		return types, err
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var bookingType BookingType
+		if err := rows.Scan(&bookingType.Id, &bookingType.Name); err != nil {
+			log.Println("Error scanning row!", err)
+		}
+		types = append(types, bookingType)
+	}
+	return types, nil
+}
+
+func GetBookingTypesCached() []BookingType {
+	types, err := definedTypes.Get("s_anwesenheit_typen")
+	if err != nil {
+		return []BookingType{}
+	}
+	return types.([]BookingType)
+}

Backend/models/controlTables.go

@@ -0,0 +1,15 @@
+package models
+
+import (
+	"arbeitszeitmessung/helper"
+)
+
+var definedTypes = helper.NewCache(3600, func(key string) (any, error) {
+	switch key {
+	case "s_abwesenheit_typen":
+		return GetAbsenceTypes()
+	case "s_anwesenheit_typen":
+		return GetBokkingTypes()
+	}
+	return nil, nil
+})

Backend/models/user.go

@@ -40,7 +40,7 @@ func (u *User) GetUserFromSession(Session *scs.SessionManager, ctx context.Conte
 }
 
 func (u *User) GetAll() ([]User, error) {
-	qStr, err := DB.Prepare((`SELECT card_uid, vorname, nachname FROM personal_daten;`))
+	qStr, err := DB.Prepare((`SELECT card_uid, vorname, nachname FROM s_personal_daten;`))
 	var users []User
 	if err != nil {
 		fmt.Printf("Error preparing query statement %v\n", err)
@@ -98,7 +98,7 @@ func (u *User) CheckOut() error {
 func (u *User) GetByPersonalNummer(personalNummer int) (User, error) {
 	var user User
 
-	qStr, err := DB.Prepare((`SELECT personal_nummer, card_uid, vorname, nachname, arbeitszeit_per_tag FROM personal_daten WHERE personal_nummer = $1;`))
+	qStr, err := DB.Prepare((`SELECT personal_nummer, card_uid, vorname, nachname, arbeitszeit_per_tag FROM s_personal_daten WHERE personal_nummer = $1;`))
 	if err != nil {
 		return user, err
 	}
@@ -146,7 +146,7 @@ func (u *User) ChangePass(password, newPassword string) (bool, error) {
 
 func (u *User) GetTeamMembers() ([]User, error) {
 	var teamMembers []User
-	qStr, err := DB.Prepare(`SELECT personal_nummer, card_uid, vorname, nachname, arbeitszeit_per_tag FROM personal_daten WHERE vorgesetzter_pers_nr = $1`)
+	qStr, err := DB.Prepare(`SELECT personal_nummer, card_uid, vorname, nachname, arbeitszeit_per_tag FROM s_personal_daten WHERE vorgesetzter_pers_nr = $1`)
 	if err != nil {
 		return teamMembers, err
 	}
@@ -234,7 +234,7 @@ func (u *User) GetFromCardUID(card_uid string) (User, error) {
 	user := User{}
 	var err error
 
-	qStr, err := DB.Prepare((`SELECT personal_nummer, card_uid, vorname, nachname, arbeitszeit_per_tag FROM personal_daten WHERE card_uid = $1;`))
+	qStr, err := DB.Prepare((`SELECT personal_nummer, card_uid, vorname, nachname, arbeitszeit_per_tag FROM s_personal_daten WHERE card_uid = $1;`))
 	if err != nil {
 		return user, err
 	}

Backend/models/workDay.go

@@ -117,8 +117,8 @@ func (d *WorkDay) GetWorkDays(card_uid string, tsFrom, tsTo time.Time) []WorkDay
 		}
 
 		if absenceType.Valid {
-			workDay.Absence = NewAbsence(card_uid, int8(absenceType.Int16), workDay.Day)
-			log.Println("Found absence", workDay.Absence)
+			workDay.Absence, err = NewAbsence(card_uid, int(absenceType.Int16), workDay.Day)
+			// log.Println("Found absence", workDay.Absence)
 		}
 
 		if workDay.Day.Equal(time.Now().Truncate(24 * time.Hour)) {