main.main - Code Metrics - Inspection of "Updated metrics sending" - FlameInTheDark/dtbot - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 23ac56...137631 )

by Viktor

created 2019-01-21 05:29 UTC

main.main B

↳ Parent: main.go

Complexity

Conditions

Size

Total Lines	44
Code Lines	38

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	5
eloc	38
nop	0
dl	0
loc	44
rs	8.5013
c	0
b	0
f	0

package main

import (
	"bytes"
	"fmt"
	"gopkg.in/robfig/cron.v2"
	"net/http"
	"os"
	"os/signal"
	"strings"
	"syscall"
	"time"

	"github.com/FlameInTheDark/dtbot/bot"
	"github.com/FlameInTheDark/dtbot/cmd"
	"github.com/bwmarrin/discordgo"
)

var (
	conf *bot.Config
	// CmdHandler bot command handler
	CmdHandler *bot.CommandHandler
	// Sessions bot session manager
	Sessions        *bot.SessionManager
	botId           string

	youtube         *bot.Youtube
	botMsg          *bot.BotMessages
	dataType        *bot.DataType
	dbWorker        *bot.DBWorker
	guilds          bot.GuildsMap
	botCron         *cron.Cron
	messagesCounter int
)

func main() {
	botCron = cron.New()
	conf = bot.LoadConfig()
	CmdHandler = bot.NewCommandHandler()
	registerCommands()
	Sessions = bot.NewSessionManager()
	youtube = &bot.Youtube{Conf: conf}
	botMsg = bot.NewMessagesMap()
	dataType = bot.NewDataType()
	discord, err := discordgo.New("Bot " + os.Getenv("BOT_TOKEN"))
	if err != nil {
		fmt.Println("Create session error, ", err)
		return
	}
	usr, err := discord.User("@me")
	if err != nil {
		fmt.Println("Error obtaining account details,", err)
		return
	}
	botId = usr.ID
	discord.AddHandler(commandHandler)
	discord.AddHandler(func(discord *discordgo.Session, ready *discordgo.Ready) {
		discord.UpdateStatus(0, conf.General.Game)
		guilds := discord.State.Guilds
		fmt.Println("Ready with", len(guilds), "guilds.")
	})

	err = discord.Open()
	if err != nil {
		fmt.Printf("Connection open error: %v", err)
		return
	}
	defer discord.Close()
	fmt.Println("Bot is now running.")

	sc := make(chan os.Signal, 1)
	signal.Notify(sc, syscall.SIGINT, syscall.SIGTERM, os.Interrupt, os.Kill)
	dbWorker = bot.NewDBSession(conf.General.DatabaseName)
	guilds = dbWorker.InitGuilds(discord, conf)
	botCron.Start()
	go MetricsSender()
	defer botCron.Stop()
	defer dbWorker.DBSession.Close()
	<-sc
}

// Handle discord messages
func commandHandler(discord *discordgo.Session, message *discordgo.MessageCreate) {
	messagesCounter++
	user := message.Author
	if user.ID == botId || user.Bot {
		return
	}
	args := strings.Split(message.Content, " ")
	name := strings.ToLower(args[0])
	command, found := CmdHandler.Get(name)
	if !found {
		return
	}

	var permission = true
	var msg string
	// Checking permissions
	perm, err := discord.State.UserChannelPermissions(botId, message.ChannelID)
	if err != nil {
		//dbWorker.Log("Message", guild.ID, fmt.Sprintf("Error whilst getting bot permissions %v\n", err))
		msg = fmt.Sprintf("Error whilst getting bot permissions %v\n", err)
		permission = false
	} else {
		if perm&discordgo.PermissionSendMessages != discordgo.PermissionSendMessages ||
			perm&discordgo.PermissionAttachFiles != discordgo.PermissionAttachFiles {
			//dbWorker.Log("Message", guild.ID, fmt.Sprintf("Permissions denied"))
			msg = "Permissions denied"
			permission = false
		}
	}

	channel, err := discord.State.Channel(message.ChannelID)
	if err != nil {
		fmt.Println("Error getting channel,", err)
		return
	}
	guild, err := discord.State.Guild(channel.GuildID)
	if err != nil {
		fmt.Println("Error getting guild,", err)
		return
	}

	if permission {
		ctx := bot.NewContext(
			botId,
			discord,
			guild,
			channel,
			user,
			message,
			conf,
			CmdHandler,
			Sessions,
			youtube,
			botMsg,
			dataType,
			dbWorker,
			guilds,
			botCron)
		ctx.Args = args[1:]
		c := *command
		c(*ctx)
		//ctx.MetricsMessage()
	} else {
		dbWorker.Log("Message", guild.ID, msg)
		query := []byte(fmt.Sprintf("logs,server=%v module=\"%v\"", guild.ID, "message"))
		addr := fmt.Sprintf("%v/write?db=%v", conf.Metrics.Address, conf.Metrics.Database)
		r := bytes.NewReader(query)
		_, _ = http.Post(addr, "", r)
	}
}

