开票记录

.idea/go.imports.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="GoImports">
+    <option name="excludedPackages">
+      <array>
+        <option value="github.com/caixw/lib.go/conv" />
+      </array>
+    </option>
+  </component>
+</project>

apiclient_key.pem

@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDiS0mOMU85JaH1
+nRsOU57TfKP+3ma7TiEe2jQNHhF1UUW8i1+Hc1NeLe7dh29J5aEa/isu0RG2LHjY
+P73dzPkarAdhmW3ETsbBVazUw7RfhbPawR6EjBArRAojqHLXdSTFeDM6LtmwbWD2
+JEjiBKyTMtsbnap4ubLhR03huPn8V20Hbq3Zg+U8T4XtnK7jrac2SqkuybKheRX8
+OzaefU/nYbxKwyTqKCanAs96ZTFuEceW9Utoa4jb4bqdVVhbc2P5gyyssKfYkfDj
+Pdr2X3vg11qq7bhjQ+xLgUiWwXlqnKY0eHxvx0Zdh5PWdh0oYZtbuHrkPPJaf4zu
+Zkre9VnXAgMBAAECggEASPlaWP5Ru+4E0n29UdtpZm3VPMVff5tsVtSq4GgH3Ts+
+L9UKE1X/Vmmdk9au7recQmYgatKE0ah5t9KmWbZVxmIfZzvhB+MXeRU1zM7nhb5K
+B4srWjcIp8sjMeiKUCy4lO10J5kgHiLHl9iPoEM9m6JUwg0QAipwIvGpjdbm1paH
+esqCyZ2+fyTypO1mkpPOOB6caGwePE0Ppd/U5woPKPS0H5JnBdKPWBh/XYkBigOl
+fMRjJg9BDGPjxI1Rt+F6S359fgfXZJV1m74YVL9HxgfKi+WHdDTtj0094NBqizCg
+goeLZbz6aWYbOBmpFHrK8F2i/pYU658KLCtjjpvnQQKBgQD6JJGRqqF1OLVsjJ+E
++8ts8IdC+OBYY9YHgLw5D2aFUrtJre9Fiktj0hupXPm+01kmc+5OupR3O/L8jhM6
++NTe3fmIzNLk72GeZsiWFrZCN0fKjts421wwyhBrqW/qZN66a1kYA7fvr0ToRjL1
+jLhTqu0a8BGRyaxbqlebo/5FkQKBgQDnl8MYmJoYpJ36WK3Bd1j/9eczDmRXf4RW
+kZjIOeXBN4zHZsvlFtMtcaZAw3Z1KPbM4ncuKwl+pc7oNUfOAU/IOiBEiZR7zSYG
+D8g+UoXfZzv5mFQQBSagfY4Q0bigG1Zt/QPMoN5setiG6BJ+bwN7WfXNjRjyaXtZ
+ovUUniFU5wKBgQDrvu0mcL6MIG7zp7Brf3bf6+w+lRmylBzRo2VBDZ+chTUXooJ/
+cm/M2ubQ/lwtmThLAjWVI0jq+qftl+TNzleo12DmqcsUkfrZc5sVwL/ytfDGGU7I
+TgybusQxA1YDfR9gZ+1msZJ3pSJ3GjnKq93IlK2zlo+oa34yQd8hQzRP0QKBgQDQ
+5TkbNHq6g7HjoJ2KBocGyd2zVeX4bpMGKuouoNq2v86CBh0gFMiDEyItBKIS59JF
+2Hg78qHr1M+e8IBGNzSpnJSCfb6rNM55ZT7vyCvs6QdWCaq5kIvY86dzUFhCQqZh
+K3mD2A8Itn4cobQcyzHOz8RBlmXMMo0Ku0xpPoE+PQKBgEFcy2wvv/saKJ+3t2Cw
+4ckwskhsQ2CizlAlTCNmBzou+IYfcg3VxS7P0EA/ViUXHTOx1pjhS977FLqJxe08
+FU7a3mIzzehJA0VnsZC6lzCqSRxdE4bcEs9Opw+sJS7abJKRU2QeZSJEChqAMUhJ
+3oP15BVjOfW79TL/hp8fRZAt
+-----END PRIVATE KEY-----

db/data.go

@@ -0,0 +1,173 @@
+package db
+
+import (
+	"context"
+	"fmt"
+	"github.com/caixw/lib.go/conv"
+	"github.com/sirupsen/logrus"
+	"reflect"
+	"strings"
+	"time"
+	"youngee_m_api/model/common_model"
+	"youngee_m_api/model/gorm_model"
+	"youngee_m_api/model/http_model"
+	"youngee_m_api/pack"
+	"youngee_m_api/util"
+)
+
+// GetTaskDataList 查询上传链接的task list
+func GetTaskDataList(ctx context.Context, projectID string, pageSize, pageNum int64, conditions *common_model.TalentConditions) ([]*http_model.TaskDataInfo, int64, error) {
+	db := GetReadDB(ctx)
+	// 查询Task表信息
+	db = db.Debug().Model(gorm_model.YoungeeTaskInfo{}).Where("task_status = 2")
+	// 根据Project条件过滤
+	conditionType := reflect.TypeOf(conditions).Elem()
+	conditionValue := reflect.ValueOf(conditions).Elem()
+	var platform_nickname string = ""
+	for i := 0; i < conditionType.NumField(); i++ {
+		field := conditionType.Field(i)
+		tag := field.Tag.Get("condition")
+		value := conditionValue.FieldByName(field.Name)
+
+		if tag == "data_status" {
+			fmt.Printf("Data %+v", value.Interface() == int64(0))
+			if value.Interface() == int64(0) {
+				db = db.Where("task_stage = ?", 14)
+			} else {
+				db = db.Where("task_stage > ?", 14)
+			}
+			continue
+		} else if !util.IsBlank(value) {
+			if tag == "platform_nickname" {
+				platform_nickname = fmt.Sprintf("%v", value.Interface())
+				continue
+			} else if tag == "project_id" {
+				db = db.Where(fmt.Sprintf("%s = ?", tag), value.Interface())
+			} else if tag == "strategy_ids" {
+				strategyIds := strings.Split(fmt.Sprintf("%v", value.Interface()), ",")
+				var strategyIdList []int
+				for _, strategyId := range strategyIds {
+					strategyIdList = append(strategyIdList, conv.MustInt(strategyId, 0))
+				}
+				db = db.Where("strategy_id in ?", strategyIdList)
+			} else {
+				db = db.Where(fmt.Sprintf("%s like '%%%v%%'", tag, value.Interface()))
+			}
+		}
+	}
+	var taskInfos []gorm_model.YoungeeTaskInfo
+	db = db.Model(gorm_model.YoungeeTaskInfo{})
+	// 查询总数
+	var totalTask int64
+	if err := db.Count(&totalTask).Error; err != nil {
+		logrus.WithContext(ctx).Errorf("[GetProjectTaskList] error query mysql total, err:%+v", err)
+		return nil, 0, err
+	}
+	db.Order("task_id").Find(&taskInfos)
+
+	// 查询任务id
+	var taskIds []int
+	taskMap := make(map[int]gorm_model.YoungeeTaskInfo)
+	for _, taskInfo := range taskInfos {
+		taskIds = append(taskIds, taskInfo.TaskId)
+		taskMap[taskInfo.TaskId] = taskInfo
+	}
+	db1 := GetReadDB(ctx)
+	db1 = db1.Debug().Model(gorm_model.YounggeeDataInfo{})
+
+	var DataInfos []gorm_model.YounggeeDataInfo
+	db1 = db1.Model(gorm_model.YounggeeDataInfo{}).Where("task_id IN ? AND is_submit=? ", taskIds, 1)
+	if conditions.DataStatus == int64(0) {
+		db1 = db1.Where("is_review = 0").Find(&DataInfos)
+	} else {
+		db1 = db1.Where("is_ok = 1").Find(&DataInfos)
+	}
+	DataMap := make(map[int]gorm_model.YounggeeDataInfo)
+	for _, DataInfo := range DataInfos {
+		DataMap[conv.MustInt(DataInfo.TaskID, 0)] = DataInfo
+	}
+	// 查询总数
+	var totalData int64
+	if err := db1.Count(&totalData).Error; err != nil {
+		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
+	offset := pageSize * pageNum // assert pageNum start with 0
+	err := db.Order("task_id").Limit(int(limit)).Offset(int(offset)).Error
+
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[GetProjectTaskList] error query mysql total, err:%+v", err)
+		return nil, 0, err
+	}
+
+	var TaskDatas []*http_model.TaskData
+	var taskDatas []*http_model.TaskDataInfo
+	var newTaskDatas []*http_model.TaskDataInfo
+	for _, taskId := range taskIds {
+		TaskData := new(http_model.TaskData)
+		TaskData.Talent = taskMap[taskId]
+		TaskData.Data = DataMap[taskId]
+		TaskDatas = append(TaskDatas, TaskData)
+	}
+
+	taskDatas = pack.TaskDataToTaskInfo(TaskDatas)
+
+	for _, v := range taskDatas {
+		if platform_nickname == "" {
+			newTaskDatas = append(newTaskDatas, v)
+		} else if strings.Contains(v.PlatformNickname, platform_nickname) {
+			newTaskDatas = append(newTaskDatas, v)
+		} else {
+			totalTask--
+		}
+	}
+	// return fulltaskData, total, nil
+	return newTaskDatas, totalTask, nil
+}
+
+// DataOpinion 提交意见
+func DataOpinion(ctx context.Context, TaskID int, ReviseOpinion string) error {
+	db := GetReadDB(ctx)
+	err := db.Model(gorm_model.YounggeeDataInfo{}).Where("task_id = ? and is_review = 0", TaskID).Updates(map[string]interface{}{"revise_opinion": ReviseOpinion, "reject_at": time.Now(), "is_review": 1}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Data db] Update YounggeeDataInfo error,err:%+v", err)
+		return err
+	}
+	err = db.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", TaskID).Updates(gorm_model.YoungeeTaskInfo{DataStatus: 3}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Data db] Update YoungeeTaskInfo error,err:%+v", err)
+		return err
+	}
+	err = db.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", TaskID).Updates(gorm_model.YoungeeTaskInfo{TaskStage: 13}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Data db] Update YoungeeTaskInfo error,err:%+v", err)
+		return err
+	}
+	return nil
+}
+
+// AcceptData 同意数据-结案
+func AcceptData(ctx context.Context, TaskIDs []int) error {
+	db := GetReadDB(ctx)
+	err := db.Model(gorm_model.YounggeeDataInfo{}).Where("task_id in ?  and is_review = 0", TaskIDs).Updates(map[string]interface{}{"is_ok": 1, "is_review": 1, "agree_at": time.Now()}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Data db] Update YounggeeDataInfo error,err:%+v", err)
+		return err
+	}
+	err = db.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id in ?", TaskIDs).Updates(gorm_model.YoungeeTaskInfo{DataStatus: 5, TaskStage: 15, CompleteStatus: 2}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Data db] Update YoungeeTaskInfo error,err:%+v", err)
+		return err
+	}
+	return nil
+}

db/default.go

@@ -6,10 +6,12 @@ import (
 	"github.com/caixw/lib.go/conv"
 	"github.com/sirupsen/logrus"
 	"reflect"
+	"strings"
 	"youngee_m_api/consts"
 	"youngee_m_api/model/common_model"
 	"youngee_m_api/model/gorm_model"
 	"youngee_m_api/model/http_model"
+	"youngee_m_api/pack"
 	"youngee_m_api/util"
 )
 
@@ -380,3 +382,464 @@ func BreachHandled(ctx context.Context, pageSize, pageNum int32, req *http_model
 	BreachHandledData.Total = total
 	return &BreachHandledData, nil
 }
+
+func GetTaskDefaultReviewList(ctx context.Context, projectID string, pageSize, pageNum int64, conditions *common_model.TalentConditions) ([]*http_model.TaskDefaultReviewInfo, int64, error) {
+	db := GetReadDB(ctx)
+	// 查询Task表信息
+	db = db.Debug().Model(gorm_model.YoungeeTaskInfo{}).Where("task_status = 2")
+	// 根据Project条件过滤
+	conditionType := reflect.TypeOf(conditions).Elem()
+	conditionValue := reflect.ValueOf(conditions).Elem()
+	var platform_nickname string = ""
+	for i := 0; i < conditionType.NumField(); i++ {
+		field := conditionType.Field(i)
+		tag := field.Tag.Get("condition")
+		value := conditionValue.FieldByName(field.Name)
+		if tag == "default_status" {
+			fmt.Printf("default %+v", value.Interface() == int64(0))
+			if value.Interface() == int64(0) {
+				db = db.Where("cur_default_type = 1")
+			} else if value.Interface() == int64(1) {
+				db = db.Where("cur_default_type = 3")
+			} else if value.Interface() == int64(2) {
+				db = db.Where("cur_default_type = 5")
+			}
+			continue
+		}
+		if !util.IsBlank(value) {
+			logrus.Println("tag: ", tag)
+			if tag == "platform_nickname" {
+				platform_nickname = fmt.Sprintf("%v", value.Interface())
+				continue
+			} else if tag == "project_id" {
+				db = db.Where(fmt.Sprintf("%s = ?", tag), value.Interface())
+			} else if tag == "strategy_ids" {
+				strategyIds := strings.Split(fmt.Sprintf("%v", value.Interface()), ",")
+				var strategyIdList []int
+				for _, strategyId := range strategyIds {
+					strategyIdList = append(strategyIdList, conv.MustInt(strategyId, 0))
+				}
+				db = db.Where("strategy_id in ?", strategyIdList)
+			} else {
+				db = db.Where(fmt.Sprintf("%s like '%%%v%%'", tag, value.Interface()))
+			}
+		}
+	}
+	var taskInfos []gorm_model.YoungeeTaskInfo
+	db = db.Model(gorm_model.YoungeeTaskInfo{})
+	// 查询总数
+	var totalTask int64
+	if err := db.Count(&totalTask).Error; err != nil {
+		logrus.WithContext(ctx).Errorf("[GetProjectTaskList] error query mysql total, err:%+v", err)
+		return nil, 0, err
+	}
+	db.Order("task_id").Find(&taskInfos)
+
+	// 查询任务id
+	var taskIds []int
+	taskMap := make(map[int]gorm_model.YoungeeTaskInfo)
+	for _, taskInfo := range taskInfos {
+		taskIds = append(taskIds, taskInfo.TaskId)
+		taskMap[taskInfo.TaskId] = taskInfo
+	}
+	db1 := GetReadDB(ctx)
+	db1 = db1.Debug().Model(gorm_model.YoungeeContractInfo{})
+
+	var DefaultReviewInfos []gorm_model.YoungeeContractInfo
+	db1 = db1.Model(gorm_model.YoungeeContractInfo{}).Where("task_id IN ? AND default_status = 1", taskIds)
+	err := db1.Find(&DefaultReviewInfos).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[GetProjectTaskList] error query mysql total, err:%+v", err)
+		return nil, 0, err
+	}
+	DefaultReviewMap := make(map[int]gorm_model.YoungeeContractInfo)
+	for _, DefaultReviewInfo := range DefaultReviewInfos {
+		DefaultReviewMap[conv.MustInt(DefaultReviewInfo.TaskID, 0)] = DefaultReviewInfo
+	}
+	// 查询总数
+	var totalDefaultReview int64
+	if err := db1.Count(&totalDefaultReview).Error; err != nil {
+		logrus.WithContext(ctx).Errorf("[GetProjectTalentList] error query mysql total, err:%+v", err)
+		return nil, 0, err
+	}
+
+	// 查询该页数据
+	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 {
+		logrus.WithContext(ctx).Errorf("[GetProjectTaskList] error query mysql total, err:%+v", err)
+		return nil, 0, err
+	}
+
+	var TaskDefaultReviews []*http_model.TaskDefaultReview
+	var taskDefaultReviews []*http_model.TaskDefaultReviewInfo
+	var newTaskDefaultReviews []*http_model.TaskDefaultReviewInfo
+	for _, taskId := range taskIds {
+		TaskDefaultReview := new(http_model.TaskDefaultReview)
+		TaskDefaultReview.Talent = taskMap[taskId]
+		TaskDefaultReview.Default = DefaultReviewMap[taskId]
+		TaskDefaultReviews = append(TaskDefaultReviews, TaskDefaultReview)
+	}
+
+	taskDefaultReviews = pack.TaskDefaultReviewToTaskInfo(TaskDefaultReviews)
+
+	for _, v := range taskDefaultReviews {
+		if platform_nickname == "" {
+			newTaskDefaultReviews = append(newTaskDefaultReviews, v)
+		} else if strings.Contains(v.PlatformNickname, platform_nickname) {
+			newTaskDefaultReviews = append(newTaskDefaultReviews, v)
+		} else {
+			totalTask--
+		}
+	}
+	return newTaskDefaultReviews, totalTask, nil
+}
+
+func GetTaskDefaultDataList(ctx context.Context, projectID string, pageSize, pageNum int64, conditions *common_model.TalentConditions) ([]*http_model.TaskDefaultDataInfo, int64, error) {
+	db := GetReadDB(ctx)
+	// 查询Task表信息
+	db = db.Debug().Model(gorm_model.YoungeeTaskInfo{}).Where("task_status = 2")
+	// 根据Project条件过滤
+	conditionType := reflect.TypeOf(conditions).Elem()
+	conditionValue := reflect.ValueOf(conditions).Elem()
+	var platform_nickname string = ""
+	for i := 0; i < conditionType.NumField(); i++ {
+		field := conditionType.Field(i)
+		tag := field.Tag.Get("condition")
+		value := conditionValue.FieldByName(field.Name)
+		if tag == "default_status" {
+			if value.Interface() == int64(3) {
+				db = db.Where("cur_default_type = 7")
+			}
+			continue
+		} else if !util.IsBlank(value) {
+			logrus.Println("tag: ", tag)
+			if tag == "platform_nickname" {
+				platform_nickname = fmt.Sprintf("%v", value.Interface())
+				continue
+			} else if tag == "project_id" {
+				db = db.Where(fmt.Sprintf("%s = ?", tag), value.Interface())
+			} else if tag == "strategy_ids" {
+				strategyIds := strings.Split(fmt.Sprintf("%v", value.Interface()), ",")
+				var strategyIdList []int
+				for _, strategyId := range strategyIds {
+					strategyIdList = append(strategyIdList, conv.MustInt(strategyId, 0))
+				}
+				db = db.Where("strategy_id in ?", strategyIdList)
+			} else {
+				db = db.Where(fmt.Sprintf("%s like '%%%v%%'", tag, value.Interface()))
+			}
+		}
+	}
+	var taskInfos []gorm_model.YoungeeTaskInfo
+	db = db.Model(gorm_model.YoungeeTaskInfo{})
+	// 查询总数
+	var totalTask int64
+	if err := db.Count(&totalTask).Error; err != nil {
+		logrus.WithContext(ctx).Errorf("[GetProjectTaskList] error query mysql total, err:%+v", err)
+		return nil, 0, err
+	}
+	db.Order("task_id").Find(&taskInfos)
+
+	// 查询任务id
+	var taskIds []int
+	taskMap := make(map[int]gorm_model.YoungeeTaskInfo)
+	for _, taskInfo := range taskInfos {
+		taskIds = append(taskIds, taskInfo.TaskId)
+		taskMap[taskInfo.TaskId] = taskInfo
+	}
+	db1 := GetReadDB(ctx)
+	db1 = db1.Debug().Model(gorm_model.YoungeeContractInfo{})
+
+	var DefaultDataInfos []gorm_model.YoungeeContractInfo
+	db1 = db1.Model(gorm_model.YoungeeContractInfo{}).Where("task_id IN ? AND default_status = 1", taskIds)
+	err := db1.Find(&DefaultDataInfos).Error
+	DefaultDataMap := make(map[int]gorm_model.YoungeeContractInfo)
+	for _, DefaultDataInfo := range DefaultDataInfos {
+		DefaultDataMap[conv.MustInt(DefaultDataInfo.TaskID, 0)] = DefaultDataInfo
+	}
+
+	var LinkInfos []gorm_model.YounggeeLinkInfo
+	db2 := GetReadDB(ctx)
+	db2 = db2.Model(gorm_model.YounggeeLinkInfo{}).Where("task_id IN ? AND is_ok = 1", taskIds).Find(&LinkInfos)
+	LinkMap := make(map[int]gorm_model.YounggeeLinkInfo)
+	for _, LinkInfo := range LinkInfos {
+		LinkMap[conv.MustInt(LinkInfo.TaskID, 0)] = LinkInfo
+	}
+
+	// 查询总数
+	var totalDefaultData int64
+	if err := db2.Count(&totalDefaultData).Error; err != nil {
+		logrus.WithContext(ctx).Errorf("[GetProjectTalentList] error query mysql total, err:%+v", err)
+		return nil, 0, err
+	}
+
+	// 查询该页数据
+	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 {
+		logrus.WithContext(ctx).Errorf("[GetProjectTaskList] error query mysql total, err:%+v", err)
+		return nil, 0, err
+	}
+
+	var TaskDefaultDatas []*http_model.TaskDefaultData
+	var taskDefaultDatas []*http_model.TaskDefaultDataInfo
+	var newTaskDefaultDatas []*http_model.TaskDefaultDataInfo
+	for _, taskId := range taskIds {
+		TaskDefaultData := new(http_model.TaskDefaultData)
+		TaskDefaultData.Talent = taskMap[taskId]
+		TaskDefaultData.Default = DefaultDataMap[taskId]
+		TaskDefaultData.Link = LinkMap[taskId]
+		TaskDefaultDatas = append(TaskDefaultDatas, TaskDefaultData)
+	}
+
+	taskDefaultDatas = pack.TaskDefaultDataToTaskInfo(TaskDefaultDatas)
+
+	for _, v := range taskDefaultDatas {
+		if platform_nickname == "" {
+			newTaskDefaultDatas = append(newTaskDefaultDatas, v)
+		} else if strings.Contains(v.PlatformNickname, platform_nickname) {
+			newTaskDefaultDatas = append(newTaskDefaultDatas, v)
+		} else {
+			totalTask--
+		}
+	}
+	return newTaskDefaultDatas, totalTask, nil
+}
+
+func GetTaskTerminatingList(ctx context.Context, projectID string, pageSize, pageNum int64, conditions *common_model.TalentConditions) ([]*http_model.TaskTerminatingInfo, int64, error) {
+	db := GetReadDB(ctx)
+
+	var taskIds1 []int
+	var totalTerminating int64
+	var TerminatingInfos []gorm_model.YoungeeContractInfo
+	db = db.Model(gorm_model.YoungeeContractInfo{})
+	err := db.Where("default_status = 3").Find(&TerminatingInfos).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[GetProjectTaskList] error query mysql total, err:%+v", err)
+		return nil, 0, err
+	}
+	TerminatingMap := make(map[int]gorm_model.YoungeeContractInfo)
+	for _, TerminatingInfo := range TerminatingInfos {
+		taskIds1 = append(taskIds1, TerminatingInfo.TaskID)
+		TerminatingMap[conv.MustInt(TerminatingInfo.TaskID, 0)] = TerminatingInfo
+	}
+
+	if err := db.Count(&totalTerminating).Error; err != nil {
+		logrus.WithContext(ctx).Errorf("[GetProjectTalentList] error query mysql total, err:%+v", err)
+		return nil, 0, err
+	}
+
+	db1 := GetReadDB(ctx)
+	// 查询Task表信息
+	db1 = db1.Model(gorm_model.YoungeeTaskInfo{}).Where("task_status = 2 and task_id in ?", taskIds1)
+	// 根据Project条件过滤
+	conditionType := reflect.TypeOf(conditions).Elem()
+	conditionValue := reflect.ValueOf(conditions).Elem()
+	var platform_nickname string = ""
+	for i := 0; i < conditionType.NumField(); i++ {
+		field := conditionType.Field(i)
+		tag := field.Tag.Get("condition")
+		value := conditionValue.FieldByName(field.Name)
+		if tag == "default_status" {
+			if value.Interface() == int64(4) {
+				db = db.Where("cur_default_type = 9")
+			}
+			continue
+		} else if !util.IsBlank(value) {
+			logrus.Println("tag: ", tag)
+			if tag == "platform_nickname" {
+				platform_nickname = fmt.Sprintf("%v", value.Interface())
+				continue
+			} else if tag == "project_id" {
+				db1 = db1.Where(fmt.Sprintf("%s = ?", tag), value.Interface())
+			} else if tag == "strategy_ids" {
+				strategyIds := strings.Split(fmt.Sprintf("%v", value.Interface()), ",")
+				var strategyIdList []int
+				for _, strategyId := range strategyIds {
+					strategyIdList = append(strategyIdList, conv.MustInt(strategyId, 0))
+				}
+				db1 = db1.Where("strategy_id in ?", strategyIdList)
+			} else {
+				db1 = db1.Where(fmt.Sprintf("%s like '%%%v%%'", tag, value.Interface()))
+			}
+		}
+	}
+	var taskInfos []gorm_model.YoungeeTaskInfo
+	// db1 = db1.Model(gorm_model.YoungeeTaskInfo{})
+	// 查询总数
+	var totalTask int64
+	if err := db1.Count(&totalTask).Error; err != nil {
+		logrus.WithContext(ctx).Errorf("[GetProjectTaskList] error query mysql total, err:%+v", err)
+		return nil, 0, err
+	}
+	db1.Order("task_id").Find(&taskInfos)
+
+	// 查询任务id
+	var taskIds []int
+	taskMap := make(map[int]gorm_model.YoungeeTaskInfo)
+	for _, taskInfo := range taskInfos {
+		taskIds = append(taskIds, taskInfo.TaskId)
+		taskMap[taskInfo.TaskId] = taskInfo
+	}
+	var misNum int64
+	if totalTerminating > totalTask {
+		misNum = totalTerminating - totalTask
+	} else {
+		misNum = totalTask - totalTerminating
+	}
+	logrus.Println("totalTerminating,totalTalent,misNum:", totalTerminating, totalTask, misNum)
+
+	// 查询该页数据
+	limit := pageSize + misNum
+	offset := pageSize * pageNum // assert pageNum start with 0
+	err = db1.Order("task_id").Limit(int(limit)).Offset(int(offset)).Error
+
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[GetProjectTaskList] error query mysql total, err:%+v", err)
+		return nil, 0, err
+	}
+
+	var TaskTerminatings []*http_model.TaskTerminating
+	var taskTerminatings []*http_model.TaskTerminatingInfo
+	var newTaskTerminatings []*http_model.TaskTerminatingInfo
+	for _, taskId := range taskIds {
+		TaskTerminating := new(http_model.TaskTerminating)
+		TaskTerminating.Talent = taskMap[taskId]
+		TaskTerminating.Default = TerminatingMap[taskId]
+		TaskTerminatings = append(TaskTerminatings, TaskTerminating)
+	}
+
+	taskTerminatings = pack.TaskTerminatingToTaskInfo(TaskTerminatings)
+
+	for _, v := range taskTerminatings {
+		if platform_nickname == "" {
+			newTaskTerminatings = append(newTaskTerminatings, v)
+		} else if strings.Contains(v.PlatformNickname, platform_nickname) {
+			newTaskTerminatings = append(newTaskTerminatings, v)
+		} else {
+			totalTask--
+		}
+	}
+	return newTaskTerminatings, totalTask, nil
+}
+
+func GetTaskTerminatedList(ctx context.Context, projectID string, pageSize, pageNum int64, conditions *common_model.TalentConditions) ([]*http_model.TaskTerminatedInfo, int64, error) {
+	db := GetReadDB(ctx)
+	// 查询Task表信息
+	db = db.Debug().Model(gorm_model.YoungeeTaskInfo{}).Where("task_status = 2")
+	// 根据Project条件过滤
+	conditionType := reflect.TypeOf(conditions).Elem()
+	conditionValue := reflect.ValueOf(conditions).Elem()
+	var platform_nickname string = ""
+	for i := 0; i < conditionType.NumField(); i++ {
+		field := conditionType.Field(i)
+		tag := field.Tag.Get("condition")
+		value := conditionValue.FieldByName(field.Name)
+		if tag == "default_status" {
+			fmt.Printf("default %+v", value.Interface() == int64(0))
+			if value.Interface() == int64(5) {
+				db = db.Where("complete_status = 4")
+			}
+			continue
+		} else if !util.IsBlank(value) {
+			logrus.Println("tag: ", tag)
+			if tag == "platform_nickname" {
+				platform_nickname = fmt.Sprintf("%v", value.Interface())
+				continue
+			} else if tag == "project_id" {
+				db = db.Where(fmt.Sprintf("%s = ?", tag), value.Interface())
+			} else if tag == "strategy_ids" {
+				strategyIds := strings.Split(fmt.Sprintf("%v", value.Interface()), ",")
+				var strategyIdList []int
+				for _, strategyId := range strategyIds {
+					strategyIdList = append(strategyIdList, conv.MustInt(strategyId, 0))
+				}
+				db = db.Where("strategy_id in ?", strategyIdList)
+			} else {
+				db = db.Where(fmt.Sprintf("%s like '%%%v%%'", tag, value.Interface()))
+			}
+		}
+	}
+	var taskInfos []gorm_model.YoungeeTaskInfo
+	db = db.Model(gorm_model.YoungeeTaskInfo{})
+	// 查询总数
+	var totalTask int64
+	if err := db.Count(&totalTask).Error; err != nil {
+		logrus.WithContext(ctx).Errorf("[GetProjectTaskList] error query mysql total, err:%+v", err)
+		return nil, 0, err
+	}
+	db.Order("task_id").Find(&taskInfos)
+
+	// 查询任务id
+	var taskIds []int
+	taskMap := make(map[int]gorm_model.YoungeeTaskInfo)
+	for _, taskInfo := range taskInfos {
+		taskIds = append(taskIds, taskInfo.TaskId)
+		taskMap[taskInfo.TaskId] = taskInfo
+	}
+	db1 := GetReadDB(ctx)
+	db1 = db1.Debug().Model(gorm_model.YoungeeContractInfo{})
+
+	var TerminatedInfos []gorm_model.YoungeeContractInfo
+	db1 = db1.Model(gorm_model.YoungeeContractInfo{}).Where("task_id IN ? AND default_status = 1", taskIds)
+	err1 := db1.Find(&TerminatedInfos).Error
+	if err1 != nil {
+		logrus.WithContext(ctx).Errorf("[GetProjectTalentList] error query mysql find, err:%+v", err1)
+		return nil, 0, err1
+	}
+	TerminatedMap := make(map[int]gorm_model.YoungeeContractInfo)
+	for _, TerminatedInfo := range TerminatedInfos {
+		TerminatedMap[conv.MustInt(TerminatedInfo.TaskID, 0)] = TerminatedInfo
+	}
+	// 查询总数
+	var totalTerminated int64
+	if err := db1.Count(&totalTerminated).Error; err != nil {
+		logrus.WithContext(ctx).Errorf("[GetProjectTalentList] error query mysql total, err:%+v", err)
+		return nil, 0, err
+	}
+	var misNum int64
+	if totalTerminated > totalTask {
+		misNum = totalTerminated - totalTask
+	} else {
+		misNum = totalTask - totalTerminated
+	}
+	logrus.Println("totalTerminated,totalTalent,misNum:", totalTerminated, totalTask, misNum)
+
+	// 查询该页数据
+	limit := pageSize + misNum
+	offset := pageSize * pageNum // assert pageNum start with 0
+	err := db.Order("task_id").Limit(int(limit)).Offset(int(offset)).Error
+
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[GetProjectTaskList] error query mysql total, err:%+v", err)
+		return nil, 0, err
+	}
+
+	var TaskTerminateds []*http_model.TaskTerminated
+	var taskTerminateds []*http_model.TaskTerminatedInfo
+	var newTaskTerminateds []*http_model.TaskTerminatedInfo
+	for _, taskId := range taskIds {
+		TaskTerminated := new(http_model.TaskTerminated)
+		TaskTerminated.Talent = taskMap[taskId]
+		TaskTerminated.Default = TerminatedMap[taskId]
+		TaskTerminateds = append(TaskTerminateds, TaskTerminated)
+	}
+
+	taskTerminateds = pack.TaskTerminatedToTaskInfo(TaskTerminateds)
+
+	for _, v := range taskTerminateds {
+		if platform_nickname == "" {
+			newTaskTerminateds = append(newTaskTerminateds, v)
+		} else if strings.Contains(v.PlatformNickname, platform_nickname) {
+			newTaskTerminateds = append(newTaskTerminateds, v)
+		} else {
+			totalTask--
+		}
+	}
+	return newTaskTerminateds, totalTask, nil
+}

db/finance.go

