Golang WriteResponse Examples

Example #1

File: FavoritesController.go Project: walkline/GoMastersLunch

func handleGetFavorites(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
	token, err := servers.AuthenticateWithHeader(r.Header.Get("Authorization"), strings.Split(r.RemoteAddr, ":")[0])
	if err != servers.STATUS_ERR_OK {
		servers.WriteResponse(w, nil, err)
		return
	}

	favorites, queryerr := models.LoadFavoritesFromDB(token.UsersId)
	if queryerr != nil {
		servers.WriteResponse(w, nil, servers.STATUS_ERR_QUERY_PROBLEM)
		return
	}

	error := favorites.LoadDishesFromDB()
	if error != nil {
		servers.WriteResponse(w, nil, servers.STATUS_ERR_QUERY_PROBLEM)
		return
	}

	usersDishes, queryerr2 := models.GetUsersDishes(token.UsersId, favorites.Dishes)
	if queryerr2 != nil {
		servers.WriteResponse(w, nil, servers.STATUS_ERR_QUERY_PROBLEM)
		return
	}

	servers.WriteResponse(w, usersDishes, servers.STATUS_SUCCESS)
}

Example #2

File: AuthController.go Project: walkline/GoMastersLunch

func handleAuth(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
	// get data from json params
	var encodedParams AuthEncodedParams
	err := json.NewDecoder(r.Body).Decode(&encodedParams)
	if err != nil {
		servers.WriteResponse(w, nil, servers.STATUS_ERR_PARAMS_DECODE)
		return
	}

	encodeData, err64 := base64.StdEncoding.DecodeString(encodedParams.Hash)
	if err64 != nil {
		servers.WriteResponse(w, nil, servers.STATUS_ERR_PARAMS_DECODE)
		return
	}

	// get real data by RSA decoding
	decoded, decodeError := crypt.RSADecrypt([]byte(encodeData))
	if decodeError != nil {
		servers.WriteResponse(w, nil, servers.STATUS_ERR_CANT_DECRYPT)
		return
	}

	var authData AuthData
	err = json.Unmarshal(decoded, &authData)
	if err != nil {
		servers.WriteResponse(w, nil, servers.STATUS_ERR_PARAMS_DECODE)
		return
	}

	// getting wordpress user by login
	var wpUser *models.WPUser
	wpUser, err = models.GetWPUserByLogin(authData.UserLogin)
	if err != nil {
		servers.WriteResponse(w, nil, servers.STATUS_ERR_USER_NOT_FOUND)
		return
	}

	// checking passwords
	if crypt.CheckPassword(authData.UserPass, wpUser.UserPass) {
		fmt.Println("User " + wpUser.Name + " authorized.")
	} else {
		servers.WriteResponse(w, nil, servers.STATUS_ERR_WRONG_PASS)
		return
	}

	role, roleError := models.GetUserRoleById(wpUser.Id)
	if roleError != nil {
		servers.WriteResponse(w, nil, servers.STATUS_ERR_CANT_GET_ROLE)
		return
	}

	token, expire, tokenerr := models.GenerateTokenAndSave(wpUser.Id, authData.DeviceId, authData.DeviceType, role, strings.Split(r.RemoteAddr, ":")[0])
	if tokenerr != nil {
		servers.WriteResponse(w, nil, servers.STATUS_ERR_CANT_GENERATE_TOKEN)
		return
	}

	tokenRes := TokenResult{token, expire}
	servers.WriteResponse(w, tokenRes, servers.STATUS_SUCCESS)
}

Example #3

File: DishesCategoriesController.go Project: walkline/GoMastersLunch

func handleGetCategoreis(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
	_, err := servers.AuthenticateWithHeader(r.Header.Get("Authorization"), strings.Split(r.RemoteAddr, ":")[0])
	if err != servers.STATUS_ERR_OK {
		servers.WriteResponse(w, nil, err)
		return
	}

	cat := GetCategoriesResponse{[]string{"First", "Second", "Garnishes", "Salads", "Desserts"}}

	servers.WriteResponse(w, cat, servers.STATUS_SUCCESS)
}

Example #4

File: UserController.go Project: walkline/GoMastersLunch

func handleGetUser(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
	token, err := servers.AuthenticateWithHeader(r.Header.Get("Authorization"), strings.Split(r.RemoteAddr, ":")[0])
	if err != servers.STATUS_ERR_OK {
		servers.WriteResponse(w, nil, err)
		return
	}

	userResult := GetUserResponse{token.User.Name, token.User.Email, token.Role}

	servers.WriteResponse(w, userResult, servers.STATUS_SUCCESS)
}

Example #5

File: OfficesController.go Project: walkline/GoMastersLunch

