305 lines
8.6 KiB
Go
305 lines
8.6 KiB
Go
package routers
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"net/http"
|
|
"os"
|
|
"path"
|
|
"recipe-manager/data"
|
|
"recipe-manager/helpers"
|
|
"recipe-manager/models"
|
|
"recipe-manager/services/logger"
|
|
"recipe-manager/services/sheet"
|
|
"sort"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"github.com/go-chi/chi/v5"
|
|
"go.uber.org/zap"
|
|
)
|
|
|
|
type RecipeRouter struct {
|
|
data *data.Data
|
|
sheetService sheet.SheetService
|
|
}
|
|
|
|
var (
|
|
Log = logger.GetInstance()
|
|
)
|
|
|
|
func NewRecipeRouter(data *data.Data, sheetService sheet.SheetService) *RecipeRouter {
|
|
return &RecipeRouter{
|
|
data: data,
|
|
sheetService: sheetService,
|
|
}
|
|
}
|
|
|
|
func (rr *RecipeRouter) Route(r chi.Router) {
|
|
r.Route("/recipes", func(r chi.Router) {
|
|
r.Get("/", func(w http.ResponseWriter, r *http.Request) {
|
|
w.Header().Add("Content-Type", "application/json")
|
|
var take, offset uint64 = 10, 0
|
|
if newOffset, err := strconv.ParseUint(r.URL.Query().Get("offset"), 10, 64); err == nil {
|
|
offset = newOffset
|
|
}
|
|
|
|
if newTake, err := strconv.ParseUint(r.URL.Query().Get("take"), 10, 64); err == nil {
|
|
take = newTake
|
|
}
|
|
|
|
country := r.URL.Query().Get("country")
|
|
filename := r.URL.Query().Get("filename")
|
|
materialIds := r.URL.Query().Get("material_ids")
|
|
|
|
var materialIdsUint []uint64
|
|
for _, v := range strings.Split(materialIds, ",") {
|
|
materialIdUint, err := strconv.ParseUint(v, 10, 64)
|
|
if err != nil || materialIdUint == 0 {
|
|
continue
|
|
}
|
|
materialIdsUint = append(materialIdsUint, materialIdUint)
|
|
}
|
|
|
|
countryID, err := rr.data.GetCountryIDByName(country)
|
|
|
|
if err != nil {
|
|
http.Error(w, fmt.Sprintf("Country Name: %s not found!!!", country), http.StatusNotFound)
|
|
return
|
|
}
|
|
|
|
recipe := rr.data.GetRecipe(countryID, filename)
|
|
searchQuery := r.URL.Query().Get("search")
|
|
|
|
if searchQuery != "" {
|
|
recipe.Recipe01 = []models.Recipe01{}
|
|
for _, v := range rr.data.GetRecipe01() {
|
|
if strings.Contains(strings.ToLower(v.ProductCode), strings.ToLower(searchQuery)) ||
|
|
strings.Contains(strings.ToLower(v.Name), strings.ToLower(searchQuery)) ||
|
|
strings.Contains(strings.ToLower(v.OtherName), strings.ToLower(searchQuery)) {
|
|
recipe.Recipe01 = append(recipe.Recipe01, v)
|
|
}
|
|
}
|
|
}
|
|
|
|
if len(materialIdsUint) > 0 {
|
|
resultFilter := []models.Recipe01{}
|
|
for _, v := range recipe.Recipe01 {
|
|
for _, matID := range materialIdsUint {
|
|
for _, recipe := range v.Recipes {
|
|
if recipe.IsUse && uint64(recipe.MaterialPathId) == matID {
|
|
resultFilter = append(resultFilter, v)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
recipe.Recipe01 = resultFilter
|
|
}
|
|
|
|
isHasMore := len(recipe.Recipe01) >= int(take+offset)
|
|
if isHasMore {
|
|
recipe.Recipe01 = recipe.Recipe01[offset : take+offset]
|
|
sort.Slice(recipe.Recipe01, func(i, j int) bool {
|
|
return recipe.Recipe01[i].ID < recipe.Recipe01[j].ID
|
|
})
|
|
} else if len(recipe.Recipe01) > int(offset) {
|
|
recipe.Recipe01 = recipe.Recipe01[offset:]
|
|
} else {
|
|
recipe.Recipe01 = []models.Recipe01{}
|
|
}
|
|
|
|
json.NewEncoder(w).Encode(map[string]interface{}{
|
|
"fileName": rr.data.CurrentFile,
|
|
"recipes": recipe,
|
|
"hasMore": isHasMore,
|
|
})
|
|
})
|
|
|
|
r.Get("/{product_code}", func(w http.ResponseWriter, r *http.Request) {
|
|
w.Header().Add("Content-Type", "application/json")
|
|
productCode := chi.URLParam(r, "product_code")
|
|
|
|
recipe := rr.data.GetRecipe01()
|
|
recipeMetaData := rr.sheetService.GetSheet(r.Context(), "1rSUKcc5POR1KeZFGoeAZIoVoI7LPGztBhPw5Z_ConDE")
|
|
|
|
var recipeResult *models.Recipe01
|
|
recipeMetaDataResult := map[string]string{}
|
|
|
|
for _, v := range recipe {
|
|
if v.ProductCode == productCode {
|
|
recipeResult = &v
|
|
break
|
|
}
|
|
}
|
|
|
|
for _, v := range recipeMetaData {
|
|
if v[0].(string) == productCode {
|
|
recipeMetaDataResult = map[string]string{
|
|
"productCode": v[0].(string),
|
|
"name": v[1].(string),
|
|
"otherName": v[2].(string),
|
|
"description": v[3].(string),
|
|
"otherDescription": v[4].(string),
|
|
"picture": v[5].(string),
|
|
}
|
|
break
|
|
}
|
|
}
|
|
|
|
if recipeResult == nil {
|
|
http.Error(w, "Not Found", http.StatusNotFound)
|
|
return
|
|
}
|
|
|
|
json.NewEncoder(w).Encode(map[string]interface{}{
|
|
"recipe": recipeResult,
|
|
"recipeMetaData": recipeMetaDataResult,
|
|
})
|
|
})
|
|
|
|
r.Get("/{country}/{filename}/json", func(w http.ResponseWriter, r *http.Request) {
|
|
country := chi.URLParam(r, "country")
|
|
filename := chi.URLParam(r, "filename")
|
|
|
|
w.Header().Add("Content-Type", "application/json")
|
|
countryID, err := rr.data.GetCountryIDByName(country)
|
|
if err != nil {
|
|
http.Error(w, fmt.Sprintf("Country Name: %s not found!!!", country), http.StatusNotFound)
|
|
return
|
|
}
|
|
json.NewEncoder(w).Encode(rr.data.GetRecipe(countryID, filename))
|
|
})
|
|
|
|
r.Get("/versions", func(w http.ResponseWriter, r *http.Request) {
|
|
w.Header().Add("Content-Type", "application/json")
|
|
// get key from map
|
|
keys := []string{}
|
|
for k := range rr.data.AllRecipeFiles {
|
|
countryName, err := rr.data.GetCountryNameByID(k)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
keys = append(keys, countryName)
|
|
}
|
|
json.NewEncoder(w).Encode(keys)
|
|
})
|
|
|
|
r.Get("/versions/{country}", func(w http.ResponseWriter, r *http.Request) {
|
|
w.Header().Add("Content-Type", "application/json")
|
|
|
|
countryName := chi.URLParam(r, "country")
|
|
countryID, err := rr.data.GetCountryIDByName(countryName)
|
|
if err != nil {
|
|
http.Error(w, fmt.Sprintf("Country Name: %s not found!!!", countryName), http.StatusNotFound)
|
|
return
|
|
}
|
|
files := []string{}
|
|
for _, v := range rr.data.AllRecipeFiles[countryID] {
|
|
files = append(files, v.Name)
|
|
}
|
|
json.NewEncoder(w).Encode(files)
|
|
})
|
|
|
|
r.Get("/test/sheet", func(w http.ResponseWriter, r *http.Request) {
|
|
result := rr.sheetService.GetSheet(r.Context(), "1rSUKcc5POR1KeZFGoeAZIoVoI7LPGztBhPw5Z_ConDE")
|
|
|
|
mapResult := []map[string]string{}
|
|
|
|
for _, v := range result {
|
|
mapResult = append(mapResult, map[string]string{
|
|
"productCode": v[0].(string),
|
|
"name": v[1].(string),
|
|
"otherName": v[2].(string),
|
|
"description": v[3].(string),
|
|
"otherDescription": v[4].(string),
|
|
"picture": v[5].(string),
|
|
})
|
|
}
|
|
json.NewEncoder(w).Encode(mapResult)
|
|
})
|
|
|
|
r.Post("/edit/{country}/{filename}", func(w http.ResponseWriter, r *http.Request) {
|
|
Log.Debug("Edit: ", zap.String("path", r.RequestURI))
|
|
filename := chi.URLParam(r, "filename")
|
|
country := chi.URLParam(r, "country")
|
|
|
|
countryID, err := rr.data.GetCountryIDByName(country)
|
|
if err != nil {
|
|
http.Error(w, fmt.Sprintf("Country Name: %s not found!!!", country), http.StatusNotFound)
|
|
return
|
|
}
|
|
|
|
target_recipe := rr.data.GetRecipe(countryID, filename)
|
|
|
|
Log.Debug("Target => ", zap.Any("target", target_recipe.MachineSetting.ConfigNumber))
|
|
|
|
// check request structure
|
|
|
|
// FIXME: Request structure bug. Case-sensitive, likely bug at client
|
|
// uncomment the below code to view the bug
|
|
|
|
// var change_request map[string]interface{}
|
|
// err = json.NewDecoder(r.Body).Decode(&change_request)
|
|
// if err != nil {
|
|
// Log.Error("Decode in request failed: ", zap.Error(err))
|
|
// }
|
|
// Log.Debug("Request => ", zap.Any("request", change_request))
|
|
|
|
// Body
|
|
var changes models.Recipe01
|
|
err = json.NewDecoder(r.Body).Decode(&changes)
|
|
if err != nil {
|
|
Log.Error("Decode in request failed: ", zap.Error(err))
|
|
}
|
|
|
|
Log.Debug("Changes: ", zap.Any("changes", changes))
|
|
// TODO: find the matched pd
|
|
target_menu := rr.data.GetRecipe01ByProductCode(changes.ProductCode)
|
|
|
|
menu_map := target_menu.ToMap()
|
|
change_map := changes.ToMap()
|
|
|
|
// Find changes
|
|
for key, val := range menu_map {
|
|
|
|
test_bool, err := helpers.DynamicCompare(val, change_map[key])
|
|
|
|
if err != nil {
|
|
Log.Error("DynamicCompare in request failed: ", zap.Error(err))
|
|
}
|
|
|
|
if !test_bool {
|
|
menu_map[key] = change_map[key]
|
|
}
|
|
}
|
|
|
|
// Apply changes
|
|
tempRecipe := models.Recipe01{}
|
|
tempRecipe = tempRecipe.FromMap(menu_map)
|
|
rr.data.SetValuesToRecipe(tempRecipe)
|
|
Log.Debug("ApplyChange", zap.Any("status", "passed"))
|
|
|
|
// check if changed
|
|
// Log.Debug("Check if changed", zap.Any("result", rr.data.GetRecipe01ByProductCode(changes.ProductCode)))
|
|
|
|
file, _ := os.Create(path.Join("./cofffeemachineConfig", countryID[:3], filename))
|
|
if err != nil {
|
|
Log.Error("Error when tried to create file", zap.Error(err))
|
|
return
|
|
}
|
|
|
|
encoder := json.NewEncoder(file)
|
|
encoder.SetIndent("", " ")
|
|
err = encoder.Encode(rr.data.GetCurrentRecipe())
|
|
|
|
if err != nil {
|
|
Log.Error("Error when write file", zap.Error(err))
|
|
}
|
|
|
|
w.Header().Add("Content-Type", "application/json")
|
|
json.NewEncoder(w).Encode(map[string]interface{}{
|
|
"status": "OK",
|
|
})
|
|
})
|
|
})
|
|
}
|