Warenwirtschaftssystem für Computerbase

package main

import (
    "bytes"
    "fmt"
    "text/template"
)

var tmpWWSMenu = template.Must(template.New("wws").Parse(tmpWWSMenuStr))
var tmpWWSMenuStr = `
**************************
* Warenwirtschaftssystem *
**************************

{{with .}}Optionen{{else}}Sorry keine Optionen implementiert :/{{end}}
{{range $i,$opt := .}}{{if $i}} {{$i}}: {{$opt.Bezeichner}}
{{end}}{{end}}
{{range $i,$opt := .}}{{if $i}}{{else}} {{$i}}: {{$opt.Bezeichner}}{{end}}{{end}}
`

type Option struct {
    Bezeichner string
    Funktion   func()
}

var Options []*Option
var menuMessage string

var produkte *Produkte
var kunden *Kunden

func init() {
    produkte = &Produkte{
        Produkte: []*Produkt{},
        ids:      make(map[int]struct{}),
    }
    kunden = &Kunden{
        Kunden: []*Kunde{},
        ids:    make(map[int]struct{}),
    }

    Options = []*Option{
        &Option{"beenden", func() { fmt.Println("beenden") }},
        &Option{"Neues Produkt eingeben", func() { produkte.Add() }},
        &Option{"Neuen Kunden eingeben", func() { kunden.Add() }},
        &Option{"Kunden ausgeben", func() { kunden.Print() }},
        &Option{"Produkte ausgeben", func() { produkte.Print() }},
        &Option{"Rabattliste", func() { fmt.Println("nicht gemacht da kein bock mehr :)") }},
    }
    var buffer bytes.Buffer
    tmpWWSMenu.Execute(&buffer, Options)
    menuMessage = (&buffer).String()
}

func main() {
    for len(Options) > 0 {
        opt, err := optionSelection()
        if err != nil {
            errorHandling(err)
        } else {
            if opt == Options[0] {
                break
            } else {
                opt.Funktion()
            }
        }
    }

    fmt.Println("Programm wurde beendet.")
}

func errorHandling(err error) {
    fmt.Println("\n>> Folgender Fehler ist aufgetreten:", err)
    fmt.Println("\nWeiter durch beliebige Taste.")
    fmt.Scanln()
}

func optionSelection() (*Option, error) {
    var selectedOption int
    fmt.Printf("%s", menuMessage)
    fmt.Print("Auswahl: ")
    _, err := fmt.Scanf("%d\n", &selectedOption)
    if err != nil {
        return nil, err
    }
    if selectedOption < 0 || selectedOption >= len(Options) {
        return nil, fmt.Errorf("Die Option %d ist unbekannt!", selectedOption)
    }
    return Options[selectedOption], nil
}

type Produkt struct {
    id    int
    name  string
    preis float32
}
type Produkte struct {
    Produkte []*Produkt
    ids      map[int]struct{}
}

func (ps *Produkte) Add() {
    var frage string
    for {
        fmt.Println("Ein Produkt hinzufügen? [j/n]")
        if _, err := fmt.Scanf("%s\n", &frage); err != nil {
            errorHandling(err)
            continue
        } else {
            if frage != "j" && frage != "J" {
                break
            }
            fmt.Println("\n\n")
        }

        var p = Produkt{}
        fmt.Print("Einzigartige ID: ")
        if _, err := fmt.Scanf("%d\n", &p.id); err != nil {
            errorHandling(err)
            continue
        }

        if _, exists := ps.ids[p.id]; exists {
            errorHandling(fmt.Errorf("Die Produkt ID existiert bereits!"))
            continue
        }

        fmt.Print("Name: ")
        if _, err := fmt.Scanf("%s\n", &p.name); err != nil {
            errorHandling(err)
            continue
        }
        if len(p.name) == 0 {
            errorHandling(fmt.Errorf("Der Name `%s` is zu kurz!", p.name))
            continue
        }

        fmt.Print("Preis: ")
        if _, err := fmt.Scanf("%f\n", &p.preis); err != nil {
            errorHandling(err)
            continue
        }
        if p.preis < 0 {
            errorHandling(fmt.Errorf("Negative Preise sind nicht möglich"))
            continue
        }

        // add product to the list
        ps.ids[p.id] = struct{}{}
        ps.Produkte = append(ps.Produkte, &p)
    }
}

func (ps *Produkte) Print() {
    fmt.Printf("%4s | %15s | %8s\n", "ID", "Name", "Preis")
    fmt.Println("---------------------------------")
    for _, p := range ps.Produkte {
        fmt.Printf("%4d | %15s | %8.2f\n", p.id, p.name, p.preis)
    }
}

type Kunde struct {
    id                int
    vorname, nachname string
}

type Kunden struct {
    Kunden []*Kunde
    ids    map[int]struct{}
}

func (ks *Kunden) Add() {
    var frage string
    for {
        fmt.Println("Ein neuen Kunden hinzufügen? [j/n]")
        if _, err := fmt.Scanf("%s\n", &frage); err != nil {
            errorHandling(err)
            continue
        } else {
            if frage != "j" && frage != "J" {
                break
            }
            fmt.Println("\n\n")
        }

        var k = Kunde{}
        fmt.Print("Einzigartige ID: ")
        if _, err := fmt.Scanf("%d\n", &k.id); err != nil {
            errorHandling(err)
            continue
        }

        if _, exists := ks.ids[k.id]; exists {
            errorHandling(fmt.Errorf("Die Kunden ID existiert bereits!"))
            continue
        }

        fmt.Print("Vorname: ")
        if _, err := fmt.Scanf("%s\n", &k.vorname); err != nil {
            errorHandling(err)
            continue
        }
        if len(k.vorname) == 0 {
            errorHandling(fmt.Errorf("Der Vorname `%s` ist nicht gültig!", k.vorname))
            continue
        }

        fmt.Print("Nachname: ")
        if _, err := fmt.Scanf("%s\n", &k.nachname); err != nil {
            errorHandling(err)
            continue
        }
        if len(k.nachname) == 0 {
            errorHandling(fmt.Errorf("Der Nachname `%s` ist nicht gültig!", k.nachname))
            continue
        }

        // add customer to list
        ks.ids[k.id] = struct{}{}
        ks.Kunden = append(ks.Kunden, &k)
    }
}

func (ks *Kunden) Print() {
    fmt.Printf("%4s | %15s | %15s\n", "ID", "Vorname", "Nachname")
    fmt.Println("----------------------------------------")
    for _, k := range ks.Kunden {
        fmt.Printf("%4d | %15s | %15s\n", k.id, k.vorname, k.nachname)
    }
}