917 lines
27 KiB
Go
917 lines
27 KiB
Go
package data
|
|
|
|
import (
|
|
"fmt"
|
|
"log"
|
|
"os"
|
|
"path"
|
|
"recipe-manager/helpers"
|
|
"recipe-manager/models"
|
|
"recipe-manager/services/logger"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"reflect"
|
|
|
|
"go.uber.org/zap"
|
|
)
|
|
|
|
type RecipeWithTimeStamps struct {
|
|
Recipe map[string]*models.Recipe
|
|
TimeStamps int64
|
|
}
|
|
|
|
type Data struct {
|
|
CurrentFile map[string]string
|
|
CurrentCountryID map[string]string
|
|
DefaultCountryMap []DefaultByCountry
|
|
AllRecipeFiles map[string][]helpers.RecipePath
|
|
CurrentRecipe map[string]*models.Recipe
|
|
recipeMap map[string]RecipeWithTimeStamps
|
|
Countries []helpers.CountryName
|
|
taoLogger *logger.TaoLogger
|
|
redisClient *RedisCli
|
|
}
|
|
|
|
type DefaultByCountry struct {
|
|
CountryShortName string
|
|
CountryLongName string
|
|
DefaultFileVersion int
|
|
}
|
|
|
|
var (
|
|
countries = []helpers.CountryName{{
|
|
CountryID: "tha",
|
|
CountryName: "Thailand",
|
|
}, {
|
|
CountryID: "mys",
|
|
CountryName: "Malaysia",
|
|
}, {
|
|
CountryID: "aus",
|
|
CountryName: "Australia",
|
|
},
|
|
}
|
|
)
|
|
|
|
func NewData(taoLogger *logger.TaoLogger, redisClient *RedisCli) *Data {
|
|
|
|
allRecipeFiles := helpers.ScanRecipeFiles(countries)
|
|
|
|
defaultFile := "coffeethai02_600.json"
|
|
|
|
// TODO: read 'version' file by country
|
|
|
|
// versionPath := path.Join("cofffeemachineConfig", defaultCountry, "version")
|
|
// taoLogger.Log.Debug("version", zap.Any("version path", versionPath))
|
|
|
|
// // versionFile, err := os.Open(versionPath)
|
|
// content, err := os.ReadFile(versionPath)
|
|
|
|
// if err != nil {
|
|
// taoLogger.Log.Debug("Error when open version file", zap.Error(err))
|
|
// }
|
|
|
|
// initVersion := string(content)
|
|
|
|
// // read latest version
|
|
// // set latest to default version
|
|
// latest_version, err := strconv.Atoi(initVersion)
|
|
|
|
// if err != nil {
|
|
// latest_version = 600
|
|
// }
|
|
|
|
defaultForEachCountry := []DefaultByCountry{}
|
|
|
|
for _, elem := range countries {
|
|
// generate default of all countries
|
|
currentVersionPath := path.Join("cofffeemachineConfig", elem.CountryID, "version")
|
|
// this is default version for each country
|
|
content, err := os.ReadFile(currentVersionPath)
|
|
if err != nil {
|
|
taoLogger.Log.Debug("Error when open version file", zap.Error(err))
|
|
}
|
|
|
|
initVersion := string(content)
|
|
|
|
// read latest version
|
|
latest_version, _ := strconv.Atoi(initVersion)
|
|
defaultForEachCountry = append(defaultForEachCountry, DefaultByCountry{CountryShortName: elem.CountryID, CountryLongName: elem.CountryName, DefaultFileVersion: latest_version})
|
|
|
|
// emit out latest version
|
|
taoLogger.Log.Info("Latest version", zap.Any("country", elem.CountryID), zap.Any("version", latest_version))
|
|
}
|
|
|
|
currentFileMap := make(map[string]string)
|
|
CurrentCountryIDMap := make(map[string]string)
|
|
currentDefaultFileForEachCountry := make(map[string]*models.Recipe)
|
|
|
|
// all default versions as string
|
|
versionsString := ""
|
|
|
|
// loop default for each country
|
|
|
|
for _, v := range defaultForEachCountry {
|
|
|
|
for _, v2 := range allRecipeFiles[v.CountryShortName] {
|
|
|
|
// extract filename as version
|
|
current_version_iter, err := strconv.Atoi(strings.Split(strings.Split(v2.Name, "_")[1], ".")[0])
|
|
|
|
if err != nil {
|
|
continue
|
|
}
|
|
|
|
if current_version_iter == v.DefaultFileVersion {
|
|
currentFileMap[v.CountryShortName] = v2.Name
|
|
CurrentCountryIDMap[v.CountryShortName] = v.CountryLongName
|
|
|
|
versionsString = versionsString + v.CountryShortName + ":" + strconv.Itoa(current_version_iter) + ","
|
|
|
|
// do read default
|
|
defaultRecipe, err := helpers.ReadRecipeFile(v.CountryShortName, v2.Name)
|
|
if err != nil {
|
|
log.Panic("Error when read default recipe file for each country:", v.CountryShortName, err)
|
|
}
|
|
|
|
redisClient.SetToKey(v2.Name, defaultRecipe)
|
|
|
|
currentDefaultFileForEachCountry[v.CountryShortName] = defaultRecipe
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
// for _, v := range allRecipeFiles[defaultCountry] {
|
|
|
|
// // extract filename as version
|
|
// current_version_iter, err := strconv.Atoi(strings.Split(strings.Split(v.Name, "_")[1], ".")[0])
|
|
|
|
// if err != nil {
|
|
// continue
|
|
// }
|
|
|
|
// if current_version_iter == latest_version {
|
|
// // taoLogger.Log.Debug("current_version_iter", zap.Any("current_version_iter", current_version_iter))
|
|
// // set latest
|
|
// latest_version = current_version_iter
|
|
// defaultFile = v.Name
|
|
// break
|
|
// }
|
|
// }
|
|
|
|
// FIXME: default file bug. do assign each default recipe model to each country
|
|
|
|
// taoLogger.Log.Debug("defaultFile", zap.Any("defaultFile", defaultFile), zap.Any("latest_version", versionsString))
|
|
|
|
// defaultRecipe, err := helpers.ReadRecipeFile(defaultCountry, defaultFile)
|
|
|
|
// if err != nil {
|
|
// log.Panic("Error when read default recipe file:", err)
|
|
// }
|
|
|
|
return &Data{
|
|
CurrentFile: currentFileMap,
|
|
CurrentCountryID: CurrentCountryIDMap,
|
|
AllRecipeFiles: allRecipeFiles,
|
|
CurrentRecipe: currentDefaultFileForEachCountry,
|
|
recipeMap: map[string]RecipeWithTimeStamps{
|
|
defaultFile: {
|
|
Recipe: currentDefaultFileForEachCountry,
|
|
TimeStamps: time.Now().Unix(),
|
|
},
|
|
},
|
|
Countries: countries,
|
|
taoLogger: taoLogger,
|
|
DefaultCountryMap: defaultForEachCountry,
|
|
redisClient: redisClient,
|
|
}
|
|
}
|
|
|
|
func (d *Data) GetRecipe(countryID, filename string) *models.Recipe {
|
|
|
|
d.taoLogger.Log.Debug("invoke GetRecipe", zap.String("countryID", countryID), zap.String("filename", filename))
|
|
|
|
// TODO: concat submenu into recipe
|
|
|
|
if countryID == "" {
|
|
d.taoLogger.Log.Debug("GetRecipe", zap.Any("EmptyCountryId", "return default country = tha"))
|
|
return d.CurrentRecipe["tha"]
|
|
}
|
|
|
|
if filename == "" {
|
|
d.taoLogger.Log.Debug("GetRecipe", zap.Any("EmptyFilename", filename))
|
|
return d.CurrentRecipe[countryID]
|
|
}
|
|
|
|
// do check if match the current pointer
|
|
if d.CurrentFile[countryID] == filename {
|
|
d.taoLogger.Log.Debug("GetRecipe",
|
|
zap.Any("FileMatchCurrent", "return from stored "+filename),
|
|
zap.Any("CurrentFile", d.CurrentFile),
|
|
zap.Any("countryID", countryID))
|
|
|
|
d.taoLogger.Log.Debug("CurrentRecipeOK?", zap.Any("CurrentRecipe", d.CurrentRecipe[countryID] != nil))
|
|
|
|
// make sure recipe vesion is equal
|
|
currentConfig := d.CurrentRecipe[countryID].MachineSetting.ConfigNumber
|
|
// get requested version
|
|
requestedConfig, _ := strconv.Atoi(strings.Split(strings.Split(filename, "_")[1], ".")[0])
|
|
if currentConfig != requestedConfig {
|
|
d.taoLogger.Log.Debug("GetRecipe", zap.Any("ActualFileNotMatch", "Skip this!"))
|
|
} else {
|
|
|
|
// detect patches, return original
|
|
var cached_original_recipe models.Recipe
|
|
err := d.redisClient.GetKeyTo(filename, &cached_original_recipe)
|
|
|
|
if err == nil && d.redisClient.HealthCheck() == nil {
|
|
d.taoLogger.Log.Debug("GetRecipe.NoReturnUpdated", zap.Any("target", filename))
|
|
return &cached_original_recipe
|
|
}
|
|
|
|
// if equal, OK
|
|
return d.CurrentRecipe[countryID]
|
|
}
|
|
|
|
}
|
|
|
|
if recipe, ok := d.recipeMap[filename]; ok && d.redisClient.HealthCheck() != nil {
|
|
d.taoLogger.Log.Debug("GetRecipe", zap.Any("ValidOnStored", "return from stored "+filename))
|
|
// d.CurrentFile[countryID] = filename
|
|
// d.CurrentCountryID[countryID] = countryID
|
|
|
|
// make sure recipe vesion is equal
|
|
currentConfig := d.CurrentRecipe[countryID].MachineSetting.ConfigNumber
|
|
// get requested version
|
|
requestedConfig, _ := strconv.Atoi(strings.Split(strings.Split(filename, "_")[1], ".")[0])
|
|
if currentConfig != requestedConfig {
|
|
d.taoLogger.Log.Debug("GetRecipe", zap.Any("InvalidOnStored", "Skip this!"))
|
|
} else {
|
|
|
|
// detect patches, return original
|
|
|
|
var cached_original_recipe models.Recipe
|
|
err := d.redisClient.GetKeyTo(filename, &cached_original_recipe)
|
|
|
|
if err == nil && d.redisClient.HealthCheck() == nil {
|
|
d.taoLogger.Log.Debug("GetRecipe.NoReturnUpdated", zap.Any("target", filename))
|
|
return &cached_original_recipe
|
|
}
|
|
|
|
d.taoLogger.Log.Debug("GetRecipe.ReturnDefault", zap.Any("error_cache_recipe", err))
|
|
|
|
// if equal, OK
|
|
return recipe.Recipe[countryID]
|
|
}
|
|
}
|
|
|
|
// change current version and read new recipe
|
|
|
|
if filename == "default" {
|
|
filename = d.CurrentFile[countryID]
|
|
}
|
|
|
|
// var recipe *models.Recipe = &models.Recipe{}
|
|
|
|
// do check if redis contains the recipe
|
|
var cached_recipe *models.Recipe = &models.Recipe{}
|
|
|
|
if err := d.redisClient.GetKeyTo(filename, cached_recipe); err != nil {
|
|
d.taoLogger.Log.Debug("GetRecipe.Cached", zap.Any("GetCacheRecipeError", err))
|
|
d.taoLogger.Log.Debug("GetRecipe", zap.String("filename", filename), zap.String("countryID", countryID))
|
|
// d.CurrentCountryID[countryID] = countryID
|
|
cached_recipe = nil
|
|
}
|
|
|
|
if cached_recipe != nil {
|
|
d.taoLogger.Log.Debug("GetRecipe", zap.Any("Check on cached recipe invalid", cached_recipe == nil), zap.Any("test config number", cached_recipe.MachineSetting.ConfigNumber))
|
|
// set to current
|
|
// d.CurrentRecipe[countryID] = cached_recipe
|
|
return cached_recipe
|
|
}
|
|
|
|
recipe, err := helpers.ReadRecipeFile(countryID, filename)
|
|
|
|
if err != nil {
|
|
d.taoLogger.Log.Debug("GetRecipe", zap.Any("ReadRecipeError -> return default", err))
|
|
return d.CurrentRecipe[countryID]
|
|
}
|
|
|
|
// cache to redis
|
|
d.redisClient.SetToKey(filename, recipe)
|
|
|
|
if err != nil {
|
|
d.taoLogger.Log.Error("GetRecipe: Error when read recipe file, Return default recipe", zap.Error(err))
|
|
return d.CurrentRecipe[countryID]
|
|
}
|
|
|
|
//. service is connected. Use from cache
|
|
|
|
// check healthcheck redis
|
|
var return_recipe *models.Recipe = &models.Recipe{}
|
|
err = d.redisClient.HealthCheck()
|
|
d.taoLogger.Log.Info("GetRecipe: HealthCheck", zap.Any("result", err))
|
|
if d.redisClient.HealthCheck() == nil && cached_recipe != nil {
|
|
d.taoLogger.Log.Debug("GetRecipeCached", zap.Any("cached_recipe", "yes"))
|
|
// d.CurrentRecipe[countryID] = cached_recipe
|
|
return_recipe = cached_recipe
|
|
} else {
|
|
d.taoLogger.Log.Debug("GetRecipeCached", zap.Any("cached_recipe", "no"))
|
|
// d.CurrentRecipe[countryID] = recipe
|
|
return_recipe = recipe
|
|
}
|
|
|
|
// save to map
|
|
if len(d.recipeMap) > 5 { // limit keep in memory 5 version
|
|
// remove oldest version
|
|
var oldestVersion string
|
|
var oldestTime int64
|
|
for k, v := range d.recipeMap {
|
|
if oldestTime == 0 || v.TimeStamps < oldestTime {
|
|
oldestTime = v.TimeStamps
|
|
oldestVersion = k
|
|
}
|
|
}
|
|
delete(d.recipeMap, oldestVersion)
|
|
}
|
|
|
|
d.recipeMap[filename] = RecipeWithTimeStamps{
|
|
Recipe: d.CurrentRecipe,
|
|
TimeStamps: time.Now().Unix(),
|
|
}
|
|
|
|
return return_recipe
|
|
}
|
|
|
|
// func (d *Data) GetRecipe01() []models.Recipe01 {
|
|
// return d.currentRecipe.Recipe01
|
|
// }
|
|
|
|
// func (d *Data) GetCurrentRecipe() *models.Recipe {
|
|
// return d.currentRecipe
|
|
// }
|
|
|
|
func (d *Data) GetRecipe01ByProductCode(filename, countryID, productCode string) (models.Recipe01, error) {
|
|
|
|
// try convert
|
|
if len(countryID) != 3 {
|
|
for k, v := range d.CurrentCountryID {
|
|
fmt.Println("GetRecipe01ByProductCode.Iterate", k, v, v == countryID)
|
|
if v == countryID {
|
|
countryID = k
|
|
break
|
|
}
|
|
}
|
|
}
|
|
fmt.Println("GetRecipe01ByProductCode", filename, countryID, productCode)
|
|
|
|
if !strings.Contains(filename, "tmp") {
|
|
if filename == "" || filename == d.CurrentFile[countryID] {
|
|
// , d.CurrentFile, countryID, "result by country id", len(d.currentRecipe[countryID].Recipe01)
|
|
// fmt.Println("GetRecipe01ByProductCode.ReadCurrent::filename", filename)
|
|
// fmt.Println("GetRecipe01ByProductCode.ReadCurrent::countryID", countryID)
|
|
// fmt.Println("GetRecipe01ByProductCode.ReadCurrent::CurrentFile", d.CurrentFile)
|
|
// fmt.Println("GetRecipe01ByProductCode.ReadCurrent::CurrentCountryID", d.CurrentCountryID)
|
|
|
|
for _, v := range d.CurrentRecipe[countryID].Recipe01 {
|
|
if v.ProductCode == productCode {
|
|
return v, nil
|
|
} else if len(v.SubMenu) > 0 {
|
|
for _, subMenu := range v.SubMenu {
|
|
if subMenu.ProductCode == productCode {
|
|
return subMenu, nil
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// fmt.Println("No result in current recipe", countryID)
|
|
} else if recipe, ok := d.recipeMap[filename]; ok {
|
|
// fmt.Println("GetRecipe01ByProductCode.ReadMap", filename, d.CurrentFile, recipe.Recipe[countryID], "countryID=", countryID)
|
|
for _, v := range recipe.Recipe[countryID].Recipe01 {
|
|
if v.ProductCode == productCode {
|
|
d.taoLogger.Log.Debug("GetRecipe01ByProductCode.getSuccess", zap.Any("fromFile", filename), zap.Any("whereSource", d.recipeMap))
|
|
return v, nil
|
|
} else if len(v.SubMenu) > 0 {
|
|
for _, subMenu := range v.SubMenu {
|
|
if subMenu.ProductCode == productCode {
|
|
d.taoLogger.Log.Debug("GetRecipe01ByProductCode.getSuccess", zap.Any("fromFile", filename), zap.Any("whereSource", d.recipeMap))
|
|
return subMenu, nil
|
|
}
|
|
}
|
|
}
|
|
}
|
|
d.taoLogger.Log.Debug("GetRecipe01ByProductCode.getFail", zap.Any("fromFile", filename), zap.Any("whereSource", d.recipeMap))
|
|
}
|
|
}
|
|
|
|
d.taoLogger.Log.Debug("GetRecipe01ByProductCode", zap.Any("filename", filename), zap.Any("countryID", countryID), zap.Any("productCode", productCode))
|
|
|
|
if filename == "default" {
|
|
filename = d.CurrentFile[countryID]
|
|
}
|
|
|
|
// d.CurrentFile[countryID] = filename
|
|
// d.CurrentCountryID[countryID] = countryID
|
|
|
|
for _, v := range countries {
|
|
if v.CountryName == countryID {
|
|
// d.CurrentCountryID[countryID] = v.CountryID
|
|
countryID = v.CountryID
|
|
break
|
|
}
|
|
}
|
|
|
|
recipe := d.GetRecipe(countryID, filename)
|
|
|
|
// if err != nil {
|
|
// d.taoLogger.Log.Error("GetRecipe01ByProductCode: Error when read recipe file, Return default recipe", zap.Error(err))
|
|
// for _, v := range d.CurrentRecipe[countryID].Recipe01 {
|
|
// if v.ProductCode == productCode {
|
|
// return v, fmt.Errorf("[DEFAULT]-ERR")
|
|
// } else if len(v.SubMenu) > 0 {
|
|
// for _, subMenu := range v.SubMenu {
|
|
// if subMenu.ProductCode == productCode {
|
|
// return subMenu, fmt.Errorf("[DEFAULT]-ERR")
|
|
// }
|
|
// }
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
d.taoLogger.Log.Debug("GetRecipe01ByProductCode", zap.Any("productCode", productCode), zap.Any("version", recipe.MachineSetting.ConfigNumber))
|
|
|
|
d.CurrentRecipe[countryID] = recipe
|
|
|
|
// save to map
|
|
if len(d.recipeMap) > 5 { // limit keep in memory 5 version
|
|
// remove oldest version
|
|
var oldestVersion string
|
|
var oldestTime int64
|
|
for k, v := range d.recipeMap {
|
|
if oldestTime == 0 || v.TimeStamps < oldestTime {
|
|
oldestTime = v.TimeStamps
|
|
oldestVersion = k
|
|
}
|
|
}
|
|
delete(d.recipeMap, oldestVersion)
|
|
}
|
|
|
|
d.recipeMap[filename] = RecipeWithTimeStamps{
|
|
Recipe: d.CurrentRecipe,
|
|
TimeStamps: time.Now().Unix(),
|
|
}
|
|
|
|
for _, v := range d.CurrentRecipe[countryID].Recipe01 {
|
|
if v.ProductCode == productCode {
|
|
// d.taoLogger.Log.Debug("GetRecipe01ByProductCode", zap.Any("productCode", productCode), zap.Any("result", v))
|
|
return v, nil
|
|
} else if len(v.SubMenu) > 0 {
|
|
for _, subMenu := range v.SubMenu {
|
|
if subMenu.ProductCode == productCode {
|
|
// d.taoLogger.Log.Debug("GetRecipe01ByProductCode", zap.Any("productCode", productCode), zap.Any("result", subMenu))
|
|
return subMenu, nil
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return models.Recipe01{}, fmt.Errorf("product code: %s not found", productCode)
|
|
}
|
|
|
|
func (d *Data) SetValuesToRecipe(base_recipe []models.Recipe01, recipe models.Recipe01) {
|
|
not_found := false
|
|
global_idx := 0
|
|
for index, v := range base_recipe {
|
|
if v.ProductCode == recipe.ProductCode {
|
|
// Log.Debug("SetValuesToRecipe", zap.Any("old", v), zap.Any("new", recipe))
|
|
// v = recipe
|
|
// TODO: change only changed values
|
|
|
|
// transform to map
|
|
base_recipe01_Map := v.ToMap()
|
|
|
|
recipe01_Map := recipe.ToMap()
|
|
|
|
for k, v := range recipe01_Map {
|
|
if !reflect.DeepEqual(base_recipe01_Map[k], v) {
|
|
d.taoLogger.Log.Debug("SetValuesToRecipe", zap.Any("key", k), zap.Any("old", base_recipe01_Map[k]), zap.Any("new", v))
|
|
base_recipe01_Map[k] = v
|
|
}
|
|
}
|
|
|
|
base_recipe[index] = base_recipe[index].FromMap(base_recipe01_Map)
|
|
|
|
not_found = false
|
|
break
|
|
} else if len(v.SubMenu) > 0 {
|
|
for _, sub := range v.SubMenu {
|
|
if sub.ProductCode == recipe.ProductCode {
|
|
// Log.Debug("SetValuesToRecipe.SubMenu", zap.Any("old", sub), zap.Any("new", recipe))
|
|
// sub = recipe
|
|
// TODO: change only changed values
|
|
|
|
// transform to map
|
|
base_recipe01_Map := sub.ToMap()
|
|
|
|
recipe01_Map := recipe.ToMap()
|
|
|
|
for k, v := range recipe01_Map {
|
|
if !reflect.DeepEqual(base_recipe01_Map[k], v) {
|
|
d.taoLogger.Log.Debug("SetValuesToRecipe.SubMenu", zap.Any("key", k), zap.Any("old", base_recipe01_Map[k]), zap.Any("new", v))
|
|
base_recipe01_Map[k] = v
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
not_found = true
|
|
global_idx = index
|
|
}
|
|
}
|
|
|
|
if not_found {
|
|
base_recipe[global_idx+1] = recipe
|
|
}
|
|
}
|
|
|
|
func (d *Data) SetValuesToMaterialSetting(base_mat_setting []models.MaterialSetting, updated_mat_setting models.MaterialSetting) {
|
|
not_found := false
|
|
global_idx := 0
|
|
|
|
for index, v := range base_mat_setting {
|
|
// find matched id
|
|
if v.ID == updated_mat_setting.ID {
|
|
// change only changed values
|
|
for k, v := range updated_mat_setting.ToMap() {
|
|
if !reflect.DeepEqual(base_mat_setting[index].ToMap()[k], v) {
|
|
d.taoLogger.Log.Debug("SetValuesToMaterialSetting", zap.Any("key", k), zap.Any("old", base_mat_setting[index].ToMap()[k]), zap.Any("new", v))
|
|
base_mat_setting[index].ToMap()[k] = v
|
|
}
|
|
}
|
|
} else {
|
|
not_found = true
|
|
global_idx = index
|
|
}
|
|
}
|
|
|
|
// is new value
|
|
if not_found {
|
|
base_mat_setting[global_idx+1] = updated_mat_setting
|
|
}
|
|
}
|
|
|
|
func (d *Data) SetValuesToToppingList(base_topping_list []models.ToppingList, updated_topping_list models.ToppingList) {
|
|
not_found := false
|
|
global_idx := 0
|
|
|
|
for index, v := range base_topping_list {
|
|
// find matched id
|
|
if v.ID == updated_topping_list.ID {
|
|
// change only changed values
|
|
for k, v := range updated_topping_list.ToMap() {
|
|
if !reflect.DeepEqual(base_topping_list[index].ToMap()[k], v) {
|
|
d.taoLogger.Log.Debug("SetValuesToToppingList", zap.Any("key", k), zap.Any("old", base_topping_list[index].ToMap()[k]), zap.Any("new", v))
|
|
base_topping_list[index].ToMap()[k] = v
|
|
}
|
|
}
|
|
} else {
|
|
not_found = true
|
|
global_idx = index
|
|
}
|
|
}
|
|
|
|
// is new value
|
|
if not_found {
|
|
base_topping_list[global_idx+1] = updated_topping_list
|
|
}
|
|
}
|
|
|
|
func (d *Data) SetValuesToToppingGroupList(base_topping_group_list []models.ToppingGroup, updated_topping_group_list models.ToppingGroup) {
|
|
not_found := false
|
|
global_idx := 0
|
|
|
|
for index, v := range base_topping_group_list {
|
|
|
|
// find matched id
|
|
if v.GroupID == updated_topping_group_list.GroupID {
|
|
// change only changed values
|
|
for k, v := range updated_topping_group_list.ToMap() {
|
|
if !reflect.DeepEqual(base_topping_group_list[index].ToMap()[k], v) {
|
|
d.taoLogger.Log.Debug("SetValuesToToppingGroup", zap.Any("key", k), zap.Any("old", base_topping_group_list[index].ToMap()[k]), zap.Any("new", v))
|
|
base_topping_group_list[index].ToMap()[k] = v
|
|
}
|
|
}
|
|
} else {
|
|
not_found = true
|
|
global_idx = index
|
|
}
|
|
}
|
|
|
|
// is new value
|
|
if not_found {
|
|
base_topping_group_list[global_idx+1] = updated_topping_group_list
|
|
}
|
|
}
|
|
|
|
func (d *Data) GetMaterialSetting(countryID, filename string) []models.MaterialSetting {
|
|
result := make([]models.MaterialSetting, 0)
|
|
|
|
if countryID == "" {
|
|
// copy(result, d.currentRecipe[countryID].MaterialSetting)
|
|
return d.CurrentRecipe[countryID].MaterialSetting
|
|
}
|
|
|
|
if !strings.Contains(filename, "tmp") {
|
|
if filename == "" || filename == d.CurrentFile[countryID] {
|
|
// copy(result, d.currentRecipe[countryID].MaterialSetting)
|
|
// d.taoLogger.Log.Debug("GetMaterialSetting", zap.Any("result", result))
|
|
return d.CurrentRecipe[countryID].MaterialSetting
|
|
}
|
|
|
|
if recipe, ok := d.recipeMap[filename]; ok {
|
|
copy(result, recipe.Recipe[countryID].MaterialSetting)
|
|
d.CurrentFile[countryID] = filename
|
|
// d.CurrentCountryID[countryID] = countryID
|
|
return d.CurrentRecipe[countryID].MaterialSetting
|
|
}
|
|
}
|
|
|
|
if filename == "default" {
|
|
filename = d.CurrentFile[countryID]
|
|
}
|
|
|
|
// d.taoLogger.Log.Debug("GetMaterialSetting", zap.Any("filename", filename), zap.Any("countryID", countryID))
|
|
|
|
// d.CurrentFile[countryID] = filename
|
|
// d.CurrentCountryID[countryID] = countryID
|
|
recipe := d.GetRecipe(countryID, filename)
|
|
|
|
// if err != nil {
|
|
// d.taoLogger.Log.Error("GetMaterialSetting: Error when read recipe file, Return default recipe", zap.Error(err))
|
|
// copy(result, d.CurrentRecipe[countryID].MaterialSetting)
|
|
// return d.CurrentRecipe[countryID].MaterialSetting
|
|
// }
|
|
|
|
// d.taoLogger.Log.Debug("GetMaterialSetting", zap.Any("recipe", recipe.MaterialSetting))
|
|
|
|
d.CurrentRecipe[countryID] = recipe
|
|
|
|
// save to map
|
|
if len(d.recipeMap) > 5 { // limit keep in memory 5 version
|
|
// remove oldest version
|
|
var oldestVersion string
|
|
var oldestTime int64
|
|
for k, v := range d.recipeMap {
|
|
if oldestTime == 0 || v.TimeStamps < oldestTime {
|
|
oldestTime = v.TimeStamps
|
|
oldestVersion = k
|
|
}
|
|
}
|
|
delete(d.recipeMap, oldestVersion)
|
|
}
|
|
|
|
d.recipeMap[filename] = RecipeWithTimeStamps{
|
|
Recipe: d.CurrentRecipe,
|
|
TimeStamps: time.Now().Unix(),
|
|
}
|
|
|
|
// copy(result, recipe.MaterialSetting)
|
|
return recipe.MaterialSetting
|
|
}
|
|
|
|
func (d *Data) GetAllToppingGroups(countryID, filename string) []models.ToppingGroup {
|
|
if countryID == "" {
|
|
return d.CurrentRecipe[countryID].Topping.ToppingGroup
|
|
}
|
|
|
|
if !strings.Contains(filename, ".tmp") {
|
|
if filename == "" || filename == d.CurrentFile[countryID] {
|
|
return d.CurrentRecipe[countryID].Topping.ToppingGroup
|
|
}
|
|
if _, ok := d.recipeMap[countryID]; ok {
|
|
d.CurrentFile[countryID] = filename
|
|
|
|
return d.CurrentRecipe[countryID].Topping.ToppingGroup
|
|
}
|
|
}
|
|
|
|
if filename == "default" {
|
|
filename = d.CurrentFile[countryID]
|
|
}
|
|
recipe := d.GetRecipe(countryID, filename)
|
|
|
|
d.CurrentRecipe[countryID] = recipe
|
|
|
|
if len(d.recipeMap) > 5 { // limit keep in memory 5 version
|
|
// remove oldest version
|
|
var oldestVersion string
|
|
var oldestTime int64
|
|
for k, v := range d.recipeMap {
|
|
if oldestTime == 0 || v.TimeStamps < oldestTime {
|
|
oldestTime = v.TimeStamps
|
|
oldestVersion = k
|
|
}
|
|
}
|
|
delete(d.recipeMap, oldestVersion)
|
|
}
|
|
|
|
d.recipeMap[filename] = RecipeWithTimeStamps{
|
|
Recipe: d.CurrentRecipe,
|
|
TimeStamps: time.Now().Unix(),
|
|
}
|
|
|
|
return recipe.Topping.ToppingGroup
|
|
}
|
|
|
|
func (d *Data) GetToppingsList(countryID, filename string) []models.ToppingList {
|
|
// do return default
|
|
if countryID == "" {
|
|
return d.CurrentRecipe[countryID].Topping.ToppingList
|
|
}
|
|
|
|
// handle temporary file
|
|
if !strings.Contains(filename, ".tmp") {
|
|
if filename == "" || filename == d.CurrentFile[countryID] {
|
|
return d.CurrentRecipe[countryID].Topping.ToppingList
|
|
}
|
|
if _, ok := d.recipeMap[countryID]; ok {
|
|
d.CurrentFile[countryID] = filename
|
|
return d.CurrentRecipe[countryID].Topping.ToppingList
|
|
}
|
|
}
|
|
|
|
if filename == "default" {
|
|
filename = d.CurrentFile[countryID]
|
|
}
|
|
|
|
recipe := d.GetRecipe(countryID, filename)
|
|
|
|
if len(d.recipeMap) > 5 { // limit keep in memory 5 version
|
|
// remove oldest version
|
|
var oldestVersion string
|
|
var oldestTime int64
|
|
for k, v := range d.recipeMap {
|
|
if oldestTime == 0 || v.TimeStamps < oldestTime {
|
|
oldestTime = v.TimeStamps
|
|
oldestVersion = k
|
|
}
|
|
}
|
|
delete(d.recipeMap, oldestVersion)
|
|
}
|
|
|
|
d.recipeMap[filename] = RecipeWithTimeStamps{
|
|
Recipe: d.CurrentRecipe,
|
|
TimeStamps: time.Now().Unix(),
|
|
}
|
|
|
|
return recipe.Topping.ToppingList
|
|
}
|
|
|
|
func (d *Data) GetMaterialCode(ids []uint64, countryID, filename string) []models.MaterialCode {
|
|
var result []models.MaterialCode
|
|
|
|
if filename == "" || filename == d.CurrentFile[countryID] {
|
|
result = d.CurrentRecipe[countryID].MaterialCode
|
|
} else if recipe, ok := d.recipeMap[filename]; ok {
|
|
d.CurrentFile[countryID] = filename
|
|
return recipe.Recipe[countryID].MaterialCode
|
|
} else {
|
|
|
|
if filename == "default" {
|
|
filename = d.CurrentFile[countryID]
|
|
}
|
|
|
|
// d.CurrentFile[countryID] = filename
|
|
// d.CurrentCountryID[countryID] = countryID
|
|
recipe := d.GetRecipe(countryID, filename)
|
|
|
|
// if err != nil {
|
|
// d.taoLogger.Log.Error("GetMaterialCode: Error when read recipe file, Return default recipe", zap.Error(err))
|
|
// return d.CurrentRecipe[countryID].MaterialCode
|
|
// }
|
|
|
|
d.CurrentRecipe[countryID] = recipe
|
|
|
|
// save to map
|
|
if len(d.recipeMap) > 5 { // limit keep in memory 5 version
|
|
// remove oldest version
|
|
var oldestVersion string
|
|
var oldestTime int64
|
|
for k, v := range d.recipeMap {
|
|
if oldestTime == 0 || v.TimeStamps < oldestTime {
|
|
oldestTime = v.TimeStamps
|
|
oldestVersion = k
|
|
}
|
|
}
|
|
delete(d.recipeMap, oldestVersion)
|
|
}
|
|
|
|
d.recipeMap[filename] = RecipeWithTimeStamps{
|
|
Recipe: d.CurrentRecipe,
|
|
TimeStamps: time.Now().Unix(),
|
|
}
|
|
|
|
result = d.CurrentRecipe[countryID].MaterialCode
|
|
}
|
|
|
|
if len(ids) == 0 {
|
|
return result
|
|
}
|
|
|
|
resultFilter := make([]models.MaterialCode, len(ids))
|
|
for _, id := range ids {
|
|
if id == 0 {
|
|
continue
|
|
}
|
|
|
|
for _, m := range result {
|
|
if m.MaterialID == id {
|
|
resultFilter = append(resultFilter, m)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
return resultFilter
|
|
}
|
|
|
|
func (d *Data) GetToppings(countryID, filename string) models.Topping {
|
|
|
|
if filename == "" || filename == d.CurrentFile[countryID] {
|
|
return d.CurrentRecipe[countryID].Topping
|
|
} else if recipe, ok := d.recipeMap[filename]; ok {
|
|
d.CurrentFile[countryID] = filename
|
|
return recipe.Recipe[countryID].Topping
|
|
}
|
|
|
|
if filename == "default" {
|
|
filename = d.CurrentFile[countryID]
|
|
}
|
|
|
|
// d.CurrentFile[countryID] = filename
|
|
// d.CurrentCountryID[countryID] = countryID
|
|
recipe := d.GetRecipe(countryID, filename)
|
|
|
|
d.CurrentRecipe[countryID] = recipe
|
|
|
|
return recipe.Topping
|
|
}
|
|
|
|
func (d *Data) GetToppingsOfRecipe(countryID, filename string, productCode string) ([]models.ToppingSet, error) {
|
|
|
|
if filename == "default" {
|
|
filename = d.CurrentFile[countryID]
|
|
}
|
|
|
|
recipe, err := d.GetRecipe01ByProductCode(filename, countryID, productCode)
|
|
|
|
if err != nil {
|
|
d.taoLogger.Log.Error("GetToppingOfRecipe: Error when read recipe file, Return default recipe", zap.Error(err))
|
|
return []models.ToppingSet{}, err
|
|
}
|
|
|
|
return recipe.ToppingSet, nil
|
|
}
|
|
|
|
func (d *Data) GetSubmenusOfRecipe(countryID, filename, productCode string) ([]models.Recipe01, error) {
|
|
|
|
if filename == "default" {
|
|
filename = d.CurrentFile[countryID]
|
|
}
|
|
|
|
recipe, err := d.GetRecipe01ByProductCode(filename, countryID, productCode)
|
|
|
|
if err != nil {
|
|
d.taoLogger.Log.Error("GetSubmenusOfRecipe: Error when read recipe file, Return default recipe", zap.Error(err))
|
|
return []models.Recipe01{}, err
|
|
}
|
|
|
|
submenu := recipe.SubMenu
|
|
|
|
if submenu == nil {
|
|
return []models.Recipe01{}, fmt.Errorf("no submenu")
|
|
}
|
|
|
|
return submenu, nil
|
|
|
|
}
|
|
|
|
func (d *Data) GetCountryNameByID(countryID string) (string, error) {
|
|
for _, country := range d.Countries {
|
|
if country.CountryID == countryID {
|
|
return country.CountryName, nil
|
|
}
|
|
}
|
|
return "", fmt.Errorf("country ID: %s not found", countryID)
|
|
}
|
|
|
|
func (d *Data) GetCountryIDByName(countryName string) (string, error) {
|
|
for _, country := range d.Countries {
|
|
if country.CountryName == countryName {
|
|
return country.CountryID, nil
|
|
}
|
|
}
|
|
return "", fmt.Errorf("country name: %s not found", countryName)
|
|
}
|