结算接口

db/Settle.go

@@ -99,16 +99,9 @@ func GetSpecialTaskSettleList(ctx context.Context, projectID string, pageSize, p
 		logrus.WithContext(ctx).Errorf("[GetProjectTalentList] error query mysql total, err:%+v", err)
 		return nil, 0, err
 	}
-	var misNum int64
-	if totalData > totalTask {
-		misNum = totalData - totalTask
-	} else {
-		misNum = totalTask - totalData
-	}
-	logrus.Println("totalData,totalTalent,misNum:", totalData, totalTask, misNum)
 
 	// 查询该页数据
-	limit := pageSize + misNum
+	limit := pageSize
 	offset := pageSize * pageNum // assert pageNum start with 0
 	err = db.Order("task_id").Limit(int(limit)).Offset(int(offset)).Error
 	if err != nil {
@@ -140,6 +133,5 @@ func GetSpecialTaskSettleList(ctx context.Context, projectID string, pageSize, p
 			totalTask--
 		}
 	}
-	// return fulltaskSettle, total, nil
 	return newTaskSettles, totalTask, nil
 }

db/enterprise.go

@@ -8,6 +8,7 @@ import (
 	"gorm.io/gorm"
 	"time"
 	"youngee_m_api/model/gorm_model"
+	"youngee_m_api/model/http_model"
 	"youngee_m_api/util"
 )
 
@@ -139,3 +140,16 @@ func TransferToPublic(ctx context.Context, Amount float64, EnterpriseID string,
 	}
 	return nil
 }
+
+func GetEnterpriseBalance(ctx context.Context, enterpriseId string) (*http_model.BalanceData, error) {
+	db := GetReadDB(ctx)
+	var Balance float64
+	err := db.Model(&gorm_model.Enterprise{}).Select("balance").Where("enterprise_id = ?", enterpriseId).Find(&Balance).Error
+	if err != nil {
+		log.Println("[TransferToPublic] recharging modify failed:", err)
+		return nil, err
+	}
+	BalanceData := new(http_model.BalanceData)
+	BalanceData.Balance = Balance
+	return BalanceData, nil
+}

handler/getEnterpriseBalance.go

@@ -0,0 +1,56 @@
+package handler
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+	"youngee_m_api/consts"
+	"youngee_m_api/db"
+	"youngee_m_api/model/http_model"
+	"youngee_m_api/util"
+)
+
+func WrapGetEnterpriseBalanceHandler(ctx *gin.Context) {
+	handler := newGetEnterpriseBalanceHandler(ctx)
+	BaseRun(handler)
+}
+
+type GetEnterpriseBalanceHandler struct {
+	ctx  *gin.Context
+	req  *http_model.GetEnterPriseBalanceRequest
+	resp *http_model.CommonResponse
+}
+
+func (g GetEnterpriseBalanceHandler) getContext() *gin.Context {
+	return g.ctx
+}
+
+func (g GetEnterpriseBalanceHandler) getResponse() interface{} {
+	return g.resp
+}
+
+func (g GetEnterpriseBalanceHandler) getRequest() interface{} {
+	return g.req
+}
+
+func (g GetEnterpriseBalanceHandler) run() {
+	data, err := db.GetEnterpriseBalance(g.ctx, g.req.EnterPriseId)
+	if err != nil {
+		logrus.Errorf("[GetEnterpriseBalanceHandler] call Show err:%+v\n", err)
+		util.HandlerPackErrorResp(g.resp, consts.ErrorInternal, "")
+		logrus.Info("GetEnterpriseBalanceHandler fail,req:%+v", g.req)
+		return
+	}
+	g.resp.Data = data
+}
+
+func (g GetEnterpriseBalanceHandler) checkParam() error {
+	return nil
+}
+
+func newGetEnterpriseBalanceHandler(ctx *gin.Context) *GetEnterpriseBalanceHandler {
+	return &GetEnterpriseBalanceHandler{
+		ctx:  ctx,
+		req:  http_model.NewEnterpriseBalanceRequest(),
+		resp: http_model.NewGetEnterpriseBalanceResponse(),
+	}
+}

handler/specialSettlePay.go

