default colour to green

app/http/endpoints/manage/panelcreate.go

@@ -88,11 +88,12 @@ func PanelCreateHandler(ctx *gin.Context) {
 		}
 
 		// Validate colour
+		validColour := true
 		panelColourHex := ctx.PostForm("colour")
 		panelColour, err := strconv.ParseUint(panelColourHex, 16, 32)
 		if err != nil {
-			ctx.Redirect(302, fmt.Sprintf("/manage/%d/panels?validColour=false", guildId))
-			return
+			validColour = false
+			panelColour = 0x23A31A
 		}
 
 		// Validate channel
@@ -149,7 +150,7 @@ func PanelCreateHandler(ctx *gin.Context) {
 
 		go cache.Client.PublishPanelCreate(settings)
 
-		ctx.Redirect(302, fmt.Sprintf("/manage/%d/panels?created=true", guildId))
+		ctx.Redirect(302, fmt.Sprintf("/manage/%d/panels?created=true&validColour=%t", guildId, validColour))
 	} else {
 		ctx.Redirect(302, "/login")
 	}

app/http/endpoints/root/callback.go

@@ -104,3 +104,23 @@ func CallbackHandler(ctx *gin.Context) {
 		table.UpdateGuilds(currentUser.Id, base64.StdEncoding.EncodeToString(marshalled))
 	}()
 }
+
+func cacheRoles(store sessions.Session, guildId, userId int64) {
+	rolesChan := make(chan *[]int64, 0)
+	go utils.GetRolesRest(store, guildId, userId, rolesChan)
+	roles := <-rolesChan
+
+	if roles == nil {
+		return
+	}
+
+	memberIdChan := make(chan *int)
+	go table.GetMemberId(guildId, userId, memberIdChan)
+	memberId := <-memberIdChan
+
+	if memberId == nil {
+		return
+	}
+
+
+}

database/table/memberids.go

@@ -0,0 +1,38 @@
+package table
+
+import (
+	"github.com/TicketsBot/GoPanel/database"
+	"github.com/apex/log"
+)
+
+// Use an intermediary table to prevent a many-to-many relationship
+type MemberId struct {
+	MemberId int `gorm:"column:MEMBERID;primary_key;auto_increment"`
+	GuildId  int64 `gorm:"column:GUILDID"`
+	UserId   int64 `gorm:"column:USERID"`
+}
+
+func (MemberId) TableName() string {
+	return "cache_memberids"
+}
+
+func GetMemberId(guildId, userId int64, ch chan *int) {
+	var row MemberId
+	database.Database.Where(&MemberId{GuildId: guildId, UserId: userId}).Take(&row)
+
+	if row.MemberId == 0 {
+		row = MemberId{
+			GuildId: guildId,
+			UserId:  userId,
+		}
+		if db := database.Database.Create(row).Scan(&row); db.Error != nil {
+			log.Error(db.Error.Error())
+			ch <- nil
+			return
+		}
+
+		ch <- &row.MemberId
+	} else {
+		ch <- &row.MemberId
+	}
+}

database/table/rolepermissions.go