@@ -6,6 +6,9 @@ import (
 	"github.com/caixw/lib.go/conv"
 	"github.com/sirupsen/logrus"
 	"reflect"
+	"strconv"
+	"strings"
+	"time"
 	"youngee_m_api/model/common_model"
 	"youngee_m_api/model/gorm_model"
 	"youngee_m_api/model/http_model"
@@ -67,11 +70,13 @@ func GetWithdrawRecords(ctx context.Context, pageSize, pageNum int32, req *http_
 	var withdrawRecordsDatas []*http_model.WithdrawalRecordsData
 	for _, withdrawRecord := range withdrawRecords {
 		withdrawRecordsData := new(http_model.WithdrawalRecordsData)
+		withdrawRecordsData.WithdrawId = withdrawRecord.WithdrawID
 		withdrawRecordsData.TalentId = withdrawRecord.TalentID
 		withdrawRecordsData.TalentName = talentIdToTalentInfoMap[withdrawRecord.TalentID].TalentWxNickname
 		withdrawRecordsData.WithdrawAmount = float32(withdrawRecord.WithdrawAmount)
 		withdrawRecordsData.AmountPayable = float32(withdrawRecord.AmountPayable)
 		withdrawRecordsData.ReceiveInfo = withdrawRecord.ReceiveInfo
+		withdrawRecordsData.BankType = withdrawRecord.BankType
 		withdrawRecordsData.Phone = talentIdToTalentInfoMap[withdrawRecord.TalentID].TalentPhoneNumber
 		withdrawRecordsData.SubmitAt = conv.MustString(withdrawRecord.SubmitAt, "")[0:19]
 		withdrawRecordsData.WithdrawAt = conv.MustString(withdrawRecord.WithdrawAt, "")[0:19]
@@ -99,3 +104,155 @@ func GetWithdrawRecord(ctx context.Context, req *http_model.GetWithdrawalRecordR
 	withdrawRecordsPreview.WithdrawalRecordData = withdrawRecordsDatas
 	return &withdrawRecordsPreview, nil
 }
+
+func GetWithdrawNums(ctx context.Context) (*http_model.WithdrawNums, error) {
+	var withdrawNums int64
+	db := GetReadDB(ctx)
+	err := db.Model(gorm_model.YounggeeWithdrawRecord{}).Where("status = 1").Count(&withdrawNums).Error
+	if err != nil {
+		return nil, err
+	}
+	WithdrawNums := new(http_model.WithdrawNums)
+	WithdrawNums.WithdrawNums = int(withdrawNums)
+	return WithdrawNums, err
+}
+
+func ConfirmWithdrawal(ctx context.Context, withdrawId string) error {
+	db := GetReadDB(ctx)
+	db2 := GetReadDB(ctx)
+	var task_id_list string
+	db = db.Debug().Model(gorm_model.YounggeeWithdrawRecord{}).Select("task_id_list").Where("withdraw_id = ?", withdrawId).Find(&task_id_list)
+	db2.Debug().Where("withdraw_id = ?", withdrawId).Updates(gorm_model.YounggeeWithdrawRecord{Status: 2, WithdrawAt: time.Now()})
+	taskIdLists := strings.Split(task_id_list, ",")
+	for _, taskIdList := range taskIdLists {
+		db1 := GetReadDB(ctx)
+		db1.Debug().Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", conv.MustInt(taskIdList, 0)).Updates(gorm_model.YoungeeTaskInfo{WithdrawStatus: 4})
+	}
+	return nil
+}
+
+func GetBankInfo(ctx context.Context, req *http_model.GetBankInfoRequest) (*http_model.BankInfo, error) {
+	db := GetReadDB(ctx)
+	var infoBank *gorm_model.InfoBank
+	db.Debug().Model(gorm_model.InfoBank{}).Where("id = ?", req.BankId).First(&infoBank)
+	db1 := GetReadDB(ctx)
+	var infoRegion *gorm_model.InfoRegion
+	db1.Debug().Model(gorm_model.InfoRegion{}).Where("self_code = ?", conv.MustInt(req.BankOpenAddress, 0)).First(&infoRegion)
+
+	provinceCode := conv.MustString(req.BankOpenAddress, "")[0:2] + "0000"
+	var province *gorm_model.InfoRegion
+	db1.Debug().Model(gorm_model.InfoRegion{}).Where("self_code = ?", conv.MustInt(provinceCode, 0)).First(&province)
+
+	cityCode := conv.MustString(req.BankOpenAddress, "")[0:4] + "00"
+	var city *gorm_model.InfoRegion
+	db1.Debug().Model(gorm_model.InfoRegion{}).Where("self_code = ?", conv.MustInt(cityCode, 0)).First(&city)
+	data := new(http_model.BankInfo)
+	data.BankName = infoBank.Name
+	data.BankOpenAddress = province.RegionName + city.RegionName + infoRegion.RegionName
+	db.Model(gorm_model.InfoBank{}).Where("")
+	return data, nil
+}
+
+// GetEnterpriseIDByBusiness 根据企业名称查找企业ID
+func GetEnterpriseIDByBusiness(ctx context.Context, BusinessName string) int64 {
+	db := GetReadDB(ctx)
+	var EnterpriseID int64
+	db = db.Model([]gorm_model.Enterprise{}).Select("enterprise_id").Where("business_name", BusinessName).First(&EnterpriseID)
+	return EnterpriseID
+}
+
+// GetEnterpriseIDByUserId 根据企业名称查找企业ID
+func GetEnterpriseIDByUserId(ctx context.Context, UserId int64) int64 {
+	db := GetReadDB(ctx)
+	var EnterpriseID int64
+	db = db.Model([]gorm_model.Enterprise{}).Select("enterprise_id").Where("user_id", UserId).First(&EnterpriseID)
+	return EnterpriseID
+}
+
+func GetInvoiceRecords(ctx context.Context, req *http_model.InvoiceRecordsRequest, condition *common_model.InvoiceRecordsCondition) (*http_model.InvoiceRecordsData, error) {
+	db := GetReadDB(ctx)
+	var invoiceRecords []*gorm_model.YounggeeInvoiceRecord
+	db = db.Debug().Model(gorm_model.YounggeeInvoiceRecord{}).Where("status = ?", req.InvoiceStatus)
+	conditionType := reflect.TypeOf(condition).Elem()
+	conditionValue := reflect.ValueOf(condition).Elem()
+	for i := 0; i < conditionType.NumField(); i++ {
+		field := conditionType.Field(i)
+		tag := field.Tag.Get("condition")
+		value := conditionValue.FieldByName(field.Name)
+		if tag == "submit_at" && value.Interface() != "" {
+			db = db.Where(fmt.Sprintf("submit_at like '%s%%'", value.Interface()))
+		}
+		if tag == "billing_at" && value.Interface() != "" {
+			db = db.Where(fmt.Sprintf("billing_at like '%s%%'", value.Interface()))
+		}
+	}
+	if req.BusinessName != "" {
+		enterpriseId := GetEnterpriseIDByBusiness(ctx, req.BusinessName)
+		db = db.Where("enterprise_id = ?", enterpriseId)
+	}
+	if req.UserId != 0 {
+		enterpriseId := GetEnterpriseIDByUserId(ctx, req.UserId)
+		db = db.Where("enterprise_id = ?", enterpriseId)
+	}
+	// 查询总数
+	var total int64
+	if err := db.Count(&total).Error; err != nil {
+		logrus.WithContext(ctx).Errorf("[GetInvoiceRecords] error query mysql total, err:%+v", err)
+		return nil, err
+	}
+	if req.InvoiceStatus == 1 {
+		db.Order("submit_at")
+	} else {
+		db.Order("submit_at desc")
+	}
+	// 查询该页数据
+	limit := req.PageSize
+	offset := req.PageSize * req.PageNum // assert pageNum start with 0
+	err := db.Limit(int(limit)).Offset(int(offset)).Find(&invoiceRecords).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[GetInvoiceRecords] error query mysql limit, err:%+v", err)
+		return nil, err
+	}
+	var enterpriseIds []int64
+	for _, invoiceRecord := range invoiceRecords {
+		enterpriseIds = append(enterpriseIds, invoiceRecord.EnterpriseID)
+	}
+	util.RemoveRepByMap(enterpriseIds)
+	enterpriseIdToUserInfoMap := make(map[int64]gorm_model.Enterprise)
+	db1 := GetReadDB(ctx)
+	for _, v := range enterpriseIds {
+		enterpriseInfo := gorm_model.Enterprise{}
+		db1.Model(gorm_model.Enterprise{}).Where("enterprise_id = ?", v).Find(&enterpriseInfo)
+		enterpriseIdToUserInfoMap[v] = enterpriseInfo
+	}
+	var InvoiceRecords []*http_model.InvoiceRecordsPreviews
+	for _, invoiceRecord := range invoiceRecords {
+		InvoiceRecord := new(http_model.InvoiceRecordsPreviews)
+		InvoiceRecord.BillingId = invoiceRecord.BillingID
+		InvoiceRecord.InvoiceInfo = invoiceRecord.InvoiceSnap
+		InvoiceRecord.AddressInfo = invoiceRecord.AddressSnap
+		InvoiceRecord.InvoiceType = invoiceRecord.InvoiceType
+		InvoiceRecord.Amount = invoiceRecord.InvoiceAmount
+		InvoiceRecord.Phone = invoiceRecord.Phone
+		InvoiceRecord.ShipmentNumber = invoiceRecord.ShipmentNumber
+		InvoiceRecord.BusinessName = enterpriseIdToUserInfoMap[invoiceRecord.EnterpriseID].BusinessName
+		InvoiceRecord.UserId = enterpriseIdToUserInfoMap[invoiceRecord.EnterpriseID].UserID
+		InvoiceRecord.SubmitAt = conv.MustString(invoiceRecord.SubmitAt, "")[:19]
+		InvoiceRecord.BillingAt = conv.MustString(invoiceRecord.BillingAt, "")[:19]
+		InvoiceRecords = append(InvoiceRecords, InvoiceRecord)
+	}
+	var InvoiceRecordsData http_model.InvoiceRecordsData
+	InvoiceRecordsData.InvoiceRecordsPreviews = InvoiceRecords
+	InvoiceRecordsData.Total = strconv.FormatInt(total, 10)
+	return &InvoiceRecordsData, nil
+}
+
+func ConfirmInvoice(ctx context.Context, request *http_model.ConfirmInvoiceRequest) error {
+	db := GetReadDB(ctx)
+	return db.Model(gorm_model.YounggeeInvoiceRecord{}).Where("billing_id = ?", request.BillingId).Updates(
+		gorm_model.YounggeeInvoiceRecord{
+			BillingAt:      time.Now(),
+			ShipmentNumber: request.ShipmentNumber,
+			Status:         2,
+		}).Error
+}

db/finish.go

@@ -0,0 +1,131 @@
+package db
+
+import (
+	"context"
+	"fmt"
+	"github.com/caixw/lib.go/conv"
+	"github.com/sirupsen/logrus"
+	"reflect"
+	"strings"
+	"youngee_m_api/model/common_model"
+	"youngee_m_api/model/gorm_model"
+	"youngee_m_api/model/http_model"
+	"youngee_m_api/pack"
+	"youngee_m_api/util"
+)
+
+func GetTaskFinishList(ctx context.Context, projectID string, pageSize, pageNum int64, conditions *common_model.TalentConditions) ([]*http_model.TaskFinishInfo, int64, error) {
+	db := GetReadDB(ctx)
+	// 查询Task表信息
+	db = db.Debug().Model(gorm_model.YoungeeTaskInfo{}).Where("task_status = 2 and task_stage = 15")
+	// 根据Project条件过滤
+	conditionType := reflect.TypeOf(conditions).Elem()
+	conditionValue := reflect.ValueOf(conditions).Elem()
+	var platform_nickname string = ""
+	for i := 0; i < conditionType.NumField(); i++ {
+		field := conditionType.Field(i)
+		tag := field.Tag.Get("condition")
+		value := conditionValue.FieldByName(field.Name)
+		if !util.IsBlank(value) {
+			logrus.Println("tag: ", tag)
+			if tag == "platform_nickname" {
+				platform_nickname = fmt.Sprintf("%v", value.Interface())
+				continue
+			} else if tag == "project_id" {
+				db = db.Where(fmt.Sprintf("%s = ?", tag), value.Interface())
+			} else if tag == "strategy_ids" {
+				strategyIds := strings.Split(fmt.Sprintf("%v", value.Interface()), ",")
+				var strategyIdList []int
+				for _, strategyId := range strategyIds {
+					strategyIdList = append(strategyIdList, conv.MustInt(strategyId, 0))
+				}
+				db = db.Where("strategy_id in ?", strategyIdList)
+			} else {
+				db = db.Where(fmt.Sprintf("%s like '%%%v%%'", tag, value.Interface()))
+			}
+		}
+	}
+	var taskInfos []gorm_model.YoungeeTaskInfo
+	db = db.Model(gorm_model.YoungeeTaskInfo{})
+	// 查询总数
+	var totalTask int64
+	if err := db.Count(&totalTask).Error; err != nil {
+		logrus.WithContext(ctx).Errorf("[GetProjectTaskList] error query mysql total, err:%+v", err)
+		return nil, 0, err
+	}
+	db.Order("task_id").Find(&taskInfos)
+
+	// 查询任务id
+	var taskIds []int
+	taskMap := make(map[int]gorm_model.YoungeeTaskInfo)
+	for _, taskInfo := range taskInfos {
+		taskIds = append(taskIds, taskInfo.TaskId)
+		taskMap[taskInfo.TaskId] = taskInfo
+	}
+	db1 := GetReadDB(ctx)
+	db1 = db1.Debug().Model(gorm_model.YounggeeDataInfo{})
+
+	var DataInfos []gorm_model.YounggeeDataInfo
+	db1 = db1.Model(gorm_model.YounggeeDataInfo{}).Where("task_id IN ? AND is_ok = 1", taskIds)
+	err := db1.Find(&DataInfos).Error
+	DataMap := make(map[int]gorm_model.YounggeeDataInfo)
+	for _, DataInfo := range DataInfos {
+		DataMap[conv.MustInt(DataInfo.TaskID, 0)] = DataInfo
+	}
+
+	var LinkInfos []gorm_model.YounggeeLinkInfo
+	db2 := GetReadDB(ctx)
+	db2 = db2.Model(gorm_model.YounggeeLinkInfo{}).Where("task_id IN ? AND is_ok = 1", taskIds).Find(&LinkInfos)
+	LinkMap := make(map[int]gorm_model.YounggeeLinkInfo)
+	for _, LinkInfo := range LinkInfos {
+		LinkMap[conv.MustInt(LinkInfo.TaskID, 0)] = LinkInfo
+	}
+
+	// 查询总数
+	var totalData int64
+	if err := db2.Count(&totalData).Error; err != nil {
+		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
+	offset := pageSize * pageNum // assert pageNum start with 0
+	err = db.Order("task_id").Limit(int(limit)).Offset(int(offset)).Error
+
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[GetProjectTaskList] error query mysql total, err:%+v", err)
+		return nil, 0, err
+	}
+
+	var TaskFinishs []*http_model.TaskFinish
+	var taskDatas []*http_model.TaskFinishInfo
+	var newTaskFinishs []*http_model.TaskFinishInfo
+	for _, taskId := range taskIds {
+		TaskFinish := new(http_model.TaskFinish)
+		TaskFinish.Talent = taskMap[taskId]
+		TaskFinish.Data = DataMap[taskId]
+		TaskFinish.Link = LinkMap[taskId]
+		TaskFinishs = append(TaskFinishs, TaskFinish)
+	}
+
+	taskDatas = pack.TaskFinishToTaskInfo(TaskFinishs)
+
+	for _, v := range taskDatas {
+		if platform_nickname == "" {
+			newTaskFinishs = append(newTaskFinishs, v)
+		} else if strings.Contains(v.PlatformNickname, platform_nickname) {
+			newTaskFinishs = append(newTaskFinishs, v)
+		} else {
+			totalTask--
+		}
+	}
+	return newTaskFinishs, totalTask, nil
+}

db/link.go

@@ -0,0 +1,169 @@
+package db
+
+import (
+	"context"
+	"fmt"
+	"github.com/caixw/lib.go/conv"
+	"github.com/sirupsen/logrus"
+	"reflect"
+	"strings"
+	"time"
+	"youngee_m_api/model/common_model"
+	"youngee_m_api/model/gorm_model"
+	"youngee_m_api/model/http_model"
+	"youngee_m_api/pack"
+	"youngee_m_api/util"
+)
+
+// GetTaskLinkList 查询上传链接的task list
+func GetTaskLinkList(ctx context.Context, projectID string, pageSize, pageNum int64, conditions *common_model.TalentConditions) ([]*http_model.TaskLinkInfo, int64, error) {
+	db := GetReadDB(ctx)
+	// 查询Task表信息
+	db = db.Debug().Model(gorm_model.YoungeeTaskInfo{}).Where("task_status = 2")
+	// 根据Project条件过滤
+	conditionType := reflect.TypeOf(conditions).Elem()
+	conditionValue := reflect.ValueOf(conditions).Elem()
+	var platform_nickname string = ""
+	for i := 0; i < conditionType.NumField(); i++ {
+		field := conditionType.Field(i)
+		tag := field.Tag.Get("condition")
+		value := conditionValue.FieldByName(field.Name)
+		if tag == "link_status" {
+			fmt.Printf("link %+v", value.Interface() == int64(0))
+			if value.Interface() == int64(0) {
+				db = db.Where("task_stage = ?", 12)
+			} else {
+				db = db.Where("task_stage > ?", 12)
+			}
+			continue
+		} else if !util.IsBlank(value) {
+			logrus.Println("tag: ", tag)
+			if tag == "platform_nickname" {
+				platform_nickname = fmt.Sprintf("%v", value.Interface())
+				continue
+			} else if tag == "project_id" {
+				db = db.Where(fmt.Sprintf("%s = ?", tag), value.Interface())
+			} else if tag == "strategy_ids" {
+				strategyIds := strings.Split(fmt.Sprintf("%v", value.Interface()), ",")
+				var strategyIdList []int
+				for _, strategyId := range strategyIds {
+					strategyIdList = append(strategyIdList, conv.MustInt(strategyId, 0))
+				}
+				db = db.Where("strategy_id in ?", strategyIdList)
+			} else {
+				db = db.Where(fmt.Sprintf("%s like '%%%v%%'", tag, value.Interface()))
+			}
+		}
+	}
+	var taskInfos []gorm_model.YoungeeTaskInfo
+	db = db.Model(gorm_model.YoungeeTaskInfo{})
+	// 查询总数
+	var totalTask int64
+	if err := db.Count(&totalTask).Error; err != nil {
+		logrus.WithContext(ctx).Errorf("[GetProjectTaskList] error query mysql total, err:%+v", err)
+		return nil, 0, err
+	}
+	db.Order("task_id").Find(&taskInfos)
+
+	// 查询任务id
+	var taskIds []int
+	taskMap := make(map[int]gorm_model.YoungeeTaskInfo)
+	for _, taskInfo := range taskInfos {
+		taskIds = append(taskIds, taskInfo.TaskId)
+		taskMap[taskInfo.TaskId] = taskInfo
+	}
+	db1 := GetReadDB(ctx)
+	db1 = db1.Debug().Model(gorm_model.YounggeeLinkInfo{})
+
+	var LinkInfos []gorm_model.YounggeeLinkInfo
+	db1 = db1.Model(gorm_model.YounggeeLinkInfo{}).Where("task_id IN ? AND is_submit=? ", taskIds, 1)
+	if conditions.LinkStatus == int64(0) {
+		db1 = db1.Where("is_review = 0").Find(&LinkInfos)
+	} else {
+		db1 = db1.Where("is_ok = 1").Find(&LinkInfos)
+	}
+	LinkMap := make(map[int]gorm_model.YounggeeLinkInfo)
+	for _, LinkInfo := range LinkInfos {
+		LinkMap[conv.MustInt(LinkInfo.TaskID, 0)] = LinkInfo
+	}
+	// 查询总数
+	var totalLink int64
+	if err := db1.Count(&totalLink).Error; err != nil {
+		logrus.WithContext(ctx).Errorf("[GetProjectTalentList] error query mysql total, err:%+v", err)
+		return nil, 0, err
+	}
+
+	// 查询该页数据
+	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 {
+		logrus.WithContext(ctx).Errorf("[GetProjectTaskList] error query mysql total, err:%+v", err)
+		return nil, 0, err
+	}
+
+	var TaskLinks []*http_model.TaskLink
+	var taskLinks []*http_model.TaskLinkInfo
+	var newTaskLinks []*http_model.TaskLinkInfo
+	for _, taskId := range taskIds {
+		TaskLink := new(http_model.TaskLink)
+		TaskLink.Talent = taskMap[taskId]
+		TaskLink.Link = LinkMap[taskId]
+		TaskLinks = append(TaskLinks, TaskLink)
+	}
+
+	taskLinks = pack.TaskLinkToTaskInfo(TaskLinks)
+
+	for _, v := range taskLinks {
+		if platform_nickname == "" {
+			newTaskLinks = append(newTaskLinks, v)
+		} else if strings.Contains(v.PlatformNickname, platform_nickname) {
+			newTaskLinks = append(newTaskLinks, v)
+		} else {
+			totalTask--
+		}
+	}
+	return newTaskLinks, totalTask, nil
+}
+
+// LinkOpinion 提交意见
+func LinkOpinion(ctx context.Context, TaskID int, ReviseOpinion string) error {
+	db := GetReadDB(ctx)
+	err := db.Model(gorm_model.YounggeeLinkInfo{}).Where("task_id = ? and is_review = 0", TaskID).Updates(map[string]interface{}{"revise_opinion": ReviseOpinion, "reject_at": time.Now(), "is_review": 1}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Link db] Update YounggeeLinkInfo error,err:%+v", err)
+		return err
+	}
+	err = db.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", TaskID).Updates(gorm_model.YoungeeTaskInfo{LinkStatus: 3}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Link db] Update YoungeeTaskInfo error,err:%+v", err)
+		return err
+	}
+	err = db.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", TaskID).Updates(gorm_model.YoungeeTaskInfo{TaskStage: 11}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Link db] Update YoungeeTaskInfo error,err:%+v", err)
+		return err
+	}
+	return nil
+}
+
+// AcceptLink 同意链接
+func AcceptLink(ctx context.Context, TaskIDs []int) error {
+	db := GetReadDB(ctx)
+	err := db.Model(gorm_model.YounggeeLinkInfo{}).Where("task_id in ?  and is_review = 0", TaskIDs).Updates(map[string]interface{}{"is_ok": 1, "is_review": 1, "agree_at": time.Now()}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Link db] Update YounggeeLinkInfo error,err:%+v", err)
+		return err
+	}
+	err = db.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id in ?", TaskIDs).Updates(gorm_model.YoungeeTaskInfo{LinkStatus: 5}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Link db] Update YoungeeTaskInfo error,err:%+v", err)
+		return err
+	}
+	err = db.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id in ?", TaskIDs).Updates(gorm_model.YoungeeTaskInfo{TaskStage: 13}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Link db] Update YoungeeTaskInfo error,err:%+v", err)
+		return err
+	}
+	return nil
+}

db/logistics.go

@@ -0,0 +1,172 @@
+package db
+
+import (
+	"context"
+	"fmt"
+	"github.com/caixw/lib.go/conv"
+	"github.com/sirupsen/logrus"
+	"reflect"
+	"strings"
+	"time"
+	"youngee_m_api/model/common_model"
+	"youngee_m_api/model/gorm_model"
+	"youngee_m_api/model/http_model"
+	"youngee_m_api/pack"
+	"youngee_m_api/util"
+)
+
+//新增
+func CreateLogistics(ctx context.Context, logistics gorm_model.YoungeeTaskLogistics, RecruitStrategyID int64) (*int64, error) {
+	db := GetReadDB(ctx)
+	err := db.Create(&logistics).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[logistics db] call CreateLogistics error,err:%+v", err)
+		return nil, err
+	}
+
+	return &logistics.LogisticsID, nil
+}
+
+//修改接口
+func UpdateLogistics(ctx context.Context, logistics gorm_model.YoungeeTaskLogistics) (*int64, error) {
+	db := GetReadDB(ctx)
+	err := db.Model(&logistics).Where("task_id = ?", logistics.TaskID).Updates(logistics).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[logistics db] call UpdateLogistics error,err:%+v", err)
+		return nil, err
+	}
+	return &logistics.LogisticsID, nil
+}
+
+// 更改签收时间
+func SignForReceipt(ctx context.Context, taskID int64) error {
+	db := GetReadDB(ctx)
+	err := db.Model(gorm_model.YoungeeTaskLogistics{}).Where("task_id = ?", taskID).Update("signed_time", time.Now()).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[logistics db] call UpdateLogistics error,err:%+v", err)
+		return err
+	}
+	return nil
+}
+
+// 查询包含物流信息的task list
+func GetTaskLogisticsList(ctx context.Context, projectID string, pageSize, pageNum int64, conditions *common_model.TalentConditions) ([]*http_model.TaskLogisticsInfo, int64, error) {
+	db := GetReadDB(ctx)
+	// 查询Task表信息
+	db = db.Debug().Model(gorm_model.YoungeeTaskInfo{})
+	// 根据Project条件过滤
+	conditionType := reflect.TypeOf(conditions).Elem()
+	conditionValue := reflect.ValueOf(conditions).Elem()
+	var platform_nickname string = ""
+	for i := 0; i < conditionType.NumField(); i++ {
+		field := conditionType.Field(i)
+		tag := field.Tag.Get("condition")
+		value := conditionValue.FieldByName(field.Name)
+		if !util.IsBlank(value) {
+			//logrus.Println("tag: ", tag)
+			if tag == "platform_nickname" {
+				platform_nickname = fmt.Sprintf("%v", value.Interface())
+				continue
+			} else if tag == "project_id" {
+				db = db.Where(fmt.Sprintf("%s = ?", tag), value.Interface())
+			} else if tag == "strategy_ids" {
+				strategyIds := strings.Split(fmt.Sprintf("%v", value.Interface()), ",")
+				var strategyIdList []int
+				for _, strategyId := range strategyIds {
+					strategyIdList = append(strategyIdList, conv.MustInt(strategyId, 0))
+				}
+				db = db.Where("strategy_id in ?", strategyIdList)
+			} else {
+				db = db.Where(fmt.Sprintf("%s like '%%%v%%'", tag, value.Interface()))
+			}
+		}
+	}
+	var taskInfos []gorm_model.YoungeeTaskInfo
+	db = db.Model(gorm_model.YoungeeTaskInfo{})
+	// 查询总数
+	var totalTask int64
+	if err := db.Count(&totalTask).Error; err != nil {
+		logrus.WithContext(ctx).Errorf("[GetProjectTaskList] error query mysql total, err:%+v", err)
+		return nil, 0, err
+	}
+	db.Order("task_id").Find(&taskInfos)
+
+	// 查询任务id
+	var taskIds []int
+	taskMap := make(map[int]gorm_model.YoungeeTaskInfo)
+	for _, taskInfo := range taskInfos {
+		taskIds = append(taskIds, taskInfo.TaskId)
+		taskMap[taskInfo.TaskId] = taskInfo
+	}
+	db1 := GetReadDB(ctx)
+	db1 = db1.Debug().Model(gorm_model.YoungeeTaskLogistics{})
+
+	// 根据Project条件过滤
+	conditionType2 := reflect.TypeOf(conditions).Elem()
+	conditionValue2 := reflect.ValueOf(conditions).Elem()
+	for i := 0; i < conditionType2.NumField(); i++ {
+		field := conditionType2.Field(i)
+		tag := field.Tag.Get("condition")
+		value := conditionValue2.FieldByName(field.Name)
+		//fmt.Printf("过滤展示 %+v %+v \n", value, tag)
+		if !util.IsBlank(value) && tag == "platform_nickname" { // input:1		taskIdsbase:1,2,3    string
+			db1 = db1.Where(fmt.Sprintf("%s = ?", tag), value.Interface())
+		}
+	}
+	var logisticsInfos []gorm_model.YoungeeTaskLogistics
+	db1 = db1.Model(gorm_model.YoungeeTaskLogistics{}).Where("task_id IN ?", taskIds).Find(&logisticsInfos)
+	logisticsMap := make(map[int]gorm_model.YoungeeTaskLogistics)
+	for _, logisticsInfo := range logisticsInfos {
+		logisticsMap[conv.MustInt(logisticsInfo.TaskID, 0)] = logisticsInfo
+	}
+	// 查询总数
+	var totalLogistics int64
+	if err := db1.Count(&totalLogistics).Error; err != nil {
+		logrus.WithContext(ctx).Errorf("[GetProjectTalentList] error query mysql total, err:%+v", err)
+		return nil, 0, err
+	}
+
+	// 查询该页数据
+	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 {
+		logrus.WithContext(ctx).Errorf("[GetProjectTaskList] error query mysql total, err:%+v", err)
+		return nil, 0, err
+	}
+
+	var TaskLogisticss []*http_model.TaskLogistics
+	var taskLogisticss []*http_model.TaskLogisticsInfo
+	var newTaskLinks []*http_model.TaskLogisticsInfo
+	for _, taskId := range taskIds {
+		TaskLogistics := new(http_model.TaskLogistics)
+		TaskLogistics.Talent = taskMap[taskId]
+		TaskLogistics.Logistics = logisticsMap[taskId]
+		TaskLogisticss = append(TaskLogisticss, TaskLogistics)
+	}
+
+	taskLogisticss = pack.TaskLogisticsToTaskInfo(TaskLogisticss)
+
+	for _, v := range taskLogisticss {
+		if platform_nickname == "" {
+			newTaskLinks = append(newTaskLinks, v)
+		} else if strings.Contains(v.PlatformNickname, platform_nickname) {
+			newTaskLinks = append(newTaskLinks, v)
+		} else {
+			totalTask--
+		}
+	}
+	// return fulltaskLogisticss, total, nil
+	return newTaskLinks, totalTask, nil
+}
+
+// 修改任务表的物流状态
+func ChangeLogisticsStatus(ctx context.Context, taskIds []string) error {
+	db := GetReadDB(ctx)
+	err := db.Debug().Model(gorm_model.YoungeeTaskInfo{}).Where("task_id IN ?", taskIds).Update("logistics_status", 3).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[ChangeTaskStatus] error query mysql total, err:%+v", err)
+		return err
+	}
+	return nil
+}

db/number_info.go

