Récapitulatif - Processeur de paiement

Fait partie de la section Programmation Orientée Objet du Journey GO de Coddy — leçon 46 sur 107.

Défi

Facile

Construisons un système de traitement de paiement complet qui rassemble tous les concepts de polymorphisme de ce chapitre. Vous allez créer différentes méthodes de paiement qui fonctionnent via une interface unifiée, un processeur qui accepte n'importe quelle méthode de paiement via l'injection de dépendances, et traiter plusieurs paiements via une collection polymorphe.

Vous organiserez votre code sur quatre fichiers :

payment.go : Définissez une interface PaymentMethod qui requiert une méthode Process(amount float64) string. C'est le contrat que tous les types de paiement doivent remplir.
methods.go : Créez trois types de paiement qui implémentent chacun l'interface PaymentMethod :
- CreditCard avec les champs CardNumber (string) et HolderName (string)—sa méthode Process retourne "Credit Card [last 4 digits of CardNumber] charged $[amount] to [HolderName]"
- PayPal avec un champ Email—sa méthode Process retourne "PayPal payment of $[amount] from [Email]"
- BankTransfer avec les champs BankName et AccountNumber—sa méthode Process retourne "Bank transfer of $[amount] via [BankName] (***[last 3 digits of AccountNumber])"
processor.go : Créez une structure PaymentProcessor qui contient une PaymentMethod (dépendance injectée). Incluez un constructeur NewPaymentProcessor qui accepte une PaymentMethod. Ajoutez une méthode ExecutePayment(amount float64) string qui délègue à la méthode de paiement injectée. Créez également une fonction ProcessAll(payments []PaymentMethod, amount float64) []string qui traite le même montant via chaque méthode de paiement de la tranche (slice) et retourne tous les résultats.
main.go : Lisez les détails du paiement depuis l'entrée, créez les trois types de paiement et démontrez à la fois l'injection de dépendances et les collections polymorphes. Tout d'abord, utilisez NewPaymentProcessor avec la carte de crédit et exécutez un paiement. Ensuite, rassemblez les trois méthodes de paiement dans une tranche et utilisez ProcessAll pour les traiter toutes avec un deuxième montant. Affichez chaque résultat sur sa propre ligne.

Les entrées suivantes seront fournies :

Ligne 1 : Numéro de carte de crédit (par ex., 4532015112830366)
Ligne 2 : Nom du titulaire de la carte
Ligne 3 : Email PayPal
Ligne 4 : Nom de la banque
Ligne 5 : Numéro de compte (par ex., 987654321)
Ligne 6 : Premier montant du paiement (pour le processeur unique)
Ligne 7 : Deuxième montant du paiement (pour le traitement par lot)

Formatez les montants avec deux décimales. Par exemple, avec 4532015112830366, John Smith, john@email.com, Chase, 987654321, 99.99, et 50, votre sortie devrait être :

Credit Card 0366 charged $99.99 to John Smith
Credit Card 0366 charged $50.00 to John Smith
PayPal payment of $50.00 from john@email.com
Bank transfer of $50.00 via Chase (***321)

La première ligne montre le paiement unique via le processeur injecté. Les trois lignes restantes montrent le traitement par lot via la collection polymorphe—la même fonction ProcessAll gère tous les types de paiement de manière uniforme, démontrant comment les interfaces permettent des systèmes de paiement flexibles et extensibles.

Essayez vous-même

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	reader := bufio.NewReader(os.Stdin)

	// Lire l'entrée
	cardNumber, _ := reader.ReadString('\n')
	cardNumber = strings.TrimSpace(cardNumber)

	holderName, _ := reader.ReadString('\n')
	holderName = strings.TrimSpace(holderName)

	email, _ := reader.ReadString('\n')
	email = strings.TrimSpace(email)

	bankName, _ := reader.ReadString('\n')
	bankName = strings.TrimSpace(bankName)

	accountNumber, _ := reader.ReadString('\n')
	accountNumber = strings.TrimSpace(accountNumber)

	amount1Str, _ := reader.ReadString('\n')
	amount1Str = strings.TrimSpace(amount1Str)
	amount1, _ := strconv.ParseFloat(amount1Str, 64)

	amount2Str, _ := reader.ReadString('\n')
	amount2Str = strings.TrimSpace(amount2Str)
	amount2, _ := strconv.ParseFloat(amount2Str, 64)

	// TODO: Créer les trois types de paiement (CreditCard, PayPal, BankTransfer)

	// TODO: Créer un PaymentProcessor avec la carte de crédit en utilisant NewPaymentProcessor
	// et exécuter un paiement avec amount1, puis afficher le résultat

	// TODO: Créer un slice de PaymentMethod contenant les trois types de paiement

	// TODO: Utiliser ProcessAll pour traiter tous les paiements avec amount2
	// et afficher chaque résultat sur sa propre ligne
}