fiee/micro-bundle
4
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'sxy'

Browse Source
This commit is contained in:
孙肖扬 2025-06-26 17:31:25 +08:00
commit ae4bbe29c0
9 changed files with 545 additions and 279 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
internal/controller/bundleV2.go
View File

@ -22,6 +22,9 @@ func (b *BundleProvider) BundleListV2(_ context.Context, req *bundle.BundleListR
func (b *BundleProvider) BundleDetailV2(_ context.Context, req *bundle.BundleDetailRequest) (res *bundle.BundleDetailResponseV2, err error) {
return logic.BundleDetailV2(req)
}
func (b *BundleProvider) BundleLangDetailV2(_ context.Context, req *bundle.BundleDetailRequest) (res *bundle.BundleProfileLang, err error) {
return logic.BundleLangDetailV2(req)
}
// ***************************************************新增值服务***********************
func (b *BundleProvider) SaveValueAddService(_ context.Context, req *bundle.ValueAddServiceLang) (res *bundle.SaveResponse, err error) {
@ -39,3 +42,12 @@ func (b *BundleProvider) ValueAddServiceLangByUuidAndLanguage(_ context.Context,
func (b *BundleProvider) CalculatePrice(ctx context.Context, req *bundle.CalculatePriceRequest) (res *bundle.CalculatePriceResponse, err error) {
return logic.CalculatePrice(req)
}
func (b *BundleProvider) BatchGetValueAddServiceLang(ctx context.Context, req *bundle.BatchGetValueAddServiceLangRequest) (res *bundle.BatchGetValueAddServiceLangResponse, err error) {
return logic.BatchGetValueAddServiceLang(req)
}
// 增加h5套餐列表
func (b *BundleProvider) BundleListH5V2(_ context.Context, req *bundle.BundleListRequest) (res *bundle.BundleListResponse, err error) {
return logic.BundleListH5V2(req)
}

143
internal/dao/bundleDao.go
View File

@ -136,7 +136,6 @@ func BundleListV2(req *bundle.BundleListRequest) (res *bundle.BundleListResponse
bundles := make([]*model.BundleProfile, 0)
query := app.ModuleClients.BundleDB.Model(&model.BundleProfile{}).Preload("BundleProfileLang")
//query = query.Where("shelf_status = ?", 1) //上架的
if req.Name != "" {
query = query.Where("name like ?", "%"+req.Name+"%")
@ -161,7 +160,7 @@ func BundleListV2(req *bundle.BundleListRequest) (res *bundle.BundleListResponse
if err = query.Preload("BundleToValueAddService").Find(&bundles).Error; err != nil {
return res, commonErr.ReturnError(err, msg.ErrorGetBundleList, "获取套餐列表失败: ")
}
if bundles != nil && len(bundles) > 0 {
if len(bundles) > 0 {
for _, bundleProfile := range bundles {
selectValueAddService := make([]*bundle.SelectValueAddService, 0)
if bundleProfile.BundleToValueAddService != nil {
@ -173,7 +172,7 @@ func BundleListV2(req *bundle.BundleListRequest) (res *bundle.BundleListResponse
}
}
bundleProfileLang := []*bundle.BundleProfileLang{}
if bundleProfile.BundleProfileLang != nil && len(bundleProfile.BundleProfileLang) > 0 {
if len(bundleProfile.BundleProfileLang) > 0 {
for _, lang := range bundleProfile.BundleProfileLang {
bpl := &bundle.BundleProfileLang{
Uuid: lang.UUID,
@ -207,6 +206,7 @@ func BundleListV2(req *bundle.BundleListRequest) (res *bundle.BundleListResponse
SelectValueAddService: selectValueAddService,
BundleProfileLang: bundleProfileLang,
ShelfStatus: int64(bundleProfile.ShelfStatus),
FontColor: bundleProfile.FontColor,
})
}
}
@ -223,7 +223,7 @@ func BundleListV2(req *bundle.BundleListRequest) (res *bundle.BundleListResponse
func BundleDetailV2(req *bundle.BundleDetailRequest) (res *model.BundleProfile, err error) {
var data model.BundleProfile
err = app.ModuleClients.BundleDB.Model(&model.BundleProfile{}).Where("uuid = ?", req.Uuid).
err = app.ModuleClients.BundleDB.Model(&model.BundleProfile{}).Where("uuid = ? ", req.Uuid).
Preload("BundleProfileLang").
Preload("BundleToValueAddService").
First(&data).Error
@ -237,6 +237,7 @@ func BundleDetailV2(req *bundle.BundleDetailRequest) (res *model.BundleProfile,
func HandShelf(uuid string, shelfStatus int64) (res *bundle.CommonResponse, err error) {
res = new(bundle.CommonResponse)
err = app.ModuleClients.BundleDB.Model(&model.BundleProfile{}).Where("uuid = ?", uuid).Update("shelf_status", shelfStatus).Error
if err != nil {
res.Msg = "套餐上下架操作失败"
return res, err
@ -247,7 +248,8 @@ func HandShelf(uuid string, shelfStatus int64) (res *bundle.CommonResponse, err
// 通过uuid和language查询套餐语言表
func BundleDetailByUuidAndLanguage(uuid string, language string) (bundleProfileLang *model.BundleProfileLang, err error) {
err = app.ModuleClients.BundleDB.Where("uuid = ? AND language = ?", uuid, language).First(&bundleProfileLang).Error
err = app.ModuleClients.BundleDB.Where("uuid = ? AND language = ? AND deleted_at = 0", uuid, language).First(&bundleProfileLang).Error
if err != nil {
return nil, err
}
@ -274,12 +276,23 @@ func TxCreateBundleLang(tx *gorm.DB, req *model.BundleProfileLang) (err error) {
func TxUpdateBundle(tx *gorm.DB, uuid string, columns map[string]interface{}) (err error) {
err = tx.Model(&model.BundleProfile{}).Where("uuid =?", uuid).Updates(columns).Error
if err != nil {
return commonErr.ReturnError(err, msg.ErrorUpdateBundleInfo, "更新套餐信息失败: ")
return commonErr.ReturnError(err, msg.ErrorUpdateBundleInfo, "更新套餐信息失败")
}
return
}
func TxUpdateBundles(tx *gorm.DB, uuids []string, columns map[string]interface{}) (err error) {
if len(uuids) == 0 {
return nil
}
err = tx.Model(&model.BundleProfile{}).Where("uuid IN (?)", uuids).Updates(columns).Error
if err != nil {
return commonErr.ReturnError(err, msg.ErrorUpdateBundleInfo, "更新套餐信息失败")
}
return
}
func TxUpdateBundleLang(tx *gorm.DB, uuid string, language string, columns map[string]interface{}) (err error) {
err = tx.Model(&model.BundleProfileLang{}).Where("uuid =? and language=?", uuid, language).Updates(columns).Error
err = tx.Model(&model.BundleProfileLang{}).Where("uuid =? and language=? and deleted_at = 0", uuid, language).Updates(columns).Error
if err != nil {
return commonErr.ReturnError(err, msg.ErrorUpdateBundleInfo, "更新套餐信息失败: ")
}
@ -288,13 +301,24 @@ func TxUpdateBundleLang(tx *gorm.DB, uuid string, language string, columns map[s
func CreateBundleToValueAddService(tx *gorm.DB, records []*model.BundleToValueAddService) error {
return tx.Model(&model.BundleToValueAddService{}).Create(&records).Error
}
func UpdateBundleToValueAddService(tx *gorm.DB, records []*model.BundleToValueAddService) error {
columns := make(map[string]interface{})
for _, record := range records {
columns["is_display"] = record.IsDisplay
err := tx.Model(&model.BundleToValueAddService{}).Where("bundle_uuid = ? AND value_uid = ? AND deleted_at = 0", record.BundleUuid, record.ValueUid).Updates(columns).Error
if err != nil {
return commonErr.ReturnError(err, msg.ErrorUpdateBundleInfo, "更新套餐信息失败: ")
}
}
return nil
}
func DeleteBundleToValueAddService(tx *gorm.DB, bundleUuid, valueUid string) error {
return tx.Where("bundle_uuid = ? AND value_uid = ?", bundleUuid, valueUid).Delete(&model.BundleToValueAddService{}).Error
return tx.Where("bundle_uuid = ? AND value_uid = ? AND deleted_at = 0", bundleUuid, valueUid).Delete(&model.BundleToValueAddService{}).Error
}
func GetValueAddServiceUuidsByBundleUuid(bundleUuid string) ([]string, error) {
var uuids []string
err := app.ModuleClients.BundleDB.Model(&model.BundleToValueAddService{}).Where("bundle_uuid = ?", bundleUuid).Pluck("value_uid", &uuids).Error
err := app.ModuleClients.BundleDB.Model(&model.BundleToValueAddService{}).Where("bundle_uuid = ? and deleted_at = 0", bundleUuid).Pluck("value_uid", &uuids).Error
return uuids, err
}
@ -302,7 +326,7 @@ func GetValueAddServiceUuidsByBundleUuid(bundleUuid string) ([]string, error) {
func GetBundleToValueAddServiceByBundleUuid(bundleUuid string) ([]*model.BundleToValueAddService, error) {
var result []*model.BundleToValueAddService
err := app.ModuleClients.BundleDB.Model(&model.BundleToValueAddService{}).
Where("bundle_uuid = ?", bundleUuid).
Where("bundle_uuid = ? and deleted_at = 0", bundleUuid).
Find(&result).Error
return result, err
}
@ -310,8 +334,11 @@ func GetBundleToValueAddServiceByBundleUuid(bundleUuid string) ([]*model.BundleT
func GetBundleLangsByUuid(uuid string) ([]*model.BundleProfileLang, error) {
var result []*model.BundleProfileLang
err := app.ModuleClients.BundleDB.Model(&model.BundleProfileLang{}).
Where("uuid =?", uuid).
Where("uuid =? and deleted_at = 0", uuid).
Find(&result).Error
if err != nil {
return nil, err
}
return result, err
}
func GetBundleDetailByUuid(uuid string) (*model.BundleProfile, error) {
@ -326,3 +353,95 @@ func GetBundleDetailByUuid(uuid string) (*model.BundleProfile, error) {
func CreateBunldeHistory(tx *gorm.DB, req *model.BundleProfileHistory) error {
return tx.Model(&model.BundleProfileHistory{}).Create(req).Error
}
func BundleListH5V2(req *bundle.BundleListRequest) (res *bundle.BundleListResponse, err error) {
res = new(bundle.BundleListResponse)
res.Bundles = make([]*bundle.BundleProfile, 0)
bundles := make([]*model.BundleProfile, 0)
query := app.ModuleClients.BundleDB.Model(&model.BundleProfile{}).Where("shelf_status = ?", 1).Preload("BundleProfileLang")
//query = query.Where("shelf_status = ?", 1) //上架的
if req.Name != "" {
query = query.Where("name like ?", "%"+req.Name+"%")
}
if req.Content != "" {
query = query.Where("content like ?", "%"+req.Content+"%")
}
if req.Language != "" {
query = query.Where("language like ?", req.Language)
}
count := *query
// 排序：sort 升序，相同 sort 按 created_at 倒序
query = query.Order("sort ASC").Order("created_at DESC")
if req.PageSize != 0 && req.Page != 0 {
query = query.Limit(int(req.PageSize)).Offset(int(req.Page-1) * int(req.PageSize))
}
if err = query.Preload("BundleToValueAddService").Find(&bundles).Error; err != nil {
return res, commonErr.ReturnError(err, msg.ErrorGetBundleList, "获取套餐列表失败: ")
}
if len(bundles) > 0 {
for _, bundleProfile := range bundles {
selectValueAddService := make([]*bundle.SelectValueAddService, 0)
if bundleProfile.BundleToValueAddService != nil {
for _, v := range bundleProfile.BundleToValueAddService {
selectValueAddService = append(selectValueAddService, &bundle.SelectValueAddService{
ValueAddUuid: v.ValueUid,
IsDisplay: v.IsDisplay,
})
}
}
bundleProfileLang := []*bundle.BundleProfileLang{}
if len(bundleProfile.BundleProfileLang) > 0 {
for _, lang := range bundleProfile.BundleProfileLang {
bpl := &bundle.BundleProfileLang{
Uuid: lang.UUID,
Name: lang.Name,
Price: lang.Price,
PriceType: lang.PriceType,
Content: lang.Content,
Language: lang.Language,
CreatedAt: time.Unix(lang.CreatedAt, 0).Format("2006-01-02 15:04:05"),
UpdatedAt: time.Unix(int64(lang.UpdatedAt), 0).Format("2006-01-02 15:04:05"),
}
bundleProfileLang = append(bundleProfileLang, bpl)
}
}
res.Bundles = append(res.Bundles, &bundle.BundleProfile{
Uuid: bundleProfile.UUID,
Name: bundleProfile.Name,
Content: bundleProfile.Content,
Price: bundleProfile.Price,
PriceType: bundleProfile.PriceType,
Contract: bundleProfile.Contract,
Language: bundleProfile.Language,
CreatedAt: bundleProfile.CreatedAt.Format("2006-01-02 15:04:05"),
UpdatedAt: bundleProfile.UpdatedAt.Format("2006-01-02 15:04:05"),
CompanySign: bundleProfile.CompanySign,
ContractDuration: int64(bundleProfile.ContractDuration),
Sort: bundleProfile.Sort,
ImgOption: int32(bundleProfile.ImgOption),
BgImg1: bundleProfile.BgImg1,
BgImg2: bundleProfile.BgImg2,
SelectValueAddService: selectValueAddService,
BundleProfileLang: bundleProfileLang,
ShelfStatus: int64(bundleProfile.ShelfStatus),
FontColor: bundleProfile.FontColor,
})
}
}
var total int64
count.Count(&total)
res.Total = int32(total)
return
}

28
internal/dao/valueAddBundleDao.go
View File

@ -97,15 +97,15 @@ func CreateValueAddServiceLang(tx *gorm.DB, req *model.ValueAddServiceLang) (err
// 增值套餐主表更新
func UpdateValueAddService(tx *gorm.DB, columns map[string]interface{}) (err error) {
err = tx.Model(&model.ValueAddService{}).Where("uuid = ?", columns["uuid"]).Updates(columns).Error
err = tx.Model(&model.ValueAddService{}).Where("uuid = ? and deleted_at = 0", columns["uuid"]).Updates(columns).Error
if err != nil {
return
}
return
}
func UpdateValueAddServiceLang(tx *gorm.DB, columns map[string]interface{}) (err error) {
err = tx.Model(&model.ValueAddServiceLang{}).Where("uuid =?", columns["uuid"]).
Where("language", columns["language"]).Updates(columns).Error
err = tx.Model(&model.ValueAddServiceLang{}).Where("uuid =? and deleted_at = 0", columns["uuid"]).
Where("language = ?", columns["language"]).Updates(columns).Error
if err != nil {
return
}
@ -115,6 +115,7 @@ func UpdateValueAddServiceLang(tx *gorm.DB, columns map[string]interface{}) (err
// 增值套餐列表
func ValueAddServiceList(req *bundle.ValueAddServiceListRequest) (res []*model.ValueAddService, total int64, err error) {
query := app.ModuleClients.BundleDB.Model(&model.ValueAddService{}).
Where("deleted_at = 0").
Preload("ValueAddServiceLang", func(db *gorm.DB) *gorm.DB {
return db.Select("uuid,service_name,service_type,price_mode,original_price,unit,language,price_type,options,created_at,updated_at")
})
@ -134,7 +135,7 @@ func ValueAddServiceList(req *bundle.ValueAddServiceListRequest) (res []*model.V
// 增值套餐详情
func ValueAddServiceDetail(uuid string) (valueAddServiceDetail *model.ValueAddService, err error) {
var data model.ValueAddService
err = app.ModuleClients.BundleDB.Where("uuid = ?", uuid).Preload("ValueAddServiceLang").First(&data).Error
err = app.ModuleClients.BundleDB.Where("uuid = ? and deleted_at = 0", uuid).Preload("ValueAddServiceLang").First(&data).Error
if err != nil {
return nil, err
}
@ -143,7 +144,8 @@ func ValueAddServiceDetail(uuid string) (valueAddServiceDetail *model.ValueAddSe
// 通过uuid和language查询增值套餐
func ValueAddServiceDetailByUuidAndLanguage(uuid string, language string) (valueAddServiceLang *model.ValueAddServiceLang, err error) {
err = app.ModuleClients.BundleDB.Where("uuid = ? AND language = ?", uuid, language).First(&valueAddServiceLang).Error
err = app.ModuleClients.BundleDB.Where("uuid = ? AND language = ? and deleted_at = 0", uuid, language).First(&valueAddServiceLang).Error
if err != nil {
return nil, err
}
@ -154,7 +156,7 @@ func ValueAddServiceDetailByUuidAndLanguage(uuid string, language string) (value
func GetBundleToValueAddServiceByValueUid(valueUid string) ([]model.BundleToValueAddService, error) {
var rels []model.BundleToValueAddService
err := app.ModuleClients.BundleDB.Model(&model.BundleToValueAddService{}).
Where("value_uid = ?", valueUid).
Where("value_uid = ? and deleted_at = 0", valueUid).
Find(&rels).Error
return rels, err
}
@ -187,3 +189,17 @@ func BatchValueAddServiceDetailTx(tx *gorm.DB, uids []string) (map[string]*model
}
return resultMap, nil
}
func BatchGetValueAddServiceLang(uuids []string, language string) (map[string]*model.ValueAddServiceLang, error) {
var results []*model.ValueAddServiceLang
err := app.ModuleClients.BundleDB.Model(&model.ValueAddServiceLang{}).
Where("uuid IN ? AND language = ? AND deleted_at = 0", uuids, language).
Find(&results).Error
if err != nil {
return nil, fmt.Errorf("批量查询增值服务语言失败: %w", err)
}
resultMap := make(map[string]*model.ValueAddServiceLang, len(results))
for _, detail := range results {
resultMap[detail.UUID] = detail
}
return resultMap, nil
}

403
internal/logic/bundleLogic.go
View File

@ -3,14 +3,13 @@ package logic
import (
"encoding/json"
"errors"
"fmt"
"micro-bundle/internal/dao"
"micro-bundle/pb/bundle"
"micro-bundle/pkg/app"
"micro-bundle/pkg/msg"
"time"
"micro-bundle/internal/model"
"micro-bundle/pb/bundle"
"github.com/aliyun/alibaba-cloud-sdk-go/sdk/utils"
"github.com/jinzhu/copier"
@ -60,7 +59,7 @@ func BundleDetail(req *bundle.BundleDetailRequest) (res *bundle.BundleDetailResp
func SaveBundle(req *bundle.BundleProfile) (res *bundle.SaveResponse, err error) {
res = &bundle.SaveResponse{}
if req.Language == "" {
return res, errors.New("语言参数不能为空")
return res, errors.New("语言不能为空")
}
if req.Sort <= 0 {
return res, errors.New("排序参数需为正整数")
@ -76,6 +75,7 @@ func SaveBundle(req *bundle.BundleProfile) (res *bundle.SaveResponse, err error)
BgImg1: req.BgImg1,
BgImg2: req.BgImg2,
ShelfStatus: 2, //默认初始状态为2-下架
FontColor: req.FontColor,
}
bundleLang := &model.BundleProfileLang{
Name: req.Name,
@ -87,50 +87,32 @@ func SaveBundle(req *bundle.BundleProfile) (res *bundle.SaveResponse, err error)
if req.Uuid == "" && req.Language != msg.ZH_CN {
return res, errors.New("请先创建中文版本套餐")
}
var existValueService = make(map[string]string)
if req.Uuid != "" {
valueService, existErr := dao.GetValueAddServiceUuidsByBundleUuid(req.Uuid)
if existErr != nil {
return res, existErr
}
if valueService != nil && len(valueService) > 0 {
for _, v := range valueService {
existValueService[v] = v
}
}
}
var cancelValueAddService = make(map[string]string)
// var existValueService = make(map[string]string)
// if req.Uuid != "" {
// valueService, existErr := dao.GetValueAddServiceUuidsByBundleUuid(req.Uuid)
// if existErr != nil {
// return res, errors.New("查询增值服务失败")
// }
// if valueService != nil && len(valueService) > 0 {
// for _, v := range valueService {
// existValueService[v] = v
// }
// }
// }
selectService := make([]*model.BundleToValueAddService, 0)
var selectValueAddServiceCount = make(map[int]struct{})
var selectValueAddServiceCount = make(map[int]struct{}) //增值服务类型数量
if req.Language == msg.ZH_CN && req.SelectValueAddService != nil && len(req.SelectValueAddService) > 0 {
for _, v := range req.SelectValueAddService {
detail, checkErr := dao.ValueAddServiceDetailByUuidAndLanguage(v.ValueAddUuid, req.Language)
if checkErr != nil {
if checkErr == gorm.ErrRecordNotFound {
return res, errors.New(fmt.Sprintf("所选增值服务[%s]%s版不存在,请先创建对应增值套餐", v.ServiceName, req.Language))
return res, errors.New("增值服务不存在")
} else {
return res, checkErr
}
}
if detail.PriceType != req.PriceType {
if req.Uuid == "" {
//中文套餐创建时，币种不一致直接返回错误
return res, errors.New(fmt.Sprintf("所选增值服务[%s]%s币种与套餐币种不一致", detail.ServiceName, req.Language))
} else {
//更新时，判断是否已存在，存在则取消关联
_, ok := existValueService[v.ValueAddUuid]
if ok {
cancelValueAddService[v.ValueAddUuid] = detail.ServiceName
continue
} else {
//币种不一致，新加币种时返回错误
return res, errors.New(fmt.Sprintf("所选增值服务[%s]%s币种与套餐币种不一致", detail.ServiceName, req.Language))
}
return res, errors.New("查询增值服务失败")
}
}
if _, exists := selectValueAddServiceCount[int(detail.ServiceType)]; exists {
return res, errors.New(fmt.Sprintf("所选增值服务[%s]类型存在多个", detail.ServiceName))
return res, errors.New("每种增值服务类型只可选择一个")
}
selectValueAddServiceCount[int(detail.ServiceType)] = struct{}{}
selectService = append(selectService, &model.BundleToValueAddService{
@ -150,9 +132,6 @@ func SaveBundle(req *bundle.BundleProfile) (res *bundle.SaveResponse, err error)
_, err = dao.BundleDetailByUuidAndLanguage(req.Uuid, req.Language)
if err != nil {
if err == gorm.ErrRecordNotFound {
// if req.Uuid != "" {
// return res, errors.New("套餐不存在")
// }
if req.Language != msg.ZH_CN {
_, err = dao.BundleDetailByUuidAndLanguage(req.Uuid, msg.ZH_CN)
if err != nil {
@ -160,14 +139,14 @@ func SaveBundle(req *bundle.BundleProfile) (res *bundle.SaveResponse, err error)
res.Msg = "请先创建中文版本套餐"
return res, errors.New("请先创建中文版本套餐")
} else {
return res, err
return res, errors.New("获取套餐信息失败")
}
}
}
if req.Language == msg.ZH_CN {
bundleProfile.UUID = utils.GetUUID()
if err = dao.TxCreateBundle(tx, bundleProfile); err != nil {
return res, errors.New("保存中文语言套餐失败: " + err.Error())
return res, errors.New("创建套餐信息失败")
}
bundleLang.UUID = bundleProfile.UUID
res.Uuid = bundleProfile.UUID
@ -177,39 +156,29 @@ func SaveBundle(req *bundle.BundleProfile) (res *bundle.SaveResponse, err error)
}
if len(selectService) > 0 {
if err = dao.CreateBundleToValueAddService(tx, selectService); err != nil {
return res, errors.New("保存套餐与增值服务关联失败: " + err.Error())
return res, errors.New("保存套餐与增值服务关联失败")
}
}
} else {
bundleLang.UUID = req.Uuid
res.Uuid = req.Uuid
valueUuid, err1 := dao.GetValueAddServiceUuidsByBundleUuid(bundleLang.UUID)
if err1 != nil {
return res, err1
if err = dao.TxCreateBundleLang(tx, bundleLang); err != nil {
return res, errors.New("创建套餐信息失败")
}
count := 0
if valueUuid != nil && len(valueUuid) > 0 {
for _, v := range valueUuid {
//可以改成批量获取
valueDetail, err2 := dao.ValueAddServiceDetailByUuidAndLanguage(v, req.Language)
if err2 != nil {
return res, err2
}
if valueDetail.PriceType != req.PriceType {
if err = tx.Where("bundle_uuid =? AND value_uid =?", bundleLang.UUID, v).Delete(&model.BundleToValueAddService{}).Error; err != nil {
return res, errors.New("删除套餐与增值服务关联失败: " + err.Error())
}
count++
}
}
}
langList := []string{msg.ZH_TW, msg.EN, msg.DE_DE, msg.JA_JP}
for _, lang := range langList {
otherLang := &model.BundleProfileLang{
UUID: bundleLang.UUID,
Name: bundleLang.Name,
Content: bundleLang.Content,
Price: bundleLang.Price,
PriceType: bundleLang.PriceType,
}
otherLang.Language = lang
if err = dao.TxCreateBundleLang(tx, otherLang); err != nil {
return res, errors.New("创建套餐信息失败")
}
res.CancelNum = int64(count)
}
if err = dao.TxCreateBundleLang(tx, bundleLang); err != nil {
return res, errors.New("保存语言套餐失败: " + err.Error())
}
res.Msg = "保存成功"
return res, nil
res.Msg = "创建套餐信息成功"
return
} else {
return
}
@ -219,20 +188,7 @@ func SaveBundle(req *bundle.BundleProfile) (res *bundle.SaveResponse, err error)
if saveErr := saveBundleHistory(tx, req.Uuid, "", 0); saveErr != nil {
return res, saveErr
}
if req.Language == msg.ZH_CN {
if len(cancelValueAddService) > 0 {
cancel := "以下增值服务:"
for _, v := range cancelValueAddService {
cancel += fmt.Sprintf("[%s]%s", v, req.Language)
if err = tx.Where("bundle_uuid = ? AND value_uid = ?", req.Uuid, v).Delete(&model.BundleToValueAddService{}).Error; err != nil {
return res, errors.New("删除套餐与增值服务关联失败: " + err.Error())
}
}
cancel += "版币种与套餐币种不一致"
res.Msg = "保存cn成功 " + cancel
}
res.CancelNum = int64(len(cancelValueAddService))
updateBundle := map[string]interface{}{
"name": req.Name,
"sort": req.Sort,
@ -242,47 +198,15 @@ func SaveBundle(req *bundle.BundleProfile) (res *bundle.SaveResponse, err error)
"img_option": req.ImgOption,
"bg_img1": req.BgImg1,
"bg_img2": req.BgImg2,
"font_color": req.FontColor,
}
if err = dao.TxUpdateBundle(tx, req.Uuid, updateBundle); err != nil {
return res, err
return res, errors.New("更新套餐信息失败")
}
// 更新中间表函数
//更新中间表函数
if err = diffUpdateBundleToValueAddService(tx, req.Uuid, selectService); err != nil {
tx.Rollback()
return res, err
}
} else {
//更新其他语言时 先获取所有关联增值服务，判断币种是否一致，不一致则取消关联
valueAddService, err := dao.GetBundleToValueAddServiceByBundleUuid(req.Uuid)
if err != nil {
return res, err
}
cancelValueService := make(map[string]string)
for _, v := range valueAddService {
detail, checkErr := dao.ValueAddServiceDetailByUuidAndLanguage(v.ValueUid, req.Language)
if checkErr != nil {
if checkErr == gorm.ErrRecordNotFound {
continue
} else {
return res, checkErr
}
}
if detail.PriceType != req.PriceType {
cancelValueService[v.ValueUid] = detail.ServiceName
continue
}
}
if int64(len(cancelValueService)) > 0 {
cancel := "以下增值服务:"
for k, v := range cancelValueService {
cancel += fmt.Sprintf("[%s]%s", v, req.Language)
if err = tx.Where("bundle_uuid = ? AND value_uid = ?", req.Uuid, k).Delete(&model.BundleToValueAddService{}).Error; err != nil {
return res, errors.New("删除套餐与增值服务关联失败: " + err.Error())
}
}
cancel += "版币种与套餐币种不一致,已取消相关关联"
res.Msg = "保存成功 " + cancel
res.CancelNum = int64(len(cancelValueService))
return res, errors.New("更新套餐与增值服务关联失败")
}
}
updateBundleLang := map[string]interface{}{
@ -292,13 +216,10 @@ func SaveBundle(req *bundle.BundleProfile) (res *bundle.SaveResponse, err error)
"price_type": req.PriceType,
}
if err = dao.TxUpdateBundleLang(tx, req.Uuid, req.Language, updateBundleLang); err != nil {
return res, err
return res, errors.New("更新套餐信息失败")
}
res.Uuid = req.Uuid
if res.Msg == "" {
res.Msg = "保存成功"
}
res.Msg = "保存成功"
}
return res, nil
}
@ -306,7 +227,10 @@ func SaveBundle(req *bundle.BundleProfile) (res *bundle.SaveResponse, err error)
func BundleListV2(req *bundle.BundleListRequest) (res *bundle.BundleListResponse, err error) {
res = new(bundle.BundleListResponse)
res, err = dao.BundleListV2(req)
return
if err != nil {
return res, errors.New("获取套餐列表失败")
}
return res, nil
}
func BundleDetailV2(req *bundle.BundleDetailRequest) (res *bundle.BundleDetailResponseV2, err error) {
res = new(bundle.BundleDetailResponseV2)
@ -314,14 +238,11 @@ func BundleDetailV2(req *bundle.BundleDetailRequest) (res *bundle.BundleDetailRe
bundleProfileLangs := make([]*bundle.BundleProfileLang, 0)
selectValueAddServices := make([]*bundle.SelectValueAddService, 0) //已选增值服务
if req.Uuid == "" {
return res, errors.New("uuid不能为空")
return res, errors.New("缺少套餐UUID")
}
// if req.Language == "" {
// return res, errors.New("language不能为空")
// }
detail, err := dao.BundleDetailV2(req)
if err != nil {
res.Msg = err.Error()
return res, errors.New("获取套餐信息失败")
}
if detail != nil {
bundleProfile.Uuid = detail.UUID
@ -332,88 +253,171 @@ func BundleDetailV2(req *bundle.BundleDetailRequest) (res *bundle.BundleDetailRe
bundleProfile.ImgOption = int32(detail.ImgOption)
bundleProfile.BgImg1 = detail.BgImg1
bundleProfile.BgImg2 = detail.BgImg2
bundleProfile.FontColor = detail.FontColor
bundleProfile.Sort = detail.Sort
bundleProfile.ShelfStatus = detail.ShelfStatus
bundleProfile.CreatedAt = detail.CreatedAt.Format("2006-01-02 15:04:05")
bundleProfile.UpdatedAt = detail.UpdatedAt.Format("2006-01-02 15:04:05")
bundleProfile.Contract = detail.Contract
if detail.BundleToValueAddService != nil && len(detail.BundleToValueAddService) > 0 {
if len(detail.BundleToValueAddService) > 0 {
for _, valueAddService := range detail.BundleToValueAddService {
valueAddDetail, err := dao.ValueAddServiceDetailByUuidAndLanguage(valueAddService.ValueUid, req.Language)
if err != nil {
return res, errors.New("查询增值服务失败")
}
selectValueAddService := &bundle.SelectValueAddService{
ValueAddUuid: valueAddService.ValueUid,
IsDisplay: valueAddService.IsDisplay,
ServiceName: valueAddDetail.ServiceName,
ServiceType: valueAddDetail.ServiceType,
}
selectValueAddServices = append(selectValueAddServices, selectValueAddService)
}
}
if detail.BundleProfileLang != nil && len(detail.BundleProfileLang) > 0 {
if len(detail.BundleProfileLang) > 0 {
for _, lang := range detail.BundleProfileLang {
bundleProfileLang := &bundle.BundleProfileLang{
Uuid: lang.UUID,
Name: lang.Name,
Price: lang.Price,
PriceType: lang.PriceType,
Content: lang.Content,
Language: lang.Language,
CreatedAt: time.Unix(lang.CreatedAt, 0).Format("2006-01-02 15:04:05"),
UpdatedAt: time.Unix(int64(lang.UpdatedAt), 0).Format("2006-01-02 15:04:05"),
Uuid: lang.UUID,
Name: lang.Name,
Price: lang.Price,
PriceType: lang.PriceType,
Content: lang.Content,
Language: lang.Language,
ImgOption: int32(detail.ImgOption),
BgImg1: detail.BgImg1,
BgImg2: detail.BgImg2,
FontColor: detail.FontColor,
Sort: detail.Sort,
ShelfStatus: detail.ShelfStatus,
CreatedAt: time.Unix(lang.CreatedAt, 0).Format("2006-01-02 15:04:05"),
UpdatedAt: time.Unix(int64(lang.UpdatedAt), 0).Format("2006-01-02 15:04:05"),
}
// 通过中间表拼接增值服务数据
// if detail.BundleToValueAddService != nil && len(detail.BundleToValueAddService) > 0 {
// for _, valueAddService := range detail.BundleToValueAddService {
// valueAddDeatilData, err := dao.ValueAddServiceDetailByUuidAndLanguage(valueAddService.ValueUid, bundleProfileLang.Language)
// if err != nil {
// return res, err
// }
//if valueAddService.IsDisplay{}
// ValueAddServiceLang := &bundle.ValueAddServiceLang{
// Uuid: valueAddDeatilData.UUID,
// ServiceName: valueAddDeatilData.ServiceName,
// ServiceType: int32(valueAddDeatilData.ServiceType),
// PriceMode: int32(valueAddDeatilData.PriceMode),
// PriceType: int64(valueAddDeatilData.PriceType),
// OriginalPrice: fmt.Sprintf("%.2f", float32(valueAddDeatilData.OriginalPrice)),
// Unit: string(valueAddDeatilData.Unit),
// Language: valueAddDeatilData.Language,
// CreatedAt: time.Unix(valueAddDeatilData.CreatedAt, 0).Format("2006-01-02 15:04:05"),
// UpdatedAt: time.Unix(valueAddDeatilData.UpdatedAt, 0).Format("2006-01-02 15:04:05"),
// }
//bundleProfileLang.ValueAddServiceLang = append(bundleProfileLang.ValueAddServiceLang, ValueAddServiceLang)
// selectValueAddService = append(selectValueAddService, &bundle.SelectValueAddService{
// ValueAddUuid: valueAddService.ValueUid,
// ServiceName: valueAddDeatilData.ServiceName,
// IsDisplay: valueAddService.IsDisplay,
// })
// }
// }
bundleProfileLangs = append(bundleProfileLangs, bundleProfileLang)
}
}
}
if selectValueAddServices != nil && len(selectValueAddServices) > 0 {
if len(selectValueAddServices) > 0 {
bundleProfile.SelectValueAddService = selectValueAddServices
}
bundleProfile.BundleProfileLang = bundleProfileLangs
res.Bundle = bundleProfile
return
}
func HandleShelf(req *bundle.HandShelfRequest) (res *bundle.CommonResponse, err error) {
res = new(bundle.CommonResponse)
func BundleLangDetailV2(req *bundle.BundleDetailRequest) (res *bundle.BundleProfileLang, err error) {
res = new(bundle.BundleProfileLang)
if req.Uuid == "" {
return res, errors.New("uuid不能为空")
return res, errors.New("缺少套餐UUID")
}
if req.Language == "" {
return res, errors.New("language不能为空")
}
detail, err := dao.BundleDetailV2(req)
if err != nil {
return res, errors.New("获取套餐信息失败")
}
lang, err := dao.BundleDetailByUuidAndLanguage(req.Uuid, req.Language)
if err != nil {
return res, errors.New("获取套餐信息失败")
}
if detail != nil {
res.Uuid = detail.UUID
res.ImgOption = int32(detail.ImgOption)
res.BgImg1 = detail.BgImg1
res.BgImg2 = detail.BgImg2
res.FontColor = detail.FontColor
res.Sort = detail.Sort
res.ShelfStatus = detail.ShelfStatus
res.Contract = detail.Contract
}
if lang != nil {
res.Name = lang.Name
res.Price = lang.Price
res.PriceType = lang.PriceType
res.Content = lang.Content
res.Language = lang.Language
res.CreatedAt = time.Unix(lang.CreatedAt, 0).Format("2006-01-02 15:04:05")
res.UpdatedAt = time.Unix(int64(lang.UpdatedAt), 0).Format("2006-01-02 15:04:05")
}
return
}
func HandleShelf(req *bundle.HandShelfRequest) (*bundle.CommonResponse, error) {
res := new(bundle.CommonResponse)
if req.Uuid == "" {
return res, errors.New("缺少套餐UUID")
}
if req.ShelfStatus != 1 && req.ShelfStatus != 2 {
return res, errors.New("Invalid shelf status")
return res, errors.New("状态值无效")
}
detail, err := dao.GetBundleDetailByUuid(req.Uuid)
if err != nil {
return res, errors.New("获取套餐信息失败")
}
if detail.ShelfStatus == req.ShelfStatus {
switch detail.ShelfStatus {
case 1:
return res, errors.New("套餐已上架,请勿重复操作")
case 2:
return res, errors.New("套餐已下架,请勿重复操作")
}
}
bundleDetailLangs, err := dao.GetBundleLangsByUuid(req.Uuid)
if err != nil {
return res, errors.New("获取套餐信息失败")
}
var langToPriceType = make(map[string]int64)
for _, bundleLang := range bundleDetailLangs {
langToPriceType[bundleLang.Language] = bundleLang.PriceType
}
tx := app.ModuleClients.BundleDB.Begin()
defer func() {
if err != nil {
tx.Rollback()
} else {
tx.Commit()
}
}()
if req.ShelfStatus == 1 {
valueAddUuids, err := dao.GetValueAddServiceUuidsByBundleUuid(req.Uuid)
if err != nil {
return res, errors.New("查询增值服务失败")
}
//判断时长类型是否存在
isExist := false
for _, valueUid := range valueAddUuids {
detail, err := dao.ValueAddServiceDetail(valueUid)
if err != nil {
return res, errors.New("查询增值服务失败")
}
if detail.ServiceType == 5 {
isExist = true
break
}
}
if !isExist {
return res, errors.New("缺失可用时长服务类型")
}
//校验币种
valueAddServices, er := dao.BatchValueAddServiceDetailTx(tx, valueAddUuids)
if er != nil {
return res, errors.New("查询增值服务详情失败")
}
for _, valueAddService := range valueAddServices {
if len(valueAddService.ValueAddServiceLang) > 0 {
for _, lang := range valueAddService.ValueAddServiceLang {
if langToPriceType[lang.Language] != lang.PriceType {
return res, errors.New("所选增值服务币种与套餐币种不一致")
}
}
}
}
}
res, err = dao.HandShelf(req.Uuid, req.ShelfStatus)
if err != nil {
res.Msg = err.Error()
return res, err
return res, errors.New("更新套餐状态失败")
}
res.Msg = "Operation success"
res.Msg = "更新成功"
return res, nil
}
@ -421,7 +425,7 @@ func HandleShelf(req *bundle.HandShelfRequest) (res *bundle.CommonResponse, err
func diffUpdateBundleToValueAddService(tx *gorm.DB, bundleUuid string, selectService []*model.BundleToValueAddService) error {
oldUuids, err := dao.GetValueAddServiceUuidsByBundleUuid(bundleUuid)
if err != nil {
return errors.New("查询旧套餐与增值服务关联失败: " + err.Error())
return errors.New("查询套餐与增值服务关联失败")
}
newUuids := make(map[string]*model.BundleToValueAddService)
for _, s := range selectService {
@ -433,14 +437,18 @@ func diffUpdateBundleToValueAddService(tx *gorm.DB, bundleUuid string, selectSer
}
// 需要新增的
toAdd := make([]*model.BundleToValueAddService, 0)
toDel := make([]string, 0)
toUpdate := make([]*model.BundleToValueAddService, 0)
for uid, s := range newUuids {
if _, exist := oldSet[uid]; !exist {
s.BundleUuid = bundleUuid
toAdd = append(toAdd, s)
} else {
s.BundleUuid = bundleUuid
toUpdate = append(toUpdate, s)
}
}
// 需要删除的
toDel := make([]string, 0)
for _, uid := range oldUuids {
if _, exist := newUuids[uid]; !exist {
toDel = append(toDel, uid)
@ -448,12 +456,23 @@ func diffUpdateBundleToValueAddService(tx *gorm.DB, bundleUuid string, selectSer
}
if len(toDel) > 0 {
if err = tx.Where("bundle_uuid = ? AND value_uid IN ?", bundleUuid, toDel).Delete(&model.BundleToValueAddService{}).Error; err != nil {
return errors.New("删除套餐与增值服务关联失败: " + err.Error())
return errors.New("删除套餐与增值服务关联失败")
}
}
if len(toAdd) > 0 {
if err = dao.CreateBundleToValueAddService(tx, toAdd); err != nil {
return errors.New("保存套餐与增值服务关联失败: " + err.Error())
return errors.New("保存套餐与增值服务关联失败")
}
}
if len(toUpdate) > 0 {
updates := make(map[string]interface{})
var uids []string
for _, record := range toUpdate {
uids = append(uids, record.ValueUid)
updates["is_display"] = record.IsDisplay
}
if err = dao.UpdateBundleToValueAddService(tx, toUpdate); err != nil {
return errors.New("保存套餐与增值服务关联失败")
}
}
return nil
@ -462,27 +481,27 @@ func saveBundleHistory(tx *gorm.DB, bundleUuid string, operator string, operator
// 保存历史记录
data, err := dao.GetBundleDetailByUuid(bundleUuid)
if err != nil {
return errors.New("查询套餐详情失败: " + err.Error())
return errors.New("获取套餐信息失败")
}
bundleToValueAddService := data.BundleToValueAddService
data.BundleToValueAddService = nil
var valueUuid []string
if bundleToValueAddService != nil && len(bundleToValueAddService) > 0 {
if len(bundleToValueAddService) > 0 {
for _, v := range bundleToValueAddService {
valueUuid = append(valueUuid, v.ValueUid)
}
}
valueData, err := dao.BatchValueAddServiceDetailTx(tx, valueUuid)
if err != nil {
return errors.New("查询增值服务详情失败: " + err.Error())
return errors.New("查询增值服务详情失败")
}
j, err := json.Marshal(data)
if err != nil {
return errors.New("套餐json转换失败: " + err.Error())
return errors.New("序列化转换失败")
}
vJ, err := json.Marshal(valueData)
if err != nil {
return errors.New("增值服务json转换失败: " + err.Error())
return errors.New("序列化转换失败")
}
history := &model.BundleProfileHistory{
Uuid: bundleUuid,
@ -492,7 +511,17 @@ func saveBundleHistory(tx *gorm.DB, bundleUuid string, operator string, operator
OperatorId: operatorId,
}
if err := tx.Create(history).Error; err != nil {
return errors.New("保存套餐历史记录失败: " + err.Error())
return errors.New("保存套餐历史记录失败")
}
return nil
}
// 增加h5套餐列表
func BundleListH5V2(req *bundle.BundleListRequest) (res *bundle.BundleListResponse, err error) {
res = new(bundle.BundleListResponse)
res, err = dao.BundleListH5V2(req)
if err != nil {
return res, errors.New("获取套餐列表失败")
}
return res, nil
}

219
internal/logic/valueAddBundleLogic.go
View File

@ -147,14 +147,31 @@ func ValueAddBundleDetail(req *bundle.ValueAddBundleDetailRequest) (res *bundle.
func SaveValueAddService(in *bundle.ValueAddServiceLang) (res *bundle.SaveResponse, err error) {
res = &bundle.SaveResponse{}
if in.Language == "" {
return res, errors.New("语言参数不能为空")
return res, errors.New("语言不能为空")
}
var options model.PriceOptions
var originalPrice float64
if in.PriceMode == 1 {
if in.OriginalPrice == "" {
return res, errors.New("原价不能为空")
}
originalPrice, err = strconv.ParseFloat(in.OriginalPrice, 32)
if err != nil {
return res, errors.New("原价格式转换失败")
}
}
index := 1
for _, option := range in.Options {
price, parseErr := strconv.ParseFloat(option.Price, 32)
if parseErr != nil {
return res, parseErr
price, parseErr1 := strconv.ParseFloat(option.Price, 32)
if parseErr1 != nil {
fmt.Println("优惠单价转换失败: ", parseErr1)
return res, errors.New("优惠单价转换失败")
}
if option.Num < 0 || option.Num > 99 {
return res, errors.New("数量参数需为0-99")
}
if in.PriceMode == 1 && price > originalPrice {
return res, errors.New("优惠单价需小于等于原价")
}
options = append(options, &model.PriceOption{
Id: int32(index),
@ -172,10 +189,6 @@ func SaveValueAddService(in *bundle.ValueAddServiceLang) (res *bundle.SaveRespon
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,
@ -187,7 +200,7 @@ func SaveValueAddService(in *bundle.ValueAddServiceLang) (res *bundle.SaveRespon
Options: options,
}
if in.Uuid == "" && in.Language != msg.ZH_CN {
return res, errors.New("请先新增简体中文套餐，再添加其他语言版本")
return res, errors.New("请先创建中文版本增值服务")
}
tx := app.ModuleClients.BundleDB.Begin()
defer func() {
@ -205,7 +218,7 @@ func SaveValueAddService(in *bundle.ValueAddServiceLang) (res *bundle.SaveRespon
_, err = dao.ValueAddServiceDetailByUuidAndLanguage(in.Uuid, msg.ZH_CN)
if err != nil {
if err != gorm.ErrRecordNotFound {
return res, errors.New("请先创建中文套餐")
return res, errors.New("请先创建中文版本增值服务")
} else {
// // 新语言补充：只要UUID存在即可直接插入新语言
// if in.Uuid != "" {
@ -225,15 +238,15 @@ func SaveValueAddService(in *bundle.ValueAddServiceLang) (res *bundle.SaveRespon
valueAddService.UUID = utils.GetUUID()
err = dao.CreateValueAddService(tx, valueAddService)
if err != nil {
return res, errors.New("保存中文语言套餐失败: " + err.Error())
return res, errors.New("保存增值服务失败")
}
valueAddServiceLang.UUID = valueAddService.UUID
res.Uuid = valueAddService.UUID
if err = dao.CreateValueAddServiceLang(tx, valueAddServiceLang); err != nil {
return res, errors.New("保存语言套餐失败: " + err.Error())
return res, errors.New("保存增值服务失败")
}
}
langList := []string{msg.ZH_TW, msg.EN, msg.DE_DE, msg.JS_JP}
langList := []string{msg.ZH_TW, msg.EN, msg.DE_DE, msg.JA_JP}
for _, lang := range langList {
otherLang := model.ValueAddServiceLang{
UUID: valueAddServiceLang.UUID,
@ -249,18 +262,18 @@ func SaveValueAddService(in *bundle.ValueAddServiceLang) (res *bundle.SaveRespon
}
otherLang.Language = lang
if err = dao.CreateValueAddServiceLang(tx, &otherLang); err != nil {
return res, errors.New(fmt.Sprintf("保存%s语言套餐失败: ", lang) + err.Error())
return res, errors.New("保存增值服务失败")
}
}
res.Msg = "保存成功"
res.Msg = "新增增值服务成功"
return
} else {
return
}
} else {
// 已存在，进行更新
if err := saveValueAddServiceHistory(tx, in.Uuid); err != nil {
return res, err
if err = saveValueAddServiceHistory(tx, in.Uuid); err != nil {
return res, errors.New("保存增值服务历史记录失败")
}
//中文状态下，更新主表和语言表
if in.Language == msg.ZH_CN {
@ -270,17 +283,7 @@ func SaveValueAddService(in *bundle.ValueAddServiceLang) (res *bundle.SaveRespon
"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++
return res, errors.New("更新增值服务失败")
}
}
//更新语言表
@ -296,11 +299,26 @@ func SaveValueAddService(in *bundle.ValueAddServiceLang) (res *bundle.SaveRespon
"language": in.Language,
}
if err := dao.UpdateValueAddServiceLang(tx, updateLangService); err != nil {
return res, err
return res, errors.New("更新增值服务失败")
}
data, err := dao.GetBundleToValueAddServiceByValueUid(in.Uuid)
if err != nil {
return res, errors.New("获取套餐信息失败")
}
bundleUuids := []string{}
if len(data) > 0 {
for _, bundle := range data {
bundleUuids = append(bundleUuids, bundle.BundleUuid)
}
}
columns := map[string]interface{}{
"updated_at": time.Now(),
}
if err = dao.TxUpdateBundles(tx, bundleUuids, columns); err != nil {
return res, errors.New("更新套餐信息失败")
}
res.Uuid = in.Uuid
res.Msg = "保存成功"
res.CancelNum = cancelNum
}
return
}
@ -310,8 +328,7 @@ func ValueAddServiceList(req *bundle.ValueAddServiceListRequest) (res *bundle.Va
res = &bundle.ValueAddServiceListResponse{}
list, total, err := dao.ValueAddServiceList(req)
if err != nil {
res.Msg = msg.ErrorValueAddServiceList
return res, err
return res, errors.New("查询增值服务列表失败")
}
for _, valueAddService := range list {
serviceInfo := &bundle.ValueAddService{
@ -332,19 +349,22 @@ func ValueAddServiceList(req *bundle.ValueAddServiceListRequest) (res *bundle.Va
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 {
if len(serviceLang.Options) > 0 {
var options []*bundle.ValueAddPriceOptions
for _, option := range serviceLang.Options {
var saveAmount decimal.Decimal
if serviceLang.PriceMode == 1 {
switch serviceLang.PriceMode {
case 1:
original := decimal.NewFromFloat(float64(serviceLang.OriginalPrice))
price := decimal.NewFromFloat(float64(option.Price))
num := decimal.NewFromInt(int64(option.Num))
saveAmount = original.Sub(price).Mul(num)
} else if serviceLang.PriceMode == 2 {
original := decimal.NewFromFloat(float64(serviceLang.OriginalPrice))
price := decimal.NewFromFloat(float64(option.Price))
saveAmount = original.Sub(price)
case 2:
//original := decimal.NewFromFloat(float64(serviceLang.OriginalPrice))
//price := decimal.NewFromFloat(float64(option.Price))
saveAmount = decimal.NewFromInt(int64(0))
default:
return nil, errors.New("无效的价格模式")
}
options = append(options, &bundle.ValueAddPriceOptions{
Id: int64(option.Id),
@ -361,7 +381,6 @@ func ValueAddServiceList(req *bundle.ValueAddServiceListRequest) (res *bundle.Va
res.ValueAddServiceList = append(res.ValueAddServiceList, serviceInfo)
}
res.Total = int32(total)
res.Msg = msg.SuccessValueAddServiceList
return
}
@ -373,7 +392,7 @@ func ValueAddServiceDetail(req *bundle.ValueAddServiceDetailRequest) (res *bundl
serviceLangs := []*bundle.ValueAddServiceLang{}
if req.Uuid == "" {
res.Msg = msg.ErrorValueAddServiceInfo
return res, errors.New("uuid不能为空")
return res, errors.New("缺少套餐UUID")
}
// if req.Language == "" {
// res.Msg = msg.ErrorValueAddServiceInfo
@ -381,8 +400,7 @@ func ValueAddServiceDetail(req *bundle.ValueAddServiceDetailRequest) (res *bundl
// }
detail, err := dao.ValueAddServiceDetail(req.Uuid)
if err != nil {
res.Msg = msg.ErrorValueAddServiceInfo
return res, err
return res, errors.New("查询增值服务详情失败")
}
if detail != nil && len(detail.ValueAddServiceLang) > 0 {
valueAddService.Uuid = detail.UUID
@ -390,18 +408,21 @@ func ValueAddServiceDetail(req *bundle.ValueAddServiceDetailRequest) (res *bundl
valueAddService.ServiceType = detail.ServiceType
for _, serviceLang := range detail.ValueAddServiceLang {
langOptions := []*bundle.ValueAddPriceOptions{}
if serviceLang.Options != nil && len(serviceLang.Options) > 0 {
if len(serviceLang.Options) > 0 {
for _, opt := range serviceLang.Options {
var saveAmount decimal.Decimal
if serviceLang.PriceMode == 1 {
switch serviceLang.PriceMode {
case 1:
original := decimal.NewFromFloat(float64(serviceLang.OriginalPrice))
price := decimal.NewFromFloat(float64(opt.Price))
num := decimal.NewFromInt(int64(opt.Num))
saveAmount = original.Sub(price).Mul(num)
} else if serviceLang.PriceMode == 2 {
original := decimal.NewFromFloat(float64(serviceLang.OriginalPrice))
price := decimal.NewFromFloat(float64(opt.Price))
saveAmount = original.Sub(price)
case 2:
//original := decimal.NewFromFloat(float64(serviceLang.OriginalPrice))
//price := decimal.NewFromFloat(float64(opt.Price))
saveAmount = decimal.NewFromInt(int64(0))
default:
return nil, errors.New("无效的价格模式")
}
langOptions = append(langOptions, &bundle.ValueAddPriceOptions{
Id: int64(opt.Id),
@ -429,9 +450,7 @@ func ValueAddServiceDetail(req *bundle.ValueAddServiceDetailRequest) (res *bundl
}
}
valueAddService.ServiceLang = serviceLangs
res.ValueAddService = valueAddService
res.Msg = msg.SuccessValueAddServiceInfo
return
}
@ -439,11 +458,11 @@ func saveValueAddServiceHistory(tx *gorm.DB, uuid string) (err error) {
// 保存历史记录
data, err := dao.GetValueAddServiceDetailByUuid(tx, uuid)
if err != nil {
return errors.New("查询增值服务详情失败: " + err.Error())
return errors.New("查询增值服务详情失败")
}
j, err := json.Marshal(data)
if err != nil {
return errors.New("json转换失败: " + err.Error())
return errors.New("序列化转换失败")
}
history := &model.ValueAddServiceHistory{
Uuid: uuid,
@ -452,33 +471,48 @@ func saveValueAddServiceHistory(tx *gorm.DB, uuid string) (err error) {
//OperatorId: operatorId,
}
if err := tx.Create(history).Error; err != nil {
return errors.New("保存增值服务历史记录失败: " + err.Error())
return errors.New("保存增值服务历史记录失败")
}
return nil
}
func ValueAddServiceDetailByUuidAndLanguage(req *bundle.ValueAddServiceDetailRequest) (res *bundle.ValueAddServiceLang, err error) {
res = &bundle.ValueAddServiceLang{}
if req.Uuid == "" {
return res, errors.New("uuid不能为空")
return res, errors.New("缺少套餐UUID")
}
if req.Language == "" {
return res, errors.New("语言选项不能为空")
return res, errors.New("语言不能为空")
}
detail, err := dao.ValueAddServiceDetailByUuidAndLanguage(req.Uuid, req.Language)
if err != nil {
return res, err
return res, errors.New("查询增值服务详情失败")
}
if detail == nil {
return res, errors.New("增值服务不存在")
}
langOptions := []*bundle.ValueAddPriceOptions{}
if detail.Options != nil && len(detail.Options) > 0 {
if len(detail.Options) > 0 {
for _, opt := range detail.Options {
var saveAmount decimal.Decimal
switch detail.PriceMode {
case 1:
original := decimal.NewFromFloat(float64(detail.OriginalPrice))
price := decimal.NewFromFloat(float64(opt.Price))
num := decimal.NewFromInt(int64(opt.Num))
saveAmount = original.Sub(price).Mul(num)
case 2:
//original := decimal.NewFromFloat(float64(detail.OriginalPrice))
//price := decimal.NewFromFloat(float64(opt.Price))
saveAmount = decimal.NewFromInt(int64(0))
default:
return nil, errors.New("无效的价格模式")
}
langOptions = append(langOptions, &bundle.ValueAddPriceOptions{
Id: int64(opt.Id),
Num: opt.Num,
Symbol: opt.Symbol,
Price: fmt.Sprintf("%.2f", opt.Price),
Id: int64(opt.Id),
Num: opt.Num,
Symbol: opt.Symbol,
Price: fmt.Sprintf("%.2f", opt.Price),
SaveAmount: saveAmount.StringFixed(2),
})
}
}
@ -492,20 +526,22 @@ func ValueAddServiceDetailByUuidAndLanguage(req *bundle.ValueAddServiceDetailReq
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"),
}
return
}
func CalculatePrice(req *bundle.CalculatePriceRequest) (res *bundle.CalculatePriceResponse, err error) {
res = &bundle.CalculatePriceResponse{}
if req.Uuid == "" {
return res, errors.New("uuid不能为空")
return res, errors.New("缺少套餐UUID")
}
if req.Language == "" {
return res, errors.New("语言选项不能为空")
return res, errors.New("语言不能为空")
}
detail, err := dao.ValueAddServiceDetailByUuidAndLanguage(req.Uuid, req.Language)
if err != nil {
return res, err
return res, errors.New("查询增值服务详情失败")
}
if detail == nil {
return res, errors.New("增值服务不存在")
@ -523,8 +559,61 @@ func CalculatePrice(req *bundle.CalculatePriceRequest) (res *bundle.CalculatePri
// }
price, err := detail.Options.CalculatePrice(detail.PriceMode, req.Num)
if err != nil {
return res, err
return res, errors.New("计算价格失败")
}
res.Price = price
return
}
func BatchGetValueAddServiceLang(req *bundle.BatchGetValueAddServiceLangRequest) (res *bundle.BatchGetValueAddServiceLangResponse, err error) {
res = &bundle.BatchGetValueAddServiceLangResponse{}
if len(req.Uuids) == 0 {
return res, errors.New("缺少套餐UUID")
}
if req.Language == "" {
return res, errors.New("语言不能为空")
}
detail, err := dao.BatchGetValueAddServiceLang(req.Uuids, req.Language)
if err != nil {
return res, errors.New("查询增值服务详情失败")
}
for _, v := range detail {
langOptions := []*bundle.ValueAddPriceOptions{}
if len(v.Options) > 0 {
for _, opt := range v.Options {
var saveAmount decimal.Decimal
switch v.PriceMode {
case 1:
original := decimal.NewFromFloat(float64(v.OriginalPrice))
price := decimal.NewFromFloat(float64(opt.Price))
num := decimal.NewFromInt(int64(opt.Num))
saveAmount = original.Sub(price).Mul(num)
case 2:
//original := decimal.NewFromFloat(float64(v.OriginalPrice))
//price := decimal.NewFromFloat(float64(opt.Price))
saveAmount = decimal.NewFromInt(int64(0))
default:
return nil, errors.New("无效的价格模式")
}
langOptions = append(langOptions, &bundle.ValueAddPriceOptions{
Id: int64(opt.Id),
Num: opt.Num,
Symbol: opt.Symbol,
Price: fmt.Sprintf("%.2f", opt.Price),
SaveAmount: saveAmount.StringFixed(2),
})
}
}
res.ValueAddServiceLangList = append(res.ValueAddServiceLangList, &bundle.ValueAddServiceLang{
Uuid: v.UUID,
ServiceName: v.ServiceName,
ServiceType: v.ServiceType,
Language: v.Language,
PriceMode: v.PriceMode,
OriginalPrice: fmt.Sprintf("%.2f", v.OriginalPrice),
Unit: v.Unit,
PriceType: int64(v.PriceType),
Options: langOptions,
})
}
return
}

5
internal/model/bundle.go
View File

@ -23,7 +23,8 @@ type BundleProfile struct {
Sort int64 `json:"sort" gorm:"column:sort;type:int;comment:套餐排序"` //数字越小越靠前，同大小后创建优先
ShelfStatus int64 `json:"shelfStatus" gorm:"column:shelf_status;type:int;default:2;comment:上架状态 1:上架 2:下架"`
ImgOption int8 `json:"imgOption" gorm:"column:img_option;type:int;default:1;comment:图片选择 1:背景图1 2 3"`
ImgOption int8 `json:"imgOption" gorm:"column:img_option;type:int;default:0;comment:图片选择 1:背景图1 2 3"`
FontColor string `json:"fontColor" gorm:"column:font_color;type:varchar(32);comment:字体颜色"`
BgImg1 string `json:"bgImg1" gorm:"column:bg_img1;type:varchar(1024);comment:背景图-首页"`
BgImg2 string `json:"bgImg2" gorm:"column:bg_img2;type:varchar(1024);comment:背景图-我的"`
BundleToValueAddService []BundleToValueAddService `gorm:"foreignKey:BundleUuid;references:UUID" json:"bundleToValueAddService"`
@ -36,7 +37,7 @@ type BundleProfileLang struct {
Price float32 `json:"price" gorm:"column:price;type:decimal(12,2);comment:套餐价格"`
PriceType int64 `json:"priceType" gorm:"column:price_type;type:int;comment:套餐类型 1:人民币 2:美元"`
Content string `json:"content" gorm:"column:content;type:text;comment:套餐内容"`
Language string `json:"language" gorm:"column:language;type:varchar(32);comment:套餐语言 zh-CN zh-TW EN de-DE js-JP(中繁英德日)"`
Language string `json:"language" gorm:"column:language;type:varchar(32);comment:套餐语言 zh-CN zh-TW EN de-DE ja-JP(中繁英德日)"`
CreatedAt int64 `gorm:"column:created_at;autoCreateTime"`
UpdatedAt int64 `gorm:"column:updated_at;autoCreateTime"`
DeletedAt soft_delete.DeletedAt

10
internal/model/valueAdd_bundle.go
View File

@ -53,7 +53,7 @@ type ValueAddServiceLang struct {
OriginalPrice float32 `json:"originalPrice" gorm:"column:original_price;type:decimal(12,2);comment:原单价"`
TotalPrice float32 `json:"totalPrice" gorm:"column:total_price;type:decimal(12,2);comment:增值服务总价"`
Unit string `json:"unit" gorm:"column:unit;type:varchar(50);comment:单位 1:个 2:条 3:天 4:月 5:年"`
Language string `json:"language" gorm:"column:language;type:varchar(32);comment:套餐语言 zh-CN zh-TW EN de-DE js-JP(中繁英德日)"`
Language string `json:"language" gorm:"column:language;type:varchar(32);comment:套餐语言 zh-CN zh-TW EN de-DE ja-JP(中繁英德日)"`
PriceType int64 `json:"priceType" gorm:"column:price_type;type:int;comment:币种 1:人民币 2:美元 3:日元 4:欧元"`
Options PriceOptions `gorm:"column:options;type:json" json:"options"`
CreatedAt int64 `gorm:"column:created_at;autoCreateTime"`
@ -76,7 +76,7 @@ type PriceOptions []*PriceOption
type PriceOption struct {
Id int32 `json:"id"`
Num int32 `json:"num"`
Symbol string `json:"symbol"` // 符号> < = <= =>
Symbol string `json:"symbol"` // 符号> < = >= <=
Price float32 `json:"price"` // 价格(根据priceMode决定是单价还是总价)
}
@ -100,7 +100,7 @@ func ValidateOptions(options PriceOptions) (bool, error) {
cover := make(map[int]struct{})
for _, opt := range options {
if opt.Num < 0 || opt.Num > 100 {
return false, errors.New("数字范围错误")
return false, errors.New("数量参数需为0-99")
}
if _, ok := symbolSet[opt.Symbol]; !ok {
@ -130,7 +130,7 @@ func ValidateOptions(options PriceOptions) (bool, error) {
}
for _, n := range nums {
if _, exist := cover[n]; exist {
return false, errors.New("逻辑存在冲突，请重新设置")
return false, errors.New("条件存在冲突,请重新设置")
}
cover[n] = struct{}{}
@ -166,7 +166,7 @@ func (options PriceOptions) CalculatePrice(priceMode, target int32) (float32, er
}
if match {
switch priceMode {
switch priceMode { //1 单价模式
case 1:
return float32(target) * opt.Price, nil
case 2:

2
pb/bundle/bundle.validator.pb.go
View File

@ -7,8 +7,8 @@ import (
fmt "fmt"
math "math"
proto "github.com/golang/protobuf/proto"
_ "google.golang.org/protobuf/types/descriptorpb"
_ "github.com/mwitkow/go-proto-validators"
_ "google.golang.org/protobuf/types/descriptorpb"
github_com_mwitkow_go_proto_validators "github.com/mwitkow/go-proto-validators"
)

2
pkg/msg/msg.go
View File

@ -15,7 +15,7 @@ const (
ZH_TW = "zh-TW" //繁体中文
EN = "EN" //英文
DE_DE = "de-DE" //德语
JS_JP = "js-JP" //日语
JA_JP = "ja-JP" //日语
)
const (