@@ -0,0 +1,212 @@
+package db
+
+import (
+	"context"
+	"youngee_m_api/model/gorm_model"
+	"youngee_m_api/model/http_model"
+
+	"github.com/sirupsen/logrus"
+)
+
+func GetLogisticsNumberInfo(ctx context.Context, projectId int64, strategyIds []int64) (*http_model.GetLogisticsNumberInfoData, error) {
+	var LogisticsNumberInfoDataList http_model.GetLogisticsNumberInfoData
+
+	for _, strategyId := range strategyIds {
+		var LogisticsNumberInfoData http_model.LogisticsNumberInfo
+		LogisticsNumberInfoData.StrategyId = strategyId
+		db := GetReadDB(ctx).Model(gorm_model.YoungeeTaskInfo{}).Where("project_id = ? and strategy_id = ? and task_status = 2", projectId, strategyId)
+		err := db.Where("logistics_status = 1").Count(&LogisticsNumberInfoData.UndeliveredNumber).Error
+		if err != nil {
+			logrus.WithContext(ctx).Errorf("[GetProjectTaskList] error query mysql total, err:%+v", err)
+			return nil, err
+		}
+		db = GetReadDB(ctx).Model(gorm_model.YoungeeTaskInfo{}).Where("project_id = ? and strategy_id = ? and task_status = 2", projectId, strategyId)
+		err = db.Where("logistics_status = 2").Count(&LogisticsNumberInfoData.DeliveredNumber).Error
+		if err != nil {
+			logrus.WithContext(ctx).Errorf("[GetProjectTaskList] error query mysql total, err:%+v", err)
+			return nil, err
+		}
+		db = GetReadDB(ctx).Model(gorm_model.YoungeeTaskInfo{}).Where("project_id = ? and strategy_id = ? and task_status = 2", projectId, strategyId)
+		err = db.Where("logistics_status = 3").Count(&LogisticsNumberInfoData.SignedNumber).Error
+		if err != nil {
+			logrus.WithContext(ctx).Errorf("[GetProjectTaskList] error query mysql total, err:%+v", err)
+			return nil, err
+		}
+
+		LogisticsNumberInfoDataList.LogisticsNumberInfoList = append(LogisticsNumberInfoDataList.LogisticsNumberInfoList, &LogisticsNumberInfoData)
+	}
+	return &LogisticsNumberInfoDataList, nil
+}
+
+func GetReviewNumberInfo(ctx context.Context, projectId int64, strategyIds []int64) (*http_model.GetReviewNumberInfoData, error) {
+	var ReviewNumberInfoDataList http_model.GetReviewNumberInfoData
+
+	for _, strategyId := range strategyIds {
+		var ReviewNumberInfoData http_model.ReviewNumberInfo
+		ReviewNumberInfoData.StrategyId = strategyId
+		db := GetReadDB(ctx).Model(gorm_model.YoungeeTaskInfo{}).Where("project_id = ? and strategy_id = ? and task_status = 2", projectId, strategyId)
+		err := db.Where("task_stage = 8").Count(&ReviewNumberInfoData.ScriptUnreviewNumber).Error
+		if err != nil {
+			logrus.WithContext(ctx).Errorf("[GetProjectTaskList] error query mysql total, err:%+v", err)
+			return nil, err
+		}
+		db = GetReadDB(ctx).Model(gorm_model.YoungeeTaskInfo{}).Where("project_id = ? and strategy_id = ? and task_status = 2", projectId, strategyId)
+		err = db.Where("task_stage > 8").Count(&ReviewNumberInfoData.ScriptPassedNumber).Error
+		if err != nil {
+			logrus.WithContext(ctx).Errorf("[GetProjectTaskList] error query mysql total, err:%+v", err)
+			return nil, err
+		}
+		db = GetReadDB(ctx).Model(gorm_model.YoungeeTaskInfo{}).Where("project_id = ? and strategy_id = ? and task_status = 2", projectId, strategyId)
+		err = db.Where("task_stage = 10").Count(&ReviewNumberInfoData.SketchUnreviewNumber).Error
+		if err != nil {
+			logrus.WithContext(ctx).Errorf("[GetProjectTaskList] error query mysql total, err:%+v", err)
+			return nil, err
+		}
+		db = GetReadDB(ctx).Model(gorm_model.YoungeeTaskInfo{}).Where("project_id = ? and strategy_id = ? and task_status = 2", projectId, strategyId)
+		err = db.Where("task_stage > 10").Count(&ReviewNumberInfoData.SketchPassedNumber).Error
+		if err != nil {
+			logrus.WithContext(ctx).Errorf("[GetProjectTaskList] error query mysql total, err:%+v", err)
+			return nil, err
+		}
+		db = GetReadDB(ctx).Model(gorm_model.YoungeeTaskInfo{}).Where("project_id = ? and strategy_id = ? and task_status = 2", projectId, strategyId)
+		err = db.Count(&ReviewNumberInfoData.ReviewNumber).Error
+		if err != nil {
+			logrus.WithContext(ctx).Errorf("[GetProjectTaskList] error query mysql total, err:%+v", err)
+			return nil, err
+		}
+
+		ReviewNumberInfoDataList.ReviewNumberInfoList = append(ReviewNumberInfoDataList.ReviewNumberInfoList, &ReviewNumberInfoData)
+	}
+	return &ReviewNumberInfoDataList, nil
+}
+
+func GetLinkNumberInfo(ctx context.Context, projectId int64, strategyIds []int64) (*http_model.GetLinkNumberInfoData, error) {
+	var LinkNumberInfoDataList http_model.GetLinkNumberInfoData
+
+	for _, strategyId := range strategyIds {
+		var LinkNumberInfoData http_model.LinkNumberInfo
+		LinkNumberInfoData.StrategyId = strategyId
+		db := GetReadDB(ctx).Model(gorm_model.YoungeeTaskInfo{}).Where("project_id = ? and strategy_id = ? and task_status = 2", projectId, strategyId)
+		err := db.Where("task_stage = 12").Count(&LinkNumberInfoData.LinkUnreviewNumber).Error
+		if err != nil {
+			logrus.WithContext(ctx).Errorf("[GetProjectTaskList] error query mysql total, err:%+v", err)
+			return nil, err
+		}
+		db = GetReadDB(ctx).Model(gorm_model.YoungeeTaskInfo{}).Where("project_id = ? and strategy_id = ? and task_status = 2", projectId, strategyId)
+		err = db.Where("task_stage > 12").Count(&LinkNumberInfoData.LinkPassedNumber).Error
+		if err != nil {
+			logrus.WithContext(ctx).Errorf("[GetProjectTaskList] error query mysql total, err:%+v", err)
+			return nil, err
+		}
+		db = GetReadDB(ctx).Model(gorm_model.YoungeeTaskInfo{}).Where("project_id = ? and strategy_id = ? and task_status = 2", projectId, strategyId)
+		err = db.Count(&LinkNumberInfoData.LinkNumber).Error
+		if err != nil {
+			logrus.WithContext(ctx).Errorf("[GetProjectTaskList] error query mysql total, err:%+v", err)
+			return nil, err
+		}
+
+		LinkNumberInfoDataList.LinkNumberInfoList = append(LinkNumberInfoDataList.LinkNumberInfoList, &LinkNumberInfoData)
+	}
+	return &LinkNumberInfoDataList, nil
+}
+
+func GetDataNumberInfo(ctx context.Context, projectId int64, strategyIds []int64) (*http_model.GetDataNumberInfoData, error) {
+	var DataNumberInfoDataList http_model.GetDataNumberInfoData
+
+	for _, strategyId := range strategyIds {
+		var DataNumberInfoData http_model.DataNumberInfo
+		DataNumberInfoData.StrategyId = strategyId
+		db := GetReadDB(ctx).Model(gorm_model.YoungeeTaskInfo{}).Where("project_id = ? and strategy_id = ? and task_status = 2", projectId, strategyId)
+		err := db.Where("task_stage = 14").Count(&DataNumberInfoData.DataUnreviewNumber).Error
+		if err != nil {
+			logrus.WithContext(ctx).Errorf("[GetProjectTaskList] error query mysql total, err:%+v", err)
+			return nil, err
+		}
+		db = GetReadDB(ctx).Model(gorm_model.YoungeeTaskInfo{}).Where("project_id = ? and strategy_id = ? and task_status = 2", projectId, strategyId)
+		err = db.Where("task_stage > 14").Count(&DataNumberInfoData.DataPassedNumber).Error
+		if err != nil {
+			logrus.WithContext(ctx).Errorf("[GetProjectTaskList] error query mysql total, err:%+v", err)
+			return nil, err
+		}
+		db = GetReadDB(ctx).Model(gorm_model.YoungeeTaskInfo{}).Where("project_id = ? and strategy_id = ? and task_status = 2", projectId, strategyId)
+		err = db.Count(&DataNumberInfoData.DataNumber).Error
+		if err != nil {
+			logrus.WithContext(ctx).Errorf("[GetProjectTaskList] error query mysql total, err:%+v", err)
+			return nil, err
+		}
+
+		DataNumberInfoDataList.DataNumberInfoList = append(DataNumberInfoDataList.DataNumberInfoList, &DataNumberInfoData)
+	}
+	return &DataNumberInfoDataList, nil
+}
+
+func GetDefaultNumberInfo(ctx context.Context, projectId int64, strategyIds []int64) (*http_model.GetDefaultNumberInfoData, error) {
+	var DefaultNumberInfoDataList http_model.GetDefaultNumberInfoData
+
+	for _, strategyId := range strategyIds {
+		var DefaultNumberInfoData http_model.DefaultNumberInfo
+		DefaultNumberInfoData.StrategyId = strategyId
+		db := GetReadDB(ctx).Model(gorm_model.YoungeeTaskInfo{}).Where("project_id = ? and strategy_id = ? and task_status = 2", projectId, strategyId)
+		err := db.Where("complete_status <> 4").Count(&DefaultNumberInfoData.ShouldFinishNumber).Error
+		if err != nil {
+			logrus.WithContext(ctx).Errorf("[GetProjectTaskList] error query mysql total, err:%+v", err)
+			return nil, err
+		}
+		db = GetReadDB(ctx).Model(gorm_model.YoungeeTaskInfo{}).Where("project_id = ? and strategy_id = ? and task_status = 2", projectId, strategyId)
+		err = db.Where("cur_default_type = 1").Count(&DefaultNumberInfoData.UnuploadScriptNumber).Error
+		if err != nil {
+			logrus.WithContext(ctx).Errorf("[GetProjectTaskList] error query mysql total, err:%+v", err)
+			return nil, err
+		}
+		db = GetReadDB(ctx).Model(gorm_model.YoungeeTaskInfo{}).Where("project_id = ? and strategy_id = ? and task_status = 2", projectId, strategyId)
+		err = db.Where("cur_default_type = 3").Count(&DefaultNumberInfoData.UnuploadSketchNumber).Error
+		if err != nil {
+			logrus.WithContext(ctx).Errorf("[GetProjectTaskList] error query mysql total, err:%+v", err)
+			return nil, err
+		}
+		db = GetReadDB(ctx).Model(gorm_model.YoungeeTaskInfo{}).Where("project_id = ? and strategy_id = ? and task_status = 2", projectId, strategyId)
+		err = db.Where("cur_default_type = 5").Count(&DefaultNumberInfoData.UnuploadLinkNumber).Error
+		if err != nil {
+			logrus.WithContext(ctx).Errorf("[GetProjectTaskList] error query mysql total, err:%+v", err)
+			return nil, err
+		}
+		db = GetReadDB(ctx).Model(gorm_model.YoungeeTaskInfo{}).Where("project_id = ? and strategy_id = ? and task_status = 2", projectId, strategyId)
+		err = db.Where("cur_default_type = 7").Count(&DefaultNumberInfoData.UnuploadDataNumber).Error
+		if err != nil {
+			logrus.WithContext(ctx).Errorf("[GetProjectTaskList] error query mysql total, err:%+v", err)
+			return nil, err
+		}
+		db = GetReadDB(ctx).Model(gorm_model.YoungeeTaskInfo{}).Where("project_id = ? and strategy_id = ? and task_status = 2", projectId, strategyId)
+		err = db.Where("complete_status = 4").Count(&DefaultNumberInfoData.TerminateNumber).Error
+		if err != nil {
+			logrus.WithContext(ctx).Errorf("[GetProjectTaskList] error query mysql total, err:%+v", err)
+			return nil, err
+		}
+
+		DefaultNumberInfoDataList.DefaultNumberInfoList = append(DefaultNumberInfoDataList.DefaultNumberInfoList, &DefaultNumberInfoData)
+	}
+	return &DefaultNumberInfoDataList, nil
+}
+
+func GetFinishNumberInfo(ctx context.Context, projectId int64, strategyIds []int64) (*http_model.GetFinishNumberInfoData, error) {
+	var FinishNumberInfoDataList http_model.GetFinishNumberInfoData
+
+	for _, strategyId := range strategyIds {
+		var FinishNumberInfoData http_model.FinishNumberInfo
+		FinishNumberInfoData.StrategyId = strategyId
+		db := GetReadDB(ctx).Model(gorm_model.YoungeeTaskInfo{}).Where("project_id = ? and strategy_id = ? and task_status = 2", projectId, strategyId)
+		err := db.Where("task_stage = 15").Count(&FinishNumberInfoData.ShouldFinishNumber).Error
+		if err != nil {
+			logrus.WithContext(ctx).Errorf("[GetProjectTaskList] error query mysql total, err:%+v", err)
+			return nil, err
+		}
+		db = GetReadDB(ctx).Model(gorm_model.YoungeeTaskInfo{}).Where("project_id = ? and strategy_id = ? and task_status = 2", projectId, strategyId)
+		err = db.Where("task_stage = 16").Count(&FinishNumberInfoData.FinishedNumber).Error
+		if err != nil {
+			logrus.WithContext(ctx).Errorf("[GetProjectTaskList] error query mysql total, err:%+v", err)
+			return nil, err
+		}
+		FinishNumberInfoDataList.FinishNumberInfoList = append(FinishNumberInfoDataList.FinishNumberInfoList, &FinishNumberInfoData)
+	}
+	return &FinishNumberInfoDataList, nil
+}

db/operate.go

