Aggiungiamo la possibilità di lavorare come amministratore e statistiche per lui - "Progetto Java dalla A alla Z"

Ciao a tutti, miei cari amici. Quindi, il bot sta già funzionando e inviando notifiche sui nuovi articoli. Se non lo usi ancora, ecco il link: Javarush Telegram Bot . Bene, oggi parleremo dell'aggiunta di comandi che funzionano solo per gli amministratori. Uno di questi comandi sono le statistiche e la scheda di aiuto. Perché è necessario? Al momento, è più interessante descrivere il lavoro con annotazioni nell'ambito di questo compito che la sua effettiva necessità. Bene, dal momento che andremo al team delle statistiche, possiamo espanderlo e renderlo più informativo. Dopo l'MVP sarà possibile, ad esempio, restituire le statistiche per gli autori. Ma ne parleremo più avanti...)

Comprendiamo l'aggiunta di amministratori e comandi per loro

Iniziamo il nostro lavoro aggiornando il ramo principale e creandone uno nuovo basato su di esso: STEP_9_JRTB-10. Per capire quale comando si applica agli amministratori e quale a tutti, è necessario etichettare il comando. Per fare ciò, creiamo un'annotazione. Cosa significa? Non l'abbiamo mai fatto prima. Questo può essere selezionato quando si crea una classe in IDEA. Te lo mostrerò adesso. Nel pacchetto comandi, crea un nuovo pacchetto di annotazioni e in esso l'annotazione AdminCommand: L'annotazione stessa sarà così:

package com.github.javarushcommunity.jrtb.command.annotation;

import com.github.javarushcommunity.jrtb.command.Command;

import java.lang.annotation.Retention;

import static java.lang.annotation.RetentionPolicy.RUNTIME;

/**
* Mark if {@link Command} can be viewed only by admins.
*/
@Retention(RUNTIME)
public @interface AdminCommand {
}

Non abbiamo bisogno di nient'altro qui. Successivamente lo aggiungiamo al nostro comando StatCommand: Ora tutto dovrebbe funzionare... Oppure no? No, ovviamente)) Dobbiamo insegnare al nostro CommandContainer a produrre correttamente il risultato. Per fare ciò, aggiorniamo il metodo retrieveCommand , che emette un comando da eseguire a seconda di ciò che gli viene passato. Utilizzeremo il suo nome utente in Telegram come identificatore amministratore. È unico e più facile da leggere rispetto a chat_id. Come ottenerlo? È nell'oggetto Update, che viene fornito con il messaggio:

update.getMessage().getFrom().getUserName()

Riassumendo tutto quanto sopra, aggiorniamo il metodo CommandContainer#retrieveCommand :

public Command retrieveCommand(String commandIdentifier, String username) {
   Command orDefault = commandMap.getOrDefault(commandIdentifier, unknownCommand);
   if (isAdminCommand(orDefault)) {
       if (admins.contains(username)) {
           return orDefault;
       } else {
           return unknownCommand;
       }
   }
   return orDefault;
}

private boolean isAdminCommand(Command command) {
   return nonNull(command.getClass().getAnnotation(AdminCommand.class));
}

Come puoi vedere qui, ho aggiunto il metodo isAdminCommand , che controlla se è presente un'annotazione AdminCommand sul comando fornito. E se si tratta di un comando riservato all'amministratore, controlliamo se abbiamo quel nome utente nella nostra raccolta di amministratori disponibili. A proposito, eccola qui, OOP, in tutto il suo splendore: passiamo semplicemente un'interfaccia, che può essere qualsiasi implementazione. Ma possiamo passare solo la classe che implementa l' interfaccia Command . E tutto sembra chiaro, tranne una cosa: da dove vengono gli amministratori? Te lo mostrerò adesso. Per ora voglio passare gli amministratori come variabile di ambiente in modo che possa essere facilmente configurato. Questa variabile conterrà una riga in cui saranno indicati tutti i nomi utente degli utenti di Telegram che saranno amministratori, separati da virgole. Per fare ciò, aggiungi a application.properties:

bot.admins: robeskman,romankh3

Nel costruttore CommandContainer passeremo la raccolta di amministratori e la inizializzeremo:

