Interface CLI d’administration

Fait partie de la section Programmation Orientée Objet du Journey GO de Coddy. Leçon 103 sur 107.

Défi

Facile

Construisons une interface en ligne de commande pour notre système de gestion de bibliothèque en utilisant le patron Command ! Vous allez créer une CLI qui traite des commandes d’administration telles que l’ajout de livres, l’inscription d’utilisateurs et la gestion des opérations d’emprunt, le tout grâce à une architecture claire et extensible.

Vous organiserez votre code sur six fichiers :

book.go : votre structure Book avec des balises JSON pour ID, Title, Author, ISBN et Available. Incluez le constructeur NewBook.
user.go : votre structure User avec des balises JSON pour ID, Name, Email et BorrowedBooks. Incluez le constructeur NewUser.
library.go : votre structure Library avec des maps pour les livres et les utilisateurs, ainsi que les méthodes AddBook, AddUser, Borrow et Return des leçons précédentes.
commands.go : c’est ici que le patron Command prend vie ! Définissez une interface Command avec une méthode Execute qui accepte un *Library et des arguments []string, et renvoie un résultat sous forme de chaîne. Implémentez ensuite les structures de commandes suivantes :
- AddBookCommand : attend 4 arguments : id, title, author, isbn. Ajoute le livre et renvoie Book added: [title]
- AddUserCommand : attend 3 arguments : id, name, email. Ajoute l’utilisateur et renvoie User added: [name]
- BorrowCommand : attend 2 arguments : userID, bookID. Renvoie Borrowed: [bookID] en cas de réussite, ou Error: [message] en cas d’échec
- ReturnCommand : attend 2 arguments : userID, bookID. Renvoie Returned: [bookID] en cas de réussite, ou Error: [message] en cas d’échec
- ListBooksCommand : n’accepte aucun argument. Renvoie l’ID et le titre de chaque livre sur des lignes séparées au format [id]: [title], ou No books si la liste est vide (triez les livres par ID)
Si une commande reçoit un nombre insuffisant d’arguments, renvoyez Error: insufficient arguments
cli.go : créez une structure CLI qui contient un pointeur vers une Library et une map associant les noms des commandes à des implémentations de Command. Construisez :
- le constructeur NewCLI, qui initialise la CLI avec une bibliothèque et enregistre toutes les commandes : addbook, adduser, borrow, return, listbooks
- la méthode Run, qui accepte une chaîne d’entrée, l’analyse à l’aide de strings.Fields, recherche la commande, puis l’exécute. Renvoyez No command provided pour une entrée vide, ou Unknown command: [name] pour les commandes non reconnues
main.go : créez une bibliothèque et une CLI, puis traitez les commandes saisies. Lisez le nombre de commandes, puis lisez chaque chaîne de commande sur une ligne séparée. Pour chaque commande, appelez Run et affichez le résultat.

Les entrées suivantes seront fournies :

Le nombre de commandes
Chaque commande sous forme de chaîne complète sur sa propre ligne

Par exemple, avec :

6
addbook B001 Go-Programming Alan-Donovan 978-0134190440
addbook B002 Clean-Code Robert-Martin 978-0132350884
adduser U001 Alice alice@test.com
borrow U001 B001
listbooks
borrow U001 B001

Votre sortie doit être :

Book added: Go-Programming
Book added: Clean-Code
User added: Alice
Borrowed: B001
B001: Go-Programming
B002: Clean-Code
Error: book not available

Et avec :

4
listbooks
addbook B100 Design-Patterns Gang-of-Four 978-0201633610
listbooks
invalidcmd test

Votre sortie doit être :

No books
Book added: Design-Patterns
B100: Design-Patterns
Unknown command: invalidcmd

Et avec :

5
adduser U001 Bob bob@email.com
borrow U001 B001
addbook B001 Golang-Guide John-Smith 123-456
borrow U001 B001
return U001 B001

Votre sortie doit être :

User added: Bob
Error: book not found
Book added: Golang-Guide
Borrowed: B001
Returned: B001

Remarquez que la CLI n’a pas besoin de connaître les détails de chaque opération. Elle recherche simplement la commande et délègue son exécution. Ainsi, l’ajout de nouvelles commandes se résume à créer une nouvelle structure qui implémente l’interface Command et à l’enregistrer dans la CLI !

Essayez vous-même

package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	// Lire le nombre de commandes
	var n int
	fmt.Scanln(&n)

	// Créer un scanner pour lire des lignes complètes
	scanner := bufio.NewScanner(os.Stdin)

	// TODO: Créer une nouvelle Library

	// TODO: Créer un nouveau CLI avec la library

	// TODO: Traiter chaque commande
	// Pour chacune des n commandes :
	// - Lire la ligne de commande en utilisant scanner.Scan() et scanner.Text()
	// - Exécuter la commande via le CLI
	// - Afficher le résultat

	_ = scanner // Supprimer cette ligne lorsque vous utilisez scanner
}