277 lines
7.2 KiB
Go
277 lines
7.2 KiB
Go
package endpoints
|
|
|
|
// this endpoint served at "/time" handles the time page
|
|
// this includes normal show + creation of bookings from the webpage +
|
|
// edit functionality
|
|
|
|
import (
|
|
"arbeitszeitmessung/helper"
|
|
"arbeitszeitmessung/helper/paramParser"
|
|
"arbeitszeitmessung/models"
|
|
"arbeitszeitmessung/templates"
|
|
"context"
|
|
"database/sql"
|
|
"encoding/json"
|
|
"log"
|
|
"log/slog"
|
|
"net/http"
|
|
"strconv"
|
|
"time"
|
|
)
|
|
|
|
// Frontend relevant backend functionality -> not used by the arduino devices
|
|
func TimeHandler(w http.ResponseWriter, r *http.Request) {
|
|
helper.RequiresLogin(Session, w, r)
|
|
helper.SetCors(w)
|
|
switch r.Method {
|
|
case http.MethodGet:
|
|
getBookings(w, r)
|
|
case http.MethodPost:
|
|
updateBooking(w, r)
|
|
case http.MethodOptions:
|
|
// just support options header for non GET Requests from SWAGGER
|
|
w.WriteHeader(http.StatusOK)
|
|
default:
|
|
http.Error(w, "Method not allowed!", http.StatusMethodNotAllowed)
|
|
}
|
|
}
|
|
|
|
func AbsencHandler(w http.ResponseWriter, r *http.Request) {
|
|
helper.RequiresLogin(Session, w, r)
|
|
helper.SetCors(w)
|
|
switch r.Method {
|
|
case http.MethodPost:
|
|
r.ParseForm()
|
|
var err error
|
|
switch r.FormValue("action") {
|
|
case "insert":
|
|
err = updateAbsence(r)
|
|
case "delete":
|
|
err = deleteAbsence(r)
|
|
default:
|
|
slog.Warn("No action found!")
|
|
}
|
|
if err != nil {
|
|
slog.Warn("Error handling absence route ", "error", err)
|
|
http.Error(w, "Internal error", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
http.Redirect(w, r, "/time", 301)
|
|
default:
|
|
http.Error(w, "Method not allowed!", http.StatusMethodNotAllowed)
|
|
}
|
|
}
|
|
|
|
func parseTimestamp(r *http.Request, getKey string, fallback string) (time.Time, error) {
|
|
getTimestamp := r.URL.Query().Get(getKey)
|
|
if getTimestamp == "" {
|
|
getTimestamp = fallback
|
|
}
|
|
Timestamp, err := time.Parse(time.DateOnly, getTimestamp)
|
|
if err != nil {
|
|
return time.Now(), err
|
|
}
|
|
return Timestamp, nil
|
|
}
|
|
|
|
// Returns bookings from DB with similar card uid -> checks for card uid in http query params
|
|
func getBookings(w http.ResponseWriter, r *http.Request) {
|
|
user, err := models.GetUserFromSession(Session, r.Context())
|
|
if err != nil {
|
|
log.Println("No user found with the given personal number!")
|
|
http.Redirect(w, r, "/user/login", http.StatusSeeOther)
|
|
return
|
|
}
|
|
pp := paramParser.New(r.URL.Query())
|
|
|
|
// TODO add config for timeoffset
|
|
tsFrom := pp.ParseTimestampFallback("time_from", time.DateOnly, time.Now().AddDate(0, -1, 0))
|
|
tsTo := pp.ParseTimestampFallback("time_to", time.DateOnly, time.Now())
|
|
|
|
tsTo = tsTo.AddDate(0, 0, 1) // so that today is inside
|
|
|
|
days := models.GetDays(user, tsFrom, tsTo, true)
|
|
|
|
lastSub := user.GetLastWorkWeekSubmission()
|
|
var aggregatedOvertime time.Duration
|
|
for _, day := range days {
|
|
if day.Date().Before(lastSub) {
|
|
continue
|
|
}
|
|
aggregatedOvertime += day.GetOvertime(user, models.WorktimeBaseDay, true)
|
|
}
|
|
if reportedOvertime, err := user.GetReportedOvertime(); err == nil {
|
|
user.Overtime = (reportedOvertime + aggregatedOvertime).Round(time.Minute)
|
|
} else {
|
|
log.Println("Cannot calculate overtime: ", err)
|
|
}
|
|
|
|
if r.Header.Get("Accept") == "application/json" {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(http.StatusOK)
|
|
json.NewEncoder(w).Encode(days)
|
|
return
|
|
}
|
|
|
|
ctx := context.WithValue(r.Context(), "user", user)
|
|
ctx = context.WithValue(ctx, "days", days)
|
|
templates.TimePage([]models.WorkDay{}, lastSub).Render(ctx, w)
|
|
}
|
|
|
|
func deleteAbsence(r *http.Request) error {
|
|
r.ParseForm()
|
|
pp := paramParser.New(r.Form)
|
|
counterId, err := pp.ParseInt("aw_id")
|
|
|
|
if err != nil {
|
|
return err
|
|
}
|
|
absence, err := models.GetAbsenceById(counterId)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return absence.Delete()
|
|
}
|
|
|
|
func updateBooking(w http.ResponseWriter, r *http.Request) {
|
|
r.ParseForm()
|
|
pp := paramParser.New(r.Form)
|
|
var loc *time.Location
|
|
loc, err := time.LoadLocation(helper.GetEnv("TZ", "Europe/Berlin"))
|
|
if err != nil {
|
|
log.Println("Error loading location", err)
|
|
loc = time.Local
|
|
}
|
|
user, err := models.GetUserFromSession(Session, r.Context())
|
|
if err != nil {
|
|
log.Println("No user found!", err)
|
|
return
|
|
}
|
|
|
|
switch r.FormValue("action") {
|
|
case "add":
|
|
timestamp, err := time.ParseInLocation("2006-01-02|15:04", r.FormValue("date")+"|"+r.FormValue("timestamp"), loc)
|
|
if err != nil {
|
|
log.Println("Error parsing timestamp", err)
|
|
return
|
|
}
|
|
|
|
check_in_out, err := pp.ParseInt("check_in_out")
|
|
if err != nil {
|
|
slog.Warn("Error parsing check_in_out")
|
|
return
|
|
}
|
|
|
|
newBooking := (*models.Booking).NewBooking(nil, user.CardUID, 0, int16(check_in_out), 1)
|
|
newBooking.Timestamp = timestamp
|
|
if newBooking.Verify() {
|
|
err = newBooking.InsertWithTimestamp()
|
|
if err != nil {
|
|
log.Printf("Error inserting booking %v -> %v\n", newBooking, err)
|
|
}
|
|
}
|
|
case "change":
|
|
for index, possibleBooking := range r.PostForm {
|
|
if len(index) > 7 && index[:7] == "booking" {
|
|
booking_id, err := strconv.Atoi(index[8:])
|
|
if err != nil {
|
|
log.Println("Error parsing bookingId", err)
|
|
continue
|
|
}
|
|
booking, err := (*models.Booking).GetBookingById(nil, booking_id)
|
|
if err != nil {
|
|
log.Println("Error getting booking!", err)
|
|
continue
|
|
}
|
|
parsedTime, err := time.ParseInLocation("15:04", possibleBooking[0], booking.Timestamp.Location())
|
|
if err != nil {
|
|
log.Println("Error parsing time!", err)
|
|
continue
|
|
}
|
|
booking.UpdateTime(parsedTime)
|
|
}
|
|
}
|
|
default:
|
|
log.Println("No action from /time found")
|
|
}
|
|
getBookings(w, r)
|
|
}
|
|
|
|
func updateAbsence(r *http.Request) error {
|
|
r.ParseForm()
|
|
var loc *time.Location
|
|
loc, err := time.LoadLocation(helper.GetEnv("TZ", "Europe/Berlin"))
|
|
if err != nil {
|
|
log.Println("Error loading location", err)
|
|
loc = time.Local
|
|
}
|
|
|
|
dateFrom, err := time.ParseInLocation(time.DateOnly, r.FormValue("date_from"), loc)
|
|
if err != nil {
|
|
log.Println("Error parsing date_from input for absence", err)
|
|
return err
|
|
}
|
|
|
|
dateTo, err := time.ParseInLocation(time.DateOnly, r.FormValue("date_to"), loc)
|
|
if err != nil {
|
|
log.Println("Error parsing date_to input for absence", err)
|
|
return err
|
|
}
|
|
|
|
absenceTypeId, err := strconv.Atoi(r.FormValue("aw_type"))
|
|
if err != nil {
|
|
log.Println("Error parsing aw_type", err)
|
|
return err
|
|
}
|
|
|
|
absenceId, err := strconv.Atoi(r.FormValue("aw_id"))
|
|
if err != nil && r.FormValue("aw_id") == "" {
|
|
absenceId = 0
|
|
} else if err != nil {
|
|
log.Println("Error parsing aw_id", err)
|
|
return err
|
|
}
|
|
|
|
absenceType, err := models.GetAbsenceTypeById(int8(absenceTypeId))
|
|
if err != nil {
|
|
log.Println("No matching absence type found!")
|
|
return err
|
|
}
|
|
|
|
newAbsence := models.Absence{DateFrom: dateFrom, DateTo: dateTo, AbwesenheitTyp: absenceType}
|
|
|
|
absence, err := models.GetAbsenceById(absenceId)
|
|
if err == sql.ErrNoRows {
|
|
err = nil
|
|
log.Println("Absence not found creating new!")
|
|
|
|
user, err := models.GetUserFromSession(Session, r.Context())
|
|
if err != nil {
|
|
log.Println("No user found!", err)
|
|
return err
|
|
}
|
|
newAbsence.CardUID = user.CardUID
|
|
newAbsence.Insert()
|
|
}
|
|
if err != nil {
|
|
log.Println("Cannot get Absence for id: ", absenceId, err)
|
|
return err
|
|
}
|
|
if r.FormValue("action") == "delete" {
|
|
log.Println("Deleting Absence!", "Not implemented")
|
|
// TODO
|
|
//absence.Delete()
|
|
return nil
|
|
}
|
|
|
|
if absence.Update(newAbsence) {
|
|
err = absence.Save()
|
|
if err != nil {
|
|
log.Println("Error saving updated absence!", err)
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
|
|
}
|