审稿管理、发布管理、数据与结案

config/mail.json

@@ -2,5 +2,5 @@
     "stmp_server": "smtp.qq.com",
     "stmp_port": "587",
     "stmp_user_name": "2467835131@qq.com",
-    "stmp_auth_token": "fqvrcfvlugygdjdc"
+    "stmp_auth_token": "ptpajplrcfhneaaa"
 }

db/data.go

@@ -0,0 +1,168 @@
+package db
+
+import (
+	"context"
+	"fmt"
+	"reflect"
+	"time"
+	"youngee_b_api/model/common_model"
+	"youngee_b_api/model/gorm_model"
+	"youngee_b_api/model/http_model"
+	"youngee_b_api/pack"
+	"youngee_b_api/util"
+
+	"github.com/issue9/conv"
+	"github.com/sirupsen/logrus"
+)
+
+// 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{})
+	// 根据Project条件过滤
+	conditionType := reflect.TypeOf(conditions).Elem()
+	conditionValue := reflect.ValueOf(conditions).Elem()
+	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
+		}
+		if !util.IsBlank(value) && tag != "platform_nickname" {
+			db = db.Where(fmt.Sprintf("%s = ?", tag), value.Interface())
+		} else if tag == "platform_nickname" {
+			continue
+		}
+	}
+	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{})
+
+	// 根据Project条件过滤
+	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) && tag == "platform_nickname" { // input:1		taskIdsbase:1,2,3    string
+			fmt.Printf("Test %s = ?\n", tag)
+			db1 = db1.Where(fmt.Sprintf("%s = ?", tag), value.Interface())
+		}
+	}
+	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)] = 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
+	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 {
+		fmt.Printf("taskData: %+v \n", *v)
+	}
+	// return fulltaskData, total, nil
+	return taskDatas, 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}).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 in ?", TaskIDs).Updates(gorm_model.YoungeeTaskInfo{TaskStage: 15}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Data db] Update YoungeeTaskInfo error,err:%+v", err)
+		return err
+	}
+	return nil
+}

db/link.go

@@ -0,0 +1,168 @@
+package db
+
+import (
+	"context"
+	"fmt"
+	"reflect"
+	"time"
+	"youngee_b_api/model/common_model"
+	"youngee_b_api/model/gorm_model"
+	"youngee_b_api/model/http_model"
+	"youngee_b_api/pack"
+	"youngee_b_api/util"
+
+	"github.com/issue9/conv"
+	"github.com/sirupsen/logrus"
+)
+
+// 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{})
+	// 根据Project条件过滤
+	conditionType := reflect.TypeOf(conditions).Elem()
+	conditionValue := reflect.ValueOf(conditions).Elem()
+	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
+		}
+		if !util.IsBlank(value) && tag != "platform_nickname" {
+			db = db.Where(fmt.Sprintf("%s = ?", tag), value.Interface())
+		} else if tag == "platform_nickname" {
+			continue
+		}
+	}
+	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{})
+
+	// 根据Project条件过滤
+	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) && tag == "platform_nickname" { // input:1		taskIdsbase:1,2,3    string
+			fmt.Printf("Test %s = ?\n", tag)
+			db1 = db1.Where(fmt.Sprintf("%s = ?", tag), value.Interface())
+		}
+	}
+	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)] = 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
+	}
+	var misNum int64
+	if totalLink > totalTask {
+		misNum = totalLink - totalTask
+	} else {
+		misNum = totalTask - totalLink
+	}
+	logrus.Println("totalLink,totalTalent,misNum:", totalLink, 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 TaskLinks []*http_model.TaskLink
+	var taskLinks []*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 {
+		fmt.Printf("taskLink: %+v \n", *v)
+	}
+	// return fulltaskLink, total, nil
+	return taskLinks, 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/script.go

@@ -30,9 +30,9 @@ func GetTaskScriptList(ctx context.Context, projectID string, pageSize, pageNum
 		if tag == "script_status" {
 			fmt.Printf("script %+v", value.Interface() == int64(2))
 			if value.Interface() == int64(2) {
-				db = db.Where("script_status>=? AND script_status < ?", 2, 5)
+				db = db.Where("task_stage = ?", 8)
 			} else {
-				db = db.Where("script_status =? ", 5)
+				db = db.Where("task_stage > ?", 8)
 			}
 			continue
 		}
@@ -75,7 +75,12 @@ func GetTaskScriptList(ctx context.Context, projectID string, pageSize, pageNum
 		}
 	}
 	var ScriptInfos []gorm_model.YounggeeScriptInfo
-	db1 = db1.Model(gorm_model.YounggeeScriptInfo{}).Where("task_id IN ? AND is_submit=? ", taskIds, 1).Find(&ScriptInfos)
+	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)] = ScriptInfo
@@ -125,30 +130,40 @@ func GetTaskScriptList(ctx context.Context, projectID string, pageSize, pageNum
 // ScriptOpinion 提交意见
 func ScriptOpinion(ctx context.Context, TaskID int, ReviseOpinion string) error {
 	db := GetReadDB(ctx)
-	err := db.Model(gorm_model.YounggeeScriptInfo{}).Where("task_id = ?", TaskID).Updates(map[string]interface{}{"revise_opinion": ReviseOpinion, "reject_at": time.Now(), "is_review": 0}).Error
+	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] call RevisieOpinion error,err:%+v", err)
+		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] call RevisieOpinion error,err:%+v", err)
+		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, TaskID int) error {
+func AcceptScript(ctx context.Context, TaskIDs []int) error {
 	db := GetReadDB(ctx)
-	err := db.Model(gorm_model.YounggeeScriptInfo{}).Where("task_id = ?", TaskID).Updates(map[string]interface{}{"is_ok": 1, "is_review": 1, "agree_at": time.Now()}).Error
+	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] call AcceptScript error,err:%+v", err)
+		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{ScriptStatus: 5}).Error
+	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] call AcceptScript  error,err:%+v", err)
+		logrus.WithContext(ctx).Errorf("[Script db] Update YoungeeTaskInfo error,err:%+v", err)
 		return err
 	}
 	return nil

