micro-bundle/internal/logic/valueAddBundleLogic.go

package logic

import (
	"errors"
	"fmt"
	"micro-bundle/internal/dao"
	"micro-bundle/internal/model"
	"micro-bundle/pb/bundle"
	"micro-bundle/pkg/app"
	"micro-bundle/pkg/msg"
	"strconv"
	"time"

	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/utils"
	"gorm.io/gorm"
)

// 增值套餐创建
func CreateValueAddBundle(req *bundle.CreateValueAddBundleRequest) (res *bundle.CreateValueAddBundleResponse, err error) {
	res = &bundle.CreateValueAddBundleResponse{}

	savedAmount := float32(req.Num * (msg.OriginalPrice - msg.DiscountPrice))
	totalPrice := float32(req.Num * msg.DiscountPrice)

	valueAddBundleProfile := &model.ValueAddBundleProfile{
		UUID:          utils.GetUUID(),
		Num:           req.Num,
		OriginalPrice: msg.OriginalPrice,
		DiscountPrice: msg.DiscountPrice,
		SavedAmount:   savedAmount,
		TotalPrice:    totalPrice,
		//Type:          msg.Custom,
	}

	err = dao.CreateValueAddBundle(valueAddBundleProfile)
	if err != nil {
		res.Msg = msg.ErrorCreateValueAddBundleInfo
		return res, err
	}

	res.Uuid = valueAddBundleProfile.UUID
	res.TotalPrice = totalPrice
	res.SavedAmount = savedAmount
	res.Msg = msg.SuccessCreateValueAddBundleInfo

	return
}

// 增值套餐列表
func ValueAddBundleList(req *bundle.ValueAddBundleListRequest) (res *bundle.ValueAddBundleListResponse, err error) {
	res = &bundle.ValueAddBundleListResponse{}
	var bundleCommonUid string
	var bundleProfile *model.BundleProfile
	bundleProfile, err = dao.BundleProfileDetail(req.BundleUuid)
	if err != nil {
		return
	} else {
		var bundleOrderRecord *model.BundleOrderRecords
		bundleOrderRecord, err = dao.GetBundleOrderRecordsByCommonUidAndUserId(bundleProfile.BundleCommonUid, req.UserId)
		if err != nil {
			err = nil
		} else {
			bundleCommonUid = bundleOrderRecord.BundleCommonUid
			res.OrderNo = true
			res.Price = bundleOrderRecord.ValueAddBundleAmount
			res.Num = bundleOrderRecord.Num

			if bundleOrderRecord.ValueAddBundleUUID != "" {
				res.Status = true
			}
		}
	}

	valueAddBundleProfile, err := dao.ValueAddBundleList(req.PriceType)
	if err != nil {
		res.Msg = msg.ErrorGetValueAddBundleList
		return res, err
	}

	for _, valueAddBundle := range valueAddBundleProfile {
		valueAddBundleProfileInfo := &bundle.ValueAddBundleProfile{
			Uuid:                valueAddBundle.UUID,
			Num:                 valueAddBundle.Num,
			OriginalPrice:       valueAddBundle.OriginalPrice,
			DiscountPrice:       valueAddBundle.DiscountPrice,
			TotalPrice:          valueAddBundle.TotalPrice,
			SavedAmount:         valueAddBundle.SavedAmount,
			DiscountPriceStatus: valueAddBundle.DiscountPriceStatus,
			Choose:              valueAddBundle.Choose,
		}

		if bundleCommonUid == valueAddBundle.AddBundleCommonUid {
			valueAddBundleProfileInfo.Status = true
		}

		res.Data = append(res.Data, valueAddBundleProfileInfo)
	}

	res.OriginalPrice = msg.OriginalPrice
	res.Total = int32(len(valueAddBundleProfile))
	res.Msg = "SUCCESS"

	return
}

// 增值套餐详情
func ValueAddBundleDetail(req *bundle.ValueAddBundleDetailRequest) (res *bundle.ValueAddBundleDetailResponse, err error) {
	res = &bundle.ValueAddBundleDetailResponse{}

	valueAddBundleProfile := &model.ValueAddBundleProfile{}
	valueAddBundleProfile, err = dao.ValueAddBundleDetail(req.Uuid)
	if err != nil {
		res.Msg = msg.ErrorGetValueAddBundleInfo
		return res, err
	}

	res.Data = &bundle.ValueAddBundleProfile{
		Uuid:                valueAddBundleProfile.UUID,
		Num:                 valueAddBundleProfile.Num,
		OriginalPrice:       valueAddBundleProfile.OriginalPrice,
		DiscountPrice:       valueAddBundleProfile.DiscountPrice,
		TotalPrice:          valueAddBundleProfile.TotalPrice,
		SavedAmount:         valueAddBundleProfile.SavedAmount,
		DiscountPriceStatus: valueAddBundleProfile.DiscountPriceStatus,
		Choose:              valueAddBundleProfile.Choose,
		AddBundleCommonUid:  valueAddBundleProfile.AddBundleCommonUid,
	}

	bundleOrderRecords := &model.BundleOrderRecords{}
	bundleOrderRecords, err = dao.BundleOrderRecordsDetailByAddUid(req.Uuid)
	if err != nil {
		err = nil
	} else {
		res.PayTime = bundleOrderRecords.PayTime
	}

	res.Msg = "SUCCESS"
	return
}