func handleGetOffices(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
	_, err := servers.AuthenticateWithHeader(r.Header.Get("Authorization"), strings.Split(r.RemoteAddr, ":")[0])
	if err != servers.STATUS_ERR_OK {
		servers.WriteResponse(w, nil, err)
		return
	}

	off := GetOfficesResponse{[]string{"Paris", "Not Paris"}}

	servers.WriteResponse(w, off, servers.STATUS_SUCCESS)
}

Example #6

File: ProvidersController.go Project: walkline/GoMastersLunch

func handleGetProviders(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
	_, err := servers.AuthenticateWithHeader(r.Header.Get("Authorization"), strings.Split(r.RemoteAddr, ":")[0])
	if err != servers.STATUS_ERR_OK {
		servers.WriteResponse(w, nil, err)
		return
	}

	providers, queryerr := models.GetAllProviders()
	if queryerr != nil {
		servers.WriteResponse(w, nil, servers.STATUS_ERR_QUERY_PROBLEM)
		return
	}

	res := GetProvidersResponse{providers}
	servers.WriteResponse(w, res, servers.STATUS_SUCCESS)
}

Example #7

File: OrdersController.go Project: walkline/GoMastersLunch

func handleGetOrders(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
	token, err := servers.AuthenticateWithHeader(r.Header.Get("Authorization"), strings.Split(r.RemoteAddr, ":")[0])
	if err != servers.STATUS_ERR_OK {
		servers.WriteResponse(w, nil, err)
		return
	}

	var params GetOrdersParams
	decodeerr := json.NewDecoder(r.Body).Decode(&params)
	if decodeerr != nil {
		servers.WriteResponse(w, nil, servers.STATUS_ERR_PARAMS_DECODE)
		return
	}

	menus, queryerr := models.GetOrdersForUserBetween(token.UsersId, params.StartDate, params.EndDate)
	if queryerr != nil {
		servers.WriteResponse(w, nil, servers.STATUS_ERR_QUERY_PROBLEM)
		return
	}

	res := GetOrdersResponse{menus}
	servers.WriteResponse(w, res, servers.STATUS_SUCCESS)
}

Example #8

File: MenuController.go Project: walkline/GoMastersLunch

func handleGetMenus(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
	_, err := servers.AuthenticateWithHeader(r.Header.Get("Authorization"), strings.Split(r.RemoteAddr, ":")[0])
	if err != servers.STATUS_ERR_OK {
		servers.WriteResponse(w, nil, err)
		return
	}

	var params MenuParams
	decodeErr := json.NewDecoder(r.Body).Decode(&params)
	if decodeErr != nil {
		servers.WriteResponse(w, nil, servers.STATUS_ERR_PARAMS_DECODE)
		return
	}

	menus, queryErr := models.GetMenuByProvider(params.ProviderId, params.Date)
	if queryErr != nil {
		servers.WriteResponse(w, nil, servers.STATUS_ERR_QUERY_PROBLEM)
		return
	}

	res := GetMenusResponse{menus}
	servers.WriteResponse(w, res, servers.STATUS_SUCCESS)
}

Example #9

File: PushController.go Project: walkline/GoMastersLunch

func handlePush(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
	if r.Header.Get("Authorization") != statictoken {
		servers.WriteResponse(w, nil, servers.STATUS_ERR_TOKEN_NOT_FOUND)
		return
	}

	var params models.PushMessage
	decodeerr := json.NewDecoder(r.Body).Decode(&params)
	if decodeerr != nil {
		servers.WriteResponse(w, nil, servers.STATUS_ERR_PARAMS_DECODE)
		return
	}

	fmt.Println("Params:", params)

	go func(params models.PushMessage) {
		err := notification.SendNotification(&params)
		if err != nil {
			fmt.Println("Sending problem:", err.Error())
		}
	}(params)

	servers.WriteResponse(w, nil, servers.STATUS_SUCCESS)
}

Example #10

File: FavoritesController.go Project: walkline/GoMastersLunch

func handleRemoveFavorites(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
	token, err := servers.AuthenticateWithHeader(r.Header.Get("Authorization"), strings.Split(r.RemoteAddr, ":")[0])
	if err != servers.STATUS_ERR_OK {
		servers.WriteResponse(w, nil, err)
		return
	}

	idStr := ps.ByName("dishId")

	dishId, convErr := strconv.ParseUint(idStr, 10, 64)
	if convErr != nil {
		servers.WriteResponse(w, nil, servers.STATUS_ERR_PARAMS_DECODE)
		return
	}

	favorites, queryerr := models.LoadFavoritesFromDB(token.UsersId)
	if queryerr != nil {
		servers.WriteResponse(w, nil, servers.STATUS_ERR_QUERY_PROBLEM)
		return
	}

	favorites.RemoveDish(dishId)
	queryerr = favorites.LoadDishesFromDB()
	if queryerr != nil {
		servers.WriteResponse(w, nil, servers.STATUS_ERR_QUERY_PROBLEM)
		return
	}

	queryerr = favorites.SaveToDB()
	if queryerr != nil {
		servers.WriteResponse(w, nil, servers.STATUS_ERR_QUERY_PROBLEM)
		return
	}

	usersDishes, queryerr2 := models.GetUsersDishes(token.UsersId, favorites.Dishes)
	if queryerr2 != nil {
		servers.WriteResponse(w, nil, servers.STATUS_ERR_QUERY_PROBLEM)
		return
	}

	servers.WriteResponse(w, usersDishes, servers.STATUS_SUCCESS)
}

