bot/database.go - Code Metrics - Inspection of "Added blacklist" - FlameInTheDark/dtbot - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 5ddae7...29f8b3 )

by Viktor

created 2019-05-06 07:10 UTC

bot/database.go B

↳ Parent: Project

Size/Duplication

Total Lines	294
Duplicated Lines	0 %

Importance

Changes

Metric	Value
cc	44
eloc	183
dl	0
loc	294
rs	8.8798
c	0
b	0
f	0

23 Methods

Rating	Name	Size	Complexity
A	bot.*DBWorker.GetRadioStations	11	3
A	bot.*DBWorker.AddBlacklistUser	4	2
A	bot.*DBWorker.UpdateAlbionPlayerLast	7	2
A	bot.*DBWorker.RemoveStream	2	1
A	bot.*DBWorker.AddRadioStation	4	1
A	bot.NewDBSession	11	3
A	bot.*DBWorker.GetAlbionPlayers	4	1
A	bot.*DBWorker.RemoveBlacklistUser	4	2
A	bot.*DBWorker.RemoveRadioStation	3	1
A	bot.*DBWorker.AddStream	2	1
A	bot.*DBWorker.RemoveAlbionPlayer	4	2
A	bot.*DBWorker.Log	2	1
A	bot.*DBWorker.AddBlacklistGuild	4	2
A	bot.*DBWorker.GetRadioStationByKey	8	2
A	bot.*DBWorker.RemoveBlacklistGuild	4	2
A	bot.*DBWorker.AddAlbionPlayer	4	2
A	bot.*DBWorker.GetTwitchStreams	11	3
A	bot.*DBWorker.InitNewGuild	13	1
B	bot.*DBWorker.InitGuilds	35	5
A	bot.*DBWorker.UpdateStream	7	2
A	bot.*DBWorker.LogGet	4	1
A	bot.*DBWorker.GetBlacklist	17	3
A	bot.*DBWorker.Guilds	2	1

package bot

import (
	"fmt"
	"github.com/bwmarrin/discordgo"
	"github.com/globalsign/mgo"
	"github.com/globalsign/mgo/bson"
	"os"
	"time"
)

// DBWorker MongoDB instance
type DBWorker struct {
	DBSession *mgo.Session
	DBName    string
}

type dbLog struct {
	Date   time.Time
	Text   string
	Module string
	Guild  string
}

// GuildData contains data about guild settings
type GuildData struct {
	ID          string
	WeatherCity string
	NewsCounty  string
	Language    string
	Timezone    int
	EmbedColor  int
	VoiceVolume float32
	Greeting    string
}

// GuildsMap contains guilds settings
type GuildsMap struct {
	Guilds map[string]*GuildData
}

// RadioStation contains info about radio station
type RadioStation struct {
	Name     string
	URL      string
	Key      string
	Category string
}

type BlackListElement struct {

	ID string
}

// NewDBSession creates new MongoDB instance
func NewDBSession(dbname string) *DBWorker {
	session, err := mgo.Dial(os.Getenv("MONGO_CONN"))
	if err != nil {
		fmt.Printf("Mongo connection error: %v", err)
	}
	count, err := session.DB("dtbot").C("logs").Count()
	if err != nil {
		fmt.Println("DB_ERR: ", err)
	}
	fmt.Printf("Mongo connected\nLogs in base: %v\n", count)
	return &DBWorker{DBSession: session, DBName: dbname}
}