//*******************************************************************新增值服务***********************

// 增值套餐保存（无则新增，有则更新）
func SaveValueAddService(in *bundle.ValueAddServiceLang) (res *bundle.SaveResponse, err error) {
	res = &bundle.SaveResponse{}
	if in.Language == "" {
		return res, errors.New("语言参数不能为空")
	}
	var options model.PriceOptions
	for _, option := range in.Options {
		price, parseErr := strconv.ParseFloat(option.Price, 32)
		if parseErr != nil {
			return res, parseErr
		}
		options = append(options, &model.PriceOption{
			Id:     int32(option.Id),
			Num:    option.Num,
			Symbol: option.Symbol,
			Price:  float32(price),
		})
	}
	ok, err := model.ValidateOptions(options)
	if !ok {
		return res, err
	}
	valueAddService := &model.ValueAddService{
		ServiceName: in.ServiceName,
		ServiceType: in.ServiceType,
	}
	originalPrice, err := strconv.ParseFloat(in.OriginalPrice, 32)
	if err != nil {
		return res, err
	}
	valueAddServiceLang := &model.ValueAddServiceLang{
		ServiceName:   in.ServiceName,
		ServiceType:   in.ServiceType,
		PriceMode:     int32(in.PriceMode),
		OriginalPrice: float32(originalPrice),
		Unit:          in.Unit,
		Language:      in.Language,
		PriceType:     in.PriceType,
		Options:       options,
	}
	if in.Uuid == "" && in.Language != msg.ZH_CN {
		return res, errors.New("请先新增简体中文套餐，再添加其他语言版本")
	}
	tx := app.ModuleClients.BundleDB.Begin()
	defer func() {
		if err != nil {
			tx.Rollback()
		} else {
			tx.Commit()
		}
	}()
	// 检查当前语言套餐是否存在
	_, err = dao.ValueAddServiceDetailByUuidAndLanguage(in.Uuid, in.Language)
	if err != nil {
		if err == gorm.ErrRecordNotFound { // 当前语言套餐不存在
			if in.Language != msg.ZH_CN {
				_, err = dao.ValueAddServiceDetailByUuidAndLanguage(in.Uuid, msg.ZH_CN)
				if err != nil {
					if err != gorm.ErrRecordNotFound {
						return res, errors.New("请先创建中文套餐")
					} else {
						// // 新语言补充：只要UUID存在即可直接插入新语言
						// if in.Uuid != "" {
						// 	valueAddServiceLang.UUID = in.Uuid
						// 	if err = dao.CreateValueAddServiceLang(tx, valueAddServiceLang); err != nil {
						// 		return res, errors.New("补充新语言套餐失败: " + err.Error())
						// 	}
						// 	res.Uuid = in.Uuid
						// 	res.Msg = "补充新语言套餐成功"
						// 	return
						// }
						return
					}
				}
			}
			if in.Language == msg.ZH_CN {
				valueAddService.UUID = utils.GetUUID()
				err = dao.CreateValueAddService(tx, valueAddService)
				if err != nil {
					return res, errors.New("保存中文语言套餐失败: " + err.Error())
				}
				valueAddServiceLang.UUID = valueAddService.UUID
				res.Uuid = valueAddService.UUID
				if err = dao.CreateValueAddServiceLang(tx, valueAddServiceLang); err != nil {
					return res, errors.New("保存语言套餐失败: " + err.Error())
				}
			}
			langList := []string{msg.ZH_TW, msg.EN, msg.DE_DE, msg.JS_JP}
			for _, lang := range langList {
				otherLang := *valueAddServiceLang
				otherLang.Language = lang
				if err = dao.CreateValueAddServiceLang(tx, &otherLang); err != nil {
					return res, errors.New(fmt.Sprintf("保存%s语言套餐失败: ", lang) + err.Error())
				}
			}
			res.Msg = "保存成功"
			return
		} else {
			return
		}
	} else {
		// 已存在，进行更新
		//中文状态下，更新主表和语言表
		if in.Language == msg.ZH_CN {
			updateService := map[string]interface{}{
				"uuid":         in.Uuid,
				"service_name": in.ServiceName,
				"service_type": in.ServiceType,
			}
			if err = dao.UpdateValueAddService(tx, updateService); err != nil {
				return res, err
			}
		}
		// 查找所有与该增值服务关联的套餐，若币种不一致则取消关联并统计
		var cancelNum int64 = 0
		bundleToValueAddList, _ := dao.GetBundleToValueAddServiceByValueUid(in.Uuid)
		for _, rel := range bundleToValueAddList {
			bundleProfile, _ := dao.BundleDetailByUuidAndLanguage(rel.BundleUuid, in.Language)
			if bundleProfile != nil && bundleProfile.PriceType != in.PriceType {
				dao.DeleteBundleToValueAddService(tx, rel.BundleUuid, in.Uuid)
				cancelNum++
			}
		}
		//更新语言表
		updateLangService := map[string]interface{}{
			"uuid":           in.Uuid,
			"service_name":   in.ServiceName,
			"service_type":   in.ServiceType,
			"price_mode":     in.PriceMode,
			"original_price": in.OriginalPrice,
			"unit":           in.Unit,
			"price_type":     in.PriceType,
			"options":        options,
			"language":       in.Language,
		}
		if err = dao.UpdateValueAddServiceLang(tx, updateLangService); err != nil {
			return res, err
		}
		res.Uuid = in.Uuid
		res.Msg = "保存成功"
		res.CancelNum = cancelNum
	}
	return
}

