Further development

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

src/barandaBot.go

@@ -25,10 +25,18 @@ func main() {
 
 	if cmdFlags.interactive {
 		mainMenuLoop()
-	} else if cmdFlags.token != "" {
+	} else {
+		if cmdFlags.token != "" {
 			err = setBotToken(cmdFlags.token)
 			if err == ErrAddToken {
 				log.Printf("Error in adding bot tokens: %v", err)
 			}
 		}
+		if cmdFlags.mediaPath != "" {
+			err = setMediaDir(cmdFlags.mediaPath)
+			if err != nil {
+				log.Printf("Error in setting the media dir: %v", err)
+			}
+		}
+	}
 }

src/manageAdmin.go

@@ -173,17 +173,12 @@ func addBotAdmin(newAdminID string) error {
 	}
 	botStatus.hasAdmin = true
 
-	err = authorizeUser(ID, true)
-	if err != nil {
-		log.Printf("Error in adding new admin ID in authorized users: %v", err)
-		return ErrAddAuthUser
-	}
 	user, err := getUserInfo(ID)
 	if err != nil {
 		log.Printf("Error getting user info: %v", err)
 		return ErrGetUser
 	}
-	err = sendMsg(user, newAdminMsg)
+	err = sendMsgWithMenu(user, newAdminMsg, false)
 	if err != nil {
 		log.Printf("Error sending message to new admin: %v", err)
 		return ErrSendMsg
@@ -206,7 +201,7 @@ func removeBotAdmin(adminID int) error {
 		log.Printf("Error getting user info: %v", err)
 		return ErrGetUser
 	}
-	err = sendMsg(user, delAdminMsg)
+	err = sendMsgWithMenu(user, delAdminMsg, false)
 	if err != nil {
 		log.Printf("Error sending message to removed admin: %v", err)
 		return ErrSendMsg

src/manageMedia.go

@@ -0,0 +1,77 @@
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"log"
+	"os"
+	"strings"
+
+	tb "gopkg.in/tucnak/telebot.v2"
+)
+
+func setMediaDir(newPath string) error {
+	var err error
+	if redisClient == nil {
+		return ErrNilPointer
+	}
+	if newPath == "" && cmdFlags.interactive {
+		fmt.Println("Add the new media path:")
+		reader := bufio.NewReader(os.Stdin)
+		newPath, err = reader.ReadString('\n')
+		if err != nil {
+			log.Printf("Error in reading new media path: %v", err)
+			return ErrStdRead
+		}
+	}
+	path := strings.TrimSpace(newPath)
+	valid, err := isValidPath(path)
+	if err != nil {
+		log.Printf("Error in validating path: %v", err)
+	}
+	if !valid {
+		return ErrInvalidPath
+	}
+
+	err = redisClient.Set(mediaPath, path, 0).Err()
+	if err != nil {
+		log.Printf("Error in adding new media path: %v", err)
+		return ErrRedisAddSet
+	}
+
+	return nil
+}
+
+func getMediaDir() (string, error) {
+	if redisClient == nil {
+		return "", ErrNilPointer
+	}
+	mediaDirExists, err := redisClient.Exists(mediaPath).Result()
+	if err != nil {
+		log.Printf("Error checking if media path exists in db: %v", err)
+		return "", ErrRedisCheckSet
+	}
+	if mediaDirExists == 0 {
+		fmt.Println("No media path found.")
+		err := setMediaDir("")
+		if err != nil {
+			log.Printf("Couldn't set new media path: %v", err)
+			return "", ErrRedisAddSet
+		}
+	}
+	path, err := redisClient.Get(mediaPath).Result()
+	if err != nil {
+		log.Printf("Couldn't retrieve mediaPath: %v", err)
+		return "", ErrRedisRetrieveSet
+	}
+	return path, nil
+}
+
+func sendImg(user *tb.User, img *tb.Photo) error {
+	_, err := bot.Send(user, img)
+	if err != nil {
+		log.Printf("Error sending img to user: %v", err)
+		return ErrSendMsg
+	}
+	return nil
+}

src/manageMsg.go

@@ -8,12 +8,16 @@ import (
 	tb "gopkg.in/tucnak/telebot.v2"
 )
 
-func closeMsgMenu(storedMsg *tb.StoredMessage) error {
+func modifyPrevMsg(userID int, storedMsg *tb.StoredMessage, newMsg string, newOptions *tb.SendOptions) error {
-	_, err := bot.EditReplyMarkup(storedMsg, &tb.ReplyMarkup{
+	msg, err := bot.Edit(storedMsg, newMsg, newOptions)
-		InlineKeyboard: nil,
-	})
 	if err != nil {
-		log.Printf("Error modifying the message: %v", err)
+		log.Printf("Error modifying previous message: %v", err)
+		return ErrSendMsg
+	}
+	err = setLastMsgPerUser(userID, msg)
+	if err != nil {
+		log.Printf("Error setting last msg per user: %v", err)
+		return ErrSetLastMsg
 	}
 
 	return nil
@@ -53,32 +57,13 @@ func getLastMsgPerUser(userID int) (*tb.StoredMessage, error) {
 	return jsonMsg, nil
 }
 
-func sendMsg(user *tb.User, msg string) error {
+func sendMsg(user *tb.User, msg string, new bool) error {
-	sentMsg, err := bot.Send(user, msg, &tb.SendOptions{
+	sendMsgWithSpecificMenu(user, msg, nil, new)
-		ParseMode: "Markdown",
+
-	})
-	if err != nil {
-		log.Printf("Error sending message to user: %v", err)
-		return ErrSendMsg
-	}
-	storedMsg, err := getLastMsgPerUser(user.ID)
-	if err != nil {
-		log.Printf("Error retriving last message per user: %v", err)
-	} else {
-		err = closeMsgMenu(storedMsg)
-		if err != nil {
-			log.Printf("Error modifying the message: %v", err)
-		}
-	}
-	err = setLastMsgPerUser(user.ID, sentMsg)
-	if err != nil {
-		log.Printf("Error setting last msg per user: %v", err)
-		return ErrSetLastMsg
-	}
 	return nil
 }
 
-func sendMsgWithMenu(user *tb.User, msg string) error {
+func sendMsgWithMenu(user *tb.User, msg string, new bool) error {
 	var menu [][]tb.InlineButton
 
 	auth, err := isAuthrizedUser(user.ID)
@@ -97,58 +82,56 @@ func sendMsgWithMenu(user *tb.User, msg string) error {
 	} else {
 		menu = genericInlineMenu
 	}
+	sendMsgWithSpecificMenu(user, msg, menu, new)
+
+	return nil
+}
+
+func sendMsgWithSpecificMenu(user *tb.User, msg string, menu [][]tb.InlineButton, new bool) error {
+	if !new {
+		storedMsg, err := getLastMsgPerUser(user.ID)
+		if err != nil {
+			log.Printf("Error retriving last message per user: %v", err)
 			sentMsg, err := bot.Send(user, msg, &tb.SendOptions{
-		ReplyMarkup: &tb.ReplyMarkup{
+				ReplyMarkup:           &tb.ReplyMarkup{InlineKeyboard: menu},
-			InlineKeyboard: menu,
+				DisableWebPagePreview: true,
-		},
+				ParseMode:             tb.ModeMarkdown,
-		ParseMode: "Markdown",
 			})
 			if err != nil {
 				log.Printf("Error sending message to user: %v", err)
 				return ErrSendMsg
 			}
-	storedMsg, err := getLastMsgPerUser(user.ID)
-	if err != nil {
-		log.Printf("Error retriving last message per user: %v", err)
-	} else {
-		err = closeMsgMenu(storedMsg)
-		if err != nil {
-			log.Printf("Error modifying the message: %v", err)
-		}
-	}
 			err = setLastMsgPerUser(user.ID, sentMsg)
 			if err != nil {
 				log.Printf("Error setting last msg per user: %v", err)
 				return ErrSetLastMsg
 			}
-	return nil
+		}
-}
+		err = modifyPrevMsg(user.ID, storedMsg, msg, &tb.SendOptions{
-
+			ReplyMarkup:           &tb.ReplyMarkup{InlineKeyboard: menu},
-func sendMsgWithSpecificMenu(user *tb.User, msg string, menu [][]tb.InlineButton) error {
+			DisableWebPagePreview: true,
-	sentMsg, err := bot.Send(user, msg, &tb.SendOptions{
+			ParseMode:             tb.ModeMarkdown,
-		ReplyMarkup: &tb.ReplyMarkup{
-			InlineKeyboard: menu,
-		},
-		ParseMode: "Markdown",
 		})
 		if err != nil {
 			log.Printf("Error sending message to user: %v", err)
 			return ErrSendMsg
 		}
-	storedMsg, err := getLastMsgPerUser(user.ID)
-	if err != nil {
-		log.Printf("Error retriving last message per user: %v", err)
 	} else {
-		err = closeMsgMenu(storedMsg)
+		sentMsg, err := bot.Send(user, msg, &tb.SendOptions{
+			ReplyMarkup:           &tb.ReplyMarkup{InlineKeyboard: menu},
+			DisableWebPagePreview: true,
+			ParseMode:             tb.ModeMarkdown,
+		})
 		if err != nil {
-			log.Printf("Error modifying the message: %v", err)
+			log.Printf("Error sending message to user: %v", err)
-		}
+			return ErrSendMsg
 		}
 		err = setLastMsgPerUser(user.ID, sentMsg)
 		if err != nil {
 			log.Printf("Error setting last msg per user: %v", err)
 			return ErrSetLastMsg
 		}
+	}
 
 	return nil
 }

src/manageUser.go

@@ -129,18 +129,41 @@ func authorizeUser(userID int, authorized 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 {
+		return nil
+	}
+
+	user, err := getUserInfo(userID)
+	if err != nil {
+		log.Printf("Error getting user info: %v", err)
+		return ErrGetUser
+	}
 	if authorized {
 		err := redisClient.SAdd(authUsers, strconv.Itoa(userID)).Err()
 		if err != nil {
 			log.Printf("Error adding token to set: %v", err)
 			return ErrRedisAddSet
 		}
+		err = sendMsg(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
 }
@@ -180,6 +203,7 @@ func getUserGroups(userID int) ([]userGroup, error) {
 	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)
@@ -187,6 +211,7 @@ func getUserGroups(userID int) ([]userGroup, error) {
 			}
 			retGroups = append(retGroups, userGroup(intGroup))
 		}
+	}
 	return retGroups, nil
 }
 
@@ -233,3 +258,48 @@ func convertUserGroups(groups []userGroup) []string {
 
 	return stringGroups
 }
+
+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) +
+		"\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
+}

src/redisAPI.go

@@ -17,6 +17,7 @@ const (
 	authUsers      = "authUsers"
 	adminUsers     = "adminUsers"
 	lastMsgPerUser = "lastMsgPerUser"
+	mediaPath      = "mediaPath"
 )
 
 var redisClient *redis.Client

src/sys.go

@@ -19,6 +19,7 @@ type flags struct {
 	redisPwd    string
 	redisDB     int
 	token       string
+	mediaPath   string
 }
 
 var cmdFlags flags
@@ -63,7 +64,20 @@ func getFlags() error {
 		dbUsage            = "The database to be selected after connecting to redis instance"
 		defaultToken       = ""
 		tokenUsage         = "A bot token to be added to the set of tokens"
+		defaultMediaPath   = ""
+		mediaPathUsage     = "A path to be used as media directory"
 	)
+	/* var defaultMediaPath string
+	usr, err := user.Current()
+	if err != nil {
+		log.Printf("Error retriving current user home dir: %v. Using current directory", err)
+		os.MkdirAll("./.barandaBot/img", os.ModePerm)
+		defaultMediaPath = "./.barandaBot/img"
+
+	} else {
+		os.MkdirAll(usr.HomeDir+"/.barandaBot/img", os.ModePerm)
+		defaultMediaPath = usr.HomeDir + "/.barandaBot/img"
+	} */
 
 	flag.BoolVar(&(cmdFlags.interactive), "interactive", defaultInteractive, interactiveUsage)
 	flag.BoolVar(&(cmdFlags.interactive), "i", defaultInteractive, interactiveUsage+"(shorthand)")
@@ -75,6 +89,8 @@ func getFlags() error {
 	flag.IntVar(&(cmdFlags.redisDB), "d", defaultDB, dbUsage+"(shorthand)")
 	flag.StringVar(&(cmdFlags.token), "token", defaultToken, tokenUsage)
 	flag.StringVar(&(cmdFlags.token), "t", defaultToken, tokenUsage+"(shorthand")
+	flag.StringVar(&(cmdFlags.mediaPath), "mediaPath", defaultMediaPath, mediaPathUsage)
+	flag.StringVar(&(cmdFlags.mediaPath), "m", defaultMediaPath, mediaPathUsage+"(shorthand")
 
 	flag.Parse()
 
@@ -96,6 +112,17 @@ func exit() error {
 	return nil
 }
 
+func isValidPath(path string) (bool, error) {
+	_, err := os.Stat(path)
+	if err == nil {
+		return true, nil
+	}
+	if os.IsNotExist(err) {
+		return false, nil
+	}
+	return true, err
+}
+
 func mainMenu() *wmenu.Menu {
 	menu := wmenu.NewMenu("What do you want to do?")
 	menu.LoopOnInvalid()
@@ -106,6 +133,9 @@ func mainMenu() *wmenu.Menu {
 		menu.Option("Set bot token", nil, false, func(opt wmenu.Opt) error {
 			return setBotToken("")
 		})
+		menu.Option("Set media path", nil, false, func(opt wmenu.Opt) error {
+			return setMediaDir("")
+		})
 	}
 	if botStatus.isStarted {
 		menu.Option("Stop bot", nil, true, func(opt wmenu.Opt) error {

src/telegramAPI.go

@@ -17,14 +17,18 @@ const (
 	startMsg          string = "Salve, sono Stefano, il Magister! Come posso esservi d'aiuto?"
 	alreadyStartedMsg string = "Si, mi dica, che c'è?! Sono qui!"
 	restartMsg        string = "Eccomi, sono tornato! Ha bisogno? Mi dica pure!"
-	stopMsg           string = "Mi assenterò per qualche istante, d'altra parte anch'io ho pur diritto alla mia vita privata. Masino mi attende!"
+	stopMsg           string = "Mi assenterò per qualche istante, d'altra parte anch'io ho pur diritto alla mia vita privata. Masino mi attende \xF0\x9F\x90\xB1"
 	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"
+	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!"
 	delAdminMsg       string = "Ecco, che le avevo detto?! Mi sembrava di essere stato chiaro! Dovrò sollevarla dall'incarico... Mi spiace molto ma da ora in avanti non sarà più amministratore"
 	menuMsg           string = "Ecco a lei, questo è l'elenco di tutto ciò che può chiedermi. Non mi disturbi con altre richieste!"
-	contactMsg        string = "*BarandaBot*" +
+	contactMsg        string = "*BarandaBot*\xE2\x84\xA2" +
 		"\nSe hai domande, suggerimenti o se vuoi segnalare bug e altri malfunzionamenti puoi contattare l'Altissimo con i seguenti mezzi di comunicazione:" +
-		"\n- \xF0\x9F\x90\xA6 _Piccione viaggiatore_: PlusCode - P99W+4Q Pisa, PI" +
+		"\n- \xF0\x9F\x90\xA6 _Piccione viaggiatore_: [Palazzo Ricci, Pisa](https://goo.gl/maps/gMUbV2eqJiL2)" +
 		"\n- \xF0\x9F\x93\xA7 _Mail_: telebot.corounipi@gmail.com" +
 		"\n- \xF0\x9F\x93\x82 _GitHub_: https://github.com/Noettore/barandaBot"
 )
@@ -48,6 +52,8 @@ var (
 	ErrBotConn = errors.New("telegram: cannot connect to bot")
 	//ErrSetLastMsg is thrown when it's not possible to set last message per user in hash
 	ErrSetLastMsg = errors.New("cannot set last message per user")
+	//ErrInvalidPath is thrown when a path isn't valid
+	ErrInvalidPath = errors.New("path is not valid")
 )
 
 func botInit() error {
@@ -107,15 +113,23 @@ func setBotPoller(upd *tb.Update) bool {
 	if upd.Message == nil {
 		return true
 	}
-	if upd.Message.Sender != nil {
+	/* if upd.Message.Sender != nil {
 		err := addUser(upd.Message.Sender)
 		if err != nil {
 			log.Printf("Error in adding user info: %v", err)
 		}
 	} else {
 		log.Printf("%v", ErrIDFromMsg)
+	} */
+	isUser, err := isUser(upd.Message.Sender.ID)
+	if err != nil {
+		log.Printf("Error checking if message come from a bot user: %v", err)
 	}
-	_, isGenericCmd := genericCommands[upd.Message.Text]
+	if !isUser && upd.Message.Text != "/start" {
+		return false
+	}
+
+	//_, isGenericCmd := genericCommands[upd.Message.Text]
 	_, isAuthCmd := authCommands[upd.Message.Text]
 	_, isAdminCmd := adminCommands[upd.Message.Text]
 
@@ -124,6 +138,7 @@ func setBotPoller(upd *tb.Update) bool {
 		log.Printf("Error checking if user is started: %v", err)
 	}
 	if !started && upd.Message.Text != "/start" {
+		sendMsgWithSpecificMenu(upd.Message.Sender, "ZzZzZzZzZzZ", startMenu, true)
 		return false
 	}
 
@@ -135,13 +150,10 @@ func setBotPoller(upd *tb.Update) bool {
 	if err != nil {
 		log.Printf("Error checking if user is admin: %v", err)
 	}
-	if isAdminCmd && !admin {
+	if isAdminCmd && admin == false {
 		return false
 	}
-	if isAuthCmd && !auth {
+	if isAuthCmd && auth == false {
-		return false
-	}
-	if !isGenericCmd {
 		return false
 	}
 	return true

src/telegramCommands.go

@@ -2,7 +2,6 @@ package main
 
 import (
 	"log"
-	"strconv"
 
 	tb "gopkg.in/tucnak/telebot.v2"
 )
@@ -12,7 +11,9 @@ var genericCommands = map[string]bool{
 	"/stop":           true,
 	"/menu":           true,
 	"/userInfo":       true,
+	"/config":         true,
 	"/botInfo":        true,
+	"/help":           true,
 	"/prossimoEvento": true,
 }
 var authCommands = map[string]bool{
@@ -21,11 +22,12 @@ var authCommands = map[string]bool{
 }
 var adminCommands = map[string]bool{
 	"/authUser":   true,
+	"/deAuthUser": true,
 	"/addAdmin":   true,
 	"/delAdmin":   true,
 }
 
-func startCmd(u *tb.User) {
+func startCmd(u *tb.User, newMsg bool) {
 	var msg string
 
 	isUser, err := isUser(u.ID)
@@ -45,13 +47,17 @@ func startCmd(u *tb.User) {
 		if isUser {
 			msg = restartMsg
 		} else {
+			err := addUser(u)
+			if err != nil {
+				log.Printf("Error adding user: %v", err)
+			}
 			msg = startMsg
 		}
 	} else {
 		msg = alreadyStartedMsg
 	}
 
-	err = sendMsgWithMenu(u, msg)
+	err = sendMsgWithMenu(u, msg, newMsg)
 	if err != nil {
 		log.Printf("Error sending message to started user: %v", err)
 	}
@@ -63,7 +69,8 @@ func stopCmd(u *tb.User) {
 		log.Printf("Error checking if user is admin: %v", err)
 	}
 	if admin {
-		err := sendMsgWithMenu(u, unstoppableMsg)
+		//img := &tb.Photo{File: tb.FromDisk()}
+		err := sendMsgWithMenu(u, unstoppableMsg, false)
 		if err != nil {
 			log.Printf("Error sending message to unstoppable user: %v", err)
 		}
@@ -72,47 +79,35 @@ func stopCmd(u *tb.User) {
 		if err != nil {
 			log.Printf("Error starting user: %v", err)
 		}
-		err := sendMsgWithSpecificMenu(u, stopMsg, startMenu)
+		err := sendMsgWithSpecificMenu(u, stopMsg, startMenu, false)
 		if err != nil {
 			log.Printf("Error sending message to stopped user: %v", err)
 		}
 	}
 }
 
-func userInfoCmd(u *tb.User) {
+func authUserCmd(u *tb.User, payload string) {
-	userGroups, err := getUserGroups(u.ID)
+	if payload == "" {
+		err := sendMsg(u, authHowToMsg, true)
 		if err != nil {
-		log.Printf("Error retriving user groups: %v", err)
+			log.Printf("Error in sending message: %v", err)
 		}
-	stringGroups := convertUserGroups(userGroups)
-
-	isAdmin, err := isBotAdmin(u.ID)
-	if err != nil {
-		log.Printf("Error checking if user is admin: %v", err)
-	}
-	isAuth, err := isAuthrizedUser(u.ID)
-	if err != nil {
-		log.Printf("Error checking if user is authorized: %v", err)
-	}
-
-	msg := "\xF0\x9F\x91\xA4 *INFORMAZIONI UTENTE*" +
-		"\n- *Nome*: " + u.FirstName +
-		"\n- *Username*: " + u.Username +
-		"\n- *ID*: " + strconv.Itoa(u.ID) +
-		"\n- *Gruppi*: "
-
-	for _, group := range stringGroups {
-		msg += group + ", "
-	}
-
-	msg += "\n- *Tipo utente*: "
-
-	if isAdmin {
-		msg += "Admin"
-	} else if isAuth {
-		msg += "Autorizzato"
 	} else {
-		msg += "Utente semplice"
+		desc, err := getUserDescription(u)
+		if err != nil {
+			log.Printf("Error retriving user description: %v", err)
+		}
+		menu := authUserMenu
+		authUserMenu[0][0].Data = payload
+		authUserMenu[0][1].Data = payload
+		authUserMenu[1][0].Data = payload
+		authUserMenu[1][1].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*",
+			menu, true)
+		if err != nil {
+			log.Printf("Error in sending message: %v", err)
+		}
 	}
-	err = sendMsgWithSpecificMenu(u, msg, goBackMenu)
 }

src/telegramHandlers.go

@@ -9,19 +9,37 @@ func setBotHandlers() error {
 		return ErrNilPointer
 	}
 	bot.Handle("/start", func(m *tb.Message) {
-		startCmd(m.Sender)
+		startCmd(m.Sender, true)
 	})
 	bot.Handle("/stop", func(m *tb.Message) {
 		stopCmd(m.Sender)
 	})
 	bot.Handle("/menu", func(m *tb.Message) {
-		sendMsgWithMenu(m.Sender, menuMsg)
+		sendMsgWithMenu(m.Sender, menuMsg, true)
 	})
 	bot.Handle("/userInfo", func(m *tb.Message) {
-		userInfoCmd(m.Sender)
+		msg, _ := getUserDescription(m.Sender)
+		sendMsgWithSpecificMenu(m.Sender, msg, myInfoMenu, false)
 	})
 	bot.Handle("/botInfo", func(m *tb.Message) {
-		sendMsgWithSpecificMenu(m.Sender, contactMsg, goBackMenu)
+		sendMsgWithSpecificMenu(m.Sender, contactMsg, botInfoMenu, true)
+	})
+	bot.Handle("/help", func(m *tb.Message) {
+		sendMsgWithSpecificMenu(m.Sender, contactMsg, botInfoMenu, true)
+	})
+	bot.Handle("/config", func(m *tb.Message) {
+		msg, _ := getUserDescription(m.Sender)
+		sendMsgWithSpecificMenu(m.Sender, msg, myInfoMenu, false)
+	})
+	bot.Handle("/authUser", func(m *tb.Message) {
+		authUserCmd(m.Sender, m.Payload)
+	})
+	bot.Handle("/deAuthUser", func(m *tb.Message) {
+
+	})
+
+	bot.Handle(tb.OnText, func(m *tb.Message) {
+		sendMsgWithMenu(m.Sender, wrongCmdMsg, true)
 	})
 
 	return nil

src/telegramMenus.go

@@ -5,11 +5,14 @@ import (
 )
 
 var (
+	superAdminInlineMenu [][]tb.InlineButton
 	adminInlineMenu      [][]tb.InlineButton
 	authInlineMenu       [][]tb.InlineButton
 	genericInlineMenu    [][]tb.InlineButton
 	startMenu            [][]tb.InlineButton
-	goBackMenu        [][]tb.InlineButton
+	myInfoMenu           [][]tb.InlineButton
+	botInfoMenu          [][]tb.InlineButton
+	authUserMenu         [][]tb.InlineButton
 )
 
 var (
@@ -27,24 +30,87 @@ var (
 	}
 	infoBtn = tb.InlineButton{
 		Unique: "info_btn",
-		Text:   "\xE2\x84\xB9 Info",
+		Text:   "\xE2\x84\xB9 Bot info",
 	}
 	userBtn = tb.InlineButton{
 		Unique: "user_btn",
 		Text:   "\xF0\x9F\x91\xA4 My info",
 	}
+	authBtn = tb.InlineButton{
+		Unique: "auth_btn",
+		Text:   "\xE2\x9C\x85 Autorizza utente",
+	}
+	deAuthBtn = tb.InlineButton{
+		Unique: "de_auth_btn",
+		Text:   "\xE2\x9D\x8C Deautorizza utente",
+	}
+	adminBtn = tb.InlineButton{
+		Unique: "admin_btn",
+		Text:   "\xF0\x9F\x91\x91 Nomina amministratore",
+	}
+	deAdminBtn = tb.InlineButton{
+		Unique: "de_admin_btn",
+		Text:   "\xF0\x9F\x92\x80 Rimuovi amministratore",
+	}
+	sendMsgBtn = tb.InlineButton{
+		Unique: "send_msg_btn",
+		Text:   "\xF0\x9F\x93\xA3 Invia messaggio alla sezione",
+	}
+	authUGSopranoBtn = tb.InlineButton{
+		Unique: "auth_ugSoprano_btn",
+		Text:   "\xF0\x9F\x91\xA7 Soprani",
+	}
+	authUGContraltoBtn = tb.InlineButton{
+		Unique: "auth_ugContralto_btn",
+		Text:   "\xF0\x9F\x91\xA9 Contralti",
+	}
+	authUGTenoreBtn = tb.InlineButton{
+		Unique: "auth_ugTenore_btn",
+		Text:   "\xF0\x9F\x91\xA6 Tenori",
+	}
+	authUGBassoBtn = tb.InlineButton{
+		Unique: "auth_ugBasso_btn",
+		Text:   "\xF0\x9F\x91\xA8 Bassi",
+	}
+	authUGCommissarioBtn = tb.InlineButton{
+		Unique: "auth_ugCommissario_btn",
+		Text:   "\xF0\x9F\x93\x9D Commissari",
+	}
+	authUGReferenteBtn = tb.InlineButton{
+		Unique: "auth_ugReferente_btn",
+		Text:   "\xF0\x9F\x93\x8B Referenti",
+	}
+	authUGPreparatoreBtn = tb.InlineButton{
+		Unique: "auth_ugPreparatori_btn",
+		Text:   "\xF0\x9F\x8E\xB9 Preparatori",
+	}
 )
 
 func setBotMenus() error {
 
-	genericInlineMenu = append(genericInlineMenu, []tb.InlineButton{userBtn, infoBtn}, []tb.InlineButton{stopBtn})
+	genericInlineMenu = append(genericInlineMenu, []tb.InlineButton{userBtn, infoBtn})
+
 	authInlineMenu = genericInlineMenu
-	adminInlineMenu = genericInlineMenu
+	//authInlineMenu = append(authInlineMenu, []tb.InlineButton{, })
-	//adminInlineMenu = append(adminInlineMenu, []tb.InlineButton{stopBtn, infoBtn})
+
-	//authInlineMenu = append(authInlineMenu, []tb.InlineButton{stopBtn, infoBtn})
+	adminInlineMenu = authInlineMenu
+	adminInlineMenu = append(adminInlineMenu,
+		[]tb.InlineButton{authBtn, deAuthBtn},
+		[]tb.InlineButton{sendMsgBtn},
+	)
+
+	superAdminInlineMenu = adminInlineMenu
+	superAdminInlineMenu = append(superAdminInlineMenu, []tb.InlineButton{adminBtn, deAdminBtn})
 
 	startMenu = append(startMenu, []tb.InlineButton{startBtn})
-	goBackMenu = append(goBackMenu, []tb.InlineButton{backBtn})
+	myInfoMenu = append(myInfoMenu, []tb.InlineButton{backBtn})
+	botInfoMenu = append(botInfoMenu, []tb.InlineButton{stopBtn}, []tb.InlineButton{backBtn})
+	authUserMenu = append(authUserMenu,
+		[]tb.InlineButton{authUGSopranoBtn, authUGContraltoBtn},
+		[]tb.InlineButton{authUGTenoreBtn, authUGBassoBtn},
+		[]tb.InlineButton{authUGCommissarioBtn, authUGReferenteBtn, authUGPreparatoreBtn},
+		[]tb.InlineButton{backBtn},
+	)
 
 	return nil
 }
@@ -56,7 +122,7 @@ func setBotCallbacks() error {
 
 	bot.Handle(&startBtn, func(c *tb.Callback) {
 		bot.Respond(c, &tb.CallbackResponse{})
-		startCmd(c.Sender)
+		startCmd(c.Sender, false)
 	})
 
 	bot.Handle(&stopBtn, func(c *tb.Callback) {
@@ -66,15 +132,30 @@ func setBotCallbacks() error {
 
 	bot.Handle(&userBtn, func(c *tb.Callback) {
 		bot.Respond(c, &tb.CallbackResponse{})
-		userInfoCmd(c.Sender)
+		msg, _ := getUserDescription(c.Sender)
+		sendMsgWithSpecificMenu(c.Sender, msg, myInfoMenu, false)
 	})
 	bot.Handle(&infoBtn, func(c *tb.Callback) {
 		bot.Respond(c, &tb.CallbackResponse{})
-		sendMsgWithSpecificMenu(c.Sender, contactMsg, goBackMenu)
+		sendMsgWithSpecificMenu(c.Sender, contactMsg, botInfoMenu, false)
 	})
 	bot.Handle(&backBtn, func(c *tb.Callback) {
 		bot.Respond(c, &tb.CallbackResponse{})
-		sendMsgWithMenu(c.Sender, menuMsg)
+		sendMsgWithMenu(c.Sender, menuMsg, false)
+	})
+
+	bot.Handle(&authBtn, func(c *tb.Callback) {
+		bot.Respond(c, &tb.CallbackResponse{})
+		sendMsgWithMenu(c.Sender, authHowToMsg, false)
+
+	})
+	bot.Handle(&deAuthBtn, func(c *tb.Callback) {
+		bot.Respond(c, &tb.CallbackResponse{})
+
+	})
+	bot.Handle(&sendMsgBtn, func(c *tb.Callback) {
+		bot.Respond(c, &tb.CallbackResponse{})
+
 	})
 
 	return nil