gosora/extend/guilds/lib/guilds.go

498 lines
14 KiB
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
}