back/internal/v2/logic/manage/jyy/order.go

package jyy

import (
	"fmt"
	"recook/internal/v2/logic/manage/after"
	"recook/internal/v2/logic/manage/order"
	"recook/internal/v2/model/gys/user"
	"recook/internal/v2/model/jyy"
	after2 "recook/internal/v2/model/recook/after"
	manage2 "recook/internal/v2/model/recook/manage"
	manage "recook/internal/v2/model/recook/order"
	"time"

	"git.oa00.com/go/mysql"
	"github.com/golangkit/formatime"
	"github.com/shopspring/decimal"
	"gorm.io/gorm"
)

type OrderEntry struct {
	OrderID uint `json:"order_id" validate:"required"`
}

func (o logic) OrderCancel(args OrderEntry, u manage2.RecookManageUserInfoModel) (err error) {
	// 发起未发货售后,并退款
	var od manage.RecookOrderInfoModel
	mysql.Db.Preload("OrderSku").Preload("After").First(&od, "id = ?", args.OrderID)
	if od.OrderType != 2 {
		err = fmt.Errorf("不是批发订单无法取消")
		return
	}
	if len(od.After) != 0 {
		err = fmt.Errorf("已发起售后仅退款,请转到售后")
		return
	}

	if od.PayTime.IsZero() {
		if err = mysql.Db.Model(&od).Updates(manage.RecookOrderInfoModel{Status: 2}).Error; err != nil {
			return err
		}
		return
	}

	ids := make([]uint, 0)
	if err = mysql.Db.Transaction(func(tx *gorm.DB) error {
		for _, v := range od.OrderSku {
			afs := after2.RecookAfterSalesGoodsModel{
				AncestorId:       v.AncestorId,
				ParentId:         v.ParentId,
				SharerId:         v.SharerId,
				UserId:           v.UserId,
				UserRole:         0,
				OrderId:          v.OrderId,
				OrderGoodsId:     v.Id,
				VendorId:         v.VendorId,
				VendorName:       v.VendorName,
				BrandName:        v.BrandName,
				CategoryName:     v.CategoryName,
				GoodsId:          v.GoodsId,
				GoodsName:        v.GoodsName,
				SkuName:          v.SkuName,
				SkuCode:          v.SkuCode,
				MainPhotoUrl:     v.MainPhotoURL,
				Quantity:         v.Quantity,
				OrderTime:        v.OrderTime,
				OrderTotalAmount: od.ActualTotalAmount,
				RefundAmount:     v.ActualAmount,
				RefundCoin:       decimal.Zero,
				TradeNo:          od.TradeNo,
				PayMethod:        od.PayMethod,
				IsShip:           v.ExpressStatus,
				AssType:          1,
				ReturnStatus:     1,
				ApplyTime:        formatime.NewSecondNow(),
				RefundNo:         fmt.Sprintf("%d_%vA%d", time.Now().Unix(), od.TradeNo, v.Id),
			}
			if e := tx.Create(&afs).Error; e != nil {
				return e
			}
			ids = append(ids, afs.Id)
			lo := after2.RecookAfterSalesLogsModel{
				AsID:    afs.Id,
				Title:   "系统申请仅退款",
				Content: "退款原因：系统自动发起" + "|退款金额：" + (afs.RefundAmount).String(),
				CTime:   formatime.Second{},
				User:    u.Name,
				UserId:  u.Id,
			}
			if e := tx.Create(&lo).Error; e != nil {
				return e
			}
		}
		return nil
	}); err != nil {
		return
	}
	for _, v := range ids {
		req := after.UpdateOrderCheckStatusReq{
			AsID:    v,
			Opinion: 1,
		}
		if err = after.Logic.Review(&req, u); err != nil {
			return err
		}
	}

	return
}

type OrderConfirmReq struct {
	OrderGoodsID uint            `json:"order_goods_id" validate:"required"`
	Amount       decimal.Decimal `json:"amount"`
	Photo        string          `json:"photo"`
	Reason       string          `json:"reason"`
}

func (o OrderConfirmReq) TableName() string {
	return "jyy_order_make_up"
}

func (o logic) OrderConfirm(args OrderConfirmReq) (err error) {
	// 发货, 只修改状态, 没有物流信息
	var ods manage.RecookOrderGoodsDetailModel
	mysql.Db.First(&ods, "id = ?", args.OrderGoodsID)
	var od manage.RecookOrderInfoModel
	mysql.Db.First(&od, "id = ?", ods.OrderId)
	if od.OrderType != 2 {
		err = fmt.Errorf("不是批发订单无法确认发货")
		return
	}
	var u user.GysUsersModel
	mysql.Db.First(&u, "id = ?", ods.VendorId)
	if err = order.Expresslogic.Update(u, args.OrderGoodsID, nil); err != nil {
		return
	}
	return
}

func (o logic) OrderMakeUp(args OrderConfirmReq) (err error) {
	// 补偿订单
	err = mysql.Db.Transaction(func(tx *gorm.DB) error {
		if e := mysql.Db.Create(&args).Error; err != nil {
			return e
		}
		if e := mysql.Db.Table((&manage.RecookOrderGoodsDetailModel{}).TableName()).Where("id = ?", args.OrderGoodsID).
			Update("make_up_status", 1).
			Error; e != nil {
			return e
		}

		return nil
	})

	return
}

func (o logic) OrderMakeUpGet(args OrderConfirmReq) (res OrderConfirmReq) {
	mysql.Db.First(&res, "order_goods_id", args.OrderGoodsID)
	return
}

func (o logic) GetContact() (res jyy.Contact) {
	mysql.Db.First(&res)
	return
}

func (o logic) UpdateContact(args jyy.Contact) error {
	return mysql.Db.Table(args.TableName()).Where("id = ?", args.ID).Updates(args).Error
}