// InitGuilds initialize guilds in database
func (db *DBWorker) InitGuilds(sess *discordgo.Session, conf *Config) *GuildsMap {
	var data = &GuildsMap{Guilds: make(map[string]*GuildData)}
	var loaded, initialized = 0, 0
	for _, guild := range sess.State.Guilds {
		count, err := db.DBSession.DB(db.DBName).C("guilds").Find(bson.M{"id": guild.ID}).Count()
		if err != nil {
			fmt.Println("Mongo: ", err)
		}
		if count == 0 {
			newData := &GuildData{
				ID:          guild.ID,
				WeatherCity: conf.Weather.City,
				NewsCounty:  conf.News.Country,
				Language:    conf.General.Language,
				Timezone:    conf.General.Timezone,
				EmbedColor:  conf.General.EmbedColor,
				VoiceVolume: conf.Voice.Volume,
				Greeting:    "",
			}
			_ = db.DBSession.DB(db.DBName).C("guilds").Insert(newData)
			data.Guilds[guild.ID] = newData
			initialized++
		} else {
			var newData = &GuildData{}
			_ = db.DBSession.DB(db.DBName).C("guilds").Find(bson.M{"id": guild.ID}).One(newData)
			if err != nil {
				fmt.Println("Mongo: ", err)
				continue
			}
			data.Guilds[guild.ID] = newData
			loaded++
		}
	}
	fmt.Printf("Guilds loaded [%v], initialized [%v]\n", loaded, initialized)
	return data
}

// InitNewGuild creates new guild in database
func (db *DBWorker) InitNewGuild(guildID string, conf *Config, data *GuildsMap) {
	newData := &GuildData{
		ID:          guildID,
		WeatherCity: conf.Weather.City,
		NewsCounty:  conf.News.Country,
		Language:    conf.General.Language,
		Timezone:    conf.General.Timezone,
		EmbedColor:  conf.General.EmbedColor,
		VoiceVolume: conf.Voice.Volume,
		Greeting:    "",
	}
	_ = db.DBSession.DB(db.DBName).C("guilds").Insert(newData)
	data.Guilds[guildID] = newData
}

// Log saves log in database
func (db *DBWorker) Log(module, guildID, text string) {
	_ = db.DBSession.DB(db.DBName).C("logs").Insert(dbLog{Date: time.Now(), Text: text, Module: module, Guild: guildID})
}

// LogGet returns last N log rows
func (db *DBWorker) LogGet(count int) []dbLog {

	var log = make([]dbLog, count)
	_ = db.DBSession.DB(db.DBName).C("logs").Find(nil).Sort("-$natural").Limit(count).All(&log)
	return log
}

// Guilds returns guilds collection from mongodb
func (db *DBWorker) Guilds() *mgo.Collection {
	return db.DBSession.DB(db.DBName).C("guilds")
}

// GetTwitchStreams returns twitch streams from mongodb
func (db *DBWorker) GetTwitchStreams(guildID string) map[string]*TwitchStream {
	streams := []TwitchStream{}
	err := db.DBSession.DB(db.DBName).C("streams").Find(bson.M{"guild": guildID}).All(&streams)
	if err != nil {
		fmt.Println("Mongo: ", err)
	}
	var newMap = make(map[string]*TwitchStream)
	for i, s := range streams {
		newMap[s.Login] = &streams[i]
	}
	return newMap
}

// UpdateStream updates stream in mongodb
func (db *DBWorker) UpdateStream(stream *TwitchStream) {
	err := db.DBSession.DB(db.DBName).C("streams").
		Update(
			bson.M{"guild": stream.Guild, "login": stream.Login},
			bson.M{"$set": bson.M{"isonline": stream.IsOnline}})
	if err != nil {
		fmt.Println(err.Error())
	}
}

// AddStream adds stream in mongodb
func (db *DBWorker) AddStream(stream *TwitchStream) {
	_ = db.DBSession.DB(db.DBName).C("streams").Insert(stream)
}

// RemoveStream removes stream from mongodb
func (db *DBWorker) RemoveStream(stream *TwitchStream) {
	_ = db.DBSession.DB(db.DBName).C("streams").Remove(bson.M{"login": stream.Login, "guild": stream.Guild})
}

// GetRadioStations gets stations from database and returns slice of them
func (db *DBWorker) GetRadioStations(category string) []RadioStation {
	stations := []RadioStation{}
	var request = bson.M{}
	if category != "" {
		request = bson.M{"category": category}
	}
	err := db.DBSession.DB(db.DBName).C("stations").Find(request).All(&stations)
	if err != nil {
		fmt.Println("Mongo: ", err)
	}
	return stations
}

