Reorg and add services

internal/exts/fun.go

@@ -1,84 +0,0 @@
-package exts
-
-import (
-	"fmt"
-	"strconv"
-	"strings"
-
-	"github.com/dustinpianalto/disgoman"
-	"github.com/dustinpianalto/rpnparse"
-)
-
-func interleave(ctx disgoman.Context, args []string) {
-	if len(args) == 2 {
-		x, err := strconv.ParseInt(args[0], 10, 64)
-		if err != nil {
-			return
-		}
-		y, err := strconv.ParseInt(args[1], 10, 64)
-		if err != nil {
-			return
-		}
-		var z = int64(0)
-		for i := 0; i < 64; i++ {
-			x_masked_i := x & (1 << i)
-			y_masked_i := y & (1 << i)
-
-			z |= x_masked_i << i
-			z |= y_masked_i << (i + 1)
-		}
-		ctx.Send(fmt.Sprintf("%v", z))
-	}
-}
-
-func deinterleave(ctx disgoman.Context, args []string) {
-	if len(args) == 1 {
-		z, err := strconv.ParseInt(args[0], 10, 64)
-		if err != nil {
-			return
-		}
-		var x = int64(0)
-		var y = int64(0)
-		i := 0
-		for z > 0 {
-			x |= (z & 1) << i
-			z >>= 1
-			y |= (z & 1) << i
-			z >>= 1
-			i++
-		}
-		ctx.Send(fmt.Sprintf("(%v, %v)", x, y))
-	}
-}
-
-func generateRPNCommand(ctx disgoman.Context, args []string) {
-	rpn, err := rpnparse.GenerateRPN(args)
-	if err != nil {
-		ctx.Send(err.Error())
-		return
-	}
-	ctx.Send(rpn)
-}
-
-func parseRPNCommand(ctx disgoman.Context, args []string) {
-	res, err := rpnparse.ParseRPN(args)
-	if err != nil {
-		ctx.Send(err.Error())
-		return
-	}
-	ctx.Send(fmt.Sprintf("The result is: %v", res))
-}
-
-func solveCommand(ctx disgoman.Context, args []string) {
-	rpn, err := rpnparse.GenerateRPN(args)
-	if err != nil {
-		ctx.Send(err.Error())
-		return
-	}
-	res, err := rpnparse.ParseRPN(strings.Split(rpn, " "))
-	if err != nil {
-		ctx.Send(err.Error())
-		return
-	}
-	ctx.Send(fmt.Sprintf("The result is: %v", res))
-}

internal/exts/fun/fun.go

@@ -0,0 +1,134 @@
+package fun
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+
+	"github.com/dustinpianalto/disgoman"
+	"github.com/dustinpianalto/rpnparse"
+)
+
+var InterleaveCommand = &disgoman.Command{
+	Name:                "encode",
+	Aliases:             []string{"e"},
+	Description:         "Encode 2 numbers",
+	OwnerOnly:           false,
+	Hidden:              false,
+	RequiredPermissions: 0,
+	Invoke:              interleaveFunc,
+}
+
+func interleaveFunc(ctx disgoman.Context, args []string) {
+	if len(args) == 2 {
+		x, err := strconv.ParseInt(args[0], 10, 64)
+		if err != nil {
+			return
+		}
+		y, err := strconv.ParseInt(args[1], 10, 64)
+		if err != nil {
+			return
+		}
+		var z = int64(0)
+		for i := 0; i < 64; i++ {
+			x_masked_i := x & (1 << i)
+			y_masked_i := y & (1 << i)
+
+			z |= x_masked_i << i
+			z |= y_masked_i << (i + 1)
+		}
+		ctx.Send(fmt.Sprintf("%v", z))
+	}
+}
+
+var DeinterleaveCommand = &disgoman.Command{
+	Name:                "decode",
+	Aliases:             []string{"d"},
+	Description:         "Decode 1 number into 2",
+	OwnerOnly:           false,
+	Hidden:              false,
+	RequiredPermissions: 0,
+	Invoke:              deinterleaveFunc,
+}
+
+func deinterleaveFunc(ctx disgoman.Context, args []string) {
+	if len(args) == 1 {
+		z, err := strconv.ParseInt(args[0], 10, 64)
+		if err != nil {
+			return
+		}
+		var x = int64(0)
+		var y = int64(0)
+		i := 0
+		for z > 0 {
+			x |= (z & 1) << i
+			z >>= 1
+			y |= (z & 1) << i
+			z >>= 1
+			i++
+		}
+		ctx.Send(fmt.Sprintf("(%v, %v)", x, y))
+	}
+}
+
+var GenerateRPNCommand = &disgoman.Command{
+	Name:                "RPN",
+	Aliases:             []string{"rpn"},
+	Description:         "Convert infix to rpn",
+	OwnerOnly:           false,
+	Hidden:              false,
+	RequiredPermissions: 0,
+	Invoke:              generateRPNFunc,
+}
+
+func generateRPNFunc(ctx disgoman.Context, args []string) {
+	rpn, err := rpnparse.GenerateRPN(args)
+	if err != nil {
+		ctx.Send(err.Error())
+		return
+	}
+	ctx.Send(rpn)
+}
+
+var ParseRPNCommand = &disgoman.Command{
+	Name:                "ParseRPN",
+	Aliases:             []string{"PRPN", "prpn"},
+	Description:         "Parse RPN string and return the result",
+	OwnerOnly:           false,
+	Hidden:              false,
+	RequiredPermissions: 0,
+	Invoke:              parseRPNFunc,
+}
+
+func parseRPNFunc(ctx disgoman.Context, args []string) {
+	res, err := rpnparse.ParseRPN(args)
+	if err != nil {
+		ctx.Send(err.Error())
+		return
+	}
+	ctx.Send(fmt.Sprintf("The result is: %v", res))
+}
+
+var SolveCommand = &disgoman.Command{
+	Name:                "solve",
+	Aliases:             []string{"math", "infix"},
+	Description:         "Solve infix equation and return the result",
+	OwnerOnly:           false,
+	Hidden:              false,
+	RequiredPermissions: 0,
+	Invoke:              solveFunc,
+}
+
+func solveFunc(ctx disgoman.Context, args []string) {
+	rpn, err := rpnparse.GenerateRPN(args)
+	if err != nil {
+		ctx.Send(err.Error())
+		return
+	}
+	res, err := rpnparse.ParseRPN(strings.Split(rpn, " "))
+	if err != nil {
+		ctx.Send(err.Error())
+		return
+	}
+	ctx.Send(fmt.Sprintf("The result is: %v", res))
+}

internal/exts/guild_management/guild.go