@@ -247,7 +247,7 @@ func GetSignInOfflineTask(projectForm int32) error {
 			db1.Model(gorm_model.YoungeeTaskInfo{}).Where("project_id = ? AND logistics_status = ?", projectInfo.ProjectID, 2).Find(&taskInfos)
 			//fmt.Println("taskInfos", taskInfos)
 			for _, taskInfo := range taskInfos {
-				fmt.Println("TaskId", taskInfo.TaskId)
+				//fmt.Println("TaskId", taskInfo.TaskId)
 				if _, ok1 := taskIDs[taskInfo.TaskId]; !ok1 {
 					taskIds = append(taskIds, taskInfo.TaskId)
 					taskIDs[taskInfo.TaskId] = taskInfo.ProjectId
@@ -267,7 +267,7 @@ func GetSignInOfflineTask(projectForm int32) error {
 		}
 	}
 	//fmt.Println("projectIdMap", projectIdMap)
-	fmt.Println("taskIds", taskIds)
+	//fmt.Println("taskIds", taskIds)
 	var logisticInfos []gorm_model.YoungeeTaskLogistics
 	db3 := GetReadDB(context.Background())
 	err = db3.Model(gorm_model.YoungeeTaskLogistics{}).Where("auto_sign_at <= ? AND task_id IN ?", time.Now(), taskIds).Find(&logisticInfos).Error
@@ -275,7 +275,7 @@ func GetSignInOfflineTask(projectForm int32) error {
 		log.Println("DB AutoGetSignInOfflineTask error :", err)
 		return err
 	}
-	var signedTaskId []int
+	var signedTaskId []int64
 	for _, logisticInfo := range logisticInfos {
 		signedTaskId = append(signedTaskId, logisticInfo.TaskID)
 		if logisticInfo.SignedTime.IsZero() {
@@ -284,19 +284,19 @@ func GetSignInOfflineTask(projectForm int32) error {
 			fmt.Println("已更新签收时间")
 		}
 	}
-	util.RemoveIntRepByMap(signedTaskId)
+	util.RemoveRepByMap(signedTaskId)
 	//fmt.Println("signedTaskId", signedTaskId)
 	for _, taskID := range signedTaskId {
 		//fmt.Println("taskID", taskID)
 		db4 := GetReadDB(context.Background())
 		taskNeedMod := gorm_model.YoungeeTaskInfo{}
 		db4.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", taskID).Find(&taskNeedMod)
-		if projectIdMap[int64(taskIDs[taskID])] == 1 {
+		if projectIdMap[int64(taskIDs[int(taskID)])] == 1 {
 			if taskNeedMod.LogisticsStatus == 2 && taskNeedMod.TaskStage == 5 {
 				db4.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", taskID).Updates(&gorm_model.YoungeeTaskInfo{LogisticsStatus: 3, TaskStage: 9})
 				fmt.Println("内容形式为图片的项目 已修改任务状态为待传初稿 及物流状态为已签收")
 			}
-		} else if projectIdMap[int64(taskIDs[taskID])] == 2 {
+		} else if projectIdMap[int64(taskIDs[int(taskID)])] == 2 {
 			if taskNeedMod.LogisticsStatus == 2 && taskNeedMod.TaskStage == 5 {
 				db4.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", taskID).Updates(&gorm_model.YoungeeTaskInfo{LogisticsStatus: 3, TaskStage: 7})
 				fmt.Println("内容形式为视频的项目 已修改任务状态为待传脚本 及物流状态为已签收")
@@ -318,7 +318,7 @@ func GetAutoReviewTask(contentType int32) error {
 		projectIdToAutoTaskIdMap := map[int64]int{}
 		for _, projectInfo := range projectInfos {
 			projectIds = append(projectIds, projectInfo.ProjectID)
-			projectIdToAutoTaskIdMap[projectInfo.ProjectID] = projectInfo.AutoTaskID
+			projectIdToAutoTaskIdMap[projectInfo.ProjectID] = int(projectInfo.AutoTaskID)
 		}
 		//fmt.Println("projectIds:", projectIds)
 		TaskIdToProjectId := make(map[int]int)
@@ -374,7 +374,7 @@ func GetAutoReviewTask(contentType int32) error {
 				}
 			}
 		}
-		fmt.Println("scriptTaskIds:", scriptTaskIds)
+		//fmt.Println("scriptTaskIds:", scriptTaskIds)
 		for _, scriptTaskId := range scriptTaskIds {
 			//fmt.Println("scriptTaskId", scriptTaskId)
 			taskStatusNeedMod := gorm_model.YoungeeTaskInfo{}
@@ -396,7 +396,7 @@ func GetAutoReviewTask(contentType int32) error {
 		projectIdToAutoTaskIdMap := map[int64]int{}
 		for _, projectInfo := range projectInfos {
 			projectIds = append(projectIds, projectInfo.ProjectID)
-			projectIdToAutoTaskIdMap[projectInfo.ProjectID] = projectInfo.AutoTaskID
+			projectIdToAutoTaskIdMap[projectInfo.ProjectID] = int(projectInfo.AutoTaskID)
 		}
 		//fmt.Println("projectIds:", projectIds)
 		TaskIdToProjectId := make(map[int]int)
@@ -476,7 +476,7 @@ func GetAutoPostReviewTask() error {
 	projectIdToAutoTaskIdMap := map[int64]int{}
 	for _, projectInfo := range projectInfos {
 		projectIds = append(projectIds, projectInfo.ProjectID)
-		projectIdToAutoTaskIdMap[projectInfo.ProjectID] = projectInfo.AutoTaskID
+		projectIdToAutoTaskIdMap[projectInfo.ProjectID] = int(projectInfo.AutoTaskID)
 	}
 	//fmt.Println("projectIds:", projectIds)
 	TaskIdToProjectId := make(map[int]int)
@@ -551,7 +551,7 @@ func GetAutoCaseCloseTask() error {
 	projectIdToAutoTaskIdMap := map[int64]int{}
 	for _, projectInfo := range projectInfos {
 		projectIds = append(projectIds, projectInfo.ProjectID)
-		projectIdToAutoTaskIdMap[projectInfo.ProjectID] = projectInfo.AutoTaskID
+		projectIdToAutoTaskIdMap[projectInfo.ProjectID] = int(projectInfo.AutoTaskID)
 	}
 	//fmt.Println("projectIds:", projectIds)
 	TaskIdToProjectId := make(map[int]int)
@@ -625,7 +625,7 @@ func GetAutoInvalidTask() error {
 	projectIdToAutoTaskIdMap := map[int64]int{}
 	for _, projectInfo := range projectInfos {
 		projectIds = append(projectIds, projectInfo.ProjectID)
-		projectIdToAutoTaskIdMap[projectInfo.ProjectID] = projectInfo.AutoTaskID
+		projectIdToAutoTaskIdMap[projectInfo.ProjectID] = int(projectInfo.AutoTaskID)
 	}
 	for _, projectId := range projectIds {
 		// 获取 autoTaskId 及其对应的限制时间、
@@ -639,8 +639,9 @@ func GetAutoInvalidTask() error {
 		db1.Model(gorm_model.ProjectInfo{}).Where("project_id = ?", projectId).First(&project)
 		if project.AutoFailAt.IsZero() {
 			dd, _ := time.ParseDuration(conv.MustString(Invalid, "") + "h")
+			t := project.RecruitDdl.Add(dd)
 			db2 := GetReadDB(context.Background())
-			db2.Model(gorm_model.ProjectInfo{}).Where("project_id = ?", projectId).Updates(&gorm_model.ProjectInfo{AutoFailAt: project.RecruitDdl.Add(dd)})
+			db2.Model(gorm_model.ProjectInfo{}).Where("project_id = ?", projectId).Updates(&gorm_model.ProjectInfo{AutoFailAt: &t})
 			fmt.Println("已添加失效自动处理时间")
 		}
 		projectNeedMod := gorm_model.ProjectInfo{}
@@ -691,15 +692,16 @@ func GetAutoDraftDefaultInPicTask() error {
 			var DraftDefaultInPic int32
 			dbStart.Model(gorm_model.InfoAutoTask{}).Select("draft_default_in_pic").Where("auto_task_id = ?", specialProjectInfo.AutoTaskID).First(&DraftDefaultInPic)
 			dd, _ := time.ParseDuration(conv.MustString(DraftDefaultInPic, "") + "h")
+			t1 := projectInfo.PayAt.Add(dd)
 			if !projectInfo.PayAt.IsZero() && projectInfo.AutoSketchBreakAt.IsZero() {
-				db1.Model(gorm_model.ProjectInfo{}).Where("project_id = ?", projectInfo.ProjectID).Updates(&gorm_model.ProjectInfo{AutoSketchBreakAt: projectInfo.PayAt.Add(dd)})
+				db1.Model(gorm_model.ProjectInfo{}).Where("project_id = ?", projectInfo.ProjectID).Updates(&gorm_model.ProjectInfo{AutoSketchBreakAt: &t1})
 				fmt.Println("已添加素材微原创的初稿违约自动处理时间")
 			}
 		} else {
 			projectIds = append(projectIds, projectInfo.ProjectID)
 		}
-		projectIdToAutoTaskIdMap[projectInfo.ProjectID] = projectInfo.AutoTaskID
-		projectIdToAutoDefaultIdMap[projectInfo.ProjectID] = projectInfo.AutoDefaultID
+		projectIdToAutoTaskIdMap[projectInfo.ProjectID] = int(projectInfo.AutoTaskID)
+		projectIdToAutoDefaultIdMap[projectInfo.ProjectID] = int(projectInfo.AutoDefaultID)
 	}
 	//fmt.Println("projectIds:", projectIds)
 	//fmt.Println("specialProjectIds:", specialProjectIds)
@@ -738,7 +740,7 @@ func GetAutoDraftDefaultInPicTask() error {
 		if projectNeedMod.AutoSketchBreakAt.Sub(time.Now()) <= 0 && !projectNeedMod.AutoSketchBreakAt.IsZero() {
 			db2 := GetReadDB(context.Background())
 			err1 := db2.Model(gorm_model.YoungeeContractInfo{}).Create(&gorm_model.YoungeeContractInfo{
-				TaskID: specialTaskNeedModId, BreakType: 2, BreakAt: time.Now(), DefaultStatus: 1}).Error
+				TaskID: specialTaskNeedModId, ProjectID: TaskIdToProjectId[specialTaskNeedModId], BreakType: 2, BreakAt: time.Now(), DefaultStatus: 1}).Error
 			if err1 != nil {
 				return err1
 			}
@@ -811,7 +813,7 @@ func GetAutoDraftDefaultInPicTask() error {
 		if !taskLogisticNeedMod2.AutoSketchBreakAt.IsZero() && taskLogisticNeedMod2.AutoSketchBreakAt.Sub(time.Now()) <= 0 {
 			db5 := GetReadDB(context.Background())
 			err1 := db5.Model(gorm_model.YoungeeContractInfo{}).Create(&gorm_model.YoungeeContractInfo{
-				TaskID: taskNeedModId, BreakType: 2, BreakAt: time.Now(), DefaultStatus: 1}).Error
+				TaskID: taskNeedModId, ProjectID: TaskIdToProjectId[taskNeedModId], BreakType: 2, BreakAt: time.Now(), DefaultStatus: 1}).Error
 			if err1 != nil {
 				return err1
 			}
@@ -845,7 +847,7 @@ func GetAutoDraftDefaultInPicTask() error {
 			if taskSketchInfo.RejectAt.Add(dd).Sub(time.Now()) <= 0 {
 				db4 := GetReadDB(context.Background())
 				err1 := db4.Model(gorm_model.YoungeeContractInfo{}).Create(&gorm_model.YoungeeContractInfo{
-					TaskID: submitTaskNeedModId, BreakType: 2, BreakAt: time.Now(), DefaultStatus: 1}).Error
+					TaskID: submitTaskNeedModId, ProjectID: TaskIdToProjectId[submitTaskNeedModId], BreakType: 2, BreakAt: time.Now(), DefaultStatus: 1}).Error
 				if err1 != nil {
 					return err1
 				}
@@ -860,7 +862,7 @@ func GetAutoDraftDefaultInPicTask() error {
 			if taskSketchInfo.AutoSketchBreakAt.Sub(time.Now()) <= 0 {
 				db4 := GetReadDB(context.Background())
 				err1 := db4.Model(gorm_model.YoungeeContractInfo{}).Create(&gorm_model.YoungeeContractInfo{
-					TaskID: submitTaskNeedModId, BreakType: 2, BreakAt: time.Now(), DefaultStatus: 1}).Error
+					TaskID: submitTaskNeedModId, ProjectID: TaskIdToProjectId[submitTaskNeedModId], BreakType: 2, BreakAt: time.Now(), DefaultStatus: 1}).Error
 				if err1 != nil {
 					return err1
 				}
@@ -897,8 +899,8 @@ func GetAutoDraftDefaultInMvTask() error {
 		db2 := GetReadDB(context.Background())
 		autoIds := gorm_model.ProjectInfo{}
 		db2.Select([]string{"auto_task_id", "auto_default_id"}).Model(&gorm_model.ProjectInfo{}).Where("project_id = ?", VideoProjectId).First(&autoIds)
-		projectIdToAutoTaskIdMap[VideoProjectId] = autoIds.AutoTaskID
-		projectIdToAutoDefaultIdMap[VideoProjectId] = autoIds.AutoDefaultID
+		projectIdToAutoTaskIdMap[VideoProjectId] = int(autoIds.AutoTaskID)
+		projectIdToAutoDefaultIdMap[VideoProjectId] = int(autoIds.AutoDefaultID)
 
 		var videoTaskInfos []*gorm_model.YoungeeTaskInfo
 		db1 := GetReadDB(context.Background())
@@ -953,7 +955,7 @@ func GetAutoDraftDefaultInMvTask() error {
 			if taskScriptInfo.AutoAgreeAt.Add(dd).Sub(time.Now()) <= 0 {
 				db4 := GetReadDB(context.Background())
 				err1 := db4.Model(gorm_model.YoungeeContractInfo{}).Create(&gorm_model.YoungeeContractInfo{
-					TaskID: videoTaskNeedModId, BreakType: 2, BreakAt: time.Now(), DefaultStatus: 1}).Error
+					TaskID: videoTaskNeedModId, ProjectID: int(taskIdToProjectIdMap[videoTaskNeedModId]), BreakType: 2, BreakAt: time.Now(), DefaultStatus: 1}).Error
 				if err1 != nil {
 					return err1
 				}
@@ -968,7 +970,7 @@ func GetAutoDraftDefaultInMvTask() error {
 			if taskScriptInfo.AutoSketchBreakAt.Sub(time.Now()) <= 0 {
 				db4 := GetReadDB(context.Background())
 				err1 := db4.Model(gorm_model.YoungeeContractInfo{}).Create(&gorm_model.YoungeeContractInfo{
-					TaskID: videoTaskNeedModId, BreakType: 2, BreakAt: time.Now(), DefaultStatus: 1}).Error
+					TaskID: videoTaskNeedModId, ProjectID: int(taskIdToProjectIdMap[videoTaskNeedModId]), BreakType: 2, BreakAt: time.Now(), DefaultStatus: 1}).Error
 				if err1 != nil {
 					return err1
 				}
@@ -1006,7 +1008,7 @@ func GetAutoDraftDefaultInMvTask() error {
 			if taskSketchInfo.RejectAt.Add(dd).Sub(time.Now()) <= 0 {
 				db4 := GetReadDB(context.Background())
 				err1 := db4.Model(gorm_model.YoungeeContractInfo{}).Create(&gorm_model.YoungeeContractInfo{
-					TaskID: submitVideoTaskNeedModId, BreakType: 2, BreakAt: time.Now(), DefaultStatus: 1}).Error
+					TaskID: submitVideoTaskNeedModId, ProjectID: int(taskIdToProjectIdMap[submitVideoTaskNeedModId]), BreakType: 2, BreakAt: time.Now(), DefaultStatus: 1}).Error
 				if err1 != nil {
 					return err1
 				}
@@ -1021,7 +1023,7 @@ func GetAutoDraftDefaultInMvTask() error {
 			if taskSketchInfo.AutoSketchBreakAt.Sub(time.Now()) <= 0 {
 				db4 := GetReadDB(context.Background())
 				err1 := db4.Model(gorm_model.YoungeeContractInfo{}).Create(&gorm_model.YoungeeContractInfo{
-					TaskID: submitVideoTaskNeedModId, BreakType: 2, BreakAt: time.Now(), DefaultStatus: 1}).Error
+					TaskID: submitVideoTaskNeedModId, ProjectID: int(taskIdToProjectIdMap[submitVideoTaskNeedModId]), BreakType: 2, BreakAt: time.Now(), DefaultStatus: 1}).Error
 				if err1 != nil {
 					return err1
 				}
@@ -1069,15 +1071,16 @@ func GetAutoScriptDefaultTask() error {
 		db2 := GetReadDB(context.Background())
 		var projectInfo gorm_model.ProjectInfo
 		db2.Model(&gorm_model.ProjectInfo{}).Where("project_id = ?", specialProjectId).First(&projectInfo)
-		projectIdToAutoTaskIdMap[int64(specialProjectId)] = projectInfo.AutoTaskID
-		projectIdToAutoDefaultIdMap[int64(specialProjectId)] = projectInfo.AutoDefaultID
+		projectIdToAutoTaskIdMap[int64(specialProjectId)] = int(projectInfo.AutoTaskID)
+		projectIdToAutoDefaultIdMap[int64(specialProjectId)] = int(projectInfo.AutoDefaultID)
 		var ScriptDefault int32
 		dbStart := GetReadDB(context.Background())
 		dbStart.Model(gorm_model.InfoAutoTask{}).Select("script_default").Where("auto_task_id = ?", projectInfo.AutoTaskID).First(&ScriptDefault)
 		dd, _ := time.ParseDuration(conv.MustString(ScriptDefault, "") + "h")
+		t3 := projectInfo.PayAt.Add(dd)
 		if !projectInfo.PayAt.IsZero() && projectInfo.AutoScriptBreakAt.IsZero() {
 			db1 := GetReadDB(context.Background())
-			db1.Model(gorm_model.ProjectInfo{}).Where("project_id = ?", projectInfo.ProjectID).Updates(&gorm_model.ProjectInfo{AutoScriptBreakAt: projectInfo.PayAt.Add(dd)})
+			db1.Model(gorm_model.ProjectInfo{}).Where("project_id = ?", projectInfo.ProjectID).Updates(&gorm_model.ProjectInfo{AutoScriptBreakAt: &t3})
 			fmt.Println("已添加素材微原创的脚本违约自动处理时间")
 		}
 		var videoTaskInfos []*gorm_model.YoungeeTaskInfo
@@ -1117,7 +1120,7 @@ func GetAutoScriptDefaultTask() error {
 			}
 			db2 := GetReadDB(context.Background())
 			err1 := db2.Model(gorm_model.YoungeeContractInfo{}).Create(&gorm_model.YoungeeContractInfo{
-				TaskID: specialTaskNeedModId, BreakType: 1, BreakAt: time.Now(), DefaultStatus: 1}).Error
+				TaskID: specialTaskNeedModId, ProjectID: int(taskIdToProjectIdMap[specialTaskNeedModId]), BreakType: 1, BreakAt: time.Now(), DefaultStatus: 1}).Error
 			if err1 != nil {
 				return err1
 			}
@@ -1180,7 +1183,7 @@ func GetAutoScriptDefaultTask() error {
 			if taskLogisticInfo.AutoSignAt.Add(dd).Sub(time.Now()) <= 0 {
 				db4 := GetReadDB(context.Background())
 				err1 := db4.Model(gorm_model.YoungeeContractInfo{}).Create(&gorm_model.YoungeeContractInfo{
-					TaskID: videoTaskNeedModId, BreakType: 1, BreakAt: time.Now(), DefaultStatus: 1}).Error
+					TaskID: videoTaskNeedModId, ProjectID: int(taskIdToProjectIdMap[videoTaskNeedModId]), BreakType: 1, BreakAt: time.Now(), DefaultStatus: 1}).Error
 				if err1 != nil {
 					return err1
 				}
@@ -1195,7 +1198,7 @@ func GetAutoScriptDefaultTask() error {
 			if taskLogisticInfo.AutoScriptBreakAt.Sub(time.Now()) <= 0 {
 				db4 := GetReadDB(context.Background())
 				err1 := db4.Model(gorm_model.YoungeeContractInfo{}).Create(&gorm_model.YoungeeContractInfo{
-					TaskID: videoTaskNeedModId, BreakType: 1, BreakAt: time.Now(), DefaultStatus: 1}).Error
+					TaskID: videoTaskNeedModId, ProjectID: int(taskIdToProjectIdMap[videoTaskNeedModId]), BreakType: 1, BreakAt: time.Now(), DefaultStatus: 1}).Error
 				if err1 != nil {
 					return err1
 				}
@@ -1234,7 +1237,7 @@ func GetAutoScriptDefaultTask() error {
 			if taskScriptInfo.RejectAt.Add(dd).Sub(time.Now()) <= 0 {
 				db4 := GetReadDB(context.Background())
 				err1 := db4.Model(gorm_model.YoungeeContractInfo{}).Create(&gorm_model.YoungeeContractInfo{
-					TaskID: submitVideoTaskNeedModId, BreakType: 1, BreakAt: time.Now(), DefaultStatus: 1}).Error
+					TaskID: submitVideoTaskNeedModId, ProjectID: int(taskIdToProjectIdMap[submitVideoTaskNeedModId]), BreakType: 1, BreakAt: time.Now(), DefaultStatus: 1}).Error
 				if err1 != nil {
 					return err1
 				}
@@ -1250,7 +1253,7 @@ func GetAutoScriptDefaultTask() error {
 			if taskScriptInfo.AutoScriptBreakAt.Sub(time.Now()) <= 0 {
 				db4 := GetReadDB(context.Background())
 				err1 := db4.Model(gorm_model.YoungeeContractInfo{}).Create(&gorm_model.YoungeeContractInfo{
-					TaskID: submitVideoTaskNeedModId, BreakType: 1, BreakAt: time.Now(), DefaultStatus: 1}).Error
+					TaskID: submitVideoTaskNeedModId, ProjectID: int(taskIdToProjectIdMap[submitVideoTaskNeedModId]), BreakType: 1, BreakAt: time.Now(), DefaultStatus: 1}).Error
 				if err1 != nil {
 					return err1
 				}
@@ -1288,8 +1291,8 @@ func GetAutoLinkBreachTask() error {
 		db2 := GetReadDB(context.Background())
 		autoIds := gorm_model.ProjectInfo{}
 		db2.Select([]string{"auto_task_id", "auto_default_id"}).Model(&gorm_model.ProjectInfo{}).Where("project_id = ?", projectId).First(&autoIds)
-		projectIdToAutoTaskIdMap[projectId] = autoIds.AutoTaskID
-		projectIdToAutoDefaultIdMap[projectId] = autoIds.AutoDefaultID
+		projectIdToAutoTaskIdMap[projectId] = int(autoIds.AutoTaskID)
+		projectIdToAutoDefaultIdMap[projectId] = int(autoIds.AutoDefaultID)
 		var taskInfos []*gorm_model.YoungeeTaskInfo
 		db1 := GetReadDB(context.Background())
 		db1.Model(&gorm_model.YoungeeTaskInfo{}).Where("project_id = ? AND cur_default_type = ? ", projectId, 0).Find(&taskInfos)
@@ -1342,7 +1345,7 @@ func GetAutoLinkBreachTask() error {
 			if taskSketchInfo.AutoAgreeAt.Add(dd).Sub(time.Now()) <= 0 {
 				db4 := GetReadDB(context.Background())
 				err1 := db4.Model(gorm_model.YoungeeContractInfo{}).Create(&gorm_model.YoungeeContractInfo{
-					TaskID: taskNeedModId, BreakType: 3, BreakAt: time.Now(), DefaultStatus: 1}).Error
+					TaskID: taskNeedModId, ProjectID: int(taskIdToProjectIdMap[taskNeedModId]), BreakType: 3, BreakAt: time.Now(), DefaultStatus: 1}).Error
 				if err1 != nil {
 					return err1
 				}
@@ -1357,7 +1360,7 @@ func GetAutoLinkBreachTask() error {
 			if taskSketchInfo.AutoLinkBreakAt.Sub(time.Now()) <= 0 {
 				db4 := GetReadDB(context.Background())
 				err1 := db4.Model(gorm_model.YoungeeContractInfo{}).Create(&gorm_model.YoungeeContractInfo{
-					TaskID: taskNeedModId, BreakType: 3, BreakAt: time.Now(), DefaultStatus: 1}).Error
+					TaskID: taskNeedModId, ProjectID: int(taskIdToProjectIdMap[taskNeedModId]), BreakType: 3, BreakAt: time.Now(), DefaultStatus: 1}).Error
 				if err1 != nil {
 					return err1
 				}
@@ -1396,7 +1399,7 @@ func GetAutoLinkBreachTask() error {
 			if taskLinkInfo.RejectAt.Add(dd).Sub(time.Now()) <= 0 {
 				db4 := GetReadDB(context.Background())
 				err1 := db4.Model(gorm_model.YoungeeContractInfo{}).Create(&gorm_model.YoungeeContractInfo{
-					TaskID: submitTaskNeedModId, BreakType: 3, BreakAt: time.Now(), DefaultStatus: 1}).Error
+					TaskID: submitTaskNeedModId, ProjectID: int(taskIdToProjectIdMap[submitTaskNeedModId]), BreakType: 3, BreakAt: time.Now(), DefaultStatus: 1}).Error
 				if err1 != nil {
 					return err1
 				}
@@ -1411,7 +1414,7 @@ func GetAutoLinkBreachTask() error {
 			if taskLinkInfo.AutoLinkBreakAt.Sub(time.Now()) <= 0 {
 				db4 := GetReadDB(context.Background())
 				err1 := db4.Model(gorm_model.YoungeeContractInfo{}).Create(&gorm_model.YoungeeContractInfo{
-					TaskID: submitTaskNeedModId, BreakType: 3, BreakAt: time.Now(), DefaultStatus: 1}).Error
+					TaskID: submitTaskNeedModId, ProjectID: int(taskIdToProjectIdMap[submitTaskNeedModId]), BreakType: 3, BreakAt: time.Now(), DefaultStatus: 1}).Error
 				if err1 != nil {
 					return err1
 				}
@@ -1446,8 +1449,8 @@ func GetAutoCaseCloseDefaultTask() error {
 		db2 := GetReadDB(context.Background())
 		autoIds := gorm_model.ProjectInfo{}
 		db2.Select([]string{"auto_task_id", "auto_default_id"}).Model(&gorm_model.ProjectInfo{}).Where("project_id = ?", projectId).First(&autoIds)
-		projectIdToAutoTaskIdMap[projectId] = autoIds.AutoTaskID
-		projectIdToAutoDefaultIdMap[projectId] = autoIds.AutoDefaultID
+		projectIdToAutoTaskIdMap[projectId] = int(autoIds.AutoTaskID)
+		projectIdToAutoDefaultIdMap[projectId] = int(autoIds.AutoDefaultID)
 		var taskInfos []int32
 		db1 := GetReadDB(context.Background())
 		db1.Select("task_id").Model(&gorm_model.YoungeeTaskInfo{}).Where("project_id = ? AND cur_default_type = ? ", projectId, 0).Find(&taskInfos)
@@ -1506,7 +1509,7 @@ func GetAutoCaseCloseDefaultTask() error {
 			if taskLinkInfo.AutoAgreeAt.Add(dd).Sub(time.Now()) <= 0 {
 				db4 := GetReadDB(context.Background())
 				err1 := db4.Model(gorm_model.YoungeeContractInfo{}).Create(&gorm_model.YoungeeContractInfo{
-					TaskID: taskNeedModId, BreakType: 4, BreakAt: time.Now(), DefaultStatus: 1}).Error
+					TaskID: taskNeedModId, ProjectID: int(taskIdToProjectIdMap[taskNeedModId]), BreakType: 4, BreakAt: time.Now(), DefaultStatus: 1}).Error
 				if err1 != nil {
 					return err1
 				}
@@ -1521,7 +1524,7 @@ func GetAutoCaseCloseDefaultTask() error {
 			if taskLinkInfo.AutoDataBreakAt.Sub(time.Now()) <= 0 {
 				db4 := GetReadDB(context.Background())
 				err1 := db4.Model(gorm_model.YoungeeContractInfo{}).Create(&gorm_model.YoungeeContractInfo{
-					TaskID: taskNeedModId, BreakType: 4, BreakAt: time.Now(), DefaultStatus: 1}).Error
+					TaskID: taskNeedModId, ProjectID: int(taskIdToProjectIdMap[taskNeedModId]), BreakType: 4, BreakAt: time.Now(), DefaultStatus: 1}).Error
 				if err1 != nil {
 					return err1
 				}
@@ -1560,7 +1563,7 @@ func GetAutoCaseCloseDefaultTask() error {
 			if taskDataInfo.RejectAt.Add(dd).Sub(time.Now()) <= 0 {
 				db4 := GetReadDB(context.Background())
 				err1 := db4.Model(gorm_model.YoungeeContractInfo{}).Create(&gorm_model.YoungeeContractInfo{
-					TaskID: submitTaskNeedModId, BreakType: 4, BreakAt: time.Now(), DefaultStatus: 1}).Error
+					TaskID: submitTaskNeedModId, ProjectID: int(taskIdToProjectIdMap[submitTaskNeedModId]), BreakType: 4, BreakAt: time.Now(), DefaultStatus: 1}).Error
 				if err1 != nil {
 					return err1
 				}
@@ -1575,7 +1578,7 @@ func GetAutoCaseCloseDefaultTask() error {
 			if taskDataInfo.AutoDataBreakAt.Sub(time.Now()) <= 0 {
 				db4 := GetReadDB(context.Background())
 				err1 := db4.Model(gorm_model.YoungeeContractInfo{}).Create(&gorm_model.YoungeeContractInfo{
-					TaskID: submitTaskNeedModId, BreakType: 4, BreakAt: time.Now(), DefaultStatus: 1}).Error
+					TaskID: submitTaskNeedModId, ProjectID: int(taskIdToProjectIdMap[submitTaskNeedModId]), BreakType: 4, BreakAt: time.Now(), DefaultStatus: 1}).Error
 				if err1 != nil {
 					return err1
 				}

db/project.go

@@ -7,6 +7,7 @@ import (
 	"github.com/sirupsen/logrus"
 	"gorm.io/gorm"
 	"reflect"
+	"time"
 	"youngee_m_api/model/common_model"
 	"youngee_m_api/model/gorm_model"
 	"youngee_m_api/model/http_model"
@@ -106,7 +107,10 @@ func ApproveProject(ctx context.Context, projectId string, isApprove int64) (err
 	projectInfo := gorm_model.ProjectInfo{}
 	db = db.Debug().Model(gorm_model.ProjectInfo{}).Where("project_id = ?", project_id).First(&projectInfo)
 	if isApprove == 1 && projectInfo.ProjectStatus == 2 {
-		err := db.Update("project_status", 4).Error
+		err := db.Updates(gorm_model.ProjectInfo{
+			ProjectStatus: 4,
+			FinishAt:      time.Now(),
+		}).Error
 		message = "审核通过"
 		if err != nil {
 			logrus.Println("DB AutoUpdateStatus error :", err)

db/recruit_strategy.go

@@ -2,6 +2,8 @@ package db
 
 import (
 	"context"
+	"github.com/sirupsen/logrus"
+	"gorm.io/gorm"
 	"youngee_m_api/model/gorm_model"
 )
 
@@ -22,3 +24,44 @@ func DeleteRecruitStrategyByProjectID(ctx context.Context, projectID int64) erro
 	}
 	return nil
 }
+
+func CalculateSelectedNumberByRecruitStrategyID(ctx context.Context, recruitstrategyIDs []int64, AddNumber int64) error {
+	db := GetReadDB(ctx)
+	err := db.Model(gorm_model.RecruitStrategy{}).Where("recruit_strategy_id in ?", recruitstrategyIDs).Updates(map[string]interface{}{"selected_number": gorm.Expr("selected_number + ?", AddNumber), "waiting_number": gorm.Expr("waiting_number + ?", AddNumber)}).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func UpdateSelectedNumber(ctx context.Context, RecruitStrategyID int64, selected_number int64) error {
+	db := GetReadDB(ctx)
+	err := db.Model(gorm_model.RecruitStrategy{}).Where("recruit_strategy_id = ?", RecruitStrategyID).Update("selected_number", gorm.Expr("selected_number + ?", selected_number)).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[logistics db] call CreateLogistics error,err:%+v", err)
+		return err
+	}
+	return nil
+}
+
+func UpdateLogisticsNumber(ctx context.Context, RecruitStrategyID int64, delivered_value int64, waiting_value int64, signed_value int64) error {
+	db := GetReadDB(ctx)
+	err := db.Model(gorm_model.RecruitStrategy{}).Where("recruit_strategy_id = ?", RecruitStrategyID).
+		Updates(map[string]interface{}{"delivered_number": gorm.Expr("delivered_number + ?", delivered_value), "waiting_number": gorm.Expr("waiting_number + ?", waiting_value), "signed_number": gorm.Expr("signed_number + ?", signed_value)}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[logistics db] call CreateLogistics error,err:%+v", err)
+		return err
+	}
+	return nil
+}
+
+func GetRecruitStrategyIdByTS(ctx context.Context, projectId int, strategyID int64) (*int64, error) {
+	db := GetReadDB(ctx)
+	RecruitStrategy := &gorm_model.RecruitStrategy{}
+	err := db.Model(gorm_model.RecruitStrategy{}).Where("project_id = ? AND strategy_id = ?", projectId, strategyID).Scan(RecruitStrategy).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[logistics db] call CreateLogistics error,err:%+v", err)
+		return nil, err
+	}
+	return &RecruitStrategy.RecruitStrategyID, nil
+}

db/script.go

@@ -0,0 +1,169 @@
+package db
+
+import (
+	"context"
+	"fmt"
+	"github.com/caixw/lib.go/conv"
+	"github.com/sirupsen/logrus"
+	"reflect"
+	"strings"
+	"time"
+	"youngee_m_api/model/common_model"
+	"youngee_m_api/model/gorm_model"
+	"youngee_m_api/model/http_model"
+	"youngee_m_api/pack"
+	"youngee_m_api/util"
+)
+
+// GetTaskScriptList 查询上传脚本的task list
+func GetTaskScriptList(ctx context.Context, projectID string, pageSize, pageNum int64, conditions *common_model.TalentConditions) ([]*http_model.TaskScriptInfo, int64, error) {
+	db := GetReadDB(ctx)
+	// 查询Task表信息
+	db = db.Debug().Model(gorm_model.YoungeeTaskInfo{}).Where("task_status = 2")
+	// 根据Project条件过滤
+	conditionType := reflect.TypeOf(conditions).Elem()
+	conditionValue := reflect.ValueOf(conditions).Elem()
+	var platform_nickname string = ""
+	for i := 0; i < conditionType.NumField(); i++ {
+		field := conditionType.Field(i)
+		tag := field.Tag.Get("condition")
+		value := conditionValue.FieldByName(field.Name)
+		if tag == "script_status" {
+			fmt.Printf("script %+v", value.Interface() == int64(2))
+			if value.Interface() == int64(2) {
+				db = db.Where("task_stage = ?", 8)
+			} else {
+				db = db.Where("task_stage > ?", 8)
+			}
+			continue
+		}
+		if !util.IsBlank(value) {
+			if tag == "platform_nickname" {
+				platform_nickname = fmt.Sprintf("%v", value.Interface())
+				continue
+			} else if tag == "project_id" {
+				db = db.Where(fmt.Sprintf("%s = ?", tag), value.Interface())
+			} else if tag == "strategy_ids" {
+				strategyIds := strings.Split(fmt.Sprintf("%v", value.Interface()), ",")
+				var strategyIdList []int
+				for _, strategyId := range strategyIds {
+					strategyIdList = append(strategyIdList, conv.MustInt(strategyId, 0))
+				}
+				db = db.Where("strategy_id in ?", strategyIdList)
+			} else {
+				db = db.Where(fmt.Sprintf("%s like '%%%v%%'", tag, value.Interface()))
+			}
+		}
+	}
+	var taskInfos []gorm_model.YoungeeTaskInfo
+	db = db.Model(gorm_model.YoungeeTaskInfo{})
+	// 查询总数
+	var totalTask int64
+	if err := db.Count(&totalTask).Error; err != nil {
+		logrus.WithContext(ctx).Errorf("[GetProjectTaskList] error query mysql total, err:%+v", err)
+		return nil, 0, err
+	}
+	db.Order("task_id").Find(&taskInfos)
+
+	// 查询任务id
+	var taskIds []int
+	taskMap := make(map[int]gorm_model.YoungeeTaskInfo)
+	for _, taskInfo := range taskInfos {
+		taskIds = append(taskIds, taskInfo.TaskId)
+		taskMap[taskInfo.TaskId] = taskInfo
+	}
+	db1 := GetReadDB(ctx)
+	db1 = db1.Debug().Model(gorm_model.YounggeeScriptInfo{})
+
+	var ScriptInfos []gorm_model.YounggeeScriptInfo
+	db1 = db1.Model(gorm_model.YounggeeScriptInfo{}).Where("task_id IN ? AND is_submit=? ", taskIds, 1)
+	if conditions.ScriptStatus == int64(2) {
+		db1 = db1.Where("is_review = 0").Find(&ScriptInfos)
+	} else {
+		db1 = db1.Where("is_ok = 1").Find(&ScriptInfos)
+	}
+	ScriptMap := make(map[int]gorm_model.YounggeeScriptInfo)
+	for _, ScriptInfo := range ScriptInfos {
+		ScriptMap[conv.MustInt(ScriptInfo.TaskID, 0)] = ScriptInfo
+	}
+	// 查询总数
+	var totalScript int64
+	if err := db1.Count(&totalScript).Error; err != nil {
+		logrus.WithContext(ctx).Errorf("[GetProjectTalentList] error query mysql total, err:%+v", err)
+		return nil, 0, err
+	}
+	// 查询该页数据
+	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 {
+		logrus.WithContext(ctx).Errorf("[GetProjectTaskList] error query mysql total, err:%+v", err)
+		return nil, 0, err
+	}
+
+	var TaskScripts []*http_model.TaskScript
+	var taskScripts []*http_model.TaskScriptInfo
+	var newTaskScripts []*http_model.TaskScriptInfo
+	for _, taskId := range taskIds {
+		TaskScript := new(http_model.TaskScript)
+		TaskScript.Talent = taskMap[taskId]
+		TaskScript.Script = ScriptMap[taskId]
+		TaskScripts = append(TaskScripts, TaskScript)
+	}
+
+	taskScripts = pack.TaskScriptToTaskInfo(TaskScripts)
+
+	for _, v := range taskScripts {
+		if platform_nickname == "" {
+			newTaskScripts = append(newTaskScripts, v)
+		} else if strings.Contains(v.PlatformNickname, platform_nickname) {
+			newTaskScripts = append(newTaskScripts, v)
+		} else {
+			totalTask--
+		}
+	}
+	return newTaskScripts, totalTask, nil
+}
+
+// ScriptOpinion 提交意见
+func ScriptOpinion(ctx context.Context, TaskID int, ReviseOpinion string) error {
+	db := GetReadDB(ctx)
+	err := db.Model(gorm_model.YounggeeScriptInfo{}).Where("task_id = ? and is_review = 0", TaskID).Updates(map[string]interface{}{"revise_opinion": ReviseOpinion, "reject_at": time.Now(), "is_review": 1}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Script db] Update YounggeeScriptInfo error,err:%+v", err)
+		return err
+	}
+	err = db.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", TaskID).Updates(gorm_model.YoungeeTaskInfo{ScriptStatus: 3}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Script db] Update YoungeeTaskInfo error,err:%+v", err)
+		return err
+	}
+	err = db.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", TaskID).Updates(gorm_model.YoungeeTaskInfo{TaskStage: 7}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Script db] Update YoungeeTaskInfo error,err:%+v", err)
+		return err
+	}
+	return nil
+}
+
+// AcceptScript 同意脚本
+func AcceptScript(ctx context.Context, TaskIDs []int) error {
+	db := GetReadDB(ctx)
+	err := db.Model(gorm_model.YounggeeScriptInfo{}).Where("task_id in ?  and is_review = 0", TaskIDs).Updates(map[string]interface{}{"is_ok": 1, "is_review": 1, "agree_at": time.Now()}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Script db] Update YounggeeScriptInfo error,err:%+v", err)
+		return err
+	}
+	err = db.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id in ?", TaskIDs).Updates(gorm_model.YoungeeTaskInfo{ScriptStatus: 5}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Script db] Update YoungeeTaskInfo error,err:%+v", err)
+		return err
+	}
+	err = db.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id in ?", TaskIDs).Updates(gorm_model.YoungeeTaskInfo{TaskStage: 9}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Script db] Update YoungeeTaskInfo error,err:%+v", err)
+		return err
+	}
+	return nil
+}

db/sketch.go

@@ -0,0 +1,204 @@
+package db
+
+import (
+	"context"
+	"fmt"
+	"github.com/caixw/lib.go/conv"
+	"github.com/sirupsen/logrus"
+	"reflect"
+	"strings"
+	"time"
+	"youngee_m_api/model/common_model"
+	"youngee_m_api/model/gorm_model"
+	"youngee_m_api/model/http_model"
+	"youngee_m_api/pack"
+	"youngee_m_api/util"
+)
+
+// GetTaskSketchList 查询上传初稿的task list
+func GetTaskSketchList(ctx context.Context, projectID string, pageSize, pageNum int64, conditions *common_model.TalentConditions) ([]*http_model.TaskSketchInfo, int64, error) {
+	db := GetReadDB(ctx)
+	// 查询Task表信息
+	db = db.Debug().Model(gorm_model.YoungeeTaskInfo{}).Where("task_status = 2")
+	// 根据Project条件过滤
+	conditionType := reflect.TypeOf(conditions).Elem()
+	conditionValue := reflect.ValueOf(conditions).Elem()
+	var platform_nickname string = ""
+	for i := 0; i < conditionType.NumField(); i++ {
+		field := conditionType.Field(i)
+		tag := field.Tag.Get("condition")
+		value := conditionValue.FieldByName(field.Name)
+		if tag == "sketch_status" {
+			fmt.Printf("sketch %+v", value.Interface() == int64(0))
+			if value.Interface() == int64(0) {
+				db = db.Where("task_stage = ?", 10)
+			} else {
+				db = db.Where("task_stage > ?", 10)
+			}
+			continue
+		} else if !util.IsBlank(value) {
+			if tag == "platform_nickname" {
+				platform_nickname = fmt.Sprintf("%v", value.Interface())
+				continue
+			} else if tag == "project_id" {
+				db = db.Where(fmt.Sprintf("%s = ?", tag), value.Interface())
+			} else if tag == "strategy_ids" {
+				strategyIds := strings.Split(fmt.Sprintf("%v", value.Interface()), ",")
+				var strategyIdList []int
+				for _, strategyId := range strategyIds {
+					strategyIdList = append(strategyIdList, conv.MustInt(strategyId, 0))
+				}
+				db = db.Where("strategy_id in ?", strategyIdList)
+			} else {
+				db = db.Where(fmt.Sprintf("%s like '%%%v%%'", tag, value.Interface()))
+			}
+		}
+	}
+	var taskInfos []gorm_model.YoungeeTaskInfo
+	db = db.Model(gorm_model.YoungeeTaskInfo{})
+	// 查询总数
+	var totalTask int64
+	if err := db.Count(&totalTask).Error; err != nil {
+		logrus.WithContext(ctx).Errorf("[GetProjectTaskList] error query mysql total, err:%+v", err)
+		return nil, 0, err
+	}
+	db.Order("task_id").Find(&taskInfos)
+
+	// 查询任务id
+	var taskIds []int
+	taskMap := make(map[int]gorm_model.YoungeeTaskInfo)
+	for _, taskInfo := range taskInfos {
+		taskIds = append(taskIds, taskInfo.TaskId)
+		taskMap[taskInfo.TaskId] = taskInfo
+	}
+	db1 := GetReadDB(ctx)
+	db1 = db1.Debug().Model(gorm_model.YounggeeSketchInfo{})
+
+	var SketchInfos []gorm_model.YounggeeSketchInfo
+	db1 = db1.Model(gorm_model.YounggeeSketchInfo{}).Where("task_id IN ? AND is_submit=? ", taskIds, 1)
+	if conditions.SketchStatus == int64(0) {
+		db1 = db1.Where("is_review = 0").Find(&SketchInfos)
+	} else {
+		db1 = db1.Where("is_ok = 1").Find(&SketchInfos)
+	}
+	fmt.Printf("初稿查询：%+v", SketchInfos)
+	SketchMap := make(map[int]gorm_model.YounggeeSketchInfo)
+	for _, SketchInfo := range SketchInfos {
+		SketchMap[conv.MustInt(SketchInfo.TaskID, 0)] = SketchInfo
+	}
+	// 查询总数
+	var totalSketch int64
+	if err := db1.Count(&totalSketch).Error; err != nil {
+		logrus.WithContext(ctx).Errorf("[GetProjectTalentList] error query mysql total, err:%+v", err)
+		return nil, 0, err
+	}
+	var misNum int64
+	if totalSketch > totalTask {
+		misNum = totalSketch - totalTask
+	} else {
+		misNum = totalTask - totalSketch
+	}
+	logrus.Println("totalSketch,totalTalent,misNum:", totalSketch, totalTask, misNum)
+
+	// 查询该页数据
+	limit := pageSize + misNum
+	offset := pageSize * pageNum // assert pageNum start with 0
+	//fmt.Printf("limit %+v  offset %+v \n", limit, offset)
+	err := db.Order("task_id").Limit(int(limit)).Offset(int(offset)).Error
+
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[GetProjectTaskList] error query mysql total, err:%+v", err)
+		return nil, 0, err
+	}
+
+	var TaskSketches []*http_model.TaskSketch
+	var taskSketches []*http_model.TaskSketchInfo
+	var newTaskSketches []*http_model.TaskSketchInfo
+	for _, taskId := range taskIds {
+		TaskSketch := new(http_model.TaskSketch)
+		TaskSketch.Talent = taskMap[taskId]
+		TaskSketch.Sketch = SketchMap[taskId]
+		TaskSketches = append(TaskSketches, TaskSketch)
+	}
+
+	taskSketches = pack.TaskSketchToTaskInfo(TaskSketches)
+
+	for _, v := range taskSketches {
+		if platform_nickname == "" {
+			newTaskSketches = append(newTaskSketches, v)
+		} else if strings.Contains(v.PlatformNickname, platform_nickname) {
+			newTaskSketches = append(newTaskSketches, v)
+		} else {
+			totalTask--
+		}
+	}
+	return newTaskSketches, totalTask, nil
+}
+
+// SketchOption 提交意见
+func SketchOption(ctx context.Context, TaskID int, ReviseOpinion string) error {
+	db := GetReadDB(ctx)
+	fmt.Printf("初稿意见 %d %+v", TaskID, ReviseOpinion)
+	err := db.Model(gorm_model.YounggeeSketchInfo{}).Where("task_id = ? and is_review = 0", TaskID).Updates(map[string]interface{}{"revise_opinion": ReviseOpinion, "reject_at": time.Now(), "is_review": 1}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Sketch db] call RevisieOption error,err:%+v", err)
+		return err
+	}
+	err = db.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", TaskID).Updates(gorm_model.YoungeeTaskInfo{SketchStatus: 3}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Sketch db] Update YoungeeTaskInfo error,err:%+v", err)
+		return err
+	}
+	err = db.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", TaskID).Updates(gorm_model.YoungeeTaskInfo{TaskStage: 9}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Sketch db] Update YoungeeTaskInfo error,err:%+v", err)
+		return err
+	}
+	return nil
+}
+
+// AcceptSketch 同意初稿
+func AcceptSketch(ctx context.Context, TaskIDs []int) error {
+	db := GetReadDB(ctx)
+	err := db.Model(gorm_model.YounggeeSketchInfo{}).Where("task_id in ? and is_review = 0", TaskIDs).Updates(map[string]interface{}{"is_ok": 1, "is_review": 1, "agree_at": time.Now()}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Sketch db] Update YounggeeSketchInfo error,err:%+v", err)
+		return err
+	}
+	err = db.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id in ?", TaskIDs).Updates(gorm_model.YoungeeTaskInfo{SketchStatus: 5}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Sketch db] Update YoungeeTaskInfo error,err:%+v", err)
+		return err
+	}
+
+	err = db.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id in ?", TaskIDs).Updates(gorm_model.YoungeeTaskInfo{TaskStage: 11}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Sketch db] Update YoungeeTaskInfo error,err:%+v", err)
+		return err
+	}
+	return nil
+}
+
+// FindPhoto
+func FindSketchInfo(ctx context.Context, TaskID int64) (*gorm_model.YounggeeSketchInfo, error) {
+	db := GetReadDB(ctx)
+	var SketchInfo gorm_model.YounggeeSketchInfo
+	err := db.Model(gorm_model.YounggeeSketchInfo{}).Where("task_id = ? and is_ok = 1", TaskID).Find(&SketchInfo).Error
+	if err != nil {
+		return nil, err
+	}
+	return &SketchInfo, nil
+
+}
+
+// FindPhoto
+func FindPhoto(ctx context.Context, SketchID int64) ([]gorm_model.YounggeeSketchPhoto, error) {
+	db := GetReadDB(ctx)
+	var SketchPhotos []gorm_model.YounggeeSketchPhoto
+	err := db.Model(gorm_model.YounggeeSketchPhoto{}).Where("sketch_id=?", SketchID).Find(&SketchPhotos).Error
+	if err != nil {
+		return nil, err
+	}
+	return SketchPhotos, nil
+
+}

db/task.go

@@ -2,12 +2,16 @@ package db
 
 import (
 	"context"
+	"github.com/caixw/lib.go/conv"
+	"time"
 	"youngee_m_api/model/gorm_model"
+
+	"github.com/sirupsen/logrus"
 )
 
 func GetTaskList(ctx context.Context, projectID int64) ([]gorm_model.YoungeeTaskInfo, error) {
 	db := GetReadDB(ctx)
-	var tasks []gorm_model.YoungeeTaskInfo
+	tasks := []gorm_model.YoungeeTaskInfo{}
 
 	err := db.Where("project_id=?", projectID).Find(&tasks).Error
 	if err != nil {
@@ -15,3 +19,75 @@ func GetTaskList(ctx context.Context, projectID int64) ([]gorm_model.YoungeeTask
 	}
 	return tasks, nil
 }
+
+func UpdateLogisticsStatus(ctx context.Context, taskID int64, status int64) error {
+
+	db := GetReadDB(ctx)
+	err := db.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", taskID).Update("logistics_status", status).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[task db] call UpdateLogisticsStatus error,err:%+v", err)
+		return err
+	}
+	return nil
+}
+
+func UpdateLogisticsDate(ctx context.Context, taskID int64) error {
+
+	db := GetReadDB(ctx)
+	err := db.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", taskID).Update("delivery_date", time.Now()).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[task db] call UpdateLogisticsDate error,err:%+v", err)
+		return err
+	}
+	return nil
+}
+
+func GetProjectIdByTaskId(ctx context.Context, taskID int64) (*int, error) {
+	db := GetReadDB(ctx)
+	task := &gorm_model.YoungeeTaskInfo{}
+	err := db.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", taskID).Scan(task).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[task db] call UpdateLogisticsStatus error,err:%+v", err)
+		return nil, err
+	}
+	return &task.ProjectId, nil
+}
+
+func ChangeTaskStatus(ctx context.Context, taskIds []string, taskStatus string) ([]int64, error) {
+	db := GetReadDB(ctx)
+
+	taskSta := conv.MustInt(taskStatus, 0)
+	if err := db.Debug().Model(&gorm_model.YoungeeTaskInfo{}).Where("task_id IN ?", taskIds).
+		Updates(gorm_model.YoungeeTaskInfo{TaskStatus: taskSta}).Error; err != nil {
+		logrus.WithContext(ctx).Errorf("[ChangeTaskStatus]2 error query mysql total, err:%+v", err)
+		return nil, err
+	}
+
+	var taskInfos []gorm_model.YoungeeTaskInfo
+	err := db.Debug().Model(&gorm_model.YoungeeTaskInfo{}).Where("task_id IN ?", taskIds).Find(&taskInfos).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[ChangeTaskStatus]3 error query mysql total, err:%+v", err)
+		return nil, err
+	}
+	var recruitStrategysIDs []int64
+	recruitStrategys := gorm_model.RecruitStrategy{}
+	for _, taskInfo := range taskInfos {
+		err2 := db.Debug().Model(gorm_model.RecruitStrategy{}).Where("project_id=? AND strategy_id=?", taskInfo.ProjectId, taskInfo.StrategyId).Scan(&recruitStrategys).Error
+		if err2 != nil {
+			logrus.WithContext(ctx).Errorf("[ChangeTaskStatus]4 error query mysql total, err:%+v", err2)
+			return nil, err2
+		}
+		recruitStrategysIDs = append(recruitStrategysIDs, recruitStrategys.RecruitStrategyID)
+	}
+	return recruitStrategysIDs, nil
+}
+
+func UpdateTaskStage(ctx context.Context, projectID int64, taskStatus int64, taskStage int64) error {
+	db := GetReadDB(ctx)
+	err := db.Model(gorm_model.YoungeeTaskInfo{}).Where("project_id=? and task_status = ?", projectID, taskStatus).Update("task_stage", taskStage).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[UpdateTaskStatusPaying]2 error query mysql total, err:%+v", err)
+		return err
+	}
+	return nil
+}

db/terminate.go

@@ -0,0 +1,47 @@
+package db
+
+import (
+	"context"
+	"time"
+	"youngee_m_api/model/gorm_model"
+	"youngee_m_api/util"
+
+	"github.com/sirupsen/logrus"
+)
+
+// Terminate 批量提交解约申请
+func Terminate(ctx context.Context, TaskIDs, projectIds []int) error {
+	db := GetReadDB(ctx)
+	err := db.Model(gorm_model.YoungeeContractInfo{}).Where("task_id in ?  and default_status = 1", TaskIDs).
+		Updates(map[string]interface{}{"default_status": 3, "terminate_at": time.Now()}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Data db] Update YoungeeContractInfo error,err:%+v", err)
+		return err
+	}
+	err = db.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id in ?", TaskIDs).Updates(gorm_model.YoungeeTaskInfo{CurDefaultType: 9}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Data db] Update YoungeeTaskInfo error,err:%+v", err)
+		return err
+	}
+	util.RemoveIntRepByMap(projectIds)
+	var unfinishedNum int64
+	for _, projectId := range projectIds {
+		err1 := db.Model(gorm_model.YoungeeTaskInfo{}).Where("project_id = ? AND task_status = 2 AND task_stage < 15", projectId).Count(&unfinishedNum).Error
+		if err1 != nil {
+			logrus.WithContext(ctx).Errorf("[Data db] Count YoungeeTaskInfo error,err:%+v", err)
+			return err1
+		}
+		if unfinishedNum == 0 {
+			// 1. 更新项目状态为结束
+			err2 := db.Model(gorm_model.ProjectInfo{}).Where("project_id = ?", projectId).Updates("project_status = 10").Error
+			if err2 != nil {
+				logrus.WithContext(ctx).Errorf("[Data db] Count YoungeeTaskInfo error,err:%+v", err)
+				return err2
+			}
+			// 2. 释放企业账户因项目冻结的资金
+			// 1） 计算剩余资金
+			// 2） 释放剩余资金
+		}
+	}
+	return nil
+}

db/user.go

@@ -358,3 +358,16 @@ func DeleteAccount(ctx context.Context, PlatformID, PlatformNickname, TalentId s
 	}
 	return nil
 }
+
+func GetEnterpriseIds(ctx context.Context) (*http_model.EnterPriseIds, error) {
+	var enterpriseIds []int64
+	db := GetReadDB(ctx)
+	err := db.Model(gorm_model.Enterprise{}).Select("enterprise_id").Find(&enterpriseIds).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[user db] call GetEnterpriseIds error,err:%+v", err)
+		return nil, err
+	}
+	EnterpriseIds := http_model.EnterPriseIds{}
+	EnterpriseIds.EnterPriseIds = enterpriseIds
+	return &EnterpriseIds, nil
+}

go.mod