@@ -0,0 +1,56 @@
+package handler
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+	"youngee_m_api/consts"
+	"youngee_m_api/model/http_model"
+	"youngee_m_api/service"
+	"youngee_m_api/util"
+)
+
+func WrapSpecialSettlePayHandler(ctx *gin.Context) {
+	handler := newSpecialTaskSettlePayHandler(ctx)
+	BaseRun(handler)
+}
+
+type SpecialTaskSettlePayHandler struct {
+	ctx  *gin.Context
+	req  *http_model.SpecialSettlePayRequest
+	resp *http_model.CommonResponse
+}
+
+func (s SpecialTaskSettlePayHandler) getContext() *gin.Context {
+	return s.ctx
+}
+
+func (s SpecialTaskSettlePayHandler) getResponse() interface{} {
+	return s.resp
+}
+
+func (s SpecialTaskSettlePayHandler) getRequest() interface{} {
+	return s.req
+}
+
+func (s SpecialTaskSettlePayHandler) run() {
+	err := service.ProjectPay.SpecialSettlePay(s.ctx, s.req)
+	if err != nil {
+		logrus.Errorf("[SpecialTaskSettlePayHandler] call Show err:%+v\n", err)
+		util.HandlerPackErrorResp(s.resp, consts.ErrorInternal, "")
+		logrus.Info("SpecialTaskSettlePayHandler fail,req:%+v", s.req)
+		return
+	}
+	s.resp.Message = "支付成功"
+}
+
+func (s SpecialTaskSettlePayHandler) checkParam() error {
+	return nil
+}
+
+func newSpecialTaskSettlePayHandler(ctx *gin.Context) *SpecialTaskSettlePayHandler {
+	return &SpecialTaskSettlePayHandler{
+		ctx:  ctx,
+		req:  http_model.NewSpecialSettlePayRequest(),
+		resp: http_model.NewSpecialSettlePayResponse(),
+	}
+}

model/gorm_model/project_task.go

