Skip to content

Commit 4c2c692

Browse files
aunefyrenaunefyren
authored
Giant overhaul (#56)
* This should be like 10 branches * Many stuffs * news posts redo Dependency updates
1 parent 52ad344 commit 4c2c692

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

50 files changed

+4908
-2627
lines changed

‎.vscode/settings.json

+2-1
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,6 @@
11
{
22
"cSpell.words": [
3-
"poenskelisten"
3+
"poenskelisten",
4+
"xhttp"
45
]
56
}

‎config/config.go

+6
Original file line numberDiff line numberDiff line change
@@ -50,6 +50,12 @@ func GetConfig() (*models.ConfigStruct, error) {
5050
anythingChanged = true
5151
}
5252

53+
if config.PoenskelistenEnvironment == "" {
54+
// Set new value
55+
config.PoenskelistenEnvironment = "production"
56+
anythingChanged = true
57+
}
58+
5359
if config.PoenskelistenPort == 0 {
5460
// Set new value
5561
config.PoenskelistenPort = 8080

‎controllers/group.go

+238-17
Original file line numberDiff line numberDiff line change
@@ -128,17 +128,64 @@ func RegisterGroup(context *gin.Context) {
128128
}
129129

130130
// Create group memberships for all members in the group_creation_request.Members slice
131-
for _, member := range groupCreationRequest.Members {
131+
for _, memberID := range groupCreationRequest.Members {
132132
// Create a new instance of the GroupMembership model
133133
var groupMembership models.GroupMembership
134134

135+
newMember, err := database.GetUserInformation(memberID)
136+
if err != nil {
137+
log.Println("Failed to get user. Error: " + err.Error())
138+
context.JSON(http.StatusBadRequest, gin.H{"error": "Failed to get user."})
139+
context.Abort()
140+
return
141+
}
142+
135143
// Set the member and group ID for the new group membership
136-
groupMembership.MemberID = member
144+
groupMembership.MemberID = newMember.ID
137145
groupMembership.GroupID = group.ID
138146
groupMembership.ID = uuid.New()
139147

140148
// Create the group membership in the database
141-
_ = database.Instance.Create(&groupMembership)
149+
_, err = database.CreateGroupMembershipInDB(groupMembership)
150+
if err != nil {
151+
log.Println("Failed to create group memberships. Error: " + err.Error())
152+
context.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to create group memberships."})
153+
context.Abort()
154+
return
155+
}
156+
}
157+
158+
for _, wishlistID := range groupCreationRequest.Wishlists {
159+
// Create a new instance of the GroupMembership model
160+
var wishlistMembership models.WishlistMembership
161+
162+
wishlist, err := database.GetWishlist(wishlistID)
163+
if err != nil {
164+
log.Println("Failed to get wishlist. Error: " + err.Error())
165+
context.JSON(http.StatusBadRequest, gin.H{"error": "Failed to get wishlist."})
166+
context.Abort()
167+
return
168+
}
169+
170+
if wishlist.OwnerID != userID {
171+
context.JSON(http.StatusUnauthorized, gin.H{"error": "Failed to add wishlist. You must own the wishlist."})
172+
context.Abort()
173+
return
174+
}
175+
176+
// Set the member and group ID for the new group membership
177+
wishlistMembership.GroupID = group.ID
178+
wishlistMembership.WishlistID = wishlistID
179+
wishlistMembership.ID = uuid.New()
180+
181+
// Create the group membership in the database
182+
_, err = database.CreateWishlistMembershipInDB(wishlistMembership)
183+
if err != nil {
184+
log.Println("Failed to create wishlist membership. Error: " + err.Error())
185+
context.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to create wishlist membership."})
186+
context.Abort()
187+
return
188+
}
142189
}
143190

144191
// Get a list of groups with the current user as the owner
@@ -207,25 +254,23 @@ func JoinGroup(context *gin.Context) {
207254
}
208255

209256
// Iterate over the members in the groupMembership.Members slice
210-
for _, member := range groupMembership.Members {
257+
for _, memberID := range groupMembership.Members {
211258
// Create a new instance of the GroupMembership model
212259
var groupMembershipDB models.GroupMembership
213260

214-
// Set the member ID for the new group membership
215-
groupMembershipDB.MemberID = member
216-
217-
// Verify that the user exists
218-
_, err := database.GetUserInformation(member)
261+
memberObject, err := database.GetUserInformation(memberID)
219262
if err != nil {
220-
// If the user does not exist, return a Bad Request response
221-
log.Println("Failed to load user from database. Error: " + err.Error())
222-
context.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to load user from database."})
263+
log.Println("Failed to find user. Error: " + err.Error())
264+
context.JSON(http.StatusBadRequest, gin.H{"error": "Failed to find user."})
223265
context.Abort()
224266
return
225267
}
226268

269+
// Set the member ID for the new group membership
270+
groupMembershipDB.MemberID = memberObject.ID
271+
227272
// Verify that the user is not already a member of the group
228-
membershipStatus, err := database.VerifyUserMembershipToGroup(member, groupIDInt)
273+
membershipStatus, err := database.VerifyUserMembershipToGroup(memberObject.ID, groupIDInt)
229274
if err != nil {
230275
// If there is an error verifying the user's membership, return a Bad Request response
231276
log.Println("Failed to verify membership to group. Error: " + err.Error())
@@ -288,7 +333,7 @@ func JoinGroup(context *gin.Context) {
288333
// It then deletes the group membership and gets an updated list of groups with the owner. It returns a success message and the updated list of groups.
289334
func RemoveFromGroup(context *gin.Context) {
290335
// Bind groupmembership request and get group ID from URL parameter
291-
var groupMembershipRequest models.GroupMembership
336+
var groupMembershipRequest models.GroupMembershipRemovalRequest
292337

293338
groupID := context.Param("group_id")
294339
if err := context.ShouldBindJSON(&groupMembershipRequest); err != nil {
@@ -319,7 +364,7 @@ func RemoveFromGroup(context *gin.Context) {
319364
membershipStatus, err := database.VerifyUserMembershipToGroup(groupMembershipRequest.MemberID, groupIDInt)
320365
if err != nil {
321366
log.Println("Failed to verify membership to group. Error: " + err.Error())
322-
context.JSON(http.StatusBadRequest, gin.H{"error": "Failed to verify membershop to group."})
367+
context.JSON(http.StatusBadRequest, gin.H{"error": "Failed to verify membership to group."})
323368
context.Abort()
324369
return
325370
} else if !membershipStatus {
@@ -330,15 +375,20 @@ func RemoveFromGroup(context *gin.Context) {
330375
}
331376

332377
// Verify group is owned by requester
333-
_, err = database.GetGroupUsingGroupIDAndUserIDAsOwner(groupMembershipRequest.GroupID, userID)
378+
group, err := database.GetGroupInformation(groupIDInt)
334379
if err != nil {
335380
// Return error if user is not owner of group
381+
log.Println("Failed to get group object. Error: " + err.Error())
382+
context.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to get group object."})
383+
context.Abort()
384+
return
385+
} else if group.OwnerID != userID {
336386
context.JSON(http.StatusBadRequest, gin.H{"error": "Only owners can edit their group memberships."})
337387
context.Abort()
338388
return
339389
}
340390

341-
if userID == groupMembershipRequest.MemberID {
391+
if group.OwnerID == groupMembershipRequest.MemberID {
342392
// Return error if user is owner and trying to remove themselves
343393
context.JSON(http.StatusBadRequest, gin.H{"error": "Owner cannot be removed as member."})
344394
context.Abort()
@@ -561,6 +611,69 @@ func GetGroups(context *gin.Context) {
561611
return
562612
}
563613

614+
ownedString, ownedOkay := context.GetQuery("owned")
615+
if ownedOkay {
616+
if ownedString == "true" {
617+
newGroupList := []models.GroupUser{}
618+
for _, group := range groupsWithOwner {
619+
if group.Owner.ID == userID {
620+
newGroupList = append(newGroupList, group)
621+
}
622+
}
623+
groupsWithOwner = newGroupList
624+
}
625+
}
626+
627+
memberOfWishlistString, memberOfWishlistOkay := context.GetQuery("memberOfWishlistID")
628+
if memberOfWishlistOkay {
629+
memberOfWishlist, err := uuid.Parse(memberOfWishlistString)
630+
if err != nil {
631+
log.Println("Failed to parse wishlist ID. Error: " + err.Error())
632+
context.JSON(http.StatusBadRequest, gin.H{"error": "Failed to parse wishlist ID."})
633+
context.Abort()
634+
return
635+
}
636+
637+
newGroupList := []models.GroupUser{}
638+
for _, group := range groupsWithOwner {
639+
membership, err := database.VerifyGroupMembershipToWishlist(memberOfWishlist, group.ID)
640+
if err != nil {
641+
log.Println("Failed to validate group membership. Error: " + err.Error())
642+
context.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to validate group membership."})
643+
context.Abort()
644+
return
645+
} else if membership {
646+
newGroupList = append(newGroupList, group)
647+
}
648+
}
649+
groupsWithOwner = newGroupList
650+
}
651+
652+
notAMemberOfWishlistString, notAMemberOfWishlistOkay := context.GetQuery("notAMemberOfWishlistID")
653+
if notAMemberOfWishlistOkay {
654+
notAMemberOfWishlistID, err := uuid.Parse(notAMemberOfWishlistString)
655+
if err != nil {
656+
log.Println("Failed to parse wishlist ID. Error: " + err.Error())
657+
context.JSON(http.StatusBadRequest, gin.H{"error": "Failed to parse wishlist ID."})
658+
context.Abort()
659+
return
660+
}
661+
662+
newGroupList := []models.GroupUser{}
663+
for _, group := range groupsWithOwner {
664+
membership, err := database.VerifyGroupMembershipToWishlist(notAMemberOfWishlistID, group.ID)
665+
if err != nil {
666+
log.Println("Failed to validate group membership. Error: " + err.Error())
667+
context.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to validate group membership."})
668+
context.Abort()
669+
return
670+
} else if !membership {
671+
newGroupList = append(newGroupList, group)
672+
}
673+
}
674+
groupsWithOwner = newGroupList
675+
}
676+
564677
// Sort groups by creation date
565678
sort.Slice(groupsWithOwner, func(i, j int) bool {
566679
return groupsWithOwner[i].CreatedAt.Before(groupsWithOwner[j].CreatedAt)
@@ -942,3 +1055,111 @@ func ConvertGroupsToGroupObjects(groups []models.Group) (groupObjects []models.G
9421055

9431056
return
9441057
}
1058+
1059+
func APIAddWishlistsToGroup(context *gin.Context) {
1060+
// Create a new instance of model
1061+
var wishlistsRequest models.GroupAddWishlistsRequest
1062+
var groupIDString = context.Param("group_id")
1063+
1064+
if err := context.ShouldBindJSON(&wishlistsRequest); err != nil {
1065+
// If there is an error binding the request, return a Bad Request response
1066+
log.Println("Failed to parse request. Error: " + err.Error())
1067+
context.JSON(http.StatusBadRequest, gin.H{"error": "Failed to parse request."})
1068+
context.Abort()
1069+
return
1070+
}
1071+
1072+
if len(wishlistsRequest.Wishlists) < 1 {
1073+
context.JSON(http.StatusBadRequest, gin.H{"error": "You must provide one or more wishlists."})
1074+
context.Abort()
1075+
return
1076+
}
1077+
1078+
// Get the user ID from the Authorization header of the request
1079+
userID, err := middlewares.GetAuthUsername(context.GetHeader("Authorization"))
1080+
if err != nil {
1081+
log.Println("Failed to parse header. Error: " + err.Error())
1082+
context.JSON(http.StatusBadRequest, gin.H{"error": "Failed to parse header."})
1083+
context.Abort()
1084+
return
1085+
}
1086+
1087+
// Parse the group ID from string to int
1088+
groupID, err := uuid.Parse(groupIDString)
1089+
if err != nil {
1090+
// If there is an error parsing the group ID, return a Bad Request response
1091+
log.Println("Failed to parse group ID. Error: " + err.Error())
1092+
context.JSON(http.StatusBadRequest, gin.H{"error": "Failed to parse group ID."})
1093+
context.Abort()
1094+
return
1095+
}
1096+
1097+
for _, wishlistID := range wishlistsRequest.Wishlists {
1098+
var wishlistMembership models.WishlistMembership
1099+
1100+
wishlist, err := database.GetWishlist(wishlistID)
1101+
if err != nil {
1102+
log.Println("Failed to find wishlist. Error: " + err.Error())
1103+
context.JSON(http.StatusBadRequest, gin.H{"error": "Failed to find wishlist."})
1104+
context.Abort()
1105+
return
1106+
} else if wishlist.OwnerID != userID {
1107+
context.JSON(http.StatusUnauthorized, gin.H{"error": "You can only add wishlists you own."})
1108+
context.Abort()
1109+
return
1110+
}
1111+
1112+
wishlistMembership.WishlistID = wishlistID
1113+
1114+
membershipStatus, err := database.VerifyGroupMembershipToWishlist(wishlistID, groupID)
1115+
if err != nil {
1116+
log.Println("Failed to verify membership to group. Error: " + err.Error())
1117+
context.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to verify membership to group."})
1118+
context.Abort()
1119+
return
1120+
} else if membershipStatus {
1121+
context.JSON(http.StatusBadRequest, gin.H{"error": "Group membership already exists for wishlist."})
1122+
context.Abort()
1123+
return
1124+
}
1125+
1126+
membershipStatus, err = database.VerifyUserMembershipToGroup(userID, groupID)
1127+
if err != nil {
1128+
log.Println("Failed to verify membership to group. Error: " + err.Error())
1129+
context.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to verify membership to group."})
1130+
context.Abort()
1131+
return
1132+
} else if !membershipStatus {
1133+
context.JSON(http.StatusBadRequest, gin.H{"error": "You must be a member of the group."})
1134+
context.Abort()
1135+
return
1136+
}
1137+
1138+
wishlistMembership.GroupID = groupID
1139+
wishlistMembership.ID = uuid.New()
1140+
1141+
_, err = database.CreateWishlistMembershipInDB(wishlistMembership)
1142+
if err != nil {
1143+
log.Println("Failed to create group membership for wishlist in database. Error: " + err.Error())
1144+
context.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to create group membership for wishlist in database."})
1145+
context.Abort()
1146+
return
1147+
}
1148+
}
1149+
1150+
groupsWithOwner, err := GetGroupObjects(userID)
1151+
if err != nil {
1152+
log.Println("Failed to get groups for user. Error: " + err.Error())
1153+
context.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to get groups for user."})
1154+
context.Abort()
1155+
return
1156+
}
1157+
1158+
// Sort groups by creation date
1159+
sort.Slice(groupsWithOwner, func(i, j int) bool {
1160+
return groupsWithOwner[j].CreatedAt.Before(groupsWithOwner[i].CreatedAt)
1161+
})
1162+
1163+
// Return a Created response with a message indicating that the group member(s) joined successfully, and the updated list of groups
1164+
context.JSON(http.StatusCreated, gin.H{"message": "Wishlists added to group.", "groups": groupsWithOwner})
1165+
}

‎controllers/image.go

+7-3
Original file line numberDiff line numberDiff line change
@@ -320,9 +320,13 @@ func APIGetWishImage(context *gin.Context) {
320320
}
321321

322322
// Check if user exists
323-
wishFound, _, err := database.GetWishByWishID(wishID)
324-
if err != nil || !wishFound {
325-
log.Println("Failed to find wish. Error: " + err.Error())
323+
wish, err := database.GetWishByWishID(wishID)
324+
if err != nil {
325+
log.Println("Failed to get wish. Error: " + err.Error())
326+
context.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to get wish."})
327+
context.Abort()
328+
return
329+
} else if wish == nil {
326330
context.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to find wish."})
327331
context.Abort()
328332
return

‎controllers/invite.go

+5
Original file line numberDiff line numberDiff line change
@@ -3,6 +3,7 @@ package controllers
33
import (
44
"aunefyren/poenskelisten/database"
55
"aunefyren/poenskelisten/models"
6+
"errors"
67
"log"
78
"net/http"
89
"sort"
@@ -140,6 +141,10 @@ func ConvertInviteToInviteObject(invite models.Invite) (models.InviteObject, err
140141
return models.InviteObject{}, err
141142
}
142143
inviteObject.User = user
144+
145+
if user.Enabled == nil || *user.Enabled == false {
146+
return models.InviteObject{}, errors.New("User is deleted.")
147+
}
143148
}
144149

145150
inviteObject.ID = invite.ID

0 commit comments

Comments
 (0)