// Adds bot commands
func registerCommands() {
	CmdHandler.Register("!r", cmd.PlayerCommand)
	CmdHandler.Register("!w", cmd.WeatherCommand)
	CmdHandler.Register("!t", cmd.TranslateCommand)
	CmdHandler.Register("!n", cmd.NewsCommand)
	CmdHandler.Register("!c", cmd.CurrencyCommand)
	CmdHandler.Register("!y", cmd.YoutubeCommand)
	CmdHandler.Register("!v", cmd.VoiceCommand)
	CmdHandler.Register("!b", cmd.BotCommand)
	CmdHandler.Register("!play", cmd.YoutubeShortCommand)
	CmdHandler.Register("!d", cmd.DebugCommand)
	CmdHandler.Register("!p", cmd.PollCommand)
	CmdHandler.Register("!m", cmd.YandexmapCommand)
	CmdHandler.Register("!dice", cmd.DiceCommand)
	CmdHandler.Register("!help", cmd.HelpCommand)
	CmdHandler.Register("!cron", cmd.CronCommand)
}

func MetricsSender() {

	for {
		query := []byte(fmt.Sprintf("messages count=%v", messagesCounter))
		addr := fmt.Sprintf("%v/write?db=%v", conf.Metrics.Address, conf.Metrics.Database)
		r := bytes.NewReader(query)
		_, _ = http.Post(addr, "", r)
		messagesCounter = 0
		time.Sleep(time.Minute)
	}
}