// 增值套餐列表
func ValueAddServiceList(req *bundle.ValueAddServiceListRequest) (res *bundle.ValueAddServiceListResponse, err error) {
	res = &bundle.ValueAddServiceListResponse{}
	list, total, err := dao.ValueAddServiceList(req)
	if err != nil {
		res.Msg = msg.ErrorValueAddServiceList
		return res, err
	}
	for _, valueAddService := range list {
		serviceInfo := &bundle.ValueAddService{
			Uuid:        valueAddService.UUID,
			ServiceName: valueAddService.ServiceName,
			ServiceType: valueAddService.ServiceType,
		}
		for _, serviceLang := range valueAddService.ValueAddServiceLang {
			serviceLangInfo := &bundle.ValueAddServiceLang{
				Uuid:          valueAddService.UUID,
				ServiceName:   serviceLang.ServiceName,
				ServiceType:   serviceLang.ServiceType,
				PriceMode:     serviceLang.PriceMode,
				OriginalPrice: fmt.Sprintf("%.2f", serviceLang.OriginalPrice),
				Unit:          serviceLang.Unit,
				PriceType:     int64(serviceLang.PriceType),
				Language:      serviceLang.Language,
				CreatedAt:     time.Unix(serviceLang.CreatedAt, 0).Format("2006-01-02 15:04:05"),
				UpdatedAt:     time.Unix(serviceLang.UpdatedAt, 0).Format("2006-01-02 15:04:05"),
			}
			if serviceLang.Options != nil && len(serviceLang.Options) > 0 {
				var options []*bundle.ValueAddPriceOptions
				for _, option := range serviceLang.Options {
					options = append(options, &bundle.ValueAddPriceOptions{
						Id:     int64(option.Id),
						Num:    option.Num,
						Symbol: option.Symbol,
						Price:  fmt.Sprintf("%.2f", option.Price),
					})
				}
				serviceLangInfo.Options = options
			}
			serviceInfo.ServiceLang = append(serviceInfo.ServiceLang, serviceLangInfo)
		}
		res.ValueAddServiceList = append(res.ValueAddServiceList, serviceInfo)
	}
	res.Total = int32(total)
	res.Msg = msg.SuccessValueAddServiceList
	return

}

// 增值套餐详情
func ValueAddServiceDetail(req *bundle.ValueAddServiceDetailRequest) (res *bundle.ValueAddServiceDetailResponse, err error) {
	res = &bundle.ValueAddServiceDetailResponse{}
	if req.Uuid == "" {
		res.Msg = msg.ErrorValueAddServiceInfo
		return res, errors.New("uuid不能为空")
	}
	if req.Language == "" {
		res.Msg = msg.ErrorValueAddServiceInfo
		return res, errors.New("语言选项不能为空")
	}
	detail, err := dao.ValueAddServiceDetailByUuidAndLanguage(req.Uuid, req.Language)
	if err != nil {
		res.Msg = msg.ErrorValueAddServiceInfo
		return res, err
	}
	langOptions := []*bundle.ValueAddPriceOptions{}
	if detail.Options != nil && len(detail.Options) > 0 {
		for _, opt := range detail.Options {
			langOptions = append(langOptions, &bundle.ValueAddPriceOptions{
				Id:     int64(opt.Id),
				Num:    opt.Num,
				Symbol: opt.Symbol,
				Price:  fmt.Sprintf("%.2f", opt.Price),
			})
		}
	}

	serviceLang := &bundle.ValueAddServiceLang{
		Uuid:          detail.UUID,
		ServiceName:   detail.ServiceName,
		ServiceType:   detail.ServiceType,
		Language:      detail.Language,
		PriceMode:     detail.PriceMode,
		OriginalPrice: fmt.Sprintf("%.2f", detail.OriginalPrice),
		Unit:          detail.Unit,
		PriceType:     int64(detail.PriceType),
		Options:       langOptions,
		CreatedAt:     time.Unix(detail.CreatedAt, 0).Format("2006-01-02 15:04:05"),
		UpdatedAt:     time.Unix(detail.UpdatedAt, 0).Format("2006-01-02 15:04:05"),
	}

	res.ValueAddServiceLang = serviceLang
	res.Msg = msg.SuccessValueAddServiceInfo
	return
}