// getAllUsernamesForChat returns all usernames for a chat, sans the sender's.
func (j *JarvisBot) getAllUsernamesForChat(chat *telebot.Chat, sender *telebot.User) (string, error) {
uArray, groupID, senderID := []string{}, strconv.Itoa(int(chat.ID)), strconv.Itoa(sender.ID)
if !chat.IsGroupChat() {
return "", fmt.Errorf("chat %s is not a group chat!", groupID)
}
err := j.db.View(func(tx *bolt.Tx) error {
b := tx.Bucket(group_usernames_bucket_name)
gb := b.Bucket([]byte(groupID))
if gb == nil {
return fmt.Errorf("error retrieving bucket for group ID %s", groupID)
}
gb.ForEach(func(k, v []byte) error {
key, curr := string(k), string(v)
if key != senderID && key != timestampKey && key != countKey {
uArray = append(uArray, curr)
}
return nil
})
return nil
})
if err != nil {
return "", err
}
res := ""
for _, v := range uArray {
res = res + "@" + v + " "
}
return res, nil
}
// usernameExistsForChat checks if a username exists for a given chat.
// This returns false if the userID exists but the username has changed.
func (j *JarvisBot) usernameExistsForChat(chat *telebot.Chat, sender *telebot.User) bool {
res := false
// Guard against possibility that chat isn't a group chat.
// We're lazy here, returning true implies that we don't want to run a save.
if !chat.IsGroupChat() {
return true
}
groupID, senderID, username := strconv.Itoa(int(chat.ID)), strconv.Itoa(sender.ID), sender.Username
j.db.View(func(tx *bolt.Tx) error {
b := tx.Bucket(group_usernames_bucket_name)
gb := b.Bucket([]byte(groupID))
if gb == nil {
return nil
}
v := gb.Get([]byte(senderID))
if v != nil && string(v) == username {
res = true
return nil
}
return nil
})
return res
}
// GetDefinition get definition
func GetDefinition(msg string, sender telebot.Chat) string {
var definition string
if sender.IsGroupChat() {
if strings.HasPrefix(msg, BOT_NAME) {
msg = msg[len(BOT_NAME):]
} else if strings.HasSuffix(msg, BOT_NAME) {
msg = msg[:len(msg)-len(BOT_NAME)]
} else {
return ""
}
}
switch {
case strings.HasPrefix(msg, "/start"):
definition = fmt.Sprintf(GREETING_MSG, GetName(sender), GetName(sender))
case strings.HasPrefix(msg, "/") || msg == "":
definition = HELP_MSG
case strings.HasPrefix(msg, "/stop"):
definition = BYE_MSG
default:
definition = GetDefinitionFromDb(msg, sender)
}
return definition
}
func GetName(sender telebot.Chat) string {
name := sender.FirstName + " " + sender.LastName
if sender.IsGroupChat() {
name = sender.Title
}
return name
}
// saveUsernameSafely checks if a user exists in a given group chat, and saves if he/she
// doesn't currently exist.
// We try as much as possible to avoid opening a Read-Write transaction, because
// Bolt can only have one Read-Write transaction at any time.
func (j *JarvisBot) saveUsernameSafely(chat *telebot.Chat, sender *telebot.User) {
if sender.Username == "" || !chat.IsGroupChat() {
return
}
if !j.usernameExistsForChat(chat, sender) {
err := j.saveUserToDB(chat, sender)
if err != nil {
j.log.Printf("[%s] error saving user %s to group %s: %s", time.Now().Format(time.RFC3339), sender.Username, chat.Title, err)
}
}
}
// updateLastSentTime updates the last sent time for a given chat.
func (j *JarvisBot) updateLastSentTime(chat *telebot.Chat) error {
if !chat.IsGroupChat() {
return fmt.Errorf("chat is not a group chat!")
}
groupID := strconv.Itoa(int(chat.ID))
err := j.db.Update(func(tx *bolt.Tx) error {
b := tx.Bucket(group_usernames_bucket_name)
gb := b.Bucket([]byte(groupID))
if gb == nil {
return fmt.Errorf("invariant error - group bucket does not exist, yet attempt to update timestamp")
}
timeString := gb.Get([]byte(timestampKey))
if timeString == nil {
return resetTime(gb)
} else {
lastTime, err := time.Parse(time.RFC3339, string(timeString))
if err != nil {
return err
}
if time.Since(lastTime) > time.Hour {
return resetTime(gb)
} else {
countBytes := gb.Get([]byte(countKey))
if countBytes == nil {
return fmt.Errorf("invariant error - timestamp was saved but no count exists")
}
lastCount, err := strconv.Atoi(string(countBytes))
if err != nil {
return err
}
newCount := strconv.Itoa(lastCount + 1)
err = gb.Put([]byte(countKey), []byte(newCount))
if err != nil {
return err
}
}
}
return nil
})
return err
}
