started work on task assignment table

backend/pkg/db/availabilites/userAvailabilities.go

@@ -1,36 +0,0 @@
-package availabilites
-
-import (
-	"github.com/johannesbuehl/golunteer/backend/pkg/db"
-	"github.com/johannesbuehl/golunteer/backend/pkg/db/users"
-)
-
-type eventAvailabilites struct {
-	userName       string `db:"userName"`
-	AvailabilityID int    `db:"availabilityID"`
-}
-
-func Event(eventID int) (map[string]string, error) {
-	// get the availabilites for the event
-	var availabilitesRows []eventAvailabilites
-
-	if err := db.DB.Select(&availabilitesRows, "SELECT (userID, availabilityID) FROM USER_AVAILABILITES WHERE eventID = ?", eventID); err != nil {
-		return nil, err
-	} else {
-		// transform the result into a map
-		eventAvailabilities := map[string]string{}
-
-		// get the availabilites
-		if availabilitesMap, err := Keys(); err != nil {
-			return nil, err
-		} else if usersMap, err := users.Get(); err != nil {
-			return nil, err
-		} else {
-			for _, a := range availabilitesRows {
-				eventAvailabilities[usersMap[a.userName].Name] = availabilitesMap[a.AvailabilityID].Text
-			}
-
-			return eventAvailabilities, nil
-		}
-	}
-}

backend/pkg/db/availabilities/availabilities.go