public class CommandContainer {

   private final ImmutableMap<String, Command> commandMap;
   private final Command unknownCommand;
   private final List<String> admins;

   public CommandContainer(SendBotMessageService sendBotMessageService, TelegramUserService telegramUserService,
                           JavaRushGroupClient javaRushGroupClient, GroupSubService groupSubService,
                           List<String> admins) {

       this.admins = admins;

E già in JavaRushTelegramBot ci sarà tutta la magia di ottenere una collection da una stringa nelle proprietà:

@Autowired
public JavarushTelegramBot(TelegramUserService telegramUserService, JavaRushGroupClient groupClient, GroupSubService groupSubService,
                          @Value("#{'${bot.admins}'.split(',')}") List<String> admins) {
   this.commandContainer =
           new CommandContainer(new SendBotMessageServiceImpl(this),
                   telegramUserService, groupClient, groupSubService, admins);
}

Come puoi vedere dal costruttore sopra, utilizziamo nuovamente l' annotazione Value , nella quale passiamo la logica per la creazione della raccolta. E questo è tutto, l'aggiunta dell'amministratore è finita. Adesso, quando un non amministratore vorrà avere dati sulle statistiche del bot, riceverà la seguente risposta: non ti capisco 😟, scrivi /aiuta per scoprire cosa ho capito. In questo modo abbiamo differenziato i ruoli per i comandi del bot.

Aggiunta di un comando di aiuto per gli amministratori

Successivamente, sarebbe logico creare un comando di aiuto separato per gli amministratori. In futuro, questa parte potrebbe crescere in modo significativo. Aggiungi il valore della guida dell'amministratore a CommandName:

ADMIN_HELP("/ahelp")

Crea la classe AdminHelpCommand nel pacchetto comandi:

package com.github.javarushcommunity.jrtb.command;

import com.github.javarushcommunity.jrtb.service.SendBotMessageService;
import org.telegram.telegrambots.meta.api.objects.Update;

import static com.github.javarushcommunity.jrtb.command.CommandName.STAT;
import static java.lang.String.format;

/**
* Admin Help {@link Command}.
*/
public class AdminHelpCommand implements Command {

   public static final String ADMIN_HELP_MESSAGE = format("✨<b>Доступные команды админа</b>✨\n\n"
                   + "<b>Получить статистику</b>\n"
                   + "%s - статистика бота\n",
           STAT.getCommandName());

   private final SendBotMessageService sendBotMessageService;

   public AdminHelpCommand(SendBotMessageService sendBotMessageService) {
       this.sendBotMessageService = sendBotMessageService;
   }

   @Override
   public void execute(Update update) {
       sendBotMessageService.sendMessage(update.getMessage().getChatId().toString(), ADMIN_HELP_MESSAGE);
   }
}

Finora è molto semplice. Potrebbe crescere abbastanza bene in futuro. Per questo comando, un test dal nostro modello:

package com.github.javarushcommunity.jrtb.command;

import org.junit.jupiter.api.DisplayName;

import static com.github.javarushcommunity.jrtb.command.AdminHelpCommand.ADMIN_HELP_MESSAGE;
import static com.github.javarushcommunity.jrtb.command.CommandName.ADMIN_HELP;

@DisplayName("Unit-level testing for AdminHelpCommand")
public class AdminHelpCommandTest extends AbstractCommandTest {

   @Override
   String getCommandName() {
       return ADMIN_HELP.getCommandName();
   }

   @Override
   String getCommandMessage() {
       return ADMIN_HELP_MESSAGE;
   }

   @Override
   Command getCommand() {
       return new AdminHelpCommand(sendBotMessageService);
   }
}

Naturalmente, il comando deve essere aggiunto al CommandContainer nella nostra mappa:

.put(ADMIN_HELP.getCommandName(), new AdminHelpCommand(sendBotMessageService))

Aggiunta di una descrizione dei comandi al bot

I bot di Telegram hanno un'altra caratteristica interessante: puoi aggiungere valori e descrizioni dei comandi che accetta per rendere più semplice l'utilizzo dei comandi da parte dell'utente. Che cosa sembra? Prendiamo ad esempio BotFather , il bot di Telegram più importante. Se inizi a scrivere un messaggio con una barra /, il bot offrirà opzioni: E se continui a scrivere, filtrerà e mostrerà opzioni pertinenti: Funzionalità interessanti, giusto? Quindi voglio fare lo stesso qui. Lo farò nel miglior modo possibile: tramite l'applicazione Telegram. So che questo può essere fatto a livello di programmazione. Ma non posso. Ciò non è necessario ai fini di questa serie di articoli. Se qualcuno sa come farlo mi scriva, lo aggiungeremo. Accetterò volentieri qualsiasi aiuto con questo. Una volta ho letto che questo può essere fatto tramite il modello di comando che funziona per noi. Ora ti mostrerò come posso farlo: dobbiamo trovare BotFather in Telegram, selezionare il bot che vogliamo configurare. Successivamente, seleziona la modifica del bot e la sezione sui comandi. Ora mostrerò tutto usando l'esempio del mio bot di prova per Javarush. A BotFather scriviamo il comando: /mybots Successivamente selezioniamo il bot di cui abbiamo bisogno, nel mio caso sarà test_javarush_community_bot: come puoi vedere dall'elenco dei pulsanti, qui puoi visualizzare il token, eliminare il bot e trasferirlo su qualcun altro. Siamo interessati a modificare il bot, quindi selezioniamo Modifica Bot : E qui selezioniamo Modifica Comandi : Dobbiamo solo fornire un messaggio in un formato specifico e verrà registrato come comandi. Oppure se vogliamo rimuoverli tutti, scriviamo /empty. A questo scopo creerò un file nella root del progetto SET_UP_COMMANDS_BOT_FATHER , in cui scriverò tutti i nostri comandi in modo che sia facile ripristinarli o aggiornarli se succede qualcosa. SET_UP_COMMANDS_BOT_FATHER: È chiaro che qui non portiamo comandi di amministrazione. Solo gli amministratori dovrebbero conoscerli. Prendiamo questo messaggio e lo trasmettiamo a BotFather: come di solito accade, non ha funzionato la prima volta. Dopo qualche minuto di riflessione, ho passato tutti i comandi in minuscolo e non in CamelCase come prima, e tutto è andato bene. Aggiorniamo nel nostro file: SET_UP_COMMANDS_BOT_FATHER: Ora puoi andare sul nostro bot e vedere se i comandi sono stati caricati automaticamente: guarda com'è bello adesso! Volevo anche espandere la funzionalità delle statistiche nell'ambito di questo articolo, ma il materiale era già voluminoso sia nel significato che nel contenuto. Pertanto, lo rimandiamo alla prossima volta. Cioè, il compito di JRTB-10 non è del tutto terminato: lo completeremo nel prossimo articolo. Allo stesso tempo, aggiungerò tutte le modifiche già esistenti al bot principale. Vuoi sostenere l'autore, ma non sai come? È molto semplice: iscriviti al mio canale TG , al mio account GitHub e scrivi la tua opinione al riguardo negli articoli qui. Questo feedback è importante per me, quindi capisco che siano letti e interessati a loro.

conclusioni

Riassumiamo quello che abbiamo vissuto oggi:

1. Abbiamo discusso come aggiungere la tua annotazione e come può essere utilizzata come indicatore per delineare i ruoli nei team. A proposito, questo avrebbe potuto essere fatto utilizzando l'interfaccia. Allo stesso modo creeremo un'interfaccia marcatore e poi controlleremo se l'oggetto che arriva implementa questa interfaccia o meno.
2. Aggiunto comando Aiuto per gli amministratori. Per quanto mi riguarda, anche questa è una parte importante nello sviluppo di questo bot.
3. Abbiamo discusso su come aggiungere una descrizione e un popup dei comandi quando li si scrive in un bot. Funzionalità interessante, sicuramente da aggiungere.

Sulla base di questo articolo, ho creato una richiesta pull , puoi vederne i dettagli. Grazie a tutti per l'attenzione, come al solito: mettete mi piace - iscrivetevi - suonate il campanello , contrassegnate il nostro progetto come stella, commentate e votate l'articolo! Ci vediamo al prossimo articolo!

Un elenco di tutti i materiali della serie si trova all'inizio di questo articolo.