Atualizando a Quantidade em Estoque

Parte da seção Lógica & Fluxo do Journey de GO da Coddy — lição 48 de 68.

Desafio

Fácil

Aprimore seu sistema de gerenciamento de inventário implementando atualizações de quantidade de estoque com validação abrangente e tratamento de erros. Este desafio baseia-se na funcionalidade anterior e adiciona a capacidade de modificar as quantidades de produtos existentes, evitando operações inválidas que poderiam resultar em níveis de estoque negativos.

Você receberá duas entradas:

Uma string contendo os dados do inventário existente no formato "product1:price1:quantity1,product2:price2:quantity2,product3:price3:quantity3" (ex: "Laptop:999.99:5,Mouse:25.50:15,Keyboard:75.00:8")
Uma string contendo as solicitações de atualização de estoque no formato "product1:change1,product2:change2,product3:change3" onde as alterações podem ser números inteiros positivos ou negativos (ex: "Mouse:10,Tablet:-5,Keyboard:-3")

Sua tarefa é:

Usar a mesma struct Product das lições anteriores com os campos Price (float64) e Quantity (int)
Analisar a primeira entrada dividindo-a por vírgulas para obter as entradas individuais de produtos existentes
Para cada entrada de produto existente, dividir por dois pontos para obter o nome do produto, preço e quantidade
Converter a string de preço para float64 e a string de quantidade para int
Criar e preencher o mapa inventory com os dados dos produtos existentes
Criar uma função chamada updateStock que recebe o mapa inventory, o nome do produto e a alteração de quantidade como parâmetros e retorna um erro:
- Se o produto não existir no inventário, retornar um erro com a mensagem "product not found: [product_name]"
- Se a alteração de quantidade resultar em um estoque negativo (quantidade atual + alteração < 0), retornar um erro com a mensagem "insufficient stock: cannot reduce [product_name] by [absolute_change_value], only [current_quantity] available"
- Se a atualização for válida, modificar a quantidade do produto no inventário e retornar nil
Analisar a segunda entrada dividindo-a por vírgulas para obter a lista de solicitações de atualização de estoque
Para cada solicitação de atualização, dividir por dois pontos para obter o nome do produto e a alteração de quantidade
Converter a string de alteração de quantidade para int
Exibir o cabeçalho do processo de atualização: "Processing Stock Updates:"
Para cada solicitação de atualização, chamar a função updateStock e exibir os resultados:
- Se não houver erro e a alteração for positiva: "[product_name]: Added [change] units - New stock: [new_quantity]"
- Se não houver erro e a alteração for negativa: "[product_name]: Removed [absolute_change_value] units - New stock: [new_quantity]"
- Se não houver erro e a alteração for zero: "[product_name]: No change - Current stock: [current_quantity]"
- Se houver erro: "[product_name]: Update failed - [error_message]"
Contar e exibir as estatísticas de atualização:
- "Update Summary:"
- "Updates processed: [total_number_of_updates_processed]"
- "Updates successful: [number_of_successful_updates]"
- "Updates failed: [number_of_failed_updates]"
Exibir o inventário atualizado em ordem alfabética pelo nome do produto:
- "Updated Inventory:"
- Para cada produto: "- [product_name]: $[price] (Stock: [quantity])"
Calcular e exibir as estatísticas finais do inventário:
- "Final Inventory Statistics:"
- "Total Products: [total_number_of_products_in_inventory]"
- "Total Items in Stock: [sum_of_all_quantities]"
- "Total Inventory Value: $[sum_of_price_times_quantity_for_all_products]"
Listar quaisquer atualizações que falharam:
- Se houver atualizações com falha: "Failed updates: [comma_separated_list_of_failed_product_names]"
- Se não houver atualizações com falha: "All stock updates were processed successfully"

Use o pacote strings para dividir as strings de entrada, o pacote strconv para converter strings em números, o pacote errors para criar mensagens de erro, o pacote fmt para saída formatada e o pacote sort para ordenar os nomes dos produtos em ordem alfabética. Formate todos os preços com 2 casas decimais e o valor total do inventário com 2 casas decimais. Este desafio demonstra como modificar dados existentes com segurança, evitando operações inválidas por meio de validação abrangente e tratamento de erros.

