Merge branch 'dev'

cloc.md

@@ -1,13 +1,13 @@
 
-cloc|github.com/AlDanial/cloc v 1.74  T=0.50 s (84.0 files/s, 4968.0 lines/s)
+cloc|github.com/AlDanial/cloc v 1.74  T=1.00 s (43.0 files/s, 2667.0 lines/s)
 --- | ---
 
 Language|files|blank|comment|code
 :-------|-------:|-------:|-------:|-------:
-Go|34|330|13|1961
+Go|35|347|13|2127
 Bourne Shell|4|18|2|50
 Markdown|1|16|0|38
 YAML|2|4|0|28
 SQL|1|3|0|21
 --------|--------|--------|--------|--------
-SUM:|42|371|15|2098
+SUM:|43|388|15|2264

commands/cmdclear.go

@@ -96,7 +96,7 @@ func (c *CmdClear) Exec(args *CommandArgs) error {
 
 	multipleMsgs := ""
 	if len(msgs) > 1 {
-		multipleMsgs = "'s"
+		multipleMsgs = "s"
 	}
 
 	msg, err := util.SendEmbed(args.Session, args.Channel.ID,

commands/report.go → commands/cmdreport.go

@@ -41,7 +41,7 @@ func (c *CmdReport) GetPermission() int {
 }
 
 func (c *CmdReport) Exec(args *CommandArgs) error {
-	if len(args.Args) < 2 {
+	if len(args.Args) < 1 {
 		msg, err := util.SendEmbedError(args.Session, args.Channel.ID,
 			"Invalid command arguments. Please use `help report` to see how to use this command.")
 		util.DeleteMessageLater(args.Session, msg, 8*time.Second)
@@ -54,11 +54,39 @@ func (c *CmdReport) Exec(args *CommandArgs) error {
 		util.DeleteMessageLater(args.Session, msg, 10*time.Second)
 		return err
 	}
+
+	if len(args.Args) == 1 {
+		emb := &discordgo.MessageEmbed{
+			Color: util.ColorEmbedDefault,
+			Title: fmt.Sprintf("Reports for %s#%s",
+				victim.User.Username, victim.User.Discriminator),
+		}
+		reps, err := args.CmdHandler.db.GetReportsGuild(args.Guild.ID)
+		if err != nil {
+			return err
+		}
+		if len(reps) == 0 {
+			emb.Description = "This user has a white west. :ok_hand:"
+		} else {
+			emb.Fields = make([]*discordgo.MessageEmbedField, len(reps))
+			for i, r := range reps {
+				if r.VictimID == victim.User.ID {
+					emb.Fields[i] = r.AsEmbedField()
+				}
+			}
+		}
+		_, err = args.Session.ChannelMessageSendEmbed(args.Channel.ID, emb)
+		return err
+	}
+
 	msgOffset := 1
 	repType, err := strconv.Atoi(args.Args[1])
+	maxType := len(util.ReportTypes) - 1
+	minType := 2
+	if repType == 0 {
+		repType = minType
+	}
 	if err == nil {
-		maxType := len(util.ReportTypes) - 1
-		minType := 2
 		if repType < minType || repType > maxType {
 			msg, err := util.SendEmbedError(args.Session, args.Channel.ID,
 				fmt.Sprintf("Report type must be between *(including)* %d and %d.\n", minType, maxType)+

commands/cmdtest.go

@@ -2,7 +2,9 @@ package commands
 
 import (
 	"fmt"
-	"time"
+
+	"github.com/bwmarrin/discordgo"
+	"github.com/zekroTJA/shinpuru/util"
 )
 
 type CmdTest struct {
@@ -29,6 +31,27 @@ func (c *CmdTest) GetPermission() int {
 }
 
 func (c *CmdTest) Exec(args *CommandArgs) error {
-	fmt.Println(time.Now(), time.Now().Unix())
+	filter := func(m *discordgo.Message) bool {
+		return m.Author.ID == args.User.ID && m.Content == "a"
+	}
+	options := &util.MessageCollectorOptions{
+		MaxMatches:         3,
+		DeleteMatchesAfter: true,
+	}
+	mc, err := util.NewMessageCollector(args.Session, args.Channel.ID, filter, options)
+	if err != nil {
+		return err
+	}
+
+	mc.OnColelcted(func(msg *discordgo.Message, c *util.MessageCollector) {
+		fmt.Println("Collected: ", msg.Content)
+	})
+	mc.OnMatched(func(msg *discordgo.Message, c *util.MessageCollector) {
+		fmt.Println("Matched: ", msg.Content)
+	})
+	mc.OnClosed(func(reason string, c *util.MessageCollector) {
+		fmt.Println(reason, len(c.CollectedMessages), len(c.CollectedMatches))
+	})
+
 	return nil
 }

core/mysql.go

@@ -172,7 +172,19 @@ func (m *MySql) AddReport(rep *util.Report) error {
 	return err
 }
 
-// TODO: functionality
 func (m *MySql) GetReportsGuild(guildID string) ([]*util.Report, error) {
-	return nil, nil
+	rows, err := m.DB.Query("SELECT * FROM reports WHERE guildID = ?", guildID)
+	var results []*util.Report
+	if err != nil {
+		return nil, err
+	}
+	for rows.Next() {
+		rep := new(util.Report)
+		err := rows.Scan(&rep.ID, &rep.Type, &rep.GuildID, &rep.ExecutorID, &rep.VictimID, &rep.Msg)
+		if err != nil {
+			return nil, err
+		}
+		results = append(results, rep)
+	}
+	return results, nil
 }

listeners/cmds.go

@@ -91,6 +91,7 @@ func (l *ListenerCmds) Handler(s *discordgo.Session, e *discordgo.MessageCreate)
 			util.SendEmbedError(s, channel.ID, "You are not permitted to use this command!", "Missing permission")
 			return
 		}
+		s.ChannelMessageDelete(channel.ID, e.Message.ID)
 		err = cmdInstance.Exec(cmdArgs)
 		if err != nil {
 			emb := &discordgo.MessageEmbed{
@@ -107,8 +108,6 @@ func (l *ListenerCmds) Handler(s *discordgo.Session, e *discordgo.MessageCreate)
 			if err != nil {
 				util.Log.Error("An error occured sending command error message: ", err)
 			}
-		} else {
-			s.ChannelMessageDelete(channel.ID, e.Message.ID)
 		}
 		if l.config.CommandLogging {
 			util.Log.Infof("Executed Command: %s[%s]@%s[%s] - %s", e.Author.Username, e.Author.ID, guild.Name, guild.ID, e.Message.Content)

util/acceptmessage.go

@@ -1,6 +1,8 @@
 package util
 
 import (
+	"errors"
+
 	"github.com/bwmarrin/discordgo"
 )
 
@@ -21,6 +23,9 @@ type AcceptMessage struct {
 }
 
 func (am *AcceptMessage) Send(chanID string) (*AcceptMessage, error) {
+	if am.Session == nil {
+		return nil, errors.New("session is not defined")
+	}
 	msg, err := am.Session.ChannelMessageSendEmbed(chanID, am.Embed)
 	if err != nil {
 		return nil, err

util/messagecollector.go

@@ -0,0 +1,102 @@
+package util
+
+import (
+	"errors"
+	"time"
+
+	"github.com/bwmarrin/discordgo"
+)
+
+type MessageCollectorOptions struct {
+	MaxMessages        int
+	MaxMatches         int
+	Timeout            time.Duration
+	DeleteMatchesAfter bool
+}
+
+type MessageCollector struct {
+	CollectedMessages []*discordgo.Message
+	CollectedMatches  []*discordgo.Message
+	Closed            bool
+	channelID         string
+	session           *discordgo.Session
+	options           *MessageCollectorOptions
+	filter            func(*discordgo.Message) bool
+	eventUnsub        func()
+	onCollected       func(*discordgo.Message, *MessageCollector)
+	onMatched         func(*discordgo.Message, *MessageCollector)
+	onClosed          func(string, *MessageCollector)
+}
+
+func NewMessageCollector(s *discordgo.Session, channelID string, filter func(*discordgo.Message) bool, options *MessageCollectorOptions) (*MessageCollector, error) {
+	if s == nil {
+		return nil, errors.New("session is not defined")
+	}
+	if options == nil {
+		options = new(MessageCollectorOptions)
+	}
+	mc := &MessageCollector{
+		session:           s,
+		channelID:         channelID,
+		filter:            filter,
+		options:           options,
+		CollectedMessages: make([]*discordgo.Message, 0),
+	}
+	mc.eventUnsub = mc.session.AddHandler(func(s *discordgo.Session, msg *discordgo.MessageCreate) {
+		if msg.ChannelID != mc.channelID {
+			return
+		}
+		mc.CollectedMessages = append(mc.CollectedMessages, msg.Message)
+		if mc.onCollected != nil {
+			mc.onCollected(msg.Message, mc)
+		}
+		if mc.filter(msg.Message) {
+			mc.CollectedMatches = append(mc.CollectedMatches, msg.Message)
+			if mc.onMatched != nil {
+				mc.onMatched(msg.Message, mc)
+			}
+		}
+		if mc.options.MaxMessages != 0 && len(mc.CollectedMessages) >= mc.options.MaxMessages {
+			mc.Close("maxMessagesReached")
+		} else if mc.options.MaxMatches != 0 && len(mc.CollectedMatches) >= mc.options.MaxMatches {
+			mc.Close("maxMatchesReached")
+		}
+	})
+	if mc.options.Timeout != 0*time.Second {
+		time.AfterFunc(mc.options.Timeout, func() {
+			// TODO: test if throws nil pointer exception
+			mc.Close("timeout")
+		})
+	}
+	return mc, nil
+}
+
+func (mc *MessageCollector) Close(reason string) {
+	if mc.Closed {
+		return
+	}
+	if mc.eventUnsub != nil {
+		mc.eventUnsub()
+	}
+	if mc.onClosed != nil {
+		mc.onClosed(reason, mc)
+	}
+	mc.Closed = true
+	if mc.options.DeleteMatchesAfter {
+		for _, msg := range mc.CollectedMatches {
+			mc.session.ChannelMessageDelete(mc.channelID, msg.ID)
+		}
+	}
+}
+
+func (mc *MessageCollector) OnColelcted(handler func(*discordgo.Message, *MessageCollector)) {
+	mc.onCollected = handler
+}
+
+func (mc *MessageCollector) OnMatched(handler func(*discordgo.Message, *MessageCollector)) {
+	mc.onMatched = handler
+}
+
+func (mc *MessageCollector) OnClosed(handler func(string, *MessageCollector)) {
+	mc.onClosed = handler
+}

util/report.go

@@ -2,6 +2,7 @@ package util
 
 import (
 	"fmt"
+	"time"
 
 	"github.com/bwmarrin/discordgo"
 	"github.com/bwmarrin/snowflake"
@@ -16,9 +17,13 @@ type Report struct {
 	Msg        string
 }
 
+func (r *Report) GetTimestamp() time.Time {
+	return time.Unix(r.ID.Time()/1000, 0)
+}
+
 func (r *Report) AsEmbed() *discordgo.MessageEmbed {
 	return &discordgo.MessageEmbed{
-		Title: "Report " + r.ID.String(),
+		Title: "Case " + r.ID.String(),
 		Color: ColorEmbedDefault,
 		Fields: []*discordgo.MessageEmbedField{
 			&discordgo.MessageEmbedField{
@@ -40,5 +45,14 @@ func (r *Report) AsEmbed() *discordgo.MessageEmbed {
 				Value: r.Msg,
 			},
 		},
+		Timestamp: r.GetTimestamp().Format("2006-01-02T15:04:05.000Z"),
+	}
+}
+
+func (r *Report) AsEmbedField() *discordgo.MessageEmbedField {
+	return &discordgo.MessageEmbedField{
+		Name: "Case " + r.ID.String(),
+		Value: fmt.Sprintf("Time: %s\nExecutor: <@%s>\nVictim: <@%s>\nType: `%s`\n__Reason__:\n%s",
+			r.GetTimestamp().Format("2006/01/02 15:04:05"), r.ExecutorID, r.VictimID, ReportTypes[r.Type], r.Msg),
 	}
 }