Reorg and add services

cmd/goff/main.go

@@ -5,10 +5,13 @@ import (
 	"log"
 
 	"github.com/dustinpianalto/disgoman"
-	"github.com/dustinpianalto/goff"
-	"github.com/dustinpianalto/goff/internal/events"
 	"github.com/dustinpianalto/goff/internal/exts"
+	"github.com/dustinpianalto/goff/internal/exts/guild_management"
+	"github.com/dustinpianalto/goff/internal/exts/logging"
+	"github.com/dustinpianalto/goff/internal/exts/tasks"
+	"github.com/dustinpianalto/goff/internal/exts/user_management"
 	"github.com/dustinpianalto/goff/internal/postgres"
+	"github.com/dustinpianalto/goff/internal/services"
 	"github.com/dustinpianalto/goff/pkg/email"
 
 	//"github.com/MikeModder/anpan"
@@ -66,25 +69,20 @@ func main() {
 		CheckPermissions: false,
 	}
 
-	goffManager := goff.CommandManager{
-		UserService:    us,
-		GuildService:   gs,
-		CommandManager: manager,
-	}
-
 	// Add Command Handlers
-	exts.AddCommandHandlers(&goffManager)
+	exts.AddCommandHandlers(&manager)
+	services.InitalizeServices(us, gs)
 
 	//if _, ok := handler.Commands["help"]; !ok {
 	//	handler.AddDefaultHelpCommand()
 	//}
 
-	dg.AddHandler(goffManager.OnMessage)
-	dg.AddHandler(goffManager.StatusManager.OnReady)
-	dg.AddHandler(events.OnMessageUpdate)
-	dg.AddHandler(events.OnMessageDelete)
-	dg.AddHandler(events.OnGuildMemberAddLogging)
-	dg.AddHandler(events.OnGuildMemberRemoveLogging)
+	dg.AddHandler(manager.OnMessage)
+	dg.AddHandler(manager.StatusManager.OnReady)
+	dg.AddHandler(guild_management.OnMessageUpdate)
+	dg.AddHandler(guild_management.OnMessageDelete)
+	dg.AddHandler(user_management.OnGuildMemberAddLogging)
+	dg.AddHandler(user_management.OnGuildMemberRemoveLogging)
 
 	err = dg.Open()
 	if err != nil {
@@ -93,13 +91,13 @@ func main() {
 	}
 
 	// Start the Error handler in a goroutine
-	go ErrorHandler(goffManager.ErrorChannel)
+	go ErrorHandler(manager.ErrorChannel)
 
 	// Start the Logging handler in a goroutine
-	go events.LoggingHandler(events.LoggingChannel)
+	go logging.LoggingHandler(logging.LoggingChannel)
 
 	// Start the task handler in a goroutine
-	go events.ProcessTasks(dg, 1)
+	go tasks.ProcessTasks(dg, 1)
 
 	go email.RecieveEmail(dg)
 
@@ -132,6 +130,9 @@ func getPrefixes(guildID string) []string {
 		}
 		prefixes = append(prefixes, prefix)
 	}
+	if len(prefixes) == 0 {
+		prefixes = append(prefixes, "Godev.", "godev.")
+	}
 	return prefixes
 }
 

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

