z1glr/golunteer
1
0
Fork 0
Code Issues Actions Packages Projects Releases Wiki Activity

refactored some database retrievle stuff

Browse Source
This commit is contained in:
z1glr
2025-01-29 19:42:32 +00:00
parent 2c005e61a6
commit 6d38048e67
11 changed files with 281 additions and 209 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
backend/pkg/db/availabilities/availabilities.go
View File

@@ -1,8 +1,6 @@
package availabilities
import (
"github.com/johannesbuehl/golunteer/backend/pkg/db"
)
import "github.com/johannesbuehl/golunteer/backend/pkg/db"
type AvailabilityID int

36
backend/pkg/db/availabilities/userAvailabilities.go
View File

@@ -1,36 +0,0 @@
package availabilities
import (
"github.com/johannesbuehl/golunteer/backend/pkg/db"
)
type eventAvailabilities struct {
UserName string `db:"userName"`
AvailabilityID int `db:"availabilityID"`
}
type AvailabilityMap map[int][]string
func Event(eventID int) (AvailabilityMap, error) {
// get the availabilities for the event
var availabilitiesRows []eventAvailabilities
if err := db.DB.Select(&availabilitiesRows, "SELECT userName, availabilityID FROM USER_AVAILABILITIES WHERE eventID = ?", eventID); err != nil {
return nil, err
} else {
// transform the result into a map
eventAvailabilities := AvailabilityMap{}
// get the availabilities
for _, a := range availabilitiesRows {
// if there is no slice for this availability, create it
if _, exists := eventAvailabilities[a.AvailabilityID]; !exists {
eventAvailabilities[a.AvailabilityID] = make([]string, 0)
}
eventAvailabilities[a.AvailabilityID] = append(eventAvailabilities[a.AvailabilityID], a.UserName)
}
return eventAvailabilities, nil
}
}

70
backend/pkg/db/events/events.go
View File

