Copy docker run --rm zchencow/innozverse-go:latest go run - << 'EOF'
package main
import (
"context"
"encoding/json"
"errors"
"fmt"
"math"
"os"
"sort"
"strings"
"sync"
"time"
)
// Core types
type Product struct {
ID int `json:"id"`
Name string `json:"name"`
Price float64 `json:"price"`
Stock int `json:"stock"`
Category string `json:"category"`
Status string `json:"status"`
CreatedAt time.Time `json:"created_at"`
}
// Step 5: JSON-backed store
type JSONStore struct {
mu sync.RWMutex
path string
items map[int]Product
nextID int
}
func NewJSONStore(path string) (*JSONStore, error) {
s := &JSONStore{path: path, items: make(map[int]Product), nextID: 1}
if data, err := os.ReadFile(path); err == nil {
var saved struct {
NextID int `json:"next_id"`
Items map[int]Product `json:"items"`
}
if err := json.Unmarshal(data, &saved); err == nil {
s.items = saved.Items; s.nextID = saved.NextID
}
}
return s, nil
}
func (s *JSONStore) save() error {
data, err := json.MarshalIndent(struct {
NextID int `json:"next_id"`
Items map[int]Product `json:"items"`
}{s.nextID, s.items}, "", " ")
if err != nil { return err }
return os.WriteFile(s.path, data, 0644)
}
func (s *JSONStore) Create(p Product) (Product, error) {
s.mu.Lock(); defer s.mu.Unlock()
if strings.TrimSpace(p.Name) == "" { return p, errors.New("name required") }
if p.Price <= 0 { return p, errors.New("price must be positive") }
p.ID = s.nextID; s.nextID++
p.CreatedAt = time.Now()
if p.Status == "" { p.Status = "active" }
if p.Stock == 0 { p.Status = "out_of_stock" }
s.items[p.ID] = p
return p, s.save()
}
func (s *JSONStore) List(filter func(Product) bool) []Product {
s.mu.RLock(); defer s.mu.RUnlock()
result := make([]Product, 0, len(s.items))
for _, p := range s.items {
if filter == nil || filter(p) { result = append(result, p) }
}
sort.Slice(result, func(i, j int) bool { return result[i].ID < result[j].ID })
return result
}
func (s *JSONStore) Update(id int, fn func(*Product)) error {
s.mu.Lock(); defer s.mu.Unlock()
p, ok := s.items[id]
if !ok { return fmt.Errorf("product %d not found", id) }
fn(&p)
s.items[id] = p
return s.save()
}
func (s *JSONStore) Delete(id int) error {
s.mu.Lock(); defer s.mu.Unlock()
if _, ok := s.items[id]; !ok { return fmt.Errorf("product %d not found", id) }
delete(s.items, id)
return s.save()
}
// Step 6: Statistics
type Stats struct {
Total int
InStock int
OutOfStock int
TotalValue float64
AvgPrice float64
MinPrice float64
MaxPrice float64
ByCategory map[string]int
}
func ComputeStats(products []Product) Stats {
if len(products) == 0 { return Stats{ByCategory: make(map[string]int)} }
s := Stats{
Total: len(products),
ByCategory: make(map[string]int),
MinPrice: math.MaxFloat64,
}
for _, p := range products {
s.TotalValue += p.Price * float64(p.Stock)
s.AvgPrice += p.Price
if p.Price < s.MinPrice { s.MinPrice = p.Price }
if p.Price > s.MaxPrice { s.MaxPrice = p.Price }
s.ByCategory[p.Category]++
if p.Stock > 0 { s.InStock++ } else { s.OutOfStock++ }
}
s.AvgPrice /= float64(len(products))
return s
}
// Step 7: Concurrent price check (simulated)
type PriceCheck struct {
Product string
Current float64
Market float64
Delta float64
}
func checkPrices(ctx context.Context, products []Product) []PriceCheck {
results := make([]PriceCheck, len(products))
var wg sync.WaitGroup
for i, p := range products {
wg.Add(1)
go func(idx int, prod Product) {
defer wg.Done()
select {
case <-ctx.Done():
return
case <-time.After(time.Duration(idx+1) * 2 * time.Millisecond):
// Simulate market price (±10% variation)
market := prod.Price * (0.95 + float64(idx%3)*0.05)
results[idx] = PriceCheck{
Product: prod.Name,
Current: prod.Price,
Market: math.Round(market*100) / 100,
Delta: math.Round((market-prod.Price)*100) / 100,
}
}
}(i, p)
}
wg.Wait()
return results
}
// Step 8: Capstone — full CLI run
func main() {
path := "/tmp/storecli.json"
store, _ := NewJSONStore(path)
defer os.Remove(path)
// Seed data
seeds := []Product{
{Name: "Surface Pro 12\"", Price: 864.00, Stock: 15, Category: "Laptop"},
{Name: "Surface Pen", Price: 49.99, Stock: 80, Category: "Accessory"},
{Name: "Office 365", Price: 99.99, Stock: 999,Category: "Software"},
{Name: "USB-C Hub", Price: 29.99, Stock: 0, Category: "Accessory"},
{Name: "Surface Book 3", Price: 1299.00,Stock: 5, Category: "Laptop"},
}
fmt.Println("=== storecli — Inventory Manager ===\n")
fmt.Println("Seeding products...")
for _, p := range seeds {
created, err := store.Create(p)
if err != nil { fmt.Println(" Error:", err); continue }
fmt.Printf(" + [%d] %s $%.2f\n", created.ID, created.Name, created.Price)
}
// List all
fmt.Println("\n--- All Products ---")
all := store.List(nil)
for _, p := range all {
fmt.Printf(" [%d] %-22s $%8.2f stock=%-4d %s\n",
p.ID, p.Name, p.Price, p.Stock, p.Status)
}
// Update
store.Update(1, func(p *Product) { p.Price = 799.99 })
fmt.Printf("\nUpdated #1 price → $799.99\n")
// Stats
fmt.Println("\n--- Inventory Stats ---")
stats := ComputeStats(store.List(nil))
fmt.Printf(" Total: %d products\n", stats.Total)
fmt.Printf(" In stock: %d\n", stats.InStock)
fmt.Printf(" Out of stock: %d\n", stats.OutOfStock)
fmt.Printf(" Avg price: $%.2f\n", stats.AvgPrice)
fmt.Printf(" Price range: $%.2f – $%.2f\n", stats.MinPrice, stats.MaxPrice)
fmt.Printf(" Total value: $%.2f\n", stats.TotalValue)
fmt.Println(" By category:")
for cat, n := range stats.ByCategory {
fmt.Printf(" %-14s %d\n", cat, n)
}
// Filter: Laptops only
laptops := store.List(func(p Product) bool { return p.Category == "Laptop" })
fmt.Printf("\n--- Laptops (%d) ---\n", len(laptops))
for _, p := range laptops { fmt.Printf(" %s $%.2f\n", p.Name, p.Price) }
// Concurrent price check
fmt.Println("\n--- Market Price Check ---")
ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
defer cancel()
checks := checkPrices(ctx, all)
for _, c := range checks {
direction := "↔"
if c.Delta > 0 { direction = "↑" } else if c.Delta < 0 { direction = "↓" }
fmt.Printf(" %-22s $%.2f → market $%.2f %s%.2f\n",
c.Product, c.Current, c.Market, direction, math.Abs(c.Delta))
}
// Delete
store.Delete(4)
fmt.Printf("\nDeleted #4 (USB-C Hub)\n")
fmt.Printf("Final count: %d products\n", len(store.List(nil)))
fmt.Println("\n✅ storecli capstone complete!")
fmt.Println(" Labs 01–14 applied: structs, interfaces, goroutines,")
fmt.Println(" errors, file I/O, JSON, HTTP patterns, testing,")
fmt.Println(" context, generics — all in one Go program.")
}
EOF 