@@ -1,4 +1,4 @@
-package exts
+package guild_management
 
 import (
 	"database/sql"
@@ -7,11 +7,21 @@ import (
 
 	"github.com/dustinpianalto/disgoman"
 	"github.com/dustinpianalto/goff/internal/postgres"
+	"github.com/dustinpianalto/goff/internal/services"
 )
 
 // Guild management commands
+var SetLoggingChannelCommand = &disgoman.Command{
+	Name:                "set-logging-channel",
+	Aliases:             []string{"slc"},
+	Description:         "Set the channel logging messages will be sent to.",
+	OwnerOnly:           false,
+	Hidden:              false,
+	RequiredPermissions: disgoman.PermissionManageServer,
+	Invoke:              setLoggingChannelFunc,
+}
 
-func loggingChannel(ctx disgoman.Context, args []string) {
+func setLoggingChannelFunc(ctx disgoman.Context, args []string) {
 	var idString string
 	if len(args) > 0 {
 		idString = args[0]
@@ -21,9 +31,18 @@ func loggingChannel(ctx disgoman.Context, args []string) {
 	} else {
 		idString = ""
 	}
-	fmt.Println(idString)
+	guild, err := services.GuildService.Guild(ctx.Guild.ID)
+	if err != nil {
+		ctx.CommandManager.ErrorChannel <- disgoman.CommandError{
+			Context: ctx,
+			Message: "Error Updating Database",
+			Error:   err,
+		}
+		return
+	}
 	if idString == "" {
-		_, err := postgres.DB.Exec("UPDATE guilds SET logging_channel='' WHERE id=$1;", ctx.Guild.ID)
+		guild.LoggingChannel = idString
+		err = services.GuildService.UpdateGuild(guild)
 		if err != nil {
 			ctx.CommandManager.ErrorChannel <- disgoman.CommandError{
 				Context: ctx,
@@ -52,7 +71,8 @@ func loggingChannel(ctx disgoman.Context, args []string) {
 		}
 		return
 	}
-	_, err = postgres.DB.Exec("UPDATE guilds SET logging_channel=$1 WHERE id=$2;", idString, ctx.Guild.ID)
+	guild.LoggingChannel = channel.ID
+	err = services.GuildService.UpdateGuild(guild)
 	if err != nil {
 		ctx.CommandManager.ErrorChannel <- disgoman.CommandError{
 			Context: ctx,
@@ -64,7 +84,17 @@ func loggingChannel(ctx disgoman.Context, args []string) {
 	_, _ = ctx.Send("Logging Channel Updated.")
 }
 
-func getLoggingChannel(ctx disgoman.Context, _ []string) {
+var GetLoggingChannelCommand = &disgoman.Command{
+	Name:                "get-logging-channel",
+	Aliases:             []string{"glc"},
+	Description:         "Gets the channel logging messages will be sent to.",
+	OwnerOnly:           false,
+	Hidden:              false,
+	RequiredPermissions: disgoman.PermissionManageServer,
+	Invoke:              getLoggingChannelFunc,
+}
+
+func getLoggingChannelFunc(ctx disgoman.Context, _ []string) {
 	var channelID string
 	row := postgres.DB.QueryRow("SELECT logging_channel FROM guilds where id=$1", ctx.Guild.ID)
 	err := row.Scan(&channelID)
@@ -95,7 +125,17 @@ func getLoggingChannel(ctx disgoman.Context, _ []string) {
 	return
 }
 
-func welcomeChannel(ctx disgoman.Context, args []string) {
+var SetWelcomeChannelCommand = &disgoman.Command{
+	Name:                "set-welcome-channel",
+	Aliases:             []string{"swc"},
+	Description:         "Set the channel welcome messages will be sent to.",
+	OwnerOnly:           false,
+	Hidden:              false,
+	RequiredPermissions: disgoman.PermissionManageServer,
+	Invoke:              setWelcomeChannelFunc,
+}
+
+func setWelcomeChannelFunc(ctx disgoman.Context, args []string) {
 	var idString string
 	if len(args) > 0 {
 		idString = args[0]
@@ -149,7 +189,17 @@ func welcomeChannel(ctx disgoman.Context, args []string) {
 	return
 }
 
-func getWelcomeChannel(ctx disgoman.Context, _ []string) {
+var GetWelcomeChannelCommand = &disgoman.Command{
+	Name:                "get-welcome-channel",
+	Aliases:             []string{"gwc"},
+	Description:         "Gets the channel welcome messages will be sent to.",
+	OwnerOnly:           false,
+	Hidden:              false,
+	RequiredPermissions: disgoman.PermissionManageServer,
+	Invoke:              getWelcomeChannelFunc,
+}
+
+func getWelcomeChannelFunc(ctx disgoman.Context, _ []string) {
 	var channelID string
 	row := postgres.DB.QueryRow("SELECT welcome_channel FROM guilds where id=$1", ctx.Guild.ID)
 	err := row.Scan(&channelID)
@@ -179,7 +229,17 @@ func getWelcomeChannel(ctx disgoman.Context, _ []string) {
 	_, _ = ctx.Send(fmt.Sprintf("The welcome channel is currently %s", channel.Mention()))
 }
 
-func addGuildCommand(ctx disgoman.Context, args []string) {
+var AddGuildCommand = &disgoman.Command{
+	Name:                "addGuild",
+	Aliases:             nil,
+	Description:         "Adds the current guild to the database",
+	OwnerOnly:           true,
+	Hidden:              false,
+	RequiredPermissions: 0,
+	Invoke:              addGuildCommandFunc,
+}
+
+func addGuildCommandFunc(ctx disgoman.Context, args []string) {
 	var guildID string
 	row := postgres.DB.QueryRow("SELECT id FROM guilds where id=$1", ctx.Guild.ID)
 	err := row.Scan(&guildID)
@@ -206,7 +266,17 @@ func addGuildCommand(ctx disgoman.Context, args []string) {
 
 }
 
-func puzzleChannel(ctx disgoman.Context, args []string) {
+var SetPuzzleChannelCommand = &disgoman.Command{
+	Name:                "set-puzzle-channel",
+	Aliases:             []string{"spc"},
+	Description:         "Set the channel puzzle messages will be sent to.",
+	OwnerOnly:           false,
+	Hidden:              false,
+	RequiredPermissions: disgoman.PermissionManageServer,
+	Invoke:              setPuzzleChannelFunc,
+}
+
+func setPuzzleChannelFunc(ctx disgoman.Context, args []string) {
 	var idString string
 	if len(args) > 0 {
 		idString = args[0]
@@ -259,7 +329,17 @@ func puzzleChannel(ctx disgoman.Context, args []string) {
 	_, _ = ctx.Send("Puzzle Channel Updated.")
 }
 
-func getPuzzleChannel(ctx disgoman.Context, _ []string) {
+var GetPuzzleChannelCommand = &disgoman.Command{
+	Name:                "get-puzzle-channel",
+	Aliases:             []string{"gpc"},
+	Description:         "Gets the channel puzzle messages will be sent to.",
+	OwnerOnly:           false,
+	Hidden:              false,
+	RequiredPermissions: disgoman.PermissionManageServer,
+	Invoke:              getPuzzleChannelFunc,
+}
+
+func getPuzzleChannelFunc(ctx disgoman.Context, _ []string) {
 	var channelID string
 	row := postgres.DB.QueryRow("SELECT puzzle_channel FROM guilds where id=$1", ctx.Guild.ID)
 	err := row.Scan(&channelID)
@@ -290,7 +370,17 @@ func getPuzzleChannel(ctx disgoman.Context, _ []string) {
 	return
 }
 
-func puzzleRole(ctx disgoman.Context, args []string) {
+var SetPuzzleRoleCommand = &disgoman.Command{
+	Name:                "set-puzzle-role",
+	Aliases:             []string{"spr"},
+	Description:         "Set the role to be pinged when there is a new puzzle",
+	OwnerOnly:           false,
+	Hidden:              false,
+	RequiredPermissions: disgoman.PermissionManageServer,
+	Invoke:              setPuzzleRoleFunc,
+}
+
+func setPuzzleRoleFunc(ctx disgoman.Context, args []string) {
 	var idString string
 	if len(args) > 0 {
 		idString = args[0]
@@ -344,7 +434,17 @@ func puzzleRole(ctx disgoman.Context, args []string) {
 	_, _ = ctx.Send("Puzzle Role Updated.")
 }
 
-func getPuzzleRole(ctx disgoman.Context, _ []string) {
+var GetPuzzleRoleCommand = &disgoman.Command{
+	Name:                "get-puzzle-role",
+	Aliases:             []string{"gpr"},
+	Description:         "Get the role that will be pinged when there is a new puzzle",
+	OwnerOnly:           false,
+	Hidden:              false,
+	RequiredPermissions: disgoman.PermissionManageServer,
+	Invoke:              getPuzzleRoleFunc,
+}
+
+func getPuzzleRoleFunc(ctx disgoman.Context, _ []string) {
 	var roleID sql.NullString
 	row := postgres.DB.QueryRow("SELECT puzzle_role FROM guilds where id=$1", ctx.Guild.ID)
 	err := row.Scan(&roleID)

internal/exts/guild_management/message_events.go

@@ -0,0 +1,97 @@
+package guild_management
+
+import (
+	"fmt"
+	"log"
+
+	"github.com/bwmarrin/discordgo"
+	"github.com/dustinpianalto/goff/internal/postgres"
+)
+
+func OnMessageUpdate(session *discordgo.Session, m *discordgo.MessageUpdate) {
+	defer func() {
+		if r := recover(); r != nil {
+			log.Println("Recovered from panic in OnMessageUpdate", r)
+		}
+	}()
+	msg := m.BeforeUpdate
+	if msg.Author.Bot {
+		return
+	}
+	var channelID string
+	row := postgres.DB.QueryRow("SELECT logging_channel FROM guilds where id=$1", msg.GuildID)
+	err := row.Scan(&channelID)
+	if err != nil || channelID == "" {
+		return
+	}
+	channel, err := session.State.Channel(msg.ChannelID)
+	if err != nil {
+		log.Println(err)
+		return
+	}
+	embed := &discordgo.MessageEmbed{
+		Title:       fmt.Sprintf("Message Edited: %v", msg.ID),
+		Description: fmt.Sprintf("**Before:** %v\n**After:** %v\nIn Channel: %v", msg.Content, m.Content, channel.Mention()),
+		Color:       session.State.UserColor(msg.Author.ID, channelID),
+		Footer: &discordgo.MessageEmbedFooter{
+			Text:    fmt.Sprintf("Author: %v", msg.Author.String()),
+			IconURL: msg.Author.AvatarURL(""),
+		},
+	}
+	session.ChannelMessageSendEmbed(channelID, embed)
+}
+
+func OnMessageDelete(session *discordgo.Session, m *discordgo.MessageDelete) {
+	defer func() {
+		if r := recover(); r != nil {
+			log.Println("Recovered from panic in OnMessageDelete", r)
+		}
+	}()
+	msg := m.BeforeDelete
+	if msg == nil {
+		log.Printf("Message Deleted but the original message was not in my cache so we are ignoring it.\nMessage ID: %v\nGuild ID: %v\nChannel ID: %v\n", m.ID, m.GuildID, m.ChannelID)
+		return
+	}
+	if msg.Author.Bot {
+		return
+	}
+	var channelID string
+	row := postgres.DB.QueryRow("SELECT logging_channel FROM guilds where id=$1", msg.GuildID)
+	err := row.Scan(&channelID)
+	if err != nil || channelID == "" {
+		return
+	}
+	channel, err := session.State.Channel(msg.ChannelID)
+	if err != nil {
+		log.Println(err)
+		return
+	}
+	desc := ""
+	al, err := session.GuildAuditLog(msg.GuildID, "", "", 72, 1)
+	if err != nil {
+		log.Println(err)
+	} else {
+		for _, log := range al.AuditLogEntries {
+			if log.TargetID == msg.Author.ID && log.Options.ChannelID == msg.ChannelID {
+				user, err := session.User(log.UserID)
+				if err == nil {
+					desc = fmt.Sprintf("**Content:** %v\nIn Channel: %v\nDeleted By: %v", msg.Content, channel.Mention(), user.Mention())
+				}
+				break
+			}
+		}
+	}
+	if desc == "" {
+		desc = fmt.Sprintf("**Content:** %v\nIn Channel: %v", msg.Content, channel.Mention())
+	}
+	embed := &discordgo.MessageEmbed{
+		Title:       fmt.Sprintf("Message Deleted: %v", msg.ID),
+		Description: desc,
+		Color:       session.State.UserColor(msg.Author.ID, channelID),
+		Footer: &discordgo.MessageEmbedFooter{
+			Text:    fmt.Sprintf("Author: %v", msg.Author.String()),
+			IconURL: msg.Author.AvatarURL(""),
+		},
+	}
+	session.ChannelMessageSendEmbed(channelID, embed)
+}

internal/exts/init.go

@@ -2,10 +2,18 @@ package exts
 
 import (
 	"github.com/dustinpianalto/disgoman"
-	"github.com/dustinpianalto/goff"
+	"github.com/dustinpianalto/goff/internal/exts/fun"
+	"github.com/dustinpianalto/goff/internal/exts/guild_management"
+	"github.com/dustinpianalto/goff/internal/exts/roles"
+	"github.com/dustinpianalto/goff/internal/exts/tags"
+	"github.com/dustinpianalto/goff/internal/exts/tasks"
+	"github.com/dustinpianalto/goff/internal/exts/user_management"
+	"github.com/dustinpianalto/goff/internal/exts/utils"
+
+	"github.com/dustinpianalto/goff/internal/exts/p_interpreter"
 )
 
-func AddCommandHandlers(h *goff.CommandManager) {
+func AddCommandHandlers(h *disgoman.CommandManager) {
 	// Arguments:
 	// name - command name - string
 	// desc - command description - string
@@ -14,276 +22,35 @@ func AddCommandHandlers(h *goff.CommandManager) {
 	// perms - permissisions required - anpan.Permission (int)
 	// type - command type, sets where the command is available
 	// run - function to run - func(anpan.Context, []string) / CommandRunFunc
-	_ = h.AddCommand(&disgoman.Command{
-		Name:                "ping",
-		Aliases:             []string{" "},
-		Description:         "Check the bot's ping",
-		OwnerOnly:           false,
-		Hidden:              false,
-		RequiredPermissions: 0,
-		Invoke:              pingCommand,
-	})
-	_ = h.AddCommand(&disgoman.Command{
-		Name:                "say",
-		Aliases:             nil,
-		Description:         "Repeat a message",
-		OwnerOnly:           false,
-		Hidden:              false,
-		RequiredPermissions: 0,
-		SanitizeEveryone:    true,
-		Invoke:              sayCommand,
-	})
-	_ = h.AddCommand(&disgoman.Command{
-		Name:                "user",
-		Aliases:             nil,
-		Description:         "Get user info",
-		OwnerOnly:           false,
-		Hidden:              false,
-		RequiredPermissions: 0,
-		Invoke:              userCommand,
-	})
-	_ = h.AddCommand(&disgoman.Command{
-		Name:                "git",
-		Aliases:             nil,
-		Description:         "Show my github link",
-		OwnerOnly:           false,
-		Hidden:              false,
-		RequiredPermissions: 0,
-		Invoke:              gitCommand,
-	})
-	_ = h.AddCommand(&disgoman.Command{
-		Name:                "tag",
-		Aliases:             nil,
-		Description:         "Get a tag",
-		OwnerOnly:           false,
-		Hidden:              false,
-		RequiredPermissions: 0,
-		Invoke:              tagCommand,
-	})
-	_ = h.AddCommand(&disgoman.Command{
-		Name:                "addtag",
-		Aliases:             nil,
-		Description:         "Add a tag",
-		OwnerOnly:           false,
-		Hidden:              false,
-		RequiredPermissions: 0,
-		SanitizeEveryone:    true,
-		Invoke:              addTagCommand,
-	})
-	_ = h.AddCommand(&disgoman.Command{
-		Name:                "invite",
-		Aliases:             nil,
-		Description:         "Get the invite link for this bot or others",
-		OwnerOnly:           false,
-		Hidden:              false,
-		RequiredPermissions: 0,
-		Invoke:              inviteCommand,
-	})
-	_ = h.AddCommand(&disgoman.Command{
-		Name:                "P",
-		Aliases:             nil,
-		Description:         "Interpret a P\" program and return the results",
-		OwnerOnly:           false,
-		Hidden:              false,
-		RequiredPermissions: 0,
-		Invoke:              pCommand,
-	})
-	_ = h.AddCommand(&disgoman.Command{
-		Name:                "set-logging-channel",
-		Aliases:             []string{"slc"},
-		Description:         "Set the channel logging messages will be sent to.",
-		OwnerOnly:           false,
-		Hidden:              false,
-		RequiredPermissions: disgoman.PermissionManageServer,
-		Invoke:              loggingChannel,
-	})
-	_ = h.AddCommand(&disgoman.Command{
-		Name:                "get-logging-channel",
-		Aliases:             []string{"glc"},
-		Description:         "Gets the channel logging messages will be sent to.",
-		OwnerOnly:           false,
-		Hidden:              false,
-		RequiredPermissions: disgoman.PermissionManageServer,
-		Invoke:              getLoggingChannel,
-	})
-	_ = h.AddCommand(&disgoman.Command{
-		Name:                "set-welcome-channel",
-		Aliases:             []string{"swc"},
-		Description:         "Set the channel welcome messages will be sent to.",
-		OwnerOnly:           false,
-		Hidden:              false,
-		RequiredPermissions: disgoman.PermissionManageServer,
-		Invoke:              welcomeChannel,
-	})
-	_ = h.AddCommand(&disgoman.Command{
-		Name:                "get-welcome-channel",
-		Aliases:             []string{"gwc"},
-		Description:         "Gets the channel welcome messages will be sent to.",
-		OwnerOnly:           false,
-		Hidden:              false,
-		RequiredPermissions: disgoman.PermissionManageServer,
-		Invoke:              getWelcomeChannel,
-	})
-	_ = h.AddCommand(&disgoman.Command{
-		Name:                "kick",
-		Aliases:             nil,
-		Description:         "Kicks the given user with the given reason",
-		OwnerOnly:           false,
-		Hidden:              false,
-		RequiredPermissions: disgoman.PermissionKickMembers,
-		Invoke:              kickUserCommand,
-	})
-	_ = h.AddCommand(&disgoman.Command{
-		Name:                "addGuild",
-		Aliases:             nil,
-		Description:         "Adds the current guild to the database",
-		OwnerOnly:           true,
-		Hidden:              false,
-		RequiredPermissions: disgoman.PermissionManageServer,
-		Invoke:              addGuildCommand,
-	})
-	_ = h.AddCommand(&disgoman.Command{
-		Name:                "ban",
-		Aliases:             []string{"ban-no-delete"},
-		Description:         "Bans the given user with the given reason",
-		OwnerOnly:           false,
-		Hidden:              false,
-		RequiredPermissions: disgoman.PermissionBanMembers,
-		Invoke:              banUserCommand,
-	})
-	_ = h.AddCommand(&disgoman.Command{
-		Name:                "unban",
-		Aliases:             nil,
-		Description:         "Unbans the given user",
-		OwnerOnly:           false,
-		Hidden:              false,
-		RequiredPermissions: disgoman.PermissionBanMembers,
-		Invoke:              unbanUserCommand,
-	})
-	_ = h.AddCommand(&disgoman.Command{
-		Name:                "remind",
-		Aliases:             nil,
-		Description:         "Remind me at a later time",
-		OwnerOnly:           false,
-		Hidden:              false,
-		RequiredPermissions: 0,
-		Invoke:              addReminderCommand,
-	})
-	_ = h.AddCommand(&disgoman.Command{
-		Name:                "encode",
-		Aliases:             []string{"e"},
-		Description:         "Encode 2 numbers",
-		OwnerOnly:           false,
-		Hidden:              false,
-		RequiredPermissions: 0,
-		Invoke:              interleave,
-	})
-	_ = h.AddCommand(&disgoman.Command{
-		Name:                "decode",
-		Aliases:             []string{"d"},
-		Description:         "Decode 1 number into 2",
-		OwnerOnly:           false,
-		Hidden:              false,
-		RequiredPermissions: 0,
-		Invoke:              deinterleave,
-	})
-	_ = h.AddCommand(&disgoman.Command{
-		Name:                "set-puzzle-channel",
-		Aliases:             []string{"spc"},
-		Description:         "Set the channel puzzle messages will be sent to.",
-		OwnerOnly:           false,
-		Hidden:              false,
-		RequiredPermissions: disgoman.PermissionManageServer,
-		Invoke:              puzzleChannel,
-	})
-	_ = h.AddCommand(&disgoman.Command{
-		Name:                "get-puzzle-channel",
-		Aliases:             []string{"gpc"},
-		Description:         "Gets the channel puzzle messages will be sent to.",
-		OwnerOnly:           false,
-		Hidden:              false,
-		RequiredPermissions: disgoman.PermissionManageServer,
-		Invoke:              getPuzzleChannel,
-	})
-	_ = h.AddCommand(&disgoman.Command{
-		Name:                "set-puzzle-role",
-		Aliases:             []string{"spr"},
-		Description:         "Set the role to be pinged when there is a new puzzle",
-		OwnerOnly:           false,
-		Hidden:              false,
-		RequiredPermissions: disgoman.PermissionManageServer,
-		Invoke:              puzzleRole,
-	})
-	_ = h.AddCommand(&disgoman.Command{
-		Name:                "get-puzzle-role",
-		Aliases:             []string{"gpr"},
-		Description:         "Get the role that will be pinged when there is a new puzzle",
-		OwnerOnly:           false,
-		Hidden:              false,
-		RequiredPermissions: disgoman.PermissionManageServer,
-		Invoke:              getPuzzleRole,
-	})
-	_ = h.AddCommand(&disgoman.Command{
-		Name:                "RPN",
-		Aliases:             []string{"rpn"},
-		Description:         "Convert infix to rpn",
-		OwnerOnly:           false,
-		Hidden:              false,
-		RequiredPermissions: 0,
-		Invoke:              generateRPNCommand,
-	})
-	_ = h.AddCommand(&disgoman.Command{
-		Name:                "ParseRPN",
-		Aliases:             []string{"PRPN", "prpn"},
-		Description:         "Parse RPN string and return the result",
-		OwnerOnly:           false,
-		Hidden:              false,
-		RequiredPermissions: 0,
-		Invoke:              parseRPNCommand,
-	})
-	_ = h.AddCommand(&disgoman.Command{
-		Name:                "solve",
-		Aliases:             []string{"math", "infix"},
-		Description:         "Solve infix equation and return the result",
-		OwnerOnly:           false,
-		Hidden:              false,
-		RequiredPermissions: 0,
-		Invoke:              solveCommand,
-	})
-	_ = h.AddCommand(&disgoman.Command{
-		Name:                "make-role-self-assignable",
-		Aliases:             []string{"makesar"},
-		Description:         "Makes the passed in role self assignable by anyone",
-		OwnerOnly:           false,
-		Hidden:              false,
-		RequiredPermissions: disgoman.PermissionManageServer,
-		Invoke:              makeRoleSelfAssignable,
-	})
-	_ = h.AddCommand(&disgoman.Command{
-		Name:                "remove-self-assignable-role",
-		Aliases:             []string{"removesar"},
-		Description:         "Makes a role that was previously self assignable not so",
-		OwnerOnly:           false,
-		Hidden:              false,
-		RequiredPermissions: disgoman.PermissionManageServer,
-		Invoke:              removeSelfAssignableRole,
-	})
-	_ = h.AddCommand(&disgoman.Command{
-		Name:                "giverole",
-		Aliases:             []string{"iwant", "givetome"},
-		Description:         "Assigns a person the passed in role if it is self assignable",
-		OwnerOnly:           false,
-		Hidden:              false,
-		RequiredPermissions: 0,
-		Invoke:              selfAssignRole,
-	})
-	_ = h.AddCommand(&disgoman.Command{
-		Name:                "removerole",
-		Aliases:             []string{"idon'twant"},
-		Description:         "Removes a role from a person if the role is self assignable",
-		OwnerOnly:           false,
-		Hidden:              false,
-		RequiredPermissions: 0,
-		Invoke:              unAssignRole,
-	})
+	_ = h.AddCommand(utils.UserCommand)
+	_ = h.AddCommand(utils.SayCommand)
+	_ = h.AddCommand(utils.GitCommand)
+	_ = h.AddCommand(utils.InviteCommand)
+	_ = h.AddCommand(utils.PingCommand)
+	_ = h.AddCommand(tasks.AddReminderCommand)
+	_ = h.AddCommand(tags.AddTagCommand)
+	_ = h.AddCommand(tags.TagCommand)
+	_ = h.AddCommand(roles.MakeRoleSelfAssignableCommand)
+	_ = h.AddCommand(roles.RemoveSelfAssignableCommand)
+	_ = h.AddCommand(roles.SelfAssignRoleCommand)
+	_ = h.AddCommand(roles.UnAssignRoleCommand)
+	_ = h.AddCommand(p_interpreter.PCommand)
+	_ = h.AddCommand(fun.InterleaveCommand)
+	_ = h.AddCommand(fun.DeinterleaveCommand)
+	_ = h.AddCommand(fun.GenerateRPNCommand)
+	_ = h.AddCommand(fun.ParseRPNCommand)
+	_ = h.AddCommand(fun.SolveCommand)
+	_ = h.AddCommand(user_management.KickUserCommand)
+	_ = h.AddCommand(user_management.BanUserCommand)
+	_ = h.AddCommand(user_management.UnbanUserCommand)
+	_ = h.AddCommand(guild_management.SetLoggingChannelCommand)
+	_ = h.AddCommand(guild_management.GetLoggingChannelCommand)
+	_ = h.AddCommand(guild_management.SetWelcomeChannelCommand)
+	_ = h.AddCommand(guild_management.GetWelcomeChannelCommand)
+	_ = h.AddCommand(guild_management.AddGuildCommand)
+	_ = h.AddCommand(guild_management.SetPuzzleChannelCommand)
+	_ = h.AddCommand(guild_management.GetPuzzleChannelCommand)
+	_ = h.AddCommand(guild_management.SetPuzzleRoleCommand)
+	_ = h.AddCommand(guild_management.GetPuzzleRoleCommand)
+
 }

internal/exts/logging/logging.go

@@ -0,0 +1,36 @@
+package logging
+
+import (
+	"fmt"
+
+	"github.com/bwmarrin/discordgo"
+	"github.com/dustinpianalto/goff/internal/postgres"
+)
+
+var LoggingChannel = make(chan *LogEvent, 10)
+
+type LogEvent struct {
+	// Embed with log message
+	Embed discordgo.MessageEmbed
+	// Guild to log event in
+	GuildID string
+	// Discordgo Session. Needed for sending messages
+	Session *discordgo.Session
+}
+
+func LoggingHandler(lc chan *LogEvent) {
+	for event := range lc {
+		var channelID string
+		row := postgres.DB.QueryRow("SELECT logging_channel FROM guilds where id=$1", event.GuildID)
+		err := row.Scan(&channelID)
+		if err != nil {
+			fmt.Println(err)
+			return
+		}
+		if channelID == "" {
+			return
+		}
+
+		_, _ = event.Session.ChannelMessageSendEmbed(channelID, &event.Embed)
+	}
+}

internal/exts/p_interpreter/P_interpreter.go

@@ -1,4 +1,4 @@
-package exts
+package p_interpreter
 
 import (
 	"errors"
@@ -8,7 +8,17 @@ import (
 	"github.com/dustinpianalto/disgoman"
 )
 
-func pCommand(ctx disgoman.Context, args []string) {
+var PCommand = &disgoman.Command{
+	Name:                "P",
+	Aliases:             nil,
+	Description:         "Interpret a P\" program and return the results",
+	OwnerOnly:           false,
+	Hidden:              false,
+	RequiredPermissions: 0,
+	Invoke:              pCommandFunc,
+}
+
+func pCommandFunc(ctx disgoman.Context, args []string) {
 	input := strings.Join(args, "")
 	const LENGTH = 1999
 	var mem [LENGTH]byte

internal/exts/roles/roles.go

@@ -1,4 +1,4 @@
-package exts
+package roles
 
 import (
 	"fmt"
@@ -10,7 +10,17 @@ import (
 	"github.com/dustinpianalto/goff/internal/postgres"
 )
 
-func makeRoleSelfAssignable(ctx disgoman.Context, args []string) {
+var MakeRoleSelfAssignableCommand = &disgoman.Command{
+	Name:                "make-role-self-assignable",
+	Aliases:             []string{"makesar"},
+	Description:         "Makes the passed in role self assignable by anyone",
+	OwnerOnly:           false,
+	Hidden:              false,
+	RequiredPermissions: disgoman.PermissionManageServer,
+	Invoke:              makeRoleSelfAssignableCommandFunc,
+}
+
+func makeRoleSelfAssignableCommandFunc(ctx disgoman.Context, args []string) {
 	var roleString string
 	var roleID string
 	if len(args) > 0 {
@@ -50,7 +60,17 @@ func makeRoleSelfAssignable(ctx disgoman.Context, args []string) {
 	_, _ = ctx.Send(fmt.Sprintf("%s is now self assignable", role.Name))
 }
 
-func removeSelfAssignableRole(ctx disgoman.Context, args []string) {
+var RemoveSelfAssignableCommand = &disgoman.Command{
+	Name:                "remove-self-assignable-role",
+	Aliases:             []string{"removesar"},
+	Description:         "Makes a role that was previously self assignable not so",
+	OwnerOnly:           false,
+	Hidden:              false,
+	RequiredPermissions: disgoman.PermissionManageServer,
+	Invoke:              removeSelfAssignableRoleCommandFunc,
+}
+
+func removeSelfAssignableRoleCommandFunc(ctx disgoman.Context, args []string) {
 	var roleString string
 	var roleID string
 	if len(args) > 0 {
@@ -90,7 +110,17 @@ func removeSelfAssignableRole(ctx disgoman.Context, args []string) {
 	_, _ = ctx.Send(fmt.Sprintf("%s's self assignability has been removed.", role.Name))
 }
 
-func selfAssignRole(ctx disgoman.Context, args []string) {
+var SelfAssignRoleCommand = &disgoman.Command{
+	Name:                "giverole",
+	Aliases:             []string{"iwant", "givetome"},
+	Description:         "Assigns a person the passed in role if it is self assignable",
+	OwnerOnly:           false,
+	Hidden:              false,
+	RequiredPermissions: 0,
+	Invoke:              selfAssignRoleCommandFunc,
+}
+
+func selfAssignRoleCommandFunc(ctx disgoman.Context, args []string) {
 	var roleString string
 	var roleID string
 	if len(args) > 0 {
@@ -148,7 +178,17 @@ func selfAssignRole(ctx disgoman.Context, args []string) {
 	_, _ = ctx.Send(fmt.Sprintf("Congratulations! The %s role has been added to your... Ummm... Thing.", role.Name))
 }
 
-func unAssignRole(ctx disgoman.Context, args []string) {
+var UnAssignRoleCommand = &disgoman.Command{
+	Name:                "removerole",
+	Aliases:             []string{"idon'twant"},
+	Description:         "Removes a role from a person if the role is self assignable",
+	OwnerOnly:           false,
+	Hidden:              false,
+	RequiredPermissions: 0,
+	Invoke:              unAssignRoleCommandFunc,
+}
+
+func unAssignRoleCommandFunc(ctx disgoman.Context, args []string) {
 	var roleString string
 	var roleID string
 	if len(args) > 0 {

internal/exts/tags/tags.go

@@ -1,4 +1,4 @@
-package exts
+package tags
 
 import (
 	"errors"
@@ -10,7 +10,18 @@ import (
 	"github.com/dustinpianalto/goff/internal/postgres"
 )
 
-func addTagCommand(ctx disgoman.Context, input []string) {
+var AddTagCommand = &disgoman.Command{
+	Name:                "addtag",
+	Aliases:             nil,
+	Description:         "Add a tag",
+	OwnerOnly:           false,
+	Hidden:              false,
+	RequiredPermissions: 0,
+	SanitizeEveryone:    true,
+	Invoke:              addTagCommandFunc,
+}
+
+func addTagCommandFunc(ctx disgoman.Context, input []string) {
 	if len(input) >= 1 {
 		queryString := `SELECT tags.id, tags.tag, tags.content from tags
 		WHERE tags.guild_id = $1
@@ -75,7 +86,17 @@ func addTagCommand(ctx disgoman.Context, input []string) {
 	}
 }
 
-func tagCommand(ctx disgoman.Context, args []string) {
+var TagCommand = &disgoman.Command{
+	Name:                "tag",
+	Aliases:             nil,
+	Description:         "Get a tag",
+	OwnerOnly:           false,
+	Hidden:              false,
+	RequiredPermissions: 0,
+	Invoke:              tagCommandFunc,
+}
+
+func tagCommandFunc(ctx disgoman.Context, args []string) {
 	if len(args) >= 1 {
 		tagString := strings.Join(args, " ")
 		queryString := `SELECT tags.id, tags.tag, tags.content from tags

internal/exts/tasks/reminders.go

@@ -0,0 +1,134 @@
+package tasks
+
+import (
+	"fmt"
+	"log"
+	"time"
+
+	"github.com/bwmarrin/discordgo"
+	"github.com/dustinpianalto/goff/internal/postgres"
+)
+
+type Task struct {
+	ID           int64
+	Type         string
+	Content      string
+	GuildID      string
+	ChannelID    string
+	UserID       string
+	CreationTime time.Time
+	TriggerTime  time.Time
+}
+
+func processTask(task *Task, s *discordgo.Session) {
+	query := "SELECT completed, processing from tasks where id = $1"
+	res, err := postgres.DB.Query(query, task.ID)
+	if err != nil {
+		log.Println(err)
+		return
+	}
+	var completed bool
+	var processing bool
+	res.Next()
+	err = res.Scan(&completed, &processing)
+	if err != nil {
+		log.Println(err)
+		return
+	}
+	if completed || processing {
+		return
+	}
+	closeQuery := "Update tasks set completed = true where id = $1"
+	processQuery := "UPDATE tasks SET processing = true WHERE id = $1"
+	defer postgres.DB.Exec(closeQuery, task.ID)
+	_, err = postgres.DB.Exec(processQuery, task.ID)
+	if err != nil {
+		log.Println(err)
+		return
+	}
+	log.Println(fmt.Sprintf("Processing task %v", task.ID))
+	guild, err := s.Guild(task.GuildID)
+	if err != nil {
+		log.Print(fmt.Sprintf("Can't find guild with ID %v. Canceling task %v.", task.GuildID, task.ID))
+		return
+	}
+	channel, err := s.Channel(task.ChannelID)
+	if err != nil {
+		log.Print(fmt.Sprintf("Can't find channel with ID %v. Canceling task %v.", task.ChannelID, task.ID))
+		return
+	}
+	if channel.GuildID != guild.ID {
+		log.Print(fmt.Sprintf("The channel %v is not in guild %v. Canceling task %v.", channel.Name, guild.Name, task.ID))
+		return
+	}
+	member, err := s.GuildMember(guild.ID, task.UserID)
+	if err != nil {
+		log.Print(fmt.Sprintf("Can't find user with ID %v in guild %v. Canceling task %v.", task.UserID, guild.Name, task.ID))
+		return
+	}
+	if task.Type == "Reminder" {
+		color := s.State.UserColor(member.User.ID, channel.ID)
+		e := discordgo.MessageEmbed{
+			Title:       "REMINDER",
+			Description: task.Content,
+			Timestamp:   task.CreationTime.Format(time.RFC3339),
+			Color:       color,
+			Footer: &discordgo.MessageEmbedFooter{
+				Text: "Created: ",
+			},
+		}
+		msg := discordgo.MessageSend{
+			Content: member.Mention(),
+			Embed:   &e,
+		}
+		_, err = s.ChannelMessageSendComplex(channel.ID, &msg)
+		if err != nil {
+			log.Println(err)
+		}
+	}
+	processQuery = "UPDATE tasks SET processing = false WHERE id = $1"
+	_, err = postgres.DB.Exec(processQuery, task.ID)
+	if err != nil {
+		log.Println(err)
+	}
+
+}
+
+func getTasksToRun() []Task {
+	query := "SELECT id, type, content, guild_id, channel_id, user_id, creation_time, trigger_time " +
+		"from tasks where completed is false and processing is false and trigger_time < $1"
+	res, err := postgres.DB.Query(query, time.Now())
+	if err != nil {
+		log.Println(err)
+	}
+	var tasks []Task
+	for res.Next() {
+		var t Task
+		err = res.Scan(&t.ID, &t.Type, &t.Content, &t.GuildID, &t.ChannelID, &t.UserID, &t.CreationTime, &t.TriggerTime)
+		if err != nil {
+			log.Println(err)
+		}
+		for _, task := range tasks {
+			if task.ID == t.ID {
+				continue
+			}
+		}
+		tasks = append(tasks, t)
+	}
+
+	return tasks
+}
+
+func ProcessTasks(s *discordgo.Session, interval int) {
+	for {
+		time.Sleep(time.Duration(interval * 1e9))
+
+		tasks := getTasksToRun()
+
+		if len(tasks) > 0 {
+			for _, t := range tasks {
+				go processTask(&t, s)
+			}
+		}
+	}
+}

internal/exts/tasks/tasks.go

@@ -1,4 +1,4 @@
-package exts
+package tasks
 
 import (
 	"errors"
@@ -13,7 +13,17 @@ import (
 	"github.com/olebedev/when/rules/en"
 )
 
-func addReminderCommand(ctx disgoman.Context, args []string) {
+var AddReminderCommand = &disgoman.Command{
+	Name:                "remind",
+	Aliases:             nil,
+	Description:         "Remind me at a later time",
+	OwnerOnly:           false,
+	Hidden:              false,
+	RequiredPermissions: 0,
+	Invoke:              addReminderFunc,
+}
+
+func addReminderFunc(ctx disgoman.Context, args []string) {
 	w := when.New(nil)
 	w.Add(en.All...)
 	w.Add(common.All...)

internal/exts/user_management/member_join.go

@@ -0,0 +1,73 @@
+package user_management
+
+import (
+	"log"
+
+	"github.com/bwmarrin/discordgo"
+	"github.com/dustinpianalto/goff"
+	"github.com/dustinpianalto/goff/internal/services"
+)
+
+func OnGuildMemberAdd(s *discordgo.Session, member *discordgo.GuildMemberAdd) {
+	defer func() {
+		if r := recover(); r != nil {
+			log.Println("Recovered from panic in OnGuildMemberAdd", r)
+		}
+	}()
+	user, err := services.UserService.User(member.User.ID)
+	if err != nil {
+		log.Println("Error getting user from database: ", err)
+		user = &goff.User{
+			ID:       member.User.ID,
+			Banned:   false,
+			Logging:  true,
+			IsActive: true,
+			IsStaff:  false,
+			IsAdmin:  false,
+		}
+		err := services.UserService.CreateUser(user)
+		if err != nil {
+			log.Println("Error adding user to database: ", err)
+		}
+	}
+	if !user.IsActive {
+		user.IsActive = true
+		err = services.UserService.UpdateUser(user)
+		if err != nil {
+			log.Println("Error marking user as active: ", err)
+		}
+	}
+	err = services.UserService.AddUserToGuild(user, &goff.Guild{ID: member.GuildID})
+	if err != nil {
+		log.Println("Error adding user to guild: ", err)
+	}
+}
+
+func OnGuildMemberRemove(s *discordgo.Session, member *discordgo.GuildMemberRemove) {
+	defer func() {
+		if r := recover(); r != nil {
+			log.Println("Recovered from panic in OnGuildMemberRemove: ", r)
+		}
+	}()
+	user, err := services.UserService.User(member.User.ID)
+	if err != nil {
+		log.Println("Error getting user from database: ", err)
+		return
+	}
+	err = services.UserService.RemoveUserFromGuild(user, &goff.Guild{ID: member.GuildID})
+	if err != nil {
+		log.Println("Error removing user from guild: ", err)
+	}
+	for i, g := range user.Guilds {
+		if g == member.GuildID {
+			user.Guilds[len(user.Guilds)-1], user.Guilds[i] = user.Guilds[i], user.Guilds[len(user.Guilds)-1]
+			user.Guilds = user.Guilds[:len(user.Guilds)-1]
+		}
+	}
+	if len(user.Guilds) == 0 {
+		err = services.UserService.MarkUserInactive(user)
+		if err != nil {
+			log.Println("Error marking user as inactive: ", err)
+		}
+	}
+}

internal/exts/user_management/member_logging.go

@@ -0,0 +1,167 @@
+package user_management
+
+import (
+	"fmt"
+	"log"
+	"strconv"
+	"time"
+
+	"github.com/bwmarrin/discordgo"
+	"github.com/dustinpianalto/goff/internal/discord_utils"
+	"github.com/dustinpianalto/goff/internal/postgres"
+)
+
+func OnGuildMemberAddLogging(s *discordgo.Session, member *discordgo.GuildMemberAdd) {
+	defer func() {
+		if r := recover(); r != nil {
+			log.Println("Recovered from panic in OnGuildMemberAddLogging", r)
+		}
+	}()
+	var channelID string
+	row := postgres.DB.QueryRow("SELECT logging_channel FROM guilds where id=$1", member.GuildID)
+	err := row.Scan(&channelID)
+	if err != nil || channelID == "" {
+		return
+	}
+	guild, err := s.State.Guild(member.GuildID)
+	if err != nil {
+		log.Println(err)
+		return
+	}
+
+	var title string
+	if member.User.Bot {
+		title = "Bot Joined"
+	} else {
+		title = "Member Joined"
+	}
+
+	thumb := &discordgo.MessageEmbedThumbnail{
+		URL: member.User.AvatarURL(""),
+	}
+
+	int64ID, _ := strconv.ParseInt(member.User.ID, 10, 64)
+	snow := discord_utils.ParseSnowflake(int64ID)
+
+	field := &discordgo.MessageEmbedField{
+		Name:   "User was created:",
+		Value:  discord_utils.ParseDateString(snow.CreationTime),
+		Inline: false,
+	}
+
+	joinTime, _ := member.JoinedAt.Parse()
+
+	embed := &discordgo.MessageEmbed{
+		Title:       title,
+		Description: fmt.Sprintf("%v (%v) Has Joined the Server", member.User.Mention(), member.User.ID),
+		Color:       0x0cc56a,
+		Thumbnail:   thumb,
+		Footer: &discordgo.MessageEmbedFooter{
+			Text:    fmt.Sprintf("Current Member Count: %v", guild.MemberCount),
+			IconURL: guild.IconURL(),
+		},
+		Timestamp: joinTime.Format(time.RFC3339),
+		Fields:    []*discordgo.MessageEmbedField{field},
+	}
+	s.ChannelMessageSendEmbed(channelID, embed)
+}
+
+func OnGuildMemberRemoveLogging(s *discordgo.Session, member *discordgo.GuildMemberRemove) {
+	defer func() {
+		if r := recover(); r != nil {
+			log.Println("Recovered from panic in OnGuildMemberAddLogging", r)
+		}
+	}()
+	timeNow := time.Now()
+	var channelID string
+	row := postgres.DB.QueryRow("SELECT logging_channel FROM guilds where id=$1", member.GuildID)
+	err := row.Scan(&channelID)
+	if err != nil || channelID == "" {
+		return
+	}
+	guild, err := s.State.Guild(member.GuildID)
+	if err != nil {
+		log.Println(err)
+		return
+	}
+
+	var title string
+	if member.User.Bot {
+		title = "Bot Left"
+	} else {
+		title = "Member Left"
+	}
+
+	thumb := &discordgo.MessageEmbedThumbnail{
+		URL: member.User.AvatarURL(""),
+	}
+
+	desc := ""
+	al, err := s.GuildAuditLog(member.GuildID, "", "", 20, 1)
+	if err != nil {
+		log.Println(err)
+	} else {
+		for _, log := range al.AuditLogEntries {
+			if log.TargetID == member.User.ID {
+				int64ID, _ := strconv.ParseInt(log.ID, 10, 64)
+				logSnow := discord_utils.ParseSnowflake(int64ID)
+				if timeNow.Sub(logSnow.CreationTime).Seconds() <= 10 {
+					user, err := s.User(log.UserID)
+					if err == nil {
+						desc = fmt.Sprintf("%v (%v) was Kicked by: %v\nReason: %v", member.User.String(), member.User.ID, user.String(), log.Reason)
+					} else {
+						desc = fmt.Sprintf("%v (%v) was Kicked by: %v\nReason: %v", member.User.String(), member.User.ID, log.UserID, log.Reason)
+					}
+					break
+				}
+			}
+		}
+	}
+	if desc == "" {
+		desc = fmt.Sprintf("%v (%v) Has Left the Server", member.User.String(), member.User.ID)
+	}
+
+	embed := &discordgo.MessageEmbed{
+		Title:       title,
+		Description: desc,
+		Color:       0xff9431,
+		Thumbnail:   thumb,
+		Footer: &discordgo.MessageEmbedFooter{
+			Text:    fmt.Sprintf("Current Member Count: %v", guild.MemberCount),
+			IconURL: guild.IconURL(),
+		},
+		Timestamp: timeNow.Format(time.RFC3339),
+	}
+	s.ChannelMessageSendEmbed(channelID, embed)
+}
+
+func AddMemberToDatabase(s *discordgo.Session, m *discordgo.GuildMemberAdd) {
+	defer func() {
+		if r := recover(); r != nil {
+			log.Println("Recovered from panic in AddMemberToDatabase", r)
+		}
+	}()
+	queryString := `INSERT INTO users (id, banned, logging, is_active, is_staff, is_admin) 
+						VALUES ($1, false, false, true, false, false)`
+	_, err := postgres.DB.Exec(queryString, m.User.ID)
+	if err != nil {
+		log.Println(fmt.Errorf("error inserting %s into database: %w", m.User.ID, err))
+		return
+	}
+	log.Printf("New User: %s\n", m.User.ID)
+}
+
+func MarkMemberInactive(s *discordgo.Session, m *discordgo.GuildMemberRemove) {
+	defer func() {
+		if r := recover(); r != nil {
+			log.Println("Recovered from panic in MarkMemberInactive")
+		}
+	}()
+	queryString := `UPDATE users SET is_active = false WHERE id = $1`
+	_, err := postgres.DB.Exec(queryString, m.User.ID)
+	if err != nil {
+		log.Println(fmt.Errorf("error marking %s as inactive: %w", m.User.ID, err))
+		return
+	}
+	log.Println("User left: %s")
+}

internal/exts/user_management/user_management.go

@@ -1,4 +1,4 @@
-package exts
+package user_management
 
 import (
 	"errors"
@@ -8,10 +8,20 @@ import (
 
 	"github.com/bwmarrin/discordgo"
 	"github.com/dustinpianalto/disgoman"
-	"github.com/dustinpianalto/goff/internal/events"
+	"github.com/dustinpianalto/goff/internal/exts/logging"
 )
 
-func kickUserCommand(ctx disgoman.Context, args []string) {
+var KickUserCommand = &disgoman.Command{
+	Name:                "kick",
+	Aliases:             nil,
+	Description:         "Kicks the given user with the given reason",
+	OwnerOnly:           false,
+	Hidden:              false,
+	RequiredPermissions: disgoman.PermissionKickMembers,
+	Invoke:              kickUserFunc,
+}
+
+func kickUserFunc(ctx disgoman.Context, args []string) {
 	var member *discordgo.Member
 	var err error
 	if len(ctx.Message.Mentions) > 0 {
@@ -70,7 +80,7 @@ func kickUserCommand(ctx disgoman.Context, args []string) {
 		return
 	}
 
-	event := &events.LogEvent{
+	event := &logging.LogEvent{
 		Embed: discordgo.MessageEmbed{
 			Title: "User Kicked",
 			Description: fmt.Sprintf(
@@ -85,11 +95,21 @@ func kickUserCommand(ctx disgoman.Context, args []string) {
 		GuildID: ctx.Guild.ID,
 		Session: ctx.Session,
 	}
-	events.LoggingChannel <- event
+	logging.LoggingChannel <- event
 	_, _ = ctx.Send(fmt.Sprintf("User %v#%v has been kicked.", member.User.Username, member.User.Discriminator))
 }
 
-func banUserCommand(ctx disgoman.Context, args []string) {
+var BanUserCommand = &disgoman.Command{
+	Name:                "ban",
+	Aliases:             []string{"ban-no-delete"},
+	Description:         "Bans the given user with the given reason",
+	OwnerOnly:           false,
+	Hidden:              false,
+	RequiredPermissions: disgoman.PermissionBanMembers,
+	Invoke:              banUserFunc,
+}
+
+func banUserFunc(ctx disgoman.Context, args []string) {
 	var user *discordgo.User
 	var err error
 	if len(ctx.Message.Mentions) > 0 {
@@ -170,7 +190,7 @@ func banUserCommand(ctx disgoman.Context, args []string) {
 		return
 	}
 
-	event := &events.LogEvent{
+	event := &logging.LogEvent{
 		Embed: discordgo.MessageEmbed{
 			Title: "User Banned",
 			Description: fmt.Sprintf(
@@ -185,11 +205,21 @@ func banUserCommand(ctx disgoman.Context, args []string) {
 		GuildID: ctx.Guild.ID,
 		Session: ctx.Session,
 	}
-	events.LoggingChannel <- event
+	logging.LoggingChannel <- event
 	_, _ = ctx.Send(fmt.Sprintf("User %v#%v has been banned.", user.Username, user.Discriminator))
 }
 
-func unbanUserCommand(ctx disgoman.Context, args []string) {
+var UnbanUserCommand = &disgoman.Command{
+	Name:                "unban",
+	Aliases:             nil,
+	Description:         "Unbans the given user",
+	OwnerOnly:           false,
+	Hidden:              false,
+	RequiredPermissions: disgoman.PermissionBanMembers,
+	Invoke:              unbanUserFunc,
+}
+
+func unbanUserFunc(ctx disgoman.Context, args []string) {
 	var user *discordgo.User
 	var err error
 	if len(ctx.Message.Mentions) > 0 {
@@ -232,7 +262,7 @@ func unbanUserCommand(ctx disgoman.Context, args []string) {
 				}
 				return
 			}
-			event := &events.LogEvent{
+			event := &logging.LogEvent{
 				Embed: discordgo.MessageEmbed{
 					Title: "User Banned",
 					Description: fmt.Sprintf(
@@ -247,7 +277,7 @@ func unbanUserCommand(ctx disgoman.Context, args []string) {
 				GuildID: ctx.Guild.ID,
 				Session: ctx.Session,
 			}
-			events.LoggingChannel <- event
+			logging.LoggingChannel <- event
 			_, _ = ctx.Send(fmt.Sprintf("User %v#%v has been unbanned.", user.Username, user.Discriminator))
 			return
 		}

internal/exts/utils/utils.go

@@ -1,4 +1,4 @@
-package exts
+package utils
 
 import (
 	"fmt"
@@ -12,7 +12,17 @@ import (
 	"github.com/dustinpianalto/goff/internal/discord_utils"
 )
 
-func pingCommand(ctx disgoman.Context, _ []string) {
+var PingCommand = &disgoman.Command{
+	Name:                "ping",
+	Aliases:             []string{" "},
+	Description:         "Check the bot's ping",
+	OwnerOnly:           false,
+	Hidden:              false,
+	RequiredPermissions: 0,
+	Invoke:              pingCommandFunc,
+}
+
+func pingCommandFunc(ctx disgoman.Context, _ []string) {
 	timeBefore := time.Now()
 	msg, _ := ctx.Send("Pong!")
 	took := time.Now().Sub(timeBefore)
@@ -26,7 +36,17 @@ func pingCommand(ctx disgoman.Context, _ []string) {
 	}
 }
 
-func inviteCommand(ctx disgoman.Context, args []string) {
+var InviteCommand = &disgoman.Command{
+	Name:                "invite",
+	Aliases:             nil,
+	Description:         "Get the invite link for this bot or others",
+	OwnerOnly:           false,
+	Hidden:              false,
+	RequiredPermissions: 0,
+	Invoke:              inviteCommandFunc,
+}
+
+func inviteCommandFunc(ctx disgoman.Context, args []string) {
 	var ids []string
 	if len(args) == 0 {
 		ids = []string{ctx.Session.State.User.ID}
@@ -48,7 +68,17 @@ func inviteCommand(ctx disgoman.Context, args []string) {
 	}
 }
 
-func gitCommand(ctx disgoman.Context, _ []string) {
+var GitCommand = &disgoman.Command{
+	Name:                "git",
+	Aliases:             nil,
+	Description:         "Show my github link",
+	OwnerOnly:           false,
+	Hidden:              false,
+	RequiredPermissions: 0,
+	Invoke:              gitCommandFunc,
+}
+
+func gitCommandFunc(ctx disgoman.Context, _ []string) {
 	embed := &discordgo.MessageEmbed{
 		Title: "Hi there, My code is on Github",
 		Color: 0,
@@ -64,7 +94,18 @@ func gitCommand(ctx disgoman.Context, _ []string) {
 	}
 }
 
-func sayCommand(ctx disgoman.Context, args []string) {
+var SayCommand = &disgoman.Command{
+	Name:                "say",
+	Aliases:             nil,
+	Description:         "Repeat a message",
+	OwnerOnly:           false,
+	Hidden:              false,
+	RequiredPermissions: 0,
+	SanitizeEveryone:    true,
+	Invoke:              sayCommandFunc,
+}
+
+func sayCommandFunc(ctx disgoman.Context, args []string) {
 	resp := strings.Join(args, " ")
 	resp = strings.ReplaceAll(resp, "@everyone", "@\ufff0everyone")
 	resp = strings.ReplaceAll(resp, "@here", "@\ufff0here")
@@ -78,7 +119,17 @@ func sayCommand(ctx disgoman.Context, args []string) {
 	}
 }
 
-func userCommand(ctx disgoman.Context, args []string) {
+var UserCommand = &disgoman.Command{
+	Name:                "user",
+	Aliases:             nil,
+	Description:         "Get user info",
+	OwnerOnly:           false,
+	Hidden:              false,
+	RequiredPermissions: 0,
+	Invoke:              userCommandFunc,
+}
+
+func userCommandFunc(ctx disgoman.Context, args []string) {
 	var member *discordgo.Member
 	if len(args) == 0 {
 		member, _ = ctx.Session.GuildMember(ctx.Guild.ID, ctx.Message.Author.ID)