Files
barandaBot/src/manageUser.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
}