arbeitszeitmessung/Backend/models/user.go

package models

import (
	"arbeitszeitmessung/helper"
	"context"
	"database/sql"
	"errors"
	"fmt"
	"log"
	"time"

	"github.com/alexedwards/scs/v2"
)

type User struct {
	CardUID             string  //`json:"card_uid"`
	Name                string  `json:"name"`
	Vorname             string  `json:"vorname"`
	PersonalNummer      int     //`json:"personal_nummer"`
	ArbeitszeitPerTag   float32 //`json:"arbeitszeit_per_tag"`
	ArbeitszeitPerWoche float32 //`json:"arbeitszeit_per_woche"`
	Overtime            time.Duration
}

func (u *User) GetUserFromSession(Session *scs.SessionManager, ctx context.Context) (User, error) {
	var user User
	var err error
	if helper.GetEnv("GO_ENV", "production") == "debug" {
		user, err = GetUserByPersonalNr(123)
	} else {
		if !Session.Exists(ctx, "user") {
			log.Println("No user in session storage!")
			return user, errors.New("No user in session storage!")
		}
		user, err = GetUserByPersonalNr(Session.GetInt(ctx, "user"))
	}
	if err != nil {
		log.Println("Cannot get user from session!")
		return user, err
	}
	return user, nil
}

// Returns the actual overtime for this moment
func (u *User) GetReportedOvertime() (time.Duration, error) {
	var overtime time.Duration

	qStr, err := DB.Prepare("SELECT COALESCE(SUM(EXTRACT(EPOCH FROM ueberstunden) * 1000000000)::BIGINT, 0) AS total_ueberstunden_ns FROM wochen_report WHERE personal_nummer = $1;")
	if err != nil {
		return 0, err
	}
	defer qStr.Close()
	err = qStr.QueryRow(u.PersonalNummer).Scan(&overtime)
	if err != nil {
		return 0, err
	}
	return overtime, nil
}

func (u *User) GetAll() ([]User, error) {
	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)
		return users, err
	}
	defer qStr.Close()
	rows, err := qStr.Query()
	if err != nil {
		return users, err
	}
	defer rows.Close()
	for rows.Next() {

		var user User
		if err := rows.Scan(&user.CardUID, &user.Vorname, &user.Name); err != nil {
			log.Println("Error creating user!", err)
			continue
		}
		users = append(users, user)
	}
	if err = rows.Err(); err != nil {
		return users, nil
	}
	return users, nil
}

// Returns true if there is a booking 1 for today -> meaning the user is at work
// Returns false if there is no booking today or the user is already booked out of the system
func (u *User) CheckAnwesenheit() bool {
	qStr, err := DB.Prepare((`SELECT check_in_out FROM anwesenheit WHERE card_uid = $1 AND "timestamp"::date = now()::date ORDER BY "timestamp" DESC LIMIT 1;`))
	if err != nil {
		fmt.Printf("Error preparing query statement %v\n", err)
		return false
	}
	defer qStr.Close()
	var check_in_out int
	err = qStr.QueryRow(u.CardUID).Scan(&check_in_out)
	if err != nil {
		return false
	}
	return check_in_out%2 == 1
}

// Creates a new booking for the user -> check_in_out will be 254 for automatic check out
func (u *User) CheckOut() error {
	booking := (*Booking).New(nil, u.CardUID, 0, 254, 1)
	err := booking.Insert()
	if err != nil {
		fmt.Printf("Error inserting booking %v -> %v\n", booking, err)
		return err
	}
	return nil
}

func GetUserByPersonalNr(personalNummer int) (User, error) {
	var user User

	qStr, err := DB.Prepare((`SELECT personal_nummer, card_uid, vorname, nachname, arbeitszeit_per_tag, arbeitszeit_per_woche FROM s_personal_daten WHERE personal_nummer = $1;`))
	if err != nil {
		return user, err
	}
	err = qStr.QueryRow(personalNummer).Scan(&user.PersonalNummer, &user.CardUID, &user.Vorname, &user.Name, &user.ArbeitszeitPerTag, &user.ArbeitszeitPerWoche)

	if err != nil {
		return user, err
	}
	return user, nil
}

func (u *User) Login(password string) bool {
	var loginSuccess bool
	qStr, err := DB.Prepare((`SELECT (pass_hash = crypt($2, pass_hash)) AS pass_hash FROM user_password WHERE personal_nummer = $1;`))
	if err != nil {
		log.Println("Error preparing db statement", err)
		return false
	}
	defer qStr.Close()
	err = qStr.QueryRow(u.PersonalNummer, password).Scan(&loginSuccess)
	if err != nil {
		log.Println("Error queriing db", err)
		return false
	}
	return loginSuccess
}

