Ripresa sviluppo. Ultime modifiche di cui non ricordo nulla

Signed-off-by: Ettore Dreucci <ettore.dreucci@gmail.com>

.gitignore

@@ -26,5 +26,9 @@ _testmain.go
 
 # ---> VisualStudioCode
 .settings
+*.code-workspace
+
+# Redis
+*.rdb
 
 

src/manageUser.go

@@ -3,17 +3,18 @@ package main
 import (
 	"encoding/json"
 	"log"
+	"sort"
 	"strconv"
 	"strings"
 
+	"github.com/go-redis/redis"
 	tb "gopkg.in/tucnak/telebot.v2"
 )
 
 type userGroup int
 
 const (
-	ugEsterno userGroup = iota
+	ugSoprano userGroup = iota
-	ugSoprano
 	ugContralto
 	ugTenore
 	ugBasso
@@ -42,12 +43,6 @@ func addUser(user *tb.User) error {
 		return ErrRedisAddHash
 	}
 
-	err = setUserGroups(user.ID, ugEsterno)
-	if err != nil {
-		log.Printf("Error setting user default group: %v", err)
-		return ErrRedisAddSet
-	}
-
 	return nil
 }
 
@@ -125,7 +120,7 @@ func isAuthrizedUser(userID int) (bool, error) {
 	return auth, nil
 }
 