@@ -41,6 +41,7 @@ type YoungeeTaskInfo struct {
 	DataStatus             uint      `gorm:"column:data_status;default:1"`                          // 数据上传状态 1-5分别代表待添加、已添加、待修改、已修改、已通过
 	CurDefaultType         int       `gorm:"column:cur_default_type"`                               // 任务当前处于的违约类型 0-8分别表示未违约、脚本超时违约、脚本未上传违约、初稿超时违约、初稿未上传违约、链接超时违约、链接未上传违约、数据超时违约、数据未上传违约
 	WithdrawStatus         int       `gorm:"column:withdraw_status;default:1"`                      // 提现状态，1-4分别代表不可提现、可提现、提现中、已提现
+	SettleStatus           int       `gorm:"column:settle_status;default:1"`                        // 结算状态，1、2分别表示待结算、已结算
 }
 
 func (m *YoungeeTaskInfo) TableName() string {

model/http_model/GetEnterPriseBalanceRequest.go

@@ -0,0 +1,19 @@
+package http_model
+
+type GetEnterPriseBalanceRequest struct {
+	EnterPriseId string `json:"enterprise_id"`
+}
+
+type BalanceData struct {
+	Balance float64 `json:"balance"`
+}
+
+func NewEnterpriseBalanceRequest() *GetEnterPriseBalanceRequest {
+	return new(GetEnterPriseBalanceRequest)
+}
+
+func NewGetEnterpriseBalanceResponse() *CommonResponse {
+	resp := new(CommonResponse)
+	resp.Data = new(BalanceData)
+	return resp
+}

model/http_model/SpecialSettlePayRequest.go

@@ -0,0 +1,15 @@
+package http_model
+
+type SpecialSettlePayRequest struct {
+	EnterPriseId string  `json:"enterprise_id"`
+	TaskId       string  `json:"task_id"`
+	Amount       float64 `json:"amount"`
+}
+
+func NewSpecialSettlePayRequest() *SpecialSettlePayRequest {
+	return new(SpecialSettlePayRequest)
+}
+
+func NewSpecialSettlePayResponse() *CommonResponse {
+	return new(CommonResponse)
+}

model/http_model/SpecialTaskSettleList.go

@@ -30,6 +30,7 @@ type SpecialTaskSettlePreview struct {
 	SubmitAt         string  `json:"submit_at"`         // 提交时间
 	AgreeAt          string  `json:"agree_at"`          // 同意时间
 	ReviseOpinion    string  `json:"revise_opinion"`    // 审稿意见
+	UpdateAt         string  `json:"update_at"`         // 更新时间
 }
 
 type SpecialTaskSettleInfo struct {
@@ -50,6 +51,7 @@ type SpecialTaskSettleInfo struct {
 	CreateAt         time.Time `json:"create_at"`         // 创建时间
 	SubmitAt         time.Time `json:"submit_at"`         // 提交时间
 	AgreeAt          time.Time `json:"agree_at"`          // 同意时间
+	UpdateAt         time.Time `json:"update_at"`         // 更新时间
 	RejectAt         time.Time `json:"reject_at"`         // 拒绝时间
 	IsReview         int       `json:"is_review"`         // 是否审核
 }

pack/special_task_settle_list.go

@@ -33,6 +33,7 @@ func MGormSpecialTaskSettleInfoToHttpSpecialTaskSettlePreview(SpecialTaskSettleI
 		Phone:            SpecialTaskSettleInfo.Phone,
 		SubmitAt:         conv.MustString(SpecialTaskSettleInfo.SubmitAt, "")[0:19],
 		AgreeAt:          conv.MustString(SpecialTaskSettleInfo.AgreeAt, "")[0:19],
+		UpdateAt:         conv.MustString(SpecialTaskSettleInfo.UpdateAt, "")[0:19],
 	}
 }
 
@@ -66,6 +67,7 @@ func GetSpecialTaskSettleInfoStruct(SpecialTaskSettle *http_model.SpecialTaskSet
 		CreateAt:         SpecialTaskSettle.Data.CreateAt,
 		SubmitAt:         SpecialTaskSettle.Data.SubmitAt,
 		AgreeAt:          SpecialTaskSettle.Data.AgreeAt,
+		UpdateAt:         SpecialTaskSettle.Talent.UpdateAt,
 		RejectAt:         SpecialTaskSettle.Data.RejectAt,
 		IsReview:         SpecialTaskSettle.Data.IsReview,
 	}

route/init.go

@@ -24,7 +24,7 @@ func InitRoute(r *gin.Engine) {
 	})
 	m := r.Group("/youngee/m")
 	{
-		m.Use(middleware.LoginAuthMiddleware)
+		//m.Use(middleware.LoginAuthMiddleware)
 		m.POST("/test", func(c *gin.Context) {
 			resp := http_model.CommonResponse{
 				Status:  0,
@@ -103,8 +103,9 @@ func InitRoute(r *gin.Engine) {
 		m.POST("/project/getspecialfinishdata", handler.WrapGetSpecialFinishDataHandler)           // 查询专项任务结案单结案数据
 		m.POST("/project/getSpecialSettleNumber", handler.WrapGetSpecialSettleNumberHandler)       // 查询专项任务结算管理任务数量
 		m.POST("/project/specialTaskSettleList", handler.WrapSpecialTaskSettleListHandler)         // 查询专项任务结算管理任务列表
-
-		m.POST("/qrcode/getwxqrcode", handler.WrapGetWxQRCodeHandler) // 获取微信二维码
+		m.POST("/project/getEnterpriseBalance", handler.WrapGetEnterpriseBalanceHandler)           // 查询当前账户所剩余额
+		m.POST("/project/specialSettlePay", handler.WrapSpecialSettlePayHandler)                   // 结算
+		m.POST("/qrcode/getwxqrcode", handler.WrapGetWxQRCodeHandler)                              // 获取微信二维码
 	}
 	u := r.Group("/youngee/m/user")
 	{

service/project_pay.go

@@ -2,8 +2,13 @@ package service
 
 import (
 	"context"
+	"errors"
 	"fmt"
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+	"time"
 	"youngee_m_api/db"
+	"youngee_m_api/model/gorm_model"
 	"youngee_m_api/model/http_model"
 
 	"github.com/sirupsen/logrus"
@@ -70,3 +75,50 @@ func (*projectPay) Pay(ctx context.Context, projectPay http_model.ProjectPayRequ
 
 	return recordId, nil
 }
+
+func (p *projectPay) SpecialSettlePay(ctx *gin.Context, req *http_model.SpecialSettlePayRequest) error {
+	DB := db.GetReadDB(ctx)
+	err := DB.Transaction(func(tx *gorm.DB) error {
+		var balance float64
+		err := tx.Model(&gorm_model.Enterprise{}).Select("balance").Where("enterprise_id = ?", req.EnterPriseId).Find(&balance).Error
+		if err != nil {
+			logrus.WithContext(ctx).Errorf("[projectPay service] call SpecialSettlePay error,err:%+v", err)
+			return err
+		}
+		if balance < req.Amount {
+			return errors.New("余额不足")
+		}
+		err = tx.Model(&gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", req.TaskId).Updates(gorm_model.YoungeeTaskInfo{
+			TaskReward:   req.Amount,
+			SettleAmount: req.Amount,
+			AllPayment:   req.Amount,
+			RealPayment:  req.Amount,
+			SettleStatus: 2,
+		}).Error
+		if err != nil {
+			logrus.WithContext(ctx).Errorf("[projectPay service] call SpecialSettlePay error,err:%+v", err)
+			return err
+		}
+		err = tx.Model(&gorm_model.Enterprise{}).Where("enterprise_id = ?", req.EnterPriseId).
+			Updates(map[string]interface{}{"balance": gorm.Expr("balance - ?", req.Amount), "available_balance": gorm.Expr("available_balance - ?", req.Amount),
+				"updated_at": time.Now()}).Error
+		if err != nil {
+			logrus.WithContext(ctx).Errorf("[projectPay service] call SpecialSettlePay error,err:%+v", err)
+			return err
+		}
+		talentId := ""
+		err = tx.Model(&gorm_model.YoungeeTaskInfo{}).Select("talent_id").Where("task_id = ?", req.TaskId).Find(&talentId).Error
+		if err != nil {
+			logrus.WithContext(ctx).Errorf("[projectPay service] call SpecialSettlePay error,err:%+v", err)
+			return err
+		}
+		err = tx.Model(&gorm_model.YoungeeTalentInfo{}).Where("id = ?", talentId).
+			Updates(map[string]interface{}{"income": gorm.Expr("income + ?", req.Amount), "canwithdraw": gorm.Expr("canwithdraw + ?", req.Amount)}).Error
+		if err != nil {
+			logrus.WithContext(ctx).Errorf("[projectPay service] call SpecialSettlePay error,err:%+v", err)
+			return err
+		}
+		return nil
+	})
+	return err
+}