1			package main
2
3			import (
4			"bytes"
5			"fmt"
6			"gopkg.in/robfig/cron.v2"
7			"net/http"
8			"os"
9			"os/signal"
10			"strings"
11			"syscall"
12			"time"
13
14			"github.com/FlameInTheDark/dtbot/bot"
15			"github.com/FlameInTheDark/dtbot/cmd"
16			"github.com/bwmarrin/discordgo"
17			)
18
19			var (
20			conf *bot.Config
21			// CmdHandler bot command handler
22			CmdHandler *bot.CommandHandler
23			// Sessions bot session manager
24			Sessions *bot.SessionManager
25			botId string
			0 ignored issues – show introduced 2018-11-08 05:49 UTC by Report Bug Copy Issue Report var botId should be botID Loading history...
26			youtube *bot.Youtube
27			botMsg *bot.BotMessages
28			dataType *bot.DataType
29			dbWorker *bot.DBWorker
30			guilds bot.GuildsMap
31			botCron *cron.Cron
32			messagesCounter int
33			)
34
35			func main() {
36			botCron = cron.New()
37			conf = bot.LoadConfig()
38			CmdHandler = bot.NewCommandHandler()
39			registerCommands()
40			Sessions = bot.NewSessionManager()
41			youtube = &bot.Youtube{Conf: conf}
42			botMsg = bot.NewMessagesMap()
43			dataType = bot.NewDataType()
44			discord, err := discordgo.New("Bot " + os.Getenv("BOT_TOKEN"))
45			if err != nil {
46			fmt.Println("Create session error, ", err)
47			return
48			}
49			usr, err := discord.User("@me")
50			if err != nil {
51			fmt.Println("Error obtaining account details,", err)
52			return
53			}
54			botId = usr.ID
55			discord.AddHandler(commandHandler)
56			discord.AddHandler(func(discord discordgo.Session, ready discordgo.Ready) {
57			discord.UpdateStatus(0, conf.General.Game)
58			guilds := discord.State.Guilds
59			fmt.Println("Ready with", len(guilds), "guilds.")
60			})
61
62			err = discord.Open()
63			if err != nil {
64			fmt.Printf("Connection open error: %v", err)
65			return
66			}
67			defer discord.Close()
68			fmt.Println("Bot is now running.")
69
70			sc := make(chan os.Signal, 1)
71			signal.Notify(sc, syscall.SIGINT, syscall.SIGTERM, os.Interrupt, os.Kill)
72			dbWorker = bot.NewDBSession(conf.General.DatabaseName)
73			guilds = dbWorker.InitGuilds(discord, conf)
74			botCron.Start()
75			go MetricsSender()
76			defer botCron.Stop()
77			defer dbWorker.DBSession.Close()
78			<-sc
79			}
80
81			// Handle discord messages
82			func commandHandler(discord discordgo.Session, message discordgo.MessageCreate) {
83			messagesCounter++
84			user := message.Author
85			if user.ID == botId \|\| user.Bot {
86			return
87			}
88			args := strings.Split(message.Content, " ")
89			name := strings.ToLower(args[0])
90			command, found := CmdHandler.Get(name)
91			if !found {
92			return
93			}
94
95			var permission = true
96			var msg string
97			// Checking permissions
98			perm, err := discord.State.UserChannelPermissions(botId, message.ChannelID)
99			if err != nil {
100			//dbWorker.Log("Message", guild.ID, fmt.Sprintf("Error whilst getting bot permissions %v\n", err))
101			msg = fmt.Sprintf("Error whilst getting bot permissions %v\n", err)
102			permission = false
103			} else {
104			if perm&discordgo.PermissionSendMessages != discordgo.PermissionSendMessages \|\|
105			perm&discordgo.PermissionAttachFiles != discordgo.PermissionAttachFiles {
106			//dbWorker.Log("Message", guild.ID, fmt.Sprintf("Permissions denied"))
107			msg = "Permissions denied"
108			permission = false
109			}
110			}
111
112			channel, err := discord.State.Channel(message.ChannelID)
113			if err != nil {
114			fmt.Println("Error getting channel,", err)
115			return
116			}
117			guild, err := discord.State.Guild(channel.GuildID)
118			if err != nil {
119			fmt.Println("Error getting guild,", err)
120			return
121			}
122
123			if permission {
124			ctx := bot.NewContext(
125			botId,
126			discord,
127			guild,
128			channel,
129			user,
130			message,
131			conf,
132			CmdHandler,
133			Sessions,
134			youtube,
135			botMsg,
136			dataType,
137			dbWorker,
138			guilds,
139			botCron)
140			ctx.Args = args[1:]
141			c := *command
142			c(*ctx)
143			//ctx.MetricsMessage()
144			} else {
145			dbWorker.Log("Message", guild.ID, msg)
146			query := []byte(fmt.Sprintf("logs,server=%v module=\"%v\"", guild.ID, "message"))
147			addr := fmt.Sprintf("%v/write?db=%v", conf.Metrics.Address, conf.Metrics.Database)
148			r := bytes.NewReader(query)
149			_, _ = http.Post(addr, "", r)
150			}
151			}
152
153			// Adds bot commands
154			func registerCommands() {
155			CmdHandler.Register("!r", cmd.PlayerCommand)
156			CmdHandler.Register("!w", cmd.WeatherCommand)
157			CmdHandler.Register("!t", cmd.TranslateCommand)
158			CmdHandler.Register("!n", cmd.NewsCommand)
159			CmdHandler.Register("!c", cmd.CurrencyCommand)
160			CmdHandler.Register("!y", cmd.YoutubeCommand)
161			CmdHandler.Register("!v", cmd.VoiceCommand)
162			CmdHandler.Register("!b", cmd.BotCommand)
163			CmdHandler.Register("!play", cmd.YoutubeShortCommand)
164			CmdHandler.Register("!d", cmd.DebugCommand)
165			CmdHandler.Register("!p", cmd.PollCommand)
166			CmdHandler.Register("!m", cmd.YandexmapCommand)
167			CmdHandler.Register("!dice", cmd.DiceCommand)
168			CmdHandler.Register("!help", cmd.HelpCommand)
169			CmdHandler.Register("!cron", cmd.CronCommand)
170			}
171
172			func MetricsSender() {
			0 ignored issues – show introduced 2019-01-21 05:30 UTC by Report Bug Copy Issue Report exported function MetricsSender should have comment or be unexported Loading history...
173			for {
174			query := []byte(fmt.Sprintf("messages count=%v", messagesCounter))
175			addr := fmt.Sprintf("%v/write?db=%v", conf.Metrics.Address, conf.Metrics.Database)
176			r := bytes.NewReader(query)
177			_, _ = http.Post(addr, "", r)
178			messagesCounter = 0
179			time.Sleep(time.Minute)
180			}
181			}

FlameInTheDark / dtbot

Push — master ( 23ac56...137631 )

main.main B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like