// GetRadioStationByKey returns one station by key
func (db *DBWorker) GetRadioStationByKey(key string) (*RadioStation, error) {
	station := RadioStation{}
	err := db.DBSession.DB(db.DBName).C("stations").Find(bson.M{"key": key}).One(&station)
	if err != nil {
		fmt.Println("Mongo: ", err)
		return nil, fmt.Errorf("station not found")
	}
	return &station, nil
}

// RemoveRadioStation removes radio station by key
func (db *DBWorker) RemoveRadioStation(key string) error {
	err := db.DBSession.DB(db.DBName).C("stations").Remove(bson.M{"key": key})
	return err
}

// AddRadioStation adds new radio station
func (db *DBWorker) AddRadioStation(name, url, key, category string) error {
	station := RadioStation{Name: name, URL: url, Key: key, Category: category}
	err := db.DBSession.DB(db.DBName).C("stations").Insert(&station)
	return err
}

// GetAlbionPlayers gets players from database
func (db *DBWorker) GetAlbionPlayers() []AlbionPlayerUpdater {
	var kills []AlbionPlayerUpdater
	_ = db.DBSession.DB(db.DBName).C("albion").Find(nil).All(&kills)
	return kills
}

// AddAlbionPlayer adds new player in database
func (db *DBWorker) AddAlbionPlayer(player *AlbionPlayerUpdater) {
	err := db.DBSession.DB(db.DBName).C("albion").Insert(player)
	if err != nil {
		fmt.Println("Error adding Albion player: ", err.Error())
	}
}

// RemoveAlbionPlayer removes player from database
func (db *DBWorker) RemoveAlbionPlayer(id string) {
	err := db.DBSession.DB(db.DBName).C("albion").Remove(bson.M{"userid": id})
	if err != nil {
		fmt.Println("Error removing Albion player: ", err.Error())
	}
}

// UpdateAlbionPlayerLast updates last kill of albion player
func (db *DBWorker) UpdateAlbionPlayerLast(userID string, lastKill int64) {
	err := db.DBSession.DB(db.DBName).C("albion").
		Update(
			bson.M{"userid": userID},
			bson.M{"$set": bson.M{"lastkill": lastKill}})
	if err != nil {
		fmt.Println(err.Error())
	}
}

// GetBlackList gets blacklist from database

func (db *DBWorker) GetBlacklist() *BlackListStruct {
	var (
		blacklist BlackListStruct
		Guilds []BlackListElement
		Users  []BlackListElement
	)
	_ = db.DBSession.DB(db.DBName).C("blusers").Find(nil).All(&Users)
	_ = db.DBSession.DB(db.DBName).C("blguilds").Find(nil).All(&Guilds)

	for _, g := range Guilds {
		blacklist.Guilds = append(blacklist.Guilds, g.ID)
	}
	for _, u := range Users {
		blacklist.Users = append(blacklist.Users, u.ID)
	}

	return &blacklist
}

// AddBlacklistGuild adds guild in database blacklist
func (db *DBWorker) AddBlacklistGuild(id string) {
	err := db.DBSession.DB(db.DBName).C("blguilds").Insert(BlackListElement{ID: id})
	if err != nil {
		fmt.Println("Error adding guild in blacklist: ", err.Error())
	}
}

// AddBlacklistUser adds user in database blacklist
func (db *DBWorker) AddBlacklistUser(id string) {
	err := db.DBSession.DB(db.DBName).C("blusers").Insert(BlackListElement{ID: id})
	if err != nil {
		fmt.Println("Error adding user in blacklist: ", err.Error())
	}
}

// RemoveBlacklistGuild removes guild from database blacklist
func (db *DBWorker) RemoveBlacklistGuild(id string) {
	err := db.DBSession.DB(db.DBName).C("blguilds").Remove(bson.M{"id": id})
	if err != nil {
		fmt.Println("Error removing guild from blacklist: ", err.Error())
	}
}

// RemoveBlacklistUser removes user from database blacklist
func (db *DBWorker) RemoveBlacklistUser(id string) {
	err := db.DBSession.DB(db.DBName).C("blusers").Remove(bson.M{"id": id})
	if err != nil {
		fmt.Println("Error removing user from blacklist: ", err.Error())
	}
}

