lone-services/services/order/internal/logic/webCreateLogic.go

package logic

import (
	"context"
	"lone-services/pkg/modelbase"
	"lone-services/pkg/utils"
	"lone-services/services/order/internal/dao"
	"lone-services/services/order/internal/model"
	"lone-services/services/order/validator"
	"strconv"
	"strings"

	"lone-services/rpc/order/pb"
	"lone-services/services/order/internal/svc"

	"github.com/zeromicro/go-zero/core/logx"
)

type WebCreateLogic struct {
	ctx    context.Context
	svcCtx *svc.ServiceContext
	logx.Logger
	BaseLogic
}

func NewWebCreateLogic(ctx context.Context, svcCtx *svc.ServiceContext) *WebCreateLogic {
	return &WebCreateLogic{
		ctx:    ctx,
		svcCtx: svcCtx,
		Logger: logx.WithContext(ctx),
	}
}

func (l *WebCreateLogic) WebCreate(in *order.CreateOrderRequest) (*order.Response, error) {
	var v validator.OrderCreateValidator
	if fail := l.checkParams(in, &v); fail != nil {
		return fail, nil
	}
	adminInfo := utils.GetUserFromCtx(l.ctx)
	if adminInfo.ID < utils.NumberOne {
		return l.fail(utils.ErrorNoLoginInfo)
	}

	w := modelbase.Params{
		Eq: map[string]string{
			"id":        strconv.FormatInt(in.AddressId, utils.NumberTen),
			"type":      strconv.Itoa(int(in.Type)),
			"target_id": strconv.FormatInt(adminInfo.ID, utils.NumberTen),
		},
	}
	var address dao.Address
	err := model.AddressModel{}.Init().GetOne(w, &address)
	if err != nil {
		return l.fail(utils.Fail)
	}
	if address.Id < utils.NumberOne {
		return l.out(utils.Fail, "地址不存在")
	}

	data := dao.OrderCreate{
		Note:        in.Note,
		ExpiredTime: utils.GetAfterMinutes(utils.NumberThirty),
		Mobile:      address.Mobile,
		Address:     address.Address,
		Addressee:   address.Name,
		DistrictIds: address.DistrictIds,
	}

	w = modelbase.Params{
		Eq: map[string]string{
			"type": strconv.Itoa(int(in.Type)),
		},
	}
	var orderSn string
	switch in.Type {
	case dao.CartTypeSale:
		data.SaleId = int(adminInfo.ID)
		data.SaleName = adminInfo.Name
		data.CreateType = dao.OrderTypeSale
		data.Type = dao.OrderTypeSale
		w.Eq["sale_id"] = strconv.FormatInt(adminInfo.ID, utils.NumberTen)
		orderSn = svc.GetOrderSn(strconv.Itoa(dao.OrderTypeSale), adminInfo.ID)
	case dao.CartTypeUser:
		data.UserId = int(adminInfo.ID)
		data.UserName = adminInfo.Name
		data.CreateType = dao.OrderTypePersonal
		data.Type = dao.OrderTypePersonal
		w.Eq["user_id"] = strconv.FormatInt(adminInfo.ID, utils.NumberTen)
		orderSn = svc.GetOrderSn(strconv.Itoa(dao.OrderTypePersonal), adminInfo.ID)
	case dao.CartTypeStore:
		data.StoreId = int(adminInfo.ID)
		data.StoreName = adminInfo.Name
		data.SaleId = int(adminInfo.SaleId)
		data.GroupId = int(adminInfo.GroupId)
		data.SaleMobile = adminInfo.SaleMobile
		data.SaleProvince = int(adminInfo.SaleProvince)
		data.CreateType = dao.OrderTypeStore
		data.Type = dao.OrderTypeStore
		w.Eq["store_id"] = strconv.FormatInt(adminInfo.ID, utils.NumberTen)
		orderSn = svc.GetOrderSn(strconv.Itoa(dao.OrderTypeStore), adminInfo.ID)
	}
	data.OrderSn = orderSn

	var cart dao.Cart
	err = model.CartModel{}.Init().GetOne(w, &address)
	if err != nil {
		return l.fail(utils.Fail)
	}
	if cart.Id < utils.NumberOne {
		return l.out(utils.Fail, "购买信息不存在")
	}

	ids, pErr := svc.GetCartInfo(cart.Content)
	if pErr != utils.Ok {
		return l.fail(utils.Fail)
	}
	products, pErr := svc.GetCartData(ids)
	if pErr != utils.Ok {
		return l.fail(utils.Fail)
	}
	keys := make([]string, utils.NumberZero, len(products))
	var totalPrice float64
	for _, item := range products {
		keys = append(keys, strconv.Itoa(int(item.Id)))
		totalPrice += item.Price * float64(item.Number)
	}
	data.ProductIds = strings.Join(keys, utils.DecollatorComma)
	data.TotalPrice = totalPrice

	mobileObj := model.OrderModel{}.Init()
	mobileObj.Begin()
	err = mobileObj.Create(&data)
	if err != nil {
		mobileObj.Rollback()
		return l.fail(utils.Fail)
	}

	for _, item := range products {
		orderProduct := dao.OrderProductCreate{
			Ordersn:     data.OrderSn,
			ProductId:   int(item.Id),
			ProductName: item.Name,
			Price:       item.Price,
			Number:      item.Number,
		}
		err = model.OrderProductModel{}.Init().Create(&orderProduct)
		if err != nil {
			mobileObj.Rollback()
			return l.fail(utils.Fail)
		}

		_, err = model.CartModel{}.Init().Del(w, &cart)
		if err != nil {
			mobileObj.Rollback()
			return l.fail(utils.Fail)
		}
		//TODO 扣除库存
		//$decrease = Product::decrease(
		//['id' => $item['id'], ['number', '>=', $item['number']]],
		//'number',
		//$item['number']
		//);
		//if ($decrease < 1) {
		//Order::rollBack();
		//$retData['code'] = Code::code('low_stocks');
		//$retData['data'] = [$item['id'] => Product::value(['id' => $item['id']], 'number')];
		//return $retData;
	}

	mobileObj.Commit()

	return l.ok(utils.NumberOne)
}