@@ -31,7 +31,11 @@ require (
 	github.com/modern-go/reflect2 v1.0.2 // indirect
 	github.com/pelletier/go-toml/v2 v2.0.1 // indirect
 	github.com/robfig/cron/v3 v3.0.0 // indirect
+	github.com/tidwall/gjson v1.14.3 // indirect
+	github.com/tidwall/match v1.1.1 // indirect
+	github.com/tidwall/pretty v1.2.0 // indirect
 	github.com/ugorji/go/codec v1.2.7 // indirect
+	github.com/wechatpay-apiv3/wechatpay-go v0.2.15 // indirect
 	golang.org/x/crypto v0.0.0-20210711020723-a769d52b0f97 // indirect
 	golang.org/x/net v0.0.0-20210428140749-89ef3d95e781 // indirect
 	golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e // indirect

go.sum

@@ -1,3 +1,4 @@
+github.com/agiledragon/gomonkey v2.0.2+incompatible/go.mod h1:2NGfXu1a80LLr2cmWXGBDaHEjb1idR6+FVlX5T3D9hw=
 github.com/caixw/lib.go v0.0.0-20141220110639-1781da9139e0 h1:MnIURgMAFAMyxAHu8h2TbnjxMMd7SKVCPyTZz5EfwNA=
 github.com/caixw/lib.go v0.0.0-20141220110639-1781da9139e0/go.mod h1:hQL8hyiiVE/BSo7gh13njx+DpvoPh/yE8/BkKKc62RA=
 github.com/cespare/xxhash/v2 v2.1.2 h1:YRXhKfTDauu4ajMg1TPgFO5jnlC2HCbmLXMcTG5cbYE=
@@ -67,16 +68,27 @@ github.com/rogpeppe/go-internal v1.8.0/go.mod h1:WmiCO8CzOY8rg0OYDC4/i/2WRWAB6po
 github.com/sirupsen/logrus v1.8.1 h1:dJKuHgqk1NNQlqoA6BTlM1Wf9DOH3NBjQyu0h9+AZZE=
 github.com/sirupsen/logrus v1.8.1/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.7.1 h1:5TQK59W5E3v0r2duFAb7P95B6hEeOyEnHRa8MjYSMTY=
 github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/tidwall/gjson v1.14.3 h1:9jvXn7olKEHU1S9vwoMGliaT8jq1vJ7IH/n9zD9Dnlw=
+github.com/tidwall/gjson v1.14.3/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk=
+github.com/tidwall/match v1.1.1 h1:+Ho715JplO36QYgwN9PGYNhgZvoUSc9X2c80KVTi+GA=
+github.com/tidwall/match v1.1.1/go.mod h1:eRSPERbgtNPcGhD8UCthc6PmLEQXEWd3PRB5JTxsfmM=
+github.com/tidwall/pretty v1.2.0 h1:RWIZEg2iJ8/g6fDDYzMpobmaoGh5OLl4AXtGUGPcqCs=
+github.com/tidwall/pretty v1.2.0/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU=
 github.com/ugorji/go v1.2.7 h1:qYhyWUUd6WbiM+C6JZAUkIJt/1WrjzNHY9+KCIjVqTo=
 github.com/ugorji/go v1.2.7/go.mod h1:nF9osbDWLy6bDVv/Rtoh6QgnvNDpmCalQV5urGCCS6M=
 github.com/ugorji/go/codec v1.2.7 h1:YPXUKf7fYbp/y8xloBqZOw2qaVggbfwMlI8WM3wZUJ0=
 github.com/ugorji/go/codec v1.2.7/go.mod h1:WGN1fab3R1fzQlVQTkfxVtIBhWDRqOviHU95kRgeqEY=
+github.com/wechatpay-apiv3/wechatpay-go v0.2.15 h1:WtlAK8GsLwTveS7c5W8Vd1m4rU1cJ0YW6tqBW2BlKH8=
+github.com/wechatpay-apiv3/wechatpay-go v0.2.15/go.mod h1:Ca9wvI7xFoIWiY163q1jzddarQBS+1NE17OM1ZV24nw=
 golang.org/x/crypto v0.0.0-20210711020723-a769d52b0f97 h1:/UOmuWzQfxxo9UtlXMwuQU8CMgg1eZXqTRwkSQJWKOI=
 golang.org/x/crypto v0.0.0-20210711020723-a769d52b0f97/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110 h1:qWPm9rbaAMKs8Bq/9LRpbMqxWRVUAQwMI9fVrssnTfw=
@@ -112,6 +124,8 @@ gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b h1:h8qDotaEPuJATrMmW04NCwg7v22aHH28wwpauUhK9Oo=
 gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gorm.io/driver/mysql v1.3.4 h1:/KoBMgsUHC3bExsekDcmNYaBnfH2WNeFuXqqrqMc98Q=
 gorm.io/driver/mysql v1.3.4/go.mod h1:s4Tq0KmD0yhPGHbZEwg1VPlH0vT/GBHJZorPzhcxBUE=
 gorm.io/gorm v1.23.4/go.mod h1:l2lP/RyAtc1ynaTjFksBde/O8v9oOGIApu2/xRitmZk=

handler/ConfirmWithdrawal.go

@@ -0,0 +1,55 @@
+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 WrapConfirmWithdrawalHandler(ctx *gin.Context) {
+	handler := newConfirmWithdrawalHandler(ctx)
+	BaseRun(handler)
+}
+
+type ConfirmWithdrawalHandler struct {
+	ctx  *gin.Context
+	req  *http_model.ConfirmWithdrawalRequest
+	resp *http_model.CommonResponse
+}
+
+func (c ConfirmWithdrawalHandler) getContext() *gin.Context {
+	return c.ctx
+}
+
+func (c ConfirmWithdrawalHandler) getResponse() interface{} {
+	return c.resp
+}
+
+func (c ConfirmWithdrawalHandler) getRequest() interface{} {
+	return c.req
+}
+
+func (c ConfirmWithdrawalHandler) run() {
+	err := db.ConfirmWithdrawal(c.ctx, c.req.WithdrawId)
+	if err != nil {
+		logrus.WithContext(c.ctx).Errorf("[ConfirmWithdrawalHandler] error ConfirmWithdrawal, err:%+v", err)
+		util.HandlerPackErrorResp(c.resp, consts.ErrorInternal, consts.DefaultToast)
+		return
+	}
+	c.resp.Message = "确认提现成功"
+}
+
+func (c ConfirmWithdrawalHandler) checkParam() error {
+	return nil
+}
+
+func newConfirmWithdrawalHandler(ctx *gin.Context) *ConfirmWithdrawalHandler {
+	return &ConfirmWithdrawalHandler{
+		ctx:  ctx,
+		req:  http_model.NewConfirmWithdrawalRequest(),
+		resp: http_model.NewConfirmWithdrawalResponse(),
+	}
+}

handler/accept_data.go

@@ -0,0 +1,58 @@
+package handler
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+	log "github.com/sirupsen/logrus"
+	"youngee_m_api/consts"
+	"youngee_m_api/model/http_model"
+	"youngee_m_api/service"
+	"youngee_m_api/util"
+)
+
+func WrapAcceptDataHandler(ctx *gin.Context) {
+	handler := newAcceptDataHandler(ctx)
+	BaseRun(handler)
+}
+
+func newAcceptDataHandler(ctx *gin.Context) *AcceptDataHandler {
+	return &AcceptDataHandler{
+		req:  http_model.NewAcceptDataRequest(),
+		resp: http_model.NewAcceptDataResponse(),
+		ctx:  ctx,
+	}
+}
+
+type AcceptDataHandler struct {
+	req  *http_model.AcceptDataRequest
+	resp *http_model.CommonResponse
+	ctx  *gin.Context
+}
+
+func (h *AcceptDataHandler) getRequest() interface{} {
+	return h.req
+}
+func (h *AcceptDataHandler) getContext() *gin.Context {
+	return h.ctx
+}
+func (h *AcceptDataHandler) getResponse() interface{} {
+	return h.resp
+}
+
+func (h *AcceptDataHandler) run() {
+	data := http_model.AcceptDataRequest{}
+	data = *h.req
+	res, err := service.Data.AcceptData(h.ctx, data)
+	if err != nil {
+		logrus.Errorf("[ReviseOpinionHandler] call Create err:%+v\n", err)
+		util.HandlerPackErrorResp(h.resp, consts.ErrorInternal, "")
+		log.Info("CreateProject fail,req:%+v", h.req)
+		return
+	}
+	h.resp.Message = "成功通过脚本"
+	h.resp.Data = res
+}
+
+func (h *AcceptDataHandler) checkParam() error {
+	return nil
+}

handler/accept_link.go

@@ -0,0 +1,89 @@
+package handler
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+	log "github.com/sirupsen/logrus"
+	"youngee_m_api/consts"
+	"youngee_m_api/model/http_model"
+	"youngee_m_api/service"
+	"youngee_m_api/util"
+)
+
+func WrapAcceptLinkHandler(ctx *gin.Context) {
+	handler := newAcceptLinkHandler(ctx)
+	BaseRun(handler)
+}
+
+func newAcceptLinkHandler(ctx *gin.Context) *AcceptLinkHandler {
+	return &AcceptLinkHandler{
+		req:  http_model.NewAcceptLinkRequest(),
+		resp: http_model.NewAcceptLinkResponse(),
+		ctx:  ctx,
+	}
+}
+
+type AcceptLinkHandler struct {
+	req  *http_model.AcceptLinkRequest
+	resp *http_model.CommonResponse
+	ctx  *gin.Context
+}
+
+func (h *AcceptLinkHandler) getRequest() interface{} {
+	return h.req
+}
+func (h *AcceptLinkHandler) getContext() *gin.Context {
+	return h.ctx
+}
+func (h *AcceptLinkHandler) getResponse() interface{} {
+	return h.resp
+}
+
+func (h *AcceptLinkHandler) run() {
+	data := http_model.AcceptLinkRequest{}
+	data = *h.req
+	res, err := service.Link.AcceptLink(h.ctx, data)
+	if err != nil {
+		logrus.Errorf("[ReviseOpinionHandler] call Create err:%+v\n", err)
+		util.HandlerPackErrorResp(h.resp, consts.ErrorInternal, "")
+		log.Info("CreateProject fail,req:%+v", h.req)
+		return
+	}
+	h.resp.Message = "成功通过脚本"
+	h.resp.Data = res
+	h.resp.Data = data
+}
+
+/***
+func (h *AcceptLinkHandler) run() {
+	data := http_model.AcceptLinkRequest{}
+	data = *h.req
+	isRefuse := data.IsRefuse
+	if isRefuse== 0 {
+		fmt.Println("Create in")
+		res, err := service.Project.Create(h.ctx, data)
+		if err != nil {
+			logrus.Errorf("[AcceptLinkHandler] call Create err:%+v\n", err)
+			util.HandlerPackErrorResp(h.resp, consts.ErrorInternal, "")
+			log.Info("CreateProject fail,req:%+v", h.req)
+			return
+		}
+		h.resp.Message = "成功添加修改意见"
+		h.resp.Data = res
+	} else {
+		res, err := service.Logistics.Update(h.ctx, data)
+		if err != nil {
+			logrus.Errorf("[AcceptLinkHandler] call Create err:%+v\n", err)
+			util.HandlerPackErrorResp(h.resp, consts.ErrorInternal, "")
+			log.Info("CreateProject fail,req:%+v", h.req)
+			return
+		}
+		h.resp.Message = "成功修改物流信息"
+		h.resp.Data = res
+	}
+
+}
+***/
+func (h *AcceptLinkHandler) checkParam() error {
+	return nil
+}

handler/accept_script.go

@@ -0,0 +1,89 @@
+package handler
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+	log "github.com/sirupsen/logrus"
+	"youngee_m_api/consts"
+	"youngee_m_api/model/http_model"
+	"youngee_m_api/service"
+	"youngee_m_api/util"
+)
+
+func WrapAcceptScriptHandler(ctx *gin.Context) {
+	handler := newAcceptScriptHandler(ctx)
+	BaseRun(handler)
+}
+
+func newAcceptScriptHandler(ctx *gin.Context) *AcceptScriptHandler {
+	return &AcceptScriptHandler{
+		req:  http_model.NewAcceptScriptRequest(),
+		resp: http_model.NewAcceptScriptResponse(),
+		ctx:  ctx,
+	}
+}
+
+type AcceptScriptHandler struct {
+	req  *http_model.AcceptScriptRequest
+	resp *http_model.CommonResponse
+	ctx  *gin.Context
+}
+
+func (h *AcceptScriptHandler) getRequest() interface{} {
+	return h.req
+}
+func (h *AcceptScriptHandler) getContext() *gin.Context {
+	return h.ctx
+}
+func (h *AcceptScriptHandler) getResponse() interface{} {
+	return h.resp
+}
+
+func (h *AcceptScriptHandler) run() {
+	data := http_model.AcceptScriptRequest{}
+	data = *h.req
+	res, err := service.Script.AcceptScript(h.ctx, data)
+	if err != nil {
+		logrus.Errorf("[ReviseOpinionHandler] call Create err:%+v\n", err)
+		util.HandlerPackErrorResp(h.resp, consts.ErrorInternal, "")
+		log.Info("CreateProject fail,req:%+v", h.req)
+		return
+	}
+	h.resp.Message = "成功通过脚本"
+	h.resp.Data = res
+	h.resp.Data = data
+}
+
+/***
+func (h *AcceptScriptHandler) run() {
+	data := http_model.AcceptScriptRequest{}
+	data = *h.req
+	isRefuse := data.IsRefuse
+	if isRefuse== 0 {
+		fmt.Println("Create in")
+		res, err := service.Project.Create(h.ctx, data)
+		if err != nil {
+			logrus.Errorf("[AcceptScriptHandler] call Create err:%+v\n", err)
+			util.HandlerPackErrorResp(h.resp, consts.ErrorInternal, "")
+			log.Info("CreateProject fail,req:%+v", h.req)
+			return
+		}
+		h.resp.Message = "成功添加修改意见"
+		h.resp.Data = res
+	} else {
+		res, err := service.Logistics.Update(h.ctx, data)
+		if err != nil {
+			logrus.Errorf("[AcceptScriptHandler] call Create err:%+v\n", err)
+			util.HandlerPackErrorResp(h.resp, consts.ErrorInternal, "")
+			log.Info("CreateProject fail,req:%+v", h.req)
+			return
+		}
+		h.resp.Message = "成功修改物流信息"
+		h.resp.Data = res
+	}
+
+}
+***/
+func (h *AcceptScriptHandler) checkParam() error {
+	return nil
+}

handler/accept_sketch.go

@@ -0,0 +1,89 @@
+package handler
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+	log "github.com/sirupsen/logrus"
+	"youngee_m_api/consts"
+	"youngee_m_api/model/http_model"
+	"youngee_m_api/service"
+	"youngee_m_api/util"
+)
+
+func WrapAcceptSketchHandler(ctx *gin.Context) {
+	handler := newAcceptSketchHandler(ctx)
+	BaseRun(handler)
+}
+
+func newAcceptSketchHandler(ctx *gin.Context) *AcceptSketchHandler {
+	return &AcceptSketchHandler{
+		req:  http_model.NewAcceptSketchRequest(),
+		resp: http_model.NewAcceptSketchResponse(),
+		ctx:  ctx,
+	}
+}
+
+type AcceptSketchHandler struct {
+	req  *http_model.AcceptSketchRequest
+	resp *http_model.CommonResponse
+	ctx  *gin.Context
+}
+
+func (h *AcceptSketchHandler) getRequest() interface{} {
+	return h.req
+}
+func (h *AcceptSketchHandler) getContext() *gin.Context {
+	return h.ctx
+}
+func (h *AcceptSketchHandler) getResponse() interface{} {
+	return h.resp
+}
+
+func (h *AcceptSketchHandler) run() {
+	data := http_model.AcceptSketchRequest{}
+	data = *h.req
+	res, err := service.Sketch.AcceptSketch(h.ctx, data)
+	if err != nil {
+		logrus.Errorf("[ReviseOpinionHandler] call Create err:%+v\n", err)
+		util.HandlerPackErrorResp(h.resp, consts.ErrorInternal, "")
+		log.Info("CreateProject fail,req:%+v", h.req)
+		return
+	}
+	h.resp.Message = "成功通过初稿"
+	h.resp.Data = res
+	h.resp.Data = data
+}
+
+/***
+func (h *AcceptSketchHandler) run() {
+	data := http_model.AcceptSketchRequest{}
+	data = *h.req
+	isRefuse := data.IsRefuse
+	if isRefuse== 0 {
+		fmt.Println("Create in")
+		res, err := service.Project.Create(h.ctx, data)
+		if err != nil {
+			logrus.Errorf("[AcceptSketchHandler] call Create err:%+v\n", err)
+			util.HandlerPackErrorResp(h.resp, consts.ErrorInternal, "")
+			log.Info("CreateProject fail,req:%+v", h.req)
+			return
+		}
+		h.resp.Message = "成功添加修改意见"
+		h.resp.Data = res
+	} else {
+		res, err := service.Logistics.Update(h.ctx, data)
+		if err != nil {
+			logrus.Errorf("[AcceptSketchHandler] call Create err:%+v\n", err)
+			util.HandlerPackErrorResp(h.resp, consts.ErrorInternal, "")
+			log.Info("CreateProject fail,req:%+v", h.req)
+			return
+		}
+		h.resp.Message = "成功修改物流信息"
+		h.resp.Data = res
+	}
+
+}
+***/
+func (h *AcceptSketchHandler) checkParam() error {
+	return nil
+}

handler/confirmInvoice.go

@@ -0,0 +1,57 @@
+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 WrapConfirmInvoiceHandler(ctx *gin.Context) {
+	handler := newConfirmInvoiceHandler(ctx)
+	BaseRun(handler)
+}
+
+type ConfirmInvoiceHandler struct {
+	ctx  *gin.Context
+	req  *http_model.ConfirmInvoiceRequest
+	resp *http_model.CommonResponse
+}
+
+func (c ConfirmInvoiceHandler) getContext() *gin.Context {
+	return c.ctx
+}
+
+func (c ConfirmInvoiceHandler) getResponse() interface{} {
+	return c.resp
+}
+
+func (c ConfirmInvoiceHandler) getRequest() interface{} {
+	return c.req
+}
+
+func (c ConfirmInvoiceHandler) run() {
+	err := db.ConfirmInvoice(c.ctx, c.req)
+	if err != nil {
+		// 数据库查询失败，返回5001
+		logrus.Errorf("[ConfirmInvoiceHandler] call ConfirmInvoice err:%+v\n", err)
+		util.HandlerPackErrorResp(c.resp, consts.ErrorInternal, "")
+		logrus.Info("ConfirmInvoice fail,req:%+v", c.req)
+		return
+	}
+	c.resp.Message = "确认开票成功"
+}
+
+func (c ConfirmInvoiceHandler) checkParam() error {
+	return nil
+}
+
+func newConfirmInvoiceHandler(ctx *gin.Context) *ConfirmInvoiceHandler {
+	return &ConfirmInvoiceHandler{
+		ctx:  ctx,
+		req:  http_model.NewConfirmInvoiceRequest(),
+		resp: http_model.NewConfirmInvoiceResponse(),
+	}
+}

handler/data_number_info.go

@@ -0,0 +1,58 @@
+package handler
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+	log "github.com/sirupsen/logrus"
+	"youngee_m_api/consts"
+	"youngee_m_api/model/http_model"
+	"youngee_m_api/service"
+	"youngee_m_api/util"
+)
+
+func WrapGetDataNumberInfoHandler(ctx *gin.Context) {
+	handler := newGetDataNumberInfoHandler(ctx)
+	BaseRun(handler)
+}
+
+func newGetDataNumberInfoHandler(ctx *gin.Context) *GetDataNumberInfoHandler {
+	return &GetDataNumberInfoHandler{
+		req:  http_model.NewGetDataNumberInfoRequest(),
+		resp: http_model.NewGetDataNumberInfoResponse(),
+		ctx:  ctx,
+	}
+}
+
+type GetDataNumberInfoHandler struct {
+	req  *http_model.GetDataNumberInfoRequest
+	resp *http_model.CommonResponse
+	ctx  *gin.Context
+}
+
+func (h *GetDataNumberInfoHandler) getRequest() interface{} {
+	return h.req
+}
+func (h *GetDataNumberInfoHandler) getContext() *gin.Context {
+	return h.ctx
+}
+func (h *GetDataNumberInfoHandler) getResponse() interface{} {
+	return h.resp
+}
+
+func (h *GetDataNumberInfoHandler) run() {
+	data := http_model.GetDataNumberInfoRequest{}
+	data = *h.req
+	res, err := service.Number.GetDataNumberInfo(h.ctx, data)
+	if err != nil {
+		logrus.Errorf("[GetDataNumberInfoHandler] call GetDataNumberInfo err:%+v\n", err)
+		util.HandlerPackErrorResp(h.resp, consts.ErrorInternal, "")
+		log.Info("GetDataNumberInfo fail,req:%+v", h.req)
+		return
+	}
+	h.resp.Message = ""
+	h.resp.Data = res
+}
+
+func (h *GetDataNumberInfoHandler) checkParam() error {
+	return nil
+}

handler/data_opinion.go

@@ -0,0 +1,89 @@
+package handler
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+	log "github.com/sirupsen/logrus"
+	"youngee_m_api/consts"
+	"youngee_m_api/model/http_model"
+	"youngee_m_api/service"
+	"youngee_m_api/util"
+)
+
+func WrapDataOpinionHandler(ctx *gin.Context) {
+	handler := newDataOpinionHandler(ctx)
+	BaseRun(handler)
+}
+
+func newDataOpinionHandler(ctx *gin.Context) *DataOpinionHandler {
+	return &DataOpinionHandler{
+		req:  http_model.NewDataOpinionRequest(),
+		resp: http_model.NewDataOpinionResponse(),
+		ctx:  ctx,
+	}
+}
+
+type DataOpinionHandler struct {
+	req  *http_model.DataOpinionRequest
+	resp *http_model.CommonResponse
+	ctx  *gin.Context
+}
+
+func (h *DataOpinionHandler) getRequest() interface{} {
+	return h.req
+}
+func (h *DataOpinionHandler) getContext() *gin.Context {
+	return h.ctx
+}
+func (h *DataOpinionHandler) getResponse() interface{} {
+	return h.resp
+}
+
+func (h *DataOpinionHandler) run() {
+	data := http_model.DataOpinionRequest{}
+	data = *h.req
+	res, err := service.Data.DataOpinion(h.ctx, data)
+	if err != nil {
+		logrus.Errorf("[DataOpinionHandler] call Create err:%+v\n", err)
+		util.HandlerPackErrorResp(h.resp, consts.ErrorInternal, "")
+		log.Info("CreateProject fail,req:%+v", h.req)
+		return
+	}
+	h.resp.Message = "提交脚本修改意见成功"
+	h.resp.Data = res
+	h.resp.Data = data
+}
+
+/***
+func (h *DataOpinionHandler) run() {
+	data := http_model.DataOpinionRequest{}
+	data = *h.req
+	isRefuse := data.IsRefuse
+	if isRefuse== 0 {
+		fmt.Println("Create in")
+		res, err := service.Project.Create(h.ctx, data)
+		if err != nil {
+			logrus.Errorf("[DataOpinionHandler] call Create err:%+v\n", err)
+			util.HandlerPackErrorResp(h.resp, consts.ErrorInternal, "")
+			log.Info("CreateProject fail,req:%+v", h.req)
+			return
+		}
+		h.resp.Message = "成功添加修改意见"
+		h.resp.Data = res
+	} else {
+		res, err := service.Logistics.Update(h.ctx, data)
+		if err != nil {
+			logrus.Errorf("[DataOpinionHandler] call Create err:%+v\n", err)
+			util.HandlerPackErrorResp(h.resp, consts.ErrorInternal, "")
+			log.Info("CreateProject fail,req:%+v", h.req)
+			return
+		}
+		h.resp.Message = "成功修改物流信息"
+		h.resp.Data = res
+	}
+
+}
+***/
+func (h *DataOpinionHandler) checkParam() error {
+	return nil
+}

handler/default_number_info.go

@@ -0,0 +1,58 @@
+package handler
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+	log "github.com/sirupsen/logrus"
+	"youngee_m_api/consts"
+	"youngee_m_api/model/http_model"
+	"youngee_m_api/service"
+	"youngee_m_api/util"
+)
+
+func WrapGetDefaultNumberInfoHandler(ctx *gin.Context) {
+	handler := newGetDefaultNumberInfoHandler(ctx)
+	BaseRun(handler)
+}
+
+func newGetDefaultNumberInfoHandler(ctx *gin.Context) *GetDefaultNumberInfoHandler {
+	return &GetDefaultNumberInfoHandler{
+		req:  http_model.NewGetDefaultNumberInfoRequest(),
+		resp: http_model.NewGetDefaultNumberInfoResponse(),
+		ctx:  ctx,
+	}
+}
+
+type GetDefaultNumberInfoHandler struct {
+	req  *http_model.GetDefaultNumberInfoRequest
+	resp *http_model.CommonResponse
+	ctx  *gin.Context
+}
+
+func (h *GetDefaultNumberInfoHandler) getRequest() interface{} {
+	return h.req
+}
+func (h *GetDefaultNumberInfoHandler) getContext() *gin.Context {
+	return h.ctx
+}
+func (h *GetDefaultNumberInfoHandler) getResponse() interface{} {
+	return h.resp
+}
+
+func (h *GetDefaultNumberInfoHandler) run() {
+	data := http_model.GetDefaultNumberInfoRequest{}
+	data = *h.req
+	res, err := service.Number.GetDefaultNumberInfo(h.ctx, data)
+	if err != nil {
+		logrus.Errorf("[GetDefaultNumberInfoHandler] call GetDefaultNumberInfo err:%+v\n", err)
+		util.HandlerPackErrorResp(h.resp, consts.ErrorInternal, "")
+		log.Info("GetDefaultNumberInfo fail,req:%+v", h.req)
+		return
+	}
+	h.resp.Message = ""
+	h.resp.Data = res
+}
+
+func (h *GetDefaultNumberInfoHandler) checkParam() error {
+	return nil
+}

handler/findAllProduct.go

@@ -0,0 +1,58 @@
+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 WrapFindAllProductHandler(ctx *gin.Context) {
+	handler := newFindAllProductHandler(ctx)
+	BaseRun(handler)
+}
+
+type AllProductHandler struct {
+	ctx  *gin.Context
+	req  *http_model.FindAllProductsRequest
+	resp *http_model.CommonResponse
+}
+
+func (a AllProductHandler) getContext() *gin.Context {
+	return a.ctx
+}
+
+func (a AllProductHandler) getResponse() interface{} {
+	return a.resp
+}
+
+func (a AllProductHandler) getRequest() interface{} {
+	return a.req
+}
+
+func (a AllProductHandler) run() {
+	res, err := service.Product.FindAll(a.ctx, a.req.EnterpriseID)
+	if err != nil {
+		// 数据库查询失败，返回5001
+		logrus.Errorf("[FindAllProductHandler] call FindAll err:%+v\n", err)
+		util.HandlerPackErrorResp(a.resp, consts.ErrorInternal, "")
+		logrus.Info("FindAllProduct fail,req:%+v", a.req)
+		return
+	}
+	// h.resp.Message = "查询成功"
+	a.resp.Data = res
+}
+
+func (a AllProductHandler) checkParam() error {
+	return nil
+}
+
+func newFindAllProductHandler(ctx *gin.Context) *AllProductHandler {
+	return &AllProductHandler{
+		ctx:  ctx,
+		req:  http_model.NewFindAllProductsRequest(),
+		resp: http_model.NewFindAllProductsResponse(),
+	}
+}

handler/finish_number_info.go

@@ -0,0 +1,58 @@
+package handler
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+	log "github.com/sirupsen/logrus"
+	"youngee_m_api/consts"
+	"youngee_m_api/model/http_model"
+	"youngee_m_api/service"
+	"youngee_m_api/util"
+)
+
+func WrapGetFinishNumberInfoHandler(ctx *gin.Context) {
+	handler := newGetFinishNumberInfoHandler(ctx)
+	BaseRun(handler)
+}
+
+func newGetFinishNumberInfoHandler(ctx *gin.Context) *GetFinishNumberInfoHandler {
+	return &GetFinishNumberInfoHandler{
+		req:  http_model.NewGetFinishNumberInfoRequest(),
+		resp: http_model.NewGetFinishNumberInfoResponse(),
+		ctx:  ctx,
+	}
+}
+
+type GetFinishNumberInfoHandler struct {
+	req  *http_model.GetFinishNumberInfoRequest
+	resp *http_model.CommonResponse
+	ctx  *gin.Context
+}
+
+func (h *GetFinishNumberInfoHandler) getRequest() interface{} {
+	return h.req
+}
+func (h *GetFinishNumberInfoHandler) getContext() *gin.Context {
+	return h.ctx
+}
+func (h *GetFinishNumberInfoHandler) getResponse() interface{} {
+	return h.resp
+}
+
+func (h *GetFinishNumberInfoHandler) run() {
+	data := http_model.GetFinishNumberInfoRequest{}
+	data = *h.req
+	res, err := service.Number.GetFinishNumberInfo(h.ctx, data)
+	if err != nil {
+		logrus.Errorf("[GetFinishNumberInfoHandler] call GetFinishNumberInfo err:%+v\n", err)
+		util.HandlerPackErrorResp(h.resp, consts.ErrorInternal, "")
+		log.Info("GetFinishNumberInfo fail,req:%+v", h.req)
+		return
+	}
+	h.resp.Message = ""
+	h.resp.Data = res
+}
+
+func (h *GetFinishNumberInfoHandler) checkParam() error {
+	return nil
+}

handler/getBankInfo.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 WrapGetBankInfoHandler(ctx *gin.Context) {
+	handler := newGetBankInfoHandler(ctx)
+	BaseRun(handler)
+}
+
+type GetBankInfo struct {
+	ctx  *gin.Context
+	req  *http_model.GetBankInfoRequest
+	resp *http_model.CommonResponse
+}
+
+func (g GetBankInfo) getContext() *gin.Context {
+	return g.ctx
+}
+
+func (g GetBankInfo) getResponse() interface{} {
+	return g.resp
+}
+
+func (g GetBankInfo) getRequest() interface{} {
+	return g.req
+}
+
+func (g GetBankInfo) run() {
+	data, err := db.GetBankInfo(g.ctx, g.req)
+	if err != nil {
+		logrus.WithContext(g.ctx).Errorf("[GetBankInfoHandler] error GetBankInfo, err:%+v", err)
+		util.HandlerPackErrorResp(g.resp, consts.ErrorInternal, consts.DefaultToast)
+		return
+	}
+	g.resp.Data = data
+
+}
+
+func (g GetBankInfo) checkParam() error {
+	return nil
+}
+
+func newGetBankInfoHandler(ctx *gin.Context) *GetBankInfo {
+	return &GetBankInfo{
+		ctx:  ctx,
+		req:  http_model.NewGetBankInfoRequest(),
+		resp: http_model.NewGetBankInfoResponse(),
+	}
+}

handler/getCodeUrl.go

@@ -0,0 +1,61 @@
+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 WrapGetCodeUrlHandler(ctx *gin.Context) {
+	handler := newGetCodeUrlHandler(ctx)
+	BaseRun(handler)
+}
+
+type getCodeUrlHandler struct {
+	ctx  *gin.Context
+	req  *http_model.GetCodeUrlRequest
+	resp *http_model.CommonResponse
+}
+
+func (g getCodeUrlHandler) getContext() *gin.Context {
+	return g.ctx
+}
+
+func (g getCodeUrlHandler) getResponse() interface{} {
+	return g.resp
+}
+
+func (g getCodeUrlHandler) getRequest() interface{} {
+	return g.req
+}
+
+func (g getCodeUrlHandler) run() {
+	tradeId := util.GetRandomString(32)
+	if g.req.Type == 1 {
+		data, err := service.NativeApiServicePrepay(tradeId, g.req.Amount)
+		if err != nil {
+			logrus.WithContext(g.ctx).Errorf("[ConfirmWithdrawalHandler] error ConfirmWithdrawal, err:%+v", err)
+			util.HandlerPackErrorResp(g.resp, consts.ErrorInternal, consts.DefaultToast)
+			return
+		}
+		codeUrlData := new(http_model.CodeUrl)
+		codeUrlData.CodeUrl = data
+		codeUrlData.TradeId = tradeId
+		g.resp.Data = codeUrlData
+	}
+}
+
+func (g getCodeUrlHandler) checkParam() error {
+	return nil
+}
+
+func newGetCodeUrlHandler(ctx *gin.Context) *getCodeUrlHandler {
+	return &getCodeUrlHandler{
+		ctx:  ctx,
+		req:  http_model.NewGetCodeUrlRequest(),
+		resp: http_model.NewGetCodeUrlResponse(),
+	}
+}

handler/getEnterpriseIds.go

@@ -0,0 +1,55 @@
+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 WrapGetEnterpriseIdsHandler(ctx *gin.Context) {
+	handler := newGetEnterpriseIdsHandler(ctx)
+	BaseRun(handler)
+}
+
+type GetEnterpriseIdsHandler struct {
+	ctx  *gin.Context
+	req  *http_model.GetEnterPriseIdsRequest
+	resp *http_model.CommonResponse
+}
+
+func (g GetEnterpriseIdsHandler) getContext() *gin.Context {
+	return g.ctx
+}
+
+func (g GetEnterpriseIdsHandler) getResponse() interface{} {
+	return g.resp
+}
+
+func (g GetEnterpriseIdsHandler) getRequest() interface{} {
+	return g.req
+}
+
+func (g GetEnterpriseIdsHandler) run() {
+	data, err := db.GetEnterpriseIds(g.ctx)
+	if err != nil {
+		logrus.WithContext(g.ctx).Errorf("[GetEnterpriseIdsHandler] error GetEnterpriseIds, err:%+v", err)
+		util.HandlerPackErrorResp(g.resp, consts.ErrorInternal, consts.DefaultToast)
+		return
+	}
+	g.resp.Data = data
+}
+
+func (g GetEnterpriseIdsHandler) checkParam() error {
+	return nil
+}
+
+func newGetEnterpriseIdsHandler(ctx *gin.Context) *GetEnterpriseIdsHandler {
+	return &GetEnterpriseIdsHandler{
+		ctx:  ctx,
+		req:  http_model.NewGetEnterpriseIdsRequest(),
+		resp: http_model.NewGetEnterpriseIdsResponse(),
+	}
+}

handler/getWithdrawNum.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 WrapGetWithdrawNumsHandler(ctx *gin.Context) {
+	handler := newGetWithdrawNumsHandler(ctx)
+	BaseRun(handler)
+}
+
+type GetWithdrawNumsHandler struct {
+	ctx  *gin.Context
+	req  *http_model.GetWithdrawNumsRequest
+	resp *http_model.CommonResponse
+}
+
+func (g GetWithdrawNumsHandler) getContext() *gin.Context {
+	return g.ctx
+}
+
+func (g GetWithdrawNumsHandler) getResponse() interface{} {
+	return g.resp
+}
+
+func (g GetWithdrawNumsHandler) getRequest() interface{} {
+	return g.req
+}
+
+func (g GetWithdrawNumsHandler) run() {
+	data, err := db.GetWithdrawNums(g.ctx)
+	if err != nil {
+		logrus.WithContext(g.ctx).Errorf("[GetWithdrawNumsHandler] error GetWithdrawNums, err:%+v", err)
+		util.HandlerPackErrorResp(g.resp, consts.ErrorInternal, consts.DefaultToast)
+		return
+	}
+	g.resp.Data = data
+
+}
+
+func (g GetWithdrawNumsHandler) checkParam() error {
+	return nil
+}
+
+func newGetWithdrawNumsHandler(ctx *gin.Context) *GetWithdrawNumsHandler {
+	return &GetWithdrawNumsHandler{
+		ctx:  ctx,
+		req:  http_model.NewGetWithdrawNumsRequest(),
+		resp: http_model.NewGetWithdrawNumsResponse(),
+	}
+}

