Taobin-Recipe-Manager/server/routers/material.go

package routers

import (
	"encoding/json"
	"net/http"
	"recipe-manager/data"
	"recipe-manager/models"
	"recipe-manager/services/logger"
	"strconv"
	"strings"

	"github.com/go-chi/chi/v5"
	"go.uber.org/zap"
)

type MaterialRouter struct {
	data      *data.Data
	taoLogger *logger.TaoLogger
}

func NewMaterialRouter(data *data.Data, taoLogger *logger.TaoLogger) *MaterialRouter {
	return &MaterialRouter{
		data:      data,
		taoLogger: taoLogger,
	}
}

func (mr *MaterialRouter) Route(r chi.Router) {
	r.Route("/materials", func(r chi.Router) {
		r.Get("/code", mr.getMaterialCode)

		r.Get("/setting/{mat_id}", mr.getMaterialSettingByMatID)

		r.Get("/full/{country}/{filename}", mr.GetFullMaterialDetail)
	})
}

func (mr *MaterialRouter) GetFullMaterialDetail(w http.ResponseWriter, r *http.Request) {

	w.Header().Add("Content-Type", "application/json")

	country := chi.URLParam(r, "country")
	filename := chi.URLParam(r, "filename")

	mr.taoLogger.Log.Debug("GetFullMaterialDetail", zap.Any("country", country), zap.Any("filename", filename))

	// get material setting and code
	matSettings := mr.data.GetMaterialSetting(country, filename)
	matCodes := mr.data.GetRecipe(country, filename).MaterialCode

	if len(matSettings) == 0 {
		// mr.taoLogger.Log.Error("MaterialRouter.GetFullMaterialDetail", zap.Error(err))
		http.Error(w, "Material not found", http.StatusNotFound)
		return
	}

	// combine
	materialDetails := []map[string]interface{}{}

	for _, matSetting := range matSettings {

		// if material name exist
		mat_name := ""
		if matSetting.MaterialName != "" {
			mat_name = matSetting.MaterialName
			// mr.taoLogger.Log.Debug("GetFullMaterialDetail", zap.Any("mat_name", mat_name))
		} else {

			for _, matCode := range matCodes {
				if matCode.MaterialID == matSetting.ID {
					mat_name = matCode.PackageDescription
					break
				}
			}
		}

		materialDetails = append(materialDetails, map[string]interface{}{
			"materialId": matSetting.ID,
			"name":       mat_name,
			"nameEN":     matSetting.MaterialOtherName,
			"type":       "powder:" + strconv.FormatBool(matSetting.PowderChannel) + ",syrup:" + strconv.FormatBool(matSetting.SyrupChannel) + ",bean:" + strconv.FormatBool(matSetting.BeanChannel) + ",equipment:" + strconv.FormatBool(matSetting.IsEquipment) + ",soda:" + strconv.FormatBool(matSetting.SodaChannel) + ",icecream:" + strconv.FormatBool(matSetting.IceScreamBingsuChannel),
		})
	}

	mr.taoLogger.Log.Debug("GetFullMaterialDetail", zap.Any("materialDetails", materialDetails[0]))

	// send result
	if err := json.NewEncoder(w).Encode(materialDetails); err != nil {
		mr.taoLogger.Log.Error("MaterialRouter.GetFullMaterialDetail", zap.Error(err))
		http.Error(w, "Internal Error", http.StatusInternalServerError)
		return
	}

}

func (mr *MaterialRouter) getMaterialCode(w http.ResponseWriter, r *http.Request) {
	w.Header().Add("Content-Type", "application/json")

	filename := r.URL.Query().Get("filename")
	country := r.URL.Query().Get("country")

	matIDs := r.URL.Query().Get("mat_ids")

	var matIDsUint []uint64
	for _, v := range strings.Split(matIDs, ",") {
		matIDUint, err := strconv.ParseUint(v, 10, 64)

		if err != nil || matIDUint == 0 {
			continue
		}

		matIDsUint = append(matIDsUint, matIDUint)
	}

	countryID, err := mr.data.GetCountryIDByName(country)

	if err != nil {
		mr.taoLogger.Log.Error("MaterialRouter.GetMaterialCode", zap.Error(err))
		http.Error(w, "Country not found", http.StatusNotFound)
		return
	}

	material := mr.data.GetMaterialCode(matIDsUint, countryID, filename)

	if err := json.NewEncoder(w).Encode(material); err != nil {
		mr.taoLogger.Log.Error("MaterialRouter.GetMaterialCode", zap.Error(err))
		http.Error(w, "Internal Error", http.StatusInternalServerError)
		return
	}
}

func (mr *MaterialRouter) getMaterialSettingByMatID(w http.ResponseWriter, r *http.Request) {
	w.Header().Add("Content-Type", "application/json")

	filename := r.URL.Query().Get("filename")
	country := r.URL.Query().Get("country")

	countryID, err := mr.data.GetCountryIDByName(country)

	if err != nil {
		// mr.taoLogger.Log.Error("MaterialRouter.GetMaterialSettingByMatID", zap.Error(err))
		http.Error(w, "Country not found", http.StatusNotFound)
		return
	}

	material := mr.data.GetMaterialSetting(countryID, filename)

	matID := chi.URLParam(r, "mat_id")

	matIDuint, err := strconv.ParseUint(matID, 10, 64)
	if err != nil {
		// mr.taoLogger.Log.Error("MaterialRouter.GetMaterialSettingByMatID", zap.Error(err))
		http.Error(w, "Invalid material id", http.StatusBadRequest)
		return
	}

	var matSetting models.MaterialSetting

	for _, mat := range material {
		if mat.ID == matIDuint {
			matSetting = mat
			break
		}
	}

	if err := json.NewEncoder(w).Encode(matSetting); err != nil {
		// mr.taoLogger.Log.Error("MaterialRouter.GetMaterialSettingByMatID", zap.Error(err))
		http.Error(w, "Internal Error", http.StatusInternalServerError)
		return
	}
}