Verificar el stock

Parte de la sección Lógica y Flujo del Journey de GO de Coddy. Lección 46 de 68.

Desafío

Fácil

Implementa una función de comprobación de existencias para tu sistema de gestión de inventario que recupere de forma segura las cantidades de productos y gestione los casos en los que los productos no existan. Este desafío se basa en los fundamentos del inventario de la lección anterior y añade el manejo de errores para las consultas de existencias.

Recibirás dos entradas:

Una cadena que contiene datos de inventario existentes con el formato "product1:price1:quantity1,product2:price2:quantity2,product3:price3:quantity3" (por ejemplo, "Laptop:999.99:5,Mouse:25.50:15,Keyboard:75.00:8")
Una cadena que contiene solicitudes de comprobación de existencias con el formato "product1,product2,product3" (por ejemplo, "Mouse,Tablet,Keyboard")

Tu tarea consiste en:

Usar la misma estructura Product de la lección anterior, con los campos Price (float64) y Quantity (int)
Analizar la primera entrada separándola por comas para obtener entradas de productos individuales
Para cada entrada de producto, separarla por dos puntos para obtener el nombre del producto, el precio y la cantidad
Convertir la cadena del precio a float64 y la cadena de la cantidad a int
Crear y rellenar el mapa inventory con los datos de los productos analizados
Crear una función llamada checkStock que reciba el mapa de inventario y el nombre de un producto como parámetros y devuelva (int, error):
- Si el producto existe en el inventario, devolver su cantidad y nil
- Si el producto no existe, devolver 0 y un error con el mensaje "product not found: [product_name]"
Analizar la segunda entrada separándola por comas para obtener la lista de productos que se comprobarán
Mostrar el encabezado de la comprobación de existencias: "Stock Check Results:"
Para cada producto de la lista de comprobación, llamar a la función checkStock y mostrar los resultados:
- Si no hay ningún error: "[product_name]: [quantity] units in stock"
- Si hay un error: "[product_name]: Error - [error_message]"
Contar y mostrar las estadísticas resumidas:
- "Check Summary:"
- "Products checked: [total_number_of_products_checked]"
- "Products found: [number_of_products_that_exist]"
- "Products not found: [number_of_products_that_dont_exist]"
Mostrar las existencias totales de los productos encontrados:
- "Total stock for found products: [sum_of_quantities_for_existing_products] units"
Enumerar los productos que falten:
- Si faltan productos: "Missing products: [comma_separated_list_of_missing_products]"
- Si no falta ningún producto: "All requested products are available"

Usa el paquete strings para separar las cadenas de entrada, el paquete strconv para convertir cadenas a números, el paquete errors para crear mensajes de error y el paquete fmt para mostrar resultados con formato. Este desafío demuestra cómo implementar una recuperación segura de datos con un manejo adecuado de errores, un patrón fundamental en los sistemas de gestión de inventario.

Pruébalo tú mismo

package main

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

// Define the Product struct
type Product struct {
	Price    float64
	Quantity int
}

func main() {
	// Read input using bufio.Scanner to handle spaces properly
	scanner := bufio.NewScanner(os.Stdin)
	
	scanner.Scan()
	storeInfo := scanner.Text()
	
	scanner.Scan()
	productData := scanner.Text()
	
	// 1. Parse store information (split by comma)
	storeInfoParts := strings.Split(storeInfo, ",")
	storeName := ""
	location := ""
	if len(storeInfoParts) >= 2 {
		storeName = storeInfoParts[0]
		location = storeInfoParts[1]
	}
	
	// 2. Parse product data (split by comma, then by colon for each product)
	productEntries := strings.Split(productData, ",")
	
	// 3. Create inventory map
	inventory := make(map[string]Product)
	
	// 4. Convert strings to appropriate types and populate inventory
	for _, entry := range productEntries {
		parts := strings.Split(entry, ":")
		if len(parts) >= 3 {
			productName := parts[0]
			price, _ := strconv.ParseFloat(parts[1], 64)
			quantity, _ := strconv.Atoi(parts[2])
			
			inventory[productName] = Product{
				Price:    price,
				Quantity: quantity,
			}
		}
	}
	
	// 5. Display store information
	fmt.Printf("=== %s Inventory System ===\n", storeName)
	fmt.Printf("Location: %s\n", location)
	fmt.Printf("Inventory initialized with %d products\n", len(inventory))
	
	// 6. Display current inventory (sorted alphabetically)
	fmt.Println("Current Inventory:")
	var productNames []string
	for name := range inventory {
		productNames = append(productNames, name)
	}
	sort.Strings(productNames)
	
	for _, name := range productNames {
		product := inventory[name]
		fmt.Printf("- %s: $%.2f (Stock: %d)\n", name, product.Price, product.Quantity)
	}
	
	// 7. Calculate and display inventory statistics
	totalProducts := len(inventory)
	totalItems := 0
	totalValue := 0.0
	
	for _, product := range inventory {
		totalItems += product.Quantity
		totalValue += product.Price * float64(product.Quantity)
	}
	
	fmt.Println("Inventory Statistics:")
	fmt.Printf("Total Products: %d\n", totalProducts)
	fmt.Printf("Total Items in Stock: %d\n", totalItems)
	fmt.Printf("Total Inventory Value: $%.2f\n", totalValue)
	
	// 8. Display system status
	fmt.Println("System Status: Ready")
	fmt.Println("Inventory management system initialized successfully")
}