db/sketch.go

@@ -30,9 +30,9 @@ func GetTaskSketchList(ctx context.Context, projectID string, pageSize, pageNum
 		if tag == "sketch_status" {
 			fmt.Printf("sketch %+v", value.Interface() == int64(0))
 			if value.Interface() == int64(0) {
-				db = db.Where("sketch_status>=? AND sketch_status < ?", 2, 5)
+				db = db.Where("task_stage = ?", 10)
 			} else {
-				db = db.Where("sketch_status =? ", 5)
+				db = db.Where("task_stage > ?", 10)
 			}
 			continue
 		}
@@ -63,19 +63,22 @@ func GetTaskSketchList(ctx context.Context, projectID string, pageSize, pageNum
 	db1 = db1.Debug().Model(gorm_model.YounggeeSketchInfo{})
 
 	// 根据Project条件过滤
-	conditionType2 := reflect.TypeOf(conditions).Elem()
-	conditionValue2 := reflect.ValueOf(conditions).Elem()
-	for i := 0; i < conditionType2.NumField(); i++ {
-		field := conditionType2.Field(i)
+	for i := 0; i < conditionType.NumField(); i++ {
+		field := conditionType.Field(i)
 		tag := field.Tag.Get("condition")
-		value := conditionValue2.FieldByName(field.Name)
+		value := conditionValue.FieldByName(field.Name)
 		if !util.IsBlank(value) && tag == "platform_nickname" { // input:1		taskIdsbase:1,2,3    string
 			fmt.Printf("Test %s = ?\n", tag)
 			db1 = db1.Where(fmt.Sprintf("%s = ?", tag), value.Interface())
 		}
 	}
 	var SketchInfos []gorm_model.YounggeeSketchInfo
-	db1 = db1.Model(gorm_model.YounggeeSketchInfo{}).Where("task_id IN ? AND is_submit=? ", taskIds, 1).Find(&SketchInfos)
+	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 {
@@ -128,30 +131,41 @@ func GetTaskSketchList(ctx context.Context, projectID string, pageSize, pageNum
 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 = ?", TaskID).Updates(map[string]interface{}{"revise_opinion": ReviseOpinion, "reject_at": time.Now(), "is_review": 1}).Error
+	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] call RevisieOption error,err:%+v", err)
+		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, TaskID int) error {
+func AcceptSketch(ctx context.Context, TaskIDs []int) error {
 	db := GetReadDB(ctx)
-	err := db.Model(gorm_model.YounggeeSketchInfo{}).Where("task_id = ?", TaskID).Updates(map[string]interface{}{"is_ok": 1, "is_review": 1, "agree_at": time.Now()}).Error
+	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] call AcceptSketch error,err:%+v", err)
+		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{SketchStatus: 5}).Error
+
+	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] call AcceptSketch  error,err:%+v", err)
+		logrus.WithContext(ctx).Errorf("[Sketch db] Update YoungeeTaskInfo error,err:%+v", err)
 		return err
 	}
 	return nil

handler/accept_data.go

@@ -0,0 +1,60 @@
+package handler
+
+import (
+	"youngee_b_api/consts"
+	"youngee_b_api/model/http_model"
+	"youngee_b_api/service"
+	"youngee_b_api/util"
+
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+	log "github.com/sirupsen/logrus"
+)
+
+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
+	h.resp.Data = data
+}
+
+func (h *AcceptDataHandler) checkParam() error {
+	return nil
+}

handler/accept_link.go

@@ -0,0 +1,90 @@
+package handler
+
+import (
+	"youngee_b_api/consts"
+	"youngee_b_api/model/http_model"
+	"youngee_b_api/service"
+	"youngee_b_api/util"
+
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+	log "github.com/sirupsen/logrus"
+)
+
+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/data_opinion.go

@@ -0,0 +1,90 @@
+package handler
+
+import (
+	"youngee_b_api/consts"
+	"youngee_b_api/model/http_model"
+	"youngee_b_api/service"
+	"youngee_b_api/util"
+
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+	log "github.com/sirupsen/logrus"
+)
+
+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/link_opinion.go

@@ -0,0 +1,90 @@
+package handler
+
+import (
+	"youngee_b_api/consts"
+	"youngee_b_api/model/http_model"
+	"youngee_b_api/service"
+	"youngee_b_api/util"
+
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+	log "github.com/sirupsen/logrus"
+)
+
+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/task_data_list.go

@@ -0,0 +1,77 @@
+package handler
+
+import (
+	"errors"
+	"fmt"
+	"youngee_b_api/consts"
+	"youngee_b_api/model/http_model"
+	"youngee_b_api/pack"
+	"youngee_b_api/service"
+	"youngee_b_api/util"
+
+	"github.com/gin-gonic/gin"
+	"github.com/issue9/conv"
+	"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
+}

model/common_model/talent_condition.go