-func authorizeUser(userID int, authorized bool) error {
+func authorizeUser(userID int, authorize bool) error {
 	if redisClient == nil {
 		return ErrNilPointer
 	}
@@ -133,7 +128,7 @@ func authorizeUser(userID int, authorized bool) error {
 	if err != nil {
 		log.Printf("Error checking if user is authorized: %v", err)
 	}
-	if isAuthUser {
+	if isAuthUser && authorize {
 		return nil
 	}
 
@@ -142,7 +137,7 @@ func authorizeUser(userID int, authorized bool) error {
 		log.Printf("Error getting user info: %v", err)
 		return ErrGetUser
 	}
-	if authorized {
+	if authorize {
 		err := redisClient.SAdd(authUsers, strconv.Itoa(userID)).Err()
 		if err != nil {
 			log.Printf("Error adding token to set: %v", err)
@@ -172,6 +167,7 @@ func setUserGroups(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)) + ","
@@ -196,10 +192,13 @@ func getUserGroups(userID int) ([]userGroup, error) {
 	}
 
 	csvGroups, err := redisClient.HGet(usersGroups, strconv.Itoa(userID)).Result()
-	if err != nil {
+	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 {
@@ -216,6 +215,9 @@ func getUserGroups(userID int) ([]userGroup, error) {
 }
 
 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)
@@ -233,12 +235,22 @@ func getUsersInGroup(group userGroup) ([]int, error) {
 	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 ugEsterno:
-			stringGroups = append(stringGroups, "Esterno al coro")
 		case ugSoprano:
 			stringGroups = append(stringGroups, "Soprano")
 		case ugContralto:
@@ -281,15 +293,17 @@ func getUserDescription(u *tb.User) (string, error) {
 	msg := "\xF0\x9F\x91\xA4 *INFORMAZIONI UTENTE*" +
 		"\n- *Nome*: " + u.FirstName +
 		"\n- *Username*: " + u.Username +
-		"\n- *ID*: " + strconv.Itoa(u.ID) +
+		"\n- *ID*: " + strconv.Itoa(u.ID)
-		"\n- *Gruppi*: "
 
+	if len(stringGroups) > 0 {
+		msg += "\n- *Gruppi*: "
 		for i, group := range stringGroups {
 			msg += group
 			if i <= len(stringGroups)-2 {
 				msg += ", "
 			}
 		}
+	}
 
 	msg += "\n- *Tipo utente*: "
 

src/telegramAPI.go

@@ -21,6 +21,7 @@ const (
 	unstoppableMsg    string = "Non ci siamo... Io l'ho nominata AMMINISTRATORE, cosa crede?! Questo ruolo esige impegno! Non può certo bloccarmi!"
 	wrongCmdMsg       string = "Non capisco, si spieghi meglio! Per cortesia, basta basta! La prego! Non so di cosa sta parlando!"
 	authHowToMsg      string = "Per autorizzare un utente invia un messaggio con scritto \n`/authUser ID_UTENTE`\n sostituendo `ID_UTENTE` con l'ID che ti é stato comunicato dall'utente da autorizzare"
+	deAuthHowToMsg    string = "Per deautorizzare un utente invia un messaggio con scritto \n`/authUser USERNAME`\n sostituendo `USERNAME` con il nome utente da deautorizzare"
 	newAuthMsg        string = "Benvenuto! Da ora in poi lei fa ufficialmente parte del magnifico *Coro dell'Università di Pisa*! Deve sentirsi onorato."
 	delAuthMsg        string = "Capisco, quindi se ne sta andando... Beh un po' mi dispiace, devo ammetterlo. Se ripassa da queste parti sarà sempre il benvenuto! Arrivederci."
 	newAdminMsg       string = "Beh allora, vediamo... Ah si, la nomino amministratore! Da grandi poteri derivano grandi responsabilità. Mi raccomando, non me ne faccia pentire!"

src/telegramCommands.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"log"
+	"strconv"
 
 	tb "gopkg.in/tucnak/telebot.v2"
 )
@@ -93,15 +94,19 @@ func authUserCmd(u *tb.User, payload string) {
 			log.Printf("Error in sending message: %v", err)
 		}
 	} else {
+		//TODO check if payload is valid ID
 		desc, err := getUserDescription(u)
 		if err != nil {
 			log.Printf("Error retriving user description: %v", err)
 		}
 		menu := authUserMenu
-		authUserMenu[0][0].Data = payload
+		menu[0][0].Data = payload
-		authUserMenu[0][1].Data = payload
+		menu[0][1].Data = payload
-		authUserMenu[1][0].Data = payload
+		menu[1][0].Data = payload
-		authUserMenu[1][1].Data = payload
+		menu[1][1].Data = payload
+		menu[2][0].Data = payload
+		menu[2][1].Data = payload
+		menu[2][2].Data = payload
 		err = sendMsgWithSpecificMenu(u, "Stai per autorizzare il seguente utente:\n"+
 			desc+
 			"\nSe le informazioni sono corrette fai 'tap' sui gruppi di appartenenza dell'utente da autorizzare, altrimenti *torna al menù principale ed annulla l'autorizzazione*",
@@ -111,3 +116,41 @@ func authUserCmd(u *tb.User, payload string) {
 		}
 	}
 }
+
+func deAuthUserCmd(u *tb.User, payload string) {
+	if payload == "" {
+		err := sendMsg(u, deAuthHowToMsg, true)
+		if err != nil {
+			log.Printf("Error in sending message: %v", err)
+		}
+	} else {
+		userID, err := strconv.Atoi(payload)
+		if err != nil {
+			log.Printf("Error converting string to int: %v", err)
+		}
+		authorizeUser(userID, false)
+		//TODO
+	}
+}
+
+func addUserGroupCmd(userID int, group userGroup) error {
+	userGroups, err := getUserGroups(userID)
+	if err != nil {
+		log.Printf("Error retriving user groups: %v", err)
+	}
+	is, err := isUserInGroup(userID, group)
+	if err != nil {
+		log.Printf("Error checking if user is in group: %v", err)
+	}
+	if is {
+		return ErrAddUser
+	}
+	userGroups = append(userGroups, group)
+	err = setUserGroups(userID, userGroups...)
+	if err != nil {
+		log.Printf("Error adding user in group: %v", err)
+		return ErrAddAuthUser
+	}
+
+	return nil
+}

src/telegramMenus.go

@@ -1,6 +1,9 @@
 package main
 
 import (
+	"log"
+	"strconv"
+
 	tb "gopkg.in/tucnak/telebot.v2"
 )
 
@@ -157,6 +160,134 @@ func setBotCallbacks() error {
 		bot.Respond(c, &tb.CallbackResponse{})
 
 	})
+	bot.Handle(&authUGSopranoBtn, func(c *tb.Callback) {
+		userID, err := strconv.Atoi(c.Data)
+		if err != nil {
+			log.Printf("Error converting string to int: %v", err)
+		}
+		err = addUserGroupCmd(userID, ugSoprano)
+		if err != nil {
+			bot.Respond(c, &tb.CallbackResponse{
+				Text:      "Impossibile autorizzare l'utente",
+				ShowAlert: true,
+			})
+		} else {
+			bot.Respond(c, &tb.CallbackResponse{
+				Text:      "Autorizzato utente " + c.Data + "e aggiunto al gruppo Soprani",
+				ShowAlert: true,
+			})
+		}
+	})
+	bot.Handle(&authUGContraltoBtn, func(c *tb.Callback) {
+		userID, err := strconv.Atoi(c.Data)
+		if err != nil {
+			log.Printf("Error converting string to int: %v", err)
+		}
+		err = addUserGroupCmd(userID, ugContralto)
+		if err != nil {
+			bot.Respond(c, &tb.CallbackResponse{
+				Text:      "Impossibile autorizzare l'utente",
+				ShowAlert: true,
+			})
+		} else {
+			bot.Respond(c, &tb.CallbackResponse{
+				Text:      "Autorizzato utente " + c.Data + "e aggiunto al gruppo Contralti",
+				ShowAlert: true,
+			})
+		}
+
+	})
+	bot.Handle(&authUGTenoreBtn, func(c *tb.Callback) {
+		userID, err := strconv.Atoi(c.Data)
+		if err != nil {
+			log.Printf("Error converting string to int: %v", err)
+		}
+		err = addUserGroupCmd(userID, ugTenore)
+		if err != nil {
+			bot.Respond(c, &tb.CallbackResponse{
+				Text:      "Impossibile autorizzare l'utente",
+				ShowAlert: true,
+			})
+		} else {
+			bot.Respond(c, &tb.CallbackResponse{
+				Text:      "Autorizzato utente " + c.Data + "e aggiunto al gruppo Tenori",
+				ShowAlert: true,
+			})
+		}
+	})
+	bot.Handle(&authUGBassoBtn, func(c *tb.Callback) {
+		userID, err := strconv.Atoi(c.Data)
+		if err != nil {
+			log.Printf("Error converting string to int: %v", err)
+		}
+		err = addUserGroupCmd(userID, ugBasso)
+		if err != nil {
+			bot.Respond(c, &tb.CallbackResponse{
+				Text:      "Impossibile autorizzare l'utente",
+				ShowAlert: true,
+			})
+		} else {
+			bot.Respond(c, &tb.CallbackResponse{
+				Text:      "Autorizzato utente " + c.Data + "e aggiunto al gruppo Bassi",
+				ShowAlert: true,
+			})
+		}
+	})
+	bot.Handle(&authUGCommissarioBtn, func(c *tb.Callback) {
+		userID, err := strconv.Atoi(c.Data)
+		if err != nil {
+			log.Printf("Error converting string to int: %v", err)
+		}
+		err = addUserGroupCmd(userID, ugCommissario)
+		if err != nil {
+			bot.Respond(c, &tb.CallbackResponse{
+				Text:      "Impossibile autorizzare l'utente",
+				ShowAlert: true,
+			})
+		} else {
+			bot.Respond(c, &tb.CallbackResponse{
+				Text:      "Autorizzato utente " + c.Data + "e aggiunto al gruppo Commissari",
+				ShowAlert: true,
+			})
+		}
+
+	})
+	bot.Handle(&authUGReferenteBtn, func(c *tb.Callback) {
+		userID, err := strconv.Atoi(c.Data)
+		if err != nil {
+			log.Printf("Error converting string to int: %v", err)
+		}
+		err = addUserGroupCmd(userID, ugReferente)
+		if err != nil {
+			bot.Respond(c, &tb.CallbackResponse{
+				Text:      "Impossibile autorizzare l'utente",
+				ShowAlert: true,
+			})
+		} else {
+			bot.Respond(c, &tb.CallbackResponse{
+				Text:      "Autorizzato utente " + c.Data + "e aggiunto al gruppo Referenti",
+				ShowAlert: true,
+			})
+		}
+	})
+	bot.Handle(&authUGPreparatoreBtn, func(c *tb.Callback) {
+		userID, err := strconv.Atoi(c.Data)
+		if err != nil {
+			log.Printf("Error converting string to int: %v", err)
+		}
+		err = addUserGroupCmd(userID, ugPreparatore)
+		if err != nil {
+			bot.Respond(c, &tb.CallbackResponse{
+				Text:      "Impossibile autorizzare l'utente",
+				ShowAlert: true,
+			})
+		} else {
+			bot.Respond(c, &tb.CallbackResponse{
+				Text:      "Autorizzato utente " + c.Data + "e aggiunto al gruppo Preparatori",
+				ShowAlert: true,
+			})
+		}
+	})
 
 	return nil
 }