github.com/Azareal/Gosora@v0.0.0-20210729070923-553e66b59003/extend/guilds/lib/guilds.go

package guilds // import "github.com/Azareal/Gosora/extend/guilds/lib"

import (
	"bytes"
	"context"
	"database/sql"
	"errors"
	"html/template"
	"net/http"
	"strconv"
	"strings"

	c "github.com/Azareal/Gosora/common"
	"github.com/Azareal/Gosora/routes"
)

// A blank list to fill out that parameter in Page for routes which don't use it
var tList []interface{}

var ListStmt *sql.Stmt
var MemberListStmt *sql.Stmt
var MemberListJoinStmt *sql.Stmt
var GetMemberStmt *sql.Stmt
var AttachForumStmt *sql.Stmt
var UnattachForumStmt *sql.Stmt
var AddMemberStmt *sql.Stmt

// Guild is a struct representing a guild
type Guild struct {
	ID      int
	Link    string
	Name    string
	Desc    string
	Active  bool
	Privacy int /* 0: Public, 1: Protected, 2: Private */

	// Who should be able to accept applications and create invites? Mods+ or just admins? Mods is a good start, we can ponder over whether we should make this more flexible in the future.
	Joinable int /* 0: Private, 1: Anyone can join, 2: Applications, 3: Invite-only */

	MemberCount    int
	Owner          int
	Backdrop       string
	CreatedAt      string
	LastUpdateTime string

	MainForumID int
	MainForum   *c.Forum
	Forums      []*c.Forum
	ExtData     c.ExtData
}

type Page struct {
	Title    string
	Header   *c.Header
	ItemList []*c.TopicsRow
	Forum    *c.Forum
	Guild    *Guild
	Page     int
	LastPage int
}

// ListPage is a page struct for constructing a list of every guild
type ListPage struct {
	Title     string
	Header    *c.Header
	GuildList []*Guild
}

type MemberListPage struct {
	Title    string
	Header   *c.Header
	ItemList []Member
	Guild    *Guild
	Page     int
	LastPage int
}

// Member is a struct representing a specific member of a guild, not to be confused with the global User struct.
type Member struct {
	Link       string
	Rank       int    /* 0: Member. 1: Mod. 2: Admin. */
	RankString string /* Member, Mod, Admin, Owner */
	PostCount  int
	JoinedAt   string
	Offline    bool // TODO: Need to track the online states of members when WebSockets are enabled

	User c.User
}

func PrebuildTmplList(user *c.User, h *c.Header) c.CTmpl {
	guildList := []*Guild{
		&Guild{
			ID:             1,
			Name:           "lol",
			Link:           BuildGuildURL(c.NameToSlug("lol"), 1),
			Desc:           "A group for people who like to laugh",
			Active:         true,
			MemberCount:    1,
			Owner:          1,
			CreatedAt:      "date",
			LastUpdateTime: "date",
			MainForumID:    1,
			MainForum:      c.Forums.DirtyGet(1),
			Forums:         []*c.Forum{c.Forums.DirtyGet(1)},
		},
	}
	listPage := ListPage{"Guild List", user, h, guildList}
	return c.CTmpl{"guilds_guild_list", "guilds_guild_list.html", "templates/", "guilds.ListPage", listPage, []string{"./extend/guilds/lib"}}
}

// TODO: Do this properly via the widget system
// TODO: REWRITE THIS
func CommonAreaWidgets(header *c.Header) {
	// TODO: Hot Groups? Featured Groups? Official Groups?
	var b bytes.Buffer
	menu := c.WidgetMenu{"Guilds", []c.WidgetMenuItem{
		c.WidgetMenuItem{"Create Guild", "/guild/create/", false},
	}}

	err := header.Theme.RunTmpl("widget_menu", pi, w)
	if err != nil {
		c.LogError(err)
		return
	}

	if header.Theme.HasDock("leftSidebar") {
		header.Widgets.LeftSidebar = template.HTML(string(b.Bytes()))
	} else if header.Theme.HasDock("rightSidebar") {
		header.Widgets.RightSidebar = template.HTML(string(b.Bytes()))
	}
}