@@ -5,6 +5,8 @@ type TalentConditions struct {
 	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"`       //初稿状态
 	StrategyId       int64  `condition:"strategy_id"`       // 策略ID
 	TaskId           string `condition:"task_id"`           // 任务ID
 	PlatformNickname string `condition:"platform_nickname"` // 账号昵称

model/gorm_model/data.go

@@ -0,0 +1,31 @@
+// Code generated by sql2gorm. DO NOT EDIT.
+package gorm_model
+
+import (
+	"time"
+)
+
+type YounggeeDataInfo struct {
+	DataID          int       `gorm:"column:data_id;primary_key;AUTO_INCREMENT"` // 脚本id
+	TaskID          int       `gorm:"column:task_id;NOT NULL"`                   // 任务id
+	PlayNumber      int       `gorm:"column:play_number;NOT NULL"`               // 播放量/阅读量
+	LikeNumber      int       `gorm:"column:like_number;NOT NULL"`               // 点赞数
+	CommentNumber   int       `gorm:"column:comment_number;NOT NULL"`            // 评论数
+	CollectNumber   int       `gorm:"column:collect_number;NOT NULL"`            // 收藏数
+	PhotoUrl        string    `gorm:"column:photo_url;NOT NULL"`                 // 数据截图url
+	ReviseOpinion   string    `gorm:"column:revise_opinion"`                     // 审核意见
+	IsSubmit        int       `gorm:"column:is_submit;NOT NULL"`                 // 是否提交
+	IsReview        int       `gorm:"column:is_review;default:0;NOT NULL"`       // 是否审核
+	IsOk            int       `gorm:"column:is_ok;NOT NULL"`                     // 是否合格
+	CreateAt        time.Time `gorm:"column:create_at;NOT NULL"`                 // 创建时间
+	SubmitAt        time.Time `gorm:"column:submit_at"`                          // 提交时间
+	AgreeAt         time.Time `gorm:"column:agree_at"`                           // 同意时间
+	RejectAt        time.Time `gorm:"column:reject_at"`                          // 驳回时间
+	AutoAgreeAt     time.Time `gorm:"column:auto_agree_at"`                      // 结案自动处理时间
+	AutoDataBreakAt time.Time `gorm:"column:auto_data_break_at"`                 // 结案违约自动处理时间
+}
+
+func (m *YounggeeDataInfo) TableName() string {
+	return "younggee_data_info"
+}
+

model/gorm_model/link.go

@@ -10,7 +10,6 @@ type YounggeeLinkInfo struct {
 	LinkID  int    `gorm:"column:link_id;primary_key;AUTO_INCREMENT"` // 链接id
 	TaskID  int    `gorm:"column:task_id;NOT NULL"`                   // 任务id
 	LinkUrl string `gorm:"column:link_url;NOT NULL"`                  // 上传链接url
-
 	PhotoUrl        string    `gorm:"column:photo_url;NOT NULL"`           // 上传截图url
 	ReviseOpinion   string    `gorm:"column:revise_opinion"`               // 审核意见
 	IsSubmit        int       `gorm:"column:is_submit;NOT NULL"`           // 是否提交

model/gorm_model/project_task.go

@@ -2,7 +2,7 @@
 package gorm_model
 
 import (
-"time"
+	"time"
 )
 
 type YoungeeTaskInfo struct {
@@ -18,7 +18,11 @@ type YoungeeTaskInfo struct {
 	SettleAmount           float64   `gorm:"column:settle_amount;NOT NULL"`                         // 达人实际所得（扣除违约扣款）
 	AllPayment             float64   `gorm:"column:all_payment;NOT NULL"`                           // 企业支付
 	RealPayment            float64   `gorm:"column:real_payment;NOT NULL"`                          // 企业实际支付（扣除违约扣款）
-	Penalty                int       `gorm:"column:penalty;NOT NULL"`                               // 违约扣款比例，百分之
+	ErrBreakRate           int       `gorm:"column:err_break_rate;default:0;NOT NULL"`              // 未上传类型违约扣款比例，百分之
+	ScriptBreakRate        int       `gorm:"column:script_break_rate;default:0;NOT NULL"`           // 脚本上传超时违约扣款比例，百分之
+	SketchBreakRate        int       `gorm:"column:sketch_break_rate;default:0;NOT NULL"`           // 初稿上传超时违约扣款比例，百分之
+	LinkBreakRate          int       `gorm:"column:link_break_rate;default:0;NOT NULL"`             // 链接上传超时违约扣款比例，百分之
+	DataBreakRate          int       `gorm:"column:data_break_rate;default:0;NOT NULL"`             // 数据上传超时违约扣款比例，百分之
 	FeeForm                int       `gorm:"column:fee_form;NOT NULL"`                              // 稿费形式，1,2,3分别代表产品置换、固定稿费、自报价
 	ServiceCharge          float64   `gorm:"column:service_charge"`                                 // 服务费
 	ServiceRate            int       `gorm:"column:service_rate"`                                   // 服务费率，千分之
@@ -31,10 +35,15 @@ type YoungeeTaskInfo struct {
 	CompleteDate           time.Time `gorm:"column:complete_date"`                                  // 结束时间
 	LogisticsStatus        int       `gorm:"column:logistics_status;default:1"`                     // 发货状态 1 待发货 2已发货 3 已签收
 	ScriptStatus           uint      `gorm:"column:script_status;default:1"`                        // 脚本上传状态 1-5分别代表待添加、已添加、待修改、已修改、已通过
-	SketchStatus           int       `gorm:"column:sketch_status"`                                  // 初稿上传状态 1-5分别代表待添加、已添加、待修改、已修改、已通过
+	SketchStatus           uint      `gorm:"column:sketch_status;default:1"`                        // 初稿上传状态 1-5分别代表待添加、已添加、待修改、已修改、已通过
+	UpdateAt               time.Time `gorm:"column:update_at"`                                      // 更新时间
+	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 {
 	return "youngee_task_info"
 }
+

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_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/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_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/script_accept.go

@@ -1,12 +1,11 @@
 package http_model
 
 type AcceptScriptRequest struct {
-	StrategyID int64 `json:"strategy_id"` //招募策略id
-	TaskID     int64 `json:"task_id"`     //任务-id
+	TaskIds string `json:"task_id_list"` //任务id列表
 }
 
 type AcceptScriptData struct {
-	TaskID int64 `json:"task_id"` // 脚本ID
+	TaskIds []int `json:"task_id_list"` //任务id列表
 }
 
 func NewAcceptScriptRequest() *AcceptScriptRequest {

model/http_model/sketch_accept.go

@@ -1,12 +1,11 @@
 package http_model
 
 type AcceptSketchRequest struct {
-	StrategyID int64 `json:"strategy_id"` //招募策略id
-	TaskID     int64 `json:"task_id"`     //任务-id
+	TaskIds string `json:"task_id_list"` //任务id列表
 }
 
 type AcceptSketchData struct {
-	TaskID int64 `json:"task_id"` // 脚本ID
+	TaskIds []int `json:"task_id_list"` //任务id列表
 }
 
 func NewAcceptSketchRequest() *AcceptSketchRequest {

model/http_model/task_data.go

@@ -0,0 +1,76 @@
+package http_model
+
+import (
+	"time"
+	"youngee_b_api/model/gorm_model"
+)
+
+type TaskDataListRequest struct {
+	PageSize         int64  `json:"page_size"`
+	PageNum          int64  `json:"page_num"`
+	ProjectId        string `json:"project_id"`        // 项目ID
+	TaskId           string `json:"task_id"`           // 任务ID
+	StrategyId       string `json:"strategy_id"`       // 策略ID
+	DataStatus       string `json:"data_status"`       // 稿件状态
+	PlatformNickname string `json:"platform_nickname"` // 账号昵称
+}
+
+type TaskDataPreview struct {
+	TaskID            string  `json:"task_id"`             // 任务ID
+	PlatformNickname  string  `json:"platform_nickname"`   // 账号昵称
+	FansCount         string  `json:"fans_count"`          // 粉丝数
+	RecruitStrategyID string  `json:"recruit_strategy_id"` // 招募策略ID
+	StrategyID        string  `json:"strategy_id"`         // 报名选择的招募策略id
+	PlayNumber        int     `json:"play_number"`         // 播放量/阅读量
+	LikeNumber        int     `json:"like_number"`         // 点赞数
+	CommentNumber     int     `json:"comment_number"`      // 评论数
+	CollectNumber     int     `json:"collect_number"`      // 收藏数
+	PhotoUrl          string  `json:"photo_url"`           // 数据截图url
+	AllPayment        float64 `json:"all_payment"`         // 企业支付
+	RealPayment       float64 `json:"real_payment"`        // 企业实际支付（扣除违约扣款）
+	Submit            string  `json:"submit_at"`           // 提交时间
+	AgreeAt           string  `json:"agree_at"`            // 同意时间
+	ReviseOpinion     string  `json:"revise_opinion"`      // 审稿意见
+}
+
+type TaskDataInfo struct {
+	TaskID            int       `json:"task_id"`             // 任务ID
+	PlatformNickname  string    `json:"platform_nickname"`   // 账号昵称
+	FansCount         string    `json:"fans_count"`          // 粉丝数
+	RecruitStrategyID int       `json:"recruit_strategy_id"` // 招募策略ID
+	StrategyID        int       `json:"strategy_id"`         // 报名选择的招募策略id
+	DataId            int       `json:"data_id"`             // 数据ID
+	PlayNumber        int       `json:"play_number"`         // 播放量/阅读量
+	LikeNumber        int       `json:"like_number"`         // 点赞数
+	CommentNumber     int       `json:"comment_number"`      // 评论数
+	CollectNumber     int       `json:"collect_number"`      // 收藏数
+	PhotoUrl          string    `json:"photo_url"`           // 数据截图url
+	AllPayment        float64   `json:"all_payment"`         // 企业支付
+	RealPayment       float64   `json:"real_payment"`        // 企业实际支付（扣除违约扣款）
+	ReviseOpinion     string    `json:"revise_opinion"`      // 审稿意见
+	CreateAt          time.Time `json:"create_at"`           // 创建时间
+	SubmitAt          time.Time `json:"submit_at"`           // 提交时间
+	AgreeAt           time.Time `json:"agree_at"`            // 同意时间
+	RejectAt          time.Time `json:"reject_at"`           // 拒绝时间
+	IsReview          int       `json:"is_review"`           // 是否审核
+}
+
+type TaskData struct {
+	Talent gorm_model.YoungeeTaskInfo
+	Data   gorm_model.YounggeeDataInfo
+}
+
+type TaskDataListData struct {
+	TaskDataPreview []*TaskDataPreview `json:"project_data_pre_view"`
+	Total           string             `json:"total"`
+}
+
+func NewTaskDataListRequest() *TaskDataListRequest {
+	return new(TaskDataListRequest)
+}
+
+func NewTaskDataListResponse() *CommonResponse {
+	resp := new(CommonResponse)
+	resp.Data = new(ProjectTaskListData)
+	return resp
+}

model/http_model/task_link.go

@@ -1,15 +1,55 @@
 package http_model
 
+import (
+	"time"
+	"youngee_b_api/model/gorm_model"
+)
+
 type TaskLinkListRequest struct {
 	PageSize         int64  `json:"page_size"`
 	PageNum          int64  `json:"page_num"`
 	ProjectId        string `json:"project_id"`        // 项目ID
 	TaskId           string `json:"task_id"`           // 任务ID
 	StrategyId       string `json:"strategy_id"`       // 策略ID
-	SketchStatus     string `json:"sketch_status"`     // 稿件状态
+	LinkStatus       string `json:"link_status"`       // 稿件状态
 	PlatformNickname string `json:"platform_nickname"` // 账号昵称
 }
 
+type TaskLinkPreview struct {
+	TaskID            string `json:"task_id"`             // 任务ID
+	PlatformNickname  string `json:"platform_nickname"`   // 账号昵称
+	FansCount         string `json:"fans_count"`          // 粉丝数
+	RecruitStrategyID string `json:"recruit_strategy_id"` //招募策略ID
+	StrategyID        string `json:"strategy_id"`         // 报名选择的招募策略id
+	LinkUrl           string `json:"link_url"`            // 上传链接url
+	PhotoUrl          string `json:"photo_url"`           // 上传截图url
+	Submit            string `json:"link_upload_time"`    //创建时间
+	AgreeAt           string `json:"agree_at"`            //同意时间
+	ReviseOpinion     string `json:"revise_opinion"`      //审稿意见
+}
+
+type TaskLinkInfo struct {
+	TaskID            int       `json:"task_id"`           // 任务ID
+	PlatformNickname  string    `json:"platform_nickname"` // 账号昵称
+	FansCount         string    `json:"fans_count"`        // 粉丝数
+	RecruitStrategyID int       `json:"recruit_strategy_id"`
+	StrategyID        int       `json:"strategy_id"`    // 报名选择的招募策略id
+	LinkId            int       `json:"link_id"`        //链接ID
+	LinkUrl           string    `json:"link_url"`       // 上传链接url
+	PhotoUrl          string    `json:"photo_url"`      // 上传截图url
+	ReviseOpinion     string    `json:"revise_opinion"` //审稿意见
+	CreateAt          time.Time `json:"create_at"`      //创建时间
+	SubmitAt          time.Time `json:"submit_at"`      // 提交时间
+	AgreeAt           time.Time `json:"agree_at"`       //同意时间
+	RejectAt          time.Time `json:"reject_at"`      //拒绝时间
+	IsReview          int       `json:"is_review"`      //是否审核
+}
+
+type TaskLink struct {
+	Talent gorm_model.YoungeeTaskInfo
+	Link   gorm_model.YounggeeLinkInfo
+}
+
 type TaskLinkListData struct {
 	TaskLinkPreview []*TaskLinkPreview `json:"project_link_pre_view"`
 	Total           string             `json:"total"`

model/http_model/task_script.go

@@ -26,7 +26,6 @@ type TaskScriptPreview struct {
 	AgreeAt           string `json:"agree_at"`            //同意时间
 	Content           string `json:"content"`             //脚本内容
 	ReviseOpinion     string `json:"revise_opinion"`      //审稿意见
-
 }
 
 type TaskScriptInfo struct {

pack/task_data_list.go

@@ -0,0 +1,73 @@
+package pack
+
+import (
+	"youngee_b_api/model/http_model"
+
+	"github.com/tidwall/gjson"
+
+	"github.com/issue9/conv"
+)
+
+func MGormTaskDataInfoListToHttpTaskDataPreviewList(gormTaskDataInfos []*http_model.TaskDataInfo) []*http_model.TaskDataPreview {
+	var httpProjectPreviews []*http_model.TaskDataPreview
+	for _, gormTaskDataInfo := range gormTaskDataInfos {
+		httpTaskDataPreview := MGormTaskDataInfoToHttpTaskDataPreview(gormTaskDataInfo)
+		httpProjectPreviews = append(httpProjectPreviews, httpTaskDataPreview)
+	}
+	return httpProjectPreviews
+}
+
+func MGormTaskDataInfoToHttpTaskDataPreview(TaskDataInfo *http_model.TaskDataInfo) *http_model.TaskDataPreview {
+	//deliveryTime := conv.MustString(TaskDataInfo.DeliveryTime)
+	//deliveryTime = deliveryTime[0:19]
+	return &http_model.TaskDataPreview{
+		TaskID:            conv.MustString(TaskDataInfo.TaskID),
+		PlatformNickname:  conv.MustString(TaskDataInfo.PlatformNickname),
+		FansCount:         conv.MustString(TaskDataInfo.FansCount),
+		RecruitStrategyID: conv.MustString(TaskDataInfo.RecruitStrategyID),
+		StrategyID:        conv.MustString(TaskDataInfo.StrategyID),
+		PlayNumber:        TaskDataInfo.PlayNumber,
+		LikeNumber:        TaskDataInfo.LikeNumber,
+		CommentNumber:     TaskDataInfo.CommentNumber,
+		CollectNumber:     TaskDataInfo.CollectNumber,
+		PhotoUrl:          TaskDataInfo.PhotoUrl,
+		AllPayment:        TaskDataInfo.AllPayment,
+		RealPayment:       TaskDataInfo.RealPayment,
+		ReviseOpinion:     TaskDataInfo.ReviseOpinion,
+		Submit:            conv.MustString(TaskDataInfo.SubmitAt)[0:19],
+		AgreeAt:           conv.MustString(TaskDataInfo.AgreeAt)[0:19],
+	}
+}
+
+func TaskDataToTaskInfo(TaskDatas []*http_model.TaskData) []*http_model.TaskDataInfo {
+	var TaskDataInfos []*http_model.TaskDataInfo
+	for _, TaskData := range TaskDatas {
+		TaskData := GetDataInfoStruct(TaskData)
+		TaskDataInfos = append(TaskDataInfos, TaskData)
+	}
+	return TaskDataInfos
+}
+
+func GetDataInfoStruct(TaskData *http_model.TaskData) *http_model.TaskDataInfo {
+	TalentPlatformInfoSnap := TaskData.Talent.TalentPlatformInfoSnap
+	return &http_model.TaskDataInfo{
+		TaskID:           TaskData.Talent.TaskID,
+		PlatformNickname: conv.MustString(gjson.Get(TalentPlatformInfoSnap, "PlatformInfo.platform_name")),
+		FansCount:        conv.MustString(gjson.Get(TalentPlatformInfoSnap, "fans_count")),
+		StrategyID:       TaskData.Talent.StrategyID,
+		DataId:           TaskData.Data.DataID,
+		PlayNumber:       TaskData.Data.PlayNumber,
+		LikeNumber:       TaskData.Data.LikeNumber,
+		CommentNumber:    TaskData.Data.CommentNumber,
+		CollectNumber:    TaskData.Data.CollectNumber,
+		PhotoUrl:         TaskData.Data.PhotoUrl,
+		AllPayment:       TaskData.Talent.AllPayment,
+		RealPayment:      TaskData.Talent.RealPayment,
+		ReviseOpinion:    TaskData.Data.ReviseOpinion,
+		CreateAt:         TaskData.Data.CreateAt,
+		SubmitAt:         TaskData.Data.SubmitAt,
+		AgreeAt:          TaskData.Data.AgreeAt,
+		RejectAt:         TaskData.Data.RejectAt,
+		IsReview:         TaskData.Data.IsReview,
+	}
+}

pack/task_data_list_conditions.go

@@ -0,0 +1,20 @@
+package pack
+
+import (
+	"fmt"
+	"youngee_b_api/model/common_model"
+	"youngee_b_api/model/http_model"
+
+	"github.com/issue9/conv"
+)
+
+func HttpTaskDataListRequestToCondition(req *http_model.TaskDataListRequest) *common_model.TalentConditions {
+	fmt.Printf("初稿转换 %+v", req)
+	return &common_model.TalentConditions{
+		ProjectId:        conv.MustInt64(req.ProjectId),
+		DataStatus:       conv.MustInt64(req.DataStatus),
+		StrategyId:       conv.MustInt64(req.StrategyId),
+		TaskId:           conv.MustString(req.TaskId),
+		PlatformNickname: conv.MustString(req.PlatformNickname),
+	}
+}

pack/task_link_list.go

@@ -0,0 +1,63 @@
+package pack
+
+import (
+	"youngee_b_api/model/http_model"
+
+	"github.com/tidwall/gjson"
+
+	"github.com/issue9/conv"
+)
+
+func MGormTaskLinkInfoListToHttpTaskLinkPreviewList(gormTaskLinkInfos []*http_model.TaskLinkInfo) []*http_model.TaskLinkPreview {
+	var httpProjectPreviews []*http_model.TaskLinkPreview
+	for _, gormTaskLinkInfo := range gormTaskLinkInfos {
+		httpTaskLinkPreview := MGormTaskLinkInfoToHttpTaskLinkPreview(gormTaskLinkInfo)
+		httpProjectPreviews = append(httpProjectPreviews, httpTaskLinkPreview)
+	}
+	return httpProjectPreviews
+}
+
+func MGormTaskLinkInfoToHttpTaskLinkPreview(TaskLinkInfo *http_model.TaskLinkInfo) *http_model.TaskLinkPreview {
+	//deliveryTime := conv.MustString(TaskLinkInfo.DeliveryTime)
+	//deliveryTime = deliveryTime[0:19]
+	return &http_model.TaskLinkPreview{
+		TaskID:            conv.MustString(TaskLinkInfo.TaskID),
+		PlatformNickname:  conv.MustString(TaskLinkInfo.PlatformNickname),
+		FansCount:         conv.MustString(TaskLinkInfo.FansCount),
+		RecruitStrategyID: conv.MustString(TaskLinkInfo.RecruitStrategyID),
+		StrategyID:        conv.MustString(TaskLinkInfo.StrategyID),
+		PhotoUrl:          TaskLinkInfo.PhotoUrl,
+		LinkUrl:           TaskLinkInfo.LinkUrl,
+		ReviseOpinion:     TaskLinkInfo.ReviseOpinion,
+		Submit:            conv.MustString(TaskLinkInfo.SubmitAt)[0:19],
+		AgreeAt:           conv.MustString(TaskLinkInfo.AgreeAt)[0:19],
+	}
+}
+
+func TaskLinkToTaskInfo(TaskLinks []*http_model.TaskLink) []*http_model.TaskLinkInfo {
+	var TaskLinkInfos []*http_model.TaskLinkInfo
+	for _, TaskLink := range TaskLinks {
+		TaskLink := GetLinkInfoStruct(TaskLink)
+		TaskLinkInfos = append(TaskLinkInfos, TaskLink)
+	}
+	return TaskLinkInfos
+}
+
+func GetLinkInfoStruct(TaskLink *http_model.TaskLink) *http_model.TaskLinkInfo {
+	TalentPlatformInfoSnap := TaskLink.Talent.TalentPlatformInfoSnap
+	return &http_model.TaskLinkInfo{
+		TaskID:           TaskLink.Talent.TaskID,
+		PlatformNickname: conv.MustString(gjson.Get(TalentPlatformInfoSnap, "PlatformInfo.platform_name")),
+		FansCount:        conv.MustString(gjson.Get(TalentPlatformInfoSnap, "fans_count")),
+		StrategyID:       TaskLink.Talent.StrategyID,
+		LinkId:           TaskLink.Link.LinkID,
+		PhotoUrl:         TaskLink.Link.PhotoUrl,
+		LinkUrl:          TaskLink.Link.LinkUrl,
+		ReviseOpinion:    TaskLink.Link.ReviseOpinion,
+		CreateAt:         TaskLink.Link.CreateAt,
+		SubmitAt:         TaskLink.Link.SubmitAt,
+		AgreeAt:          TaskLink.Link.AgreeAt,
+		RejectAt:         TaskLink.Link.RejectAt,
+		IsReview:         TaskLink.Link.IsReview,
+	}
+}

pack/task_link_list_conditions.go

@@ -0,0 +1,20 @@
+package pack
+
+import (
+	"fmt"
+	"youngee_b_api/model/common_model"
+	"youngee_b_api/model/http_model"
+
+	"github.com/issue9/conv"
+)
+
+func HttpTaskLinkListRequestToCondition(req *http_model.TaskLinkListRequest) *common_model.TalentConditions {
+	fmt.Printf("初稿转换 %+v", req)
+	return &common_model.TalentConditions{
+		ProjectId:        conv.MustInt64(req.ProjectId),
+		LinkStatus:       conv.MustInt64(req.LinkStatus),
+		StrategyId:       conv.MustInt64(req.StrategyId),
+		TaskId:           conv.MustString(req.TaskId),
+		PlatformNickname: conv.MustString(req.PlatformNickname),
+	}
+}

route/init.go

@@ -66,8 +66,11 @@ func InitRoute(r *gin.Engine) {
 		m.POST("/project/findsketchphoto", handler.WrapFindSketchPhotoHandler) //查询脚本配图和视频demo
 		m.POST("/project/sketchopinion", handler.WrapSketchOpinionHandler)     //脚本审核意见提交
 		m.POST("/project/acceptsketch", handler.WrapAcceptSketchHandler)       //同意脚本
-		m.POST("/project/tasklinklist", handler.WrapTaskLinkListHandler)       //查询脚本列表
-		//m.POST("/project/acceptsketch", handler.WrapAcceptSketchHandler)       //链接合格
-		//m.POST("/project/tasksketchlist", handler.WrapTaskSketchListHandler)
+		m.POST("/project/tasklinklist", handler.WrapTaskLinkListHandler)       //查询链接列表
+		m.POST("/project/linkopinion", handler.WrapLinkOpinionHandler)         //链接审核意见提交
+		m.POST("/project/acceptlink", handler.WrapAcceptLinkHandler)           //同意链接
+		m.POST("/project/taskdatalist", handler.WrapTaskDataListHandler)       //查询数据列表
+		m.POST("/project/dataopinion", handler.WrapDataOpinionHandler)         //数据审核意见提交
+		m.POST("/project/acceptdata", handler.WrapAcceptDataHandler)           //同意数据
 	}
 }

service/data.go

@@ -0,0 +1,57 @@
+package service
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"youngee_b_api/db"
+	"youngee_b_api/model/gorm_model"
+	"youngee_b_api/model/http_model"
+
+	"github.com/issue9/conv"
+	"github.com/sirupsen/logrus"
+)
+
+var Data *data
+
+type data struct {
+}
+
+// DataOpinion 在上传脚本表上提交修改意见
+func (*data) DataOpinion(ctx context.Context, request http_model.DataOpinionRequest) (*http_model.DataOpinionData, error) {
+	Data := gorm_model.YounggeeDataInfo{
+		TaskID:        conv.MustInt(request.TaskID),
+		ReviseOpinion: request.DataOpinion,
+	}
+	err := db.DataOpinion(ctx, Data.TaskID, Data.ReviseOpinion)
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Data service] call CreateData error,err:%+v", err)
+		return nil, err
+	}
+
+	res := &http_model.DataOpinionData{
+		TaskID: int64(Data.TaskID),
+	}
+	return res, nil
+}
+
+// AcceptData
+func (*data) AcceptData(ctx context.Context, request http_model.AcceptDataRequest) (*http_model.AcceptDataData, error) {
+	var TaskIDList []int
+	TaskIDs := strings.Split(request.TaskIds, ",")
+	for _, taskId := range TaskIDs {
+		TaskIDList = append(TaskIDList, conv.MustInt(taskId))
+	}
+
+	fmt.Printf("acc request %+v", TaskIDList)
+	err := db.AcceptData(ctx, TaskIDList)
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Data service] call CreateData error,err:%+v", err)
+		return nil, err
+	}
+
+	res := &http_model.AcceptDataData{
+		TaskIds: TaskIDList,
+	}
+	return res, nil
+}

service/link.go

@@ -0,0 +1,57 @@
+package service
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"youngee_b_api/db"
+	"youngee_b_api/model/gorm_model"
+	"youngee_b_api/model/http_model"
+
+	"github.com/issue9/conv"
+
+	"github.com/sirupsen/logrus"
+)
+
+var Link *link
+
+type link struct {
+}
+
+// LinkOpinion 在上传脚本表上提交修改意见
+func (*link) LinkOpinion(ctx context.Context, request http_model.LinkOpinionRequest) (*http_model.LinkOpinionData, error) {
+	Link := gorm_model.YounggeeLinkInfo{
+		TaskID:        conv.MustInt(request.TaskID),
+		ReviseOpinion: request.LinkOpinion,
+	}
+	err := db.LinkOpinion(ctx, Link.TaskID, Link.ReviseOpinion)
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Link service] call CreateLink error,err:%+v", err)
+		return nil, err
+	}
+
+	res := &http_model.LinkOpinionData{
+		TaskID: int64(Link.TaskID),
+	}
+	return res, nil
+}
+
+// AcceptLink
+func (*link) AcceptLink(ctx context.Context, request http_model.AcceptLinkRequest) (*http_model.AcceptLinkData, error) {
+	var TaskIDList []int
+	TaskIDs := strings.Split(request.TaskIds, ",")
+	for _, taskId := range TaskIDs {
+		TaskIDList = append(TaskIDList, conv.MustInt(taskId))
+	}
+	fmt.Printf("acc request %+v", TaskIDList)
+	err := db.AcceptLink(ctx, TaskIDList)
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Link service] call CreateLink error,err:%+v", err)
+		return nil, err
+	}
+
+	res := &http_model.AcceptLinkData{
+		TaskIds: TaskIDList,
+	}
+	return res, nil
+}

