scout_ante/dashboard-v2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

port to be compatible with GDL bot

Browse Source
This commit is contained in:
Dot-Rar 2020-04-04 17:52:43 +01:00
parent 26172fbd89
commit ce3e50725b
43 changed files with 587 additions and 611 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
app/http/endpoints/manage/blacklist.go
View File

@ -27,7 +27,7 @@ func BlacklistHandler(ctx *gin.Context) {
// Verify the guild exists // Verify the guild exists
guildIdStr := ctx.Param("id") guildIdStr := ctx.Param("id")
guildId, err := strconv.ParseInt(guildIdStr, 10, 64) guildId, err := strconv.ParseUint(guildIdStr, 10, 64)
if err != nil { if err != nil {
ctx.Redirect(302, config.Conf.Server.BaseUrl) // TODO: 404 Page ctx.Redirect(302, config.Conf.Server.BaseUrl) // TODO: 404 Page
return return
@ -52,7 +52,7 @@ func BlacklistHandler(ctx *gin.Context) {
blacklistedUsers := table.GetBlacklistNodes(guildId) blacklistedUsers := table.GetBlacklistNodes(guildId)
var blacklistedIds []int64 var blacklistedIds []uint64
for _, user := range blacklistedUsers { for _, user := range blacklistedUsers {
blacklistedIds = append(blacklistedIds, user.User) blacklistedIds = append(blacklistedIds, user.User)
} }

4
app/http/endpoints/manage/blacklistremove.go
View File

@ -28,7 +28,7 @@ func BlacklistRemoveHandler(ctx *gin.Context) {
// Verify the guild exists // Verify the guild exists
guildIdStr := ctx.Param("id") guildIdStr := ctx.Param("id")
guildId, err := strconv.ParseInt(guildIdStr, 10, 64) guildId, err := strconv.ParseUint(guildIdStr, 10, 64)
if err != nil { if err != nil {
ctx.Redirect(302, config.Conf.Server.BaseUrl) // TODO: 404 Page ctx.Redirect(302, config.Conf.Server.BaseUrl) // TODO: 404 Page
return return
@ -53,7 +53,7 @@ func BlacklistRemoveHandler(ctx *gin.Context) {
if ctx.Query("c") == store.Get("csrf").(string) { if ctx.Query("c") == store.Get("csrf").(string) {
targetIdStr := ctx.Param("user") targetIdStr := ctx.Param("user")
targetId, err := strconv.ParseInt(targetIdStr, 10, 64) targetId, err := strconv.ParseUint(targetIdStr, 10, 64)
if err == nil { // If it's a real ID if err == nil { // If it's a real ID
table.RemoveBlacklist(guildId, targetId) table.RemoveBlacklist(guildId, targetId)

6
app/http/endpoints/manage/logs.go
View File

@ -27,7 +27,7 @@ func LogsHandler(ctx *gin.Context) {
// Verify the guild exists // Verify the guild exists
guildIdStr := ctx.Param("id") guildIdStr := ctx.Param("id")
guildId, err := strconv.ParseInt(guildIdStr, 10, 64) guildId, err := strconv.ParseUint(guildIdStr, 10, 64)
if err != nil { if err != nil {
ctx.Redirect(302, config.Conf.Server.BaseUrl) // TODO: 404 Page ctx.Redirect(302, config.Conf.Server.BaseUrl) // TODO: 404 Page
return return
@ -63,9 +63,9 @@ func LogsHandler(ctx *gin.Context) {
// Get logs // Get logs
// Get user ID from URL // Get user ID from URL
var filteredUserId int64 var filteredUserId uint64
if utils.IsInt(ctx.Query("userid")) { if utils.IsInt(ctx.Query("userid")) {
filteredUserId, _ = strconv.ParseInt(ctx.Query("userid"), 10, 64) filteredUserId, _ = strconv.ParseUint(ctx.Query("userid"), 10, 64)
} }
// Get ticket ID from URL // Get ticket ID from URL

12
app/http/endpoints/manage/panelcreate.go
View File

@ -30,7 +30,7 @@ func PanelCreateHandler(ctx *gin.Context) {
// Verify the guild exists // Verify the guild exists
guildIdStr := ctx.Param("id") guildIdStr := ctx.Param("id")
guildId, err := strconv.ParseInt(guildIdStr, 10, 64) guildId, err := strconv.ParseUint(guildIdStr, 10, 64)
if err != nil { if err != nil {
ctx.Redirect(302, config.Conf.Server.BaseUrl) // TODO: 404 Page ctx.Redirect(302, config.Conf.Server.BaseUrl) // TODO: 404 Page
return return
@ -62,7 +62,7 @@ func PanelCreateHandler(ctx *gin.Context) {
// Get if the guild is premium // Get if the guild is premium
premiumChan := make(chan bool) premiumChan := make(chan bool)
go utils.IsPremiumGuild(store, guildIdStr, premiumChan) go utils.IsPremiumGuild(store, guildId, premiumChan)
premium := <-premiumChan premium := <-premiumChan
// Check the user hasn't met their panel quota // Check the user hasn't met their panel quota
@ -100,7 +100,7 @@ func PanelCreateHandler(ctx *gin.Context) {
// Validate channel // Validate channel
channelIdStr := ctx.PostForm("channel") channelIdStr := ctx.PostForm("channel")
channelId, err := strconv.ParseInt(channelIdStr, 10, 64); if err != nil { channelId, err := strconv.ParseUint(channelIdStr, 10, 64); if err != nil {
ctx.Redirect(302, fmt.Sprintf("/manage/%d/panels?validChannel=false", guildId)) ctx.Redirect(302, fmt.Sprintf("/manage/%d/panels?validChannel=false", guildId))
return return
} }
@ -114,7 +114,7 @@ func PanelCreateHandler(ctx *gin.Context) {
// Validate category // Validate category
categoryStr := ctx.PostForm("categories") categoryStr := ctx.PostForm("categories")
categoryId, err := strconv.ParseInt(categoryStr, 10, 64); if err != nil { categoryId, err := strconv.ParseUint(categoryStr, 10, 64); if err != nil {
ctx.Redirect(302, fmt.Sprintf("/manage/%d/panels?validCategory=false", guildId)) ctx.Redirect(302, fmt.Sprintf("/manage/%d/panels?validCategory=false", guildId))
return return
} }
@ -158,7 +158,7 @@ func PanelCreateHandler(ctx *gin.Context) {
} }
} }
func validateChannel(guildId, channelId int64, res chan bool) { func validateChannel(guildId, channelId uint64, res chan bool) {
// Get channels from DB // Get channels from DB
channelsChan := make(chan []table.Channel) channelsChan := make(chan []table.Channel)
go table.GetCachedChannelsByGuild(guildId, channelsChan) go table.GetCachedChannelsByGuild(guildId, channelsChan)
@ -176,7 +176,7 @@ func validateChannel(guildId, channelId int64, res chan bool) {
res <- validChannel res <- validChannel
} }
func validateCategory(guildId, categoryId int64, res chan bool) { func validateCategory(guildId, categoryId uint64, res chan bool) {
// Get channels from DB // Get channels from DB
categoriesChan := make(chan []table.Channel) categoriesChan := make(chan []table.Channel)
go table.GetCategories(guildId, categoriesChan) go table.GetCategories(guildId, categoriesChan)

4
app/http/endpoints/manage/paneldelete.go
View File

@ -28,14 +28,14 @@ func PanelDeleteHandler(ctx *gin.Context) {
// Verify the guild exists // Verify the guild exists
guildIdStr := ctx.Param("id") guildIdStr := ctx.Param("id")
guildId, err := strconv.ParseInt(guildIdStr, 10, 64) guildId, err := strconv.ParseUint(guildIdStr, 10, 64)
if err != nil { if err != nil {
ctx.Redirect(302, config.Conf.Server.BaseUrl) // TODO: 404 Page ctx.Redirect(302, config.Conf.Server.BaseUrl) // TODO: 404 Page
return return
} }
messageIdStr := ctx.Param("msg") messageIdStr := ctx.Param("msg")
messageId, err := strconv.ParseInt(messageIdStr, 10, 64); if err != nil { messageId, err := strconv.ParseUint(messageIdStr, 10, 64); if err != nil {
ctx.Redirect(302, fmt.Sprintf("/manage/%d/panels", guildId)) ctx.Redirect(302, fmt.Sprintf("/manage/%d/panels", guildId))
return return
} }

10
app/http/endpoints/manage/panels.go
View File

@ -11,7 +11,7 @@ import (
) )
type wrappedPanel struct { type wrappedPanel struct {
MessageId int64 MessageId uint64
ChannelName string ChannelName string
Title string Title string
Content string Content string
@ -35,7 +35,7 @@ func PanelHandler(ctx *gin.Context) {
// Verify the guild exists // Verify the guild exists
guildIdStr := ctx.Param("id") guildIdStr := ctx.Param("id")
guildId, err := strconv.ParseInt(guildIdStr, 10, 64) guildId, err := strconv.ParseUint(guildIdStr, 10, 64)
if err != nil { if err != nil {
ctx.Redirect(302, config.Conf.Server.BaseUrl) // TODO: 404 Page ctx.Redirect(302, config.Conf.Server.BaseUrl) // TODO: 404 Page
return return
@ -101,7 +101,7 @@ func PanelHandler(ctx *gin.Context) {
} }
// Format channels to be text channels only // Format channels to be text channels only
channelMap := make(map[int64]string) channelMap := make(map[uint64]string)
for _, channel := range channels { for _, channel := range channels {
if channel.Type == 0 { if channel.Type == 0 {
channelMap[channel.ChannelId] = channel.Name channelMap[channel.ChannelId] = channel.Name
@ -109,7 +109,7 @@ func PanelHandler(ctx *gin.Context) {
} }
// Get categories & format // Get categories & format
categories := make(map[int64]string) categories := make(map[uint64]string)
for _, channel := range channels { for _, channel := range channels {
if channel.Type == 4 { if channel.Type == 4 {
categories[channel.ChannelId] = channel.Name categories[channel.ChannelId] = channel.Name
@ -118,7 +118,7 @@ func PanelHandler(ctx *gin.Context) {
// Get is premium // Get is premium
isPremiumChan := make(chan bool) isPremiumChan := make(chan bool)
go utils.IsPremiumGuild(store, guildIdStr, isPremiumChan) go utils.IsPremiumGuild(store, guildId, isPremiumChan)
isPremium := <-isPremiumChan isPremium := <-isPremiumChan
ctx.HTML(200, "manage/panels", gin.H{ ctx.HTML(200, "manage/panels", gin.H{

2
app/http/endpoints/manage/sendmessage.go
View File

@ -30,7 +30,7 @@ func SendMessage(ctx *gin.Context) {
// Verify the guild exists // Verify the guild exists
guildIdStr := ctx.Param("id") guildIdStr := ctx.Param("id")
guildId, err := strconv.ParseInt(guildIdStr, 10, 64) guildId, err := strconv.ParseUint(guildIdStr, 10, 64)
if err != nil { if err != nil {
ctx.Redirect(302, config.Conf.Server.BaseUrl) // TODO: 404 Page ctx.Redirect(302, config.Conf.Server.BaseUrl) // TODO: 404 Page
return return

2
app/http/endpoints/manage/settings.go
View File

@ -29,7 +29,7 @@ func SettingsHandler(ctx *gin.Context) {
// Verify the guild exists // Verify the guild exists
guildIdStr := ctx.Param("id") guildIdStr := ctx.Param("id")
guildId, err := strconv.ParseInt(guildIdStr, 10, 64) guildId, err := strconv.ParseUint(guildIdStr, 10, 64)
if err != nil { if err != nil {
ctx.Redirect(302, config.Conf.Server.BaseUrl) // TODO: 404 Page ctx.Redirect(302, config.Conf.Server.BaseUrl) // TODO: 404 Page
return return

2
app/http/endpoints/manage/ticketclose.go
View File

@ -29,7 +29,7 @@ func TicketCloseHandler(ctx *gin.Context) {
// Verify the guild exists // Verify the guild exists
guildIdStr := ctx.Param("id") guildIdStr := ctx.Param("id")
guildId, err := strconv.ParseInt(guildIdStr, 10, 64) guildId, err := strconv.ParseUint(guildIdStr, 10, 64)
if err != nil { if err != nil {
ctx.Redirect(302, config.Conf.Server.BaseUrl) // TODO: 404 Page ctx.Redirect(302, config.Conf.Server.BaseUrl) // TODO: 404 Page
return return

10
app/http/endpoints/manage/ticketlist.go
View File

@ -28,7 +28,7 @@ func TicketListHandler(ctx *gin.Context) {
// Verify the guild exists // Verify the guild exists
guildIdStr := ctx.Param("id") guildIdStr := ctx.Param("id")
guildId, err := strconv.ParseInt(guildIdStr, 10, 64) guildId, err := strconv.ParseUint(guildIdStr, 10, 64)
if err != nil { if err != nil {
ctx.Redirect(302, config.Conf.Server.BaseUrl) // TODO: 404 Page ctx.Redirect(302, config.Conf.Server.BaseUrl) // TODO: 404 Page
return return
@ -53,18 +53,18 @@ func TicketListHandler(ctx *gin.Context) {
tickets := table.GetOpenTickets(guildId) tickets := table.GetOpenTickets(guildId)
var toFetch []int64 var toFetch []uint64
for _, ticket := range tickets { for _, ticket := range tickets {
toFetch = append(toFetch, ticket.Owner) toFetch = append(toFetch, ticket.Owner)
for _, idStr := range strings.Split(ticket.Members, ",") { for _, idStr := range strings.Split(ticket.Members, ",") {
if memberId, err := strconv.ParseInt(idStr, 10, 64); err == nil { if memberId, err := strconv.ParseUint(idStr, 10, 64); err == nil {
toFetch = append(toFetch, memberId) toFetch = append(toFetch, memberId)
} }
} }
} }
nodes := make(map[int64]table.UsernameNode) nodes := make(map[uint64]table.UsernameNode)
for _, node := range table.GetUserNodes(toFetch) { for _, node := range table.GetUserNodes(toFetch) {
nodes[node.Id] = node nodes[node.Id] = node
} }
@ -74,7 +74,7 @@ func TicketListHandler(ctx *gin.Context) {
for _, ticket := range tickets { for _, ticket := range tickets {
var membersFormatted []map[string]interface{} var membersFormatted []map[string]interface{}
for index, memberIdStr := range strings.Split(ticket.Members, ",") { for index, memberIdStr := range strings.Split(ticket.Members, ",") {
if memberId, err := strconv.ParseInt(memberIdStr, 10, 64); err == nil { if memberId, err := strconv.ParseUint(memberIdStr, 10, 64); err == nil {
if memberId != 0 { if memberId != 0 {
var separator string var separator string
if index != len(strings.Split(ticket.Members, ",")) - 1 { if index != len(strings.Split(ticket.Members, ",")) - 1 {

6
app/http/endpoints/manage/ticketview.go
View File

@ -33,7 +33,7 @@ func TicketViewHandler(ctx *gin.Context) {
// Verify the guild exists // Verify the guild exists
guildIdStr := ctx.Param("id") guildIdStr := ctx.Param("id")
guildId, err := strconv.ParseInt(guildIdStr, 10, 64) guildId, err := strconv.ParseUint(guildIdStr, 10, 64)
if err != nil { if err != nil {
ctx.Redirect(302, config.Conf.Server.BaseUrl) // TODO: 404 Page ctx.Redirect(302, config.Conf.Server.BaseUrl) // TODO: 404 Page
return return
@ -96,7 +96,7 @@ func TicketViewHandler(ctx *gin.Context) {
match := MentionRegex.FindAllStringSubmatch(content, -1) match := MentionRegex.FindAllStringSubmatch(content, -1)
for _, mention := range match { for _, mention := range match {
if len(mention) >= 2 { if len(mention) >= 2 {
mentionedId, err := strconv.ParseInt(mention[1], 10, 64); if err != nil { mentionedId, err := strconv.ParseUint(mention[1], 10, 64); if err != nil {
continue continue
} }
@ -113,7 +113,7 @@ func TicketViewHandler(ctx *gin.Context) {
} }
premium := make(chan bool) premium := make(chan bool)
go utils.IsPremiumGuild(store, guildIdStr, premium) go utils.IsPremiumGuild(store, guildId, premium)
ctx.HTML(200, "manage/ticketview", gin.H{ ctx.HTML(200, "manage/ticketview", gin.H{
"name": store.Get("name").(string), "name": store.Get("name").(string),

8
app/http/endpoints/manage/updatesettings.go
View File

@ -28,7 +28,7 @@ func UpdateSettingsHandler(ctx *gin.Context) {
// Verify the guild exists // Verify the guild exists
guildIdStr := ctx.Param("id") guildIdStr := ctx.Param("id")
guildId, err := strconv.ParseInt(guildIdStr, 10, 64) guildId, err := strconv.ParseUint(guildIdStr, 10, 64)
if err != nil { if err != nil {
ctx.Redirect(302, config.Conf.Server.BaseUrl) // TODO: 404 Page ctx.Redirect(302, config.Conf.Server.BaseUrl) // TODO: 404 Page
return return
@ -108,7 +108,7 @@ func UpdateSettingsHandler(ctx *gin.Context) {
categoryStr := ctx.PostForm("category") categoryStr := ctx.PostForm("category")
if utils.Contains(categoryIds, categoryStr) { if utils.Contains(categoryIds, categoryStr) {
// Error is impossible, as we check it's a valid channel already // Error is impossible, as we check it's a valid channel already
category, _ := strconv.ParseInt(categoryStr, 10, 64) category, _ := strconv.ParseUint(categoryStr, 10, 64)
table.UpdateChannelCategory(guildId, category) table.UpdateChannelCategory(guildId, category)
} }
@ -118,14 +118,14 @@ func UpdateSettingsHandler(ctx *gin.Context) {
go table.GetCachedChannelsByGuild(guildId, channelsChan) go table.GetCachedChannelsByGuild(guildId, channelsChan)
channels := <-channelsChan channels := <-channelsChan
var channelIds []int64 var channelIds []uint64
for _, channel := range channels { for _, channel := range channels {
channelIds = append(channelIds, channel.ChannelId) channelIds = append(channelIds, channel.ChannelId)
} }
// Update or archive channel // Update or archive channel
archiveChannelStr := ctx.PostForm("archivechannel") archiveChannelStr := ctx.PostForm("archivechannel")
archiveChannelId, err := strconv.ParseInt(archiveChannelStr, 10, 64) archiveChannelId, err := strconv.ParseUint(archiveChannelStr, 10, 64)
if err == nil && utils.Contains(channelIds, archiveChannelId) { if err == nil && utils.Contains(channelIds, archiveChannelId) {
table.UpdateArchiveChannel(guildId, archiveChannelId) table.UpdateArchiveChannel(guildId, archiveChannelId)
} }

2
app/http/endpoints/manage/viewlog.go
View File

@ -31,7 +31,7 @@ func LogViewHandler(ctx *gin.Context) {
// Verify the guild exists // Verify the guild exists
guildIdStr := ctx.Param("id") guildIdStr := ctx.Param("id")
guildId, err := strconv.ParseInt(guildIdStr, 10, 64) guildId, err := strconv.ParseUint(guildIdStr, 10, 64)
if err != nil { if err != nil {
ctx.Redirect(302, config.Conf.Server.BaseUrl) // TODO: 404 Page ctx.Redirect(302, config.Conf.Server.BaseUrl) // TODO: 404 Page
return return

6
app/http/endpoints/manage/webchatws.go
View File

@ -93,7 +93,7 @@ func WebChatWs(ctx *gin.Context) {
} }
var guildId string var guildId string
var guildIdParsed int64 var guildIdParsed uint64
var ticket int var ticket int
for { for {
@ -119,7 +119,7 @@ func WebChatWs(ctx *gin.Context) {
socket.Ticket = ticket socket.Ticket = ticket
// Verify the guild exists // Verify the guild exists
guildIdParsed, err = strconv.ParseInt(guildId, 10, 64) guildIdParsed, err = strconv.ParseUint(guildId, 10, 64)
if err != nil { if err != nil {
fmt.Println(err.Error()) fmt.Println(err.Error())
conn.Close() conn.Close()
@ -146,7 +146,7 @@ func WebChatWs(ctx *gin.Context) {
// Verify the guild is premium // Verify the guild is premium
premium := make(chan bool) premium := make(chan bool)
go utils.IsPremiumGuild(store, guildId, premium) go utils.IsPremiumGuild(store, guildIdParsed, premium)
if !<-premium { if !<-premium {
conn.Close() conn.Close()
return return

6
app/http/endpoints/root/callback.go
View File

@ -83,7 +83,7 @@ func CallbackHandler(ctx *gin.Context) {
ctx.Redirect(302, config.Conf.Server.BaseUrl) ctx.Redirect(302, config.Conf.Server.BaseUrl)
userId, err := strconv.ParseInt(currentUser.Id, 10, 64); if err != nil { // ??? userId, err := strconv.ParseUint(currentUser.Id, 10, 64); if err != nil { // ???
return return
} }
@ -100,7 +100,7 @@ func CallbackHandler(ctx *gin.Context) {
go cache.Client.StoreGuild(guild) go cache.Client.StoreGuild(guild)
// cache roles // cache roles
guildId, err := strconv.ParseInt(guild.Id, 10, 64); if err != nil { guildId, err := strconv.ParseUint(guild.Id, 10, 64); if err != nil {
continue continue
} }
go cacheRoles(store, guildId, userId) go cacheRoles(store, guildId, userId)
@ -116,7 +116,7 @@ func CallbackHandler(ctx *gin.Context) {
}() }()
} }
func cacheRoles(store sessions.Session, guildId, userId int64) { func cacheRoles(store sessions.Session, guildId, userId uint64) {
roles := utils.GetRolesRest(store, guildId, userId) roles := utils.GetRolesRest(store, guildId, userId)
if roles == nil { if roles == nil {

2
app/http/endpoints/root/index.go
View File

@ -28,7 +28,7 @@ func IndexHandler(ctx *gin.Context) {
userGuilds := table.GetGuilds(userIdStr) userGuilds := table.GetGuilds(userIdStr)
adminGuilds := make([]objects.Guild, 0) adminGuilds := make([]objects.Guild, 0)
for _, guild := range userGuilds { for _, guild := range userGuilds {
guildId, err := strconv.ParseInt(guild.Id, 10, 64) guildId, err := strconv.ParseUint(guild.Id, 10, 64)
if err != nil { // I think this happens when a server was deleted? We should just skip though. if err != nil { // I think this happens when a server was deleted? We should just skip though.
continue continue
} }

4
cache/ticketclose.go vendored
View File

@ -7,11 +7,11 @@ import (
type TicketCloseMessage struct { type TicketCloseMessage struct {
Uuid string Uuid string
User int64 User uint64
Reason string Reason string
} }
func (c *RedisClient) PublishTicketClose(ticket string, userId int64, reason string) { func (c *RedisClient) PublishTicketClose(ticket string, userId uint64, reason string) {
settings := TicketCloseMessage{ settings := TicketCloseMessage{
Uuid: ticket, Uuid: ticket,
User: userId, User: userId,

8
database/table/archivechannel.go
View File

@ -5,20 +5,20 @@ import (
) )
type ArchiveChannel struct { type ArchiveChannel struct {
Guild int64 `gorm:"column:GUILDID"` Guild uint64 `gorm:"column:GUILDID"`
Channel int64 `gorm:"column:CHANNELID"` Channel uint64 `gorm:"column:CHANNELID"`
} }
func (ArchiveChannel) TableName() string { func (ArchiveChannel) TableName() string {
return "archivechannel" return "archivechannel"
} }
func UpdateArchiveChannel(guildId int64, channelId int64) { func UpdateArchiveChannel(guildId uint64, channelId uint64) {
var channel ArchiveChannel var channel ArchiveChannel
database.Database.Where(ArchiveChannel{Guild: guildId}).Assign(ArchiveChannel{Channel: channelId}).FirstOrCreate(&channel) database.Database.Where(ArchiveChannel{Guild: guildId}).Assign(ArchiveChannel{Channel: channelId}).FirstOrCreate(&channel)
} }
func GetArchiveChannel(guildId int64) int64 { func GetArchiveChannel(guildId uint64) uint64 {
var channel ArchiveChannel var channel ArchiveChannel
database.Database.Where(&ArchiveChannel{Guild: guildId}).First(&channel) database.Database.Where(&ArchiveChannel{Guild: guildId}).First(&channel)

12
database/table/blacklist.go
View File

@ -6,31 +6,31 @@ import (
type BlacklistNode struct { type BlacklistNode struct {
Assoc int `gorm:"column:ASSOCID;type:int;primary_key;auto_increment"` Assoc int `gorm:"column:ASSOCID;type:int;primary_key;auto_increment"`
Guild int64 `gorm:"column:GUILDID"` Guild uint64 `gorm:"column:GUILDID"`
User int64 `gorm:"column:USERID"` User uint64 `gorm:"column:USERID"`
} }
func (BlacklistNode) TableName() string { func (BlacklistNode) TableName() string {
return "blacklist" return "blacklist"
} }
func IsBlacklisted(guildId, userId int64) bool { func IsBlacklisted(guildId, userId uint64) bool {
var count int var count int
database.Database.Table("blacklist").Where(&BlacklistNode{Guild: guildId, User: userId}).Count(&count) database.Database.Table("blacklist").Where(&BlacklistNode{Guild: guildId, User: userId}).Count(&count)
return count > 0 return count > 0
} }
func AddBlacklist(guildId, userId int64) { func AddBlacklist(guildId, userId uint64) {
database.Database.Create(&BlacklistNode{Guild: guildId, User: userId}) database.Database.Create(&BlacklistNode{Guild: guildId, User: userId})
} }
func RemoveBlacklist(guildId, userId int64) { func RemoveBlacklist(guildId, userId uint64) {
var node BlacklistNode var node BlacklistNode
database.Database.Where(BlacklistNode{Guild: guildId, User: userId}).Take(&node) database.Database.Where(BlacklistNode{Guild: guildId, User: userId}).Take(&node)
database.Database.Delete(&node) database.Database.Delete(&node)
} }
func GetBlacklistNodes(guildId int64) []BlacklistNode { func GetBlacklistNodes(guildId uint64) []BlacklistNode {
var nodes []BlacklistNode var nodes []BlacklistNode
database.Database.Where(&BlacklistNode{Guild: guildId}).Find(&nodes) database.Database.Where(&BlacklistNode{Guild: guildId}).Find(&nodes)
return nodes return nodes

8
database/table/channelcategory.go
View File

@ -5,19 +5,19 @@ import (
) )
type ChannelCategory struct { type ChannelCategory struct {
GuildId int64 `gorm:"column:GUILDID"` GuildId uint64 `gorm:"column:GUILDID"`
Category int64 `gorm:"column:CATEGORYID"` Category uint64 `gorm:"column:CATEGORYID"`
} }
func (ChannelCategory) TableName() string { func (ChannelCategory) TableName() string {
return "channelcategory" return "channelcategory"
} }
func UpdateChannelCategory(guildId int64, categoryId int64) { func UpdateChannelCategory(guildId uint64, categoryId uint64) {
database.Database.Where(&ChannelCategory{GuildId: guildId}).Assign(&ChannelCategory{Category: categoryId}).FirstOrCreate(&ChannelCategory{}) database.Database.Where(&ChannelCategory{GuildId: guildId}).Assign(&ChannelCategory{Category: categoryId}).FirstOrCreate(&ChannelCategory{})
} }
func GetChannelCategory(guildId int64) int64 { func GetChannelCategory(guildId uint64) uint64 {
var category ChannelCategory var category ChannelCategory
database.Database.Where(&ChannelCategory{GuildId: guildId}).First(&category) database.Database.Where(&ChannelCategory{GuildId: guildId}).First(&category)

14
database/table/channels.go
View File

@ -5,8 +5,8 @@ import (
) )
type Channel struct { type Channel struct {
ChannelId int64 `gorm:"column:CHANNELID"` ChannelId uint64 `gorm:"column:CHANNELID"`
GuildId int64 `gorm:"column:GUILDID"` GuildId uint64 `gorm:"column:GUILDID"`
Name string `gorm:"column:NAME;type:VARCHAR(32)"` Name string `gorm:"column:NAME;type:VARCHAR(32)"`
Type int `gorm:"column:CHANNELTYPE;type:TINYINT(1)"` Type int `gorm:"column:CHANNELTYPE;type:TINYINT(1)"`
} }
@ -15,7 +15,7 @@ func (Channel) TableName() string {
return "Channel" return "Channel"
} }
func StoreChannel(channelId, guildId int64, name string, channelType int) { func StoreChannel(channelId, guildId uint64, name string, channelType int) {
channel := Channel{ channel := Channel{
ChannelId: channelId, ChannelId: channelId,
GuildId: guildId, GuildId: guildId,
@ -23,23 +23,23 @@ func StoreChannel(channelId, guildId int64, name string, channelType int) {
Type: channelType, Type: channelType,
} }
database.Database.Where(&Channel{ChannelId:channelId}).Assign(&channel).FirstOrCreate(&Channel{}) database.Database.Where(&Channel{ChannelId: channelId}).Assign(&channel).FirstOrCreate(&Channel{})
} }
func DeleteChannel(channelId int64) { func DeleteChannel(channelId uint64) {
var node Channel var node Channel
database.Database.Where(Channel{ChannelId: channelId}).Take(&node) database.Database.Where(Channel{ChannelId: channelId}).Take(&node)
database.Database.Delete(&node) database.Database.Delete(&node)
} }
func GetCachedChannelsByGuild(guildId int64, res chan []Channel) { func GetCachedChannelsByGuild(guildId uint64, res chan []Channel) {
var nodes []Channel var nodes []Channel
database.Database.Where(Channel{GuildId: guildId}).Find(&nodes) database.Database.Where(Channel{GuildId: guildId}).Find(&nodes)
res <- nodes res <- nodes
} }
// Util function ig // Util function ig
func GetCategories(guildId int64, res chan []Channel) { func GetCategories(guildId uint64, res chan []Channel) {
channelsChan := make(chan []Channel) channelsChan := make(chan []Channel)
go GetCachedChannelsByGuild(guildId, channelsChan) go GetCachedChannelsByGuild(guildId, channelsChan)
channels := <-channelsChan channels := <-channelsChan

6
database/table/namingscheme.go
View File

@ -3,7 +3,7 @@ package table
import "github.com/TicketsBot/GoPanel/database" import "github.com/TicketsBot/GoPanel/database"
type TicketNamingScheme struct { type TicketNamingScheme struct {
Guild int64 `gorm:"column:GUILDID;unique;primary_key"` Guild uint64 `gorm:"column:GUILDID;unique;primary_key"`
NamingScheme string `gorm:"column:NAMINGSCHEME;type:VARCHAR(16)"` NamingScheme string `gorm:"column:NAMINGSCHEME;type:VARCHAR(16)"`
} }
@ -20,7 +20,7 @@ func (TicketNamingScheme) TableName() string {
return "TicketNamingScheme" return "TicketNamingScheme"
} }
func GetTicketNamingScheme(guild int64, ch chan NamingScheme) { func GetTicketNamingScheme(guild uint64, ch chan NamingScheme) {
var node TicketNamingScheme var node TicketNamingScheme
database.Database.Where(TicketNamingScheme{Guild: guild}).First(&node) database.Database.Where(TicketNamingScheme{Guild: guild}).First(&node)
namingScheme := node.NamingScheme namingScheme := node.NamingScheme
@ -32,6 +32,6 @@ func GetTicketNamingScheme(guild int64, ch chan NamingScheme) {
} }
} }
func SetTicketNamingScheme(guild int64, scheme NamingScheme) { func SetTicketNamingScheme(guild uint64, scheme NamingScheme) {
database.Database.Where(&TicketNamingScheme{Guild: guild}).Assign(&TicketNamingScheme{NamingScheme: string(scheme)}).FirstOrCreate(&TicketNamingScheme{}) database.Database.Where(&TicketNamingScheme{Guild: guild}).Assign(&TicketNamingScheme{NamingScheme: string(scheme)}).FirstOrCreate(&TicketNamingScheme{})
} }

17
database/table/panels.go
View File

@ -5,14 +5,13 @@ import (
) )
type Panel struct { type Panel struct {
MessageId int64 `gorm:"column:MESSAGEID"` MessageId uint64 `gorm:"column:MESSAGEID"`
ChannelId int64 `gorm:"column:CHANNELID"` ChannelId uint64 `gorm:"column:CHANNELID"`
GuildId int64 `gorm:"column:GUILDID"` // Might be useful in the future so we store it GuildId uint64 `gorm:"column:GUILDID"` // Might be useful in the future so we store it
Title string `gorm:"column:TITLE;type:VARCHAR(255)"` Title string `gorm:"column:TITLE;type:VARCHAR(255)"`
Content string `gorm:"column:CONTENT;type:TEXT"` Content string `gorm:"column:CONTENT;type:TEXT"`
Colour int `gorm:"column:COLOUR` Colour int `gorm:"column:COLOUR`
TargetCategory int64 `gorm:"column:TARGETCATEGORY"` TargetCategory uint64 `gorm:"column:TARGETCATEGORY"`
ReactionEmote string `gorm:"column:REACTIONEMOTE;type:VARCHAR(32)"` ReactionEmote string `gorm:"column:REACTIONEMOTE;type:VARCHAR(32)"`
} }
@ -20,7 +19,7 @@ func (Panel) TableName() string {
return "panels" return "panels"
} }
func AddPanel(messageId, channelId, guildId int64, title, content string, colour int, targetCategory int64, reactionEmote string) { func AddPanel(messageId, channelId, guildId uint64, title, content string, colour int, targetCategory uint64, reactionEmote string) {
database.Database.Create(&Panel{ database.Database.Create(&Panel{
MessageId: messageId, MessageId: messageId,
ChannelId: channelId, ChannelId: channelId,
@ -34,18 +33,18 @@ func AddPanel(messageId, channelId, guildId int64, title, content string, colour
}) })
} }
func IsPanel(messageId int64, ch chan bool) { func IsPanel(messageId uint64, ch chan bool) {
var count int var count int
database.Database.Table(Panel{}.TableName()).Where(Panel{MessageId: messageId}).Count(&count) database.Database.Table(Panel{}.TableName()).Where(Panel{MessageId: messageId}).Count(&count)
ch <- count > 0 ch <- count > 0
} }
func GetPanelsByGuild(guildId int64, ch chan []Panel) { func GetPanelsByGuild(guildId uint64, ch chan []Panel) {
var panels []Panel var panels []Panel
database.Database.Where(Panel{GuildId: guildId}).Find(&panels) database.Database.Where(Panel{GuildId: guildId}).Find(&panels)
ch <- panels ch <- panels
} }
func DeletePanel(msgId int64) { func DeletePanel(msgId uint64) {
database.Database.Where(Panel{MessageId: msgId}).Delete(Panel{}) database.Database.Where(Panel{MessageId: msgId}).Delete(Panel{})
} }

12
database/table/panelsettings.go
View File

@ -5,7 +5,7 @@ import (
) )
type PanelSettings struct { type PanelSettings struct {
GuildId int64 `gorm:"column:GUILDID"` GuildId uint64 `gorm:"column:GUILDID"`
Title string `gorm:"column:TITLE;type:VARCHAR(255)"` Title string `gorm:"column:TITLE;type:VARCHAR(255)"`
Content string `gorm:"column:CONTENT;type:TEXT"` Content string `gorm:"column:CONTENT;type:TEXT"`
Colour int `gorm:"column:COLOUR` Colour int `gorm:"column:COLOUR`
@ -15,7 +15,7 @@ func (PanelSettings) TableName() string {
return "panelsettings" return "panelsettings"
} }
func UpdatePanelSettings(guildId int64, title string, content string, colour int) { func UpdatePanelSettings(guildId uint64, title string, content string, colour int) {
settings := PanelSettings{ settings := PanelSettings{
Title: title, Title: title,
Content: content, Content: content,
@ -25,7 +25,7 @@ func UpdatePanelSettings(guildId int64, title string, content string, colour int
database.Database.Where(&PanelSettings{GuildId: guildId}).Assign(&settings).FirstOrCreate(&PanelSettings{}) database.Database.Where(&PanelSettings{GuildId: guildId}).Assign(&settings).FirstOrCreate(&PanelSettings{})
} }
func UpdatePanelTitle(guildId int64, title string) { func UpdatePanelTitle(guildId uint64, title string) {
settings := PanelSettings{ settings := PanelSettings{
Title: title, Title: title,
} }
@ -33,7 +33,7 @@ func UpdatePanelTitle(guildId int64, title string) {
database.Database.Where(&PanelSettings{GuildId: guildId}).Assign(&settings).FirstOrCreate(&PanelSettings{}) database.Database.Where(&PanelSettings{GuildId: guildId}).Assign(&settings).FirstOrCreate(&PanelSettings{})
} }
func UpdatePanelContent(guildId int64, content string) { func UpdatePanelContent(guildId uint64, content string) {
settings := PanelSettings{ settings := PanelSettings{
Content: content, Content: content,
} }
@ -41,7 +41,7 @@ func UpdatePanelContent(guildId int64, content string) {
database.Database.Where(&PanelSettings{GuildId: guildId}).Assign(&settings).FirstOrCreate(&PanelSettings{}) database.Database.Where(&PanelSettings{GuildId: guildId}).Assign(&settings).FirstOrCreate(&PanelSettings{})
} }
func UpdatePanelColour(guildId int64, colour int) { func UpdatePanelColour(guildId uint64, colour int) {
settings := PanelSettings{ settings := PanelSettings{
Colour: colour, Colour: colour,
} }
@ -49,7 +49,7 @@ func UpdatePanelColour(guildId int64, colour int) {
database.Database.Where(&PanelSettings{GuildId: guildId}).Assign(&settings).FirstOrCreate(&PanelSettings{}) database.Database.Where(&PanelSettings{GuildId: guildId}).Assign(&settings).FirstOrCreate(&PanelSettings{})
} }
func GetPanelSettings(guildId int64) PanelSettings { func GetPanelSettings(guildId uint64) PanelSettings {
settings := PanelSettings{ settings := PanelSettings{
Title: "Open A Ticket", Title: "Open A Ticket",
Content: "React with :envelope_with_arrow: to open a ticket", Content: "React with :envelope_with_arrow: to open a ticket",

14
database/table/permissions.go
View File

@ -3,8 +3,8 @@ package table
import "github.com/TicketsBot/GoPanel/database" import "github.com/TicketsBot/GoPanel/database"
type PermissionNode struct { type PermissionNode struct {
GuildId int64 `gorm:"column:GUILDID"` GuildId uint64 `gorm:"column:GUILDID"`
UserId int64 `gorm:"column:USERID"` UserId uint64 `gorm:"column:USERID"`
IsSupport bool `gorm:"column:ISSUPPORT"` IsSupport bool `gorm:"column:ISSUPPORT"`
IsAdmin bool `gorm:"column:ISADMIN"` IsAdmin bool `gorm:"column:ISADMIN"`
} }
@ -13,11 +13,11 @@ func (PermissionNode) TableName() string {
return "permissions" return "permissions"
} }
func GetAdminGuilds(userId int64) []int64 { func GetAdminGuilds(userId uint64) []uint64 {
var nodes []PermissionNode var nodes []PermissionNode
database.Database.Where(&PermissionNode{UserId: userId}).Find(&nodes) database.Database.Where(&PermissionNode{UserId: userId}).Find(&nodes)
ids := make([]int64, 0) ids := make([]uint64, 0)
for _, node := range nodes { for _, node := range nodes {
ids = append(ids, node.GuildId) ids = append(ids, node.GuildId)
} }
@ -25,19 +25,19 @@ func GetAdminGuilds(userId int64) []int64 {
return ids return ids
} }
func IsSupport(guildId int64, userId int64) bool { func IsSupport(guildId uint64, userId uint64) bool {
var node PermissionNode var node PermissionNode
database.Database.Where(&PermissionNode{GuildId: guildId, UserId: userId}).Take(&node) database.Database.Where(&PermissionNode{GuildId: guildId, UserId: userId}).Take(&node)
return node.IsSupport return node.IsSupport
} }
func IsAdmin(guildId int64, userId int64) bool { func IsAdmin(guildId uint64, userId uint64) bool {
var node PermissionNode var node PermissionNode
database.Database.Where(&PermissionNode{GuildId: guildId, UserId: userId}).Take(&node) database.Database.Where(&PermissionNode{GuildId: guildId, UserId: userId}).Take(&node)
return node.IsAdmin return node.IsAdmin
} }
func IsStaff(guildId int64, userId int64) bool { func IsStaff(guildId uint64, userId uint64) bool {
var node PermissionNode var node PermissionNode
database.Database.Where(&PermissionNode{GuildId: guildId, UserId: userId}).Take(&node) database.Database.Where(&PermissionNode{GuildId: guildId, UserId: userId}).Take(&node)
return node.IsAdmin || node.IsSupport return node.IsAdmin || node.IsSupport

6
database/table/pingeveryone.go
View File

@ -5,7 +5,7 @@ import (
) )
type PingEveryone struct { type PingEveryone struct {
GuildId int64 `gorm:"column:GUILDID"` GuildId uint64 `gorm:"column:GUILDID"`
PingEveryone bool `gorm:"column:PINGEVERYONE;type:TINYINT"` PingEveryone bool `gorm:"column:PINGEVERYONE;type:TINYINT"`
} }
@ -14,7 +14,7 @@ func (PingEveryone) TableName() string {
} }
// tldr I hate gorm // tldr I hate gorm
func UpdatePingEveryone(guildId int64, pingEveryone bool) { func UpdatePingEveryone(guildId uint64, pingEveryone bool) {
var settings []PingEveryone var settings []PingEveryone
database.Database.Where(&PingEveryone{GuildId: guildId}).Find(&settings) database.Database.Where(&PingEveryone{GuildId: guildId}).Find(&settings)
@ -29,7 +29,7 @@ func UpdatePingEveryone(guildId int64, pingEveryone bool) {
//database.Database.Where(&PingEveryone{GuildId: guildId}).Assign(&updated).FirstOrCreate(&PingEveryone{}) //database.Database.Where(&PingEveryone{GuildId: guildId}).Assign(&updated).FirstOrCreate(&PingEveryone{})
} }
func GetPingEveryone(guildId int64) bool { func GetPingEveryone(guildId uint64) bool {
pingEveryone := PingEveryone{PingEveryone: true} pingEveryone := PingEveryone{PingEveryone: true}
database.Database.Where(&PingEveryone{GuildId: guildId}).First(&pingEveryone) database.Database.Where(&PingEveryone{GuildId: guildId}).First(&pingEveryone)

6
database/table/prefix.go
View File

@ -5,7 +5,7 @@ import (
) )
type Prefix struct { type Prefix struct {
GuildId int64 `gorm:"column:GUILDID"` GuildId uint64 `gorm:"column:GUILDID"`
Prefix string `gorm:"column:PREFIX;type:varchar(8)"` Prefix string `gorm:"column:PREFIX;type:varchar(8)"`
} }
@ -13,11 +13,11 @@ func (Prefix) TableName() string {
return "prefix" return "prefix"
} }
func UpdatePrefix(guildId int64, prefix string) { func UpdatePrefix(guildId uint64, prefix string) {
database.Database.Where(&Prefix{GuildId: guildId}).Assign(&Prefix{Prefix: prefix}).FirstOrCreate(&Prefix{}) database.Database.Where(&Prefix{GuildId: guildId}).Assign(&Prefix{Prefix: prefix}).FirstOrCreate(&Prefix{})
} }
func GetPrefix(guildId int64) string { func GetPrefix(guildId uint64) string {
prefix := Prefix{Prefix: "t!"} prefix := Prefix{Prefix: "t!"}
database.Database.Where(&Prefix{GuildId: guildId}).First(&prefix) database.Database.Where(&Prefix{GuildId: guildId}).First(&prefix)

22
database/table/premiumguilds.go
View File

@ -7,10 +7,10 @@ import (
) )
type PremiumGuilds struct { type PremiumGuilds struct {
Guild int64 `gorm:"column:GUILDID;unique;primary_key"` Guild uint64 `gorm:"column:GUILDID;unique;primary_key"`
Expiry int64 `gorm:"column:EXPIRY"` Expiry int64 `gorm:"column:EXPIRY"`
User int64 `gorm:"column:USERID"` User uint64 `gorm:"column:USERID"`
ActivatedBy int64 `gorm:"column:ACTIVATEDBY"` ActivatedBy uint64 `gorm:"column:ACTIVATEDBY"`
Keys string `gorm:"column:KEYSUSED"` Keys string `gorm:"column:KEYSUSED"`
} }
@ -18,7 +18,7 @@ func (PremiumGuilds) TableName() string {
return "premiumguilds" return "premiumguilds"
} }
func IsPremium(guild int64, ch chan bool) { func IsPremium(guild uint64, ch chan bool) {
var node PremiumGuilds var node PremiumGuilds
database.Database.Where(PremiumGuilds{Guild: guild}).First(&node) database.Database.Where(PremiumGuilds{Guild: guild}).First(&node)
@ -31,17 +31,17 @@ func IsPremium(guild int64, ch chan bool) {
ch <- node.Expiry > current ch <- node.Expiry > current
} }
func AddPremium(key string, guild, userId, length, activatedBy int64) { func AddPremium(key string, guild, userId uint64, length int64, activatedBy uint64) {
var expiry int64 var expiry int64
hasPrem := make(chan bool) hasPrem := make(chan bool)
go IsPremium(guild, hasPrem) go IsPremium(guild, hasPrem)
isPremium := <- hasPrem isPremium := <-hasPrem
if isPremium { if isPremium {
expiryChan := make(chan int64) expiryChan := make(chan int64)
go GetExpiry(guild, expiryChan) go GetExpiry(guild, expiryChan)
currentExpiry := <- expiryChan currentExpiry := <-expiryChan
expiry = currentExpiry + length expiry = currentExpiry + length
} else { } else {
@ -51,21 +51,21 @@ func AddPremium(key string, guild, userId, length, activatedBy int64) {
keysChan := make(chan []string) keysChan := make(chan []string)
go GetKeysUsed(guild, keysChan) go GetKeysUsed(guild, keysChan)
keys := <- keysChan keys := <-keysChan
keys = append(keys, key) keys = append(keys, key)
keysStr := strings.Join(keys,",") keysStr := strings.Join(keys, ",")
var node PremiumGuilds var node PremiumGuilds
database.Database.Where(PremiumGuilds{Guild: guild}).Assign(PremiumGuilds{Expiry: expiry, User: userId, ActivatedBy: activatedBy, Keys: keysStr}).FirstOrCreate(&node) database.Database.Where(PremiumGuilds{Guild: guild}).Assign(PremiumGuilds{Expiry: expiry, User: userId, ActivatedBy: activatedBy, Keys: keysStr}).FirstOrCreate(&node)
} }
func GetExpiry(guild int64, ch chan int64) { func GetExpiry(guild uint64, ch chan int64) {
var node PremiumGuilds var node PremiumGuilds
database.Database.Where(PremiumGuilds{Guild: guild}).First(&node) database.Database.Where(PremiumGuilds{Guild: guild}).First(&node)
ch <- node.Expiry ch <- node.Expiry
} }
func GetKeysUsed(guild int64, ch chan []string) { func GetKeysUsed(guild uint64, ch chan []string) {
var node PremiumGuilds var node PremiumGuilds
database.Database.Where(PremiumGuilds{Guild: guild}).First(&node) database.Database.Where(PremiumGuilds{Guild: guild}).First(&node)
ch <- strings.Split(node.Keys, ",") ch <- strings.Split(node.Keys, ",")

91
database/table/rolepermissions.go
View File

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

14
database/table/rolescache.go
View File

@ -6,16 +6,16 @@ import (
type CachedRole struct { type CachedRole struct {
AssociationId int `gorm:"column:ASSOCIATIONID;primary_key;auto_increment"` AssociationId int `gorm:"column:ASSOCIATIONID;primary_key;auto_increment"`
GuildId int64 `gorm:"column:GUILDID"` GuildId uint64 `gorm:"column:GUILDID"`
UserId int64 `gorm:"column:USERID"` UserId uint64 `gorm:"column:USERID"`
RoleId int64 `gorm:"column:ROLEID"` RoleId uint64 `gorm:"column:ROLEID"`
} }
func (CachedRole) TableName() string { func (CachedRole) TableName() string {
return "cache_roles" return "cache_roles"
} }
func DeleteRoles(guildId, userId int64) { func DeleteRoles(guildId, userId uint64) {
database.Database.Where(CachedRole{ database.Database.Where(CachedRole{
GuildId: guildId, GuildId: guildId,
UserId: userId, UserId: userId,
@ -23,7 +23,7 @@ func DeleteRoles(guildId, userId int64) {
} }
// TODO: Cache invalidation // TODO: Cache invalidation
func CacheRole(guildId, userId, roleId int64) { func CacheRole(guildId, userId, roleId uint64) {
database.Database.Create(&CachedRole{ database.Database.Create(&CachedRole{
GuildId: guildId, GuildId: guildId,
UserId: userId, UserId: userId,
@ -31,14 +31,14 @@ func CacheRole(guildId, userId, roleId int64) {
}) })
} }
func GetCachedRoles(guildId, userId int64, res chan []int64) { func GetCachedRoles(guildId, userId uint64, res chan []uint64) {
var rows []CachedRole var rows []CachedRole
database.Database.Where(&CachedRole{ database.Database.Where(&CachedRole{
GuildId: guildId, GuildId: guildId,
UserId: userId, UserId: userId,
}).Find(&rows) }).Find(&rows)
roles := make([]int64, 0) roles := make([]uint64, 0)
for _, row := range rows { for _, row := range rows {
roles = append(roles, row.RoleId) roles = append(roles, row.RoleId)
} }

10
database/table/ticketarchive.go
View File

@ -6,8 +6,8 @@ import (
type TicketArchive struct { type TicketArchive struct {
Uuid string `gorm:"column:UUID;type:varchar(36)"` Uuid string `gorm:"column:UUID;type:varchar(36)"`
Guild int64 `gorm:"column:GUILDID"` Guild uint64 `gorm:"column:GUILDID"`
User int64 `gorm:"column:USERID"` User uint64 `gorm:"column:USERID"`
Username string `gorm:"column:USERNAME;type:varchar(32)"` Username string `gorm:"column:USERNAME;type:varchar(32)"`
TicketId int `gorm:"column:TICKETID"` TicketId int `gorm:"column:TICKETID"`
CdnUrl string `gorm:"column:CDNURL;type:varchar(100)"` CdnUrl string `gorm:"column:CDNURL;type:varchar(100)"`
@ -17,14 +17,14 @@ func (TicketArchive) TableName() string {
return "ticketarchive" return "ticketarchive"
} }
func GetTicketArchives(guildId int64) []TicketArchive { func GetTicketArchives(guildId uint64) []TicketArchive {
var archives []TicketArchive var archives []TicketArchive
database.Database.Where(&TicketArchive{Guild: guildId}).Order("TICKETID desc").Find(&archives) database.Database.Where(&TicketArchive{Guild: guildId}).Order("TICKETID desc").Find(&archives)
return archives return archives
} }
func GetFilteredTicketArchives(guildId int64, userId int64, username string, ticketId int) []TicketArchive { func GetFilteredTicketArchives(guildId uint64, userId uint64, username string, ticketId int) []TicketArchive {
var archives []TicketArchive var archives []TicketArchive
query := database.Database.Where(&TicketArchive{Guild: guildId}) query := database.Database.Where(&TicketArchive{Guild: guildId})
@ -43,7 +43,7 @@ func GetFilteredTicketArchives(guildId int64, userId int64, username string, tic
return archives return archives
} }
func GetCdnUrl(guildId int64, uuid string) string { func GetCdnUrl(guildId uint64, uuid string) string {
var archive TicketArchive var archive TicketArchive
database.Database.Where(&TicketArchive{Guild: guildId, Uuid: uuid}).First(&archive) database.Database.Where(&TicketArchive{Guild: guildId, Uuid: uuid}).First(&archive)
return archive.CdnUrl return archive.CdnUrl

6
database/table/ticketlimit.go
View File

@ -5,7 +5,7 @@ import (
) )
type TicketLimit struct { type TicketLimit struct {
GuildId int64 `gorm:"column:GUILDID"` GuildId uint64 `gorm:"column:GUILDID"`
Limit int `gorm:"column:TICKETLIMIT"` Limit int `gorm:"column:TICKETLIMIT"`
} }
@ -13,11 +13,11 @@ func (TicketLimit) TableName() string {
return "ticketlimit" return "ticketlimit"
} }
func UpdateTicketLimit(guildId int64, limit int) { func UpdateTicketLimit(guildId uint64, limit int) {
database.Database.Where(&TicketLimit{GuildId: guildId}).Assign(&TicketLimit{Limit: limit}).FirstOrCreate(&TicketLimit{}) database.Database.Where(&TicketLimit{GuildId: guildId}).Assign(&TicketLimit{Limit: limit}).FirstOrCreate(&TicketLimit{})
} }
func GetTicketLimit(guildId int64) int { func GetTicketLimit(guildId uint64) int {
limit := TicketLimit{Limit: 5} limit := TicketLimit{Limit: 5}
database.Database.Where(&TicketLimit{GuildId: guildId}).First(&limit) database.Database.Where(&TicketLimit{GuildId: guildId}).First(&limit)

12
database/table/tickets.go
View File

@ -5,9 +5,9 @@ import "github.com/TicketsBot/GoPanel/database"
type Ticket struct { type Ticket struct {
Uuid string `gorm:"column:UUID;type:varchar(36);primary_key"` Uuid string `gorm:"column:UUID;type:varchar(36);primary_key"`
TicketId int `gorm:"column:ID"` TicketId int `gorm:"column:ID"`
Guild int64 `gorm:"column:GUILDID"` Guild uint64 `gorm:"column:GUILDID"`
Channel int64 `gorm:"column:CHANNELID"` Channel uint64 `gorm:"column:CHANNELID"`
Owner int64 `gorm:"column:OWNERID"` Owner uint64 `gorm:"column:OWNERID"`
Members string `gorm:"column:MEMBERS;type:text"` Members string `gorm:"column:MEMBERS;type:text"`
IsOpen bool `gorm:"column:OPEN"` IsOpen bool `gorm:"column:OPEN"`
OpenTime int64 `gorm:"column:OPENTIME"` OpenTime int64 `gorm:"column:OPENTIME"`
@ -17,13 +17,13 @@ func (Ticket) TableName() string {
return "tickets" return "tickets"
} }
func GetTickets(guild int64) []Ticket { func GetTickets(guild uint64) []Ticket {
var tickets []Ticket var tickets []Ticket
database.Database.Where(&Ticket{Guild: guild}).Order("ID asc").Find(&tickets) database.Database.Where(&Ticket{Guild: guild}).Order("ID asc").Find(&tickets)
return tickets return tickets
} }
func GetOpenTickets(guild int64) []Ticket { func GetOpenTickets(guild uint64) []Ticket {
var tickets []Ticket var tickets []Ticket
database.Database.Where(&Ticket{Guild: guild, IsOpen: true}).Order("ID asc").Find(&tickets) database.Database.Where(&Ticket{Guild: guild, IsOpen: true}).Order("ID asc").Find(&tickets)
return tickets return tickets
@ -35,7 +35,7 @@ func GetTicket(uuid string, ch chan Ticket) {
ch <- ticket ch <- ticket
} }
func GetTicketById(guild int64, id int, ch chan Ticket) { func GetTicketById(guild uint64, id int, ch chan Ticket) {
var ticket Ticket var ticket Ticket
database.Database.Where(&Ticket{Guild: guild, TicketId: id}).First(&ticket) database.Database.Where(&Ticket{Guild: guild, TicketId: id}).First(&ticket)
ch <- ticket ch <- ticket

8
database/table/username.go
View File

@ -5,7 +5,7 @@ import (
) )
type UsernameNode struct { type UsernameNode struct {
Id int64 `gorm:"column:USERID;primary_key"` Id uint64 `gorm:"column:USERID;primary_key"`
Name string `gorm:"column:USERNAME;type:text"` // Base 64 encoded Name string `gorm:"column:USERNAME;type:text"` // Base 64 encoded
Discriminator string `gorm:"column:DISCRIM;type:varchar(4)"` Discriminator string `gorm:"column:DISCRIM;type:varchar(4)"`
Avatar string `gorm:"column:AVATARHASH;type:varchar(100)"` Avatar string `gorm:"column:AVATARHASH;type:varchar(100)"`
@ -15,19 +15,19 @@ func (UsernameNode) TableName() string {
return "usernames" return "usernames"
} }
func GetUsername(id int64, ch chan string) { func GetUsername(id uint64, ch chan string) {
node := UsernameNode{Name: "Unknown"} node := UsernameNode{Name: "Unknown"}
database.Database.Where(&UsernameNode{Id: id}).First(&node) database.Database.Where(&UsernameNode{Id: id}).First(&node)
ch <- node.Name ch <- node.Name
} }
func GetUserNodes(ids []int64) []UsernameNode { func GetUserNodes(ids []uint64) []UsernameNode {
var nodes []UsernameNode var nodes []UsernameNode
database.Database.Where(ids).Find(&nodes) database.Database.Where(ids).Find(&nodes)
return nodes return nodes
} }
func GetUserId(name, discrim string) int64 { func GetUserId(name, discrim string) uint64 {
var node UsernameNode var node UsernameNode
database.Database.Where(&UsernameNode{Name: name, Discriminator: discrim}).First(&node) database.Database.Where(&UsernameNode{Name: name, Discriminator: discrim}).First(&node)
return node.Id return node.Id

6
database/table/userscanclose.go
View File

@ -3,7 +3,7 @@ package table
import "github.com/TicketsBot/GoPanel/database" import "github.com/TicketsBot/GoPanel/database"
type UserCanClose struct { type UserCanClose struct {
Guild int64 `gorm:"column:GUILDID;unique;primary_key"` Guild uint64 `gorm:"column:GUILDID;unique;primary_key"`
CanClose *bool `gorm:"column:CANCLOSE"` CanClose *bool `gorm:"column:CANCLOSE"`
} }
@ -11,7 +11,7 @@ func (UserCanClose) TableName() string {
return "usercanclose" return "usercanclose"
} }
func IsUserCanClose(guild int64, ch chan bool) { func IsUserCanClose(guild uint64, ch chan bool) {
var node UserCanClose var node UserCanClose
database.Database.Where(UserCanClose{Guild: guild}).First(&node) database.Database.Where(UserCanClose{Guild: guild}).First(&node)
@ -22,6 +22,6 @@ func IsUserCanClose(guild int64, ch chan bool) {
} }
} }
func SetUserCanClose(guild int64, value bool) { func SetUserCanClose(guild uint64, value bool) {
database.Database.Where(&UserCanClose{Guild: guild}).Assign(&UserCanClose{CanClose: &value}).FirstOrCreate(&UserCanClose{}) database.Database.Where(&UserCanClose{Guild: guild}).Assign(&UserCanClose{CanClose: &value}).FirstOrCreate(&UserCanClose{})
} }

6
database/table/votes.go
View File

@ -6,7 +6,7 @@ import (
) )
type Votes struct { type Votes struct {
Id int64 `gorm:"type:bigint;unique_index;primary_key"` Id uint64 `gorm:"type:bigint;unique_index;primary_key"`
VoteTime time.Time VoteTime time.Time
} }
@ -14,9 +14,9 @@ func (Votes) TableName() string {
return "votes" return "votes"
} }
func HasVoted(owner int64, ch chan bool) { func HasVoted(owner uint64, ch chan bool) {
var node Votes var node Votes
database.Database.Where(Votes{Id: owner}).First(&node) database.Database.Where(Votes{Id: owner}).First(&node)
ch <- time.Now().Sub(node.VoteTime) < 24 * time.Hour ch <- time.Now().Sub(node.VoteTime) < 24*time.Hour
} }

6
database/table/welcomemessage.go
View File

@ -5,7 +5,7 @@ import (
) )
type WelcomeMessage struct { type WelcomeMessage struct {
GuildId int64 `gorm:"column:GUILDID"` GuildId uint64 `gorm:"column:GUILDID"`
Message string `gorm:"column:MESSAGE;type:text"` Message string `gorm:"column:MESSAGE;type:text"`
} }
@ -13,11 +13,11 @@ func (WelcomeMessage) TableName() string {
return "welcomemessages" return "welcomemessages"
} }
func UpdateWelcomeMessage(guildId int64, message string) { func UpdateWelcomeMessage(guildId uint64, message string) {
database.Database.Where(&WelcomeMessage{GuildId: guildId}).Assign(&WelcomeMessage{Message: message}).FirstOrCreate(&WelcomeMessage{}) database.Database.Where(&WelcomeMessage{GuildId: guildId}).Assign(&WelcomeMessage{Message: message}).FirstOrCreate(&WelcomeMessage{})
} }
func GetWelcomeMessage(guildId int64) string { func GetWelcomeMessage(guildId uint64) string {
message := WelcomeMessage{Message: "No message specified"} message := WelcomeMessage{Message: "No message specified"}
database.Database.Where(&WelcomeMessage{GuildId: guildId}).First(&message) database.Database.Where(&WelcomeMessage{GuildId: guildId}).First(&message)

5
utils/discord/endpoints/guild/getGuildMember.go
View File

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

2
utils/discord/objects/member.go
View File

@ -5,7 +5,7 @@ import "github.com/TicketsBot/GoPanel/utils/types"
type Member struct { type Member struct {
User User User User
Nick string Nick string
Roles types.Int64StringSlice `json:"roles,string"` Roles types.UInt64StringSlice `json:"roles,string"`
JoinedAt string JoinedAt string
Deaf bool Deaf bool
Mute bool Mute bool

14
utils/permissionutils.go
View File

@ -14,7 +14,7 @@ import (
var roleCache = cache.New(time.Minute, time.Minute) var roleCache = cache.New(time.Minute, time.Minute)
func IsAdmin(guild objects.Guild, guildId, userId int64, res chan bool) { func IsAdmin(guild objects.Guild, guildId, userId uint64, res chan bool) {
if Contains(config.Conf.Admins, strconv.Itoa(int(userId))) { if Contains(config.Conf.Admins, strconv.Itoa(int(userId))) {
res <- true res <- true
} }
@ -31,12 +31,12 @@ func IsAdmin(guild objects.Guild, guildId, userId int64, res chan bool) {
res <- true res <- true
} }
userRolesChan := make(chan []int64) userRolesChan := make(chan []uint64)
go table.GetCachedRoles(guildId, userId, userRolesChan) go table.GetCachedRoles(guildId, userId, userRolesChan)
userRoles := <-userRolesChan userRoles := <-userRolesChan
adminRolesChan := make(chan []int64) adminRolesChan := make(chan []uint64)
go table.GetAdminRoles(strconv.Itoa(int(guildId)), adminRolesChan) go table.GetAdminRoles(guildId, adminRolesChan)
adminRoles := <- adminRolesChan adminRoles := <- adminRolesChan
hasAdminRole := false hasAdminRole := false
@ -56,15 +56,15 @@ func IsAdmin(guild objects.Guild, guildId, userId int64, res chan bool) {
res <- false res <- false
} }
func GetRolesRest(store sessions.Session, guildId, userId int64) *[]int64 { func GetRolesRest(store sessions.Session, guildId, userId uint64) *[]uint64 {
var member objects.Member var member objects.Member
endpoint := guild.GetGuildMember(int(guildId), int(userId)) endpoint := guild.GetGuildMember(guildId, userId)
if err, _ := endpoint.Request(store, nil, nil, &member); err != nil { if err, _ := endpoint.Request(store, nil, nil, &member); err != nil {
log.Error(err.Error()) log.Error(err.Error())
return nil return nil
} }
roles := []int64(member.Roles) roles := []uint64(member.Roles)
return &roles return &roles
} }

9
utils/premiumutils.go
View File

@ -23,17 +23,14 @@ type ProxyResponse struct {
var premiumCache = cache.New(10 * time.Minute, 10 * time.Minute) var premiumCache = cache.New(10 * time.Minute, 10 * time.Minute)
func IsPremiumGuild(store sessions.Session, guildIdRaw string, ch chan bool) { func IsPremiumGuild(store sessions.Session, guildId uint64, ch chan bool) {
guildIdRaw := strconv.FormatUint(guildId, 10)
if premium, ok := premiumCache.Get(guildIdRaw); ok { if premium, ok := premiumCache.Get(guildIdRaw); ok {
ch<-premium.(bool) ch<-premium.(bool)
return return
} }
guildId, err := strconv.ParseInt(guildIdRaw, 10, 64); if err != nil {
ch<-false
return
}
// First lookup by premium key, then votes, then patreon // First lookup by premium key, then votes, then patreon
keyLookup := make(chan bool) keyLookup := make(chan bool)
go table.IsPremium(guildId, keyLookup) go table.IsPremium(guildId, keyLookup)

4
utils/sessionutils.go
View File

@ -15,6 +15,6 @@ func IsLoggedIn(store sessions.Session) bool {
store.Get("csrf") != nil store.Get("csrf") != nil
} }
func GetUserId(store sessions.Session) (int64, error) { func GetUserId(store sessions.Session) (uint64, error) {
return strconv.ParseInt(store.Get("userid").(string), 10, 64) return strconv.ParseUint(store.Get("userid").(string), 10, 64)
} }

44
utils/types/uint64stringslice.go Normal file
View File

@ -0,0 +1,44 @@
package types
import (
"encoding/json"
"fmt"
"strconv"
"strings"
)
type UInt64StringSlice []uint64
func (slice UInt64StringSlice) MarshalJSON() ([]byte, error) {
values := make([]string, len(slice))
for i, value := range []uint64(slice) {
values[i] = fmt.Sprintf(`"%v"`, value)
}
return []byte(fmt.Sprintf("[%v]", strings.Join(values, ","))), nil
}
func (slice *UInt64StringSlice) UnmarshalJSON(b []byte) error {
// Try array of strings first.
var values []string
err := json.Unmarshal(b, &values)
if err != nil {
// Fall back to array of integers:
var values []uint64
if err := json.Unmarshal(b, &values); err != nil {
return err
}
*slice = values
return nil
}
*slice = make([]uint64, len(values))
for i, value := range values {
value, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return err
}
(*slice)[i] = value
}
return nil
}