mh_server/controller/address.go

package controller

import (
	"mh-server/common"
	"mh-server/lib/auth"
	"mh-server/lib/status"
	"mh-server/model"
	"regexp"

	"github.com/codinl/go-logger"
	"github.com/gin-gonic/gin"
)

func UserAddressAdd(c *gin.Context) {
	req := struct {
		ReceiverName string `json:"receiver_name" binding:"required"`
		Tel          string `json:"tel" binding:"required"`
		Province     string `json:"province" binding:"required"`
		City         string `json:"city" binding:"required"`
		District     string `json:"district" `
		Address      string `json:"address" `
		IsDefault    uint8  `json:"is_default"`
	}{}
	//body, err := ioutil.ReadAll(c.Request.Body)
	//fmt.Println("err:", err)
	//fmt.Println("body:", string(body))

	if c.ShouldBindJSON(&req) != nil {
		logger.Error("ShouldBindJSON err:")
		RespJson(c, status.BadRequest, nil)
		return
	}

	uc := auth.GetCurrentUser(c)
	if uc == nil {
		logger.Error("uc is nil")
		RespJson(c, status.Unauthorized, nil)
		return
	}

	//if match, err := regexp.MatchString(`^1[345789]\d{9}$`, req.Tel); err != nil || !match {
	//	RespJson(c, status.BadRequest, nil)
	//	return
	//}

	// 最多添加地址数量
	if count, err := model.NewUserAddressQuerySet(model.DB).UidEq(uc.Uid).Count(); err != nil {
		logger.Error(err)
		RespJson(c, status.InternalServerError, nil)
		return
	} else if count > 10 {
		Toast(c, "最多创建10个地址")
		return
	}

	// 是否默认收货地址
	if count, err := model.NewUserAddressQuerySet(model.DB).UidEq(uc.Uid).IsDefaultEq(common.Yes).Count(); err == model.RecordNotFound || count == 0 {
		req.IsDefault = common.Yes
	} else if err == nil && count > 0 {
		if req.IsDefault == common.Yes {
			if err := model.UserAddressSetAllUnDefault(uc.Uid); err != nil {
				logger.Error(err)
				RespJson(c, status.InternalServerError, nil)
				return
			}
		}
	}

	address := model.UserAddress{
		Uid:          uc.Uid,
		ReceiverName: req.ReceiverName,
		Tel:          req.Tel,
		Province:     req.Province,
		City:         req.City,
		District:     req.District,
		Address:      req.Address,
		State:        common.Show,
		IsDefault:    req.IsDefault,
	}
	if err := address.Create(model.DB); err != nil {
		logger.Error(err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	userAddressList, err := model.UserAddressList(uc.Uid)
	if err != nil {
		logger.Error(err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	RespOK(c, map[string]interface{}{
		"new_address_id":    address.ID,
		"user_address_list": userAddressList,
	})
	return
}

func UserAddressUpdate(c *gin.Context) {
	req := struct {
		Id           uint32 `json:"id"`
		ReceiverName string `json:"receiver_name" binding:"required"`
		Tel          string `json:"tel" binding:"required"`
		Province     string `json:"province" binding:"required"`
		City         string `json:"city" binding:"required"`
		District     string `json:"district" binding:"required"`
		IsDefault    uint8  `json:"is_default"`
		Address      string `json:"address" binding:"required"`
	}{}
	if c.ShouldBindJSON(&req) != nil {
		RespJson(c, status.BadRequest, nil)
		return
	}

	uc := auth.GetCurrentUser(c)
	if uc == nil {
		RespJson(c, status.Unauthorized, nil)
		return
	}

	if match, err := regexp.MatchString(`^1[345789]\d{9}$`, req.Tel); err != nil || !match {
		Toast(c, "手机号格式错误")
		return
	}

	address := new(model.UserAddress)
	if err := model.NewUserAddressQuerySet(model.DB).UidEq(uc.Uid).IDEq(req.Id).One(address); err == nil {
		address.ReceiverName = req.ReceiverName
		address.Tel = req.Tel
		address.Province = req.Province
		address.City = req.City
		address.District = req.District
		address.Address = req.Address
		if req.IsDefault != 0 {
			address.IsDefault = req.IsDefault
		}

		as := model.UserAddressDBSchema

		if req.IsDefault == common.Yes {
			if err := model.UserAddressSetAllUnDefault(uc.Uid); err != nil {
				logger.Error(err)
				RespJson(c, status.InternalServerError, nil)
				return
			}
		}

		if err := address.Update(model.DB, as.ReceiverName, as.Tel, as.Province, as.City, as.District, as.Address, as.IsDefault); err != nil {
			logger.Error(err)
			RespJson(c, status.InternalServerError, nil)
			return
		} else {
			userAddressList, err := model.UserAddressList(uc.Uid)
			if err != nil {
				logger.Error(err)
				RespJson(c, status.InternalServerError, nil)
				return
			}

			RespJson(c, status.OK, userAddressList)
			return
		}
	} else if err == model.RecordNotFound {
		RespJson(c, status.BadRequest, nil)
		return
	} else {
		logger.Error(err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
}

func UserAddressList(c *gin.Context) {
	uc := auth.GetCurrentUser(c)
	if uc == nil {
		RespJson(c, status.Unauthorized, nil)
		return
	}

	userAddressList, err := model.UserAddressList(uc.Uid)
	if err != nil {
		logger.Error(err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	RespJson(c, status.OK, userAddressList)
	return
}

func UserAddressDelete(c *gin.Context) {
	req := struct {
		Id uint32 `json:"id" binding:"required"`
	}{}
	if c.ShouldBindJSON(&req) != nil {
		RespJson(c, status.BadRequest, nil)
		return
	}

	uc := auth.GetCurrentUser(c)
	if uc == nil {
		RespJson(c, status.Unauthorized, nil)
		return
	}

	address := new(model.UserAddress)
	if err := model.NewUserAddressQuerySet(model.DB).UidEq(uc.Uid).IDEq(req.Id).One(address); err == nil {
		if err := address.Delete(model.DB); err != nil {
			logger.Error(err)
			RespJson(c, status.InternalServerError, nil)
			return
		} else {
			userAddressList, err := model.UserAddressList(uc.Uid)
			if err != nil {
				logger.Error(err)
				RespJson(c, status.InternalServerError, nil)
				return
			}

			RespJson(c, status.OK, userAddressList)
			return
		}
	} else if err == model.RecordNotFound {
		RespJson(c, status.BadRequest, nil)
		return
	} else {
		logger.Error(err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
}

func UserAddressDetail(c *gin.Context) {
	req := struct {
		Id uint32 `json:"id" binding:"required"`
	}{}
	if c.ShouldBindJSON(&req) != nil {
		RespJson(c, status.BadRequest, nil)
		return
	}
	//fmt.Println("req.Id", req.Id)

	//uc := auth.GetCurrentUser(c)
	//if uc == nil {
	//	RespJson(c, status.Unauthorized, nil)
	//	return
	//}

	address := new(model.UserAddress)
	if err := model.NewUserAddressQuerySet(model.DB.Unscoped()).IDEq(req.Id).One(address); err == nil {
		result := struct {
			ID           uint32 `json:"id"`
			ReceiverName string `json:"receiver_name"`
			Tel          string `json:"tel"`
			Province     string `json:"province"`
			City         string `json:"city"`
			District     string `json:"district"`
			Address      string `json:"address"`
			IsDefault    uint8  `json:"is_default"`
		}{
			ID:           address.ID,
			ReceiverName: address.ReceiverName,
			Tel:          address.Tel,
			Province:     address.Province,
			City:         address.City,
			District:     address.District,
			Address:      address.Address,
			IsDefault:    address.IsDefault,
		}
		RespOK(c, result)
		return
	} else if err == model.RecordNotFound {
		logger.Error(err)
		RespJson(c, status.BadRequest, nil)
		return
	} else {
		logger.Error(err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
}

func UserAddressSetDefault(c *gin.Context) {
	req := struct {
		Id uint32 `json:"id" binding:"required"`
	}{}
	if c.ShouldBindJSON(&req) != nil {
		RespJson(c, status.BadRequest, nil)
		return
	}

	uc := auth.GetCurrentUser(c)
	if uc == nil {
		RespJson(c, status.Unauthorized, nil)
		return
	}

	address := new(model.UserAddress)
	if err := model.NewUserAddressQuerySet(model.DB).UidEq(uc.Uid).IDEq(req.Id).One(address); err == nil {
		if err := model.UserAddressSetAllUnDefault(uc.Uid); err != nil {
			logger.Error(err)
			RespJson(c, status.InternalServerError, nil)
			return
		}

		address.IsDefault = common.Yes
		as := model.UserAddressDBSchema
		if err := address.Update(model.DB, as.IsDefault); err != nil {
			logger.Error(err)
			RespJson(c, status.InternalServerError, nil)
			return
		} else {
			userAddressList, err := model.UserAddressList(uc.Uid)
			if err != nil {
				logger.Error(err)
				RespJson(c, status.InternalServerError, nil)
				return
			}

			RespJson(c, status.OK, userAddressList)
			return
		}
	} else if err == model.RecordNotFound {
		RespJson(c, status.BadRequest, nil)
		return
	} else {
		logger.Error(err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
}