// TODO: Do this properly via the widget system
// TODO: Make a better more customisable group widget system
func GuildWidgets(header *c.Header, guildItem *Guild) (success bool) {
	return false // Disabled until the next commit

	/*var b bytes.Buffer
	var menu WidgetMenu = WidgetMenu{"Guild Options", []WidgetMenuItem{
		WidgetMenuItem{"Join", "/guild/join/" + strconv.Itoa(guildItem.ID), false},
		WidgetMenuItem{"Members", "/guild/members/" + strconv.Itoa(guildItem.ID), false},
	}}

	err := templates.ExecuteTemplate(&b, "widget_menu.html", menu)
	if err != nil {
		c.LogError(err)
		return false
	}

	if themes[header.Theme.Name].Sidebars == "left" {
		header.Widgets.LeftSidebar = template.HTML(string(b.Bytes()))
	} else if themes[header.Theme.Name].Sidebars == "right" || themes[header.Theme.Name].Sidebars == "both" {
		header.Widgets.RightSidebar = template.HTML(string(b.Bytes()))
	} else {
		return false
	}
	return true*/
}

/*
	Custom Pages
*/

func RouteGuildList(w http.ResponseWriter, r *http.Request, user *c.User) c.RouteError {
	h, ferr := c.UserCheck(w, r, user)
	if ferr != nil {
		return ferr
	}
	CommonAreaWidgets(h)

	rows, err := ListStmt.Query()
	if err != nil && err != c.ErrNoRows {
		return c.InternalError(err, w, r)
	}
	defer rows.Close()

	var guildList []*Guild
	for rows.Next() {
		g := &Guild{ID: 0}
		err := rows.Scan(&g.ID, &g.Name, &g.Desc, &g.Active, &g.Privacy, &g.Joinable, &g.Owner, &g.MemberCount, &g.CreatedAt, &g.LastUpdateTime)
		if err != nil {
			return c.InternalError(err, w, r)
		}
		g.Link = BuildGuildURL(c.NameToSlug(g.Name), g.ID)
		guildList = append(guildList, g)
	}
	if err = rows.Err(); err != nil {
		return c.InternalError(err, w, r)
	}

	pi := ListPage{"Guild List", user, h, guildList}
	return routes.RenderTemplate("guilds_guild_list", w, r, h, pi)
}

func MiddleViewGuild(w http.ResponseWriter, r *http.Request, user *c.User) c.RouteError {
	_, guildID, err := routes.ParseSEOURL(r.URL.Path[len("/guild/"):])
	if err != nil {
		return c.PreError("Not a valid guild ID", w, r)
	}

	guildItem, err := Gstore.Get(guildID)
	if err != nil {
		return c.LocalError("Bad guild", w, r, user)
	}
	// TODO: Build and pass header
	if !guildItem.Active {
		return c.NotFound(w, r, nil)
	}

	return nil

	// TODO: Re-implement this
	// Re-route the request to routeForums
	//var ctx = context.WithValue(r.Context(), "guilds_current_guild", guildItem)
	//return routeForum(w, r.WithContext(ctx), user, strconv.Itoa(guildItem.MainForumID))
}

func RouteCreateGuild(w http.ResponseWriter, r *http.Request, user *c.User) c.RouteError {
	h, ferr := c.UserCheck(w, r, user)
	if ferr != nil {
		return ferr
	}
	h.Title = "Create Guild"
	// TODO: Add an approval queue mode for group creation
	if !user.Loggedin || !user.PluginPerms["CreateGuild"] {
		return c.NoPermissions(w, r, user)
	}
	CommonAreaWidgets(h)

	return routes.RenderTemplate("guilds_create_guild", w, r, h, c.Page{h, tList, nil})
}

