Interfaccia CLI per amministratori

Fa parte della sezione Programmazione orientata agli oggetti del percorso GO di Coddy. Lezione 103 di 107.

Sfida

Facile

Costruiamo un'interfaccia a riga di comando per il nostro sistema di gestione della biblioteca usando il pattern Command! Creerai una CLI che elabora comandi amministrativi, come aggiungere libri, registrare utenti e gestire le operazioni di prestito, il tutto tramite un'architettura pulita ed estensibile.

Organizzerai il codice in sei file:

book.go: la tua struct Book con tag JSON per ID, Title, Author, ISBN e Available. Includi il costruttore NewBook.
user.go: la tua struct User con tag JSON per ID, Name, Email e BorrowedBooks. Includi il costruttore NewUser.
library.go: la tua struct Library con mappe per libri e utenti, insieme ai metodi AddBook, AddUser, Borrow e Return delle lezioni precedenti.
commands.go: è qui che il pattern Command prende vita! Definisci un'interfaccia Command con un metodo Execute che accetta un *Library e argomenti []string, restituendo una stringa come risultato. Poi implementa queste struct per i comandi:
- AddBookCommand: si aspetta 4 argomenti: id, title, author, isbn. Aggiunge il libro e restituisce Book added: [title]
- AddUserCommand: si aspetta 3 argomenti: id, name, email. Aggiunge l'utente e restituisce User added: [name]
- BorrowCommand: si aspetta 2 argomenti: userID, bookID. In caso di successo restituisce Borrowed: [bookID], altrimenti Error: [message]
- ReturnCommand: si aspetta 2 argomenti: userID, bookID. In caso di successo restituisce Returned: [bookID], altrimenti Error: [message]
- ListBooksCommand: non accetta argomenti. Restituisce l'ID e il titolo di ogni libro su righe separate nel formato [id]: [title], oppure No books se l'elenco è vuoto (ordina i libri per ID)
Se un comando riceve un numero insufficiente di argomenti, restituisci Error: insufficient arguments
cli.go: crea una struct CLI che contiene un puntatore a una Library e una mappa di nomi di comandi associati alle implementazioni di Command. Realizza:
- Il costruttore NewCLI, che inizializza la CLI con una biblioteca e registra tutti i comandi: addbook, adduser, borrow, return, listbooks
- Il metodo Run, che accetta una stringa di input, la analizza usando strings.Fields, cerca il comando e lo esegue. Restituisce No command provided se l'input è vuoto, oppure Unknown command: [name] per i comandi non riconosciuti
main.go: crea una biblioteca e una CLI, poi elabora i comandi ricevuti in input. Leggi il numero di comandi, quindi leggi ogni stringa di comando su una riga separata. Per ogni comando, chiama Run e stampa il risultato.

Verranno forniti i seguenti input:

Numero di comandi
Ogni comando come stringa completa su una riga propria

Per esempio, dato:

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

L'output dovrebbe essere:

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

E dato:

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

L'output dovrebbe essere:

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

E dato:

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

L'output dovrebbe essere:

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

Nota che la CLI non deve conoscere i dettagli di ogni operazione. Si limita a cercare il comando e a delegarne l'esecuzione. In questo modo, aggiungere nuovi comandi è semplice come creare una nuova struct che implementa l'interfaccia Command e registrarla nella CLI!

Provalo tu

package main

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

func main() {
	// Leggi il numero di comandi
	var n int
	fmt.Scanln(&n)

	// Crea uno scanner per leggere righe intere
	scanner := bufio.NewScanner(os.Stdin)

	// TODO: Crea una nuova Library

	// TODO: Crea una nuova CLI con la libreria

	// TODO: Elabora ogni comando
	// Per ciascuno degli n comandi:
	// - Leggi la riga del comando usando scanner.Scan() e scanner.Text()
	// - Esegui il comando tramite la CLI
	// - Stampa il risultato

	_ = scanner // Rimuovi questa riga quando usi scanner
}