back/internal/api/mobile/order_preview/shipping_method_update.go

package order_preview

import (
	"fmt"
	"github.com/gin-gonic/gin"
	"github.com/jinzhu/gorm"
	"github.com/shopspring/decimal"
	"recook/internal/back"
	"recook/internal/dbc"
	"recook/internal/model/order_preview"
	"recook/internal/model/store"
	"recook/internal/model/user"
	"recook/tools"
)

type updateOrderShippingMethodParam struct {
	UserID         uint `json:"userId"  validate:"required"`
	OrderID        uint `json:"orderId"  validate:"required"`
	ShippingMethod uint `json:"shippingMethod"`
	StoreID        uint `json:"storeId"`
}

func UpdateOrderShippingMethod(c *gin.Context) {
	var p updateOrderShippingMethodParam
	err := tools.ParseParams(&p, c)
	if err != nil {
		back.Fail(c, err.Error())
		return
	}

	if p.ShippingMethod == 1 && p.StoreID == 0 {
		back.Fail(c, "未指定提货门店")
		return
	}

	var previewOrderInfo order_preview.Information
	dbc.DB.First(&previewOrderInfo, p.OrderID)

	var goodsList []order_preview.GoodsDetail
	dbc.DB.Find(&goodsList, "order_id = ?", p.OrderID)

	if previewOrderInfo.ShippingMethod == 0 && p.ShippingMethod == 1 { // 改成自提

		tx := dbc.DB.Begin()
		{
			// 增加自提逻辑
			if err = updateStoreAddr(p.StoreID, p.OrderID); err != nil {
				back.Fail(c, err.Error())
				return
			}

			for _, v := range goodsList {
				err = tx.Model(&v).Updates(map[string]interface{}{
					"express_fee":   0.0,
					"actual_amount": v.ActualAmount.Sub(v.ExpressFee),
				}).Error
				if err != nil {
					back.Err(c, err.Error())
					tx.Rollback()
					return
				}
			}

			err = tx.Model(&previewOrderInfo).Updates(map[string]interface{}{
				"shipping_method":   1,
				"store_id":          p.StoreID,
				"express_total_fee": 0.0,
				"actual_amount":     previewOrderInfo.ActualTotalAmount.Sub(previewOrderInfo.ExpressTotalFee),
			}).Error
			if err != nil {
				back.Err(c, err.Error())
				tx.Rollback()
				return
			}
		}
		tx.Commit()
	} else if previewOrderInfo.ShippingMethod == 1 && p.ShippingMethod == 1 { // 本来是自提 单纯的换个门店
		err = dbc.DB.Model(&previewOrderInfo).Updates(map[string]interface{}{
			"store_id": p.StoreID,
		}).Error
		if err != nil {
			back.Err(c, err.Error())
			return
		}

		if err = updateStoreAddr(p.StoreID, p.OrderID); err != nil {
			back.Fail(c, err.Error())
			return
		}
	} else if previewOrderInfo.ShippingMethod == 1 && p.ShippingMethod == 0 { // 改成快递
		tx := dbc.DB.Begin()
		{
			// 删除上一次地址
			var prevAddr order_preview.Addr
			dbc.DB.Where("order_id= ?", p.OrderID).Delete(&prevAddr)
			// 寻找默认地址， 没有就跳过
			var userAddr user.Addr
			userAddr.UserID = p.UserID
			userAddr.IsDefault = 1
			if err := dbc.DB.Find(&userAddr).Error; err != nil {
				if err == gorm.ErrRecordNotFound {
					// 如果没有默认地址
					if err := dbc.DB.Model(&previewOrderInfo).Updates(map[string]interface{}{
						"shipping_method": 0,
					}).Error; err != nil {
						back.Suc(c, "更改失败", queryPreviewOrderGroup(previewOrderInfo.ID))
						return
					} else {
						back.Suc(c, "更改成功", queryPreviewOrderGroup(previewOrderInfo.ID))
						return
					}
				}
				tx.Rollback()
				back.Fail(c, "服务器错误"+err.Error())
				return
			}
			{
				var prevAddr order_preview.Addr
				prevAddr.OrderID = p.OrderID
				dbc.DB.Delete(&prevAddr)

				// 自提改成快递，从新计算收获地址的运费
				var addr order_preview.Addr
				tx.First(&addr, "order_id = ?", p.OrderID)
				if addr.IsDeliveryArea == 1 {
					expressTotalFee := decimal.NewFromFloat(0.0)
					for _, v := range goodsList {
						_, expFee, err := computeExpressFeeWithPreviewGoods(v.Quantity, &v, addr.Province, addr.City)
						if err != nil {
							back.Err(c, err.Error())
							tx.Rollback()
							return
						}

						err = tx.Model(&v).Updates(map[string]interface{}{
							"express_fee":   expFee,
							"actual_amount": v.ActualAmount.Sub(v.ExpressFee).Add(expFee),
						}).Error
						if err != nil {
							back.Err(c, err.Error())
							tx.Rollback()
							return
						}
						expressTotalFee = expressTotalFee.Add(expFee)
					}

					err = tx.Model(&previewOrderInfo).Updates(map[string]interface{}{
						"shipping_method":   0,
						"express_total_fee": expressTotalFee,
						"actual_amount":     previewOrderInfo.ActualTotalAmount.Sub(previewOrderInfo.ExpressTotalFee).Add(expressTotalFee),
					}).Error
					if err != nil {
						back.Err(c, err.Error())
						tx.Rollback()
						return
					}
				} else { // 原来的地址属于不发货地区
					// 不操作，直接返回
					// 如果没有默认地址
					dbc.DB.Model(&previewOrderInfo).Updates(map[string]interface{}{
						"shipping_method": 0,
					})
				}
			}
		}
		tx.Commit()
	} else {
		back.Fail(c, "无需操作")
		return
	}

	back.Suc(c, "更改成功", queryPreviewOrderGroup(previewOrderInfo.ID))
}

func updateStoreAddr(StoreID, OrderID uint) (err error) {
	// 在表中先删后增
	var prevAddr order_preview.Addr
	prevAddr.OrderID = OrderID
	dbc.DB.Where("order_id=?", OrderID).Delete(&prevAddr)
	// 增加自提逻辑
	var storeInfo store.Information
	dbc.DB.Find(&storeInfo, StoreID)
	if storeInfo.ID <= 0 {
		err = fmt.Errorf("自提店选择错误")
		return
	}

	var pAddr order_preview.Addr
	dbc.DB.First(&pAddr, OrderID)
	pAddr.OrderID = OrderID
	pAddr.AddressID = 0
	pAddr.Address = storeInfo.BusinessLicenseAddress
	pAddr.Province = "[自提]"
	pAddr.City = ""
	pAddr.District = ""
	pAddr.ReceiverName = ""
	pAddr.Mobile = ""
	err = dbc.DB.Save(&pAddr).Error
	return
}