376 lines
9.0 KiB
Go
376 lines
9.0 KiB
Go
package main
|
|
|
|
import (
|
|
"encoding/json"
|
|
"log"
|
|
"sort"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"github.com/go-redis/redis"
|
|
tb "gopkg.in/tucnak/telebot.v2"
|
|
)
|
|
|
|
type userGroup int
|
|
|
|
const (
|
|
ugSoprano userGroup = iota
|
|
ugContralto
|
|
ugTenore
|
|
ugBasso
|
|
ugCommissario
|
|
ugReferente
|
|
ugPreparatore
|
|
)
|
|
|
|
func addUser(user *tb.User) error {
|
|
if redisClient == nil {
|
|
return ErrNilPointer
|
|
}
|
|
err := redisClient.SAdd(usersID, user.ID).Err()
|
|
if err != nil {
|
|
log.Printf("Error in adding user ID: %v", err)
|
|
return ErrRedisAddSet
|
|
}
|
|
jsonUser, err := json.Marshal(&user)
|
|
if err != nil {
|
|
log.Printf("Error in marshalling user to json: %v", err)
|
|
return ErrJSONMarshall
|
|
}
|
|
err = redisClient.HSet(usersInfo, strconv.Itoa(user.ID), jsonUser).Err()
|
|
if err != nil {
|
|
log.Printf("Error adding user info in hash: %v", err)
|
|
return ErrRedisAddHash
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func isUser(userID int) (bool, error) {
|
|
if redisClient == nil {
|
|
return false, ErrNilPointer
|
|
}
|
|
user, err := redisClient.SIsMember(usersID, strconv.Itoa(userID)).Result()
|
|
if err != nil {
|
|
log.Printf("Error checking if ID is bot user: %v", err)
|
|
return false, ErrRedisCheckSet
|
|
}
|
|
return user, nil
|
|
}
|
|
|
|
func getUserInfo(userID int) (*tb.User, error) {
|
|
if redisClient == nil {
|
|
return nil, ErrNilPointer
|
|
}
|
|
user, err := redisClient.HGet(usersInfo, strconv.Itoa(userID)).Result()
|
|
if err != nil {
|
|
log.Printf("Error retriving user info from hash: %v", err)
|
|
return nil, ErrRedisRetrieveHash
|
|
}
|
|
jsonUser := &tb.User{}
|
|
err = json.Unmarshal([]byte(user), jsonUser)
|
|
if err != nil {
|
|
log.Printf("Error unmarshalling user info: %v", err)
|
|
return nil, ErrJSONUnmarshall
|
|
}
|
|
return jsonUser, nil
|
|
}
|
|
|
|
func isStartedUser(userID int) (bool, error) {
|
|
if redisClient == nil {
|
|
return false, ErrNilPointer
|
|
}
|
|
started, err := redisClient.SIsMember(startedUsers, strconv.Itoa(userID)).Result()
|
|
if err != nil {
|
|
log.Printf("Error checking if user is started: %v", err)
|
|
return false, ErrRedisCheckSet
|
|
}
|
|
return started, nil
|
|
}
|
|
|
|
func startUser(userID int, start bool) error {
|
|
if redisClient == nil {
|
|
return ErrNilPointer
|
|
}
|
|
if start {
|
|
err := redisClient.SAdd(startedUsers, strconv.Itoa(userID)).Err()
|
|
if err != nil {
|
|
log.Printf("Error adding token to set: %v", err)
|
|
return ErrRedisAddSet
|
|
}
|
|
} else {
|
|
err := redisClient.SRem(startedUsers, strconv.Itoa(userID)).Err()
|
|
if err != nil {
|
|
log.Printf("Error removing token from set: %v", err)
|
|
return ErrRedisRemSet
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func isAuthrizedUser(userID int) (bool, error) {
|
|
if redisClient == nil {
|
|
return false, ErrNilPointer
|
|
}
|
|
auth, err := redisClient.SIsMember(authUsers, strconv.Itoa(userID)).Result()
|
|
if err != nil {
|
|
log.Printf("Error checking if user is authorized: %v", err)
|
|
return false, ErrRedisCheckSet
|
|
}
|
|
return auth, nil
|
|
}
|
|
|
|
func authorizeUser(userID int, authorize bool) error {
|
|
if redisClient == nil {
|
|
return ErrNilPointer
|
|
}
|
|
isAuthUser, err := isAuthrizedUser(userID)
|
|
if err != nil {
|
|
log.Printf("Error checking if user is authorized: %v", err)
|
|
}
|
|
if isAuthUser && authorize {
|
|
return nil
|
|
}
|
|
|
|
user, err := getUserInfo(userID)
|
|
if err != nil {
|
|
log.Printf("Error getting user info: %v", err)
|
|
return ErrGetUser
|
|
}
|
|
if authorize {
|
|
err := redisClient.SAdd(authUsers, strconv.Itoa(userID)).Err()
|
|
if err != nil {
|
|
log.Printf("Error adding token to set: %v", err)
|
|
return ErrRedisAddSet
|
|
}
|
|
err = sendMsgWithMenu(user, newAuthMsg, true)
|
|
if err != nil {
|
|
log.Printf("Error sending message to new authorized user: %v", err)
|
|
return ErrSendMsg
|
|
}
|
|
} else {
|
|
err := redisClient.SRem(authUsers, strconv.Itoa(userID)).Err()
|
|
if err != nil {
|
|
log.Printf("Error removing token from set: %v", err)
|
|
return ErrRedisRemSet
|
|
}
|
|
err = sendMsg(user, delAuthMsg, true)
|
|
if err != nil {
|
|
log.Printf("Error sending message to removed authorized user: %v", err)
|
|
return ErrSendMsg
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func addUserGroups(userID int, groups ...userGroup) error {
|
|
if redisClient == nil {
|
|
return ErrNilPointer
|
|
}
|
|
sort.Slice(groups, func(i, j int) bool { return groups[i] < groups[j] })
|
|
var csvGroups string
|
|
for _, group := range groups {
|
|
csvGroups += strconv.Itoa(int(group)) + ","
|
|
err := redisClient.SAdd("ug"+strconv.Itoa(int(group)), strconv.Itoa(userID)).Err()
|
|
if err != nil {
|
|
log.Printf("Error adding user to usergroup set: %v", err)
|
|
return ErrRedisAddSet
|
|
}
|
|
}
|
|
err := redisClient.HSet(usersGroups, strconv.Itoa(userID), csvGroups).Err()
|
|
if err != nil {
|
|
log.Printf("Error adding user groups to hash: %v", err)
|
|
return ErrRedisAddHash
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func remUserGroups(userID int, newGroups []userGroup, remGroups ...userGroup) error {
|
|
if redisClient == nil {
|
|
return ErrNilPointer
|
|
}
|
|
sort.Slice(newGroups, func(i, j int) bool { return newGroups[i] < newGroups[j] })
|
|
|
|
for _, remGroup := range remGroups {
|
|
err := redisClient.SRem("ug"+strconv.Itoa(int(remGroup)), strconv.Itoa(userID)).Err()
|
|
if err != nil {
|
|
log.Printf("Error removing user from usergroup set: %v", err)
|
|
return ErrRedisAddSet
|
|
}
|
|
}
|
|
|
|
if len(newGroups) > 0 {
|
|
var csvGroups string
|
|
for _, group := range newGroups {
|
|
csvGroups += strconv.Itoa(int(group)) + ","
|
|
}
|
|
err := redisClient.HSet(usersGroups, strconv.Itoa(userID), csvGroups).Err()
|
|
if err != nil {
|
|
log.Printf("Error adding user groups to hash: %v", err)
|
|
return ErrRedisAddHash
|
|
}
|
|
} else {
|
|
err := redisClient.HDel(usersGroups, strconv.Itoa(userID)).Err()
|
|
if err != nil {
|
|
log.Printf("Error removing user from usersGroups hash: %v", err)
|
|
return ErrRedisAddHash
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func getUserGroups(userID int) ([]userGroup, error) {
|
|
if redisClient == nil {
|
|
return nil, ErrNilPointer
|
|
}
|
|
|
|
csvGroups, err := redisClient.HGet(usersGroups, strconv.Itoa(userID)).Result()
|
|
if err != nil && err != redis.Nil {
|
|
log.Printf("Error retriving user groups: %v", err)
|
|
return nil, ErrRedisRetrieveHash
|
|
}
|
|
if err == redis.Nil {
|
|
return nil, nil
|
|
}
|
|
var retGroups []userGroup
|
|
groups := strings.Split(csvGroups, ",")
|
|
for _, group := range groups {
|
|
if group != "" {
|
|
intGroup, err := strconv.Atoi(group)
|
|
if err != nil {
|
|
log.Printf("Error converting user group: %v", err)
|
|
return nil, ErrAtoiConv
|
|
}
|
|
retGroups = append(retGroups, userGroup(intGroup))
|
|
}
|
|
}
|
|
return retGroups, nil
|
|
}
|
|
|
|
func getUsersInGroup(group userGroup) ([]int, error) {
|
|
if redisClient == nil {
|
|
return nil, ErrNilPointer
|
|
}
|
|
users, err := redisClient.SMembers("ug" + strconv.Itoa(int(group))).Result()
|
|
if err != nil {
|
|
log.Printf("Error retriving users in group: %v", err)
|
|
return nil, ErrRedisRetrieveSet
|
|
}
|
|
var retUsers []int
|
|
for _, user := range users {
|
|
intUser, err := strconv.Atoi(user)
|
|
if err != nil {
|
|
log.Printf("Error converting user ID: %v", err)
|
|
return nil, ErrAtoiConv
|
|
}
|
|
retUsers = append(retUsers, intUser)
|
|
}
|
|
return retUsers, nil
|
|
}
|
|
|
|
func isUserInGroup(userID int, group userGroup) (bool, error) {
|
|
if redisClient == nil {
|
|
return false, ErrNilPointer
|
|
}
|
|
is, err := redisClient.SIsMember("ug"+strconv.Itoa(int(group)), strconv.Itoa(userID)).Result()
|
|
if err != nil {
|
|
log.Printf("Error checking if user is in group: %v", err)
|
|
return false, ErrRedisCheckSet
|
|
}
|
|
return is, nil
|
|
}
|
|
|
|
func convertUserGroups(groups []userGroup) []string {
|
|
var stringGroups []string
|
|
for _, group := range groups {
|
|
switch group {
|
|
case ugSoprano:
|
|
stringGroups = append(stringGroups, "Soprano")
|
|
case ugContralto:
|
|
stringGroups = append(stringGroups, "Contralto")
|
|
case ugTenore:
|
|
stringGroups = append(stringGroups, "Tenore")
|
|
case ugBasso:
|
|
stringGroups = append(stringGroups, "Basso")
|
|
case ugCommissario:
|
|
stringGroups = append(stringGroups, "Commissario")
|
|
case ugReferente:
|
|
stringGroups = append(stringGroups, "Referente")
|
|
case ugPreparatore:
|
|
stringGroups = append(stringGroups, "Preparatore")
|
|
}
|
|
}
|
|
|
|
return stringGroups
|
|
}
|
|
|
|
func getGroupName(group userGroup) (string, error) {
|
|
switch group {
|
|
case ugSoprano:
|
|
return "Soprano", nil
|
|
case ugContralto:
|
|
return "Contralto", nil
|
|
case ugTenore:
|
|
return "Tenore", nil
|
|
case ugBasso:
|
|
return "Basso", nil
|
|
case ugCommissario:
|
|
return "Commissario", nil
|
|
case ugReferente:
|
|
return "Referente", nil
|
|
case ugPreparatore:
|
|
return "Preparatore", nil
|
|
default:
|
|
return "", ErrGroupInvalid
|
|
}
|
|
}
|
|
|
|
func getUserDescription(u *tb.User) (string, error) {
|
|
userGroups, err := getUserGroups(u.ID)
|
|
if err != nil {
|
|
log.Printf("Error retriving user groups: %v", err)
|
|
return "", ErrRedisRetrieveHash
|
|
}
|
|
stringGroups := convertUserGroups(userGroups)
|
|
|
|
isAdmin, err := isBotAdmin(u.ID)
|
|
if err != nil {
|
|
log.Printf("Error checking if user is admin: %v", err)
|
|
return "", ErrRedisCheckSet
|
|
}
|
|
isAuth, err := isAuthrizedUser(u.ID)
|
|
if err != nil {
|
|
log.Printf("Error checking if user is authorized: %v", err)
|
|
return "", ErrRedisCheckSet
|
|
}
|
|
|
|
msg := "\xF0\x9F\x91\xA4 *INFORMAZIONI UTENTE*" +
|
|
"\n- *Nome*: " + u.FirstName +
|
|
"\n- *Username*: " + u.Username +
|
|
"\n- *ID*: " + strconv.Itoa(u.ID)
|
|
|
|
if len(stringGroups) > 0 {
|
|
msg += "\n- *Gruppi*: "
|
|
for i, group := range stringGroups {
|
|
msg += group
|
|
if i <= len(stringGroups)-2 {
|
|
msg += ", "
|
|
}
|
|
}
|
|
}
|
|
|
|
msg += "\n- *Tipo utente*: "
|
|
|
|
if isAdmin {
|
|
msg += "Admin"
|
|
} else if isAuth {
|
|
msg += "Autorizzato"
|
|
} else {
|
|
msg += "Utente semplice"
|
|
}
|
|
|
|
return msg, nil
|
|
}
|