Esempio n. 1
0
// CreateVenueHandler makes a new venue and saves it to the datastore
func CreateVenueHandler(w util.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)

	var venueData Venue
	if err := json.NewDecoder(r.Body).Decode(&venueData); err != nil {
		log.Println("Unable to decode create venue data:", err.Error())
		http.Error(w, "Unable to decode JSON request body", http.StatusBadRequest)
		return
	}

	if venueData.Name == "" {
		http.Error(w, `must provide "name" field when creating a venue`, http.StatusBadRequest)
		return
	}

	key := datastore.NewIncompleteKey(c, "Venues", nil)
	newKey, err := datastore.Put(c, key, &venueData)
	if err != nil {
		w.WriteJSON(nil, err)
		return
	}

	venueData.ID = newKey.IntID()
	w.WriteJSON(&venueData, nil)
}
Esempio n. 2
0
// GetVenueHandler returns information about a single Venue
func GetVenueHandler(w util.ResponseWriter, r *http.Request) {
	// TODO: Test this function
	c := appengine.NewContext(r)

	venueID, err := util.GetIntParam(r, "venue_id", 0)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	if !VenueExists(c, venueID) {
		http.Error(w, "provided venue_id does not exist", http.StatusBadRequest)
		return
	}

	key := datastore.NewKey(c, "Venues", "", venueID, nil)

	var venue Venue
	err = datastore.Get(c, key, &venue)

	if err == datastore.ErrNoSuchEntity {
		http.NotFound(w.ResponseWriter, r)
	} else if err != nil {
		log.Println("Unable to retrieve a venue from datastore:", err.Error())
		w.WriteJSON(nil, err)
		return
	}

	venue.ID = venueID
	w.WriteJSON(&venue, nil)
}
Esempio n. 3
0
// CreateVenueDishHandler creates a new dish based on the request body
func CreateVenueDishHandler(w util.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)

	var dishData Dish
	if err := json.NewDecoder(r.Body).Decode(&dishData); err != nil {
		log.Println("Unable to decode create dish data:", err.Error())
		http.Error(w, "Unable to decode JSON request body", http.StatusBadRequest)
		return
	}

	venueID, err := util.GetIntParam(r, "venue_id", 0)
	if !VenueExists(c, venueID) {
		http.Error(w, "provided venue_id does not exist", http.StatusBadRequest)
		return
	}
	dishData.VenueID = venueID

	if dishData.Name == "" {
		http.Error(w, `must provide "name" field when creating a dish`, http.StatusBadRequest)
		return
	}

	key := datastore.NewIncompleteKey(c, "Dishes", nil)
	newKey, err := datastore.Put(c, key, &dishData)
	if err != nil {
		w.WriteJSON(nil, err)
		return
	}

	dishData.ID = newKey.IntID()
	w.WriteJSON(&dishData, nil)
}
Esempio n. 4
0
// CreateDishRatingHandler inserts a new rating into the datastore.
// dish_id parameter must be set to a dish which exists in the datastore and
// rating must be between 1 and 10. User must be logged in.
func CreateDishRatingHandler(w util.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)

	dishID, err := util.GetIntParam(r, "dish_id", 0)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	if !DishExists(c, dishID) {
		http.Error(w, "provided dish_id does not exist", http.StatusBadRequest)
		return
	}

	// Check that no rating already exists for this dish
	if GetDishRating(c, dishID) != -1 {
		http.Error(w, "dish already has a rating from this user", http.StatusBadRequest)
		return
	}

	var ratingData Rating
	if err := json.NewDecoder(r.Body).Decode(&ratingData); err != nil {
		log.Println("unable to decode create rating data:", err.Error())
		http.Error(w, "Unable to decode JSON request body", http.StatusBadRequest)
		return
	}

	if ratingData.Rating > 10 || ratingData.Rating < 1 {
		http.Error(w, "rating must be between 1 and 10", http.StatusBadRequest)
		return
	}

	ratingData.DishID = dishID
	ratingData.UserID = GetCurrentUserID(c)
	ratingData.Timestamp = time.Now()

	key := datastore.NewIncompleteKey(c, "Ratings", nil)
	newKey, err := datastore.Put(c, key, &ratingData)
	if err != nil {
		w.WriteJSON(nil, err)
		return
	}

	w.WriteCreated("/api/rating/" + strconv.FormatInt(newKey.IntID(), 10))
}
Esempio n. 5
0
// GetVenuesHandler retrieves all venues
func GetVenuesHandler(w util.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)

	limit, err := util.GetIntParam(r, "limit", 25)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	offset, err := util.GetIntParam(r, "offset", 0)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	q := datastore.NewQuery("Venues").Limit(int(limit)).Offset(int(offset))

	var results []Venue
	keys, err := q.GetAll(c, &results)
	if err != nil {
		w.WriteJSON(nil, err)
	}

	if len(keys) == 0 {
		w.WriteJSON([]Venue{}, nil)
		return
	}

	for i, key := range keys {
		results[i].ID = key.IntID()
	}

	w.WriteJSON(results, err)
}
Esempio n. 6
0
// GetUserInfoHandler returns either the location where the user can log into
// the app, or metadata about the currently authenticated user.
func GetUserInfoHandler(w util.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	u := user.Current(c)

	dest := mux.Vars(r)["dest"]
	if dest == "" {
		dest = "/"
	}

	if u == nil {
		url, err := user.LoginURL(c, dest)
		w.WriteJSON(map[string]interface{}{"loginURL": url}, err)
		return
	}

	// Check if the user exists in the database
	q := datastore.NewQuery("Users").Limit(1)
	q.Filter("GoogleID = ", u.ID)

	var results []User
	keys, err := q.GetAll(c, &results)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	if len(results) == 0 {
		newUser := User{
			GoogleID:    u.ID,
			CreatedTime: time.Now(),
			Email:       u.Email,
		}

		key := datastore.NewIncompleteKey(c, "Users", nil)
		newKey, err := datastore.Put(c, key, &newUser)

		if newKey != nil {
			newUser.ID = newKey.IntID()
		}

		url, _ := user.LogoutURL(c, dest)
		newUser.LogoutURL = url
		w.WriteJSON(newUser, err)
		return
	}

	url, _ := user.LogoutURL(c, dest)

	fullUser := results[0]
	fullUser.ID = keys[0].IntID()
	fullUser.LogoutURL = url

	w.WriteJSON(fullUser, nil)
}
Esempio n. 7
0
// GetDishRatingsHandler returns the ratings for all users on a particular dish
func GetDishRatingsHandler(w util.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)

	dishID, err := util.GetIntParam(r, "dish_id", 0)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	if !DishExists(c, dishID) {
		http.Error(w, "provided dish_id does not exist", http.StatusBadRequest)
		return
	}

	limit, err := util.GetIntParam(r, "limit", 25)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	offset, err := util.GetIntParam(r, "offset", 0)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	q := datastore.NewQuery("Ratings").Limit(int(limit)).Offset(int(offset))
	q = q.Filter("DishID =", dishID)

	var results []Dish
	keys, err := q.GetAll(c, &results)
	if err != nil {
		w.WriteJSON(nil, err)
	}

	if len(keys) == 0 {
		w.WriteJSON([]Dish{}, nil)
		return
	}

	for i, key := range keys {
		results[i].ID = key.IntID()
	}

	w.WriteJSON(results, err)
}
Esempio n. 8
0
// getDishesHelper performs a datastore query, writing the results to the http
// response. If venueID is not 0, the results are filtered to only that venue.
func getDishesHelper(venueID int64, w util.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)

	limit, err := util.GetIntParam(r, "limit", 25)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	offset, err := util.GetIntParam(r, "offset", 0)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	q := datastore.NewQuery("Dishes").Limit(int(limit)).Offset(int(offset))

	if venueID != 0 {
		log.Printf("adding 'VenueID = %d' to query", venueID)
		q = q.Filter("VenueID =", venueID)
	}

	var results []Dish
	keys, err := q.GetAll(c, &results)
	if err != nil {
		w.WriteJSON(nil, err)
	}

	if len(keys) == 0 {
		w.WriteJSON([]Dish{}, nil)
		return
	}

	for i, key := range keys {
		results[i].ID = key.IntID()
	}

	w.WriteJSON(results, err)
}
Esempio n. 9
0
// GetRecentRatingsHandler returns increments of <limit> ratings, starting at
// <offset>, ordered from most recent to least.
func GetRecentRatingsHandler(w util.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)

	limit, err := util.GetIntParam(r, "limit", 10)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	offset, err := util.GetIntParam(r, "offset", 0)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	q := datastore.NewQuery("Ratings").Limit(int(limit)).Offset(int(offset))
	q = q.Filter("UserID =", GetCurrentUserID(c))
	q = q.Order("Timestamp")

	var results []Dish
	keys, err := q.GetAll(c, &results)
	if err != nil {
		w.WriteJSON(nil, err)
	}

	if len(keys) == 0 {
		w.WriteJSON([]Dish{}, nil)
		return
	}

	for i, key := range keys {
		results[i].ID = key.IntID()
	}

	w.WriteJSON(results, err)
}