Teajey
/
lishwist
1
0
Fork 0
Code Issues 10 Pull Requests Projects Releases Wiki Activity

Rename internal rsvp package 

To prevent conflicts when github.com/Teajey/rsvp moves in
This commit is contained in:
Teajey 2025-08-19 16:43:28 +09:00
parent 0603386f4c
commit d33c02a5ac
Signed by: Teajey
GPG Key ID: 970E790FE834A713
16 changed files with 121 additions and 118 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
http/rsvp/handler.go → http/response/handler.go
View File

@ -1,4 +1,4 @@
package rsvp package response
import ( import (
"log" "log"
@ -45,7 +45,7 @@ func (m *ServeMux) HandleFunc(pattern string, handler HandlerFunc) {
} }
err = response.Write(w, stdReq) err = response.Write(w, stdReq)
if err != nil { if err != nil {
log.Printf("Failed to write rsvp.Response to bytes: %s\n", err) log.Printf("Failed to write response.Response to bytes: %s\n", err)
http.Error(w, "Failed to write response", http.StatusInternalServerError) http.Error(w, "Failed to write response", http.StatusInternalServerError)
} }
}) })

2
http/rsvp/request.go → http/response/request.go
View File

@ -1,4 +1,4 @@
package rsvp package response
import ( import (
"log" "log"

4
http/rsvp/response.go → http/response/response.go
View File

@ -1,4 +1,4 @@
package rsvp package response
import ( import (
"bytes" "bytes"
@ -79,7 +79,7 @@ func (res *Response) Write(w http.ResponseWriter, r *http.Request) error {
_, err := w.Write(bodyBytes.Bytes()) _, err := w.Write(bodyBytes.Bytes())
if err != nil { if err != nil {
log.Printf("Failed to write rsvp.Response to HTTP: %s\n", err) log.Printf("Failed to write response.Response to HTTP: %s\n", err)
} }
return nil return nil
} }

2
http/rsvp/session.go → http/response/session.go
View File

@ -1,4 +1,4 @@
package rsvp package response
import ( import (
"github.com/gorilla/sessions" "github.com/gorilla/sessions"

10
http/router/router.go
View File

@ -1,7 +1,7 @@
package router package router
import ( import (
"lishwist/http/rsvp" "lishwist/http/response"
"net/http" "net/http"
"github.com/Teajey/sqlstore" "github.com/Teajey/sqlstore"
@ -9,8 +9,8 @@ import (
type VisibilityRouter struct { type VisibilityRouter struct {
Store *sqlstore.Store Store *sqlstore.Store
Public *rsvp.ServeMux Public *response.ServeMux
Private *rsvp.ServeMux Private *response.ServeMux
} }
func (s *VisibilityRouter) ServeHTTP(w http.ResponseWriter, r *http.Request) { func (s *VisibilityRouter) ServeHTTP(w http.ResponseWriter, r *http.Request) {
@ -27,7 +27,7 @@ func (s *VisibilityRouter) ServeHTTP(w http.ResponseWriter, r *http.Request) {
func New(store *sqlstore.Store) *VisibilityRouter { func New(store *sqlstore.Store) *VisibilityRouter {
return &VisibilityRouter{ return &VisibilityRouter{
Store: store, Store: store,
Public: rsvp.NewServeMux(store), Public: response.NewServeMux(store),
Private: rsvp.NewServeMux(store), Private: response.NewServeMux(store),
} }
} }

14
http/routing/context.go
View File

@ -1,22 +1,24 @@
package routing package routing
import ( import (
lishwist "lishwist/core"
"lishwist/http/rsvp"
"net/http" "net/http"
lishwist "lishwist/core"
"lishwist/http/response"
) )
func ExpectAppSession(next func(*lishwist.Session, http.Header, *rsvp.Request) rsvp.Response) rsvp.HandlerFunc { func ExpectAppSession(next func(*lishwist.Session, http.Header, *response.Request) response.Response) response.HandlerFunc {
return func(w http.Header, r *rsvp.Request) rsvp.Response { return func(w http.Header, r *response.Request) response.Response {
session := r.GetSession() session := r.GetSession()
username, ok := session.GetValue("username").(string) username, ok := session.GetValue("username").(string)
if !ok { if !ok {
return rsvp.Error(http.StatusInternalServerError, "Something went wrong.").Log("Failed to get username from session") return response.Error(http.StatusInternalServerError, "Something went wrong.").Log("Failed to get username from session")
} }
appSession, err := lishwist.SessionFromUsername(username) appSession, err := lishwist.SessionFromUsername(username)
if err != nil { if err != nil {
return rsvp.Error(http.StatusInternalServerError, "Something went wrong.").Log("Failed to get session by username %q: %s", username, err) return response.Error(http.StatusInternalServerError, "Something went wrong.").Log("Failed to get session by username %q: %s", username, err)
} }
return next(appSession, w, r) return next(appSession, w, r)

24
http/routing/foreign_wishlist.go
View File

@ -2,7 +2,7 @@ package routing
import ( import (
lishwist "lishwist/core" lishwist "lishwist/core"
"lishwist/http/rsvp" "lishwist/http/response"
"net/http" "net/http"
) )
@ -13,24 +13,24 @@ type foreignWishlistProps struct {
Gifts []lishwist.Wish Gifts []lishwist.Wish
} }
func ForeignWishlist(app *lishwist.Session, h http.Header, r *rsvp.Request) rsvp.Response { func ForeignWishlist(app *lishwist.Session, h http.Header, r *response.Request) response.Response {
userReference := r.PathValue("userReference") userReference := r.PathValue("userReference")
if app.User.Reference == userReference { if app.User.Reference == userReference {
return rsvp.SeeOther("/") return response.SeeOther("/")
} }
otherUser, err := lishwist.GetUserByReference(userReference) otherUser, err := lishwist.GetUserByReference(userReference)
if err != nil { if err != nil {
return rsvp.Error(http.StatusInternalServerError, "An error occurred while fetching this user :(").Log("Couldn't get user by reference %q: %s", userReference, err) return response.Error(http.StatusInternalServerError, "An error occurred while fetching this user :(").Log("Couldn't get user by reference %q: %s", userReference, err)
} }
if otherUser == nil { if otherUser == nil {
return rsvp.Error(http.StatusInternalServerError, "User not found") return response.Error(http.StatusInternalServerError, "User not found")
} }
wishes, err := app.GetOthersWishes(userReference) wishes, err := app.GetOthersWishes(userReference)
if err != nil { if err != nil {
return rsvp.Error(http.StatusInternalServerError, "An error occurred while fetching this user :(").Log("%q couldn't get wishes of other user %q: %s", app.User.Name, otherUser.Name, err) return response.Error(http.StatusInternalServerError, "An error occurred while fetching this user :(").Log("%q couldn't get wishes of other user %q: %s", app.User.Name, otherUser.Name, err)
} }
p := foreignWishlistProps{CurrentUserId: app.User.Id, CurrentUserName: app.User.Name, Username: otherUser.Name, Gifts: wishes} p := foreignWishlistProps{CurrentUserId: app.User.Id, CurrentUserName: app.User.Name, Username: otherUser.Name, Gifts: wishes}
return rsvp.Data("foreign_wishlist.gotmpl", p) return response.Data("foreign_wishlist.gotmpl", p)
} }
type publicWishlistProps struct { type publicWishlistProps struct {
@ -38,19 +38,19 @@ type publicWishlistProps struct {
GiftCount int GiftCount int
} }
func PublicWishlist(h http.Header, r *rsvp.Request) rsvp.Response { func PublicWishlist(h http.Header, r *response.Request) response.Response {
userReference := r.PathValue("userReference") userReference := r.PathValue("userReference")
otherUser, err := lishwist.GetUserByReference(userReference) otherUser, err := lishwist.GetUserByReference(userReference)
if err != nil { if err != nil {
return rsvp.Error(http.StatusInternalServerError, "An error occurred while fetching this user :(").Log("Couldn't get user by reference %q on public wishlist: %s", userReference, err) return response.Error(http.StatusInternalServerError, "An error occurred while fetching this user :(").Log("Couldn't get user by reference %q on public wishlist: %s", userReference, err)
} }
if otherUser == nil { if otherUser == nil {
return rsvp.Error(http.StatusInternalServerError, "User not found") return response.Error(http.StatusInternalServerError, "User not found")
} }
giftCount, err := otherUser.WishCount() giftCount, err := otherUser.WishCount()
if err != nil { if err != nil {
return rsvp.Error(http.StatusInternalServerError, "An error occurred while fetching this user :(").Log("Couldn't get wishes of user %q on public wishlist: %s", otherUser.Name, err) return response.Error(http.StatusInternalServerError, "An error occurred while fetching this user :(").Log("Couldn't get wishes of user %q on public wishlist: %s", otherUser.Name, err)
} }
p := publicWishlistProps{Username: otherUser.Name, GiftCount: giftCount} p := publicWishlistProps{Username: otherUser.Name, GiftCount: giftCount}
return rsvp.Data("public_foreign_wishlist.gotmpl", p) return response.Data("public_foreign_wishlist.gotmpl", p)
} }

50
http/routing/groups.go
View File

@ -5,7 +5,7 @@ import (
"slices" "slices"
lishwist "lishwist/core" lishwist "lishwist/core"
"lishwist/http/rsvp" "lishwist/http/response"
) )
type GroupProps struct { type GroupProps struct {
@ -13,14 +13,14 @@ type GroupProps struct {
CurrentUsername string CurrentUsername string
} }
func AdminGroup(app *lishwist.Session, h http.Header, r *rsvp.Request) rsvp.Response { func AdminGroup(app *lishwist.Session, h http.Header, r *response.Request) response.Response {
reference := r.PathValue("groupReference") reference := r.PathValue("groupReference")
group, err := app.GetGroupByReference(reference) group, err := app.GetGroupByReference(reference)
if err != nil { if err != nil {
return rsvp.Error(http.StatusInternalServerError, "Couldn't get group: %s", err) return response.Error(http.StatusInternalServerError, "Couldn't get group: %s", err)
} }
if group == nil { if group == nil {
return rsvp.Error(http.StatusNotFound, "Group not found") return response.Error(http.StatusNotFound, "Group not found")
} }
if !app.User.IsAdmin { if !app.User.IsAdmin {
index := group.MemberIndex(app.User.Id) index := group.MemberIndex(app.User.Id)
@ -30,20 +30,20 @@ func AdminGroup(app *lishwist.Session, h http.Header, r *rsvp.Request) rsvp.Resp
Group: group, Group: group,
CurrentUsername: app.User.Name, CurrentUsername: app.User.Name,
} }
return rsvp.Data("group_page.gotmpl", p) return response.Data("group_page.gotmpl", p)
} }
func Group(app *lishwist.Session, h http.Header, r *rsvp.Request) rsvp.Response { func Group(app *lishwist.Session, h http.Header, r *response.Request) response.Response {
if app.User.IsAdmin { if app.User.IsAdmin {
return AdminGroup(app, h, r) return AdminGroup(app, h, r)
} }
groupReference := r.PathValue("groupReference") groupReference := r.PathValue("groupReference")
group, err := app.GetGroupByReference(groupReference) group, err := app.GetGroupByReference(groupReference)
if err != nil { if err != nil {
return rsvp.Error(http.StatusInternalServerError, "An error occurred while fetching this group :(").Log("Couldn't get group: %s", err) return response.Error(http.StatusInternalServerError, "An error occurred while fetching this group :(").Log("Couldn't get group: %s", err)
} }
if group == nil { if group == nil {
return rsvp.Error(http.StatusNotFound, "Group not found. (It might be because you're not a member)") return response.Error(http.StatusNotFound, "Group not found. (It might be because you're not a member)")
} }
index := group.MemberIndex(app.User.Id) index := group.MemberIndex(app.User.Id)
group.Members = slices.Delete(group.Members, index, index+1) group.Members = slices.Delete(group.Members, index, index+1)
@ -51,22 +51,22 @@ func Group(app *lishwist.Session, h http.Header, r *rsvp.Request) rsvp.Response
Group: group, Group: group,
CurrentUsername: app.User.Name, CurrentUsername: app.User.Name,
} }
return rsvp.Data("group_page.gotmpl", p) return response.Data("group_page.gotmpl", p)
} }
func PublicGroup(h http.Header, r *rsvp.Request) rsvp.Response { func PublicGroup(h http.Header, r *response.Request) response.Response {
groupReference := r.PathValue("groupReference") groupReference := r.PathValue("groupReference")
group, err := lishwist.GetGroupByReference(groupReference) group, err := lishwist.GetGroupByReference(groupReference)
if err != nil { if err != nil {
return rsvp.Error(http.StatusInternalServerError, "An error occurred while fetching this group :(").Log("Couldn't get group: %s", err) return response.Error(http.StatusInternalServerError, "An error occurred while fetching this group :(").Log("Couldn't get group: %s", err)
} }
p := GroupProps{ p := GroupProps{
Group: group, Group: group,
} }
return rsvp.Data("public_group_page.gotmpl", p) return response.Data("public_group_page.gotmpl", p)
} }
func GroupPost(app *lishwist.Session, h http.Header, r *rsvp.Request) rsvp.Response { func GroupPost(app *lishwist.Session, h http.Header, r *response.Request) response.Response {
admin := app.Admin() admin := app.Admin()
if admin == nil { if admin == nil {
return NotFound(h, r) return NotFound(h, r)
@ -83,27 +83,27 @@ func GroupPost(app *lishwist.Session, h http.Header, r *rsvp.Request) rsvp.Respo
if name != "" { if name != "" {
createdGroup, err := admin.CreateGroup(name, reference) createdGroup, err := admin.CreateGroup(name, reference)
if err != nil { if err != nil {
return rsvp.Error(http.StatusInternalServerError, "Failed to create group: %s", err) return response.Error(http.StatusInternalServerError, "Failed to create group: %s", err)
} }
group = createdGroup group = createdGroup
} else { } else {
existingGroup, err := lishwist.GetGroupByReference(reference) existingGroup, err := lishwist.GetGroupByReference(reference)
if err != nil { if err != nil {
return rsvp.Error(http.StatusInternalServerError, "Failed to get group: %s", err) return response.Error(http.StatusInternalServerError, "Failed to get group: %s", err)
} }
if existingGroup == nil { if existingGroup == nil {
return rsvp.Error(http.StatusNotFound, "Group not found", err) return response.Error(http.StatusNotFound, "Group not found", err)
} }
group = existingGroup group = existingGroup
for _, userId := range removeUsers { for _, userId := range removeUsers {
index := group.MemberIndex(userId) index := group.MemberIndex(userId)
if index == -1 { if index == -1 {
return rsvp.Error(http.StatusBadRequest, "Group %q does not contain a user with id %s", reference, userId) return response.Error(http.StatusBadRequest, "Group %q does not contain a user with id %s", reference, userId)
} }
err = admin.RemoveUserFromGroup(userId, group.Id) err = admin.RemoveUserFromGroup(userId, group.Id)
if err != nil { if err != nil {
return rsvp.Error(http.StatusInternalServerError, "On group %q failed to remove user with id %s: %s", reference, userId, err) return response.Error(http.StatusInternalServerError, "On group %q failed to remove user with id %s: %s", reference, userId, err)
} }
group.Members = slices.Delete(group.Members, index, index+1) group.Members = slices.Delete(group.Members, index, index+1)
} }
@ -112,22 +112,22 @@ func GroupPost(app *lishwist.Session, h http.Header, r *rsvp.Request) rsvp.Respo
for _, userId := range addUsers { for _, userId := range addUsers {
user, err := admin.GetUser(userId) user, err := admin.GetUser(userId)
if err != nil { if err != nil {
return rsvp.Error(http.StatusInternalServerError, "Groups exists, but a user with id %s could not be fetched: %s", userId, err) return response.Error(http.StatusInternalServerError, "Groups exists, but a user with id %s could not be fetched: %s", userId, err)
} }
if user == nil { if user == nil {
return rsvp.Error(http.StatusInternalServerError, "Groups exists, but a user with id %s does not exist", userId) return response.Error(http.StatusInternalServerError, "Groups exists, but a user with id %s does not exist", userId)
} }
err = admin.AddUserToGroup(user.Id, group.Id) err = admin.AddUserToGroup(user.Id, group.Id)
if err != nil { if err != nil {
return rsvp.Error(http.StatusInternalServerError, "Groups exists, but failed to add user with id %s: %s", userId, err) return response.Error(http.StatusInternalServerError, "Groups exists, but failed to add user with id %s: %s", userId, err)
} }
group.Members = append(group.Members, *user) group.Members = append(group.Members, *user)
} }
return rsvp.Data("", group) return response.Data("", group)
} }
func Groups(app *lishwist.Session, h http.Header, r *rsvp.Request) rsvp.Response { func Groups(app *lishwist.Session, h http.Header, r *response.Request) response.Response {
admin := app.Admin() admin := app.Admin()
if admin == nil { if admin == nil {
return NotFound(h, r) return NotFound(h, r)
@ -135,8 +135,8 @@ func Groups(app *lishwist.Session, h http.Header, r *rsvp.Request) rsvp.Response
groups, err := admin.ListGroups() groups, err := admin.ListGroups()
if err != nil { if err != nil {
return rsvp.Error(http.StatusInternalServerError, "Failed to get groups: %s", err) return response.Error(http.StatusInternalServerError, "Failed to get groups: %s", err)
} }
return rsvp.Data("", groups) return response.Data("", groups)
} }

14
http/routing/home.go
View File

@ -5,7 +5,7 @@ import (
lishwist "lishwist/core" lishwist "lishwist/core"
"lishwist/http/env" "lishwist/http/env"
"lishwist/http/rsvp" "lishwist/http/response"
) )
type HomeProps struct { type HomeProps struct {
@ -17,24 +17,24 @@ type HomeProps struct {
Groups []lishwist.Group Groups []lishwist.Group
} }
func Home(app *lishwist.Session, h http.Header, r *rsvp.Request) rsvp.Response { func Home(app *lishwist.Session, h http.Header, r *response.Request) response.Response {
gifts, err := app.GetWishes() gifts, err := app.GetWishes()
if err != nil { if err != nil {
return rsvp.Error(http.StatusInternalServerError, "An error occurred while fetching your wishlist :(").Log("Failed to get gifts: %s", err) return response.Error(http.StatusInternalServerError, "An error occurred while fetching your wishlist :(").Log("Failed to get gifts: %s", err)
} }
todo, err := app.GetTodo() todo, err := app.GetTodo()
if err != nil { if err != nil {
return rsvp.Error(http.StatusInternalServerError, "An error occurred while fetching your wishlist :(").Log("Failed to get todo: %s", err) return response.Error(http.StatusInternalServerError, "An error occurred while fetching your wishlist :(").Log("Failed to get todo: %s", err)
} }
groups, err := app.GetGroups() groups, err := app.GetGroups()
if err != nil { if err != nil {
return rsvp.Error(http.StatusInternalServerError, "An error occurred while fetching your wishlist :(").Log("Failed to get groups: %s", err) return response.Error(http.StatusInternalServerError, "An error occurred while fetching your wishlist :(").Log("Failed to get groups: %s", err)
} }
p := HomeProps{Username: app.User.Name, Gifts: gifts, Todo: todo, Reference: app.User.Reference, HostUrl: env.HostUrl.String(), Groups: groups} p := HomeProps{Username: app.User.Name, Gifts: gifts, Todo: todo, Reference: app.User.Reference, HostUrl: env.HostUrl.String(), Groups: groups}
return rsvp.Data("home.gotmpl", p) return response.Data("home.gotmpl", p)
} }
func HomePost(app *lishwist.Session, h http.Header, r *rsvp.Request) rsvp.Response { func HomePost(app *lishwist.Session, h http.Header, r *response.Request) response.Response {
form := r.ParseForm() form := r.ParseForm()
switch form.Get("intent") { switch form.Get("intent") {
case "add_idea": case "add_idea":

19
http/routing/login.go
View File

@ -1,13 +1,14 @@
package routing package routing
import ( import (
"net/http"
lishwist "lishwist/core" lishwist "lishwist/core"
"lishwist/http/api" "lishwist/http/api"
"lishwist/http/rsvp" "lishwist/http/response"
"net/http"
) )
func Login(h http.Header, r *rsvp.Request) rsvp.Response { func Login(h http.Header, r *response.Request) response.Response {
session := r.GetSession() session := r.GetSession()
props := api.NewLoginProps("", "") props := api.NewLoginProps("", "")
@ -28,10 +29,10 @@ func Login(h http.Header, r *rsvp.Request) rsvp.Response {
props.SuccessfulRegistration = true props.SuccessfulRegistration = true
} }
return rsvp.Data("login.gotmpl", props).SaveSession(session) return response.Data("login.gotmpl", props).SaveSession(session)
} }
func LoginPost(h http.Header, r *rsvp.Request) rsvp.Response { func LoginPost(h http.Header, r *response.Request) response.Response {
form := r.ParseForm() form := r.ParseForm()
session := r.GetSession() session := r.GetSession()
@ -44,7 +45,7 @@ func LoginPost(h http.Header, r *rsvp.Request) rsvp.Response {
props.Password.Value = "" props.Password.Value = ""
if !valid { if !valid {
session.FlashSet(&props) session.FlashSet(&props)
return rsvp.SeeOther("/").SaveSession(session).Log("Invalid props: %#v\n", props) return response.SeeOther("/").SaveSession(session).Log("Invalid props: %#v\n", props)
} }
app, err := lishwist.Login(username, password) app, err := lishwist.Login(username, password)
@ -53,11 +54,11 @@ func LoginPost(h http.Header, r *rsvp.Request) rsvp.Response {
case lishwist.ErrorInvalidCredentials: case lishwist.ErrorInvalidCredentials:
props.GeneralError = "Username or password invalid" props.GeneralError = "Username or password invalid"
session.FlashSet(&props) session.FlashSet(&props)
return rsvp.SeeOther("/").SaveSession(session).Log("Invalid credentials: %s: %#v\n", err, props) return response.SeeOther("/").SaveSession(session).Log("Invalid credentials: %s: %#v\n", err, props)
default: default:
props.GeneralError = "Something went wrong." props.GeneralError = "Something went wrong."
session.FlashSet(&props) session.FlashSet(&props)
return rsvp.SeeOther("/").SaveSession(session).Log("Login error: %s\n", err) return response.SeeOther("/").SaveSession(session).Log("Login error: %s\n", err)
} }
} }
@ -65,5 +66,5 @@ func LoginPost(h http.Header, r *rsvp.Request) rsvp.Response {
session.SetValue("authorized", true) session.SetValue("authorized", true)
session.SetValue("username", app.User.Name) session.SetValue("username", app.User.Name)
return rsvp.SeeOther(r.URL().Path).SaveSession(session) return response.SeeOther(r.URL().Path).SaveSession(session)
} }

6
http/routing/logout.go
View File

@ -1,15 +1,15 @@
package routing package routing
import ( import (
"lishwist/http/rsvp" "lishwist/http/response"
"net/http" "net/http"
) )
func LogoutPost(h http.Header, r *rsvp.Request) rsvp.Response { func LogoutPost(h http.Header, r *response.Request) response.Response {
session := r.GetSession() session := r.GetSession()
session.Options().MaxAge = 0 session.Options().MaxAge = 0
session.ClearValues() session.ClearValues()
return rsvp.SeeOther("/").SaveSession(session) return response.SeeOther("/").SaveSession(session)
} }

6
http/routing/not_found.go
View File

@ -3,9 +3,9 @@ package routing
import ( import (
"net/http" "net/http"
"lishwist/http/rsvp" "lishwist/http/response"
) )
func NotFound(h http.Header, r *rsvp.Request) rsvp.Response { func NotFound(h http.Header, r *response.Request) response.Response {
return rsvp.Error(http.StatusNotFound, "Page not found") return response.Error(http.StatusNotFound, "Page not found")
} }

14
http/routing/register.go
View File

@ -4,11 +4,11 @@ import (
"errors" "errors"
lishwist "lishwist/core" lishwist "lishwist/core"
"lishwist/http/api" "lishwist/http/api"
"lishwist/http/rsvp" "lishwist/http/response"
"net/http" "net/http"
) )
func Register(h http.Header, r *rsvp.Request) rsvp.Response { func Register(h http.Header, r *response.Request) response.Response {
props := api.NewRegisterProps("", "", "") props := api.NewRegisterProps("", "", "")
session := r.GetSession() session := r.GetSession()
@ -23,10 +23,10 @@ func Register(h http.Header, r *rsvp.Request) rsvp.Response {
props.ConfirmPassword.Error = flashProps.ConfirmPassword.Error props.ConfirmPassword.Error = flashProps.ConfirmPassword.Error
} }
return rsvp.Data("register.gotmpl", props).SaveSession(session) return response.Data("register.gotmpl", props).SaveSession(session)
} }
func RegisterPost(h http.Header, r *rsvp.Request) rsvp.Response { func RegisterPost(h http.Header, r *response.Request) response.Response {
form := r.ParseForm() form := r.ParseForm()
s := r.GetSession() s := r.GetSession()
@ -41,7 +41,7 @@ func RegisterPost(h http.Header, r *rsvp.Request) rsvp.Response {
props.ConfirmPassword.Value = "" props.ConfirmPassword.Value = ""
if !valid { if !valid {
s.FlashSet(&props) s.FlashSet(&props)
return rsvp.SeeOther("/").SaveSession(s).Log("Invalid props: %#v\n", props) return response.SeeOther("/").SaveSession(s).Log("Invalid props: %#v\n", props)
} }
_, err := lishwist.Register(username, newPassword) _, err := lishwist.Register(username, newPassword)
@ -52,9 +52,9 @@ func RegisterPost(h http.Header, r *rsvp.Request) rsvp.Response {
props.GeneralError = "Something went wrong." props.GeneralError = "Something went wrong."
} }
s.FlashSet(&props) s.FlashSet(&props)
return rsvp.SeeOther("/register").SaveSession(s).Log("Registration failed: %s\n", err) return response.SeeOther("/register").SaveSession(s).Log("Registration failed: %s\n", err)
} }
s.FlashSet(true) s.FlashSet(true)
return rsvp.SeeOther("/").SaveSession(s) return response.SeeOther("/").SaveSession(s)
} }

12
http/routing/todo.go
View File

@ -2,11 +2,11 @@ package routing
import ( import (
lishwist "lishwist/core" lishwist "lishwist/core"
"lishwist/http/rsvp" "lishwist/http/response"
"net/http" "net/http"
) )
func TodoUpdate(app *lishwist.Session, h http.Header, r *rsvp.Request) rsvp.Response { func TodoUpdate(app *lishwist.Session, h http.Header, r *response.Request) response.Response {
form := r.ParseForm() form := r.ParseForm()
switch form.Get("intent") { switch form.Get("intent") {
@ -14,16 +14,16 @@ func TodoUpdate(app *lishwist.Session, h http.Header, r *rsvp.Request) rsvp.Resp
unclaims := form["gift"] unclaims := form["gift"]
err := app.ClaimWishes([]string{}, unclaims) err := app.ClaimWishes([]string{}, unclaims)
if err != nil { if err != nil {
return rsvp.Error(http.StatusInternalServerError, "Failed to update claim...").LogError(err) return response.Error(http.StatusInternalServerError, "Failed to update claim...").LogError(err)
} }
case "complete_todo": case "complete_todo":
claims := form["gift"] claims := form["gift"]
err := app.CompleteWishes(claims) err := app.CompleteWishes(claims)
if err != nil { if err != nil {
return rsvp.Error(http.StatusInternalServerError, "Failed to complete gifts...").LogError(err) return response.Error(http.StatusInternalServerError, "Failed to complete gifts...").LogError(err)
} }
default: default:
return rsvp.Error(http.StatusBadRequest, "Invalid intent") return response.Error(http.StatusBadRequest, "Invalid intent")
} }
return rsvp.SeeOther("/") return response.SeeOther("/")
} }

28
http/routing/users.go
View File

@ -2,11 +2,11 @@ package routing
import ( import (
lishwist "lishwist/core" lishwist "lishwist/core"
"lishwist/http/rsvp" "lishwist/http/response"
"net/http" "net/http"
) )
func Users(app *lishwist.Session, h http.Header, r *rsvp.Request) rsvp.Response { func Users(app *lishwist.Session, h http.Header, r *response.Request) response.Response {
admin := app.Admin() admin := app.Admin()
if admin == nil { if admin == nil {
return NotFound(h, r) return NotFound(h, r)
@ -14,13 +14,13 @@ func Users(app *lishwist.Session, h http.Header, r *rsvp.Request) rsvp.Response
users, err := admin.ListUsers() users, err := admin.ListUsers()
if err != nil { if err != nil {
return rsvp.Error(http.StatusInternalServerError, "Failed to get users: %s", err) return response.Error(http.StatusInternalServerError, "Failed to get users: %s", err)
} }
return rsvp.Data("", users) return response.Data("", users)
} }
func User(app *lishwist.Session, h http.Header, r *rsvp.Request) rsvp.Response { func User(app *lishwist.Session, h http.Header, r *response.Request) response.Response {
admin := app.Admin() admin := app.Admin()
if admin == nil { if admin == nil {
return NotFound(h, r) return NotFound(h, r)
@ -30,16 +30,16 @@ func User(app *lishwist.Session, h http.Header, r *rsvp.Request) rsvp.Response {
user, err := lishwist.GetUserByReference(reference) user, err := lishwist.GetUserByReference(reference)
if err != nil { if err != nil {
return rsvp.Error(http.StatusInternalServerError, "Failed to get user: %s", err) return response.Error(http.StatusInternalServerError, "Failed to get user: %s", err)
} }
if user == nil { if user == nil {
return rsvp.Error(http.StatusNotFound, "User not found") return response.Error(http.StatusNotFound, "User not found")
} }
return rsvp.Data("", user) return response.Data("", user)
} }
func UserPost(app *lishwist.Session, h http.Header, r *rsvp.Request) rsvp.Response { func UserPost(app *lishwist.Session, h http.Header, r *response.Request) response.Response {
admin := app.Admin() admin := app.Admin()
if admin == nil { if admin == nil {
return NotFound(h, r) return NotFound(h, r)
@ -49,15 +49,15 @@ func UserPost(app *lishwist.Session, h http.Header, r *rsvp.Request) rsvp.Respon
reference := r.PathValue("userReference") reference := r.PathValue("userReference")
if reference == app.User.Reference { if reference == app.User.Reference {
return rsvp.Error(http.StatusForbidden, "You cannot delete yourself.") return response.Error(http.StatusForbidden, "You cannot delete yourself.")
} }
user, err := lishwist.GetUserByReference(reference) user, err := lishwist.GetUserByReference(reference)
if err != nil { if err != nil {
return rsvp.Error(http.StatusInternalServerError, "Failed to get user: %s", err) return response.Error(http.StatusInternalServerError, "Failed to get user: %s", err)
} }
if user == nil { if user == nil {
return rsvp.Error(http.StatusNotFound, "User not found") return response.Error(http.StatusNotFound, "User not found")
} }
intent := form.Get("intent") intent := form.Get("intent")
@ -65,9 +65,9 @@ func UserPost(app *lishwist.Session, h http.Header, r *rsvp.Request) rsvp.Respon
if intent != "" { if intent != "" {
err = admin.UserSetLive(reference, intent != "delete") err = admin.UserSetLive(reference, intent != "delete")
if err != nil { if err != nil {
return rsvp.Error(http.StatusInternalServerError, "Failed to delete user: %s", err) return response.Error(http.StatusInternalServerError, "Failed to delete user: %s", err)
} }
} }
return rsvp.Data("", user) return response.Data("", user)
} }

30
http/routing/wishlist.go
View File

@ -2,31 +2,31 @@ package routing
import ( import (
lishwist "lishwist/core" lishwist "lishwist/core"
"lishwist/http/rsvp" "lishwist/http/response"
"net/http" "net/http"
) )
func WishlistAdd(app *lishwist.Session, h http.Header, r *rsvp.Request) rsvp.Response { func WishlistAdd(app *lishwist.Session, h http.Header, r *response.Request) response.Response {
form := r.ParseForm() form := r.ParseForm()
newGiftName := form.Get("gift_name") newGiftName := form.Get("gift_name")
err := app.MakeWish(newGiftName) err := app.MakeWish(newGiftName)
if err != nil { if err != nil {
return rsvp.Error(http.StatusInternalServerError, "Failed to add gift.").LogError(err) return response.Error(http.StatusInternalServerError, "Failed to add gift.").LogError(err)
} }
return rsvp.SeeOther("/") return response.SeeOther("/")
} }
func WishlistDelete(app *lishwist.Session, h http.Header, r *rsvp.Request) rsvp.Response { func WishlistDelete(app *lishwist.Session, h http.Header, r *response.Request) response.Response {
form := r.ParseForm() form := r.ParseForm()
targets := form["gift"] targets := form["gift"]
err := app.RevokeWishes(targets...) err := app.RevokeWishes(targets...)
if err != nil { if err != nil {
return rsvp.Error(http.StatusInternalServerError, "Failed to remove gifts.").LogError(err) return response.Error(http.StatusInternalServerError, "Failed to remove gifts.").LogError(err)
} }
return rsvp.SeeOther("/") return response.SeeOther("/")
} }
func ForeignWishlistPost(app *lishwist.Session, h http.Header, r *rsvp.Request) rsvp.Response { func ForeignWishlistPost(app *lishwist.Session, h http.Header, r *response.Request) response.Response {
form := r.ParseForm() form := r.ParseForm()
userReference := r.PathValue("userReference") userReference := r.PathValue("userReference")
intent := form.Get("intent") intent := form.Get("intent")
@ -36,22 +36,22 @@ func ForeignWishlistPost(app *lishwist.Session, h http.Header, r *rsvp.Request)
unclaims := form["claimed"] unclaims := form["claimed"]
err := app.ClaimWishes(claims, unclaims) err := app.ClaimWishes(claims, unclaims)
if err != nil { if err != nil {
return rsvp.Error(http.StatusInternalServerError, "Failed to update claim...").LogError(err) return response.Error(http.StatusInternalServerError, "Failed to update claim...").LogError(err)
} }
case "complete": case "complete":
claims := form["claimed"] claims := form["claimed"]
err := app.CompleteWishes(claims) err := app.CompleteWishes(claims)
if err != nil { if err != nil {
return rsvp.Error(http.StatusInternalServerError, "Failed to complete gifts...").LogError(err) return response.Error(http.StatusInternalServerError, "Failed to complete gifts...").LogError(err)
} }
case "add": case "add":
wishName := form.Get("gift_name") wishName := form.Get("gift_name")
if wishName == "" { if wishName == "" {
return rsvp.Error(http.StatusBadRequest, "Gift name not provided") return response.Error(http.StatusBadRequest, "Gift name not provided")
} }
err := app.SuggestWishForUser(userReference, wishName) err := app.SuggestWishForUser(userReference, wishName)
if err != nil { if err != nil {
return rsvp.Error(http.StatusInternalServerError, "Failed to add gift idea to other user...").LogError(err) return response.Error(http.StatusInternalServerError, "Failed to add gift idea to other user...").LogError(err)
} }
case "delete": case "delete":
claims := form["unclaimed"] claims := form["unclaimed"]
@ -59,10 +59,10 @@ func ForeignWishlistPost(app *lishwist.Session, h http.Header, r *rsvp.Request)
gifts := append(claims, unclaims...) gifts := append(claims, unclaims...)
err := app.RecindWishesForUser(gifts...) err := app.RecindWishesForUser(gifts...)
if err != nil { if err != nil {
return rsvp.Error(http.StatusInternalServerError, "Failed to remove gift idea for other user...").LogError(err) return response.Error(http.StatusInternalServerError, "Failed to remove gift idea for other user...").LogError(err)
} }
default: default:
return rsvp.Error(http.StatusBadRequest, "Invalid intent %q", intent) return response.Error(http.StatusBadRequest, "Invalid intent %q", intent)
} }
return rsvp.SeeOther("/list/" + userReference) return response.SeeOther("/list/" + userReference)
} }