1			package bot
2
3			import (
4			"fmt"
5			"github.com/bwmarrin/discordgo"
6			"github.com/globalsign/mgo"
7			"github.com/globalsign/mgo/bson"
8			"os"
9			"time"
10			)
11
12			// DBWorker MongoDB instance
13			type DBWorker struct {
14			DBSession *mgo.Session
15			DBName string
16			}
17
18			type dbLog struct {
19			Date time.Time
20			Text string
21			Module string
22			Guild string
23			}
24
25			// GuildData contains data about guild settings
26			type GuildData struct {
27			ID string
28			WeatherCity string
29			NewsCounty string
30			Language string
31			Timezone int
32			EmbedColor int
33			VoiceVolume float32
34			Greeting string
35			}
36
37			// GuildsMap contains guilds settings
38			type GuildsMap struct {
39			Guilds map[string]*GuildData
40			}
41
42			// RadioStation contains info about radio station
43			type RadioStation struct {
44			Name string
45			URL string
46			Key string
47			Category string
48			}
49
50			type BlackListElement struct {
			0 ignored issues – show introduced 2019-05-06 07:12 UTC by Report Bug Copy Issue Report exported type BlackListElement should have comment or be unexported Loading history...
51			ID string
52			}
53
54			// NewDBSession creates new MongoDB instance
55			func NewDBSession(dbname string) *DBWorker {
56			session, err := mgo.Dial(os.Getenv("MONGO_CONN"))
57			if err != nil {
58			fmt.Printf("Mongo connection error: %v", err)
59			}
60			count, err := session.DB("dtbot").C("logs").Count()
61			if err != nil {
62			fmt.Println("DB_ERR: ", err)
63			}
64			fmt.Printf("Mongo connected\nLogs in base: %v\n", count)
65			return &DBWorker{DBSession: session, DBName: dbname}
66			}
67
68			// InitGuilds initialize guilds in database
69			func (db DBWorker) InitGuilds(sess discordgo.Session, conf Config) GuildsMap {
70			var data = &GuildsMap{Guilds: make(map[string]*GuildData)}
71			var loaded, initialized = 0, 0
72			for _, guild := range sess.State.Guilds {
73			count, err := db.DBSession.DB(db.DBName).C("guilds").Find(bson.M{"id": guild.ID}).Count()
74			if err != nil {
75			fmt.Println("Mongo: ", err)
76			}
77			if count == 0 {
78			newData := &GuildData{
79			ID: guild.ID,
80			WeatherCity: conf.Weather.City,
81			NewsCounty: conf.News.Country,
82			Language: conf.General.Language,
83			Timezone: conf.General.Timezone,
84			EmbedColor: conf.General.EmbedColor,
85			VoiceVolume: conf.Voice.Volume,
86			Greeting: "",
87			}
88			_ = db.DBSession.DB(db.DBName).C("guilds").Insert(newData)
89			data.Guilds[guild.ID] = newData
90			initialized++
91			} else {
92			var newData = &GuildData{}
93			_ = db.DBSession.DB(db.DBName).C("guilds").Find(bson.M{"id": guild.ID}).One(newData)
94			if err != nil {
95			fmt.Println("Mongo: ", err)
96			continue
97			}
98			data.Guilds[guild.ID] = newData
99			loaded++
100			}
101			}
102			fmt.Printf("Guilds loaded [%v], initialized [%v]\n", loaded, initialized)
103			return data
104			}
105
106			// InitNewGuild creates new guild in database
107			func (db DBWorker) InitNewGuild(guildID string, conf Config, data *GuildsMap) {
108			newData := &GuildData{
109			ID: guildID,
110			WeatherCity: conf.Weather.City,
111			NewsCounty: conf.News.Country,
112			Language: conf.General.Language,
113			Timezone: conf.General.Timezone,
114			EmbedColor: conf.General.EmbedColor,
115			VoiceVolume: conf.Voice.Volume,
116			Greeting: "",
117			}
118			_ = db.DBSession.DB(db.DBName).C("guilds").Insert(newData)
119			data.Guilds[guildID] = newData
120			}
121
122			// Log saves log in database
123			func (db *DBWorker) Log(module, guildID, text string) {
124			_ = db.DBSession.DB(db.DBName).C("logs").Insert(dbLog{Date: time.Now(), Text: text, Module: module, Guild: guildID})
125			}
126
127			// LogGet returns last N log rows
128			func (db *DBWorker) LogGet(count int) []dbLog {
			0 ignored issues – show introduced 2018-11-08 05:49 UTC by Report Bug Copy Issue Report exported method LogGet returns unexported type []bot.dbLog, which can be annoying to use Loading history...
129			var log = make([]dbLog, count)
130			_ = db.DBSession.DB(db.DBName).C("logs").Find(nil).Sort("-$natural").Limit(count).All(&log)
131			return log
132			}
133
134			// Guilds returns guilds collection from mongodb
135			func (db DBWorker) Guilds() mgo.Collection {
136			return db.DBSession.DB(db.DBName).C("guilds")
137			}
138
139			// GetTwitchStreams returns twitch streams from mongodb
140			func (db DBWorker) GetTwitchStreams(guildID string) map[string]TwitchStream {
141			streams := []TwitchStream{}
142			err := db.DBSession.DB(db.DBName).C("streams").Find(bson.M{"guild": guildID}).All(&streams)
143			if err != nil {
144			fmt.Println("Mongo: ", err)
145			}
146			var newMap = make(map[string]*TwitchStream)
147			for i, s := range streams {
148			newMap[s.Login] = &streams[i]
149			}
150			return newMap
151			}
152
153			// UpdateStream updates stream in mongodb
154			func (db DBWorker) UpdateStream(stream TwitchStream) {
155			err := db.DBSession.DB(db.DBName).C("streams").
156			Update(
157			bson.M{"guild": stream.Guild, "login": stream.Login},
158			bson.M{"$set": bson.M{"isonline": stream.IsOnline}})
159			if err != nil {
160			fmt.Println(err.Error())
161			}
162			}
163
164			// AddStream adds stream in mongodb
165			func (db DBWorker) AddStream(stream TwitchStream) {
166			_ = db.DBSession.DB(db.DBName).C("streams").Insert(stream)
167			}
168
169			// RemoveStream removes stream from mongodb
170			func (db DBWorker) RemoveStream(stream TwitchStream) {
171			_ = db.DBSession.DB(db.DBName).C("streams").Remove(bson.M{"login": stream.Login, "guild": stream.Guild})
172			}
173
174			// GetRadioStations gets stations from database and returns slice of them
175			func (db *DBWorker) GetRadioStations(category string) []RadioStation {
176			stations := []RadioStation{}
177			var request = bson.M{}
178			if category != "" {
179			request = bson.M{"category": category}
180			}
181			err := db.DBSession.DB(db.DBName).C("stations").Find(request).All(&stations)
182			if err != nil {
183			fmt.Println("Mongo: ", err)
184			}
185			return stations
186			}
187
188			// GetRadioStationByKey returns one station by key
189			func (db DBWorker) GetRadioStationByKey(key string) (RadioStation, error) {
190			station := RadioStation{}
191			err := db.DBSession.DB(db.DBName).C("stations").Find(bson.M{"key": key}).One(&station)
192			if err != nil {
193			fmt.Println("Mongo: ", err)
194			return nil, fmt.Errorf("station not found")
195			}
196			return &station, nil
197			}
198
199			// RemoveRadioStation removes radio station by key
200			func (db *DBWorker) RemoveRadioStation(key string) error {
201			err := db.DBSession.DB(db.DBName).C("stations").Remove(bson.M{"key": key})
202			return err
203			}
204
205			// AddRadioStation adds new radio station
206			func (db *DBWorker) AddRadioStation(name, url, key, category string) error {
207			station := RadioStation{Name: name, URL: url, Key: key, Category: category}
208			err := db.DBSession.DB(db.DBName).C("stations").Insert(&station)
209			return err
210			}
211
212			// GetAlbionPlayers gets players from database
213			func (db *DBWorker) GetAlbionPlayers() []AlbionPlayerUpdater {
214			var kills []AlbionPlayerUpdater
215			_ = db.DBSession.DB(db.DBName).C("albion").Find(nil).All(&kills)
216			return kills
217			}
218
219			// AddAlbionPlayer adds new player in database
220			func (db DBWorker) AddAlbionPlayer(player AlbionPlayerUpdater) {
221			err := db.DBSession.DB(db.DBName).C("albion").Insert(player)
222			if err != nil {
223			fmt.Println("Error adding Albion player: ", err.Error())
224			}
225			}
226
227			// RemoveAlbionPlayer removes player from database
228			func (db *DBWorker) RemoveAlbionPlayer(id string) {
229			err := db.DBSession.DB(db.DBName).C("albion").Remove(bson.M{"userid": id})
230			if err != nil {
231			fmt.Println("Error removing Albion player: ", err.Error())
232			}
233			}
234
235			// UpdateAlbionPlayerLast updates last kill of albion player
236			func (db *DBWorker) UpdateAlbionPlayerLast(userID string, lastKill int64) {
237			err := db.DBSession.DB(db.DBName).C("albion").
238			Update(
239			bson.M{"userid": userID},
240			bson.M{"$set": bson.M{"lastkill": lastKill}})
241			if err != nil {
242			fmt.Println(err.Error())
243			}
244			}
245
246			// GetBlackList gets blacklist from database
			0 ignored issues – show introduced 2019-05-06 07:12 UTC by Report Bug Copy Issue Report comment on exported method DBWorker.GetBlacklist should be of the form "GetBlacklist ..." Loading history...
