Ejemplo n.º 1
0
func handleDeleteCellarRequest(c appengine.Context, w http.ResponseWriter, r *http.Request) {

	deleteCellarID, err := strconv.Atoi(r.PostFormValue("cellarID"))
	if err != nil {
		writeError(w, err)
		return
	}

	account := getAccount(c)
	if account == nil {
		writeError(w, errors.New("no account"))
	}

	cellar := account.CellarsByID[deleteCellarID]
	err = account.DeleteCellarByID(deleteCellarID)
	if err != nil {
		writeError(w, err)
		return
	}

	err = models.SaveAccount(c, account)
	if err != nil {
		writeError(w, err)
		return
	}

	writeSuccess(w, simpleCellar{ID: cellar.ID, Name: cellar.Name})
}
Ejemplo n.º 2
0
func handleNewCellarRequest(c appengine.Context, w http.ResponseWriter, r *http.Request) {

	newCellar := r.PostFormValue("cellarName")

	if newCellar != "" {
		account := getAccount(c)
		if account == nil {
			writeError(w, errors.New("no account"))
			return
		}

		err := account.AddCellar(newCellar)
		if err != nil {
			writeError(w, err)
			return
		}

		err = models.SaveAccount(c, account)
		if err != nil {
			writeError(w, err)
			return
		}

		cellar := account.Cellars[newCellar]
		writeSuccess(w, simpleCellar{ID: cellar.ID, Name: cellar.Name, BeerCount: 0})
		return
	}

	writeError(w, errors.New("No cellar supplied"))
}
Ejemplo n.º 3
0
func handleDeleteTastingRequest(c appengine.Context, w http.ResponseWriter, r *http.Request) {

	cellarID, err := strconv.Atoi(r.PostFormValue("cellarID"))
	if err != nil {
		writeError(w, err)
		return
	}

	beerID, err := strconv.Atoi(r.PostFormValue("beerID"))
	if err != nil {
		writeError(w, err)
		return
	}

	tastingID, err := strconv.Atoi(r.PostFormValue("tastingID"))
	if err != nil {
		writeError(w, err)
		return
	}

	account := getAccount(c)
	if account == nil {
		writeError(w, errors.New("no account"))
		return
	}

	cellar := account.CellarsByID[cellarID]
	if cellar == nil {
		writeError(w, errors.New("cellar not found"))
		return
	}

	beer := cellar.BeersByID[beerID]
	if beer == nil {
		writeError(w, errors.New("beer not found"))
		return
	}

	tasting := beer.TastingsByID[tastingID]
	if tasting == nil {
		writeError(w, errors.New("tasting not found"))
		return
	}

	delete(beer.TastingsByID, tasting.ID)

	err = models.SaveAccount(c, account)
	if err != nil {
		writeError(w, err)
		return
	}

	writeSuccess(w, simpleTasting{ID: tasting.ID,
		Quantity:      beer.Quantity,
		AverageRating: beer.GetAverageRating(),
	})
}
Ejemplo n.º 4
0
func handleDeleteBeerRequest(c appengine.Context, w http.ResponseWriter, r *http.Request) {

	cellarID, err := strconv.Atoi(r.PostFormValue("cellarID"))
	if err != nil {
		writeError(w, err)
		return
	}

	beerID, err := strconv.Atoi(r.PostFormValue("beerID"))
	if err != nil {
		writeError(w, err)
		return
	}

	account := getAccount(c)
	if account == nil {
		writeError(w, errors.New("no account"))
		return
	}

	cellar := account.CellarsByID[cellarID]
	if cellar == nil {
		writeError(w, errors.New("cellar not found"))
		return
	}

	beer := cellar.BeersByID[beerID]
	if beer == nil {
		writeError(w, errors.New("beer not found"))
		return
	}

	delete(cellar.Beers, beer.Name)
	delete(cellar.BeersByID, beer.ID)

	err = models.SaveAccount(c, account)
	if err != nil {
		writeError(w, err)
		return
	}

	writeSuccess(w, simpleBeer{ID: beer.ID, Name: beer.Name})
}
Ejemplo n.º 5
0
func handleUpdateAccount(c appengine.Context, w http.ResponseWriter, r *http.Request) {

	newUsername := r.PostFormValue("username")

	if newUsername != "" {
		account := getAccount(c)
		if account == nil {
			writeError(w, errors.New("no account"))
			return
		}

		account.User.UserID = newUsername
		err := models.SaveAccount(c, account)
		if err != nil {
			writeError(w, err)
			return
		}
		writeSuccess(w, simpleUser{Username: newUsername})
		return
	}

	writeError(w, errors.New("No username supplied"))
}
Ejemplo n.º 6
0
func handleUpdateCellarRequest(c appengine.Context, w http.ResponseWriter, r *http.Request) {

	cellarID, err := strconv.Atoi(r.PostFormValue("cellarID"))
	if err != nil {
		writeError(w, err)
		return
	}

	cellarName := r.PostFormValue("cellarName")

	if cellarName != "" {
		account := getAccount(c)
		if account == nil {
			writeError(w, errors.New("no account"))
			return
		}

		err := account.UpdateCellarName(cellarID, cellarName)
		if err != nil {
			writeError(w, err)
			return
		}

		err = models.SaveAccount(c, account)
		if err != nil {
			writeError(w, err)
			return
		}

		cellar := account.CellarsByID[cellarID]
		writeSuccess(w, simpleCellar{ID: cellar.ID, Name: cellar.Name})
		return
	}

	writeError(w, errors.New("No cellar supplied"))
}
Ejemplo n.º 7
0
func importaccount(c appengine.Context, w http.ResponseWriter, r *http.Request) {
	usr := user.Current(c)
	if usr == nil {
		w.Write([]byte("Not logged in"))
	}
	account := models.GetAccount(c, usr.Email)

	r.ParseForm()

	//file, header, err
	file, _, err := r.FormFile("importfile")
	if err != nil {
		w.Write([]byte(err.Error()))
		return
	}

	reset := r.Form.Get("resetAccount") == "on"

	if reset {
		account.Cellars = map[string]*models.Cellar{}
		account.CellarsByID = map[int]*models.Cellar{}
	}
	csvReader := csv.NewReader(file)
	csvReader.FieldsPerRecord = -1
	err = nil

	var currentCellar *models.Cellar
	var currentBeer *models.Beer

	for err == nil {
		line, err2 := csvReader.Read()
		err = err2
		if len(line) > 0 {
			switch {
			case "CELLAR" == line[0]:
				{
					w.Write([]byte("Got Cellar"))
					cellarName := line[1]
					currentCellar = account.Cellars[cellarName]
					if currentCellar == nil {
						currentCellar = &models.Cellar{
							ID:         account.NextCellarID,
							NextBeerID: 0,
							Name:       cellarName,
							Beers:      map[string]*models.Beer{},
							BeersByID:  map[int]*models.Beer{},
						}
						account.Cellars[cellarName] = currentCellar
						account.CellarsByID[account.NextCellarID] = currentCellar
						account.NextCellarID++
					}
					break
				}
			case "BEER" == line[0]:
				{
					w.Write([]byte("Got Beer"))
					ubid, err := strconv.Atoi(line[1])
					if err != nil {
						w.Write([]byte(err.Error()))
						return
					}
					if ubid < 0 {
						ubid, err = models.GetAndIncrementUniversalBeerID(c)
						if err != nil {
							w.Write([]byte(err.Error()))
							return
						}
					}
					beerName := line[2]
					quantity, err := strconv.Atoi(line[3])
					if err != nil {
						w.Write([]byte(err.Error()))
						return
					}
					notes := line[4]
					brewed := models.ParseDate(line[5])
					added := models.ParseDate(line[6])
					currentBeer = currentCellar.Beers[beerName]
					if currentBeer == nil {
						currentBeer = &models.Beer{
							UBID:          ubid,
							ID:            currentCellar.NextBeerID,
							Name:          beerName,
							Notes:         notes,
							Brewed:        brewed,
							Added:         added,
							Quantity:      quantity,
							NextTastingID: 0,
							TastingsByID:  map[int]*models.Tasting{},
						}
						currentCellar.Beers[beerName] = currentBeer
						currentCellar.BeersByID[currentCellar.NextBeerID] = currentBeer
						currentCellar.NextBeerID++
					}
					break
				}
			case "TASTING" == line[0]:
				{
					w.Write([]byte("Got Tasting"))
					rating, err := strconv.Atoi(line[1])
					if err != nil {
						w.Write([]byte(err.Error()))
						return
					}
					notes := line[2]
					tasted := models.ParseDate(line[3])
					var currentTasting *models.Tasting
					for _, tasting := range currentBeer.TastingsByID {
						if tasting.Rating == rating && tasting.Notes == notes && tasting.Date.ToString() == tasted.ToString() {
							currentTasting = tasting
							break
						}
					}
					if currentTasting == nil {
						currentTasting = &models.Tasting{
							ID:     currentBeer.NextTastingID,
							Rating: rating,
							Notes:  notes,
							Date:   tasted,
						}
						currentBeer.TastingsByID[currentBeer.NextTastingID] = currentTasting
						currentBeer.NextTastingID++
					}
					break
				}
			}
		}
	}

	if err != io.EOF {
		w.Write([]byte(err.Error()))
		return
	}

	models.SaveAccount(c, account)
}
Ejemplo n.º 8
0
func handleUpdateTastingRequest(c appengine.Context, w http.ResponseWriter, r *http.Request) {

	cellarID, err := strconv.Atoi(r.PostFormValue("cellarID"))
	if err != nil {
		writeError(w, err)
		return
	}

	beerID, err := strconv.Atoi(r.PostFormValue("beerID"))
	if err != nil {
		writeError(w, err)
		return
	}

	tastingID, err := strconv.Atoi(r.PostFormValue("tastingID"))
	if err != nil {
		writeError(w, err)
		return
	}

	tastedDateStr := r.PostFormValue("tastedDate")
	var tastedDate *models.Date
	if tastedDateStr == "" {
		tastedDate = models.Now()
	} else {
		tastedDate = models.ParseDate(tastedDateStr)
	}

	rating, err := strconv.Atoi(r.PostFormValue("rating"))
	if err != nil {
		writeError(w, err)
		return
	}

	notes := r.PostFormValue("notes")

	account := getAccount(c)
	if account == nil {
		writeError(w, errors.New("no account"))
		return
	}

	cellar := account.CellarsByID[cellarID]
	if cellar == nil {
		writeError(w, errors.New("cellar not found"))
		return
	}

	beer := cellar.BeersByID[beerID]
	if beer == nil {
		writeError(w, errors.New("beer not found"))
		return
	}

	tasting := beer.TastingsByID[tastingID]
	if tasting == nil {
		writeError(w, errors.New("tasting not found"))
		return
	}

	tasting.Notes = notes
	tasting.Rating = rating
	tasting.Date = tastedDate

	err = models.SaveAccount(c, account)
	if err != nil {
		writeError(w, err)
		return
	}

	writeSuccess(w, simpleTasting{
		ID:            tasting.ID,
		Rating:        tasting.Rating,
		Notes:         tasting.Notes,
		TastedDate:    tasting.Date.ToString(),
		AgeTastedDate: beer.GetTastingAge(tasting),
		Quantity:      beer.Quantity,
		AverageRating: beer.GetAverageRating(),
	})
}
Ejemplo n.º 9
0
func handleUpdateBeerRequest(c appengine.Context, w http.ResponseWriter, r *http.Request) {

	cellarID, err := strconv.Atoi(r.PostFormValue("cellarID"))
	if err != nil {
		writeError(w, err)
		return
	}

	beerID, err := strconv.Atoi(r.PostFormValue("beerID"))
	if err != nil {
		writeError(w, err)
		return
	}

	quantity, err := strconv.Atoi(r.PostFormValue("quantity"))
	if err != nil {
		writeError(w, err)
		return
	}

	account := getAccount(c)
	if account == nil {
		writeError(w, errors.New("no account"))
		return
	}

	cellar := account.CellarsByID[cellarID]
	if cellar == nil {
		writeError(w, errors.New("Could not update beer, cellar not found"))
		return
	}

	beer := cellar.BeersByID[beerID]
	if beer == nil {
		writeError(w, errors.New("Could not update beer, beer not found"))
		return
	}

	name := r.PostFormValue("name")
	notes := r.PostFormValue("notes")

	brewed := r.PostFormValue("brewed")
	var brewDate *models.Date
	if brewed == "" {
		brewDate = models.Now()
	} else {
		brewDate = models.ParseDate(brewed)
	}

	added := r.PostFormValue("added")
	var addedDate *models.Date
	if added == "" {
		addedDate = models.Now()
	} else {
		addedDate = models.ParseDate(added)
	}

	delete(cellar.Beers, beer.Name)

	beer.Name = name
	beer.Quantity = quantity
	beer.Notes = notes
	beer.Brewed = brewDate
	beer.Added = addedDate

	cellar.Beers[beer.Name] = beer

	err = models.SaveAccount(c, account)
	if err != nil {
		writeError(w, err)
		return
	}
	writeSuccess(w, simpleBeer{
		ID:            beer.ID,
		Name:          beer.Name,
		AverageRating: 0,
		Quantity:      quantity,
		Notes:         beer.Notes,
		Brewed:        beer.Brewed.ToString(),
		Added:         beer.Added.ToString(),
		Age:           beer.GetAgeString(),
	})
}
Ejemplo n.º 10
0
func handleTransferBeerRequest(c appengine.Context, w http.ResponseWriter, r *http.Request) {

	fromCellarID, err := strconv.Atoi(r.PostFormValue("fromCellarID"))
	if err != nil {
		writeError(w, err)
		return
	}

	toCellarID, err := strconv.Atoi(r.PostFormValue("toCellarID"))
	if err != nil {
		writeError(w, err)
		return
	}

	beerID, err := strconv.Atoi(r.PostFormValue("beerID"))
	if err != nil {
		writeError(w, err)
		return
	}

	account := getAccount(c)
	if account == nil {
		writeError(w, errors.New("no account"))
		return
	}

	fromCellar := account.CellarsByID[fromCellarID]
	if fromCellar == nil {
		writeError(w, errors.New("Could not move from cellar, cellar not found"))
		return
	}
	toCellar := account.CellarsByID[toCellarID]
	if toCellar == nil {
		writeError(w, errors.New("Could not move to cellar, cellar not found"))
		return
	}
	beer := fromCellar.BeersByID[beerID]
	if beer == nil {
		writeError(w, errors.New("Could not move from cellar, beer not found"))
		return
	}

	delete(fromCellar.Beers, beer.Name)
	delete(fromCellar.BeersByID, beer.ID)

	oldBeerID := beer.ID

	beer.ID = toCellar.NextBeerID
	toCellar.NextBeerID++

	toCellar.Beers[beer.Name] = beer
	toCellar.BeersByID[beer.ID] = beer

	err = models.SaveAccount(c, account)
	if err != nil {
		writeError(w, err)
		return
	}
	writeSuccess(w, simpleTransfer{
		FromCellar: simpleCellar{
			ID:   fromCellar.ID,
			Name: fromCellar.Name,
		},
		ToCellar: simpleCellar{
			ID:   toCellar.ID,
			Name: toCellar.Name,
		},
		Beer: simpleBeer{
			ID:   oldBeerID,
			Name: beer.Name,
		},
	})
}
Ejemplo n.º 11
0
func handleNewBeerRequest(c appengine.Context, w http.ResponseWriter, r *http.Request) {

	cellarID, err := strconv.Atoi(r.PostFormValue("cellarID"))
	if err != nil {
		writeError(w, err)
		return
	}

	quantity, err := strconv.Atoi(r.PostFormValue("quantity"))
	if err != nil {
		writeError(w, err)
		return
	}

	name := r.PostFormValue("name")
	if name == "" {
		writeError(w, errors.New("No beer supplied"))
		return
	}

	notes := r.PostFormValue("notes")

	brewed := r.PostFormValue("brewed")
	var brewDate *models.Date
	if brewed == "" {
		brewDate = models.Now()
	} else {
		brewDate = models.ParseDate(brewed)
	}

	added := r.PostFormValue("added")
	var addedDate *models.Date
	if added == "" {
		addedDate = models.Now()
	} else {
		addedDate = models.ParseDate(added)
	}

	account := getAccount(c)
	if account == nil {
		writeError(w, errors.New("no account"))
		return
	}

	cellar := account.CellarsByID[cellarID]
	if cellar == nil {
		writeError(w, errors.New("cellar not found"))
		return
	}

	ubid, err := models.GetAndIncrementUniversalBeerID(c)
	if err != nil {
		writeError(w, err)
		return
	}

	beer := &models.Beer{
		UBID:          ubid,
		ID:            cellar.NextBeerID,
		Name:          name,
		Notes:         notes,
		Brewed:        brewDate,
		Added:         addedDate,
		Quantity:      quantity,
		NextTastingID: 0,
		TastingsByID:  map[int]*models.Tasting{},
	}

	cellar.NextBeerID++

	cellar.Beers[beer.Name] = beer
	cellar.BeersByID[beer.ID] = beer

	err = models.SaveAccount(c, account)
	if err != nil {
		writeError(w, err)
		return
	}

	writeSuccess(w, simpleBeer{
		ID:            beer.ID,
		Name:          beer.Name,
		AverageRating: 0,
		Quantity:      quantity,
		Notes:         beer.Notes,
		Brewed:        beer.Brewed.ToString(),
		Added:         beer.Added.ToString(),
		Age:           beer.GetAgeString(),
	})
}