youngee_mc_api/app/service/youngee_talent_service/task_income.go

package youngee_talent_service

import (
	"context"
	"encoding/json"
	"fmt"
	"math/rand"
	"strings"
	"time"
	"youngmini_server/app/dao"
	"youngmini_server/app/model"
	"youngmini_server/app/model/youngee_talent_model"
	"youngmini_server/app/utils"

	"github.com/gogf/gf/database/gdb"
	"github.com/gogf/gf/frame/g"
	"github.com/gogf/gf/net/ghttp"
	"github.com/gogf/gf/os/gtime"
)

func GetWithdrawTaskInfo(r *ghttp.Request) *TalentHttpResult {
	tid, err := utils.SessionTalentInfo.GetTalentIdFromSession(r)
	if err != nil {
		return &TalentHttpResult{Code: -1, Msg: "Get talent info failed"}
	}

	withdrawTaskInfoList := youngee_talent_model.WithdrawTaskInfoList{}
	// 获取可提现任务列表
	var taskList []*model.YoungeeTaskInfo
	err = g.Model(dao.YoungeeTaskInfo.Table).Where("talent_id = ?", tid).And("withdraw_status IN(?)", g.Slice{2, 3, 4}).Scan(&taskList)
	if err != nil {
		return &TalentHttpResult{Code: -1, Msg: "Get task list failed"}
	}

	for _, v := range taskList {
		projectInfo, err := g.Model(dao.ProjectInfo.Table).Where("project_id = ?", v.ProjectId).One()
		if err != nil {
			return &TalentHttpResult{Code: -1, Msg: "Get project info failed"}
		}
		product, err := g.Model(dao.YounggeeProduct.Table).One("product_id = ?", projectInfo[dao.ProjectInfo.Columns.ProductId])
		if err != nil {
			return &TalentHttpResult{Code: -1, Msg: "Get product mainphoto failed"}
		}
		strategy := model.RecruitStrategy{}
		err = g.Model(dao.RecruitStrategy.Table).Where("project_id = ? and strategy_id = ?", v.ProjectId, v.StrategyId).Scan(&strategy)
		if err != nil {
			return &TalentHttpResult{Code: -1, Msg: "Get platform failed"}
		}

		taskInfoBrief := &youngee_talent_model.WithdrawTaskInfo{
			TaskId:          v.TaskId,
			ProjectName:     projectInfo[dao.ProjectInfo.Columns.ProjectName].String(),
			ProductPrice:    product[dao.Product.Columns.ProductPrice].Int(),
			RecruitStrategy: &strategy,
			TaskReward:      v.TaskReward,
			SettleAmount:    v.SettleAmount,
			CompleteDate:    v.CompleteDate,
			WithdrawDate:    v.WithdrawDate,
			Checked:         false,
		}
		if v.WithdrawStatus == 2 {
			withdrawTaskInfoList.CanWithdrawTaskInfoList = append(withdrawTaskInfoList.CanWithdrawTaskInfoList, taskInfoBrief)
		} else if v.WithdrawStatus == 3 {
			withdrawTaskInfoList.WithdrawingTaskInfoList = append(withdrawTaskInfoList.WithdrawingTaskInfoList, taskInfoBrief)
		} else if v.WithdrawStatus == 4 {
			withdrawTaskInfoList.WithdrawedTaskInfoList = append(withdrawTaskInfoList.WithdrawedTaskInfoList, taskInfoBrief)
		}
	}
	return &TalentHttpResult{Code: 0, Msg: "success", Data: withdrawTaskInfoList}
}

