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

changed names of database columns

Browse Source
This commit is contained in:
z1glr
2025-01-23 10:12:12 +00:00
parent 7265a4e36a
commit c752bc6c14
36 changed files with 604 additions and 605 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
backend/pkg/db/assignments/assignments.go
View File

@@ -1,22 +0,0 @@
package assignments
import (
"github.com/johannesbuehl/golunteer/backend/pkg/db"
)
type EventAssignment struct {
TaskID int `db:"taskID" json:"taskID"`
TaskName string `db:"taskName" json:"taskName"`
UserName *string `db:"userName" json:"userName"`
}
func Event(eventID int) ([]EventAssignment, error) {
// get the assignments from the database
var assignmentRows []EventAssignment
if err := db.DB.Select(&assignmentRows, "SELECT USERS.name AS userName, taskID, TASKS.name AS taskName FROM USER_ASSIGNMENTS LEFT JOIN USERS ON USER_ASSIGNMENTS.userName = USERS.name LEFT JOIN TASKS ON USER_ASSIGNMENTS.taskID = TASKS.id WHERE USER_ASSIGNMENTS.eventID = ?", eventID); err != nil {
return nil, err
} else {
return assignmentRows, nil
}
}

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

@@ -5,24 +5,24 @@ import (
)
type AvailabilityDB struct {
Id int `db:"id" json:"id" validate:"required"`
Availability `validate:"required"`
AvailabilityID int `db:"availabilityID" json:"availabilityID" validate:"required"`
Availability `validate:"required"`
}
type Availability struct {
Name string `db:"name" json:"name" validate:"required"`
Enabled bool `db:"enabled" json:"enabled" validate:"required"`
Color string `db:"color" json:"color" validate:"required"`
AvailabilityName string `db:"availabilityName" json:"availabilityName" validate:"required"`
Enabled bool `db:"enabled" json:"enabled"`
Color string `db:"color" json:"color" validate:"required"`
}
func Add(a Availability) error {
_, err := db.DB.NamedExec("INSERT INTO AVAILABILITIES (name, color, enabled) VALUES (:name, :color, :enabled)", a)
_, err := db.DB.NamedExec("INSERT INTO AVAILABILITIES (availabilityName, color, enabled) VALUES (:availabilityName, :color, :enabled)", a)
return err
}
func Update(a AvailabilityDB) error {
_, err := db.DB.NamedExec("UPDATE AVAILABILITIES SET name = :name, color = :color, enabled = :enabled WHERE id = :id", a)
_, err := db.DB.NamedExec("UPDATE AVAILABILITIES SET availabilityName = :availabilityName, color = :color, enabled = :enabled WHERE availabilityID = :availabilityID", a)
return err
}
@@ -46,10 +46,10 @@ func Keys() (map[int]Availability, error) {
availabilities := map[int]Availability{}
for _, a := range availabilitiesRaw {
availabilities[a.Id] = Availability{
Name: a.Name,
Enabled: a.Enabled,
Color: a.Color,
availabilities[a.AvailabilityID] = Availability{
AvailabilityName: a.AvailabilityName,
Enabled: a.Enabled,
Color: a.Color,
}
}
@@ -58,7 +58,7 @@ func Keys() (map[int]Availability, error) {
}
func Delete(id int) error {
_, err := db.DB.Exec("DELETE FROM AVAILABILITIES WHERE id = $1", id)
_, err := db.DB.Exec("DELETE FROM AVAILABILITIES WHERE availabilityID = $1", id)
return err
}

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

@@ -24,7 +24,7 @@ func Event(eventID int) (map[string]string, error) {
return nil, err
} else {
for _, a := range availabilitiesRows {
eventAvailabilities[a.UserName] = availabilitiesMap[a.AvailabilityID].Name
eventAvailabilities[a.UserName] = availabilitiesMap[a.AvailabilityID].AvailabilityName
}
return eventAvailabilities, nil

2
backend/pkg/db/db.go
View File

@@ -31,7 +31,7 @@ func init() {
var admin struct {
Admin bool `db:"admin"`
}
if err := DB.QueryRowx("SELECT admin FROM USERS WHERE name = 'admin'").StructScan(&admin); err != nil {
if err := DB.QueryRowx("SELECT admin FROM USERS WHERE userName = 'admin'").StructScan(&admin); err != nil {
// if the error isn't because there was no result, it's a real one
if err != sql.ErrNoRows {
panic(fmt.Errorf("can't query for the admin-user: %v", err))

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

@@ -4,14 +4,30 @@ import (
"slices"
"github.com/johannesbuehl/golunteer/backend/pkg/db"
"github.com/johannesbuehl/golunteer/backend/pkg/db/assignments"
"github.com/johannesbuehl/golunteer/backend/pkg/db/availabilities"
"github.com/johannesbuehl/golunteer/backend/pkg/logger"
)
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"`
}
type EventPatch struct {
EventData
Tasks []int `json:"tasks" validate:"required,min=1"`
}
type EventAssignment struct {
TaskID int `db:"taskID" json:"taskID"`
TaskName string `db:"taskName" json:"taskName"`
UserName *string `db:"userName" json:"userName"`
}
type EventWithAssignment struct {
eventDataDB
Tasks []assignments.EventAssignment `json:"tasks"`
EventData
Tasks []EventAssignment `json:"tasks"`
}
type EventWithAvailabilities struct {
@@ -19,32 +35,32 @@ type EventWithAvailabilities struct {
Availabilities map[string]string `json:"availabilities"`
}
type eventDataDB struct {
ID int `db:"id" json:"id" validate:"required"`
Date string `db:"date" json:"date" validate:"required"`
type EventCreate struct {
Date string `db:"date" json:"date" validate:"required,datetime=2006-01-02T15:04:05.999999999Z"`
Description string `db:"description" json:"description"`
Tasks []int `json:"tasks" validate:"required,min=1"`
}
// transform the database-entry to an Event
func (e eventDataDB) Event() (EventWithAssignment, error) {
func (e EventData) Event() (EventWithAssignment, error) {
// get the assignments associated with the event
if assignemnts, err := assignments.Event(e.ID); err != nil {
if assignemnts, err := Assignments(e.EventID); err != nil {
return EventWithAssignment{}, err
} else {
return EventWithAssignment{
eventDataDB: e,
Tasks: assignemnts,
EventData: e,
Tasks: assignemnts,
}, nil
}
}
func (e eventDataDB) EventWithAvailabilities() (EventWithAvailabilities, error) {
func (e EventData) EventWithAvailabilities() (EventWithAvailabilities, error) {
// get the event with assignments
if event, err := e.Event(); err != nil {
return EventWithAvailabilities{}, err
// get the availabilities
} else if availabilities, err := availabilities.Event(e.ID); err != nil {
} else if availabilities, err := availabilities.Event(e.EventID); err != nil {
return EventWithAvailabilities{}, err
} else {
return EventWithAvailabilities{
@@ -54,12 +70,6 @@ func (e eventDataDB) EventWithAvailabilities() (EventWithAvailabilities, error)
}
}
type EventCreate struct {
Date string `db:"date" json:"date" validate:"required,datetime=2006-01-02T15:04:05.999999999Z"`
Description string `db:"description" json:"description"`
Tasks []int `json:"tasks" validate:"required,min=1"`
}
func Create(event EventCreate) error {
// convert the date to utc
if result, err := db.DB.NamedExec("INSERT INTO EVENTS (date, description) VALUES (:date, :description)", event); err != nil {
@@ -86,7 +96,7 @@ func Create(event EventCreate) error {
// create the assignments
if _, err := db.DB.NamedExec("INSERT INTO USER_ASSIGNMENTS (eventID, taskID) VALUES (:eventID, :taskID)", tasks); err != nil {
// delete the event again
db.DB.Query("DELETE FROM EVENTS WHERE id = ?", id)
db.DB.Query("DELETE FROM EVENTS WHERE eventID = ?", id)
return err
}
@@ -95,25 +105,20 @@ func Create(event EventCreate) error {
return nil
}
type EventPatch struct {
eventDataDB
Tasks []int `json:"tasks" validate:"required,min=1"`
}
func Update(event EventPatch) error {
// update the event itself
if _, err := db.DB.NamedExec("UPDATE EVENTS SET description = :description, date = :date WHERE id = :id", event); err != nil {
if _, err := db.DB.NamedExec("UPDATE EVENTS SET description = :description, date = :date WHERE eventID = :id", event); err != nil {
return err
// get the tasks currently assigned to the event
} else {
type TaskID struct {
ID int `db:"taskID"`
TaskID int `db:"taskID"`
}
var taskRows []TaskID
if err := db.DB.Select(&taskRows, "SELECT taskID FROM USER_ASSIGNMENTS WHERE eventID = ?", event.ID); err != nil {
if err := db.DB.Select(&taskRows, "SELECT taskID FROM USER_ASSIGNMENTS WHERE eventID = $1", event.EventID); err != nil {
return err
} else {
type Task struct {
@@ -125,17 +130,17 @@ func Update(event EventPatch) error {
deleteRows := []Task{}
for _, row := range taskRows {
if !slices.Contains(event.Tasks, row.ID) {
deleteRows = append(deleteRows, Task{TaskID: row, EventID: event.ID})
if !slices.Contains(event.Tasks, row.TaskID) {
deleteRows = append(deleteRows, Task{TaskID: row, EventID: event.EventID})
}
}
// extract the rows that need to be created
createRows := []Task{}
for _, id := range event.Tasks {
if !slices.Contains(taskRows, TaskID{ID: id}) {
createRows = append(createRows, Task{TaskID: TaskID{ID: id}, EventID: event.ID})
for _, taskID := range event.Tasks {
if !slices.Contains(taskRows, TaskID{TaskID: taskID}) {
createRows = append(createRows, Task{TaskID: TaskID{TaskID: taskID}, EventID: event.EventID})
}
}
@@ -158,8 +163,8 @@ func Update(event EventPatch) error {
}
}
func All() ([]eventDataDB, error) {
var dbRows []eventDataDB
func All() ([]EventData, error) {
var dbRows []EventData
if err := db.DB.Select(&dbRows, "SELECT * FROM EVENTS"); err != nil {
return nil, err
@@ -177,7 +182,7 @@ func WithAssignments() ([]EventWithAssignment, error) {
for ii, e := range eventsDB {
if ev, err := e.Event(); err != nil {
logger.Logger.Error().Msgf("can't get assignments for event with id = %d: %v", e.ID, err)
logger.Logger.Error().Msgf("can't get assignments for event with assignmentID = %d: %v", e.EventID, err)
} else {
events[ii] = ev
}
@@ -196,7 +201,7 @@ func WithAvailabilities() ([]EventWithAvailabilities, error) {
for ii, e := range eventsDB {
if ev, err := e.EventWithAvailabilities(); err != nil {
logger.Logger.Error().Msgf("can't get availabilities for event with id = %d: %v", e.ID, err)
logger.Logger.Error().Msgf("can't get availabilities for event with eventID = %d: %v", e.EventID, err)
} else {
events[ii] = ev
}
@@ -206,12 +211,22 @@ func WithAvailabilities() ([]EventWithAvailabilities, error) {
}
}
func UserPending(userName string) (int, error) {
func UserPending(userName string) ([]EventData, error) {
var result []EventData
if err := db.DB.Select(&result, "SELECT eventID, date, description FROM EVENTS WHERE NOT EXISTS (SELECT 1 FROM USER_AVAILABILITIES WHERE USER_AVAILABILITIES.eventID = EVENTS.eventID AND USER_AVAILABILITIES.userName = ?)", userName); err != nil {
return nil, err
} else {
return result, nil
}
}
func UserPendingCount(userName string) (int, error) {
var result struct {
Count int `db:"count(*)"`
}
if err := db.DB.QueryRowx("SELECT count(*) FROM EVENTS WHERE NOT EXISTS (SELECT 1 FROM USER_AVAILABILITIES WHERE USER_AVAILABILITIES.eventID = EVENTS.id AND USER_AVAILABILITIES.userName = ?)", userName).StructScan(&result); err != nil {
if err := db.DB.QueryRowx("SELECT count(*) FROM EVENTS WHERE NOT EXISTS (SELECT 1 FROM USER_AVAILABILITIES WHERE USER_AVAILABILITIES.eventID = EVENTS.eventID AND USER_AVAILABILITIES.userName = ?)", userName).StructScan(&result); err != nil {
return 0, err
} else {
return result.Count, nil
@@ -219,7 +234,35 @@ func UserPending(userName string) (int, error) {
}
func Delete(eventId int) error {
_, err := db.DB.Exec("DELETE FROM EVENTS WHERE id = ?", eventId)
_, err := db.DB.Exec("DELETE FROM EVENTS WHERE eventID = ?", eventId)
return err
}
func Assignments(eventID int) ([]EventAssignment, error) {
// get the assignments from the database
var assignmentRows []EventAssignment
if err := db.DB.Select(&assignmentRows, "SELECT USERS.userName, TASKS.taskID, TASKS.taskName FROM USER_ASSIGNMENTS LEFT JOIN USERS ON USER_ASSIGNMENTS.userName = USERS.userName LEFT JOIN TASKS ON USER_ASSIGNMENTS.taskID = TASKS.taskID WHERE USER_ASSIGNMENTS.eventID = ?", eventID); err != nil {
return nil, err
} else {
return assignmentRows, nil
}
}
func User(userName string) ([]EventWithAssignment, error) {
// get all assignments of the user
// var events []EventWithAssignment
var events []struct {
EventData
TaskID int `db:"taskID"`
UserName string `db:"userName"`
}
if err := db.DB.Select(&events, "SELECT DISTINCT * FROM USER_ASSIGNMENTS INNER JOIN EVENTS ON USER_ASSIGNMENTS.eventID = EVENTS.eventID WHERE userName = $1", userName); err != nil {
return nil, err
} else {
return nil, nil
}
}

6
backend/pkg/db/setup.go
View File

@@ -38,17 +38,17 @@ func setup() {
// create an admin-user
user := struct {
Name string `db:"name"`
UserName string `db:"userName"`
Password []byte `db:"password"`
Admin bool `db:"admin"`
TokenID string `db:"tokenID"`
}{
Name: "admin",
UserName: "admin",
Password: passwordHash,
Admin: true,
TokenID: uuid.NewString(),
}
if _, err := DB.NamedExec("INSERT INTO USERS (name, password, tokenID, admin) VALUES (:name, :password, :tokenID, :admin)", &user); err != nil {
if _, err := DB.NamedExec("INSERT INTO USERS (userName, password, tokenID, admin) VALUES (:userName, :password, :tokenID, :admin)", &user); err != nil {
panic(fmt.Errorf("can't insert admin-user into the database: %v", err))
}

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

@@ -5,13 +5,13 @@ import (
)
type TaskDB struct {
ID int `json:"id" db:"id" validate:"required"`
Task `valdate:"required" `
TaskID int `json:"taskID" db:"taskID" validate:"required"`
Task `valdate:"required" `
}
type Task struct {
Name string `json:"name" db:"name" validate:"required"`
Enabled bool `json:"enabled" db:"enabled" validate:"required"`
TaskName string `json:"taskName" db:"taskName" validate:"required"`
Enabled bool `json:"enabled" db:"enabled" validate:"required"`
}
func GetSlice() ([]TaskDB, error) {
@@ -33,9 +33,9 @@ func GetMap() (map[int]Task, error) {
tasks := map[int]Task{}
for _, a := range tasksRaw {
tasks[a.ID] = Task{
Name: a.Name,
Enabled: a.Enabled,
tasks[a.TaskID] = Task{
TaskName: a.TaskName,
Enabled: a.Enabled,
}
}
@@ -44,19 +44,19 @@ func GetMap() (map[int]Task, error) {
}
func Add(t Task) error {
_, err := db.DB.NamedExec("INSERT INTO TASKS (name, enabled) VALUES (:name, :enabled)", &t)
_, err := db.DB.NamedExec("INSERT INTO TASKS (taskName, enabled) VALUES (:taskName, :enabled)", &t)
return err
}
func Update(t TaskDB) error {
_, err := db.DB.NamedExec("UPDATE TASKS set name = :name, enabled = :enabled WHERE id = :id", &t)
_, err := db.DB.NamedExec("UPDATE TASKS set taskName = :taskName, enabled = :enabled WHERE taskID = :taskID", &t)
return err
}
func Delete(i int) error {
_, err := db.DB.Exec("DELETE FROM TASKS WHERE id = $1", i)
_, err := db.DB.Exec("DELETE FROM TASKS WHERE taskID = $1", i)
return err
}

16
backend/pkg/db/users/users.go
View File

@@ -7,8 +7,8 @@ import (
)
type User struct {
Name string `db:"name" json:"userName"`
Admin bool `db:"admin" json:"admin"`
UserName string `db:"userName" json:"userName"`
Admin bool `db:"admin" json:"admin"`
}
type UserChangePassword struct {
@@ -25,7 +25,7 @@ func Get() ([]User, error) {
// get the users from the database
var users []User
if err := db.DB.Select(&users, "SELECT name, admin FROM USERS"); err != nil {
if err := db.DB.Select(&users, "SELECT userName, admin FROM USERS"); err != nil {
return nil, err
} else {
return users, nil
@@ -37,7 +37,7 @@ func TokenID(userName string) (string, error) {
TokenID string `db:"tokenID"`
}
err := db.DB.Get(&dbResult, "SELECT tokenID FROM USERS WHERE name = ?", userName)
err := db.DB.Get(&dbResult, "SELECT tokenID FROM USERS WHERE userName = ?", userName)
return dbResult.TokenID, err
}
@@ -63,7 +63,7 @@ func Add(user UserAdd) error {
TokenID: uuid.NewString(),
}
_, err := db.DB.NamedExec("INSERT INTO USERS (name, password, admin, tokenID) VALUES (:userName, :password, :admin, :tokenID)", insertUser)
_, err := db.DB.NamedExec("INSERT INTO USERS (userName, password, admin, tokenID) VALUES (:userName, :password, :admin, :tokenID)", insertUser)
return err
}
@@ -93,19 +93,19 @@ func ChangePassword(user UserChangePassword) (string, error) {
}
func ChangeName(userName, newName string) error {
_, err := db.DB.Exec("UPDATE USERS SET name = ? WHERE name = ?", newName, userName)
_, err := db.DB.Exec("UPDATE USERS SET userName = ? WHERE userName = ?", newName, userName)
return err
}
func SetAdmin(userName string, admin bool) error {
_, err := db.DB.Exec("UPDATE USERS SET admin = ? WHERE name = ?", admin, userName)
_, err := db.DB.Exec("UPDATE USERS SET admin = ? WHERE userName = ?", admin, userName)
return err
}
func Delete(userName string) error {
_, err := db.DB.Exec("DELETE FROM USERS WHERE name = $1", userName)
_, err := db.DB.Exec("DELETE FROM USERS WHERE userName = $1", userName)
return err
}