lishwist/http/routing/groups.go

package routing

import (
	"encoding/xml"
	"log"
	"net/http"
	"slices"

	lishwist "lishwist/core"
	"lishwist/http/response"
	"lishwist/http/templates"

	"github.com/Teajey/rsvp"
)

type GroupProps struct {
	Navbar templates.NavCollapse
	Group  *lishwist.Group
}

func AdminGroup(app *lishwist.Session, h http.Header, r *http.Request) rsvp.Response {
	reference := r.PathValue("groupReference")
	group, err := lishwist.GetGroupByReference(reference)
	if err != nil {
		return response.Error(http.StatusInternalServerError, "Couldn't get group: %s", err)
	}
	if group == nil {
		return response.Error(http.StatusNotFound, "Group not found")
	}
	user := app.User()
	if !user.IsAdmin {
		index := group.MemberIndex(user.Id)
		group.Members = slices.Delete(group.Members, index, index+1)
	}
	p := GroupProps{
		Navbar: templates.UserNavCollapse(user.Name, user.PasswordFromAdmin),
		Group:  group,
	}
	return response.Data("group_page.gotmpl", p)
}

func Group(app *lishwist.Session, session *response.Session, h http.Header, r *http.Request) rsvp.Response {
	user := app.User()
	if user.IsAdmin {
		return AdminGroup(app, h, r)
	}
	groupReference := r.PathValue("groupReference")
	group, err := app.GetGroupByReference(groupReference)
	if err != nil {
		log.Printf("Couldn't get group: %s\n", err)
		return response.Error(http.StatusInternalServerError, "An error occurred while fetching this group :(")
	}
	if group == nil {
		return response.Error(http.StatusNotFound, "Group not found. (It might be because you're not a member)")
	}
	index := group.MemberIndex(user.Id)
	group.Members = slices.Delete(group.Members, index, index+1)
	p := GroupProps{
		Navbar: templates.UserNavCollapse(user.Name, user.PasswordFromAdmin),
		Group:  group,
	}
	return response.Data("group_page.gotmpl", p)
}

func PublicGroup(s *response.Session, h http.Header, r *http.Request) rsvp.Response {
	groupReference := r.PathValue("groupReference")
	group, err := lishwist.GetGroupByReference(groupReference)
	if err != nil {
		log.Printf("Couldn't get group: %s\n", err)
		return response.Error(http.StatusInternalServerError, "An error occurred while fetching this group :(")
	}
	if group == nil {
		return response.Error(http.StatusNotFound, "Group not found")
	}
	p := GroupProps{
		Navbar: templates.DefaultNavCollapse(),
		Group:  group,
	}
	return response.Data("public_group_page.gotmpl", p)
}

func GroupPost(app *lishwist.Session, session *response.Session, h http.Header, r *http.Request) rsvp.Response {
	admin := app.Admin()
	if admin == nil {
		return response.NotFound()
	}

	err := r.ParseForm()
	if err != nil {
		return response.Error(http.StatusBadRequest, "Failed to parse form")
	}

	var group *lishwist.Group

	reference := r.PathValue("groupReference")
	name := r.Form.Get("name")
	addUsers := r.Form["addUser"]
	removeUsers := r.Form["removeUser"]

	if name != "" {
		createdGroup, err := admin.CreateGroup(name, reference)
		if err != nil {
			return response.Error(http.StatusInternalServerError, "Failed to create group: %s", err)
		}
		group = createdGroup
	} else {
		existingGroup, err := lishwist.GetGroupByReference(reference)
		if err != nil {
			return response.Error(http.StatusInternalServerError, "Failed to get group: %s", err)
		}
		if existingGroup == nil {
			return response.Error(http.StatusNotFound, "Group not found: %s", err)
		}
		group = existingGroup

		for _, userId := range removeUsers {
			index := group.MemberIndex(userId)
			if index == -1 {
				return response.Error(http.StatusBadRequest, "Group %q does not contain a user with id %s", reference, userId)
			}
			err = admin.RemoveUserFromGroup(userId, group.Id)
			if err != nil {
				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)
		}
	}

	for _, userId := range addUsers {
		user, err := admin.GetUser(userId)
		if err != nil {
			return response.Error(http.StatusInternalServerError, "Groups exists, but a user with id %s could not be fetched: %s", userId, err)
		}
		if user == nil {
			return response.Error(http.StatusInternalServerError, "Groups exists, but a user with id %s does not exist", userId)
		}
		err = admin.AddUserToGroup(user.Id, group.Id)
		if err != nil {
			return response.Error(http.StatusInternalServerError, "Groups exists, but failed to add user with id %s: %s", userId, err)
		}
		group.Members = append(group.Members, *user)
	}

	return response.Data("", group)
}

type GroupList struct {
	XMLName xml.Name         `xml:"Groups" json:"-"`
	Groups  []lishwist.Group `xml:"Group"`
}

func Groups(app *lishwist.Session, session *response.Session, h http.Header, r *http.Request) rsvp.Response {
	admin := app.Admin()
	if admin == nil {
		return response.NotFound()
	}

	groups, err := admin.ListGroups()
	if err != nil {
		return response.Error(http.StatusInternalServerError, "Failed to get groups: %s", err)
	}

	return response.Data("", GroupList{Groups: groups})
}