247			func (db DBWorker) GetBlacklist() BlackListStruct {
248			var (
249			blacklist BlackListStruct
250			Guilds []BlackListElement
251			Users []BlackListElement
252			)
253			_ = db.DBSession.DB(db.DBName).C("blusers").Find(nil).All(&Users)
254			_ = db.DBSession.DB(db.DBName).C("blguilds").Find(nil).All(&Guilds)
255
256			for _, g := range Guilds {
257			blacklist.Guilds = append(blacklist.Guilds, g.ID)
258			}
259			for _, u := range Users {
260			blacklist.Users = append(blacklist.Users, u.ID)
261			}
262
263			return &blacklist
264			}
265
266			// AddBlacklistGuild adds guild in database blacklist
267			func (db *DBWorker) AddBlacklistGuild(id string) {
268			err := db.DBSession.DB(db.DBName).C("blguilds").Insert(BlackListElement{ID: id})
269			if err != nil {
270			fmt.Println("Error adding guild in blacklist: ", err.Error())
271			}
272			}
273
274			// AddBlacklistUser adds user in database blacklist
275			func (db *DBWorker) AddBlacklistUser(id string) {
276			err := db.DBSession.DB(db.DBName).C("blusers").Insert(BlackListElement{ID: id})
277			if err != nil {
278			fmt.Println("Error adding user in blacklist: ", err.Error())
279			}
280			}
281
282			// RemoveBlacklistGuild removes guild from database blacklist
283			func (db *DBWorker) RemoveBlacklistGuild(id string) {
284			err := db.DBSession.DB(db.DBName).C("blguilds").Remove(bson.M{"id": id})
285			if err != nil {
286			fmt.Println("Error removing guild from blacklist: ", err.Error())
287			}
288			}
289
290			// RemoveBlacklistUser removes user from database blacklist
291			func (db *DBWorker) RemoveBlacklistUser(id string) {
292			err := db.DBSession.DB(db.DBName).C("blusers").Remove(bson.M{"id": id})
293			if err != nil {
294			fmt.Println("Error removing user from blacklist: ", err.Error())
295			}
296			}

FlameInTheDark / dtbot

Push — master ( 5ddae7...29f8b3 )

bot/database.go B

Size/Duplication

Importance

23 Methods

Duplication Side-by-Side

Filter issues like