@@ -1,4 +1,4 @@
-package availabilites
+package availabilities
 
 import (
 	"fmt"
@@ -8,7 +8,7 @@ import (
 	"github.com/johannesbuehl/golunteer/backend/pkg/db"
 )
 
-type availabilitesDB struct {
+type availabilitiesDB struct {
 	Id       int    `db:"id"`
 	Text     string `db:"text"`
 	Disabled bool   `db:"disabled"`
@@ -22,31 +22,31 @@ type Availability struct {
 var c *cache.Cache
 
 func Keys() (map[int]Availability, error) {
-	if availabilities, hit := c.Get("availabilites"); !hit {
+	if availabilities, hit := c.Get("availabilities"); !hit {
 		refresh()
 
-		return nil, fmt.Errorf("availabilites not stored cached")
+		return nil, fmt.Errorf("availabilities not stored cached")
 	} else {
 		return availabilities.(map[int]Availability), nil
 	}
 }
 
 func refresh() {
-	// get the availabilitesRaw from the database
-	var availabilitesRaw []availabilitesDB
+	// get the availabilitiesRaw from the database
+	var availabilitiesRaw []availabilitiesDB
 
-	if err := db.DB.Select(&availabilitesRaw, "SELECT * FROM AVAILABILITIES"); err == nil {
+	if err := db.DB.Select(&availabilitiesRaw, "SELECT * FROM AVAILABILITIES"); err == nil {
 		// convert the result in a map
-		availabilites := map[int]Availability{}
+		availabilities := map[int]Availability{}
 
-		for _, a := range availabilitesRaw {
-			availabilites[a.Id] = Availability{
+		for _, a := range availabilitiesRaw {
+			availabilities[a.Id] = Availability{
 				Text:     a.Text,
 				Disabled: a.Disabled,
 			}
 		}
 
-		c.Set("availabilites", availabilites)
+		c.Set("availabilities", availabilities)
 	}
 }
 

backend/pkg/db/availabilities/userAvailabilities.go

@@ -0,0 +1,36 @@
+package availabilities
+
+import (
+	"github.com/johannesbuehl/golunteer/backend/pkg/db"
+	"github.com/johannesbuehl/golunteer/backend/pkg/db/users"
+)
+
+type eventAvailabilities struct {
+	UserName       string `db:"userName"`
+	AvailabilityID int    `db:"availabilityID"`
+}
+
+func Event(eventID int) (map[string]string, 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 := map[string]string{}
+
+		// get the availabilities
+		if availabilitiesMap, err := Keys(); err != nil {
+			return nil, err
+		} else if usersMap, err := users.Get(); err != nil {
+			return nil, err
+		} else {
+			for _, a := range availabilitiesRows {
+				eventAvailabilities[usersMap[a.UserName].Name] = availabilitiesMap[a.AvailabilityID].Text
+			}
+
+			return eventAvailabilities, nil
+		}
+	}
+}

backend/pkg/db/events/events.go

@@ -3,6 +3,7 @@ package events
 import (
 	"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"
 )
 
@@ -11,6 +12,11 @@ type EventWithAssignment struct {
 	Tasks map[string]*string `json:"tasks"`
 }
 
+type EventWithAvailabilities struct {
+	EventWithAssignment
+	Availabilities map[string]string `json:"availabilities"`
+}
+
 type eventDataDB struct {
 	Id          int    `db:"id" json:"id"`
 	Date        string `db:"date" json:"date" validate:"required"`
@@ -18,18 +24,34 @@ type eventDataDB struct {
 }
 
 // transform the database-entry to an Event
-func (e *eventDataDB) Event() (EventWithAssignment, error) {
-	// get the availabilites associated with the event
+func (e eventDataDB) Event() (EventWithAssignment, error) {
+	// get the assignments associated with the event
 	if assignemnts, err := assignments.Event(e.Id); err != nil {
 		return EventWithAssignment{}, err
 	} else {
 		return EventWithAssignment{
-			eventDataDB: *e,
+			eventDataDB: e,
 			Tasks:       assignemnts,
 		}, nil
 	}
 }
 
+func (e eventDataDB) 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 {
+		return EventWithAvailabilities{}, err
+	} else {
+		return EventWithAvailabilities{
+			EventWithAssignment: event,
+			Availabilities:      availabilities,
+		}, nil
+	}
+}
+
 type EventCreate struct {
 	eventDataDB
 	Tasks []int `json:"tasks" validate:"required,min=1"`
@@ -98,6 +120,25 @@ func WithAssignments() ([]EventWithAssignment, error) {
 	}
 }
 
+func WithAvailabilities() ([]EventWithAvailabilities, error) {
+	// get all events
+	if eventsDB, err := All(); err != nil {
+		return nil, err
+	} else {
+		events := make([]EventWithAvailabilities, len(eventsDB))
+
+		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)
+			} else {
+				events[ii] = ev
+			}
+		}
+
+		return events, nil
+	}
+}
+
 func UserPending(userName string) (int, error) {
 	var result struct {
 		Count int `db:"count(*)"`

backend/pkg/db/users/users.go

@@ -9,10 +9,10 @@ import (
 )
 
 type User struct {
-	Name     string `db:"text"`
+	Name     string `db:"name"`
 	Password []byte `db:"password"`
 	TokenID  string `db:"tokenID"`
-	Admin    bool   `db:"disabled"`
+	Admin    bool   `db:"admin"`
 }
 
 var c *cache.Cache
@@ -21,7 +21,7 @@ func Get() (map[string]User, error) {
 	if users, hit := c.Get("users"); !hit {
 		refresh()
 
-		return nil, fmt.Errorf("users not stored cached")
+		return nil, fmt.Errorf("users not cached")
 	} else {
 		return users.(map[string]User), nil
 	}

backend/pkg/router/events.go

@@ -56,6 +56,25 @@ func getEventsAssignments(args HandlerArgs) responseMessage {
 	return response
 }
 
+func getEventsAvailabilities(args HandlerArgs) responseMessage {
+	response := responseMessage{}
+
+	// check for admin
+	if !args.User.Admin {
+		response.Status = fiber.StatusForbidden
+	} else {
+		if events, err := events.WithAvailabilities(); err != nil {
+			response.Status = fiber.StatusInternalServerError
+
+			logger.Error().Msgf("can't retrieve events with availabilities: %v", err)
+		} else {
+			response.Data = events
+		}
+	}
+
+	return response
+}
+
 func getEventsUserPending(args HandlerArgs) responseMessage {
 	response := responseMessage{}
 

backend/pkg/router/login.go

@@ -73,8 +73,8 @@ func handleLogin(c *fiber.Ctx) error {
 			} else {
 				// password is correct -> generate the JWT
 				if jwt, err := config.SignJWT(JWTPayload{
-					UserID:  requestBody.Username,
-					TokenID: result.TokenID,
+					UserName: requestBody.Username,
+					TokenID:  result.TokenID,
 				}); err != nil {
 					response.Status = fiber.StatusInternalServerError
 					logger.Error().Msgf("can't create JWT: %v", err)

backend/pkg/router/router.go

@@ -75,9 +75,10 @@ func init() {
 	// map with the individual registered endpoints
 	endpoints := map[string]map[string]func(HandlerArgs) responseMessage{
 		"GET": {
-			"events/assignments":  getEventsAssignments,
-			"events/user/pending": getEventsUserPending,
-			"tasks":               getTasks,
+			"events/assignments":    getEventsAssignments,
+			"events/availabilities": getEventsAvailabilities,
+			"events/user/pending":   getEventsUserPending,
+			"tasks":                 getTasks,
 		},
 		"POST":   {"events": postEvent},
 		"PATCH":  {},
@@ -160,8 +161,8 @@ func removeSessionCookie(c *fiber.Ctx) {
 
 // payload of the JSON webtoken
 type JWTPayload struct {
-	UserID  string `json:"userID"`
-	TokenID string `json:"tokenID"`
+	UserName string `json:"userName"`
+	TokenID  string `json:"tokenID"`
 }
 
 // complete JSON webtoken
@@ -172,7 +173,7 @@ type JWT struct {
 
 // extracts the json webtoken from the request
 //
-// @returns (userID, tokenID, error)
+// @returns (userName, tokenID, error)
 func extractJWT(c *fiber.Ctx) (string, string, error) {
 	// get the session-cookie
 	cookie := c.Cookies("session")
@@ -191,7 +192,7 @@ func extractJWT(c *fiber.Ctx) (string, string, error) {
 
 	// extract the claims from the JWT
 	if claims, ok := token.Claims.(*JWT); ok && token.Valid {
-		return claims.CustomClaims.UserID, claims.CustomClaims.TokenID, nil
+		return claims.CustomClaims.UserName, claims.CustomClaims.TokenID, nil
 	} else {
 		return "", "", fmt.Errorf("invalid JWT")
 	}