@@ -4,14 +4,26 @@ import (
"slices"
"github.com/johannesbuehl/golunteer/backend/pkg/db"
"github.com/johannesbuehl/golunteer/backend/pkg/db/availabilities"
"github.com/johannesbuehl/golunteer/backend/pkg/logger"
)
// empty UserName interface so that the functions of this package can accept UserName variables without a circular import
type UserName interface{}
type TaskID interface{}
type EventID int
type eventAvailabilities struct {
UserName string `db:"userName"`
AvailabilityID int `db:"availabilityID"`
}
type AvailabilityMap map[int][]string
type EventData struct {
EventID int `db:"eventID" json:"eventID" validate:"required"`
Date string `db:"date" json:"date" validate:"required"`
Description string `db:"description" json:"description"`
EventID EventID `db:"eventID" json:"eventID" validate:"required"`
Date string `db:"date" json:"date" validate:"required"`
Description string `db:"description" json:"description"`
}
type EventPatch struct {
@@ -20,7 +32,7 @@ type EventPatch struct {
}
type EventAssignment struct {
TaskID int `db:"taskID" json:"taskID"`
TaskID TaskID `db:"taskID" json:"taskID"`
TaskName string `db:"taskName" json:"taskName"`
UserName *string `db:"userName" json:"userName"`
}
@@ -32,7 +44,7 @@ type EventWithAssignments struct {
type EventWithAvailabilities struct {
EventWithAssignments
Availabilities availabilities.AvailabilityMap `json:"availabilities"`
Availabilities AvailabilityMap `json:"availabilities"`
}
type EventWithAssignmentsUserAvailability struct {
@@ -49,7 +61,7 @@ type EventCreate struct {
// transform the database-entry to an WithAssignments
func (e EventData) WithAssignments() (EventWithAssignments, error) {
// get the assignments associated with the event
if assignemnts, err := Assignments(e.EventID); err != nil {
if assignemnts, err := e.EventID.Assignments(); err != nil {
return EventWithAssignments{}, err
} else {
return EventWithAssignments{
@@ -72,13 +84,37 @@ func (e EventWithAssignments) WithUserAvailability(userName string) (EventWithAs
}
}
func (eventID EventID) Availabilities() (AvailabilityMap, error) {
// get the availabilities for the event
var availabilitiesRows []eventAvailabilities
if err := db.DB.Select(&availabilitiesRows, "SELECT userName, availabilityID FROM USER_AVAILABILITIES WHERE eventID = ?", eventID); err != nil {
return nil, err
} else {
// transform the result into a map
eventAvailabilities := AvailabilityMap{}
// get the availabilities
for _, a := range availabilitiesRows {
// if there is no slice for this availability, create it
if _, exists := eventAvailabilities[a.AvailabilityID]; !exists {
eventAvailabilities[a.AvailabilityID] = make([]string, 0)
}
eventAvailabilities[a.AvailabilityID] = append(eventAvailabilities[a.AvailabilityID], a.UserName)
}
return eventAvailabilities, nil
}
}
func (e EventData) WithAvailabilities() (EventWithAvailabilities, error) {
// get the event with assignments
if event, err := e.WithAssignments(); err != nil {
return EventWithAvailabilities{}, err
// get the availabilities
} else if availabilities, err := availabilities.Event(e.EventID); err != nil {
} else if availabilities, err := e.EventID.Availabilities(); err != nil {
return EventWithAvailabilities{}, err
} else {
return EventWithAvailabilities{
@@ -141,7 +177,7 @@ func Update(event EventPatch) error {
} else {
type Task struct {
TaskID
EventID int `db:"eventID"`
EventID EventID `db:"eventID"`
}
// extract the rows that need to be deleted
@@ -235,25 +271,13 @@ func WithAvailabilities() ([]EventWithAvailabilities, error) {
}
}
func GetUserAvailability(eventID int, userName string) (*availabilities.AvailabilityID, error) {
var availabilityID struct {
AvailabilityID *availabilities.AvailabilityID `db:"availabilityID"`
}
if err := db.DB.QueryRowx("SELECT availabilityID FROM USER_AVAILABILITIES WHERE eventID = $1 AND userName = $2", eventID, userName).StructScan(&availabilityID); err != nil {
return availabilityID.AvailabilityID, err
} else {
return availabilityID.AvailabilityID, nil
}
}
func Delete(eventId int) error {
_, err := db.DB.Exec("DELETE FROM EVENTS WHERE eventID = ?", eventId)
return err
}
func Assignments(eventID int) ([]EventAssignment, error) {
func (eventID EventID) Assignments() ([]EventAssignment, error) {
// get the assignments from the database
var assignmentRows []EventAssignment
@@ -265,7 +289,7 @@ func Assignments(eventID int) ([]EventAssignment, error) {
}
// set the assignment of an user to a task for a specific event
func SetAssignment(eventID, taskID int, userName string) error {
func (eventID EventID) SetAssignment(taskID TaskID, userName UserName) error {
_, err := db.DB.Exec("UPDATE USER_ASSIGNMENTS SET userName = $1 WHERE eventID = $2 AND taskID = $3", userName, eventID, taskID)
return err

8
backend/pkg/db/tasks/tasks.go
View File

@@ -4,8 +4,10 @@ import (
"github.com/johannesbuehl/golunteer/backend/pkg/db"
)
type TaskID int
type TaskDB struct {
TaskID int `json:"taskID" db:"taskID" validate:"required"`
TaskID TaskID `json:"taskID" db:"taskID" validate:"required"`
Task `valdate:"required" `
}
@@ -25,12 +27,12 @@ func GetSlice() ([]TaskDB, error) {
}
func GetMap() (map[int]Task, error) {
func GetMap() (map[TaskID]Task, error) {
if tasksRaw, err := GetSlice(); err != nil {
return nil, err
} else {
// convert the result in a map
tasks := map[int]Task{}
tasks := map[TaskID]Task{}
for _, a := range tasksRaw {
tasks[a.TaskID] = Task{

139
backend/pkg/db/users/User.go
View File

@@ -3,10 +3,125 @@ package users
import (
"github.com/google/uuid"
"github.com/johannesbuehl/golunteer/backend/pkg/db"
"github.com/johannesbuehl/golunteer/backend/pkg/db/availabilities"
"github.com/johannesbuehl/golunteer/backend/pkg/db/events"
"github.com/johannesbuehl/golunteer/backend/pkg/db/tasks"
"github.com/johannesbuehl/golunteer/backend/pkg/logger"
"golang.org/x/crypto/bcrypt"
)
type UserName string
type UserDB struct {
UserName UserName `db:"userName" json:"userName"`
Admin bool `db:"admin" json:"admin"`
}
type User struct {
UserDB
PossibleTasks []int `json:"possibleTasks"`
}
type UserChangePassword struct {
UserName `json:"userName" validate:"required" db:"userName"`
Password string `json:"password" validate:"required,min=12"`
}
// hashes a password
func hashPassword(password string) ([]byte, error) {
return bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
}
func Get() ([]User, error) {
// get the usersDB from the database
var usersDB []UserDB
// get the users
if err := db.DB.Select(&usersDB, "SELECT userName, admin FROM USERS"); err != nil {
return nil, err
} else {
users := make([]User, len(usersDB))
// for the individual users, get the possible tasks
for ii, userDB := range usersDB {
if user, err := userDB.ToUser(); err != nil {
users = append(users[:ii], users[ii+1:]...)
} else {
users[ii] = user
}
}
return users, nil
}
}
func (userName UserName) TokenID() (string, error) {
var dbResult struct {
TokenID string `db:"tokenID"`
}
err := db.DB.Get(&dbResult, "SELECT tokenID FROM USERS WHERE userName = ?", userName)
return dbResult.TokenID, err
}
type UserAdd struct {
UserName `json:"userName" validate:"required" db:"userName"`
Password string `json:"password" validate:"required,min=12,max=64"`
Admin bool `json:"admin" db:"admin"`
PossibleTasks []tasks.TaskID `json:"possibleTasks" validate:"required"`
}
func Add(user UserAdd) error {
// try to hash the password
if hash, err := hashPassword(user.Password); err != nil {
return err
} else {
insertUser := struct {
UserAdd
Password []byte `db:"password"`
TokenID string `db:"tokenID"`
}{
UserAdd: user,
Password: hash,
TokenID: uuid.NewString(),
}
if _, err := db.DB.NamedExec("INSERT INTO USERS (userName, password, admin, tokenID) VALUES (:userName, :password, :admin, :tokenID)", insertUser); err != nil {
return err
}
// set the possible Tasks
for _, task := range user.PossibleTasks {
if _, err := db.DB.Exec("INSERT INTO USER_TASKS (userName, taskID) VALUES ($1, $2)", user.UserName, task); err != nil {
return err
}
}
return err
}
}
func Delete(userName string) error {
_, err := db.DB.Exec("DELETE FROM USERS WHERE userName = $1", userName)
return err
}
func (u *UserDB) ToUser() (User, error) {
// get the possible tasks
tasks := make([]int, 0)
if err := db.DB.Select(&tasks, "SELECT taskID FROM USER_TASKS WHERE userName = $1", u.UserName); err != nil {
return User{}, err
} else {
return User{
UserDB: *u,
PossibleTasks: tasks,
}, nil
}
}
func (userName UserName) WithUserAvailability() ([]events.EventWithAssignmentsUserAvailability, error) {
var events []events.EventWithAssignmentsUserAvailability
@@ -62,7 +177,7 @@ func (userName UserName) ChangePassword(password string) (string, error) {
}
}
func (userName UserName) SetTasks(tasks []int) error {
func (userName UserName) SetTasks(tasks []tasks.TaskID) error {
// remove all current possible tasks
if _, err := db.DB.Exec("DELETE FROM USER_TASKS WHERE userName = $1", userName); err != nil {
return err
@@ -79,6 +194,16 @@ func (userName UserName) SetTasks(tasks []int) error {
}
}
func (userName UserName) CheckTask(taskID tasks.TaskID) (bool, error) {
var check bool
if err := db.DB.Select(&check, "SELECT 1 FROM USER_TASKS WHERE userName = $1 AND taskID = $2", userName, taskID); err != nil {
return false, err
} else {
return check, nil
}
}
func (userName UserName) UserPending() ([]events.EventData, error) {
var result []events.EventData
@@ -137,3 +262,15 @@ func (userName UserName) SetEventAvailability(eventID, availabilityID int) error
return err
}
func (userName UserName) GetUserAvailability(eventID events.EventID) (*availabilities.AvailabilityID, error) {
var availabilityID struct {
AvailabilityID *availabilities.AvailabilityID `db:"availabilityID"`
}
if err := db.DB.QueryRowx("SELECT availabilityID FROM USER_AVAILABILITIES WHERE eventID = $1 AND userName = $2", eventID, userName).StructScan(&availabilityID); err != nil {
return availabilityID.AvailabilityID, err
} else {
return availabilityID.AvailabilityID, nil
}
}

119
backend/pkg/db/users/main.go
View File

@@ -1,119 +0,0 @@
package users
import (
"github.com/google/uuid"
"github.com/johannesbuehl/golunteer/backend/pkg/db"
"golang.org/x/crypto/bcrypt"
)
type UserName string
type UserDB struct {
UserName UserName `db:"userName" json:"userName"`
Admin bool `db:"admin" json:"admin"`
}
type User struct {
UserDB
PossibleTasks []int `json:"possibleTasks"`
}
type UserChangePassword struct {
UserName `json:"userName" validate:"required" db:"userName"`
Password string `json:"password" validate:"required,min=12"`
}
// hashes a password
func hashPassword(password string) ([]byte, error) {
return bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
}
func Get() ([]User, error) {
// get the usersDB from the database
var usersDB []UserDB
// get the users
if err := db.DB.Select(&usersDB, "SELECT userName, admin FROM USERS"); err != nil {
return nil, err
} else {
users := make([]User, len(usersDB))
// for the individual users, get the possible tasks
for ii, userDB := range usersDB {
if user, err := userDB.ToUser(); err != nil {
users = append(users[:ii], users[ii+1:]...)
} else {
users[ii] = user
}
}
return users, nil
}
}
func (userName UserName) TokenID() (string, error) {
var dbResult struct {
TokenID string `db:"tokenID"`
}
err := db.DB.Get(&dbResult, "SELECT tokenID FROM USERS WHERE userName = ?", userName)
return dbResult.TokenID, err
}
type UserAdd struct {
UserName `json:"userName" validate:"required" db:"userName"`
Password string `json:"password" validate:"required,min=12,max=64"`
Admin bool `json:"admin" db:"admin"`
PossibleTasks []int `json:"possibleTasks" validate:"required"`
}
func Add(user UserAdd) error {
// try to hash the password
if hash, err := hashPassword(user.Password); err != nil {
return err
} else {
insertUser := struct {
UserAdd
Password []byte `db:"password"`
TokenID string `db:"tokenID"`
}{
UserAdd: user,
Password: hash,
TokenID: uuid.NewString(),
}
if _, err := db.DB.NamedExec("INSERT INTO USERS (userName, password, admin, tokenID) VALUES (:userName, :password, :admin, :tokenID)", insertUser); err != nil {
return err
}
// set the possible Tasks
for _, task := range user.PossibleTasks {
if _, err := db.DB.Exec("INSERT INTO USER_TASKS (userName, taskID) VALUES ($1, $2)", user.UserName, task); err != nil {
return err
}
}
return err
}
}
func Delete(userName string) error {
_, err := db.DB.Exec("DELETE FROM USERS WHERE userName = $1", userName)
return err
}
func (u *UserDB) ToUser() (User, error) {
// get the possible tasks
tasks := make([]int, 0)
if err := db.DB.Select(&tasks, "SELECT taskID FROM USER_TASKS WHERE userName = $1", u.UserName); err != nil {
return User{}, err
} else {
return User{
UserDB: *u,
PossibleTasks: tasks,
}, nil
}
}

23
backend/pkg/router/events.go
View File

@@ -7,6 +7,8 @@ import (
"github.com/jmoiron/sqlx"
"github.com/johannesbuehl/golunteer/backend/pkg/db"
"github.com/johannesbuehl/golunteer/backend/pkg/db/events"
"github.com/johannesbuehl/golunteer/backend/pkg/db/tasks"
"github.com/johannesbuehl/golunteer/backend/pkg/db/users"
)
func (a *Handler) postEvent() {
@@ -189,24 +191,25 @@ func (a *Handler) putEventAssignment() {
logger.Warn().Msg("setting event-assignment failed: user is no admin")
// retrieve the eventID from the query
} else if eventID := a.C.QueryInt("eventID", -1); eventID == -1 {
} else if eventID := events.EventID(a.C.QueryInt("eventID", -1)); eventID == -1 {
a.Status = fiber.StatusBadRequest
logger.Warn().Msg("setting event-assignment failed: query is missing \"eventID\"")
// retrieve the taskID from the query
} else if taskID := a.C.QueryInt("taskID", -1); taskID == -1 {
} else if taskID := tasks.TaskID(a.C.QueryInt("taskID", -1)); taskID == -1 {
a.Status = fiber.StatusBadRequest
logger.Log().Msg("setting event-assignment failed: query is missing \"taskID\"")
// parse the body
} else if userName := string(a.C.Body()); userName == "" {
} else if userName := users.UserName(a.C.Body()); userName == "" {
a.Status = fiber.StatusBadRequest
logger.Log().Msg("setting event-assignment failed: body is missing")
// check wether the user has actually entered an availability for the event
} else if availabilityID, err := events.GetUserAvailability(eventID, userName); err != nil {
} else if availabilityID, err := userName.GetUserAvailability(eventID); err != nil {
a.Status = fiber.StatusBadRequest
logger.Log().Msgf("setting event-assignment failed: can't check users availability: %v", err)
@@ -215,8 +218,18 @@ func (a *Handler) putEventAssignment() {
logger.Log().Msgf("setting event-assignment failed: user %q isn't available for event with eventID = %d", userName, eventID)
// check wether the user can be assigned for this task
} else if check, err := userName.CheckTask(taskID); err != nil {
a.Status = fiber.StatusInternalServerError
logger.Error().Msgf("setting event-assignment failed: can't check wether the task with taskID = %d is possible: %v", taskID, err)
} else if !check {
a.Status = fiber.StatusBadRequest
logger.Log().Msgf("setting event-assignment failed: task with taskID = %d is not possible for user", taskID)
// set the availability in the database
} else if err := events.SetAssignment(eventID, taskID, userName); err != nil {
} else if err := eventID.SetAssignment(taskID, userName); err != nil {
a.Status = fiber.StatusBadRequest
logger.Warn().Msgf("setting event-assignment failed: can't write to database: %v", err)