service/project.go

@@ -327,3 +327,27 @@ func (p *project) GetTaskSketchList(ctx *gin.Context, projectID string, pageSize
 	TaskSketchListData.Total = conv.MustString(total)
 	return TaskSketchListData, nil
 }
+
+func (p *project) GetTaskLinkList(ctx *gin.Context, projectID string, pageSize, pageNum int64, conditions *common_model.TalentConditions) (*http_model.TaskLinkListData, error) {
+	TaskLinks, total, err := db.GetTaskLinkList(ctx, projectID, pageSize, pageNum, conditions)
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[project service] call GetTaskLinkList error,err:%+v", err)
+		return nil, err
+	}
+	TaskLinkListData := new(http_model.TaskLinkListData)
+	TaskLinkListData.TaskLinkPreview = pack.MGormTaskLinkInfoListToHttpTaskLinkPreviewList(TaskLinks)
+	TaskLinkListData.Total = conv.MustString(total)
+	return TaskLinkListData, nil
+}
+
+func (p *project) GetTaskDataList(ctx *gin.Context, projectID string, pageSize, pageNum int64, conditions *common_model.TalentConditions) (*http_model.TaskDataListData, error) {
+	TaskDatas, total, err := db.GetTaskDataList(ctx, projectID, pageSize, pageNum, conditions)
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[project service] call GetTaskDataList error,err:%+v", err)
+		return nil, err
+	}
+	TaskDataListData := new(http_model.TaskDataListData)
+	TaskDataListData.TaskDataPreview = pack.MGormTaskDataInfoListToHttpTaskDataPreviewList(TaskDatas)
+	TaskDataListData.Total = conv.MustString(total)
+	return TaskDataListData, nil
+}

