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 modèle de conception Command ! Vous allez créer une CLI qui traite les commandes d'administration telles que l'ajout de livres, l'enregistrement d'utilisateurs et la gestion des opérations d'emprunt, le tout via une architecture propre 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 modèle Command prend vie ! Définissez une interface Command avec une méthode Execute qui prend un *Library et des arguments []string, retournant un résultat sous forme de chaîne. Implémentez ensuite ces structures de commande :
- AddBookCommand — attend 4 arguments : id, title, author, isbn. Ajoute le livre et retourne Book added: [title]
- AddUserCommand — attend 3 arguments : id, name, email. Ajoute l'utilisateur et retourne User added: [name]
- BorrowCommand — attend 2 arguments : userID, bookID. Retourne Borrowed: [bookID] en cas de succès, ou Error: [message] en cas d'échec
- ReturnCommand — attend 2 arguments : userID, bookID. Retourne Returned: [bookID] en cas de succès, ou Error: [message] en cas d'échec
- ListBooksCommand — ne prend aucun argument. Retourne 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 (listez les livres triés par ID)
Si une commande reçoit des arguments insuffisants, retournez Error: insufficient arguments
cli.go : Créez une structure CLI qui contient un pointeur vers une Library et une map associant les noms de commandes aux 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 prend une chaîne d'entrée, l'analyse à l'aide de strings.Fields, recherche la commande et l'exécute. Retournez 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 à partir de l'entrée. 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, étant donné :

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 devrait ê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 étant donné :

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

Votre sortie devrait être :

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

Et étant donné :

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 devrait être :

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

Remarquez comment 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 l'exécution. Cela rend l'ajout de nouvelles commandes aussi simple que la création d'une nouvelle structure qui implémente l'interface Command et son enregistrement 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 une nouvelle 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 la CLI
	// - Afficher le résultat

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