func Withdraw(r *ghttp.Request) *TalentHttpResult {
	tid, err := utils.SessionTalentInfo.GetTalentIdFromSession(r)
	if err != nil {
		return &TalentHttpResult{Code: -1, Msg: "Get talent info failed"}
	}

	var DataInfoReq *youngee_talent_model.WithdrawInfo
	err = r.ParseForm(&DataInfoReq)
	if err != nil {
		return &TalentHttpResult{Code: -2, Msg: err.Error()}
	}
	taskIdListStr := strings.Split(DataInfoReq.TaskIdList, ",")
	// taskIdListInt := utils.TypeTran.String2Int(taskIdListStr)

	// 检验是否taskIdList中所有task均处于可提现状态，且talent_id是否正确
	var taskList []model.YoungeeTaskInfo
	err = g.Model(dao.YoungeeTaskInfo.Table).Where("talent_id = ?", tid).And("task_id IN (?)", taskIdListStr).Scan(&taskList)
	if err != nil {
		return &TalentHttpResult{Code: -3, Msg: "Get task list failed"}
	}
	if len(taskIdListStr) != len(taskList) {
		return &TalentHttpResult{Code: -4, Msg: "Task TalentID Error"}
	}
	for _, v := range taskList {
		if v.WithdrawStatus != 2 {
			return &TalentHttpResult{Code: -4, Msg: "Task Withdraw Status Error"}
		}
	}

	var talentBank model.YounggeeTalentBank
	err = g.Model(dao.YounggeeTalentBank.Table).Where("talent_id = ?", tid).Scan(&talentBank)
	if err != nil {
		return &TalentHttpResult{Code: -5, Msg: "Get Bank Info failed"}
	}

	bankJsons, errs := json.Marshal(talentBank) //转换成JSON返回的是byte[]
	if errs != nil {
		return &TalentHttpResult{Code: -6, Msg: " Json transformed failed"}
	}

	err = g.DB().Transaction(context.TODO(), func(ctx context.Context, tx *gdb.TX) error {
		s1 := tid[7:]
		s2 := fmt.Sprintf("%d", gtime.Now().YearDay())
		s3 := fmt.Sprintf("%02v", rand.New(rand.NewSource(time.Now().UnixNano())).Int63n(100))
		s := "6" + s1 + s2 + s3
		// 插入提现记录
		_, err1 := tx.Ctx(ctx).Model(dao.YounggeeWithdrawRecord.Table).Data(model.YounggeeWithdrawRecord{
			WithdrawId:     s,
			TalentId:       tid,
			WithdrawAmount: float64(DataInfoReq.TotalAmount),
			AmountPayable:  float64(DataInfoReq.RealAmount),
			TaskIdList:     DataInfoReq.TaskIdList,
			ReceiveInfo:    string(bankJsons),
			BankType:       DataInfoReq.BankType,
			Status:         1,
			SubmitAt:       gtime.Now(),
		}).InsertAndGetId()
		if err1 != nil {
			fmt.Printf("[Withdraw Transaction] Error:%+v\n", err1)
			return err1
		}

		// 更新task表中提现状态
		_, err1 = tx.Ctx(ctx).Model(dao.YoungeeTaskInfo.Table).Where("task_id IN (?)", taskIdListStr).Update(g.Map{"withdraw_status": 3, "withdraw_date": gtime.Now()})
		if err1 != nil {
			fmt.Printf("[Withdraw Transaction] Error:%+v\n", err1)
			return err1
		}

		// 更新talent表中提现金额
		_, err1 = tx.Ctx(ctx).Model(dao.YoungeeTalentInfo.Table).Where("id = ?", tid).Increment("withdrawing", float64(DataInfoReq.TotalAmount))
		if err1 != nil {
			fmt.Printf("[Withdraw Transaction] Error:%+v\n", err1)
			return err1
		}
		_, err1 = tx.Ctx(ctx).Model(dao.YoungeeTalentInfo.Table).Where("id = ?", tid).Decrement("canwithdraw", float64(DataInfoReq.TotalAmount))
		if err1 != nil {
			fmt.Printf("[Withdraw Transaction] Error:%+v\n", err1)
			return err1
		}
		for _, taskId := range taskIdListStr {
			projectInfo := model.ProjectInfo{}
			err1 = tx.Ctx(ctx).Model(model.ProjectInfo{}).Where("project_id = ?", taskId).Scan(&projectInfo)
			if err1 != nil {
				fmt.Printf("[Withdraw Transaction] Error:%+v\n", err1)
				return err1
			}
			messageInfo := model.YounggeeMessageInfo{
				MessageId:   12,
				MessageType: 2,
				CreatedAt:   gtime.Now(),
				TalentId:    taskId,
				ProjectName: projectInfo.ProjectName,
				IsReaded:    0,
				IsDeleted:   0,
			}
			_, err = tx.Ctx(ctx).Model(dao.YounggeeMessageInfo.Table).Data(&messageInfo).Insert()
			if err != nil {
				fmt.Printf("[Withdraw Transaction] Error:%+v\n", err)
				return err
			}
		}
		return nil
	})
	if err != nil {
		return &TalentHttpResult{Code: -7, Msg: "Add Withdraw Record failed"}
	}

	return &TalentHttpResult{Code: 0, Msg: "success"}
}