@@ -0,0 +1,140 @@
+package table
+
+import (
+	"github.com/TicketsBot/GoPanel/database"
+	"strconv"
+)
+
+type RolePermissions struct {
+	GuildId int64 `gorm:"column:GUILDID"`
+	RoleId  int64 `gorm:"column:ROLEID"`
+	Support bool  `gorm:"column:ISSUPPORT"`
+	Admin   bool  `gorm:"column:ISADMIN"`
+}
+
+func (RolePermissions) TableName() string {
+	return "role_permissions"
+}
+
+func IsSupportRole(guild string, role string, ch chan bool) {
+	guildId, err := strconv.ParseInt(guild, 10, 64); if err != nil {
+		ch <- false
+		return
+	}
+
+	rollId, err := strconv.ParseInt(role, 10, 64); if err != nil {
+		ch <- false
+		return
+	}
+
+	var node RolePermissions
+	database.Database.Where(RolePermissions{GuildId: guildId, RoleId: rollId}).First(&node)
+	ch <- node.Support
+}
+
+func IsAdminRole(guild string, role string, ch chan bool) {
+	guildId, err := strconv.ParseInt(guild, 10, 64); if err != nil {
+		ch <- false
+		return
+	}
+
+	rollId, err := strconv.ParseInt(role, 10, 64); if err != nil {
+		ch <- false
+		return
+	}
+
+	var node RolePermissions
+	database.Database.Where(RolePermissions{GuildId: guildId, RoleId: rollId}).First(&node)
+	ch <- node.Admin
+}
+
+func GetAdminRoles(guild string, ch chan []int64) {
+	guildId, err := strconv.ParseInt(guild, 10, 64); if err != nil {
+		ch <- []int64{}
+		return
+	}
+
+	var nodes []RolePermissions
+	database.Database.Where(RolePermissions{GuildId: guildId, Admin: true}).Find(&nodes)
+
+	ids := make([]int64, 0)
+	for _, node := range nodes {
+		ids = append(ids, node.RoleId)
+	}
+
+	ch <- ids
+}
+
+func GetSupportRoles(guild string, ch chan []int64) {
+	guildId, err := strconv.ParseInt(guild, 10, 64); if err != nil {
+		ch <- []int64{}
+		return
+	}
+
+	var nodes []RolePermissions
+	database.Database.Where(RolePermissions{GuildId: guildId, Support: true, Admin: false}).Find(&nodes)
+
+	ids := make([]int64, 0)
+	for _, node := range nodes {
+		ids = append(ids, node.RoleId)
+	}
+
+	ch <- ids
+}
+
+func AddAdminRole(guild string, role string) {
+	guildId, err := strconv.ParseInt(guild, 10, 64); if err != nil {
+		return
+	}
+
+	roleId, err := strconv.ParseInt(role, 10, 64); if err != nil {
+		return
+	}
+
+	var node RolePermissions
+	database.Database.Where(RolePermissions{GuildId: guildId, RoleId: roleId}).Assign(RolePermissions{Admin: true, Support: true}).FirstOrCreate(&node)
+}
+
+func AddSupportRole(guild string, role string) {
+	guildId, err := strconv.ParseInt(guild, 10, 64); if err != nil {
+		return
+	}
+
+	roleId, err := strconv.ParseInt(role, 10, 64); if err != nil {
+		return
+	}
+
+	var node RolePermissions
+	database.Database.Where(RolePermissions{GuildId: guildId, RoleId: roleId}).Assign(RolePermissions{Support: true}).FirstOrCreate(&node)
+}
+
+func RemoveAdminRole(guild string, role string) {
+	guildId, err := strconv.ParseInt(guild, 10, 64); if err != nil {
+		return
+	}
+
+	roleId, err := strconv.ParseInt(role, 10, 64); if err != nil {
+		return
+	}
+
+	var node RolePermissions
+	database.Database.Where(RolePermissions{GuildId: guildId, RoleId: roleId}).Take(&node)
+	database.Database.Model(&node).Where("GUILDID = ? AND ROLEID = ?", guildId, roleId).Update("ISADMIN", false)
+}
+
+func RemoveSupportRole(guild string, role string) {
+	guildId, err := strconv.ParseInt(guild, 10, 64); if err != nil {
+		return
+	}
+
+	roleId, err := strconv.ParseInt(role, 10, 64); if err != nil {
+		return
+	}
+
+	var node RolePermissions
+	database.Database.Where(RolePermissions{GuildId: guildId, RoleId: roleId}).Take(&node)
+	database.Database.Model(&node).Where("GUILDID = ? AND ROLEID = ?", guildId, roleId).Updates(map[string]interface{}{
+		"ISADMIN": false,
+		"ISSUPPORT": false,
+	})
+}

database/table/rolescache.go

@@ -0,0 +1,11 @@
+package table
+
+// Use an intermediary table to prevent a many-to-many relationship
+type RoleCache struct {
+	MemberId int   `gorm:"column:MEMBERID;primary_key"`
+	RoleId   int64 `gorm:"column:ROLEID"`
+}
+
+func (RoleCache) TableName() string {
+	return "cache_roles"
+}

public/templates/views/panels.tmpl

@@ -159,6 +159,7 @@
               </div>
               <div class="toast-body">
                 Invalid panel colour. You must use the hex value of the colour, which you can find <a href="https://www.google.co.uk/search?client=opera&q=html+colour+picker">here</a>.
+                <br />Colour has defaulted to green.
               </div>
             </div>
           {{end}}

utils/discord/endpoints/guild/getGuildMember.go

@@ -0,0 +1,15 @@
+package guild
+
+import (
+	"fmt"
+	"github.com/TicketsBot/GoPanel/utils/discord"
+	"strconv"
+)
+
+func GetGuildMember(guildId, userId int) discord.Endpoint {
+	return discord.Endpoint{
+		RequestType:       discord.GET,
+		AuthorizationType: discord.BOT,
+		Endpoint:          fmt.Sprintf("/guilds/%s/members/%s", strconv.Itoa(guildId), strconv.Itoa(userId)),
+	}
+}

utils/permissionutils.go

@@ -0,0 +1,52 @@
+package utils
+
+import (
+	"fmt"
+	"github.com/TicketsBot/GoPanel/config"
+	"github.com/TicketsBot/GoPanel/database/table"
+	"github.com/TicketsBot/GoPanel/utils/discord"
+	"github.com/TicketsBot/GoPanel/utils/discord/endpoints/guild"
+	"github.com/TicketsBot/GoPanel/utils/discord/objects"
+	"github.com/apex/log"
+	"github.com/gin-gonic/contrib/sessions"
+	"strconv"
+)
+
+func IsAdmin(guild objects.Guild, guildId, user int64, res chan bool) {
+	userIdStr := strconv.Itoa(int(user))
+
+	if Contains(config.Conf.Admins, userIdStr) {
+		res <- true
+	}
+
+	if guild.Owner {
+		res <- true
+	}
+
+	if table.IsAdmin(guildId, user) {
+		res <- true
+	}
+
+	res <- false
+}
+
+func GetRolesRest(store sessions.Session, guildId, userId int64, res chan *[]int64) {
+	var member objects.Member
+	endpoint := guild.GetGuildMember(int(guildId), int(userId))
+
+	if err, _ := endpoint.Request(store, nil, nil, &member); err != nil {
+		res <- nil
+	}
+
+	roles := make([]int64, 0)
+	for _, role := range member.Roles {
+		int, err := strconv.ParseInt(role, 10, 64); if err != nil {
+			log.Error(err.Error())
+			continue
+		}
+
+		roles = append(roles, int)
+	}
+
+	res <- &roles
+}