handler/invoiceRecords.go

@@ -0,0 +1,69 @@
+package handler
+
+import (
+	"errors"
+	"fmt"
+	"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/pack"
+	"youngee_m_api/util"
+)
+
+func WrapInvoiceRecordsHandler(ctx *gin.Context) {
+	handler := newInvoiceRecordsHandler(ctx)
+	BaseRun(handler)
+}
+
+type InvoiceRecordsHandler struct {
+	ctx  *gin.Context
+	req  *http_model.InvoiceRecordsRequest
+	resp *http_model.CommonResponse
+}
+
+func (i InvoiceRecordsHandler) getContext() *gin.Context {
+	return i.ctx
+}
+
+func (i InvoiceRecordsHandler) getResponse() interface{} {
+	return i.resp
+}
+
+func (i InvoiceRecordsHandler) getRequest() interface{} {
+	return i.req
+}
+
+func (i InvoiceRecordsHandler) run() {
+	condition := pack.HttpInvoiceRecordsRequestToCondition(i.req)
+	data, err := db.GetInvoiceRecords(i.ctx, i.req, condition)
+	if err != nil {
+		// 数据库查询失败，返回5001
+		logrus.Errorf("[InvoiceRecordsHandler] call GetInvoiceRecords err:%+v\n", err)
+		util.HandlerPackErrorResp(i.resp, consts.ErrorInternal, "")
+		logrus.Info("GetInvoiceRecords fail,req:%+v", i.req)
+		return
+	}
+	i.resp.Data = data
+}
+
+func (i InvoiceRecordsHandler) checkParam() error {
+	var errs []error
+	if i.req.PageNum < 0 || i.req.PageSize <= 0 {
+		errs = append(errs, errors.New("page param error"))
+	}
+	i.req.PageNum--
+	if len(errs) != 0 {
+		return fmt.Errorf("check param errs:%+v", errs)
+	}
+	return nil
+}
+
+func newInvoiceRecordsHandler(ctx *gin.Context) *InvoiceRecordsHandler {
+	return &InvoiceRecordsHandler{
+		ctx:  ctx,
+		req:  http_model.NewInvoiceRecordsRequest(),
+		resp: http_model.NewInvoiceRecordsResponse(),
+	}
+}

handler/link_number_info.go

@@ -0,0 +1,58 @@
+package handler
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+	log "github.com/sirupsen/logrus"
+	"youngee_m_api/consts"
+	"youngee_m_api/model/http_model"
+	"youngee_m_api/service"
+	"youngee_m_api/util"
+)
+
+func WrapGetLinkNumberInfoHandler(ctx *gin.Context) {
+	handler := newGetLinkNumberInfoHandler(ctx)
+	BaseRun(handler)
+}
+
+func newGetLinkNumberInfoHandler(ctx *gin.Context) *GetLinkNumberInfoHandler {
+	return &GetLinkNumberInfoHandler{
+		req:  http_model.NewGetLinkNumberInfoRequest(),
+		resp: http_model.NewGetLinkNumberInfoResponse(),
+		ctx:  ctx,
+	}
+}
+
+type GetLinkNumberInfoHandler struct {
+	req  *http_model.GetLinkNumberInfoRequest
+	resp *http_model.CommonResponse
+	ctx  *gin.Context
+}
+
+func (h *GetLinkNumberInfoHandler) getRequest() interface{} {
+	return h.req
+}
+func (h *GetLinkNumberInfoHandler) getContext() *gin.Context {
+	return h.ctx
+}
+func (h *GetLinkNumberInfoHandler) getResponse() interface{} {
+	return h.resp
+}
+
+func (h *GetLinkNumberInfoHandler) run() {
+	data := http_model.GetLinkNumberInfoRequest{}
+	data = *h.req
+	res, err := service.Number.GetLinkNumberInfo(h.ctx, data)
+	if err != nil {
+		logrus.Errorf("[GetLinkNumberInfoHandler] call GetLinkNumberInfo err:%+v\n", err)
+		util.HandlerPackErrorResp(h.resp, consts.ErrorInternal, "")
+		log.Info("GetLinkNumberInfo fail,req:%+v", h.req)
+		return
+	}
+	h.resp.Message = ""
+	h.resp.Data = res
+}
+
+func (h *GetLinkNumberInfoHandler) checkParam() error {
+	return nil
+}

handler/link_opinion.go

@@ -0,0 +1,89 @@
+package handler
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+	log "github.com/sirupsen/logrus"
+	"youngee_m_api/consts"
+	"youngee_m_api/model/http_model"
+	"youngee_m_api/service"
+	"youngee_m_api/util"
+)
+
+func WrapLinkOpinionHandler(ctx *gin.Context) {
+	handler := newLinkOpinionHandler(ctx)
+	BaseRun(handler)
+}
+
+func newLinkOpinionHandler(ctx *gin.Context) *LinkOpinionHandler {
+	return &LinkOpinionHandler{
+		req:  http_model.NewLinkOpinionRequest(),
+		resp: http_model.NewLinkOpinionResponse(),
+		ctx:  ctx,
+	}
+}
+
+type LinkOpinionHandler struct {
+	req  *http_model.LinkOpinionRequest
+	resp *http_model.CommonResponse
+	ctx  *gin.Context
+}
+
+func (h *LinkOpinionHandler) getRequest() interface{} {
+	return h.req
+}
+func (h *LinkOpinionHandler) getContext() *gin.Context {
+	return h.ctx
+}
+func (h *LinkOpinionHandler) getResponse() interface{} {
+	return h.resp
+}
+
+func (h *LinkOpinionHandler) run() {
+	data := http_model.LinkOpinionRequest{}
+	data = *h.req
+	res, err := service.Link.LinkOpinion(h.ctx, data)
+	if err != nil {
+		logrus.Errorf("[LinkOpinionHandler] call Create err:%+v\n", err)
+		util.HandlerPackErrorResp(h.resp, consts.ErrorInternal, "")
+		log.Info("CreateProject fail,req:%+v", h.req)
+		return
+	}
+	h.resp.Message = "提交脚本修改意见成功"
+	h.resp.Data = res
+	h.resp.Data = data
+}
+
+/***
+func (h *LinkOpinionHandler) run() {
+	data := http_model.LinkOpinionRequest{}
+	data = *h.req
+	isRefuse := data.IsRefuse
+	if isRefuse== 0 {
+		fmt.Println("Create in")
+		res, err := service.Project.Create(h.ctx, data)
+		if err != nil {
+			logrus.Errorf("[LinkOpinionHandler] call Create err:%+v\n", err)
+			util.HandlerPackErrorResp(h.resp, consts.ErrorInternal, "")
+			log.Info("CreateProject fail,req:%+v", h.req)
+			return
+		}
+		h.resp.Message = "成功添加修改意见"
+		h.resp.Data = res
+	} else {
+		res, err := service.Logistics.Update(h.ctx, data)
+		if err != nil {
+			logrus.Errorf("[LinkOpinionHandler] call Create err:%+v\n", err)
+			util.HandlerPackErrorResp(h.resp, consts.ErrorInternal, "")
+			log.Info("CreateProject fail,req:%+v", h.req)
+			return
+		}
+		h.resp.Message = "成功修改物流信息"
+		h.resp.Data = res
+	}
+
+}
+***/
+func (h *LinkOpinionHandler) checkParam() error {
+	return nil
+}

handler/logistics_create.go

@@ -0,0 +1,73 @@
+package handler
+
+import (
+	"fmt"
+	"youngee_m_api/consts"
+	"youngee_m_api/model/http_model"
+	"youngee_m_api/service"
+	"youngee_m_api/util"
+
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+	log "github.com/sirupsen/logrus"
+)
+
+func WrapCreateLogisticsHandler(ctx *gin.Context) {
+	handler := newCreateLogisticsHandler(ctx)
+	BaseRun(handler)
+}
+
+func newCreateLogisticsHandler(ctx *gin.Context) *CreateLogisticsHandler {
+	return &CreateLogisticsHandler{
+		req:  http_model.NewCreateLogisticsRequest(),
+		resp: http_model.NewCreateLogisticsResponse(),
+		ctx:  ctx,
+	}
+}
+
+type CreateLogisticsHandler struct {
+	req  *http_model.CreateLogisticsRequest
+	resp *http_model.CommonResponse
+	ctx  *gin.Context
+}
+
+func (h *CreateLogisticsHandler) getRequest() interface{} {
+	return h.req
+}
+func (h *CreateLogisticsHandler) getContext() *gin.Context {
+	return h.ctx
+}
+func (h *CreateLogisticsHandler) getResponse() interface{} {
+	return h.resp
+}
+func (h *CreateLogisticsHandler) run() {
+	data := http_model.CreateLogisticsRequest{}
+	data = *h.req
+	isUpdate := data.IsUpdate
+	if isUpdate == 0 {
+		fmt.Println("Create in")
+		res, err := service.Logistics.Create(h.ctx, data)
+		if err != nil {
+			logrus.Errorf("[CreateLogisticsHandler] call Create err:%+v\n", err)
+			util.HandlerPackErrorResp(h.resp, consts.ErrorInternal, "")
+			log.Info("CreateProject fail,req:%+v", h.req)
+			return
+		}
+		h.resp.Message = "成功添加物流信息"
+		h.resp.Data = res
+	} else {
+		res, err := service.Logistics.Update(h.ctx, data)
+		if err != nil {
+			logrus.Errorf("[CreateLogisticsHandler] call Create err:%+v\n", err)
+			util.HandlerPackErrorResp(h.resp, consts.ErrorInternal, "")
+			log.Info("CreateProject fail,req:%+v", h.req)
+			return
+		}
+		h.resp.Message = "成功修改物流信息"
+		h.resp.Data = res
+	}
+
+}
+func (h *CreateLogisticsHandler) checkParam() error {
+	return nil
+}

handler/operate/count_num_of_defaults.go