Experimente você mesmo

package main

import (
	"errors"
	"fmt"
	"sort"
	"strconv"
	"strings"
)

type Product struct {
	Price    float64
	Quantity int
}

func addNewItem(inventory map[string]Product, productName string, price float64, quantity int) error {
	if _, exists := inventory[productName]; exists {
		return errors.New("product already exists: " + productName)
	}
	inventory[productName] = Product{Price: price, Quantity: quantity}
	return nil
}

func main() {
	var existingInventory string
	var newProducts string
	fmt.Scanln(&existingInventory)
	fmt.Scanln(&newProducts)

	inventory := make(map[string]Product)

	// Parse existing inventory
	existingItems := strings.Split(existingInventory, ",")
	for _, item := range existingItems {
		parts := strings.Split(item, ":")
		name := parts[0]
		price, _ := strconv.ParseFloat(parts[1], 64)
		quantity, _ := strconv.Atoi(parts[2])
		inventory[name] = Product{Price: price, Quantity: quantity}
	}

	// Parse new products to add
	newItems := strings.Split(newProducts, ",")
	
	fmt.Println("Adding New Items:")
	
	itemsProcessed := 0
	itemsAdded := 0
	itemsRejected := 0
	var rejectedProducts []string

	for _, item := range newItems {
		parts := strings.Split(item, ":")
		name := parts[0]
		price, _ := strconv.ParseFloat(parts[1], 64)
		quantity, _ := strconv.Atoi(parts[2])
		
		itemsProcessed++
		
		err := addNewItem(inventory, name, price, quantity)
		if err != nil {
			fmt.Printf("%s: Failed to add - %s\n", name, err.Error())
			itemsRejected++
			rejectedProducts = append(rejectedProducts, name)
		} else {
			fmt.Printf("%s: Successfully added - $%.2f (Stock: %d)\n", name, price, quantity)
			itemsAdded++
		}
	}

	// Addition summary
	fmt.Println("Addition Summary:")
	fmt.Printf("Items processed: %d\n", itemsProcessed)
	fmt.Printf("Items added: %d\n", itemsAdded)
	fmt.Printf("Items rejected: %d\n", itemsRejected)

	// Display updated inventory in alphabetical order
	fmt.Println("Updated Inventory:")
	var productNames []string
	for name := range inventory {
		productNames = append(productNames, name)
	}
	sort.Strings(productNames)

	totalProducts := 0
	totalItems := 0
	totalValue := 0.0

	for _, name := range productNames {
		product := inventory[name]
		fmt.Printf("- %s: $%.2f (Stock: %d)\n", name, product.Price, product.Quantity)
		totalProducts++
		totalItems += product.Quantity
		totalValue += product.Price * float64(product.Quantity)
	}

	// Final inventory statistics
	fmt.Println("Final 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)

	// List rejected products
	if len(rejectedProducts) > 0 {
		fmt.Printf("Rejected products: %s\n", strings.Join(rejectedProducts, ","))
	} else {
		fmt.Println("All new products were added successfully")
	}
}

Todas as lições de Lógica & Fluxo

2Structs e Métodos

Definindo Métodos em Structs Recebedores de Valor Recebedores de Ponteiro Escolhendo Recebedores Métodos vs Funções Recapitulação - Comportamento de Structs

5Mapas em Profundidade

Mapas de Structs Ponteiros como Valores de Map Verificando Mapas Nil Comparando Mapas Recapitulação - Contador de Frequência de Palavras

8Projeto: Inventário Simples

Visão Geral do Projeto Verificando o Estoque

Adicionando um Novo Item

Atualizando a Quantidade em Estoque Lição de projeto

Gerando um Relatório

Juntando Tudo

11Desafios Finais

Lista de Contatos Básica Validador de Números Simples Coletor de Itens Únicos