145 lines
3.8 KiB
Go
145 lines
3.8 KiB
Go
package models
|
|
|
|
import (
|
|
"errors"
|
|
"log"
|
|
"time"
|
|
)
|
|
|
|
type AbsenceType struct {
|
|
Id int8
|
|
Name string
|
|
WorkTime float32
|
|
}
|
|
|
|
type Absence struct {
|
|
CounterId int
|
|
CardUID string
|
|
AbwesenheitTyp AbsenceType
|
|
Datum time.Time
|
|
}
|
|
|
|
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", 100},
|
|
Datum: datum,
|
|
}, nil
|
|
}
|
|
_absenceType, ok := GetAbsenceTypesCached()[int8(abwesenheit_typ)]
|
|
if !ok {
|
|
return Absence{}, errors.New("Invalid absencetype")
|
|
}
|
|
return Absence{
|
|
CardUID: card_uid,
|
|
AbwesenheitTyp: _absenceType,
|
|
Datum: datum,
|
|
}, nil
|
|
}
|
|
|
|
func (a *Absence) Insert() error {
|
|
qStr, err := DB.Prepare(`INSERT INTO abwesenheit (card_uid, abwesenheit_typ, datum) VALUES ($1, $2, $3) RETURNING counter_id;`)
|
|
if err != nil {
|
|
log.Println("Error preparing sql Statement", err)
|
|
return err
|
|
}
|
|
defer qStr.Close()
|
|
err = qStr.QueryRow(a.CardUID, a.AbwesenheitTyp.Id, a.Datum).Scan(&a.CounterId)
|
|
if err != nil {
|
|
log.Println("Error executing insert statement", err)
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func GetAbsenceById(counterId int) (Absence, error) {
|
|
var absence Absence = Absence{CounterId: counterId}
|
|
qStr, err := DB.Prepare("SELECT card_uid, abwesenheit_typ, datum FROM abwesenheit WHERE counter_id = $1;")
|
|
if err != nil {
|
|
return absence, err
|
|
}
|
|
defer qStr.Close()
|
|
err = qStr.QueryRow(counterId).Scan(&absence.CardUID, &absence.AbwesenheitTyp.Id, &absence.Datum)
|
|
if err != nil {
|
|
return absence, err
|
|
}
|
|
return absence, nil
|
|
}
|
|
|
|
func GetAbsencesByCardUID(card_uid string, tsFrom time.Time, tsTo time.Time) ([]Absence, error) {
|
|
var absences []Absence
|
|
qStr, err := DB.Prepare("SELECT counter_id, abwesenheit_typ, datum FROM abwesenheit WHERE card_uid = $1 AND datum BETWEEN $2::DATE AND $3::DATE ORDER BY datum;")
|
|
if err != nil {
|
|
return absences, err
|
|
}
|
|
defer qStr.Close()
|
|
rows, err := qStr.Query(card_uid, tsFrom, tsTo)
|
|
if err != nil {
|
|
return absences, err
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
var absence Absence
|
|
if err := rows.Scan(&absence.CounterId, &absence.AbwesenheitTyp.Id, &absence.Datum); err != nil {
|
|
return absences, err
|
|
}
|
|
absence.AbwesenheitTyp, err = GetAbsenceTypeById(absence.AbwesenheitTyp.Id)
|
|
if err == nil {
|
|
absences = append(absences, absence)
|
|
} else {
|
|
log.Println("Cannot populate absence type!", err)
|
|
}
|
|
}
|
|
if err = rows.Err(); err != nil {
|
|
return absences, err
|
|
}
|
|
return absences, nil
|
|
}
|
|
|
|
func GetAbsenceTypes() (map[int8]AbsenceType, error) {
|
|
var types = make(map[int8]AbsenceType)
|
|
qStr, err := DB.Prepare("SELECT abwesenheit_id, abwesenheit_name, arbeitszeit_equivalent 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, &absenceType.WorkTime); 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)
|
|
}
|
|
|
|
func GetAbsenceTypeById(absenceTypeId int8) (AbsenceType, error) {
|
|
var absenceType AbsenceType = AbsenceType{Id: absenceTypeId}
|
|
|
|
qStr, err := DB.Prepare("SELECT abwesenheit_name, arbeitszeit_equivalent FROM s_abwesenheit_typen WHERE abwesenheit_id = $1;")
|
|
if err != nil {
|
|
return absenceType, err
|
|
}
|
|
defer qStr.Close()
|
|
err = qStr.QueryRow(absenceTypeId).Scan(&absenceType.Name, &absenceType.WorkTime)
|
|
if err != nil {
|
|
return absenceType, err
|
|
}
|
|
return absenceType, nil
|
|
}
|