@@ -43,7 +43,7 @@ func (c CountNumOfDefaults) getRequest() interface{} {
 func (c CountNumOfDefaults) run() {
 	err, data := db.CountDefaultNum(c.ctx)
 	if err != nil {
-		logrus.WithContext(c.ctx).Errorf("[caseCloseDefaultHandler] error AutoCaseCloseDefault, err:%+v", err)
+		logrus.WithContext(c.ctx).Errorf("[CountNumOfDefaults] error CountDefaultNum, err:%+v", err)
 		util.HandlerPackErrorResp(c.resp, consts.ErrorInternal, consts.DefaultToast)
 		return
 	}

handler/product_findAll.go

@@ -11,12 +11,12 @@ import (
 	"youngee_m_api/util"
 )
 
-func WrapFindAllProductHandler(ctx *gin.Context) {
-	handler := newFindAllProductHandler(ctx)
+func WrapFindEnterpriseAllProductHandler(ctx *gin.Context) {
+	handler := newFindEnterpriseAllProductHandler(ctx)
 	BaseRun(handler)
 }
 
-func newFindAllProductHandler(ctx *gin.Context) *FindAllProductHandler {
+func newFindEnterpriseAllProductHandler(ctx *gin.Context) *FindAllProductHandler {
 	return &FindAllProductHandler{
 		req:  http_model.NewFindAllProductRequest(),
 		resp: http_model.NewFindAllProductResponse(),

handler/product_list.go

@@ -3,7 +3,7 @@ package handler
 import (
 	"errors"
 	"fmt"
-	"github.com/cstockton/go-conv"
+	"github.com/caixw/lib.go/conv"
 	"time"
 	"youngee_m_api/consts"
 	"youngee_m_api/model/http_model"

handler/project_change_taskStatus.go

@@ -0,0 +1,70 @@
+package handler
+
+import (
+	"github.com/sirupsen/logrus"
+	"youngee_m_api/consts"
+	"youngee_m_api/model/http_model"
+	"youngee_m_api/service"
+	"youngee_m_api/util"
+
+	"github.com/gin-gonic/gin"
+)
+
+// WrapProjectChangeTaskStatusHandler
+// @BasePath /youngee/m/
+// SendCode godoc
+// @Summary ProjectChangeTaskStatus 更改项目任务状态
+// @Schemes
+// @Description  更改项目任务的状态
+// @Accept json
+// @Produce json
+// @Param req body http_model.ProjectChangeTaskStatusRequest true "更改项目任务状态的请求结构体"
+// @Success 200 {object} http_model.CommonResponse{} "更改项目任务状态相应结构体"
+// @Router /product/changeTaskStatus [post]
+func WrapProjectChangeTaskStatusHandler(ctx *gin.Context) {
+	handler := newProjectChangeTaskStatusHandler(ctx)
+	BaseRun(handler)
+}
+
+func newProjectChangeTaskStatusHandler(ctx *gin.Context) *ProjectChangeTaskStatusHandler {
+	return &ProjectChangeTaskStatusHandler{
+		req:  http_model.NewProjectChangeTaskStatusRequst(),
+		resp: http_model.NewProjectChangeTaskStatusResponse(),
+		ctx:  ctx,
+	}
+}
+
+type ProjectChangeTaskStatusHandler struct {
+	req  *http_model.ProjectChangeTaskStatusRequest
+	resp *http_model.CommonResponse
+	ctx  *gin.Context
+}
+
+func (p *ProjectChangeTaskStatusHandler) getContext() *gin.Context {
+	return p.ctx
+}
+
+func (p *ProjectChangeTaskStatusHandler) getResponse() interface{} {
+	return p.resp
+}
+
+func (p *ProjectChangeTaskStatusHandler) getRequest() interface{} {
+	return p.req
+}
+
+func (p *ProjectChangeTaskStatusHandler) run() {
+	data := http_model.ProjectChangeTaskStatusRequest{}
+	data = *p.req
+	err := service.Project.ChangeTaskStatus(p.ctx, data)
+	if err != nil {
+		logrus.Errorf("[ChangeTaskStatusHandler] call Create err:%+v\n", err)
+		util.HandlerPackErrorResp(p.resp, consts.ErrorInternal, "")
+		logrus.Info("ChangeTaskStatus fail,req:%+v", p.req)
+		return
+	}
+	p.resp.Message = "任务状态更换成功"
+}
+
+func (p *ProjectChangeTaskStatusHandler) checkParam() error {
+	return nil
+}

handler/project_update.go

@@ -1,6 +1,7 @@
 package handler
 
 import (
+	"github.com/caixw/lib.go/conv"
 	"github.com/gin-gonic/gin"
 	"github.com/sirupsen/logrus"
 	"youngee_m_api/consts"
@@ -40,16 +41,17 @@ func (h *UpdateProjectHandler) getResponse() interface{} {
 func (h *UpdateProjectHandler) run() {
 	data := http_model.UpdateProjectRequest{}
 	data = *h.req
-	res, err := service.Project.Update(h.ctx, data, data.EnterpriseID)
+	res, err := service.Project.Update(h.ctx, data, conv.MustInt64(data.EnterpriseID, 0))
 	if err != nil {
 		logrus.Errorf("[UpdateProjectHandler] call Create err:%+v\n", err)
 		util.HandlerPackErrorResp(h.resp, consts.ErrorInternal, "")
 		logrus.Info("UpdateProject fail,req:%+v", h.req)
 		return
 	}
-	h.resp.Message = "项目更新成功"
+	//h.resp.Message = "项目更新成功"
 	h.resp.Data = res
 }
+
 func (h *UpdateProjectHandler) checkParam() error {
 	return nil
 }

handler/review_number_info.go

@@ -0,0 +1,58 @@
+package handler
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+	log "github.com/sirupsen/logrus"
+	"youngee_m_api/consts"
+	"youngee_m_api/model/http_model"
+	"youngee_m_api/service"
+	"youngee_m_api/util"
+)
+
+func WrapGetReviewNumberInfoHandler(ctx *gin.Context) {
+	handler := newGetReviewNumberInfoHandler(ctx)
+	BaseRun(handler)
+}
+
+func newGetReviewNumberInfoHandler(ctx *gin.Context) *GetReviewNumberInfoHandler {
+	return &GetReviewNumberInfoHandler{
+		req:  http_model.NewGetReviewNumberInfoRequest(),
+		resp: http_model.NewGetReviewNumberInfoResponse(),
+		ctx:  ctx,
+	}
+}
+
+type GetReviewNumberInfoHandler struct {
+	req  *http_model.GetReviewNumberInfoRequest
+	resp *http_model.CommonResponse
+	ctx  *gin.Context
+}
+
+func (h *GetReviewNumberInfoHandler) getRequest() interface{} {
+	return h.req
+}
+func (h *GetReviewNumberInfoHandler) getContext() *gin.Context {
+	return h.ctx
+}
+func (h *GetReviewNumberInfoHandler) getResponse() interface{} {
+	return h.resp
+}
+
+func (h *GetReviewNumberInfoHandler) run() {
+	data := http_model.GetReviewNumberInfoRequest{}
+	data = *h.req
+	res, err := service.Number.GetReviewNumberInfo(h.ctx, data)
+	if err != nil {
+		logrus.Errorf("[GetReviewNumberInfoHandler] call GetReviewNumberInfo err:%+v\n", err)
+		util.HandlerPackErrorResp(h.resp, consts.ErrorInternal, "")
+		log.Info("GetReviewNumberInfo fail,req:%+v", h.req)
+		return
+	}
+	h.resp.Message = ""
+	h.resp.Data = res
+}
+
+func (h *GetReviewNumberInfoHandler) checkParam() error {
+	return nil
+}

handler/script_opinion.go

@@ -0,0 +1,89 @@
+package handler
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+	log "github.com/sirupsen/logrus"
+	"youngee_m_api/consts"
+	"youngee_m_api/model/http_model"
+	"youngee_m_api/service"
+	"youngee_m_api/util"
+)
+
+func WrapScriptOpinionHandler(ctx *gin.Context) {
+	handler := newScriptOpinionHandler(ctx)
+	BaseRun(handler)
+}
+
+func newScriptOpinionHandler(ctx *gin.Context) *ScriptOpinionHandler {
+	return &ScriptOpinionHandler{
+		req:  http_model.NewScriptOpinionRequest(),
+		resp: http_model.NewScriptOpinionResponse(),
+		ctx:  ctx,
+	}
+}
+
+type ScriptOpinionHandler struct {
+	req  *http_model.ScriptOpinionRequest
+	resp *http_model.CommonResponse
+	ctx  *gin.Context
+}
+
+func (h *ScriptOpinionHandler) getRequest() interface{} {
+	return h.req
+}
+func (h *ScriptOpinionHandler) getContext() *gin.Context {
+	return h.ctx
+}
+func (h *ScriptOpinionHandler) getResponse() interface{} {
+	return h.resp
+}
+
+func (h *ScriptOpinionHandler) run() {
+	data := http_model.ScriptOpinionRequest{}
+	data = *h.req
+	res, err := service.Script.ScriptOpinion(h.ctx, data)
+	if err != nil {
+		logrus.Errorf("[ScriptOpinionHandler] call Create err:%+v\n", err)
+		util.HandlerPackErrorResp(h.resp, consts.ErrorInternal, "")
+		log.Info("CreateProject fail,req:%+v", h.req)
+		return
+	}
+	h.resp.Message = "提交脚本修改意见成功"
+	h.resp.Data = res
+	h.resp.Data = data
+}
+
+/***
+func (h *ScriptOpinionHandler) run() {
+	data := http_model.ScriptOpinionRequest{}
+	data = *h.req
+	isRefuse := data.IsRefuse
+	if isRefuse== 0 {
+		fmt.Println("Create in")
+		res, err := service.Project.Create(h.ctx, data)
+		if err != nil {
+			logrus.Errorf("[ScriptOpinionHandler] call Create err:%+v\n", err)
+			util.HandlerPackErrorResp(h.resp, consts.ErrorInternal, "")
+			log.Info("CreateProject fail,req:%+v", h.req)
+			return
+		}
+		h.resp.Message = "成功添加修改意见"
+		h.resp.Data = res
+	} else {
+		res, err := service.Logistics.Update(h.ctx, data)
+		if err != nil {
+			logrus.Errorf("[ScriptOpinionHandler] call Create err:%+v\n", err)
+			util.HandlerPackErrorResp(h.resp, consts.ErrorInternal, "")
+			log.Info("CreateProject fail,req:%+v", h.req)
+			return
+		}
+		h.resp.Message = "成功修改物流信息"
+		h.resp.Data = res
+	}
+
+}
+***/
+func (h *ScriptOpinionHandler) checkParam() error {
+	return nil
+}

handler/sign_for_receipt.go

@@ -0,0 +1,59 @@
+package handler
+
+import (
+	"github.com/sirupsen/logrus"
+	"youngee_m_api/consts"
+	"youngee_m_api/model/http_model"
+	"youngee_m_api/service"
+	"youngee_m_api/util"
+
+	"github.com/gin-gonic/gin"
+)
+
+func WrapSignForReceiptHandler(ctx *gin.Context) {
+	handler := newSignForReceiptHandler(ctx)
+	BaseRun(handler)
+}
+
+func newSignForReceiptHandler(ctx *gin.Context) *SignForReceiptHandler {
+	return &SignForReceiptHandler{
+		req:  http_model.NewSignForReceiptRequst(),
+		resp: http_model.NewSignForReceiptResponse(),
+		ctx:  ctx,
+	}
+}
+
+type SignForReceiptHandler struct {
+	req  *http_model.SignForReceiptRequest
+	resp *http_model.CommonResponse
+	ctx  *gin.Context
+}
+
+func (p *SignForReceiptHandler) getContext() *gin.Context {
+	return p.ctx
+}
+
+func (p *SignForReceiptHandler) getResponse() interface{} {
+	return p.resp
+}
+
+func (p *SignForReceiptHandler) getRequest() interface{} {
+	return p.req
+}
+
+func (p *SignForReceiptHandler) run() {
+	data := http_model.SignForReceiptRequest{}
+	data = *p.req
+	err := service.Logistics.SignForReceipt(p.ctx, data)
+	if err != nil {
+		logrus.Errorf("[ChangeLogisticsStatusHandler] call Create err:%+v\n", err)
+		util.HandlerPackErrorResp(p.resp, consts.ErrorInternal, "")
+		logrus.Info("ChangeLogisticsStatus fail,req:%+v", p.req)
+		return
+	}
+	p.resp.Message = "物流状态更换成功"
+}
+
+func (p *SignForReceiptHandler) checkParam() error {
+	return nil
+}

handler/sketch_info.go

@@ -0,0 +1,58 @@
+package handler
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+	log "github.com/sirupsen/logrus"
+	"youngee_m_api/consts"
+	"youngee_m_api/model/http_model"
+	"youngee_m_api/service"
+	"youngee_m_api/util"
+)
+
+// WrapGetSketchInfoHandler
+
+func WrapGetSketchInfoHandler(ctx *gin.Context) {
+	handler := newGetSketchInfoHandler(ctx)
+	BaseRun(handler)
+}
+
+func newGetSketchInfoHandler(ctx *gin.Context) *GetSketchInfoHandler {
+	return &GetSketchInfoHandler{
+		req:  http_model.NewGetSketchInfoRequest(),
+		resp: http_model.NewGetSketchInfoResponse(),
+		ctx:  ctx,
+	}
+}
+
+type GetSketchInfoHandler struct {
+	req  *http_model.GetSketchInfoRequest
+	resp *http_model.CommonResponse
+	ctx  *gin.Context
+}
+
+func (h *GetSketchInfoHandler) getRequest() interface{} {
+	return h.req
+}
+func (h *GetSketchInfoHandler) getContext() *gin.Context {
+	return h.ctx
+}
+func (h *GetSketchInfoHandler) getResponse() interface{} {
+	return h.resp
+}
+func (h *GetSketchInfoHandler) run() {
+	data := *&http_model.GetSketchInfoRequest{}
+	data = *h.req
+	res, err := service.Sketch.GetSketchInfo(h.ctx, data)
+	if err != nil {
+		// 数据库查询失败，返回5001
+		logrus.Errorf("[GetSketchInfoHandler] call GetByID err:%+v\n", err)
+		util.HandlerPackErrorResp(h.resp, consts.ErrorInternal, "")
+		log.Info("GetProduct fail,req:%+v", h.req)
+		return
+	}
+	h.resp.Data = res
+}
+func (h *GetSketchInfoHandler) checkParam() error {
+	return nil
+}

handler/sketch_opinion.go

@@ -0,0 +1,89 @@
+package handler
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+	log "github.com/sirupsen/logrus"
+	"youngee_m_api/consts"
+	"youngee_m_api/model/http_model"
+	"youngee_m_api/service"
+	"youngee_m_api/util"
+)
+
+func WrapSketchOpinionHandler(ctx *gin.Context) {
+	handler := newSketchOpinionHandler(ctx)
+	BaseRun(handler)
+}
+
+func newSketchOpinionHandler(ctx *gin.Context) *SketchOpinionHandler {
+	return &SketchOpinionHandler{
+		req:  http_model.NewSketchOpinionRequest(),
+		resp: http_model.NewSketchOpinionResponse(),
+		ctx:  ctx,
+	}
+}
+
+type SketchOpinionHandler struct {
+	req  *http_model.SketchOpinionRequest
+	resp *http_model.CommonResponse
+	ctx  *gin.Context
+}
+
+func (h *SketchOpinionHandler) getRequest() interface{} {
+	return h.req
+}
+func (h *SketchOpinionHandler) getContext() *gin.Context {
+	return h.ctx
+}
+func (h *SketchOpinionHandler) getResponse() interface{} {
+	return h.resp
+}
+
+func (h *SketchOpinionHandler) run() {
+	data := http_model.SketchOpinionRequest{}
+	data = *h.req
+	res, err := service.Sketch.SketchOption(h.ctx, data)
+	if err != nil {
+		logrus.Errorf("[SketchOpinionHandler] call Create err:%+v\n", err)
+		util.HandlerPackErrorResp(h.resp, consts.ErrorInternal, "")
+		log.Info("CreateProject fail,req:%+v", h.req)
+		return
+	}
+	h.resp.Message = "提交初稿修改意见成功"
+	h.resp.Data = res
+	h.resp.Data = data
+}
+
+/***
+func (h *SketchOpinionHandler) run() {
+	data := http_model.SketchOpinionRequest{}
+	data = *h.req
+	isRefuse := data.IsRefuse
+	if isRefuse== 0 {
+		fmt.Println("Create in")
+		res, err := service.Project.Create(h.ctx, data)
+		if err != nil {
+			logrus.Errorf("[SketchOpinionHandler] call Create err:%+v\n", err)
+			util.HandlerPackErrorResp(h.resp, consts.ErrorInternal, "")
+			log.Info("CreateProject fail,req:%+v", h.req)
+			return
+		}
+		h.resp.Message = "成功添加修改意见"
+		h.resp.Data = res
+	} else {
+		res, err := service.Logistics.Update(h.ctx, data)
+		if err != nil {
+			logrus.Errorf("[SketchOpinionHandler] call Create err:%+v\n", err)
+			util.HandlerPackErrorResp(h.resp, consts.ErrorInternal, "")
+			log.Info("CreateProject fail,req:%+v", h.req)
+			return
+		}
+		h.resp.Message = "成功修改物流信息"
+		h.resp.Data = res
+	}
+
+}
+***/
+func (h *SketchOpinionHandler) checkParam() error {
+	return nil
+}

handler/sketch_photo.go

@@ -0,0 +1,58 @@
+package handler
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+	log "github.com/sirupsen/logrus"
+	"youngee_m_api/consts"
+	"youngee_m_api/model/http_model"
+	"youngee_m_api/service"
+	"youngee_m_api/util"
+)
+
+// WrapFindSketchPhotoHandler
+
+func WrapFindSketchPhotoHandler(ctx *gin.Context) {
+	handler := newFindSketchPhotoHandler(ctx)
+	BaseRun(handler)
+}
+
+func newFindSketchPhotoHandler(ctx *gin.Context) *FindSketchPhotoHandler {
+	return &FindSketchPhotoHandler{
+		req:  http_model.NewFindSketchPhotoRequest(),
+		resp: http_model.NewFindSketchPhotoResponse(),
+		ctx:  ctx,
+	}
+}
+
+type FindSketchPhotoHandler struct {
+	req  *http_model.FindSketchPhotoRequest
+	resp *http_model.CommonResponse
+	ctx  *gin.Context
+}
+
+func (h *FindSketchPhotoHandler) getRequest() interface{} {
+	return h.req
+}
+func (h *FindSketchPhotoHandler) getContext() *gin.Context {
+	return h.ctx
+}
+func (h *FindSketchPhotoHandler) getResponse() interface{} {
+	return h.resp
+}
+func (h *FindSketchPhotoHandler) run() {
+	data := *&http_model.FindSketchPhotoRequest{}
+	data = *h.req
+	res, err := service.Sketch.FindPhoto(h.ctx, data)
+	if err != nil {
+		// 数据库查询失败，返回5001
+		logrus.Errorf("[FindSketchPhotoHandler] call FindByID err:%+v\n", err)
+		util.HandlerPackErrorResp(h.resp, consts.ErrorInternal, "")
+		log.Info("FindProduct fail,req:%+v", h.req)
+		return
+	}
+	h.resp.Data = res
+}
+func (h *FindSketchPhotoHandler) checkParam() error {
+	return nil
+}

handler/task_data_list.go

@@ -0,0 +1,77 @@
+package handler
+
+import (
+	"errors"
+	"fmt"
+	"github.com/caixw/lib.go/conv"
+	"youngee_m_api/consts"
+	"youngee_m_api/model/http_model"
+	"youngee_m_api/pack"
+	"youngee_m_api/service"
+	"youngee_m_api/util"
+
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+)
+
+func WrapTaskDataListHandler(ctx *gin.Context) {
+	handler := newTaskDataListHandler(ctx)
+	BaseRun(handler)
+}
+
+func newTaskDataListHandler(ctx *gin.Context) *TaskDataListHandler {
+	return &TaskDataListHandler{
+		req:  http_model.NewTaskDataListRequest(),
+		resp: http_model.NewTaskDataListResponse(),
+		ctx:  ctx,
+	}
+}
+
+type TaskDataListHandler struct {
+	req  *http_model.TaskDataListRequest
+	resp *http_model.CommonResponse
+	ctx  *gin.Context
+}
+
+func (h *TaskDataListHandler) getRequest() interface{} {
+	return h.req
+}
+func (h *TaskDataListHandler) getContext() *gin.Context {
+	return h.ctx
+}
+func (h *TaskDataListHandler) getResponse() interface{} {
+	return h.resp
+}
+func (h *TaskDataListHandler) run() {
+	conditions := pack.HttpTaskDataListRequestToCondition(h.req)
+	data, err := service.Project.GetTaskDataList(h.ctx, h.req.ProjectId, h.req.PageSize, h.req.PageNum, conditions)
+	if err != nil {
+		logrus.WithContext(h.ctx).Errorf("[TaskLogisticsListHandler] error GetProjectTaskList, err:%+v", err)
+		util.HandlerPackErrorResp(h.resp, consts.ErrorInternal, consts.DefaultToast)
+		return
+	}
+	h.resp.Data = data
+}
+func (h *TaskDataListHandler) checkParam() error {
+	var errs []error
+	if h.req.PageNum < 0 || h.req.PageSize <= 0 {
+		errs = append(errs, errors.New("page param error"))
+	}
+	h.req.PageNum--
+	h.req.ProjectId = util.IsNull(h.req.ProjectId)
+	if _, err := conv.Int64(h.req.ProjectId); err != nil {
+		errs = append(errs, err)
+	}
+	// h.req.StrategyId = util.IsNull(h.req.StrategyId)
+	// if _, err := conv.Int64(h.req.StrategyId); err != nil {
+	// 	errs = append(errs, err)
+	// }
+	h.req.DataStatus = util.IsNull(h.req.DataStatus)
+	if _, err := conv.Int64(h.req.DataStatus); err != nil {
+		errs = append(errs, err)
+	}
+	if len(errs) != 0 {
+		return fmt.Errorf("check param errs:%+v", errs)
+	}
+	return nil
+}

handler/task_default_data_list.go

@@ -0,0 +1,73 @@
+package handler
+
+import (
+	"errors"
+	"fmt"
+	"github.com/caixw/lib.go/conv"
+	"youngee_m_api/consts"
+	"youngee_m_api/model/http_model"
+	"youngee_m_api/pack"
+	"youngee_m_api/service"
+	"youngee_m_api/util"
+
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+)
+
+func WrapTaskDefaultDataListHandler(ctx *gin.Context) {
+	handler := newTaskDefaultDataListHandler(ctx)
+	BaseRun(handler)
+}
+
+func newTaskDefaultDataListHandler(ctx *gin.Context) *TaskDefaultDataListHandler {
+	return &TaskDefaultDataListHandler{
+		req:  http_model.NewTaskDefaultDataListRequest(),
+		resp: http_model.NewTaskDefaultDataListResponse(),
+		ctx:  ctx,
+	}
+}
+
+type TaskDefaultDataListHandler struct {
+	req  *http_model.TaskDefaultDataListRequest
+	resp *http_model.CommonResponse
+	ctx  *gin.Context
+}
+
+func (h *TaskDefaultDataListHandler) getRequest() interface{} {
+	return h.req
+}
+func (h *TaskDefaultDataListHandler) getContext() *gin.Context {
+	return h.ctx
+}
+func (h *TaskDefaultDataListHandler) getResponse() interface{} {
+	return h.resp
+}
+func (h *TaskDefaultDataListHandler) run() {
+	conditions := pack.HttpTaskDefaultDataListRequestToCondition(h.req)
+	data, err := service.Default.GetTaskDefaultDataList(h.ctx, h.req.ProjectId, h.req.PageSize, h.req.PageNum, conditions)
+	if err != nil {
+		logrus.WithContext(h.ctx).Errorf("[TaskLogisticsListHandler] error GetProjectTaskList, err:%+v", err)
+		util.HandlerPackErrorResp(h.resp, consts.ErrorInternal, consts.DefaultToast)
+		return
+	}
+	h.resp.Data = data
+}
+func (h *TaskDefaultDataListHandler) checkParam() error {
+	var errs []error
+	if h.req.PageNum < 0 || h.req.PageSize <= 0 {
+		errs = append(errs, errors.New("page param error"))
+	}
+	h.req.PageNum--
+	h.req.ProjectId = util.IsNull(h.req.ProjectId)
+	if _, err := conv.Int64(h.req.ProjectId); err != nil {
+		errs = append(errs, err)
+	}
+	h.req.DefaultStatus = util.IsNull(h.req.DefaultStatus)
+	if _, err := conv.Int64(h.req.DefaultStatus); err != nil {
+		errs = append(errs, err)
+	}
+	if len(errs) != 0 {
+		return fmt.Errorf("check param errs:%+v", errs)
+	}
+	return nil
+}

handler/task_default_review_list.go

@@ -0,0 +1,73 @@
+package handler
+
+import (
+	"errors"
+	"fmt"
+	"github.com/caixw/lib.go/conv"
+	"youngee_m_api/consts"
+	"youngee_m_api/model/http_model"
+	"youngee_m_api/pack"
+	"youngee_m_api/service"
+	"youngee_m_api/util"
+
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+)
+
+func WrapTaskDefaultReviewListHandler(ctx *gin.Context) {
+	handler := newTaskDefaultReviewListHandler(ctx)
+	BaseRun(handler)
+}
+
+func newTaskDefaultReviewListHandler(ctx *gin.Context) *TaskDefaultReviewListHandler {
+	return &TaskDefaultReviewListHandler{
+		req:  http_model.NewTaskDefaultReviewListRequest(),
+		resp: http_model.NewTaskDefaultReviewListResponse(),
+		ctx:  ctx,
+	}
+}
+
+type TaskDefaultReviewListHandler struct {
+	req  *http_model.TaskDefaultReviewListRequest
+	resp *http_model.CommonResponse
+	ctx  *gin.Context
+}
+
+func (h *TaskDefaultReviewListHandler) getRequest() interface{} {
+	return h.req
+}
+func (h *TaskDefaultReviewListHandler) getContext() *gin.Context {
+	return h.ctx
+}
+func (h *TaskDefaultReviewListHandler) getResponse() interface{} {
+	return h.resp
+}
+func (h *TaskDefaultReviewListHandler) run() {
+	conditions := pack.HttpTaskDefaultReviewListRequestToCondition(h.req)
+	data, err := service.Default.GetTaskDefaultReviewList(h.ctx, h.req.ProjectId, h.req.PageSize, h.req.PageNum, conditions)
+	if err != nil {
+		logrus.WithContext(h.ctx).Errorf("[TaskLogisticsListHandler] error GetProjectTaskList, err:%+v", err)
+		util.HandlerPackErrorResp(h.resp, consts.ErrorInternal, consts.DefaultToast)
+		return
+	}
+	h.resp.Data = data
+}
+func (h *TaskDefaultReviewListHandler) checkParam() error {
+	var errs []error
+	if h.req.PageNum < 0 || h.req.PageSize <= 0 {
+		errs = append(errs, errors.New("page param error"))
+	}
+	h.req.PageNum--
+	h.req.ProjectId = util.IsNull(h.req.ProjectId)
+	if _, err := conv.Int64(h.req.ProjectId); err != nil {
+		errs = append(errs, err)
+	}
+	h.req.DefaultStatus = util.IsNull(h.req.DefaultStatus)
+	if _, err := conv.Int64(h.req.DefaultStatus); err != nil {
+		errs = append(errs, err)
+	}
+	if len(errs) != 0 {
+		return fmt.Errorf("check param errs:%+v", errs)
+	}
+	return nil
+}

handler/task_finish_list.go

@@ -0,0 +1,69 @@
+package handler
+
+import (
+	"errors"
+	"fmt"
+	"github.com/caixw/lib.go/conv"
+	"youngee_m_api/consts"
+	"youngee_m_api/model/http_model"
+	"youngee_m_api/pack"
+	"youngee_m_api/service"
+	"youngee_m_api/util"
+
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+)
+
+func WrapTaskFinishListHandler(ctx *gin.Context) {
+	handler := newTaskFinishListHandler(ctx)
+	BaseRun(handler)
+}
+
+func newTaskFinishListHandler(ctx *gin.Context) *TaskFinishListHandler {
+	return &TaskFinishListHandler{
+		req:  http_model.NewTaskFinishListRequest(),
+		resp: http_model.NewTaskFinishListResponse(),
+		ctx:  ctx,
+	}
+}
+
+type TaskFinishListHandler struct {
+	req  *http_model.TaskFinishListRequest
+	resp *http_model.CommonResponse
+	ctx  *gin.Context
+}
+
+func (h *TaskFinishListHandler) getRequest() interface{} {
+	return h.req
+}
+func (h *TaskFinishListHandler) getContext() *gin.Context {
+	return h.ctx
+}
+func (h *TaskFinishListHandler) getResponse() interface{} {
+	return h.resp
+}
+func (h *TaskFinishListHandler) run() {
+	conditions := pack.HttpTaskFinishListRequestToCondition(h.req)
+	data, err := service.Project.GetTaskFinishList(h.ctx, h.req.ProjectId, h.req.PageSize, h.req.PageNum, conditions)
+	if err != nil {
+		logrus.WithContext(h.ctx).Errorf("[TaskLogisticsListHandler] error GetProjectTaskList, err:%+v", err)
+		util.HandlerPackErrorResp(h.resp, consts.ErrorInternal, consts.DefaultToast)
+		return
+	}
+	h.resp.Data = data
+}
+func (h *TaskFinishListHandler) checkParam() error {
+	var errs []error
+	if h.req.PageNum < 0 || h.req.PageSize <= 0 {
+		errs = append(errs, errors.New("page param error"))
+	}
+	h.req.PageNum--
+	h.req.ProjectId = util.IsNull(h.req.ProjectId)
+	if _, err := conv.Int64(h.req.ProjectId); err != nil {
+		errs = append(errs, err)
+	}
+	if len(errs) != 0 {
+		return fmt.Errorf("check param errs:%+v", errs)
+	}
+	return nil
+}

handler/task_link_list.go

@@ -0,0 +1,77 @@
+package handler
+
+import (
+	"errors"
+	"fmt"
+	"github.com/caixw/lib.go/conv"
+	"youngee_m_api/consts"
+	"youngee_m_api/model/http_model"
+	"youngee_m_api/pack"
+	"youngee_m_api/service"
+	"youngee_m_api/util"
+
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+)
+
+func WrapTaskLinkListHandler(ctx *gin.Context) {
+	handler := newTaskLinkListHandler(ctx)
+	BaseRun(handler)
+}
+
+func newTaskLinkListHandler(ctx *gin.Context) *TaskLinkListHandler {
+	return &TaskLinkListHandler{
+		req:  http_model.NewTaskLinkListRequest(),
+		resp: http_model.NewTaskLinkListResponse(),
+		ctx:  ctx,
+	}
+}
+
+type TaskLinkListHandler struct {
+	req  *http_model.TaskLinkListRequest
+	resp *http_model.CommonResponse
+	ctx  *gin.Context
+}
+
+func (h *TaskLinkListHandler) getRequest() interface{} {
+	return h.req
+}
+func (h *TaskLinkListHandler) getContext() *gin.Context {
+	return h.ctx
+}
+func (h *TaskLinkListHandler) getResponse() interface{} {
+	return h.resp
+}
+func (h *TaskLinkListHandler) run() {
+	conditions := pack.HttpTaskLinkListRequestToCondition(h.req)
+	data, err := service.Project.GetTaskLinkList(h.ctx, h.req.ProjectId, h.req.PageSize, h.req.PageNum, conditions)
+	if err != nil {
+		logrus.WithContext(h.ctx).Errorf("[TaskLogisticsListHandler] error GetProjectTaskList, err:%+v", err)
+		util.HandlerPackErrorResp(h.resp, consts.ErrorInternal, consts.DefaultToast)
+		return
+	}
+	h.resp.Data = data
+}
+func (h *TaskLinkListHandler) checkParam() error {
+	var errs []error
+	if h.req.PageNum < 0 || h.req.PageSize <= 0 {
+		errs = append(errs, errors.New("page param error"))
+	}
+	h.req.PageNum--
+	h.req.ProjectId = util.IsNull(h.req.ProjectId)
+	if _, err := conv.Int64(h.req.ProjectId); err != nil {
+		errs = append(errs, err)
+	}
+	// h.req.StrategyId = util.IsNull(h.req.StrategyId)
+	// if _, err := conv.Int64(h.req.StrategyId); err != nil {
+	// 	errs = append(errs, err)
+	// }
+	h.req.LinkStatus = util.IsNull(h.req.LinkStatus)
+	if _, err := conv.Int64(h.req.LinkStatus); err != nil {
+		errs = append(errs, err)
+	}
+	if len(errs) != 0 {
+		return fmt.Errorf("check param errs:%+v", errs)
+	}
+	return nil
+}

handler/task_logistics_list.go

@@ -0,0 +1,76 @@
+package handler
+
+import (
+	"errors"
+	"fmt"
+	"youngee_m_api/consts"
+	"youngee_m_api/model/http_model"
+	"youngee_m_api/pack"
+	"youngee_m_api/service"
+	"youngee_m_api/util"
+
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+)
+
+func WrapTaskLogisticsListHandler(ctx *gin.Context) {
+	handler := newTaskLogisticsListHandler(ctx)
+	BaseRun(handler)
+}
+
+func newTaskLogisticsListHandler(ctx *gin.Context) *TaskLogisticsListHandler {
+	return &TaskLogisticsListHandler{
+		req:  http_model.NewTaskLogisticsListRequest(),
+		resp: http_model.NewTaskLogisticsListResponse(),
+		ctx:  ctx,
+	}
+}
+
+type TaskLogisticsListHandler struct {
+	req  *http_model.TaskLogisticsListRequest
+	resp *http_model.CommonResponse
+	ctx  *gin.Context
+}
+
+func (h *TaskLogisticsListHandler) getRequest() interface{} {
+	return h.req
+}
+func (h *TaskLogisticsListHandler) getContext() *gin.Context {
+	return h.ctx
+}
+func (h *TaskLogisticsListHandler) getResponse() interface{} {
+	return h.resp
+}
+func (h *TaskLogisticsListHandler) run() {
+	conditions := pack.HttpTaskLogisticsListRequestToCondition(h.req)
+	data, err := service.Project.GetTaskLogisticsList(h.ctx, h.req.ProjectId, h.req.PageSize, h.req.PageNum, conditions)
+	if err != nil {
+		logrus.WithContext(h.ctx).Errorf("[TaskLogisticsListHandler] error GetProjectTaskList, err:%+v", err)
+		util.HandlerPackErrorResp(h.resp, consts.ErrorInternal, consts.DefaultToast)
+		return
+	}
+	h.resp.Data = data
+}
+func (h *TaskLogisticsListHandler) checkParam() error {
+	var errs []error
+	if h.req.PageNum < 0 || h.req.PageSize <= 0 {
+		errs = append(errs, errors.New("page param error"))
+	}
+	h.req.PageNum--
+	//h.req.ProjectId = util.IsNull(h.req.ProjectId)
+	//if _, err := conv.Int64(h.req.ProjectId); err != nil {
+	//	errs = append(errs, err)
+	//}
+	//h.req.StrategyId = util.IsNull(h.req.StrategyId)
+	//if _, err := conv.Int64(h.req.StrategyId); err != nil {
+	//	errs = append(errs, err)
+	//}
+	//h.req.LogisticsStatus = util.IsNull(h.req.LogisticsStatus)
+	//if _, err := conv.Int64(h.req.LogisticsStatus); err != nil {
+	//	errs = append(errs, err)
+	//}
+	if len(errs) != 0 {
+		return fmt.Errorf("check param errs:%+v", errs)
+	}
+	return nil
+}

handler/task_script_list.go

@@ -0,0 +1,77 @@
+package handler
+
+import (
+	"errors"
+	"fmt"
+	"github.com/caixw/lib.go/conv"
+	"youngee_m_api/consts"
+	"youngee_m_api/model/http_model"
+	"youngee_m_api/pack"
+	"youngee_m_api/service"
+	"youngee_m_api/util"
+
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+)
+
+func WrapTaskScriptListHandler(ctx *gin.Context) {
+	handler := newTaskScriptListHandler(ctx)
+	BaseRun(handler)
+}
+
+func newTaskScriptListHandler(ctx *gin.Context) *TaskScriptListHandler {
+	return &TaskScriptListHandler{
+		req:  http_model.NewTaskScriptListRequest(),
+		resp: http_model.NewTaskScriptListResponse(),
+		ctx:  ctx,
+	}
+}
+
+type TaskScriptListHandler struct {
+	req  *http_model.TaskScriptListRequest
+	resp *http_model.CommonResponse
+	ctx  *gin.Context
+}
+
+func (h *TaskScriptListHandler) getRequest() interface{} {
+	return h.req
+}
+func (h *TaskScriptListHandler) getContext() *gin.Context {
+	return h.ctx
+}
+func (h *TaskScriptListHandler) getResponse() interface{} {
+	return h.resp
+}
+func (h *TaskScriptListHandler) run() {
+	conditions := pack.HttpTaskScriptListRequestToCondition(h.req)
+	data, err := service.Project.GetTaskScriptList(h.ctx, h.req.ProjectId, h.req.PageSize, h.req.PageNum, conditions)
+	if err != nil {
+		logrus.WithContext(h.ctx).Errorf("[TaskLogisticsListHandler] error GetProjectTaskList, err:%+v", err)
+		util.HandlerPackErrorResp(h.resp, consts.ErrorInternal, consts.DefaultToast)
+		return
+	}
+	h.resp.Data = data
+}
+func (h *TaskScriptListHandler) checkParam() error {
+	var errs []error
+	if h.req.PageNum < 0 || h.req.PageSize <= 0 {
+		errs = append(errs, errors.New("page param error"))
+	}
+	h.req.PageNum--
+	h.req.ProjectId = util.IsNull(h.req.ProjectId)
+	if _, err := conv.Int64(h.req.ProjectId); err != nil {
+		errs = append(errs, err)
+	}
+	// h.req.StrategyId = util.IsNull(h.req.StrategyId)
+	// if _, err := conv.Int64(h.req.StrategyId); err != nil {
+	// 	errs = append(errs, err)
+	// }
+	h.req.ScriptStatus = util.IsNull(h.req.ScriptStatus)
+	if _, err := conv.Int64(h.req.ScriptStatus); err != nil {
+		errs = append(errs, err)
+	}
+	if len(errs) != 0 {
+		return fmt.Errorf("check param errs:%+v", errs)
+	}
+	return nil
+}

handler/task_sketch_list.go

@@ -0,0 +1,76 @@
+package handler
+
+import (
+	"errors"
+	"fmt"
+	"youngee_m_api/consts"
+	"youngee_m_api/model/http_model"
+	"youngee_m_api/pack"
+	"youngee_m_api/service"
+	"youngee_m_api/util"
+
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+)
+
+func WrapTaskSketchListHandler(ctx *gin.Context) {
+	handler := newTaskSketchListHandler(ctx)
+	BaseRun(handler)
+}
+
+func newTaskSketchListHandler(ctx *gin.Context) *TaskSketchListHandler {
+	return &TaskSketchListHandler{
+		req:  http_model.NewTaskSketchListRequest(),
+		resp: http_model.NewTaskSketchListResponse(),
+		ctx:  ctx,
+	}
+}
+
+type TaskSketchListHandler struct {
+	req  *http_model.TaskSketchListRequest
+	resp *http_model.CommonResponse
+	ctx  *gin.Context
+}
+
+func (h *TaskSketchListHandler) getRequest() interface{} {
+	return h.req
+}
+func (h *TaskSketchListHandler) getContext() *gin.Context {
+	return h.ctx
+}
+func (h *TaskSketchListHandler) getResponse() interface{} {
+	return h.resp
+}
+func (h *TaskSketchListHandler) run() {
+	conditions := pack.HttpTaskSketchListRequestToCondition(h.req)
+	data, err := service.Project.GetTaskSketchList(h.ctx, h.req.ProjectId, h.req.PageSize, h.req.PageNum, conditions)
+	if err != nil {
+		logrus.WithContext(h.ctx).Errorf("[TaskLogisticsListHandler] error GetProjectTaskList, err:%+v", err)
+		util.HandlerPackErrorResp(h.resp, consts.ErrorInternal, consts.DefaultToast)
+		return
+	}
+	h.resp.Data = data
+}
+func (h *TaskSketchListHandler) checkParam() error {
+	var errs []error
+	if h.req.PageNum < 0 || h.req.PageSize <= 0 {
+		errs = append(errs, errors.New("page param error"))
+	}
+	h.req.PageNum--
+	//h.req.ProjectId = util.IsNull(h.req.ProjectId)
+	//if _, err := conv.Int64(h.req.ProjectId); err != nil {
+	//	errs = append(errs, err)
+	//}
+	//// h.req.StrategyId = util.IsNull(h.req.StrategyId)
+	//// if _, err := conv.Int64(h.req.StrategyId); err != nil {
+	//// 	errs = append(errs, err)
+	//// }
+	//h.req.SketchStatus = util.IsNull(h.req.SketchStatus)
+	//if _, err := conv.Int64(h.req.SketchStatus); err != nil {
+	//	errs = append(errs, err)
+	//}
+	if len(errs) != 0 {
+		return fmt.Errorf("check param errs:%+v", errs)
+	}
+	return nil
+}

handler/task_terminate.go

@@ -0,0 +1,54 @@
+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 WrapTaskTerminateHandler(ctx *gin.Context) {
+	handler := newTaskTerminateHandler(ctx)
+	BaseRun(handler)
+}
+
+func newTaskTerminateHandler(ctx *gin.Context) *TaskTerminateHandler {
+	return &TaskTerminateHandler{
+		req:  http_model.NewTaskTerminateRequest(),
+		resp: http_model.NewTaskTerminateResponse(),
+		ctx:  ctx,
+	}
+}
+
+type TaskTerminateHandler struct {
+	req  *http_model.TaskTerminateRequest
+	resp *http_model.CommonResponse
+	ctx  *gin.Context
+}
+
+func (h *TaskTerminateHandler) getRequest() interface{} {
+	return h.req
+}
+func (h *TaskTerminateHandler) getContext() *gin.Context {
+	return h.ctx
+}
+func (h *TaskTerminateHandler) getResponse() interface{} {
+	return h.resp
+}
+func (h *TaskTerminateHandler) run() {
+	data := http_model.TaskTerminateRequest{}
+	data = *h.req
+	res, err := service.Terminate.TaskTerminate(h.ctx, data)
+	if err != nil {
+		logrus.Errorf("[TaskTerminateHandler] call TaskTerminate err:%+v\n", err)
+		util.HandlerPackErrorResp(h.resp, consts.ErrorInternal, "")
+		return
+	}
+	h.resp.Message = ""
+	h.resp.Data = res
+}
+func (h *TaskTerminateHandler) checkParam() error {
+	return nil
+}

handler/task_terminated_list.go

@@ -0,0 +1,73 @@
+package handler
+
+import (
+	"errors"
+	"fmt"
+	"github.com/caixw/lib.go/conv"
+	"youngee_m_api/consts"
+	"youngee_m_api/model/http_model"
+	"youngee_m_api/pack"
+	"youngee_m_api/service"
+	"youngee_m_api/util"
+
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+)
+
+func WrapTaskTerminatedListHandler(ctx *gin.Context) {
+	handler := newTaskTerminatedListHandler(ctx)
+	BaseRun(handler)
+}
+
+func newTaskTerminatedListHandler(ctx *gin.Context) *TaskTerminatedListHandler {
+	return &TaskTerminatedListHandler{
+		req:  http_model.NewTaskTerminatedListRequest(),
+		resp: http_model.NewTaskTerminatedListResponse(),
+		ctx:  ctx,
+	}
+}
+
+type TaskTerminatedListHandler struct {
+	req  *http_model.TaskTerminatedListRequest
+	resp *http_model.CommonResponse
+	ctx  *gin.Context
+}
+
+func (h *TaskTerminatedListHandler) getRequest() interface{} {
+	return h.req
+}
+func (h *TaskTerminatedListHandler) getContext() *gin.Context {
+	return h.ctx
+}
+func (h *TaskTerminatedListHandler) getResponse() interface{} {
+	return h.resp
+}
+func (h *TaskTerminatedListHandler) run() {
+	conditions := pack.HttpTaskTerminatedListRequestToCondition(h.req)
+	data, err := service.Default.GetTaskTerminatedList(h.ctx, h.req.ProjectId, h.req.PageSize, h.req.PageNum, conditions)
+	if err != nil {
+		logrus.WithContext(h.ctx).Errorf("[TaskLogisticsListHandler] error GetProjectTaskList, err:%+v", err)
+		util.HandlerPackErrorResp(h.resp, consts.ErrorInternal, consts.DefaultToast)
+		return
+	}
+	h.resp.Data = data
+}
+func (h *TaskTerminatedListHandler) checkParam() error {
+	var errs []error
+	if h.req.PageNum < 0 || h.req.PageSize <= 0 {
+		errs = append(errs, errors.New("page param error"))
+	}
+	h.req.PageNum--
+	h.req.ProjectId = util.IsNull(h.req.ProjectId)
+	if _, err := conv.Int64(h.req.ProjectId); err != nil {
+		errs = append(errs, err)
+	}
+	h.req.DefaultStatus = util.IsNull(h.req.DefaultStatus)
+	if _, err := conv.Int64(h.req.DefaultStatus); err != nil {
+		errs = append(errs, err)
+	}
+	if len(errs) != 0 {
+		return fmt.Errorf("check param errs:%+v", errs)
+	}
+	return nil
+}

handler/task_terminating_list.go

@@ -0,0 +1,73 @@
+package handler
+
+import (
+	"errors"
+	"fmt"
+	"github.com/caixw/lib.go/conv"
+	"youngee_m_api/consts"
+	"youngee_m_api/model/http_model"
+	"youngee_m_api/pack"
+	"youngee_m_api/service"
+	"youngee_m_api/util"
+
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+)
+
+func WrapTaskTerminatingListHandler(ctx *gin.Context) {
+	handler := newTaskTerminatingListHandler(ctx)
+	BaseRun(handler)
+}
+
+func newTaskTerminatingListHandler(ctx *gin.Context) *TaskTerminatingListHandler {
+	return &TaskTerminatingListHandler{
+		req:  http_model.NewTaskTerminatingListRequest(),
+		resp: http_model.NewTaskTerminatingListResponse(),
+		ctx:  ctx,
+	}
+}
+
+type TaskTerminatingListHandler struct {
+	req  *http_model.TaskTerminatingListRequest
+	resp *http_model.CommonResponse
+	ctx  *gin.Context
+}
+
+func (h *TaskTerminatingListHandler) getRequest() interface{} {
+	return h.req
+}
+func (h *TaskTerminatingListHandler) getContext() *gin.Context {
+	return h.ctx
+}
+func (h *TaskTerminatingListHandler) getResponse() interface{} {
+	return h.resp
+}
+func (h *TaskTerminatingListHandler) run() {
+	conditions := pack.HttpTaskTerminatingListRequestToCondition(h.req)
+	data, err := service.Default.GetTaskTerminatingList(h.ctx, h.req.ProjectId, h.req.PageSize, h.req.PageNum, conditions)
+	if err != nil {
+		logrus.WithContext(h.ctx).Errorf("[TaskLogisticsListHandler] error GetProjectTaskList, err:%+v", err)
+		util.HandlerPackErrorResp(h.resp, consts.ErrorInternal, consts.DefaultToast)
+		return
+	}
+	h.resp.Data = data
+}
+func (h *TaskTerminatingListHandler) checkParam() error {
+	var errs []error
+	if h.req.PageNum < 0 || h.req.PageSize <= 0 {
+		errs = append(errs, errors.New("page param error"))
+	}
+	h.req.PageNum--
+	h.req.ProjectId = util.IsNull(h.req.ProjectId)
+	if _, err := conv.Int64(h.req.ProjectId); err != nil {
+		errs = append(errs, err)
+	}
+	h.req.DefaultStatus = util.IsNull(h.req.DefaultStatus)
+	if _, err := conv.Int64(h.req.DefaultStatus); err != nil {
+		errs = append(errs, err)
+	}
+	if len(errs) != 0 {
+		return fmt.Errorf("check param errs:%+v", errs)
+	}
+	return nil
+}

model/common_model/InvoiceRecordsCondition.go

@@ -0,0 +1,6 @@
+package common_model
+
+type InvoiceRecordsCondition struct {
+	SubmitAt  string `condition:"submit_at"`  // 申请提交时间
+	BillingAt string `condition:"billing_at"` // 申请提交时间
+}

model/common_model/WithdrawRecordsCondition.go

@@ -4,5 +4,5 @@ type WithdrawRecordsCondition struct {
 	TalentId   string `condition:"talent_id"`   // 达人ID
 	Status     int32  `condition:"status"`      //提现状态
 	SubmitAt   string `condition:"submit_at"`   // 申请提交时间
-	WithdrawAt string `condition:"withdraw_at"` // 申请提交时间
+	WithdrawAt string `condition:"withdraw_at"` // 提现时间
 }

model/common_model/talent_condition.go

@@ -0,0 +1,14 @@
+package common_model
+
+type TalentConditions struct {
+	ProjectId        int64  `condition:"project_id"`        // 项目ID
+	LogisticsStatus  int64  `condition:"logistics_status"`  // 物流状态
+	ScriptStatus     int64  `condition:"script_status"`     // 脚本状态
+	SketchStatus     int64  `condition:"sketch_status"`     // 初稿状态
+	LinkStatus       int64  `condition:"link_status"`       // 链接状态
+	DataStatus       int64  `condition:"data_status"`       // 数据状态
+	DefaultStatus    int64  `condition:"default_status"`    // 违约状态
+	StrategyIds      string `condition:"strategy_ids"`      // 策略ID
+	TaskId           string `condition:"task_id"`           // 任务ID
+	PlatformNickname string `condition:"platform_nickname"` // 账号昵称
+}

model/gorm_model/contract_info.go

@@ -9,6 +9,7 @@ import (
 type YoungeeContractInfo struct {
 	ContractID       int        `gorm:"column:contract_id;primary_key;AUTO_INCREMENT"` // 合约id
 	TaskID           int        `gorm:"column:task_id;NOT NULL"`                       // 任务id
+	ProjectID        int        `gorm:"column:project_id;NOT NULL"`                    // 任务所属项目id
 	BreakType        int        `gorm:"column:break_type;NOT NULL"`                    // 违约类型（4类严重违约）：1（脚本）2（初稿）3（链接）4（数据）
 	SettlementAmount float64    `gorm:"column:settlement_amount;NOT NULL"`             // 应结算金额
 	BreakAt          time.Time  `gorm:"column:break_at"`                               // 违约时间

model/gorm_model/invoice_record.go

@@ -0,0 +1,25 @@
+package gorm_model
+
+// Code generated by sql2gorm. DO NOT EDIT.
+
+import (
+	"time"
+)
+
+type YounggeeInvoiceRecord struct {
+	BillingID      string    `gorm:"column:billing_id;primary_key"`  // 开票订单ID
+	EnterpriseID   int64     `gorm:"column:enterprise_id;NOT NULL"`  // 企业id
+	InvoiceType    string    `gorm:"column:invoice_type;NOT NULL"`   // 发票类型
+	InvoiceAmount  float64   `gorm:"column:invoice_amount;NOT NULL"` // 开票金额
+	InvoiceSnap    string    `gorm:"column:invoice_snap;NOT NULL"`   // 开票信息快照
+	AddressSnap    string    `gorm:"column:address_snap;NOT NULL"`   // 邮寄地址快照
+	Status         int64     `gorm:"column:status;NOT NULL"`         // 开票状态:1 为待开票，2为已开票
+	Phone          string    `gorm:"column:phone;NOT NULL"`          // 联系方式
+	ShipmentNumber string    `gorm:"column:shipment_number"`         // 物流单号
+	SubmitAt       time.Time `gorm:"column:submit_at;NOT NULL"`      // 申请提交时间
+	BillingAt      time.Time `gorm:"column:billing_at"`              // 开票时间
+}
+
+func (m *YounggeeInvoiceRecord) TableName() string {
+	return "younggee_invoice_record"
+}

model/gorm_model/project.go

@@ -6,30 +6,33 @@ import (
 )
 
 type ProjectInfo struct {
-	ProjectID         int64     `gorm:"column:project_id;primary_key;AUTO_INCREMENT"` // 项目id
-	ProjectName       string    `gorm:"column:project_name"`                          // 项目名称
-	ProjectStatus     int64     `gorm:"column:project_status"`                        // 项目状态，1-10分别代表创建中、待审核、审核通过、招募中、招募完毕、待支付、已支付、失效、执行中、已结案
-	ProjectType       int64     `gorm:"column:project_type"`                          // 项目类型，1代表全流程项目，2代表专项项目
-	ProjectPlatform   int64     `gorm:"column:project_platform"`                      // 项目平台，1-7分别代表红book、抖音、微博、快手、b站、大众点评、知乎
-	ProjectForm       int64     `gorm:"column:project_form"`                          // 项目形式，1-4分别代表实体商品寄拍、虚拟产品测评、线下探店打卡、素材微原创
-	TalentType        string    `gorm:"column:talent_type"`                           // 达人类型
-	RecruitDdl        time.Time `gorm:"column:recruit_ddl"`                           // 招募截止时间
-	ContentType       int64     `gorm:"column:content_type"`                          // 内容形式，1代表图文，2代表视频
-	ProjectDetail     string    `gorm:"column:project_detail"`                        // 项目详情
-	ApplyNum          int64     `gorm:"column:apply_num;default:0;NOT NULL"`          // 报名人数
-	RecruitNum        int64     `gorm:"column:recruit_num;default:0;NOT NULL"`        // 已招募人数
-	EnterpriseID      int64     `gorm:"column:enterprise_id"`                         // 所属企业id
-	ProductID         int64     `gorm:"column:product_id"`                            // 关联商品id
-	CreatedAt         time.Time `gorm:"column:created_at"`                            // 创建时间
-	UpdatedAt         time.Time `gorm:"column:updated_at"`                            // 修改时间
-	FeeForm           string    `gorm:"column:fee_form"`                              // 稿费形式列表
-	AutoFailAt        time.Time `gorm:"column:auto_fail_at"`                          // 失效自动处理时间
-	AutoTaskID        int       `gorm:"column:auto_task_id;NOT NULL"`                 // 定时任务id
-	AutoDefaultID     int       `gorm:"column:auto_default_id;NOT NULL"`              // 违约状态id
-	PaymentAmount     float64   `gorm:"column:payment_amount"`                        // 支付金额
-	PayAt             time.Time `gorm:"column:pay_at"`                                // 支付时间
-	AutoScriptBreakAt time.Time `gorm:"column:auto_script_break_at"`                  // 脚本违约自动处理时间
-	AutoSketchBreakAt time.Time `gorm:"column:auto_sketch_break_at"`                  // 初稿违约自动处理时间
+	ProjectID         int64      `gorm:"column:project_id;primary_key;AUTO_INCREMENT"` // 项目id
+	ProjectName       string     `gorm:"column:project_name"`                          // 项目名称
+	ProjectStatus     int64      `gorm:"column:project_status"`                        // 项目状态，1-10分别代表创建中、待审核、审核通过、招募中、招募完毕、待支付、已支付、失效、执行中、已结案
+	ProjectType       int64      `gorm:"column:project_type"`                          // 项目类型，1代表全流程项目，2代表专项项目
+	ProjectPlatform   int64      `gorm:"column:project_platform"`                      // 项目平台，1-7分别代表小红书、抖音、微博、快手、b站、大众点评、知乎
+	ProjectForm       int64      `gorm:"column:project_form"`                          // 项目形式，1-4分别代表实体商品寄拍、虚拟产品测评、线下探店打卡、素材微原创
+	TalentType        string     `gorm:"column:talent_type"`                           // 达人类型
+	RecruitDdl        time.Time  `gorm:"column:recruit_ddl"`                           // 招募截止时间
+	ContentType       int64      `gorm:"column:content_type"`                          // 内容形式，1代表图文，2代表视频
+	ProjectDetail     string     `gorm:"column:project_detail"`                        // 项目详情
+	ApplyNum          int64      `gorm:"column:apply_num;default:0;NOT NULL"`          // 报名人数
+	RecruitNum        int64      `gorm:"column:recruit_num;default:0;NOT NULL"`        // 已招募人数
+	EnterpriseID      int64      `gorm:"column:enterprise_id"`                         // 所属企业id
+	ProductID         int64      `gorm:"column:product_id"`                            // 关联商品id
+	CreatedAt         time.Time  `gorm:"column:created_at"`                            // 创建时间
+	UpdatedAt         time.Time  `gorm:"column:updated_at"`                            // 修改时间
+	FeeForm           string     `gorm:"column:fee_form"`                              // 稿费形式列表
+	AutoFailAt        *time.Time `gorm:"column:auto_fail_at"`                          // 失效自动处理时间
+	AutoTaskID        int64      `gorm:"column:auto_task_id;NOT NULL"`                 // 定时任务id
+	AutoDefaultID     int64      `gorm:"column:auto_default_id;NOT NULL"`              // 违约状态id
+	PaymentAmount     float64    `gorm:"column:payment_amount"`                        // 支付金额
+	PayAt             *time.Time `gorm:"column:pay_at"`                                // 支付时间
+	AutoScriptBreakAt *time.Time `gorm:"column:auto_script_break_at"`                  // 脚本违约自动处理时间
+	AutoSketchBreakAt *time.Time `gorm:"column:auto_sketch_break_at"`                  // 初稿违约自动处理时间
+	FailReason        int        `gorm:"column:fail_reason"`                           // 失效原因，1、2分别表示逾期未支付、项目存在风险
+	PassAt            time.Time  `gorm:"column:pass_at"`                               // 审核通过时间
+	FinishAt          time.Time  `gorm:"column:finish_at"`                             // 结案时间
 }
 
 func (m *ProjectInfo) TableName() string {

model/gorm_model/project_task.go

@@ -40,6 +40,7 @@ type YoungeeTaskInfo struct {
 	LinkStatus             uint      `gorm:"column:link_status;default:1"`                          // 链接上传状态 1-5分别代表待添加、已添加、待修改、已修改、已通过
 	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分别代表不可提现、可提现、提现中、已提现
 }
 
 func (m *YoungeeTaskInfo) TableName() string {

model/gorm_model/recruit_strategy.go

@@ -1,19 +1,22 @@
 // Code generated by sql2gorm. DO NOT EDIT.
 package gorm_model
 
-
 type RecruitStrategy struct {
-	RecruitStrategyID int64 `gorm:"column:recruit_strategy_id;primary_key"` // 招募策略id
-	FeeForm           int64 `gorm:"column:fee_form"`                        // 稿费形式，1-3分别代表产品置换、固定稿费、自报价
-	StrategyID        int64 `gorm:"column:strategy_id"`                     // 策略id
-	FollowersLow      int64 `gorm:"column:followers_low"`                   // 达人粉丝数下限
-	FollowersUp       int64 `gorm:"column:followers_up"`                    // 达人粉丝数上限
-	RecruitNumber     int64 `gorm:"column:recruit_number"`                  // 招募数量
-	Offer             int64 `gorm:"column:offer"`                           // 报价
-	ProjectID         int64 `gorm:"column:project_id"`                      // 所属项目id
+	RecruitStrategyID int64 `gorm:"column:recruit_strategy_id;primary_key;AUTO_INCREMENT"` // 招募策略id
+	FeeForm           int64 `gorm:"column:fee_form"`                                       // 稿费形式，1-3分别代表产品置换、固定稿费、自报价
+	StrategyID        int64 `gorm:"column:strategy_id"`                                    // 策略id
+	FollowersLow      int64 `gorm:"column:followers_low"`                                  // 达人粉丝数下限
+	FollowersUp       int64 `gorm:"column:followers_up"`                                   // 达人粉丝数上限
+	RecruitNumber     int64 `gorm:"column:recruit_number"`                                 // 招募数量
+	Offer             int64 `gorm:"column:offer"`                                          // 报价
+	ProjectID         int64 `gorm:"column:project_id"`                                     // 所属项目id
+	ServiceCharge     int64 `gorm:"column:service_charge"`                                 // 平台服务费，稿费形式为产品置换时必填
+	SelectedNumber    int64 `gorm:"column:selected_number"`                                // 已选数量，被企业选择的达人数量 应发货
+	WaitingNumber     int64 `gorm:"column:waiting_number"`                                 // 待发货
+	DeliveredNumber   int64 `gorm:"column:delivered_number"`                               // 已发货
+	SignedNumber      int64 `gorm:"column:signed_number"`                                  // 已签收
 }
 
 func (m *RecruitStrategy) TableName() string {
 	return "recruit_strategy"
 }
-

model/gorm_model/task_logistic.go

@@ -6,16 +6,16 @@ import (
 )
 
 type YoungeeTaskLogistics struct {
-	LogisticsID           int       `gorm:"column:logistics_id;primary_key;AUTO_INCREMENT"` // 货物-id
+	LogisticsID           int64     `gorm:"column:logistics_id;primary_key;AUTO_INCREMENT"` // 货物-id
 	CompanyName           string    `gorm:"column:company_name"`                            // 实物商品-物流公司名称
 	LogisticsNumber       string    `gorm:"column:logistics_number"`                        // 实物商品-物流单号
 	ExplorestoreStarttime time.Time `gorm:"column:explorestore_starttime"`                  // 线下探店-探店开始时间
 	ExplorestoreEndtime   time.Time `gorm:"column:explorestore_endtime"`                    // 线下探店-探店结束时间
 	ExplorestorePeriod    string    `gorm:"column:explorestore_period"`                     // 线下探店-探店持续时间
 	CouponCodeInformation string    `gorm:"column:coupon_code_information"`                 // 虚拟产品-券码信息
-	TaskID                int       `gorm:"column:task_id;NOT NULL"`                        // 任务id
+	TaskID                int64     `gorm:"column:task_id;NOT NULL"`                        // 任务id
 	DeliveryTime          time.Time `gorm:"column:delivery_time"`                           // 发货时间
-	ThingsType            int       `gorm:"column:things_type;NOT NULL"`                    // 任务类型：1 实物，2：线下探店，3：虚拟产品
+	ThingsType            int64     `gorm:"column:things_type;NOT NULL"`                    // 任务类型：1 实物，2：线下探店，3：虚拟产品
 	SignedTime            time.Time `gorm:"column:signed_time"`                             // 实物商品-签收时间
 	AutoSignAt            time.Time `gorm:"column:auto_sign_at"`                            // 自动签收时间
 	AutoScriptBreakAt     time.Time `gorm:"column:auto_script_break_at"`                    // 脚本违约自动处理时间

model/gorm_model/withdraw_info.go

@@ -11,8 +11,10 @@ type YounggeeWithdrawRecord struct {
 	TalentID       string    `gorm:"column:talent_id;NOT NULL"`       // 达人id
 	WithdrawAmount int64     `gorm:"column:withdraw_amount;NOT NULL"` // 提现金额
 	AmountPayable  int64     `gorm:"column:amount_payable;NOT NULL"`  // 应付金额
+	TaskIDList     string    `gorm:"column:task_id_list;NOT NULL"`    // 该提现订单包含的task_id列表
 	ReceiveInfo    string    `gorm:"column:receive_info;NOT NULL"`    // 收款信息
 	Status         int       `gorm:"column:status;NOT NULL"`          // 提现状态：1为提现待确认，2为已提现
+	BankType       int       `gorm:"column:bank_type;NOT NULL"`       // 到账方式，1为支付宝，2为银行卡
 	SubmitAt       time.Time `gorm:"column:submit_at;NOT NULL"`       // 申请提交时间
 	WithdrawAt     time.Time `gorm:"column:withdraw_at"`              // 提现时间
 }

model/http_model/ConfirmInvoiceRequest.go

@@ -0,0 +1,14 @@
+package http_model
+
+type ConfirmInvoiceRequest struct {
+	BillingId      string `json:"billing_id"`
+	ShipmentNumber string `json:"shipment_number"`
+}
+
+func NewConfirmInvoiceRequest() *ConfirmInvoiceRequest {
+	return new(ConfirmInvoiceRequest)
+}
+
+func NewConfirmInvoiceResponse() *CommonResponse {
+	return new(CommonResponse)
+}

model/http_model/ConfirmWithdrawalRequest.go

@@ -0,0 +1,14 @@
+package http_model
+
+type ConfirmWithdrawalRequest struct {
+	WithdrawId string `json:"withdraw_id"`
+}
+
+func NewConfirmWithdrawalRequest() *ConfirmWithdrawalRequest {
+	return new(ConfirmWithdrawalRequest)
+}
+
+func NewConfirmWithdrawalResponse() *CommonResponse {
+	resp := new(CommonResponse)
+	return resp
+}

model/http_model/FeeDetailRequest.go

@@ -0,0 +1,27 @@
+package http_model
+
+type FeeDetailRequest struct {
+	EndTime string `json:"end_time"`
+}
+
+type FeeDetailData struct {
+	ProjectID   int64  `json:"project_id"`
+	ProjectName string `json:"project_name"`
+	ProjectType string `json:"project_type"`
+	Payment     string `json:"payment"`
+	UpdatedAt   string `json:"updated_at"`
+}
+
+type FeeDetailPreview struct {
+	FeeDetailData []*FeeDetailData `json:"fee_detail_data"`
+}
+
+func NewFeeDetailRequest() *FeeDetailRequest {
+	return new(FeeDetailRequest)
+}
+
+func NewFeeDetailResponse() *CommonResponse {
+	resp := new(CommonResponse)
+	resp.Data = new(FeeDetailPreview)
+	return resp
+}

model/http_model/FindAllProductsRequest.go

@@ -0,0 +1,25 @@
+package http_model
+
+type FindAllProductsRequest struct {
+	EnterpriseID int64 `json:"enterprise_id"`
+}
+
+type ProductInfos struct {
+	ProductID   int64  `json:"product_id"`
+	BrandName   string `json:"brand_name"`
+	ProductName string `json:"product_name"`
+	ProductType string `json:"product_type"`
+}
+
+type FindAllProductsData struct {
+	ProductInfos []ProductInfos `json:"product_infos"`
+}
+
+func NewFindAllProductsRequest() *FindAllProductsRequest {
+	return new(FindAllProductsRequest)
+}
+func NewFindAllProductsResponse() *CommonResponse {
+	resp := new(CommonResponse)
+	resp.Data = new(FindAllProductsData)
+	return resp
+}

model/http_model/GetBankInfoRequest.go

@@ -0,0 +1,21 @@
+package http_model
+
+type GetBankInfoRequest struct {
+	BankId          string `json:"bank_id"`
+	BankOpenAddress string `json:"bank_open_address"`
+}
+
+type BankInfo struct {
+	BankName        string `json:"bank_name"`
+	BankOpenAddress string `json:"bank_open_address"`
+}
+
+func NewGetBankInfoRequest() *GetBankInfoRequest {
+	return new(GetBankInfoRequest)
+}
+
+func NewGetBankInfoResponse() *CommonResponse {
+	resp := new(CommonResponse)
+	resp.Data = new(BankInfo)
+	return resp
+}

model/http_model/GetCodeUrlRequest.go

@@ -0,0 +1,21 @@
+package http_model
+
+type GetCodeUrlRequest struct {
+	Amount int64 `json:"amount"`
+	Type   int64 `json:"type"`
+}
+
+type CodeUrl struct {
+	CodeUrl string `json:"code_url"`
+	TradeId string `json:"trade_id"`
+}
+
+func NewGetCodeUrlRequest() *GetCodeUrlRequest {
+	return new(GetCodeUrlRequest)
+}
+
+func NewGetCodeUrlResponse() *CommonResponse {
+	resp := new(CommonResponse)
+	resp.Data = new(CodeUrl)
+	return resp
+}

model/http_model/GetEnterPriseIdsRequest.go

@@ -0,0 +1,18 @@
+package http_model
+
+type GetEnterPriseIdsRequest struct {
+}
+
+type EnterPriseIds struct {
+	EnterPriseIds []int64 `json:"enter_prise_ids"`
+}
+
+func NewGetEnterpriseIdsRequest() *GetEnterPriseIdsRequest {
+	return new(GetEnterPriseIdsRequest)
+}
+
+func NewGetEnterpriseIdsResponse() *CommonResponse {
+	resp := new(CommonResponse)
+	resp.Data = new(EnterPriseIds)
+	return resp
+}

model/http_model/GetWithdrawNumsRequest.go

@@ -0,0 +1,18 @@
+package http_model
+
+type GetWithdrawNumsRequest struct {
+}
+
+type WithdrawNums struct {
+	WithdrawNums int `json:"withdraw_nums"`
+}
+
+func NewGetWithdrawNumsRequest() *GetWithdrawNumsRequest {
+	return new(GetWithdrawNumsRequest)
+}
+
+func NewGetWithdrawNumsResponse() *CommonResponse {
+	resp := new(CommonResponse)
+	resp.Data = new(WithdrawNums)
+	return resp
+}

model/http_model/InvoiceRecordsRequest.go

@@ -0,0 +1,40 @@
+package http_model
+
+type InvoiceRecordsRequest struct {
+	PageSize      int32  `json:"page_size"`
+	PageNum       int32  `json:"page_num"`
+	InvoiceStatus int32  `json:"invoice_status"`
+	SubmitAt      string `json:"submit_at"`
+	BusinessName  string `json:"business_name"`
+	UserId        int64  `json:"user_id"`
+	BillingAt     string `json:"billing_at"`
+}
+
+type InvoiceRecordsPreviews struct {
+	BillingId      string  `json:"billing_id"`
+	UserId         int64   `json:"user_id"`
+	BusinessName   string  `json:"business_name"`
+	Amount         float64 `json:"amount"`
+	InvoiceType    string  `json:"invoice_type"`
+	InvoiceInfo    string  `json:"invoice_info"`
+	AddressInfo    string  `json:"address_info"`
+	ShipmentNumber string  `json:"shipment_number"` // 物流单号
+	Phone          string  `json:"phone"`
+	SubmitAt       string  `json:"submit_at"`
+	BillingAt      string  `json:"billing_at"`
+}
+
+type InvoiceRecordsData struct {
+	InvoiceRecordsPreviews []*InvoiceRecordsPreviews `json:"invoice_records_previews"`
+	Total                  string                    `json:"total"`
+}
+
+func NewInvoiceRecordsRequest() *InvoiceRecordsRequest {
+	return new(InvoiceRecordsRequest)
+}
+
+func NewInvoiceRecordsResponse() *CommonResponse {
+	resp := new(CommonResponse)
+	resp.Data = new(InvoiceRecordsData)
+	return resp
+}

model/http_model/WithDrawalRecordsRequest.go

@@ -11,11 +11,13 @@ type WithdrawalRecordsRequest struct {
 }
 
 type WithdrawalRecordsData struct {
+	WithdrawId     string  `json:"withdraw_id"`
 	TalentId       string  `json:"talent_id"`
 	TalentName     string  `json:"talent_name"`
 	WithdrawAmount float32 `json:"withdraw_amount"`
 	AmountPayable  float32 `json:"amount_payable"`
 	ReceiveInfo    string  `json:"receive_info"`
+	BankType       int     `json:"bank_type"`
 	Phone          string  `json:"phone"`
 	SubmitAt       string  `json:"submit_at"`
 	WithdrawAt     string  `json:"withdraw_at"`

model/http_model/data_accept.go

@@ -0,0 +1,20 @@
+package http_model
+
+type AcceptDataRequest struct {
+	Payment float64 `json:"payment"`      //招募策略id
+	TaskIds string  `json:"task_id_list"` //任务id列表
+	// TaskID     int64 `json:"task_id"`     //任务-id
+}
+
+type AcceptDataData struct {
+	TaskIds []int `json:"taskIds"` //任务id列表
+}
+
+func NewAcceptDataRequest() *AcceptDataRequest {
+	return new(AcceptDataRequest)
+}
+func NewAcceptDataResponse() *CommonResponse {
+	resp := new(CommonResponse)
+	resp.Data = new(AcceptDataData)
+	return resp
+}

model/http_model/data_number_info.go

@@ -0,0 +1,26 @@
+package http_model
+
+type GetDataNumberInfoRequest struct {
+	ProjectId   int64  `json:"project_id"`   // 项目id
+	StrategyIds string `json:"strategy_ids"` // 招募策略id列表
+}
+
+type DataNumberInfo struct {
+	StrategyId         int64 `json:"strategy_id"`          // 招募策略id
+	DataNumber         int64 `json:"data_number"`          // 应传数据数量
+	DataUnreviewNumber int64 `json:"data_unreview_number"` // 数据待审数量
+	DataPassedNumber   int64 `json:"data_passed_number"`   // 数据已通过数量
+}
+
+type GetDataNumberInfoData struct {
+	DataNumberInfoList []*DataNumberInfo `json:"number_info_list"`
+}
+
+func NewGetDataNumberInfoRequest() *GetDataNumberInfoRequest {
+	return new(GetDataNumberInfoRequest)
+}
+func NewGetDataNumberInfoResponse() *CommonResponse {
+	resp := new(CommonResponse)
+	resp.Data = new(GetDataNumberInfoData)
+	return resp
+}

model/http_model/data_opinion.go

@@ -0,0 +1,19 @@
+package http_model
+
+type DataOpinionRequest struct {
+	TaskID      int64  `json:"task_id"`      //任务-id
+	DataOpinion string `json:"Data_opinion"` //数据审核意见
+}
+
+type DataOpinionData struct {
+	TaskID int64 `json:"task_id"` // 任务ID
+}
+
+func NewDataOpinionRequest() *DataOpinionRequest {
+	return new(DataOpinionRequest)
+}
+func NewDataOpinionResponse() *CommonResponse {
+	resp := new(CommonResponse)
+	resp.Data = new(DataOpinionData)
+	return resp
+}

model/http_model/default_number_info.go

@@ -0,0 +1,29 @@
+package http_model
+
+type GetDefaultNumberInfoRequest struct {
+	ProjectId   int64  `json:"project_id"`   // 项目id
+	StrategyIds string `json:"strategy_ids"` // 招募策略id列表
+}
+
+type DefaultNumberInfo struct {
+	StrategyId           int64 `json:"strategy_id"`            // 招募策略id
+	ShouldFinishNumber   int64 `json:"should_finish_number"`   // 应结案数量
+	UnuploadSketchNumber int64 `json:"unupload_sketch_number"` // 未传初稿违约数量
+	UnuploadScriptNumber int64 `json:"unupload_script_number"` // 未传脚本违约数量
+	UnuploadLinkNumber   int64 `json:"unupload_link_number"`   // 未传链接违约数量
+	UnuploadDataNumber   int64 `json:"unupload_data_number"`   // 未传数据违约数量
+	TerminateNumber      int64 `json:"terminate_number"`       // 解约数量
+}
+
+type GetDefaultNumberInfoData struct {
+	DefaultNumberInfoList []*DefaultNumberInfo `json:"number_info_list"`
+}
+
+func NewGetDefaultNumberInfoRequest() *GetDefaultNumberInfoRequest {
+	return new(GetDefaultNumberInfoRequest)
+}
+func NewGetDefaultNumberInfoResponse() *CommonResponse {
+	resp := new(CommonResponse)
+	resp.Data = new(GetDefaultNumberInfoData)
+	return resp
+}

model/http_model/finish_number.go

@@ -0,0 +1,25 @@
+package http_model
+
+type GetFinishNumberInfoRequest struct {
+	ProjectId   int64  `json:"project_id"`   // 项目id
+	StrategyIds string `json:"strategy_ids"` // 招募策略id列表
+}
+
+type FinishNumberInfo struct {
+	StrategyId         int64 `json:"strategy_id"`          // 招募策略id
+	ShouldFinishNumber int64 `json:"should_finish_number"` // 应结案数量
+	FinishedNumber     int64 `json:"finished_number"`      // 实际结案数量
+}
+
+type GetFinishNumberInfoData struct {
+	FinishNumberInfoList []*FinishNumberInfo `json:"number_info_list"`
+}
+
+func NewGetFinishNumberInfoRequest() *GetFinishNumberInfoRequest {
+	return new(GetFinishNumberInfoRequest)
+}
+func NewGetFinishNumberInfoResponse() *CommonResponse {
+	resp := new(CommonResponse)
+	resp.Data = new(GetFinishNumberInfoData)
+	return resp
+}

model/http_model/full_project_list.go

@@ -12,14 +12,14 @@ type FullProjectListRequest struct {
 	ProjectUpdated     string `json:"project_updated"`      // 最后操作时间
 }
 type FullProjectPreview struct {
-	ProjectId          string   `json:"project_id"`           // 项目ID
-	ProjectName        string   `json:"project_name"`         // 项目名
-	EnterpriseID    int64     `json:"enterprise_id"`                         // 所属企业id
-	ProjectStatus      string   `json:"project_status"`       // 项目状态
-	ProjectPlatform    string   `json:"project_platform"`     // 项目平台
-	ProjectForm        string   `json:"project_form"`         // 项目形式
-	ProjectContentType string   `json:"project_content_type"` // 内容形式
-	ProjectUpdated     string   `json:"project_updated"`      // 最后操作时间
+	ProjectId          string `json:"project_id"`           // 项目ID
+	ProjectName        string `json:"project_name"`         // 项目名
+	EnterpriseID       int64  `json:"enterprise_id"`        // 所属企业id
+	ProjectStatus      string `json:"project_status"`       // 项目状态
+	ProjectPlatform    string `json:"project_platform"`     // 项目平台
+	ProjectForm        string `json:"project_form"`         // 项目形式
+	ProjectContentType string `json:"project_content_type"` // 内容形式
+	ProjectUpdated     string `json:"project_updated"`      // 最后操作时间
 }
 type FullProjectListData struct {
 	FullProjectPreview []*FullProjectPreview `json:"full_project_pre_view"`

model/http_model/get_login_user.go

@@ -1,6 +1,6 @@
 package http_model
 
-type GetLoginUserRequest struct {}
+type GetLoginUserRequest struct{}
 
 type GetLoginUserList struct {
 	User []string `json:"user"`

model/http_model/link_accept.go

@@ -0,0 +1,18 @@
+package http_model
+
+type AcceptLinkRequest struct {
+	TaskIds string `json:"task_id_list"` //任务id列表
+}
+
+type AcceptLinkData struct {
+	TaskIds []int `json:"task_id_list"` //任务id列表
+}
+
+func NewAcceptLinkRequest() *AcceptLinkRequest {
+	return new(AcceptLinkRequest)
+}
+func NewAcceptLinkResponse() *CommonResponse {
+	resp := new(CommonResponse)
+	resp.Data = new(AcceptLinkData)
+	return resp
+}

model/http_model/link_number_info.go

@@ -0,0 +1,26 @@
+package http_model
+
+type GetLinkNumberInfoRequest struct {
+	ProjectId   int64  `json:"project_id"`   // 项目id
+	StrategyIds string `json:"strategy_ids"` // 招募策略id列表
+}
+
+type LinkNumberInfo struct {
+	StrategyId         int64 `json:"strategy_id"`          // 招募策略id
+	LinkNumber         int64 `json:"link_number"`          // 应发布数量
+	LinkUnreviewNumber int64 `json:"link_unreview_number"` // 链接未审数量
+	LinkPassedNumber   int64 `json:"link_passed_number"`   // 链接已通过数量
+}
+
+type GetLinkNumberInfoData struct {
+	LinkNumberInfoList []*LinkNumberInfo `json:"number_info_list"`
+}
+
+func NewGetLinkNumberInfoRequest() *GetLinkNumberInfoRequest {
+	return new(GetLinkNumberInfoRequest)
+}
+func NewGetLinkNumberInfoResponse() *CommonResponse {
+	resp := new(CommonResponse)
+	resp.Data = new(GetLinkNumberInfoData)
+	return resp
+}

model/http_model/link_opinion.go

@@ -0,0 +1,20 @@
+package http_model
+
+type LinkOpinionRequest struct {
+	StrategyID  int64  `json:"strategy_id"`  //招募策略id
+	TaskID      int64  `json:"task_id"`      //任务-id
+	LinkOpinion string `json:"Link_opinion"` //链接审核意见
+}
+
+type LinkOpinionData struct {
+	TaskID int64 `json:"task_id"` // 任务ID
+}
+
+func NewLinkOpinionRequest() *LinkOpinionRequest {
+	return new(LinkOpinionRequest)
+}
+func NewLinkOpinionResponse() *CommonResponse {
+	resp := new(CommonResponse)
+	resp.Data = new(LinkOpinionData)
+	return resp
+}

model/http_model/logistic_number_info.go

@@ -0,0 +1,27 @@
+package http_model
+
+type GetLogisticsNumberInfoRequest struct {
+	ProjectId   int64  `json:"project_id"`   // 项目id
+	StrategyIds string `json:"strategy_ids"` // 招募策略id列表
+}
+
+type LogisticsNumberInfo struct {
+	StrategyId        int64 `json:"strategy_id"`        // 招募策略id
+	DeliverNumber     int64 `json:"deliver_number"`     // 应发货数量
+	UndeliveredNumber int64 `json:"undelivered_number"` // 未发货数量
+	DeliveredNumber   int64 `json:"delivered_number"`   // 已发货数量
+	SignedNumber      int64 `json:"signed_number"`      // 已签收数量
+}
+
+type GetLogisticsNumberInfoData struct {
+	LogisticsNumberInfoList []*LogisticsNumberInfo `json:"number_info_list"`
+}
+
+func NewGetLogisticsNumberInfoRequest() *GetLogisticsNumberInfoRequest {
+	return new(GetLogisticsNumberInfoRequest)
+}
+func NewGetLogisticsNumberInfoResponse() *CommonResponse {
+	resp := new(CommonResponse)
+	resp.Data = new(GetLogisticsNumberInfoData)
+	return resp
+}

model/http_model/logistics_create.go

@@ -0,0 +1,31 @@
+package http_model
+
+import "time"
+
+type CreateLogisticsRequest struct {
+	StrategyID            int64     `json:"strategy_id"`             //招募策略id
+	LogisticsID           int64     `json:"logistics_id"`            // 货物-id
+	CompanyName           string    `json:"company_name"`            // 实物商品-物流公司名称
+	LogisticsNumber       string    `json:"logistics_number"`        // 实物商品-物流单号
+	ExplorestoreStarttime time.Time `json:"explorestore_starttime"`  // 线下探店-探店开始时间
+	ExplorestoreEndtime   time.Time `json:"explorestore_endtime"`    // 线下探店-探店结束时间
+	ExplorestorePeriod    string    `json:"explorestore_period"`     // 线下探店-探店持续时间
+	CouponCodeInformation string    `json:"coupon_code_information"` // 虚拟产品-券码信息
+	TaskID                int64     `json:"task_id"`                 // 任务id
+	DeliveryTime          string    `json:"delivery_time"`           // 发货时间
+	ThingsType            int       `json:"things_type"`             //产品类型 1：实物, 2：虚拟产品，3：线下探店
+	IsUpdate              int       `json:"is_update"`               //更新标志位 0：不更新 1：更新
+}
+
+type CreateLogisticsData struct {
+	LogisticsID int64 `json:"logisitcs_id"` // 商品id
+}
+
+func NewCreateLogisticsRequest() *CreateLogisticsRequest {
+	return new(CreateLogisticsRequest)
+}
+func NewCreateLogisticsResponse() *CommonResponse {
+	resp := new(CommonResponse)
+	resp.Data = new(CreateLogisticsData)
+	return resp
+}

model/http_model/pay_sum.go

@@ -4,7 +4,7 @@ type PaySumRequest struct {
 	ProjectId string `json:"project_id"` // 项目ID
 }
 type PaySum struct {
-	StrategyId int     `json:"strategy_id"`  // 策略ID
+	StrategyId int     `json:"strategy_id"` // 策略ID
 	AllPayment float64 `json:"all_payment"` //任务的全部费用
 }
 type PaySumResponce struct {

model/http_model/project_approve.go

@@ -1,9 +1,8 @@
 package http_model
 
-
 type ApproveProjectRequest struct {
 	ProjectId string `json:"project_id"` // 项目ID
-	IsApprove int64 `json:"is_approve"`
+	IsApprove int64  `json:"is_approve"`
 }
 
 func NewApproveProjectRequest() *ApproveProjectRequest {

model/http_model/project_change_taskStatus.go

@@ -0,0 +1,15 @@
+package http_model
+
+type ProjectChangeTaskStatusRequest struct {
+	TaskIds    []string `json:"taskIds"`
+	TaskStatus string   `json:"task_status"`
+}
+
+func NewProjectChangeTaskStatusRequst() *ProjectChangeTaskStatusRequest {
+	return new(ProjectChangeTaskStatusRequest)
+}
+
+func NewProjectChangeTaskStatusResponse() *CommonResponse {
+	resp := new(CommonResponse)
+	return resp
+}

model/http_model/project_show.go

@@ -8,19 +8,25 @@ type ShowProjectPhoto struct {
 }
 
 type ShowRecruitStrategy struct {
-	FeeForm       string `json:"fee_form"`       // 稿费形式，1-3分别代表自报价、固定稿费、产品置换
-	StrategyID    string `json:"strategy_id"`    // 策略id
-	FollowersLow  string `json:"followers_low"`  // 达人粉丝数下限
-	FollowersUp   string `json:"followers_up"`   // 达人粉丝数上限
-	RecruitNumber string `json:"recruit_number"` // 招募数量
-	Offer         string `json:"offer"`          // 报价
+	RecruitStrategyID string `json:"recruit_strategy_id"`
+	FeeForm           string `json:"fee_form"`       // 稿费形式，1-3分别代表自报价、固定稿费、产品置换
+	StrategyID        string `json:"strategy_id"`    // 策略id
+	FollowersLow      string `json:"followers_low"`  // 达人粉丝数下限
+	FollowersUp       string `json:"followers_up"`   // 达人粉丝数上限
+	RecruitNumber     string `json:"recruit_number"` // 招募数量
+	Offer             string `json:"offer"`          // 报价
+	ServiceCharge     int64  `json:"service_charge"`
+	SelectedNumber    int64  `json:"selected_number"`
+	WaitingNumber     int64  `json:"waiting_number"`   // 待发货
+	DeliveredNumber   int64  `json:"delivered_number"` // 已发货
+	SignedNumber      int64  `json:"signed_number"`    // 已签收
 }
 
 type ShowProjectData struct {
 	ProjectName      string                `json:"project_name"`      // 项目名称
 	ProjectStatus    string                `json:"project_status"`    // 项目状态，1-7分别代表创建中、待审核、招募中、待支付、失效、执行中、已结案
 	ProjectType      string                `json:"project_type"`      // 项目类型，1代表全流程项目，2代表专项项目
-	ProjectPlatform  string                `json:"project_platform"`  // 项目平台，1-7分别代表红book、抖音、微博、快手、b站、大众点评、知乎
+	ProjectPlatform  string                `json:"project_platform"`  // 项目平台，1-7分别代表小红书、抖音、微博、快手、b站、大众点评、知乎
 	ProjectForm      string                `json:"project_form"`      // 项目形式，1-4分别代表实体商品寄拍、虚拟产品测评、线下探店打卡、素材微原创
 	TalentType       string                `json:"talent_type"`       // 达人类型
 	RecruitDdl       time.Time             `json:"recruit_ddl"`       // 招募截止时间
@@ -32,9 +38,10 @@ type ShowProjectData struct {
 	EnterpriseID     string                `json:"enterprise_id"`     // 企业id
 	Balance          string                `json:"balance"`           //企业余额
 	ProjectID        string                `json:"project_id"`        // 项目id
-	CreateAt         time.Time             `json:"create_at"`         //创建时间
-	UpdateAt         time.Time             `json:"update_at"`         //更新时间
-	Phone            string                `json:"phone"`             //联系方式
+	FailReason       string                `json:"fail_reason"`
+	CreateAt         time.Time             `json:"create_at"` //创建时间
+	UpdateAt         time.Time             `json:"update_at"` //更新时间
+	Phone            string                `json:"phone"`     //联系方式
 }
 
 type ShowProjectRequest struct {

model/http_model/project_update.go

@@ -19,6 +19,7 @@ type UpdateRecruitStrategy struct {
 type UpdateProjectRequest struct {
 	ProjectForm      string                  `json:"project_form"`      // 项目形式，1-4分别代表实体商品寄拍、虚拟产品测评、线下探店打卡、素材微原创
 	TalentType       string                  `json:"talent_type"`       // 达人类型
+	ProjectStatus    int                     `json:"project_status"`    // 要保存的项目状态
 	RecruitDdl       time.Time               `json:"recruit_ddl"`       // 招募截止时间
 	ContentType      string                  `json:"content_type"`      // 内容形式，1代表图文，2代表视频
 	ProjectDetail    string                  `json:"project_detail"`    // 项目详情

model/http_model/review_number_info.go

@@ -0,0 +1,28 @@
+package http_model
+
+type GetReviewNumberInfoRequest struct {
+	ProjectId   int64  `json:"project_id"`   // 项目id
+	StrategyIds string `json:"strategy_ids"` // 招募策略id列表
+}
+
+type ReviewNumberInfo struct {
+	StrategyId           int64 `json:"strategy_id"`            // 招募策略id
+	ReviewNumber         int64 `json:"review_number"`          // 应审稿数量
+	ScriptUnreviewNumber int64 `json:"script_unreview_number"` // 脚本待审数量
+	ScriptPassedNumber   int64 `json:"script_passed_number"`   // 脚本已通过数量
+	SketchUnreviewNumber int64 `json:"sketch_unreview_number"` // 初稿待审数量
+	SketchPassedNumber   int64 `json:"sketch_passed_number"`   // 初稿已通过数量
+}
+
+type GetReviewNumberInfoData struct {
+	ReviewNumberInfoList []*ReviewNumberInfo `json:"number_info_list"`
+}
+
+func NewGetReviewNumberInfoRequest() *GetReviewNumberInfoRequest {
+	return new(GetReviewNumberInfoRequest)
+}
+func NewGetReviewNumberInfoResponse() *CommonResponse {
+	resp := new(CommonResponse)
+	resp.Data = new(GetReviewNumberInfoData)
+	return resp
+}

model/http_model/script_accept.go

@@ -0,0 +1,18 @@
+package http_model
+
+type AcceptScriptRequest struct {
+	TaskIds string `json:"task_id_list"` //任务id列表
+}
+
+type AcceptScriptData struct {
+	TaskIds []int `json:"task_id_list"` //任务id列表
+}
+
+func NewAcceptScriptRequest() *AcceptScriptRequest {
+	return new(AcceptScriptRequest)
+}
+func NewAcceptScriptResponse() *CommonResponse {
+	resp := new(CommonResponse)
+	resp.Data = new(AcceptScriptData)
+	return resp
+}

model/http_model/script_opinion.go

@@ -0,0 +1,20 @@
+package http_model
+
+type ScriptOpinionRequest struct {
+	StrategyID    int64  `json:"strategy_id"`    //招募策略id
+	TaskID        int64  `json:"task_id"`        //任务-id
+	ScriptOpinion string `json:"script_opinion"` //初稿意见
+}
+
+type ScriptOpinionData struct {
+	TaskID int64 `json:"task_id"` // 脚本ID
+}
+
+func NewScriptOpinionRequest() *ScriptOpinionRequest {
+	return new(ScriptOpinionRequest)
+}
+func NewScriptOpinionResponse() *CommonResponse {
+	resp := new(CommonResponse)
+	resp.Data = new(ScriptOpinionData)
+	return resp
+}