scout_ante/dashboard
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
guildIdStr := ctx.Param("id")
guildId, err := strconv.ParseInt(guildIdStr, 10, 64)
guildId, err := strconv.ParseUint(guildIdStr, 10, 64)
if err != nil {
ctx.Redirect(302, config.Conf.Server.BaseUrl) // TODO: 404 Page
return
@ -52,7 +52,7 @@ func BlacklistHandler(ctx *gin.Context) {
blacklistedUsers := table.GetBlacklistNodes(guildId)
var blacklistedIds []int64
var blacklistedIds []uint64
for _, user := range blacklistedUsers {
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
guildIdStr := ctx.Param("id")
guildId, err := strconv.ParseInt(guildIdStr, 10, 64)
guildId, err := strconv.ParseUint(guildIdStr, 10, 64)
if err != nil {
ctx.Redirect(302, config.Conf.Server.BaseUrl) // TODO: 404 Page
return
@ -53,7 +53,7 @@ func BlacklistRemoveHandler(ctx *gin.Context) {
if ctx.Query("c") == store.Get("csrf").(string) {
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
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
guildIdStr := ctx.Param("id")
guildId, err := strconv.ParseInt(guildIdStr, 10, 64)
guildId, err := strconv.ParseUint(guildIdStr, 10, 64)
if err != nil {
ctx.Redirect(302, config.Conf.Server.BaseUrl) // TODO: 404 Page
return
@ -63,9 +63,9 @@ func LogsHandler(ctx *gin.Context) {
// Get logs
// Get user ID from URL
var filteredUserId int64
var filteredUserId uint64
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

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

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

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

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

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

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

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

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

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

@ -28,7 +28,7 @@ func TicketListHandler(ctx *gin.Context) {
// Verify the guild exists
guildIdStr := ctx.Param("id")
guildId, err := strconv.ParseInt(guildIdStr, 10, 64)
guildId, err := strconv.ParseUint(guildIdStr, 10, 64)
if err != nil {
ctx.Redirect(302, config.Conf.Server.BaseUrl) // TODO: 404 Page
return
@ -53,18 +53,18 @@ func TicketListHandler(ctx *gin.Context) {
tickets := table.GetOpenTickets(guildId)
var toFetch []int64
var toFetch []uint64
for _, ticket := range tickets {
toFetch = append(toFetch, ticket.Owner)
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)
}
}
}
nodes := make(map[int64]table.UsernameNode)
nodes := make(map[uint64]table.UsernameNode)
for _, node := range table.GetUserNodes(toFetch) {
nodes[node.Id] = node
}
@ -74,7 +74,7 @@ func TicketListHandler(ctx *gin.Context) {
for _, ticket := range tickets {
var membersFormatted []map[string]interface{}
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 {
var separator string
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
guildIdStr := ctx.Param("id")
guildId, err := strconv.ParseInt(guildIdStr, 10, 64)
guildId, err := strconv.ParseUint(guildIdStr, 10, 64)
if err != nil {
ctx.Redirect(302, config.Conf.Server.BaseUrl) // TODO: 404 Page
return
@ -96,7 +96,7 @@ func TicketViewHandler(ctx *gin.Context) {
match := MentionRegex.FindAllStringSubmatch(content, -1)
for _, mention := range match {
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
}
@ -113,7 +113,7 @@ func TicketViewHandler(ctx *gin.Context) {
}
premium := make(chan bool)
go utils.IsPremiumGuild(store, guildIdStr, premium)
go utils.IsPremiumGuild(store, guildId, premium)
ctx.HTML(200, "manage/ticketview", gin.H{
"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
guildIdStr := ctx.Param("id")
guildId, err := strconv.ParseInt(guildIdStr, 10, 64)
guildId, err := strconv.ParseUint(guildIdStr, 10, 64)
if err != nil {
ctx.Redirect(302, config.Conf.Server.BaseUrl) // TODO: 404 Page
return
@ -108,7 +108,7 @@ func UpdateSettingsHandler(ctx *gin.Context) {
categoryStr := ctx.PostForm("category")
if utils.Contains(categoryIds, categoryStr) {
// 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)
}
@ -118,14 +118,14 @@ func UpdateSettingsHandler(ctx *gin.Context) {
go table.GetCachedChannelsByGuild(guildId, channelsChan)
channels := <-channelsChan
var channelIds []int64
var channelIds []uint64
for _, channel := range channels {
channelIds = append(channelIds, channel.ChannelId)
}
// Update or archive channel
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) {
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
guildIdStr := ctx.Param("id")
guildId, err := strconv.ParseInt(guildIdStr, 10, 64)
guildId, err := strconv.ParseUint(guildIdStr, 10, 64)
if err != nil {
ctx.Redirect(302, config.Conf.Server.BaseUrl) // TODO: 404 Page
return

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

@ -93,7 +93,7 @@ func WebChatWs(ctx *gin.Context) {
}
var guildId string
var guildIdParsed int64
var guildIdParsed uint64
var ticket int
for {
@ -119,7 +119,7 @@ func WebChatWs(ctx *gin.Context) {
socket.Ticket = ticket
// Verify the guild exists
guildIdParsed, err = strconv.ParseInt(guildId, 10, 64)
guildIdParsed, err = strconv.ParseUint(guildId, 10, 64)
if err != nil {
fmt.Println(err.Error())
conn.Close()
@ -146,7 +146,7 @@ func WebChatWs(ctx *gin.Context) {
// Verify the guild is premium
premium := make(chan bool)
go utils.IsPremiumGuild(store, guildId, premium)
go utils.IsPremiumGuild(store, guildIdParsed, premium)
if !<-premium {
conn.Close()
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)
userId, err := strconv.ParseInt(currentUser.Id, 10, 64); if err != nil { // ???
userId, err := strconv.ParseUint(currentUser.Id, 10, 64); if err != nil { // ???
return
}
@ -100,7 +100,7 @@ func CallbackHandler(ctx *gin.Context) {
go cache.Client.StoreGuild(guild)
// 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
}
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)
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)
adminGuilds := make([]objects.Guild, 0)
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.
continue
}

4
cache/ticketclose.go vendored
View File

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

8
database/table/archivechannel.go
View File

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

14
database/table/blacklist.go
View File

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

8
database/table/channelcategory.go
View File

@ -5,19 +5,19 @@ import (
)
type ChannelCategory struct {
GuildId int64 `gorm:"column:GUILDID"`
Category int64 `gorm:"column:CATEGORYID"`
GuildId uint64 `gorm:"column:GUILDID"`
Category uint64 `gorm:"column:CATEGORYID"`
}
func (ChannelCategory) TableName() string {
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{})
}
func GetChannelCategory(guildId int64) int64 {
func GetChannelCategory(guildId uint64) uint64 {
var category ChannelCategory
database.Database.Where(&ChannelCategory{GuildId: guildId}).First(&category)

14
database/table/channels.go
View File

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

6
database/table/namingscheme.go
View File

@ -3,7 +3,7 @@ package table
import "github.com/TicketsBot/GoPanel/database"
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)"`
}
@ -20,7 +20,7 @@ func (TicketNamingScheme) TableName() string {
return "TicketNamingScheme"
}
func GetTicketNamingScheme(guild int64, ch chan NamingScheme) {
func GetTicketNamingScheme(guild uint64, ch chan NamingScheme) {
var node TicketNamingScheme
database.Database.Where(TicketNamingScheme{Guild: guild}).First(&node)
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{})
}

17
database/table/panels.go
View File

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

24
database/table/panelsettings.go
View File

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

18
database/table/permissions.go
View File

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

8
database/table/pingeveryone.go
View File

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

6
database/table/prefix.go
View File

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

26
database/table/premiumguilds.go
View File

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

97
database/table/rolepermissions.go
View File

@ -2,62 +2,36 @@ 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"`
GuildId uint64 `gorm:"column:GUILDID"`
RoleId uint64 `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
}
func IsSupportRole(guildId, roleId uint64, ch chan bool) {
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
}
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
}
func IsAdminRole(guildId, roleId uint64, ch chan bool) {
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
}
func GetAdminRoles(guild string, ch chan []int64) {
guildId, err := strconv.ParseInt(guild, 10, 64); if err != nil {
ch <- []int64{}
return
}
func GetAdminRoles(guildId uint64, ch chan []uint64) {
var nodes []RolePermissions
database.Database.Where(RolePermissions{GuildId: guildId, Admin: true}).Find(&nodes)
ids := make([]int64, 0)
ids := make([]uint64, 0)
for _, node := range nodes {
ids = append(ids, node.RoleId)
}
@ -65,16 +39,11 @@ func GetAdminRoles(guild string, ch chan []int64) {
ch <- ids
}
func GetSupportRoles(guild string, ch chan []int64) {
guildId, err := strconv.ParseInt(guild, 10, 64); if err != nil {
ch <- []int64{}
return
}
func GetSupportRoles(guildId uint64, ch chan []uint64) {
var nodes []RolePermissions
database.Database.Where(RolePermissions{GuildId: guildId, Support: true, Admin: false}).Find(&nodes)
ids := make([]int64, 0)
ids := make([]uint64, 0)
for _, node := range nodes {
ids = append(ids, node.RoleId)
}
@ -82,59 +51,27 @@ func GetSupportRoles(guild string, ch chan []int64) {
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
}
func AddAdminRole(guildId, roleId uint64) {
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
}
func AddSupportRole(guildId, roleId uint64) {
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
}
func RemoveAdminRole(guildId, roleId uint64) {
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
}
func RemoveSupportRole(guildId, roleId uint64) {
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,
"ISADMIN": false,
"ISSUPPORT": false,
})
}

16
database/table/rolescache.go
View File

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

10
database/table/ticketarchive.go
View File

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

8
database/table/ticketlimit.go
View File

@ -5,19 +5,19 @@ import (
)
type TicketLimit struct {
GuildId int64 `gorm:"column:GUILDID"`
Limit int `gorm:"column:TICKETLIMIT"`
GuildId uint64 `gorm:"column:GUILDID"`
Limit int `gorm:"column:TICKETLIMIT"`
}
func (TicketLimit) TableName() string {
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{})
}
func GetTicketLimit(guildId int64) int {
func GetTicketLimit(guildId uint64) int {
limit := TicketLimit{Limit: 5}
database.Database.Where(&TicketLimit{GuildId: guildId}).First(&limit)

20
database/table/tickets.go
View File

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

12
database/table/username.go
View File

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

8
database/table/userscanclose.go
View File

@ -3,15 +3,15 @@ package table
import "github.com/TicketsBot/GoPanel/database"
type UserCanClose struct {
Guild int64 `gorm:"column:GUILDID;unique;primary_key"`
CanClose *bool `gorm:"column:CANCLOSE"`
Guild uint64 `gorm:"column:GUILDID;unique;primary_key"`
CanClose *bool `gorm:"column:CANCLOSE"`
}
func (UserCanClose) TableName() string {
return "usercanclose"
}
func IsUserCanClose(guild int64, ch chan bool) {
func IsUserCanClose(guild uint64, ch chan bool) {
var node UserCanClose
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{})
}

6
database/table/votes.go
View File

@ -6,7 +6,7 @@ import (
)
type Votes struct {
Id int64 `gorm:"type:bigint;unique_index;primary_key"`
Id uint64 `gorm:"type:bigint;unique_index;primary_key"`
VoteTime time.Time
}
@ -14,9 +14,9 @@ func (Votes) TableName() string {
return "votes"
}
func HasVoted(owner int64, ch chan bool) {
func HasVoted(owner uint64, ch chan bool) {
var node Votes
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 {
GuildId int64 `gorm:"column:GUILDID"`
GuildId uint64 `gorm:"column:GUILDID"`
Message string `gorm:"column:MESSAGE;type:text"`
}
@ -13,11 +13,11 @@ func (WelcomeMessage) TableName() string {
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{})
}
func GetWelcomeMessage(guildId int64) string {
func GetWelcomeMessage(guildId uint64) string {
message := WelcomeMessage{Message: "No message specified"}
database.Database.Where(&WelcomeMessage{GuildId: guildId}).First(&message)

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

@ -3,13 +3,12 @@ package guild
import (
"fmt"
"github.com/TicketsBot/GoPanel/utils/discord"
"strconv"
)
func GetGuildMember(guildId, userId int) discord.Endpoint {
func GetGuildMember(guildId, userId uint64) discord.Endpoint {
return discord.Endpoint{
RequestType: discord.GET,
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 {
User User
Nick string
Roles types.Int64StringSlice `json:"roles,string"`
Roles types.UInt64StringSlice `json:"roles,string"`
JoinedAt string
Deaf bool
Mute bool

14
utils/permissionutils.go
View File

@ -14,7 +14,7 @@ import (
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))) {
res <- true
}
@ -31,12 +31,12 @@ func IsAdmin(guild objects.Guild, guildId, userId int64, res chan bool) {
res <- true
}
userRolesChan := make(chan []int64)
userRolesChan := make(chan []uint64)
go table.GetCachedRoles(guildId, userId, userRolesChan)
userRoles := <-userRolesChan
adminRolesChan := make(chan []int64)
go table.GetAdminRoles(strconv.Itoa(int(guildId)), adminRolesChan)
adminRolesChan := make(chan []uint64)
go table.GetAdminRoles(guildId, adminRolesChan)
adminRoles := <- adminRolesChan
hasAdminRole := false
@ -56,15 +56,15 @@ func IsAdmin(guild objects.Guild, guildId, userId int64, res chan bool) {
res <- false
}
func GetRolesRest(store sessions.Session, guildId, userId int64) *[]int64 {
func GetRolesRest(store sessions.Session, guildId, userId uint64) *[]uint64 {
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 {
log.Error(err.Error())
return nil
}
roles := []int64(member.Roles)
roles := []uint64(member.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)
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 {
ch<-premium.(bool)
return
}
guildId, err := strconv.ParseInt(guildIdRaw, 10, 64); if err != nil {
ch<-false
return
}
// First lookup by premium key, then votes, then patreon
keyLookup := make(chan bool)
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
}
func GetUserId(store sessions.Session) (int64, error) {
return strconv.ParseInt(store.Get("userid").(string), 10, 64)
func GetUserId(store sessions.Session) (uint64, error) {
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
}