// checks if old password matches and changes to new password
//
// returns auth(bool), error
func (u *User) ChangePass(password, newPassword string) (bool, error) {
	if !u.Login(password) {
		return false, nil
	}
	qStr, err := DB.Prepare((`UPDATE user_password SET pass_hash = crypt($2, gen_salt('bf')) WHERE personal_nummer = $1;`))
	if err != nil {
		return false, err
	}
	_, err = qStr.Exec(u.PersonalNummer, newPassword)
	if err != nil {
		return false, err
	}
	return true, nil
}

func (u *User) GetTeamMembers() ([]User, error) {
	var teamMembers []User
	qStr, err := DB.Prepare(`SELECT personal_nummer FROM s_personal_daten WHERE vorgesetzter_pers_nr = $1`)
	if err != nil {
		return teamMembers, err
	}
	defer qStr.Close()
	rows, err := qStr.Query(u.PersonalNummer)
	if err != nil {
		log.Println("Error getting rows!")
		return teamMembers, err
	}
	defer rows.Close()
	for rows.Next() {
		var personalNr int
		err := rows.Scan(&personalNr)
		user, err := GetUserByPersonalNr(personalNr)
		if err != nil {
			log.Println("Error getting user!")
			return teamMembers, err
		}
		teamMembers = append(teamMembers, user)
	}

	return teamMembers, nil
}

func (u *User) IsTeamLeader() bool {
	team, err := u.GetTeamMembers()
	if err != nil {
		log.Println("Error getting team Members", err)
		return false
	}
	return len(team) > 0
}

func (u *User) GetWeek(tsFrom time.Time) WorkWeek {
	var bookings []WorkDay
	weekStart := tsFrom.AddDate(0, 0, -1*int(tsFrom.Local().Weekday())-1)
	bookings, err := (*Booking).GetBookingsGrouped(nil, u.CardUID, weekStart, time.Now())
	if err != nil {
		log.Println("Error fetching bookings!")
		return WorkWeek{WorkDays: bookings}
	}
	return WorkWeek{WorkDays: bookings}
}

// gets the first week, that needs to be submitted
func (u *User) GetNextWeek() WorkWeek {
	var week WorkWeek
	return week

}

func parseUser(rows *sql.Rows) (User, error) {
	var user User
	if err := rows.Scan(&user.PersonalNummer, &user.CardUID, &user.Vorname, &user.Name, &user.ArbeitszeitPerTag); err != nil {
		log.Println("Error scanning row!", err)
		return user, err
	}
	return user, nil
}

// returns the start of the week, the last submission was made, submission == first booking or last send wochen_report to team leader
func (u *User) GetLastWorkWeekSubmission() time.Time {
	var lastSub time.Time
	qStr, err := DB.Prepare(`
	SELECT COALESCE(
	    (SELECT woche_start + INTERVAL '1 week' FROM wochen_report WHERE personal_nummer = $1 ORDER BY woche_start DESC LIMIT 1),
	    (SELECT timestamp FROM anwesenheit WHERE card_uid = $2 ORDER BY timestamp LIMIT 1)
    ) AS letzte_buchung;
`)
	if err != nil {
		log.Println("Error preparing statement!", err)
		return lastSub
	}
	err = qStr.QueryRow(u.PersonalNummer, u.CardUID).Scan(&lastSub)
	if err != nil {
		log.Println("Error executing query!", err)
		return lastSub
	}
	lastSub = getMonday(lastSub)
	lastSub = lastSub.Round(24 * time.Hour)
	return lastSub
}

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 s_personal_daten WHERE card_uid = $1;`))
	if err != nil {
		return user, err
	}
	err = qStr.QueryRow(card_uid).Scan(&user.PersonalNummer, &user.CardUID, &user.Vorname, &user.Name, &user.ArbeitszeitPerTag)

	if err != nil {
		return user, err
	}
	return user, nil
}

func getMonday(ts time.Time) time.Time {
	if ts.Weekday() != time.Monday {
		if ts.Weekday() == time.Sunday {
			ts = ts.AddDate(0, 0, -6)
		} else {
			ts = ts.AddDate(0, 0, -int(ts.Weekday()-1))
		}
	}
	return ts
}