Example #11

File: DishesController.go Project: walkline/GoMastersLunch

// params:
// 	providerId
// 	date
func handleGetDishesByProviderAndDate(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
	token, err := servers.AuthenticateWithHeader(r.Header.Get("Authorization"), strings.Split(r.RemoteAddr, ":")[0])
	if err != servers.STATUS_ERR_OK {
		servers.WriteResponse(w, nil, err)
		return
	}

	q := r.URL.Query()
	idstr := q.Get("providerId")

	providerId, converr1 := strconv.ParseUint(idstr, 10, 64)
	if converr1 != nil {
		servers.WriteResponse(w, nil, servers.STATUS_ERR_PARAMS_DECODE)
		return
	}

	dateStr := q.Get("date")
	date, converr2 := strconv.ParseInt(dateStr, 10, 64)
	if converr2 != nil {
		servers.WriteResponse(w, nil, servers.STATUS_ERR_PARAMS_DECODE)
		return
	}

	dishes, queryerr1 := models.GetDishesByProviderAndDate(providerId, date)
	if queryerr1 != nil {
		servers.WriteResponse(w, nil, servers.STATUS_ERR_QUERY_PROBLEM)
		return
	}

	usersDishes, queryerr2 := models.GetUsersDishes(token.UsersId, dishes)
	if queryerr2 != nil {
		servers.WriteResponse(w, nil, servers.STATUS_ERR_QUERY_PROBLEM)
		return
	}

	res := GetDishesResponse{usersDishes}

	servers.WriteResponse(w, res, servers.STATUS_SUCCESS)
}

Example #12

File: OrdersController.go Project: walkline/GoMastersLunch

func handleGetOrder(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
	token, err := servers.AuthenticateWithHeader(r.Header.Get("Authorization"), strings.Split(r.RemoteAddr, ":")[0])
	if err != servers.STATUS_ERR_OK {
		servers.WriteResponse(w, nil, err)
		return
	}

	q := r.URL.Query()
	var res interface{}

	orderIdStr := q.Get("order_id")

	orderFromDateStr := q.Get("from_date")
	orderToDateStr := q.Get("to_date")

	orderDateStr := q.Get("order_date")

	if len(orderIdStr) > 0 {
		orderId, converr := strconv.ParseInt(orderIdStr, 10, 64)
		if converr != nil {
			servers.WriteResponse(w, converr.Error(), servers.STATUS_ERR_PARAMS_DECODE)
			return
		}
		order, queryerr := models.GetOrderListForUserAndId(token.UsersId, uint64(orderId))
		if queryerr != nil {
			servers.WriteResponse(w, queryerr.Error(), servers.STATUS_ERR_QUERY_PROBLEM)
			return
		}
		res = GetOrderListResponse{*order}
	} else if len(orderFromDateStr) > 0 && len(orderToDateStr) > 0 {
		orderFromDate, converr := strconv.ParseInt(orderFromDateStr, 10, 64)
		if converr != nil {
			servers.WriteResponse(w, converr.Error(), servers.STATUS_ERR_PARAMS_DECODE)
			return
		}
		orderToDate, converr := strconv.ParseInt(orderToDateStr, 10, 64)
		if converr != nil {
			servers.WriteResponse(w, converr.Error(), servers.STATUS_ERR_PARAMS_DECODE)
			return
		}
		orders, queryerr := models.GetOrderListsForUserBetween(token.UsersId, orderFromDate, orderToDate)
		if queryerr != nil {
			servers.WriteResponse(w, queryerr.Error(), servers.STATUS_ERR_QUERY_PROBLEM)
			return
		}
		res = GetOrderListsResponse{orders}
	} else if len(orderDateStr) > 0 {
		orderDate, converr := strconv.ParseInt(orderDateStr, 10, 64)
		if converr != nil {
			servers.WriteResponse(w, converr.Error(), servers.STATUS_ERR_PARAMS_DECODE)
			return
		}
		order, queryerr := models.GetOrderListForUserAndDate(token.UsersId, orderDate)
		if queryerr != nil {
			servers.WriteResponse(w, queryerr.Error(), servers.STATUS_ERR_QUERY_PROBLEM)
			return
		}
		res = GetOrderListResponse{*order}
	}

	servers.WriteResponse(w, res, servers.STATUS_SUCCESS)
}