func RouteCreateGuildSubmit(w http.ResponseWriter, r *http.Request, user *c.User) c.RouteError {
	// TODO: Add an approval queue mode for group creation
	if !user.Loggedin || !user.PluginPerms["CreateGuild"] {
		return c.NoPermissions(w, r, user)
	}

	guildActive := true
	guildName := c.SanitiseSingleLine(r.PostFormValue("group_name"))
	// TODO: Allow Markdown / BBCode / Limited HTML in the description?
	guildDesc := c.SanitiseBody(r.PostFormValue("group_desc"))

	var guildPrivacy int
	switch r.PostFormValue("group_privacy") {
	case "0":
		guildPrivacy = 0 // Public
	case "1":
		guildPrivacy = 1 // Protected
	case "2":
		guildPrivacy = 2 // private
	default:
		guildPrivacy = 0
	}

	// Create the backing forum
	fid, err := c.Forums.Create(guildName, "", true, "")
	if err != nil {
		return c.InternalError(err, w, r)
	}

	gid, err := Gstore.Create(guildName, guildDesc, guildActive, guildPrivacy, user.ID, fid)
	if err != nil {
		return c.InternalError(err, w, r)
	}

	// Add the main backing forum to the forum list
	err = AttachForum(gid, fid)
	if err != nil {
		return c.InternalError(err, w, r)
	}

	_, err = AddMemberStmt.Exec(gid, user.ID, 2)
	if err != nil {
		return c.InternalError(err, w, r)
	}

	http.Redirect(w, r, BuildGuildURL(c.NameToSlug(guildName), gid), http.StatusSeeOther)
	return nil
}

func RouteMemberList(w http.ResponseWriter, r *http.Request, user *c.User) c.RouteError {
	header, ferr := c.UserCheck(w, r, &user)
	if ferr != nil {
		return ferr
	}

	_, guildID, err := routes.ParseSEOURL(r.URL.Path[len("/guild/members/"):])
	if err != nil {
		return c.PreError("Not a valid group ID", w, r)
	}

	guild, err := Gstore.Get(guildID)
	if err != nil {
		return c.LocalError("Bad group", w, r, user)
	}
	guild.Link = BuildGuildURL(c.NameToSlug(guild.Name), guild.ID)

	GuildWidgets(header, guild)

	rows, err := MemberListJoinStmt.Query(guildID)
	if err != nil && err != c.ErrNoRows {
		return c.InternalError(err, w, r)
	}

	var guildMembers []Member
	for rows.Next() {
		gMember := Member{PostCount: 0}
		err := rows.Scan(&gMember.User.ID, &gMember.Rank, &gMember.PostCount, &gMember.JoinedAt, &gMember.User.Name, &gMember.User.RawAvatar)
		if err != nil {
			return c.InternalError(err, w, r)
		}
		gMember.Link = c.BuildProfileURL(c.NameToSlug(gMember.User.Name), gMember.User.ID)
		gMember.User.Avatar, gMember.User.MicroAvatar = c.BuildAvatar(gMember.User.ID, gMember.User.RawAvatar)
		gMember.JoinedAt, _ = c.RelativeTimeFromString(gMember.JoinedAt)
		if guild.Owner == gMember.User.ID {
			gMember.RankString = "Owner"
		} else {
			switch gMember.Rank {
			case 0:
				gMember.RankString = "Member"
			case 1:
				gMember.RankString = "Mod"
			case 2:
				gMember.RankString = "Admin"
			}
		}
		guildMembers = append(guildMembers, gMember)
	}
	if err = rows.Err(); err != nil {
		return c.InternalError(err, w, r)
	}
	rows.Close()

	pi := MemberListPage{"Guild Member List", user, header, gMembers, guild, 0, 0}
	// A plugin with plugins. Pluginception!
	if c.RunPreRenderHook("pre_render_guilds_member_list", w, r, user, &pi) {
		return nil
	}
	err = c.RunThemeTemplate(header.Theme.Name, "guilds_member_list", pi, w)
	if err != nil {
		return c.InternalError(err, w, r)
	}
	return nil
}

func AttachForum(guildID, fid int) error {
	_, err := AttachForumStmt.Exec(guildID, fid)
	return err
}

func UnattachForum(fid int) error {
	_, err := AttachForumStmt.Exec(fid)
	return err
}

func BuildGuildURL(slug string, id int) string {
	if slug == "" || !c.Config.BuildSlugs {
		return "/guild/" + strconv.Itoa(id)
	}
	return "/guild/" + slug + "." + strconv.Itoa(id)
}

/*
	Hooks
*/

// TODO: Prebuild this template
func PreRenderViewForum(w http.ResponseWriter, r *http.Request, user *c.User, data interface{}) (halt bool) {
	pi := data.(*c.ForumPage)
	if pi.Header.ExtData.Items != nil {
		if guildData, ok := pi.Header.ExtData.Items["guilds_current_group"]; ok {
			guildItem := guildData.(*Guild)

			guildpi := Page{pi.Title, pi.Header, pi.ItemList, pi.Forum, guildItem, pi.Page, pi.LastPage}
			err := routes.RenderTemplate("guilds_view_guild", w, r, pi.Header, guildpi)
			if err != nil {
				c.LogError(err)
				return false
			}
			return true
		}
	}
	return false
}

