micro-bundle/internal/logic/bundleExtendLogic.go

package logic

import (
	"micro-bundle/internal/dao"
	"micro-bundle/internal/model"
	"micro-bundle/pb/bundle"
	"time"

	"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.AddBundleBalanceByUserId(model.BundleBalance{
		UserId:               int(req.UserId),
		VideoNumber:          int(req.VideoAdditional),
		ImageNumber:          int(req.ImagesAdditional),
		DataAnalysisNumber:   int(req.DataAdditional),
		AccountNumber:        int(req.AccountAdditional),
		ExpansionPacksNumber: 1,
	}); err != nil {
		return nil, err
	}
	return nil, dao.AddBundleExtendRecord(data)
}

func BundleExtendRecordsList(req *bundle.BundleExtendRecordsListRequest) (*bundle.BundleExtendRecordsListResponse, error) {
	data, total, err := dao.GetBundleExtendRecordList(req)
	if err != nil {
		return nil, err
	}
	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)
		return result
	})
	return resp, nil
}

func GetBundleBalanceList(req *bundle.GetBundleBalanceListReq) (*bundle.GetBundleBalanceListResp, error) {
	data, total, err := dao.GetBundleBalanceList(req)
	if err != nil {
		return nil, err
	}
	resp := &bundle.GetBundleBalanceListResp{}
	resp.Total = total
	resp.Data = lo.Map(data, func(m model.BundleBalancePo, _ int) *bundle.BundleBalanceItem {
		result := &bundle.BundleBalanceItem{}
		copier.Copy(result, &m)
		t, _ := time.Parse("2006-01-02", m.ExpirationTime)
		result.ExpiredTime = t.UnixMilli()
		return result
	})
	return resp, nil
}

func AddBundleBalance(req *bundle.AddBundleBalanceReq) (*bundle.AddBundleBalanceResp, error) {
	var data model.BundleBalance
	if err := copier.Copy(&data, req); err != nil {
		return nil, err
	}
	return nil, dao.AddBundleBalanceByUserId(data)
}

func CreateBundleBalance(req *bundle.CreateBundleBalanceReq) (*bundle.CreateBundleBalanceResp, error) {
	var data model.BundleBalance
	if err := copier.Copy(&data, req); err != nil {
		return nil, err
	}
	return nil, dao.CreateBundleBalance(data)
}

func GetUsedRecord(req *bundle.GetUsedRecordListReq) (*bundle.GetUsedRecordListResp, error) {
	data, total, err := dao.GetUsedRecord(req)
	if err != nil {
		return nil, err
	}
	resp := &bundle.GetUsedRecordListResp{}
	resp.Total = total
	resp.Data = lo.Map(data, func(m model.CostLog, _ 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 {
		return nil, err
	}
	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 {
		return nil, err
	}
	result := &bundle.GetVedioeWorkDetailResp{}
	err = copier.Copy(result, &data)
	return result, err
}

func ToBeComfirmedWorks(req *bundle.ToBeComfirmedWorksReq) (*bundle.ToBeComfirmedWorksResp, error) {
	// data, err := dao.ToBeComfirmedWorks(req)
	return nil, nil
}