service/script.go

@@ -3,11 +3,13 @@ package service
 import (
 	"context"
 	"fmt"
-	"github.com/issue9/conv"
+	"strings"
 	"youngee_b_api/db"
 	"youngee_b_api/model/gorm_model"
 	"youngee_b_api/model/http_model"
 
+	"github.com/issue9/conv"
+
 	"github.com/sirupsen/logrus"
 )
 
@@ -36,18 +38,20 @@ func (*script) ScriptOpinion(ctx context.Context, request http_model.ScriptOpini
 
 // AcceptScript
 func (*script) AcceptScript(ctx context.Context, request http_model.AcceptScriptRequest) (*http_model.AcceptScriptData, error) {
-
-	TaskID := conv.MustInt(request.TaskID)
-
-	fmt.Printf("acc request %+v", TaskID)
-	err := db.AcceptScript(ctx, TaskID)
+	var TaskIDList []int
+	TaskIDs := strings.Split(request.TaskIds, ",")
+	for _, taskId := range TaskIDs {
+		TaskIDList = append(TaskIDList, conv.MustInt(taskId))
+	}
+	fmt.Printf("acc request %+v", TaskIDList)
+	err := db.AcceptScript(ctx, TaskIDList)
 	if err != nil {
 		logrus.WithContext(ctx).Errorf("[Script service] call CreateScript error,err:%+v", err)
 		return nil, err
 	}
 
 	res := &http_model.AcceptScriptData{
-		TaskID: int64(TaskID),
+		TaskIds: TaskIDList,
 	}
 	return res, nil
 }

service/sketch.go

@@ -3,11 +3,13 @@ package service
 import (
 	"context"
 	"fmt"
-	"github.com/issue9/conv"
+	"strings"
 	"youngee_b_api/db"
 	"youngee_b_api/model/gorm_model"
 	"youngee_b_api/model/http_model"
 
+	"github.com/issue9/conv"
+
 	"github.com/sirupsen/logrus"
 )
 
@@ -36,18 +38,20 @@ func (*sketch) SketchOption(ctx context.Context, request http_model.SketchOpinio
 
 // AcceptSketch 同意初稿
 func (*sketch) AcceptSketch(ctx context.Context, request http_model.AcceptSketchRequest) (*http_model.AcceptSketchData, error) {
-
-	TaskID := conv.MustInt(request.TaskID)
-
-	fmt.Printf("acc request %+v", TaskID)
-	err := db.AcceptSketch(ctx, TaskID)
+	var TaskIDList []int
+	TaskIDs := strings.Split(request.TaskIds, ",")
+	for _, taskId := range TaskIDs {
+		TaskIDList = append(TaskIDList, conv.MustInt(taskId))
+	}
+	fmt.Printf("acc request %+v", TaskIDList)
+	err := db.AcceptSketch(ctx, TaskIDList)
 	if err != nil {
 		logrus.WithContext(ctx).Errorf("[Sketch service] call CreateSketch error,err:%+v", err)
 		return nil, err
 	}
 
 	res := &http_model.AcceptSketchData{
-		TaskID: int64(TaskID),
+		TaskIds: TaskIDList,
 	}
 	return res, nil
 }