436 lines
21 KiB
Go
436 lines
21 KiB
Go
package logic
|
||
|
||
import (
|
||
"errors"
|
||
"micro-bundle/internal/dao"
|
||
"micro-bundle/internal/model"
|
||
"micro-bundle/pb/bundle"
|
||
"strconv"
|
||
"time"
|
||
|
||
"dubbo.apache.org/dubbo-go/v3/common/logger"
|
||
"github.com/jinzhu/copier"
|
||
"github.com/samber/lo"
|
||
)
|
||
|
||
func BundleExtend(req *bundle.BundleExtendRequest) (*bundle.BundleExtendResponse, error) {
|
||
data := model.BundleExtensionRecords{}
|
||
if err := copier.CopyWithOption(&data, req, copier.Option{DeepCopy: true}); err != nil {
|
||
return nil, err
|
||
}
|
||
if err := dao.ExtendBundleBalanceByUserId(model.BundleBalanceExtendPo{
|
||
UserId: int(req.UserId),
|
||
VideoNumber: int(req.VideoAdditional),
|
||
ImageNumber: int(req.ImagesAdditional),
|
||
DataAnalysisNumber: int(req.DataAdditional),
|
||
AccountNumber: int(req.AccountAdditional),
|
||
DurationNumber: int(req.DataAdditional),
|
||
}); err != nil {
|
||
return nil, errors.New("用户没有余量信息")
|
||
}
|
||
err := dao.AddBundleExtendRecord(data)
|
||
if err != nil {
|
||
logger.Error(err)
|
||
return nil, errors.New("创建扩展记录失败")
|
||
}
|
||
return nil, nil
|
||
}
|
||
|
||
func BundleExtendRecordsList(req *bundle.BundleExtendRecordsListRequest) (*bundle.BundleExtendRecordsListResponse, error) {
|
||
data, total, err := dao.GetBundleExtendRecordList(req)
|
||
if err != nil {
|
||
logger.Error(err)
|
||
return nil, errors.New("查询失败")
|
||
}
|
||
resp := &bundle.BundleExtendRecordsListResponse{}
|
||
resp.Total = total
|
||
resp.Data = lo.Map(data, func(m model.BundleExtendRecordItemPo, _ int) *bundle.BundleExtendRecordItem {
|
||
result := &bundle.BundleExtendRecordItem{}
|
||
copier.Copy(result, &m)
|
||
result.CreatedAt = uint64(m.CreatedAt.UnixMilli())
|
||
return result
|
||
})
|
||
return resp, nil
|
||
}
|
||
|
||
func GetBundleBalanceList(req *bundle.GetBundleBalanceListReq) (*bundle.GetBundleBalanceListResp, error) {
|
||
data, total, err := dao.GetBundleBalanceList(req)
|
||
if err != nil {
|
||
logger.Error(err)
|
||
return nil, errors.New("查询失败")
|
||
}
|
||
resp := &bundle.GetBundleBalanceListResp{}
|
||
resp.Total = total
|
||
date, err := time.Parse("2006-01", req.Month)
|
||
if err != nil {
|
||
return nil, errors.New("请求时间有误")
|
||
}
|
||
resp.Data = lo.Map(data, func(m model.BundleBalancePo, _ int) *bundle.BundleBalanceItem {
|
||
result := &bundle.BundleBalanceItem{
|
||
UserId: int32(m.UserId),
|
||
UserName: m.UserName,
|
||
UserPhoneNumber: m.UserPhoneNumber,
|
||
Status: int32(m.Status),
|
||
BundleName: m.BundleName,
|
||
ExpiredTime: m.ExpiredAt.UnixMilli(),
|
||
// 账号类
|
||
BundleAccountNumber: int32(m.BundleAccountNumber),
|
||
IncreaseAccountNumber: int32(m.IncreaseAccountNumber),
|
||
BundleAccountConsumptionNumber: int32(m.BundleAccountConsumptionNumber),
|
||
IncreaseAccountConsumptionNumber: int32(m.IncreaseAccountConsumptionNumber),
|
||
// 视频类
|
||
BundleVideoNumber: int32(m.BundleVideoNumber) + int32(m.BundleLimitVideoNumber) + int32(m.BundleLimitVideoExpiredNumber),
|
||
IncreaseVideoNumber: int32(m.IncreaseVideoNumber) + int32(m.IncreaseLimitVideoNumber) + int32(m.IncreaseLimitVideoExpiredNumber),
|
||
BundleVideoConsumptionNumber: int32(m.BundleVideoConsumptionNumber) + int32(m.BundleLimitVideoConsumptionNumber) + int32(m.BundleLimitVideoExpiredConsumptionNumber),
|
||
IncreaseVideoConsumptionNumber: int32(m.IncreaseVideoConsumptionNumber) + int32(m.IncreaseLimitVideoConsumptionNumber) + int32(m.IncreaseLimitVideoExpiredConsumptionNumber),
|
||
InvalidBundleVideoNumber: int32(m.InvalidBundleVideoNumber),
|
||
InvalidIncreaseVideoNumber: int32(m.InvalidIncreaseVideoNumber),
|
||
MonthlyNewBundleVideoNumber: int32(cal(m.BundleBalance, m.BundleLimitVideoNumber, m.MonthlyLimitVideoQuotaNumber, date) + cal(m.BundleBalance, m.BundleLimitVideoExpiredNumber, m.MonthlyLimitVideoQuotaNumber, date)),
|
||
MonthlyNewIncreaseVideoNumber: int32(cal(m.BundleBalance, m.IncreaseLimitVideoNumber, m.MonthlyLimitVideoQuotaNumber, date) + cal(m.BundleBalance, m.IncreaseLimitVideoExpiredNumber, m.MonthlyLimitVideoQuotaNumber, date)),
|
||
MonthlyInvalidBundleVideoNumber: int32(m.MonthlyInvalidBundleVideoNumber),
|
||
MonthlyInvalidIncreaseVideoNumber: int32(m.MonthlyInvalidIncreaseVideoNumber),
|
||
// 图文类
|
||
BundleImageNumber: int32(m.BundleImageNumber) + int32(m.BundleLimitImageNumber) + int32(m.BundleLimitImageExpiredNumber),
|
||
IncreaseImageNumber: int32(m.IncreaseImageNumber) + int32(m.IncreaseLimitImageNumber) + int32(m.IncreaseLimitImageExpiredNumber),
|
||
BundleImageConsumptionNumber: int32(m.BundleImageConsumptionNumber) + int32(m.BundleLimitImageConsumptionNumber) + int32(m.BundleLimitImageExpiredConsumptionNumber),
|
||
IncreaseImageConsumptionNumber: int32(m.IncreaseImageConsumptionNumber) + int32(m.IncreaseLimitImageConsumptionNumber) + int32(m.IncreaseLimitImageExpiredConsumptionNumber),
|
||
InvalidBundleImageNumber: int32(m.InvalidBundleImageNumber),
|
||
InvalidIncreaseImageNumber: int32(m.InvalidIncreaseImageNumber),
|
||
MonthlyNewBundleImageNumber: int32(cal(m.BundleBalance, m.BundleLimitImageNumber, m.MonthlyLimitImageQuotaNumber, date) + cal(m.BundleBalance, m.BundleLimitImageExpiredNumber, m.MonthlyLimitImageQuotaNumber, date)),
|
||
MonthlyNewIncreaseImageNumber: int32(cal(m.BundleBalance, m.IncreaseLimitImageNumber, m.MonthlyLimitImageQuotaNumber, date) + cal(m.BundleBalance, m.IncreaseLimitImageExpiredNumber, m.MonthlyLimitImageQuotaNumber, date)),
|
||
MonthlyInvalidBundleImageNumber: int32(m.MonthlyInvalidBundleImageNumber),
|
||
MonthlyInvalidIncreaseImageNumber: int32(m.MonthlyInvalidIncreaseImageNumber),
|
||
// 数据分析类
|
||
BundleDataAnalysisNumber: int32(m.BundleDataAnalysisNumber) + int32(m.BundleLimitDataAnalysisNumber) + int32(m.BundleLimitDataAnalysisExpiredNumber),
|
||
IncreaseDataAnalysisNumber: int32(m.IncreaseDataAnalysisNumber) + int32(m.IncreaseLimitDataAnalysisNumber) + int32(m.IncreaseLimitDataAnalysisExpiredNumber),
|
||
BundleDataAnalysisConsumptionNumber: int32(m.BundleDataAnalysisConsumptionNumber) + int32(m.BundleLimitDataAnalysisConsumptionNumber) + int32(m.BundleLimitDataAnalysisExpiredConsumptionNumber),
|
||
IncreaseDataAnalysisConsumptionNumber: int32(m.IncreaseDataAnalysisConsumptionNumber) + int32(m.IncreaseLimitDataAnalysisConsumptionNumber) + int32(m.IncreaseLimitDataAnalysisExpiredConsumptionNumber),
|
||
InvalidBundleDataAnalysisNumber: int32(m.InvalidBundleDataAnalysisNumber),
|
||
InvalidIncreaseDataAnalysisNumber: int32(m.InvalidIncreaseDataAnalysisNumber),
|
||
MonthlyNewBundleDataAnalysisNumber: int32(cal(m.BundleBalance, m.BundleLimitDataAnalysisNumber, m.MonthlyLimitDataAnalysisQuotaNumber, date) + cal(m.BundleBalance, m.BundleLimitDataAnalysisExpiredNumber, m.MonthlyLimitDataAnalysisQuotaNumber, date)),
|
||
MonthlyNewIncreaseDataAnalysisNumber: int32(cal(m.BundleBalance, m.IncreaseLimitDataAnalysisNumber, m.MonthlyLimitDataAnalysisQuotaNumber, date) + cal(m.BundleBalance, m.IncreaseLimitDataAnalysisExpiredNumber, m.MonthlyLimitDataAnalysisQuotaNumber, date)),
|
||
MonthlyInvalidBundleDataAnalysisNumber: int32(m.MonthlyInvalidBundleDataAnalysisNumber),
|
||
MonthlyInvalidIncreaseDataAnalysisNumber: int32(m.MonthlyInvalidIncreaseDataAnalysisNumber),
|
||
// 手动扩展类
|
||
MonthlyNewManualAccountNumber: int32(m.MonthlyNewAccountNumber),
|
||
MonthlyNewManualVideoNumber: int32(m.MonthlyNewManualVideoNumber),
|
||
MonthlyNewManualImageNumber: int32(m.MonthlyNewManualImageNumber),
|
||
MonthlyNewManualDataAnalysisNumber: int32(m.MonthlyNewManualDataAnalysisNumber),
|
||
MonthlyNewDurationNumber: int32(m.MonthlyNewDurationNumber),
|
||
MonthlyManualAccountConsumptionNumber: int32(m.MonthlyManualAccountConsumptionNumber),
|
||
MonthlyManualVideoConsumptionNumber: int32(m.MonthlyManualVideoConsumptionNumber),
|
||
MonthlyManualImageConsumptionNumber: int32(m.MonthlyManualImageConsumptionNumber),
|
||
MonthlyManualDataAnalysisConsumptionNumber: int32(m.MonthlyManualDataAnalysisConsumptionNumber),
|
||
|
||
Activate: int32(m.Activate),
|
||
}
|
||
|
||
if m.OrderUUID != "" {
|
||
result.Bought = 2
|
||
} else {
|
||
result.Bought = 1
|
||
}
|
||
return result
|
||
})
|
||
return resp, nil
|
||
}
|
||
|
||
func GetBundleBalanceByUserId(req *bundle.GetBundleBalanceByUserIdReq) (*bundle.GetBundleBalanceByUserIdResp, error) {
|
||
data, err := dao.GetBundleBalanceByUserId(req)
|
||
if err != nil {
|
||
logger.Error(err)
|
||
return nil, errors.New("无套餐数据")
|
||
}
|
||
if data.Activate != 2 {
|
||
return nil, errors.New("套餐未激活")
|
||
}
|
||
result := &bundle.GetBundleBalanceByUserIdResp{
|
||
OrderUUID: data.OrderUUID,
|
||
BundleName: data.BundleName,
|
||
PayTime: data.StartAt.UnixMilli(),
|
||
ExpiredTime: data.ExpiredAt.UnixMilli(),
|
||
PaymentAmount: data.PaymentAmount,
|
||
PaymentType: data.PaymentType,
|
||
AccountNumber: int32(data.BundleAccountNumber) + int32(data.IncreaseAccountNumber) + int32(data.ManualAccountNumber),
|
||
AccountAdditional: int32(data.ManualAccountNumber),
|
||
AccountConsumptionNumber: int32(data.BundleAccountConsumptionNumber) + int32(data.IncreaseAccountConsumptionNumber),
|
||
VideoNumber: int32(data.BundleVideoNumber) + int32(data.BundleLimitVideoNumber) + int32(data.BundleLimitVideoExpiredNumber) + int32(data.IncreaseVideoNumber) + int32(data.IncreaseLimitVideoNumber) + int32(data.IncreaseLimitVideoExpiredNumber),
|
||
VideoAdditional: int32(data.ManualVideoNumber),
|
||
VideoConsumptionNumber: int32(data.BundleVideoConsumptionNumber) + int32(data.BundleLimitVideoConsumptionNumber) + int32(data.BundleLimitVideoExpiredConsumptionNumber) + int32(data.IncreaseVideoConsumptionNumber) + int32(data.IncreaseLimitVideoConsumptionNumber) + int32(data.IncreaseLimitVideoExpiredConsumptionNumber),
|
||
ImageNumber: int32(data.BundleImageNumber) + int32(data.BundleLimitImageNumber) + int32(data.BundleLimitImageExpiredNumber) + int32(data.IncreaseImageNumber) + int32(data.IncreaseLimitImageNumber) + int32(data.IncreaseLimitImageExpiredNumber),
|
||
ImageAdditional: int32(data.ManualImageNumber),
|
||
ImageConsumptionNumber: int32(data.BundleImageConsumptionNumber) + int32(data.BundleLimitImageConsumptionNumber) + int32(data.BundleLimitImageExpiredConsumptionNumber) + int32(data.IncreaseImageConsumptionNumber) + int32(data.IncreaseLimitImageConsumptionNumber) + int32(data.IncreaseLimitImageExpiredConsumptionNumber),
|
||
DataAnalysisNumber: int32(data.BundleDataAnalysisNumber) + int32(data.BundleLimitDataAnalysisNumber) + int32(data.BundleLimitDataAnalysisExpiredNumber) + int32(data.IncreaseDataAnalysisNumber) + int32(data.IncreaseLimitDataAnalysisNumber) + int32(data.IncreaseLimitDataAnalysisExpiredNumber),
|
||
DataAnalysisAdditional: int32(data.ManualDataAnalysisNumber),
|
||
DataAnalysisConsumptionNumber: int32(data.BundleDataAnalysisConsumptionNumber) + int32(data.BundleLimitDataAnalysisConsumptionNumber) + int32(data.BundleLimitDataAnalysisExpiredConsumptionNumber) + int32(data.IncreaseDataAnalysisConsumptionNumber) + int32(data.IncreaseLimitDataAnalysisConsumptionNumber) + int32(data.IncreaseLimitDataAnalysisExpiredConsumptionNumber),
|
||
}
|
||
return result, nil
|
||
}
|
||
|
||
func AddBundleBalance(req *bundle.AddBundleBalanceReq) (*bundle.AddBundleBalanceResp, error) {
|
||
data := model.BundleBalanceUsePo{
|
||
UserId: int(req.UserId),
|
||
AccountNumber: int(req.AccountConsumptionNumber),
|
||
ImageNumber: int(req.ImageConsumptionNumber),
|
||
VideoNumber: int(req.VideoConsumptionNumber),
|
||
DataAnalysisNumber: int(req.DataAnalysisConsumptionNumber),
|
||
}
|
||
uesdType, err := dao.AddBundleBalanceByUserId(data)
|
||
return &bundle.AddBundleBalanceResp{
|
||
UsedType: uint32(uesdType),
|
||
}, err
|
||
}
|
||
|
||
// 计算本月发放的限制类型数量
|
||
func cal(data model.BundleBalance, total, limit int, date time.Time) int {
|
||
var released int // 已释放的次数
|
||
if data.StartAt.Month() == date.Month() && data.StartAt.Year() == date.Year() {
|
||
} else if data.StartAt.Day() >= 16 { //第一个月释放的
|
||
released += limit/2 + 1
|
||
} else {
|
||
released += limit
|
||
}
|
||
interval := date.Year()*12 + int(date.Month()) - (data.StartAt.Year()*12 + int(data.StartAt.Month())) // 后续月份释放的
|
||
released += interval * limit
|
||
remaining := max(total-released, 0) // 还剩余多少次没有发放
|
||
|
||
if data.StartAt.Month() == date.Month() && data.StartAt.Year() == date.Year() && data.StartAt.Day() >= 16 { // 本月为第一个月并且16号后购买只给一半（向上取整）
|
||
return min(limit/2+1, remaining)
|
||
}
|
||
if data.ExpiredAt.Month() == date.Month() && data.ExpiredAt.Year() == date.Year() && data.ExpiredAt.Day() < 16 { // 本月为最后一个月并且16号前到期只给一半（向下取整）
|
||
return min(limit/2, remaining)
|
||
}
|
||
return min(limit, remaining)
|
||
}
|
||
|
||
func CreateBundleBalance(req *bundle.CreateBundleBalanceReq) (*bundle.CreateBundleBalanceResp, error) {
|
||
var data model.BundleBalance
|
||
|
||
addValues, err := dao.GetValueAddByOrderUUID(req.OrderUUID)
|
||
if err != nil || len(addValues) == 0 {
|
||
return nil, errors.New("获取增值服务失败")
|
||
}
|
||
data.StartAt = time.Now()
|
||
data.ExpiredAt = time.Now()
|
||
userId, err := strconv.Atoi(addValues[0].CustomerID)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
data.Month = time.Now().Format("2006-01")
|
||
data.UserId = userId
|
||
data.OrderUUID = req.OrderUUID
|
||
for _, v := range addValues {
|
||
switch v.ServiceType {
|
||
case 1: // 视频类型
|
||
if v.EquityType == 1 { // 套餐权益
|
||
if v.QuotaType == 2 { // 限制额度
|
||
data.MonthlyLimitVideoQuotaNumber = int(v.QuotaValue)
|
||
if v.IsExpired { // 会过期的限制类型
|
||
data.BundleLimitVideoExpiredNumber += int(v.Num)
|
||
} else {
|
||
data.BundleLimitVideoNumber += int(v.Num)
|
||
}
|
||
} else {
|
||
data.BundleVideoNumber += int(v.Num)
|
||
}
|
||
} else {
|
||
if v.QuotaType == 2 { // 限制额度
|
||
data.MonthlyLimitVideoQuotaNumber = int(v.QuotaValue)
|
||
if v.IsExpired { // 会过期的限制类型
|
||
data.IncreaseLimitVideoExpiredNumber += int(v.Num)
|
||
} else {
|
||
data.IncreaseLimitVideoNumber += int(v.Num)
|
||
}
|
||
} else {
|
||
data.IncreaseVideoNumber += int(v.Num)
|
||
}
|
||
}
|
||
case 2: // 图文类型
|
||
if v.EquityType == 1 { // 套餐权益
|
||
if v.QuotaType == 2 { // 限制额度
|
||
data.MonthlyLimitImageQuotaNumber = int(v.QuotaValue)
|
||
if v.IsExpired { // 会过期的限制类型
|
||
data.BundleLimitImageExpiredNumber += int(v.Num)
|
||
} else {
|
||
data.BundleLimitImageNumber += int(v.Num)
|
||
}
|
||
} else {
|
||
data.BundleImageNumber += int(v.Num)
|
||
}
|
||
} else {
|
||
if v.QuotaType == 2 { // 限制额度
|
||
data.MonthlyLimitImageQuotaNumber = int(v.QuotaValue)
|
||
if v.IsExpired { // 会过期的限制类型
|
||
data.IncreaseLimitImageExpiredNumber += int(v.Num)
|
||
} else {
|
||
data.IncreaseLimitImageNumber += int(v.Num)
|
||
}
|
||
} else {
|
||
data.IncreaseImageNumber += int(v.Num)
|
||
}
|
||
}
|
||
case 3: // 数据分析
|
||
if v.EquityType == 1 { // 套餐权益
|
||
if v.QuotaType == 2 { // 限制额度
|
||
data.MonthlyLimitDataAnalysisQuotaNumber = int(v.QuotaValue)
|
||
if v.IsExpired { // 会过期的限制类型
|
||
data.BundleLimitDataAnalysisExpiredNumber += int(v.Num)
|
||
} else {
|
||
data.BundleLimitDataAnalysisNumber += int(v.Num)
|
||
}
|
||
} else {
|
||
data.BundleDataAnalysisNumber += int(v.Num)
|
||
}
|
||
} else {
|
||
if v.QuotaType == 2 { // 限制额度
|
||
data.MonthlyLimitDataAnalysisQuotaNumber = int(v.QuotaValue)
|
||
if v.IsExpired { // 会过期的限制类型
|
||
data.IncreaseLimitDataAnalysisExpiredNumber += int(v.Num)
|
||
} else {
|
||
data.IncreaseLimitDataAnalysisNumber += int(v.Num)
|
||
}
|
||
} else {
|
||
|
||
data.IncreaseDataAnalysisNumber += int(v.Num)
|
||
}
|
||
}
|
||
case 4: // 账号数
|
||
if v.EquityType == 1 { // 套餐权益
|
||
data.BundleAccountNumber += int(v.Num)
|
||
} else {
|
||
data.IncreaseAccountNumber += int(v.Num)
|
||
}
|
||
case 5: // 可用时长
|
||
switch v.Unit {
|
||
case "天":
|
||
data.ExpiredAt = data.ExpiredAt.Add(time.Hour * 24 * time.Duration(v.Num))
|
||
case "月":
|
||
data.ExpiredAt = data.ExpiredAt.Add(time.Hour * 24 * 30 * time.Duration(v.Num))
|
||
case "年":
|
||
data.ExpiredAt = data.ExpiredAt.Add(time.Hour * 24 * 365 * time.Duration(v.Num))
|
||
}
|
||
}
|
||
}
|
||
now := time.Now()
|
||
// 当月可用的限制类型数等于本月方法的套餐和增值两种类型的总和
|
||
data.MonthlyLimitVideoExpireNumber = cal(data, data.BundleLimitVideoExpiredNumber, data.MonthlyLimitVideoQuotaNumber, now) + cal(data, data.IncreaseLimitVideoExpiredNumber, data.MonthlyLimitVideoQuotaNumber, now)
|
||
data.MonthlyLimitVideoNumber = cal(data, data.BundleLimitVideoNumber, data.MonthlyLimitVideoQuotaNumber, now) + cal(data, data.IncreaseLimitVideoNumber, data.MonthlyLimitVideoQuotaNumber, now)
|
||
data.MonthlyLimitImageExpireNumber = cal(data, data.BundleLimitImageExpiredNumber, data.MonthlyLimitImageQuotaNumber, now) + cal(data, data.IncreaseLimitImageExpiredNumber, data.MonthlyLimitImageQuotaNumber, now)
|
||
data.MonthlyLimitImageNumber = cal(data, data.BundleLimitImageNumber, data.MonthlyLimitImageQuotaNumber, now) + cal(data, data.IncreaseLimitImageNumber, data.MonthlyLimitImageQuotaNumber, now)
|
||
data.MonthlyLimitDataAnalysisExpireNumber = cal(data, data.BundleLimitDataAnalysisExpiredNumber, data.MonthlyLimitDataAnalysisQuotaNumber, now) + cal(data, data.IncreaseLimitDataAnalysisExpiredNumber, data.MonthlyLimitDataAnalysisQuotaNumber, now)
|
||
data.MonthlyLimitDataAnalysisNumber = cal(data, data.BundleLimitDataAnalysisNumber, data.MonthlyLimitDataAnalysisQuotaNumber, now) + cal(data, data.IncreaseLimitDataAnalysisNumber, data.MonthlyLimitDataAnalysisQuotaNumber, now)
|
||
|
||
err = dao.CreateBundleBalance(data)
|
||
if err != nil {
|
||
logger.Error(err)
|
||
return nil, errors.New("创建余量信息失败")
|
||
}
|
||
return nil, nil
|
||
}
|
||
|
||
func GetUsedRecord(req *bundle.GetUsedRecordListReq) (*bundle.GetUsedRecordListResp, error) {
|
||
data, total, err := dao.GetUsedRecord(req)
|
||
if err != nil {
|
||
logger.Error(err)
|
||
return nil, errors.New("查询失败")
|
||
}
|
||
resp := &bundle.GetUsedRecordListResp{}
|
||
resp.Total = total
|
||
resp.Data = lo.Map(data, func(m model.CostLogPo, _ int) *bundle.WorkCastItem {
|
||
result := &bundle.WorkCastItem{}
|
||
copier.Copy(result, &m)
|
||
return result
|
||
})
|
||
return resp, nil
|
||
}
|
||
|
||
func GetImageWorkDetail(req *bundle.GetImageWorkDetailReq) (*bundle.GetImageWorkDetailResp, error) {
|
||
data, err := dao.GetImageWorkDetail(req)
|
||
if err != nil {
|
||
logger.Error(err)
|
||
return nil, errors.New("查询失败")
|
||
}
|
||
result := &bundle.GetImageWorkDetailResp{}
|
||
err = copier.Copy(result, &data)
|
||
return result, err
|
||
}
|
||
|
||
func GetVedioWorkDetail(req *bundle.GetVedioWorkDetailReq) (*bundle.GetVedioeWorkDetailResp, error) {
|
||
data, err := dao.GetVedioWorkDetail(req)
|
||
if err != nil {
|
||
logger.Error(err)
|
||
return nil, errors.New("查询失败")
|
||
}
|
||
result := &bundle.GetVedioeWorkDetailResp{}
|
||
err = copier.Copy(result, &data)
|
||
return result, err
|
||
}
|
||
|
||
func ToBeComfirmedWorks(req *bundle.ToBeComfirmedWorksReq) (*bundle.ToBeComfirmedWorksResp, error) {
|
||
data, total, unconfirmed, err := dao.ToBeComfirmedWorks(req)
|
||
if err != nil {
|
||
logger.Error(err)
|
||
return nil, errors.New("查询失败")
|
||
}
|
||
result := &bundle.ToBeComfirmedWorksResp{
|
||
Total: total,
|
||
Unconfirmed: unconfirmed,
|
||
}
|
||
result.Data = lo.Map(data, func(m model.CastWorkLog, _ int) *bundle.WorkItem {
|
||
result := &bundle.WorkItem{}
|
||
copier.Copy(result, &m)
|
||
return result
|
||
})
|
||
return result, nil
|
||
}
|
||
|
||
func ConfirmWork(req *bundle.ConfirmWorkReq) (*bundle.ConfirmWorkResp, error) {
|
||
return nil, dao.ConfirmWork(req)
|
||
}
|
||
|
||
func BundleActivate(req *bundle.BundleActivateReq) error {
|
||
return dao.BundleActivate(req.Ids)
|
||
}
|
||
|
||
func UpdateBundleBalance() {
|
||
dao.UpdateBundleBalance()
|
||
}
|
||
|
||
func BundleBalanceExport(req *bundle.BundleBalanceExportReq) (*bundle.BundleBalanceExportResp, error) {
|
||
data, err := GetBundleBalanceList(&bundle.GetBundleBalanceListReq{
|
||
Month: req.Month,
|
||
Bought: 2,
|
||
})
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
prefixData, err := dao.BalanceExportPrefix()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
var prefixMap = map[int32]model.BundleExportDto{}
|
||
for _, v := range prefixData {
|
||
prefixMap[v.UserId] = v
|
||
}
|
||
|
||
items := []*bundle.BundleBalanceExportItem{}
|
||
|
||
for _, v := range data.Data {
|
||
prefixItem := prefixMap[v.UserId]
|
||
item := &bundle.BundleBalanceExportItem{}
|
||
copier.Copy(item, v)
|
||
item.CustomerNum = prefixItem.CustomNum
|
||
item.PayTime = prefixItem.PayTime
|
||
item.BundleAmount = prefixItem.BundleAmount
|
||
item.IncreaseAmount = prefixItem.TotalPayAmount - prefixItem.BundleAmount
|
||
item.TotalPayAmount = prefixItem.TotalPayAmount
|
||
item.Currency = "USD"
|
||
item.Fee = prefixItem.Fee
|
||
item.BundleVideoUnitPrice = float32(item.BundleAmount / float32(v.BundleVideoNumber))
|
||
item.IncreaseVideoUnitPrice = float32(item.IncreaseAmount / float32(v.IncreaseVideoNumber))
|
||
items = append(items, item)
|
||
}
|
||
return &bundle.BundleBalanceExportResp{Total: int64(len(items)), Data: items}, nil
|
||
}
|