264 lines
7.0 KiB
Go
264 lines
7.0 KiB
Go
package endpoints
|
|
|
|
import (
|
|
"arbeitszeitmessung/helper"
|
|
"arbeitszeitmessung/models"
|
|
"arbeitszeitmessung/templates"
|
|
"context"
|
|
"database/sql"
|
|
"encoding/json"
|
|
"log"
|
|
"net/http"
|
|
"sort"
|
|
"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:
|
|
err := updateAbsence(r)
|
|
if err != nil {
|
|
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("2006-01-02", 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
|
|
}
|
|
|
|
// TODO add config for timeoffset
|
|
tsFrom, err := parseTimestamp(r, "time_from", time.Now().AddDate(0, -1, 0).Format("2006-01-02"))
|
|
if err != nil {
|
|
log.Println("Error parsing 'from' time", err)
|
|
http.Error(w, "Timestamp 'from' cannot be parsed!", http.StatusBadRequest)
|
|
return
|
|
}
|
|
tsTo, err := parseTimestamp(r, "time_to", time.Now().Format("2006-01-02"))
|
|
if err != nil {
|
|
log.Println("Error parsing 'to' time", err)
|
|
http.Error(w, "Timestamp 'to' cannot be parsed!", http.StatusBadRequest)
|
|
return
|
|
}
|
|
tsTo = tsTo.AddDate(0, 0, 1) // so that today is inside
|
|
|
|
days := models.GetDays(user, tsFrom, tsTo, true)
|
|
sort.Slice(days, func(i, j int) bool {
|
|
return days[i].Date().After(days[j].Date())
|
|
})
|
|
|
|
lastSub := user.GetLastWorkWeekSubmission()
|
|
var aggregatedOvertime time.Duration
|
|
for _, day := range days {
|
|
if day.Date().Before(lastSub) {
|
|
continue
|
|
}
|
|
aggregatedOvertime += day.TimeOvertimeReal(user)
|
|
}
|
|
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 updateBooking(w http.ResponseWriter, r *http.Request) {
|
|
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
|
|
}
|
|
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
|
|
}
|
|
|
|
var check_in_out int
|
|
check_in_out, err = strconv.Atoi(r.FormValue("check_in_out"))
|
|
if err != nil {
|
|
log.Println("Error parsing check_in_out", err)
|
|
return
|
|
}
|
|
|
|
newBooking := (*models.Booking).New(nil, user.CardUID, 0, int16(check_in_out), 1)
|
|
newBooking.Timestamp = timestamp
|
|
err = newBooking.InsertWithTimestamp()
|
|
if err != nil {
|
|
log.Printf("Error inserting booking %v -> %v\n", newBooking, err)
|
|
}
|
|
case "change":
|
|
// absenceType, err := strconv.Atoi(r.FormValue("absence"))
|
|
// if err != nil {
|
|
// log.Println("Error parsing absence type.", err)
|
|
// absenceType = 0
|
|
// }
|
|
// if absenceType != 0 {
|
|
// createAbsence(absenceType, user, loc, r)
|
|
// }
|
|
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("2006-01-02", r.FormValue("date_from"), loc)
|
|
if err != nil {
|
|
log.Println("Error parsing date_from input for absence", err)
|
|
return err
|
|
}
|
|
|
|
dateTo, err := time.ParseInLocation("2006-01-02", 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
|
|
|
|
}
|