@@ -1,4 +1,4 @@
-package events
+package guild_management
 
 import (
 	"fmt"

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

@@ -1,4 +1,4 @@
-package events
+package logging
 
 import (
 	"fmt"

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

@@ -1,4 +1,4 @@
-package events
+package tasks
 
 import (
 	"fmt"

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

@@ -1,4 +1,4 @@
-package events
+package user_management
 
 import (
 	"fmt"

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)

internal/postgres/guild.go

@@ -2,6 +2,7 @@ package postgres
 
 import (
 	"database/sql"
+	"log"
 
 	"github.com/dustinpianalto/goff"
 )
@@ -49,17 +50,78 @@ func (s *GuildService) Guild(id string) (*goff.Guild, error) {
 }
 
 func (s *GuildService) CreateGuild(g *goff.Guild) error {
-	return nil
+	queryString := `INSERT INTO guilds (id, 
+					welcome_message, 
+					goodbye_message, 
+					logging_channel, 
+					welcome_channel, 
+					puzzle_channel, 
+					puzzle_role) 
+					VALUES ($1, $2, $3, $4, $5, $6, $7)`
+	_, err := s.DB.Exec(queryString,
+		g.ID,
+		g.WelcomeMessage,
+		g.GoodbyeMessage,
+		g.LoggingChannel,
+		g.WelcomeChannel,
+		g.PuzzleChannel,
+		g.PuzzleRole,
+	)
+	return err
 }
 
 func (s *GuildService) DeleteGuild(g *goff.Guild) error {
-	return nil
+	queryString := `DELETE CASCADE FROM guilds WHERE id = $1`
+	_, err := s.DB.Exec(queryString, g.ID)
+	return err
 }
 
 func (s *GuildService) GuildUsers(g *goff.Guild) ([]*goff.User, error) {
-	return []*goff.User{}, nil
+	var users []*goff.User
+	queryString := `SELECT u.id, u.banned, u.logging, u.steam_id, u.is_active, u.is_staff, u.is_admin
+					FROM users u, x_users_guilds xug
+					WHERE xug.guild_id = $1
+					AND xug.user_id = u.id`
+	rows, err := s.DB.Query(queryString, g.ID)
+	if err != nil {
+		return nil, err
+	}
+	for rows.Next() {
+		var user goff.User
+		err := rows.Scan(&user.ID,
+			&user.Banned,
+			&user.Logging,
+			&user.SteamID,
+			&user.IsActive,
+			&user.IsStaff,
+			&user.IsAdmin,
+		)
+		if err != nil {
+			log.Println(err)
+			continue
+		}
+		users = append(users, &user)
+	}
+	return users, nil
 }
 
 func (s *GuildService) UpdateGuild(g *goff.Guild) error {
-	return nil
+	queryString := `UPDATE guilds SET 
+					welcome_message = $1,
+					goodbye_message = $2,
+					logging_channel = $3,
+					welcome_channel = $4,
+					puzzle_channel = $5,
+					puzzle_role = $6
+					WHERE id = $7`
+	_, err := s.DB.Exec(queryString,
+		g.WelcomeMessage,
+		g.GoodbyeMessage,
+		g.LoggingChannel,
+		g.WelcomeChannel,
+		g.PuzzleChannel,
+		g.PuzzleRole,
+		g.ID,
+	)
+	return err
 }

internal/postgres/user.go

@@ -44,7 +44,7 @@ func (s *UserService) CreateUser(u *goff.User) error {
 }
 
 func (s *UserService) DeleteUser(u *goff.User) error {
-	queryString := `DELETE FROM x_users_guilds WHERE user_id = $1; DELETE FROM users WHERE id = $1`
+	queryString := `DELETE CASCADE FROM x_users_guilds WHERE user_id = $1; DELETE FROM users WHERE id = $1`
 	_, err := s.DB.Exec(queryString, u.ID)
 	return err
 }
@@ -72,11 +72,11 @@ func (s *UserService) RemoveUserFromGuild(u *goff.User, g *goff.Guild) error {
 
 func (s *UserService) UpdateUser(u *goff.User) error {
 	queryString := `UPDATE users SET 
-						banned = $1 
-						logging = $2 
-						steam_id = $3 
-						is_active = $4 
-						is_staff = $5 
+						banned = $1,
+						logging = $2, 
+						steam_id = $3, 
+						is_active = $4, 
+						is_staff = $5,
 						is_admin = $6
 						WHERE id = $7`
 	_, err := s.DB.Exec(queryString, u.Banned, u.Logging, u.SteamID, u.IsActive, u.IsStaff, u.IsAdmin)

internal/services/services.go

@@ -0,0 +1,11 @@
+package services
+
+import "github.com/dustinpianalto/goff"
+
+var UserService goff.UserService
+var GuildService goff.GuildService
+
+func InitalizeServices(us goff.UserService, gs goff.GuildService) {
+	UserService = us
+	GuildService = gs
+}