func TrowAssign(args ...interface{}) interface{} {
	var forum = args[1].(*c.Forum)
	if forum.ParentType == "guild" {
		var topicItem = args[0].(*c.TopicsRow)
		topicItem.ForumLink = "/guild/" + strings.TrimPrefix(topicItem.ForumLink, c.GetForumURLPrefix())
	}
	return nil
}

// TODO: It would be nice, if you could select one of the boards in the group from that drop-down rather than just the one you got linked from
func TopicCreatePreLoop(args ...interface{}) interface{} {
	var fid = args[2].(int)
	if c.Forums.DirtyGet(fid).ParentType == "guild" {
		var strictmode = args[5].(*bool)
		*strictmode = true
	}
	return nil
}

// TODO: Add privacy options
// TODO: Add support for multiple boards and add per-board simplified permissions
// TODO: Take js into account for routes which expect JSON responses
func ForumCheck(args ...interface{}) (skip bool, rerr c.RouteError) {
	r := args[1].(*http.Request)
	fid := args[3].(*int)
	forum := c.Forums.DirtyGet(*fid)

	if forum.ParentType == "guild" {
		var err error
		w := args[0].(http.ResponseWriter)
		guildItem, ok := r.Context().Value("guilds_current_group").(*Guild)
		if !ok {
			guildItem, err = Gstore.Get(forum.ParentID)
			if err != nil {
				return true, c.InternalError(errors.New("Unable to find the parent group for a forum"), w, r)
			}
			if !guildItem.Active {
				return true, c.NotFound(w, r, nil) // TODO: Can we pull header out of args?
			}
			r = r.WithContext(context.WithValue(r.Context(), "guilds_current_group", guildItem))
		}

		user := args[2].(*c.User)
		var rank, posts int
		var joinedAt string

		// TODO: Group privacy settings. For now, groups are all globally visible

		// Clear the default group permissions
		// TODO: Do this more efficiently, doing it quick and dirty for now to get this out quickly
		c.OverrideForumPerms(&user.Perms, false)
		user.Perms.ViewTopic = true

		err = GetMemberStmt.QueryRow(guildItem.ID, user.ID).Scan(&rank, &posts, &joinedAt)
		if err != nil && err != c.ErrNoRows {
			return true, c.InternalError(err, w, r)
		} else if err != nil {
			// TODO: Should we let admins / guests into public groups?
			return true, c.LocalError("You're not part of this group!", w, r, user)
		}

		// TODO: Implement bans properly by adding the Local Ban API in the next commit
		// TODO: How does this even work? Refactor it along with the rest of this plugin!
		if rank < 0 {
			return true, c.LocalError("You've been banned from this group!", w, r, user)
		}

		// Basic permissions for members, more complicated permissions coming in the next commit!
		if guildItem.Owner == user.ID {
			c.OverrideForumPerms(&user.Perms, true)
		} else if rank == 0 {
			user.Perms.LikeItem = true
			user.Perms.CreateTopic = true
			user.Perms.CreateReply = true
		} else {
			c.OverrideForumPerms(&user.Perms, true)
		}
		return true, nil
	}

	return false, nil
}

// TODO: Override redirects? I don't think this is needed quite yet

func Widgets(args ...interface{}) interface{} {
	zone := args[0].(string)
	h := args[2].(*c.Header)
	request := args[3].(*http.Request)
	if zone != "view_forum" {
		return false
	}

	f := args[1].(*c.Forum)
	if f.ParentType == "guild" {
		// This is why I hate using contexts, all the daisy chains and interface casts x.x
		guild, ok := request.Context().Value("guilds_current_group").(*Guild)
		if !ok {
			c.LogError(errors.New("Unable to find a parent group in the context data"))
			return false
		}

		if h.ExtData.Items == nil {
			h.ExtData.Items = make(map[string]interface{})
		}
		h.ExtData.Items["guilds_current_group"] = guild

		return GuildWidgets(h, guild)
	}
	return false
}