执行中、招募中

config/dev.yaml

@@ -1,12 +1,17 @@
+#mysql:
+#  host: 139.9.53.143
+#  port: 3306
+#  user: talent
+#  password: talentDB_123
+#  database: youngmini
 mysql:
-  host: 139.9.53.143
+  host: 1.92.142.62
   port: 3306
-  user: talent
-  password: talentDB_123
+  user: root
+  password: Younggee_root_DB_123
   database: youngmini
-
 redis:
-  host: 139.9.53.143
+  host: 1.92.142.62
   port: 6379
   auth: younggeeRedis_123
   database: 1

config/pro.yaml

@@ -17,15 +17,22 @@
 #   session:
 #     ttl: -1 #minute
 
+#mysql:
+#  host: 139.9.53.143
+#  port: 3306
+#  user: talent
+#  password: talentDB_123
+#  database: youngmini
 mysql:
-  host: 139.9.53.143
+  host: 1.92.142.62
   port: 3306
-  user: talent
-  password: talentDB_123
+  user: root
+  password: Younggee_root_DB_123
   database: youngmini
 
+
 redis:
-  host: 139.9.53.143
+  host: 1.92.142.62
   port: 6379
   auth: younggeeRedis_123
   database: 1

consts/error_code.go

@@ -7,15 +7,15 @@ var errorCodeToastMap = map[int32]string{}
 
 const DefaultToast = ""
 
-const ErrorSuccess int32 = 0
-const ErrorNotLogin int32 = 4001
-const ErrorParamCheck int32 = 5001
-const ErrorInternal int32 = 5001
+const ErrorSuccess int32 = 20000
+const ErrorNotLogin int32 = 44000
+const ErrorParamCheck int32 = 40000
+const ErrorInternal int32 = 50001
 
 func init() {
 	errorCodeToastMap[ErrorSuccess] = "请求成功"
 	errorCodeToastMap[ErrorNotLogin] = "请登录后操作"
-	errorCodeToastMap[ErrorParamCheck] = "参数有误"
+	errorCodeToastMap[ErrorParamCheck] = "error"
 	errorCodeToastMap[ErrorInternal] = "网络错误"
 }
 

db/data.go

@@ -185,6 +185,40 @@ func DataOpinion(ctx context.Context, TaskID string, ReviseOpinion string, opera
 	return nil
 }
 
+// DataOpinion 提交意见
+func LocalDataOpinion(ctx context.Context, TaskID string, ReviseOpinion string, operatorid string, operatetype int, projectid 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, "b_operator": operatorid, "b_operator_type": operatetype}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Data db] Update YounggeeDataInfo error,err:%+v", err)
+		return err
+	}
+	var project gorm_model.YounggeeLocalLifeInfo
+	err = db.Model(gorm_model.YounggeeLocalLifeInfo{}).Where("local_id = ?", projectid).Find(&project).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Sketch db] Find ProjectInfo error,err:%+v", err)
+		return err
+	}
+
+	var data_default gorm_model.InfoAutoTask
+	err = db.Model(gorm_model.InfoAutoTask{}).Where("auto_task_id = ?", project.AutoTaskId).Find(&data_default).Error
+	if err != nil {
+		return err
+	}
+	duration := time.Duration(data_default.CaseCloseDefault) * time.Hour
+	err = db.Model(gorm_model.YoungeeLocalTaskInfo{}).Where("task_id = ?", TaskID).Updates(gorm_model.YoungeeLocalTaskInfo{DataStatus: 3, CurBreakAt: time.Now().Add(duration)}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Data db] Update YoungeeLocalTaskInfo error,err:%+v", err)
+		return err
+	}
+	err = db.Model(gorm_model.YoungeeLocalTaskInfo{}).Where("task_id = ?", TaskID).Updates(gorm_model.YoungeeLocalTaskInfo{TaskStage: 13}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Data db] Update YoungeeLocalTaskInfo error,err:%+v", err)
+		return err
+	}
+	return nil
+}
+
 // AcceptData 同意数据-结案
 func AcceptData(ctx context.Context, TaskIDs []string, operatorid string, operatetype int) error {
 	db := GetReadDB(ctx)
@@ -230,6 +264,40 @@ func RejectData(ctx context.Context, TaskIDs []string, operatorid string, operat
 	return nil
 }
 
+// RejectData 拒绝数据-结案
+func LocalRejectData(ctx context.Context, TaskIDs []string, operatorid string, operatetype int, projectid string) error {
+	db := GetReadDB(ctx)
+	err := db.Model(gorm_model.YounggeeDataInfo{}).Where("task_id in ?  and is_review = 0", TaskIDs).Updates(map[string]interface{}{"reject_at": time.Now(), "is_review": 1, "b_operator": operatorid, "b_operator_type": operatetype}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Data db] Update YounggeeDataInfo error,err:%+v", err)
+		return err
+	}
+	var project gorm_model.YounggeeLocalLifeInfo
+	err = db.Model(gorm_model.YounggeeLocalLifeInfo{}).Where("local_id = ?", projectid).Find(&project).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Sketch db] Find ProjectInfo error,err:%+v", err)
+		return err
+	}
+
+	var data_default gorm_model.InfoAutoTask
+	err = db.Model(gorm_model.InfoAutoTask{}).Where("auto_task_id = ?", project.AutoTaskId).Find(&data_default).Error
+	if err != nil {
+		return err
+	}
+	duration := time.Duration(data_default.CaseCloseDefault) * time.Hour
+	err = db.Model(gorm_model.YoungeeLocalTaskInfo{}).Where("task_id IN ?", TaskIDs).Updates(gorm_model.YoungeeLocalTaskInfo{DataStatus: 3, CurBreakAt: time.Now().Add(duration)}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Data db] Update YoungeeLocalTaskInfo error,err:%+v", err)
+		return err
+	}
+	err = db.Model(gorm_model.YoungeeLocalTaskInfo{}).Where("task_id IN ?", TaskIDs).Updates(gorm_model.YoungeeLocalTaskInfo{TaskStage: 13}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Data db] Update YoungeeLocalTaskInfo error,err:%+v", err)
+		return err
+	}
+	return nil
+}
+
 // GetSpecialTaskDataList 专项任务-查询上传数据的task list
 func GetSpecialTaskDataList(ctx context.Context, projectID string, pageSize, pageNum int64, conditions *common_model.TalentConditions) ([]*http_model.SpecialTaskDataInfo, int64, error) {
 	db := GetReadDB(ctx)

db/link.go

@@ -161,6 +161,40 @@ func LinkOpinion(ctx context.Context, TaskID string, ReviseOpinion string, opera
 	return nil
 }
 
+// LinkOpinion 提交意见
+func LocalLinkOpinion(ctx context.Context, TaskID string, ReviseOpinion string, operatorid string, operatetype int, projectid 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, "b_operator": operatorid, "b_operator_type": operatetype}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Link db] Update YounggeeLinkInfo error,err:%+v", err)
+		return err
+	}
+	var project gorm_model.YounggeeLocalLifeInfo
+	err = db.Model(gorm_model.YounggeeLocalLifeInfo{}).Where("local_id = ?", projectid).Find(&project).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Sketch db] Find ProjectInfo error,err:%+v", err)
+		return err
+	}
+
+	var link_default gorm_model.InfoAutoTask
+	err = db.Model(gorm_model.InfoAutoTask{}).Where("auto_task_id = ?", project.AutoTaskId).Find(&link_default).Error
+	if err != nil {
+		return err
+	}
+	duration := time.Duration(link_default.LinkBreach) * time.Hour
+	err = db.Model(gorm_model.YoungeeLocalTaskInfo{}).Where("task_id = ?", TaskID).Updates(gorm_model.YoungeeLocalTaskInfo{LinkStatus: 3, CurBreakAt: time.Now().Add(duration)}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Link db] Update YoungeeTaskInfo error,err:%+v", err)
+		return err
+	}
+	err = db.Model(gorm_model.YoungeeLocalTaskInfo{}).Where("task_id = ?", TaskID).Updates(gorm_model.YoungeeLocalTaskInfo{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 []string, operatorid string, operatetype int, projectid string, isspecial int) error {
 	db := GetReadDB(ctx)
@@ -218,6 +252,64 @@ func AcceptLink(ctx context.Context, TaskIDs []string, operatorid string, operat
 	return nil
 }
 
+// AcceptLink 同意链接
+func LocalAcceptLink(ctx context.Context, TaskIDs []string, operatorid string, operatetype int, projectid string, isspecial 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(), "b_operator": operatorid, "b_operator_type": operatetype}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Link db] Update YounggeeLinkInfo error,err:%+v", err)
+		return err
+	}
+	var project gorm_model.YounggeeLocalLifeInfo
+	err = db.Model(gorm_model.YounggeeLocalLifeInfo{}).Where("local_id = ?", projectid).Find(&project).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Sketch db] Find YounggeeLocalLifeInfo error,err:%+v", err)
+		return err
+	}
+	taskstages := 13
+	nextstage := [6]int{0, 0, 0, 0, 0, 0} // 数组长度为6，表示6种工具 4,9,11,13
+	if isspecial == 1 {
+
+		toolList := strings.Split(project.Tools, ",")
+		for _, tool := range toolList {
+			// 将 tool 转换为整数
+			if t, err := strconv.Atoi(tool); err == nil && t >= 0 && t <= len(nextstage) {
+				nextstage[t-1] = 1
+			}
+		}
+		for i := 4; i < len(nextstage); i++ { // 从位置1开始
+			if nextstage[i] == 1 {
+				switch i {
+				case 4:
+					taskstages = 13
+				case 5:
+					taskstages = 15
+				}
+				break
+			}
+		}
+	}
+
+	var data_default gorm_model.InfoAutoTask
+	err = db.Model(gorm_model.InfoAutoTask{}).Where("auto_task_id = ?", project.AutoTaskId).Find(&data_default).Error
+	if err != nil {
+		return err
+	}
+	duration := time.Duration(data_default.CaseCloseDefault) * time.Hour
+
+	err = db.Model(gorm_model.YoungeeLocalTaskInfo{}).Where("task_id in ?", TaskIDs).Updates(gorm_model.YoungeeLocalTaskInfo{LinkStatus: 5, CurBreakAt: time.Now().Add(duration)}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Link db] Update YoungeeLocalTaskInfo error,err:%+v", err)
+		return err
+	}
+	err = db.Model(gorm_model.YoungeeLocalTaskInfo{}).Where("task_id in ?", TaskIDs).Updates(gorm_model.YoungeeLocalTaskInfo{TaskStage: taskstages}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Link db] Update YoungeeLocalTaskInfo error,err:%+v", err)
+		return err
+	}
+	return nil
+}
+
 // RejectLink 不同意链接
 func RejectLink(ctx context.Context, TaskIDs []string, operatorid string, operatetype int, projectid string) error {
 	db := GetReadDB(ctx)
@@ -252,6 +344,40 @@ func RejectLink(ctx context.Context, TaskIDs []string, operatorid string, operat
 	return nil
 }
 
+// RejectLink 不同意链接
+func LocalRejectLink(ctx context.Context, TaskIDs []string, operatorid string, operatetype int, projectid string) 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": 0, "is_review": 1, "reject_at": time.Now(), "b_operator": operatorid, "b_operator_type": operatetype}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Link db] Update YounggeeLinkInfo error,err:%+v", err)
+		return err
+	}
+	var project gorm_model.YounggeeLocalLifeInfo
+	err = db.Model(gorm_model.YounggeeLocalLifeInfo{}).Where("local_id = ?", projectid).Find(&project).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Sketch db] Find ProjectInfo error,err:%+v", err)
+		return err
+	}
+
+	var link_default gorm_model.InfoAutoTask
+	err = db.Model(gorm_model.InfoAutoTask{}).Where("auto_task_id = ?", project.AutoTaskId).Find(&link_default).Error
+	if err != nil {
+		return err
+	}
+	duration := time.Duration(link_default.LinkBreach) * time.Hour
+	err = db.Model(gorm_model.YoungeeLocalTaskInfo{}).Where("task_id in ?", TaskIDs).Updates(gorm_model.YoungeeLocalTaskInfo{LinkStatus: 3, CurBreakAt: time.Now().Add(duration)}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Link db] Update YoungeeLocalTaskInfo error,err:%+v", err)
+		return err
+	}
+	err = db.Model(gorm_model.YoungeeLocalTaskInfo{}).Where("task_id in ?", TaskIDs).Updates(gorm_model.YoungeeLocalTaskInfo{TaskStage: 11}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Link db] Update YoungeeLocalTaskInfo error,err:%+v", err)
+		return err
+	}
+	return nil
+}
+
 // GetSpecialTaskLinkList 专项任务-查询上传链接的task list
 func GetSpecialTaskLinkList(ctx context.Context, projectID string, pageSize, pageNum int64, conditions *common_model.TalentConditions) ([]*http_model.SpecialTaskLinkInfo, int64, error) {
 	db := GetReadDB(ctx)

db/locallife_task.go

@@ -0,0 +1,822 @@
+package db
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"github.com/issue9/conv"
+	"github.com/sirupsen/logrus"
+	"gorm.io/gorm"
+	"strconv"
+	"strings"
+	"time"
+	"youngee_b_api/model/gorm_model"
+	"youngee_b_api/model/http_model"
+)
+
+func GetLocallifetaskList(ctx context.Context, request http_model.GetLocalTaskListRequest) (*http_model.GetLocalTaskListData, error) {
+	db := GetReadDB(ctx)
+	var projecrtaskinfo []gorm_model.YoungeeLocalTaskInfo
+	query := db.Model(&gorm_model.YoungeeLocalTaskInfo{}).Where("local_id = ? AND task_status = ?", request.ProjectId, request.CoopType)
+	fmt.Println(query)
+	// 构建查询条件
+	if request.FeeFrom != nil {
+		query = query.Where("fee_form = ?", request.FeeFrom)
+	}
+	if request.Type != nil {
+		switch *request.Type {
+		case 1:
+			query = query.Where("supplier_id = 0 AND supplier_status = 0")
+		case 2:
+			query = query.Where("supplier_id !=0 AND supplier_status = 2")
+		}
+	}
+	if request.TalentFromList != "" {
+		citylist := strings.Split(request.TalentFromList, ",")
+		query = query.Where("city in ?", citylist)
+	}
+	// 计算总数
+	var total int64
+	if err := query.Count(&total).Error; err != nil {
+		return nil, err
+	}
+
+	// 添加分页逻辑
+	pageSize := request.PageSize
+	if pageSize == 0 {
+		pageSize = 10
+	}
+	pageNum := request.PageNum
+	if pageNum == 0 {
+		pageNum = 1
+	}
+	offset := (pageNum - 1) * pageSize
+
+	// 执行分页查询
+	if err := query.Offset(offset).Limit(pageSize).Find(&projecrtaskinfo).Error; err != nil {
+		return nil, err
+	}
+	taskInfoPointers := make([]*http_model.LocaLTaskInfo, 0, len(projecrtaskinfo))
+	for _, task := range projecrtaskinfo {
+		var Time time.Time
+		switch request.CoopType {
+		case 1:
+			Time = task.CreateDate
+		case 2:
+			Time = task.SelectDate //2 signedtime
+		case 3:
+			Time = task.CompleteDate
+		}
+		boperator := getBOperator(db, task.BOperator, task.BOperatorType)
+		nickname, headurl := getTalentinfo(db, task.TalentId)
+		Iscoop := getIscoop(db, task.TalentId, request.EnterPriseId)
+		response := &http_model.LocaLTaskInfo{
+			TaskId:             task.TaskId,
+			ProjectId:          task.LocalId,
+			TalentId:           task.TalentId,
+			FansNum:            task.FansNum,
+			DraftFee:           task.DraftFee,
+			Voteavg:            task.VoteAvg,
+			FeeFrom:            task.FeeForm,
+			TaskStage:          task.TaskStage,
+			Commentavg:         task.CommitAvg,
+			CurrentDefaultType: task.CurDefaultType,
+			From:               determineFrom(task.SupplierId, task.SupplierStatus),
+			Boperator:          boperator,
+			CreateAt:           Time,
+			NickName:           nickname,
+			HeadUrl:            headurl,
+			ISCoop:             Iscoop,
+			Sprojectid:         task.SLocalLifeId,
+			City:               task.City,
+		}
+		taskInfoPointers = append(taskInfoPointers, response)
+	}
+
+	return &http_model.GetLocalTaskListData{
+		TaskList: taskInfoPointers,
+		Total:    conv.MustString(total, ""),
+	}, nil
+}
+
+func PassLocalTaskCoop(ctx context.Context, req http_model.PasslocalTaskCoopRequest) (bool, error) {
+	db := GetReadDB(ctx)
+	var count int64
+	fmt.Println("task_ids: ", req.TaskIds)
+	err := db.Model(gorm_model.YoungeeLocalTaskInfo{}).Where("task_id IN ? AND task_stage = 1", req.TaskIds).Count(&count).Error
+
+	fmt.Println("count: ", count)
+	if err != nil {
+		return false, err
+	}
+	if int64(len(req.TaskIds)) == 0 || count != int64(len(req.TaskIds)) {
+		return false, errors.New("任务id有误")
+	}
+
+	// 2. 查询任务对应达人id（用于生成达人消息）
+	var talentIds []string
+	err = db.Model(gorm_model.YoungeeLocalTaskInfo{}).Where("task_id IN ?", req.TaskIds).Select("talent_id").Find(&talentIds).Error
+	if err != nil {
+		return false, err
+	}
+
+	// 3. 查询任务对应project名称（用于生成达人消息）
+	var project gorm_model.YounggeeLocalLifeInfo
+	err = db.Model(gorm_model.YounggeeLocalLifeInfo{}).Where("local_id = ?", req.ProjectId).Find(&project).Error
+	if err != nil {
+		return false, err
+	}
+
+	var taskstages int
+	if project.TaskForm == 1 {
+		taskstages = 4
+	} else {
+		taskstages = 9
+	}
+
+	nextstage := [6]int{0, 0, 0, 0, 0, 0} // 数组长度为6，表示6种工具 4,9,11,13
+	if req.IsSpecial == 1 {
+		toolList := strings.Split(project.Tools, ",")
+		for _, tool := range toolList {
+			// 将 tool 转换为整数
+			if t, err := strconv.Atoi(tool); err == nil && t >= 0 && t <= len(nextstage) {
+				nextstage[t-1] = 1
+			}
+		}
+		fmt.Println(nextstage)
+		for i := 1; i < len(nextstage); i++ { // 从位置1开始
+			if nextstage[i] == 1 {
+				switch i {
+				case 1:
+					taskstages = 4
+				case 2:
+					taskstages = 9
+				case 3:
+					taskstages = 11
+				case 4:
+					taskstages = 13
+				case 5:
+					taskstages = 15
+				}
+				break
+			}
+		}
+	}
+
+	//4.根据达人来源改变状态、阶段、数目
+	var tasks []gorm_model.YoungeeLocalTaskInfo
+	err = db.Model(gorm_model.YoungeeLocalTaskInfo{}).Where("task_id IN ? AND task_stage = 1", req.TaskIds).Find(&tasks).Error
+	if err != nil {
+		return false, err
+	}
+	err = db.Transaction(func(tx *gorm.DB) error {
+		// 2. 修改任务状态和任务阶段
+		for _, taskInfo := range tasks {
+			if taskInfo.SupplierId != 0 && taskInfo.SupplierStatus == 2 { //服务商招募数量+1
+				updateData := gorm_model.YoungeeLocalTaskInfo{
+					TaskStage:     taskstages,
+					TaskStatus:    2,
+					UpdateAt:      time.Now(),
+					BOperator:     req.OperatorId,
+					BOperatorType: req.OperateType,
+					SelectDate:    time.Now(),
+				}
+				err = tx.Model(gorm_model.YoungeeLocalTaskInfo{}).Where("task_id = ? AND task_stage = 1", taskInfo.TaskId).Updates(updateData).Error
+				if err != nil {
+					return err
+				}
+
+				//project招募数+1,预估成本+服务商价格
+				var projectinfo gorm_model.YounggeeLocalLifeInfo
+				err = db.Model(gorm_model.YounggeeLocalLifeInfo{}).Where("local_id = ?", req.ProjectId).Find(&projectinfo).Error
+				if err != nil {
+					return err
+				}
+				projectinfo.RecruitNum += 1
+				projectinfo.EstimatedCost += taskInfo.SupportFee
+				err = tx.Model(gorm_model.YounggeeLocalLifeInfo{}).Where("local_id = ? ", req.ProjectId).Updates(projectinfo).Error
+				if err != nil {
+					return err
+				}
+				//服务商s_project已招募人数+1改成s_locallife
+				var sprojectinfo gorm_model.YounggeeSProjectInfo
+				err = db.Model(gorm_model.YounggeeSProjectInfo{}).Where(" s_project_id =?", req.SProjectId).Find(&sprojectinfo).Error
+				if err != nil {
+					return err
+				}
+				sprojectinfo.RecruitNum += 1
+				fmt.Println("......", projectinfo.RecruitNum)
+				err = tx.Model(gorm_model.YounggeeSProjectInfo{}).Where(" s_project_id =?", req.SProjectId).Updates(sprojectinfo).Error
+				if err != nil {
+					return err
+				} //
+
+			}
+
+			//if project.TaskForm != 1 { //素材分发
+			//	var draft_default gorm_model.InfoAutoTask
+			//	err = db.Model(gorm_model.InfoAutoTask{}).Where("auto_task_id = ?", project.AutoTaskId).Find(&draft_default).Error
+			//	if err != nil {
+			//		return err
+			//	}
+			//	duration := time.Duration(draft_default.DraftDefault) * time.Hour
+			//	upbreakdate := gorm_model.YoungeeLocalTaskInfo{
+			//		CurBreakAt: time.Now().Add(duration),
+			//	}
+			//	err = tx.Model(gorm_model.YoungeeLocalTaskInfo{}).Where("task_id = ? ", taskInfo.TaskId).Updates(upbreakdate).Error
+			//	if err != nil {
+			//		return err
+			//	}
+			//}
+
+			if taskInfo.SupplierId == 0 && taskInfo.SupplierStatus == 0 { //来源于公海
+				updateData := gorm_model.YoungeeLocalTaskInfo{
+					TaskStage:     taskstages,
+					TaskStatus:    2,
+					UpdateAt:      time.Now(),
+					BOperator:     req.OperatorId,
+					BOperatorType: req.OperateType,
+					SelectDate:    time.Now(),
+				}
+				err = tx.Model(gorm_model.YoungeeLocalTaskInfo{}).Where("task_id = ? AND task_stage = 1", taskInfo.TaskId).Updates(updateData).Error
+				if err != nil {
+					return err
+				}
+
+				//project招募数+1
+				var projectinfo gorm_model.YounggeeLocalLifeInfo
+				err = db.Model(gorm_model.YounggeeLocalLifeInfo{}).Where("local_id = ?", req.ProjectId).Find(&projectinfo).Error
+				if err != nil {
+					return err
+				}
+				projectinfo.RecruitNum += 1
+				err = tx.Model(gorm_model.YounggeeLocalLifeInfo{}).Where("local_id = ? ", req.ProjectId).Updates(projectinfo).Error
+				if err != nil {
+					return err
+				}
+			}
+
+		}
+		// 4. 生成达人消息
+		for _, talendId := range talentIds {
+			err = CreateMessage(ctx, 1, 1, talendId, project.LocalName)
+			if err != nil {
+				return err
+			}
+		}
+		// 返回 nil 提交事务
+		return nil
+	})
+	if err != nil {
+		return false, err
+	}
+	return true, nil
+}
+
+func RefuseLocalTaskCoop(ctx context.Context, req http_model.RefuselocalTaskCoopRequest) (bool, error) {
+	db := GetWriteDB(ctx)
+	// 1. 校验
+	var count int64
+	err := db.Model(gorm_model.YoungeeLocalTaskInfo{}).Where("task_id IN ? AND task_stage = 1", req.TaskIds).Count(&count).Error
+	if err != nil {
+		return false, err
+	}
+	if count != int64(len(req.TaskIds)) {
+		return false, errors.New("任务id有误")
+	}
+
+	// 2. 查询任务对应达人id（用于生成达人消息）
+	var talentIds []string
+	err = db.Model(gorm_model.YoungeeLocalTaskInfo{}).Where("task_id IN ?", req.TaskIds).Select("talent_id").Find(&talentIds).Error
+	if err != nil {
+		return false, err
+	}
+
+	var tasks []gorm_model.YoungeeLocalTaskInfo
+	err = db.Model(gorm_model.YoungeeLocalTaskInfo{}).Where("task_id IN ? AND task_stage = 1", req.TaskIds).Find(&tasks).Error
+
+	err = db.Transaction(func(tx *gorm.DB) error {
+		// 2. 修改任务状态和任务阶段
+		for _, taskInfo := range tasks {
+			updateData := gorm_model.YoungeeLocalTaskInfo{
+				TaskStage:     3,
+				TaskStatus:    3,
+				UpdateAt:      time.Now(),
+				BOperator:     req.OperatorId,
+				BOperatorType: req.OperateType,
+				CompleteDate:  time.Now(),
+			}
+			err = tx.Model(gorm_model.YoungeeLocalTaskInfo{}).Where("task_id = ? AND task_stage = 1", taskInfo.TaskId).Updates(updateData).Error
+		}
+		if err != nil {
+			return err
+		}
+
+		// 返回 nil 提交事务
+		return nil
+	})
+	if err != nil {
+		return false, err
+	}
+	return true, nil
+}
+
+func GetLocallifeData(ctx context.Context, req http_model.LocallifeDataRequest) (http_model.LocallifeDataResponse, error) {
+	db := GetReadDB(ctx)
+	var projectInfo gorm_model.YounggeeLocalLifeInfo
+	// 查询项目基本信息
+	if err := db.Where("local_id = ?", req.LocallifeId).First(&projectInfo).Error; err != nil {
+		logrus.WithContext(ctx).Errorf("[Locallife db] GetLocallifeData error, err: %+v", err)
+		return http_model.LocallifeDataResponse{}, err
+	}
+	fmt.Println("projectInfo---", projectInfo.LocalId)
+	var projectTasks []gorm_model.YoungeeLocalTaskInfo
+	if err := db.Where("local_id = ? AND task_status = ?", req.LocallifeId, 2).Find(&projectTasks).Error; err != nil {
+		return http_model.LocallifeDataResponse{}, err
+	}
+
+	var totalTasks int64
+	if err := db.Model(&gorm_model.YoungeeLocalTaskInfo{}).Where("local_id = ? AND task_status = ?", req.LocallifeId, 2).Count(&totalTasks).Error; err != nil {
+		return http_model.LocallifeDataResponse{}, err
+	}
+
+	// 初始化统计数据
+	dateStats := make(map[string]int)
+	fansCounts := map[int64]int{0: 0, 1: 0, 2: 0, 3: 0}
+	feeCounts := map[int]int{1: 0, 2: 0, 3: 0}
+	startDate := *projectInfo.CreatedAt
+	endDate := time.Now()
+
+	// 填充日期统计
+	for d := startDate; d.Before(endDate) || d.Equal(endDate); d = d.Add(24 * time.Hour) {
+		dateStats[d.Format("2006-01-02")] = 0
+	}
+
+	var totalCost float64
+	var totalFans int
+	var serverTaskCount float64
+	var maleCount int64
+
+	// 处理每个任务
+	for _, task := range projectTasks {
+		totalCost += task.DraftFee
+		var talentInfo gorm_model.YoungeeTalentInfo
+
+		// 查询达人信息
+		if err := db.Where("id = ?", task.TalentId).First(&talentInfo).Error; err != nil {
+			logrus.WithContext(ctx).Errorf("[Locallife db] GetLocallifeData error, err: %+v", err)
+			return http_model.LocallifeDataResponse{}, err
+		}
+
+		// 统计性别
+		if talentInfo.Sex == 1 {
+			maleCount++
+		}
+		totalFans += task.FansNum
+
+		// 统计来自服务商的任务
+		if task.SupplierId != 0 && task.SupplierStatus == 2 {
+			serverTaskCount++
+		}
+
+		// 稿费形式统计
+		feeCounts[task.FeeForm]++
+
+		// 统计粉丝数
+		switch {
+		case task.FansNum < 10000:
+			fansCounts[0]++
+		case task.FansNum < 100000:
+			fansCounts[1]++
+		case task.FansNum < 1000000:
+			fansCounts[2]++
+		default:
+			fansCounts[3]++
+		}
+
+		SelectDate := task.SelectDate.Format("2006-01-02")
+		if _, exists := dateStats[SelectDate]; exists {
+			dateStats[SelectDate]++
+		}
+	}
+
+	// 计算平均值
+	var avgFansNum int
+	if totalTasks > 0 {
+		avgFansNum = totalFans / int(totalTasks)
+	} else {
+		avgFansNum = 0
+	}
+
+	var fromType float64
+	if totalTasks > 0 {
+		fromType = serverTaskCount / float64(totalTasks)
+	} else {
+		fromType = 0
+	}
+
+	var manRatio float64
+	if totalTasks > 0 {
+		manRatio = float64(maleCount) / float64(totalTasks)
+	} else {
+		manRatio = 0
+	}
+	// 构建响应
+	res := http_model.LocallifeDataResponse{
+		Recruittime: *projectInfo.PassAt,
+		RecruitDDl:  *projectInfo.RecruitDdl,
+		AgreeNum:    projectInfo.RecruitNum,
+		ApplyNum:    projectInfo.ApplyNum,
+		DraftFee:    totalCost,
+		AvgFansNum:  avgFansNum,
+		FromType:    fromType,
+		ManRatio:    manRatio,
+		DateStats:   dateStats,
+		FeeMap:      feeCounts,
+		FansMap:     fansCounts,
+	}
+	return res, nil
+}
+
+func GetLocalPreSketchList(ctx context.Context, request http_model.LocalPreSketchListRequest) (*http_model.GetLocalSketchTaskListData, error) {
+	db := GetReadDB(ctx)
+	var projecrtaskinfo []gorm_model.YoungeeLocalTaskInfo
+	query := db.Model(&gorm_model.YoungeeLocalTaskInfo{}).Where("local_id = ? AND task_stage = ?", request.ProjectId, request.ScriptStatus)
+	// 计算总数
+	var total int64
+	if err := query.Count(&total).Error; err != nil {
+		return nil, err
+	}
+
+	// 添加分页逻辑
+	pageSize := request.PageSize
+	if pageSize == 0 {
+		pageSize = 10
+	}
+	pageNum := request.PageNum
+	if pageNum == 0 {
+		pageNum = 1
+	}
+	offset := (pageNum - 1) * pageSize
+	// 执行分页查询
+	if err := query.Offset(offset).Limit(pageSize).Find(&projecrtaskinfo).Error; err != nil {
+		return nil, err
+	}
+	taskInfoPointers := make([]*http_model.LocalTasksketchInfo, 0, len(projecrtaskinfo))
+
+	for _, task := range projecrtaskinfo {
+		nickname, headurl := getTalentinfo(db, task.TalentId)
+		Iscoop := getIscoop(db, task.TalentId, request.EnterpriseId)
+		taskinfo := &http_model.LocaLTaskInfo{
+			TaskId:             task.TaskId,
+			ProjectId:          task.LocalId,
+			TalentId:           task.TalentId,
+			FansNum:            task.FansNum,
+			DraftFee:           task.DraftFee,
+			Voteavg:            task.VoteAvg,
+			FeeFrom:            task.FeeForm,
+			TaskStage:          task.TaskStage,
+			Commentavg:         task.CommitAvg,
+			CurrentDefaultType: task.CurDefaultType,
+			From:               determineFrom(task.SupplierId, task.SupplierStatus),
+			NickName:           nickname,
+			HeadUrl:            headurl,
+			ISCoop:             Iscoop,
+			City:               task.City,
+		}
+		response := &http_model.LocalTasksketchInfo{
+			Task: taskinfo,
+			DDl:  task.CurBreakAt,
+		}
+		taskInfoPointers = append(taskInfoPointers, response)
+
+	}
+	return &http_model.GetLocalSketchTaskListData{
+		TasksketchList: taskInfoPointers,
+		Total:          conv.MustString(total, ""),
+	}, nil
+}
+
+func GetLocalSketchList(ctx context.Context, request http_model.LocalTasksketchlistRequest) (*http_model.GetsketchlocaltaskListData, error) {
+	db := GetReadDB(ctx)
+	var projecrtaskinfo []gorm_model.YoungeeLocalTaskInfo
+	query := db.Model(&gorm_model.YoungeeLocalTaskInfo{}).Where("local_id = ? AND task_stage = ?", request.ProjectId, request.ScriptStatus)
+	// 计算总数
+	var total int64
+	if err := query.Count(&total).Error; err != nil {
+		return nil, err
+	}
+
+	// 添加分页逻辑
+	pageSize := request.PageSize
+	if pageSize == 0 {
+		pageSize = 10
+	}
+	pageNum := request.PageNum
+	if pageNum == 0 {
+		pageNum = 1
+	}
+	offset := (pageNum - 1) * pageSize
+	// 执行分页查询
+	if err := query.Offset(offset).Limit(pageSize).Find(&projecrtaskinfo).Error; err != nil {
+		return nil, err
+	}
+	taskInfoPointers := make([]*http_model.LocalTasksketchinfo, 0, len(projecrtaskinfo))
+	for _, task := range projecrtaskinfo {
+		nickname, headurl := getTalentinfo(db, task.TalentId)
+		taskinfo := &http_model.LocaLTaskInfo{
+			TaskId:             task.TaskId,
+			ProjectId:          task.LocalId,
+			TalentId:           task.TalentId,
+			FansNum:            task.FansNum,
+			DraftFee:           task.DraftFee,
+			Voteavg:            task.VoteAvg,
+			FeeFrom:            task.FeeForm,
+			TaskStage:          task.TaskStage,
+			Commentavg:         task.CommitAvg,
+			CurrentDefaultType: task.CurDefaultType,
+			From:               determineFrom(task.SupplierId, task.SupplierStatus),
+			NickName:           nickname,
+			HeadUrl:            headurl,
+			City:               task.City,
+		}
+		var sketchinfo gorm_model.YounggeeSketchInfo
+		err := db.Model(&gorm_model.YounggeeSketchInfo{}).Where("task_id = ? and is_review = 0", task.TaskId).First(&sketchinfo).Error
+		if err != nil {
+			return nil, err
+		}
+		boperator := getBOperator(db, task.BOperator, task.BOperatorType)
+		response := &http_model.LocalTasksketchinfo{
+			Task:     taskinfo,
+			SketchId: sketchinfo.SketchID,
+			SubmitAt: sketchinfo.SubmitAt,
+			AgreeAt:  sketchinfo.AgreeAt,
+			Operator: boperator,
+		}
+		taskInfoPointers = append(taskInfoPointers, response)
+
+	}
+	return &http_model.GetsketchlocaltaskListData{
+		LocalTasksketchList: taskInfoPointers,
+		Total:               conv.MustString(total, ""),
+	}, nil
+}
+
+func GetLocalPreLinkList(ctx context.Context, request http_model.LocalPreLinkListRequest) (*http_model.GetLocalPreLinkListData, error) {
+	db := GetReadDB(ctx)
+	var projecrtaskinfo []gorm_model.YoungeeLocalTaskInfo
+	query := db.Model(&gorm_model.YoungeeLocalTaskInfo{}).Where("local_id = ? AND task_stage = ?", request.ProjectId, request.LinkStatus)
+	// 计算总数
+	var total int64
+	if err := query.Count(&total).Error; err != nil {
+		return nil, err
+	}
+
+	// 添加分页逻辑
+	pageSize := request.PageSize
+	if pageSize == 0 {
+		pageSize = 10
+	}
+	pageNum := request.PageNum
+	if pageNum == 0 {
+		pageNum = 1
+	}
+	offset := (pageNum - 1) * pageSize
+	// 执行分页查询
+	if err := query.Offset(offset).Limit(pageSize).Find(&projecrtaskinfo).Error; err != nil {
+		return nil, err
+	}
+	taskInfoPointers := make([]*http_model.LocalTasklinkinfo, 0, len(projecrtaskinfo))
+	for _, task := range projecrtaskinfo {
+		nickname, headurl := getTalentinfo(db, task.TalentId)
+		Iscoop := getIscoop(db, task.TalentId, request.EnterpriseId)
+		taskinfo := &http_model.LocaLTaskInfo{
+			TaskId:             task.TaskId,
+			ProjectId:          task.LocalId,
+			TalentId:           task.TalentId,
+			FansNum:            task.FansNum,
+			DraftFee:           task.DraftFee,
+			Voteavg:            task.VoteAvg,
+			FeeFrom:            task.FeeForm,
+			TaskStage:          task.TaskStage,
+			Commentavg:         task.CommitAvg,
+			CurrentDefaultType: task.CurDefaultType,
+			From:               determineFrom(task.SupplierId, task.SupplierStatus),
+			NickName:           nickname,
+			HeadUrl:            headurl,
+			ISCoop:             Iscoop,
+			City:               task.City,
+		}
+		response := &http_model.LocalTasklinkinfo{
+			Task: taskinfo,
+			DDl:  task.CurBreakAt,
+		}
+		taskInfoPointers = append(taskInfoPointers, response)
+
+	}
+	return &http_model.GetLocalPreLinkListData{
+		TasklinkList: taskInfoPointers,
+		Total:        conv.MustString(total, ""),
+	}, nil
+}
+
+func GetLocalLinkList(ctx context.Context, request http_model.LocalTaskLinklistRequest) (*http_model.GetLocalTaskLinkListData, error) {
+	db := GetReadDB(ctx)
+	var projecrtaskinfo []gorm_model.YoungeeLocalTaskInfo
+	query := db.Model(&gorm_model.YoungeeLocalTaskInfo{}).Where("local_id = ? AND task_stage = ?", request.ProjectId, request.LinkStatus)
+	// 计算总数
+	var total int64
+	if err := query.Count(&total).Error; err != nil {
+		return nil, err
+	}
+
+	// 添加分页逻辑
+	pageSize := request.PageSize
+	if pageSize == 0 {
+		pageSize = 10
+	}
+	pageNum := request.PageNum
+	if pageNum == 0 {
+		pageNum = 1
+	}
+	offset := (pageNum - 1) * pageSize
+	// 执行分页查询
+	if err := query.Offset(offset).Limit(pageSize).Find(&projecrtaskinfo).Error; err != nil {
+		return nil, err
+	}
+	taskInfoPointers := make([]*http_model.LocalTaskLinkinfo, 0, len(projecrtaskinfo))
+	for _, task := range projecrtaskinfo {
+		nickname, headurl := getTalentinfo(db, task.TalentId)
+		Iscoop := getIscoop(db, task.TalentId, request.EnterpriseId)
+		taskinfo := &http_model.LocaLTaskInfo{
+			TaskId:             task.TaskId,
+			ProjectId:          task.LocalId,
+			TalentId:           task.TalentId,
+			FansNum:            task.FansNum,
+			DraftFee:           task.DraftFee,
+			Voteavg:            task.VoteAvg,
+			FeeFrom:            task.FeeForm,
+			TaskStage:          task.TaskStage,
+			Commentavg:         task.CommitAvg,
+			CurrentDefaultType: task.CurDefaultType,
+			From:               determineFrom(task.SupplierId, task.SupplierStatus),
+			NickName:           nickname,
+			HeadUrl:            headurl,
+			ISCoop:             Iscoop,
+			City:               task.City,
+		}
+		var linkinfo gorm_model.YounggeeLinkInfo
+		err := db.Model(&gorm_model.YounggeeLinkInfo{}).Where("task_id = ? and is_review = 0", task.TaskId).First(&linkinfo).Error
+		if err != nil {
+			return nil, err
+		}
+		boperator := getBOperator(db, task.BOperator, task.BOperatorType)
+		response := &http_model.LocalTaskLinkinfo{
+			Task:     taskinfo,
+			LinkId:   linkinfo.LinkID,
+			SubmitAt: linkinfo.SubmitAt,
+			AgreeAt:  linkinfo.AgreeAt,
+			LinkUrl:  linkinfo.LinkUrl,
+			PhotoUrl: linkinfo.PhotoUrl,
+			Operator: boperator,
+		}
+		taskInfoPointers = append(taskInfoPointers, response)
+
+	}
+	return &http_model.GetLocalTaskLinkListData{
+		LocalTaskLinklist: taskInfoPointers,
+		Total:             conv.MustString(total, ""),
+	}, nil
+}
+
+func GetLocalPreDataList(ctx context.Context, request http_model.LocalPreDataListRequest) (*http_model.GetLocalPreDataListData, error) {
+	db := GetReadDB(ctx)
+	var projecrtaskinfo []gorm_model.YoungeeLocalTaskInfo
+	query := db.Model(&gorm_model.YoungeeLocalTaskInfo{}).Where("local_id = ? AND task_stage = ?", request.ProjectId, request.DataStatus)
+	// 计算总数
+	var total int64
+	if err := query.Count(&total).Error; err != nil {
+		return nil, err
+	}
+
+	// 添加分页逻辑
+	pageSize := request.PageSize
+	if pageSize == 0 {
+		pageSize = 10
+	}
+	pageNum := request.PageNum
+	if pageNum == 0 {
+		pageNum = 1
+	}
+	offset := (pageNum - 1) * pageSize
+	// 执行分页查询
+	if err := query.Offset(offset).Limit(pageSize).Find(&projecrtaskinfo).Error; err != nil {
+		return nil, err
+	}
+	taskInfoPointers := make([]*http_model.LocalTaskdatainfo, 0, len(projecrtaskinfo))
+	for _, task := range projecrtaskinfo {
+		nickname, headurl := getTalentinfo(db, task.TalentId)
+		Iscoop := getIscoop(db, task.TalentId, request.EnterpriseId)
+		taskinfo := &http_model.LocaLTaskInfo{
+			TaskId:             task.TaskId,
+			ProjectId:          task.LocalId,
+			TalentId:           task.TalentId,
+			FansNum:            task.FansNum,
+			DraftFee:           task.DraftFee,
+			Voteavg:            task.VoteAvg,
+			FeeFrom:            task.FeeForm,
+			TaskStage:          task.TaskStage,
+			Commentavg:         task.CommitAvg,
+			CurrentDefaultType: task.CurDefaultType,
+			From:               determineFrom(task.SupplierId, task.SupplierStatus),
+			NickName:           nickname,
+			HeadUrl:            headurl,
+			ISCoop:             Iscoop,
+			City:               task.City,
+		}
+		response := &http_model.LocalTaskdatainfo{
+			Task: taskinfo,
+			DDl:  task.CurBreakAt,
+		}
+		taskInfoPointers = append(taskInfoPointers, response)
+
+	}
+	return &http_model.GetLocalPreDataListData{
+		TaskdataList: taskInfoPointers,
+		Total:        conv.MustString(total, ""),
+	}, nil
+}
+
+func GetLocalDataList(ctx context.Context, request http_model.LocalTaskDatalistRequest) (*http_model.GetLocalTaskDatalistData, error) {
+	db := GetReadDB(ctx)
+	var projecrtaskinfo []gorm_model.YoungeeLocalTaskInfo
+	query := db.Model(&gorm_model.YoungeeLocalTaskInfo{}).Where("local_id = ? AND task_stage = ?", request.ProjectId, request.DataStatus)
+	// 计算总数
+	var total int64
+	if err := query.Count(&total).Error; err != nil {
+		return nil, err
+	}
+
+	// 添加分页逻辑
+	pageSize := request.PageSize
+	if pageSize == 0 {
+		pageSize = 10
+	}
+	pageNum := request.PageNum
+	if pageNum == 0 {
+		pageNum = 1
+	}
+	offset := (pageNum - 1) * pageSize
+	// 执行分页查询
+	if err := query.Offset(offset).Limit(pageSize).Find(&projecrtaskinfo).Error; err != nil {
+		return nil, err
+	}
+	taskInfoPointers := make([]*http_model.LocalTaskDatainfo, 0, len(projecrtaskinfo))
+	for _, task := range projecrtaskinfo {
+		nickname, headurl := getTalentinfo(db, task.TalentId)
+		Iscoop := getIscoop(db, task.TalentId, request.EnterpriseId)
+		taskinfo := &http_model.LocaLTaskInfo{
+			TaskId:             task.TaskId,
+			ProjectId:          task.LocalId,
+			TalentId:           task.TalentId,
+			FansNum:            task.FansNum,
+			DraftFee:           task.DraftFee,
+			Voteavg:            task.VoteAvg,
+			FeeFrom:            task.FeeForm,
+			TaskStage:          task.TaskStage,
+			Commentavg:         task.CommitAvg,
+			CurrentDefaultType: task.CurDefaultType,
+			From:               determineFrom(task.SupplierId, task.SupplierStatus),
+			NickName:           nickname,
+			HeadUrl:            headurl,
+			ISCoop:             Iscoop,
+			City:               task.City,
+		}
+		var datainfo gorm_model.YounggeeDataInfo
+		err := db.Model(&gorm_model.YounggeeDataInfo{}).Where("task_id = ? and is_review = 0", task.TaskId).First(&datainfo).Error
+		if err != nil {
+			return nil, err
+		}
+		boperator := getBOperator(db, task.BOperator, task.BOperatorType)
+		response := &http_model.LocalTaskDatainfo{
+			Task:          taskinfo,
+			DataId:        datainfo.DataID,
+			SubmitAt:      datainfo.SubmitAt,
+			AgreeAt:       datainfo.AgreeAt,
+			PhotoUrl:      datainfo.PhotoUrl,
+			PlayNumber:    datainfo.PlayNumber,
+			LikeNumber:    datainfo.LikeNumber,
+			CollectNumber: datainfo.CollectNumber,
+			CommentNumber: datainfo.CommentNumber,
+			SettleAmount:  task.SettleAmount,
+			Breakrate:     task.SketchBreakRate + task.LinkBreakRate + task.DataBreakRate,
+			Operator:      boperator,
+		}
+		taskInfoPointers = append(taskInfoPointers, response)
+
+	}
+	return &http_model.GetLocalTaskDatalistData{
+		LocalTaskDatalist: taskInfoPointers,
+		Total:             conv.MustString(total, ""),
+	}, nil
+}

db/project_task.go

@@ -56,12 +56,12 @@ func GetProjecttaskList(ctx context.Context, request http_model.GetTaskListReque
 	taskInfoPointers := make([]*http_model.TaskInfo, 0, len(projecrtaskinfo))
 	for _, task := range projecrtaskinfo {
 		var Time time.Time
-		switch *request.Type {
-		case 0:
-			Time = task.CreateDate
+		switch request.CoopType {
 		case 1:
-			Time = task.SignedTime
+			Time = task.CreateDate
 		case 2:
+			Time = task.SelectDate //2 signedtime
+		case 3:
 			Time = task.CompleteDate
 		}
 		boperator := getBOperator(db, task.BOperator, task.BOperatorType)
@@ -79,12 +79,14 @@ func GetProjecttaskList(ctx context.Context, request http_model.GetTaskListReque
 			Commentavg:         task.CommitAvg,
 			CurrentDefaultType: task.CurDefaultType,
 			From:               determineFrom(task.SupplierId, task.SupplierStatus),
+			SType:              stype(db, task.SupplierId, task.SupplierStatus),
 			Boperator:          boperator,
 			CreateAt:           Time,
 			NickName:           nickname,
 			HeadUrl:            headurl,
 			ISCoop:             Iscoop,
 			Sprojectid:         task.SprojectId,
+			City:               task.City,
 		}
 		taskInfoPointers = append(taskInfoPointers, response)
 	}
@@ -142,6 +144,17 @@ func determineFrom(supplierID, supplierStatus int) int {
 	return 1
 }
 
+func stype(db *gorm.DB, supplierID, supplierStatus int) int {
+	if supplierID != 0 && supplierStatus == 2 {
+		var supplierinfo gorm_model.Supplier
+		err := db.Model(gorm_model.Supplier{}).Where("supplier_id = ?", supplierID).First(&supplierinfo).Error
+		if err != nil {
+			return 0
+		}
+		return supplierinfo.SupplierType
+	}
+	return 0
+}
 func PassProTaskCoop(ctx context.Context, projectId string, taskIds []string, operatorid string, operatetype int, Isspecial int, req http_model.PassproTaskCoopRequest) (bool, error) {
 	db := GetReadDB(ctx)
 	var count int64
@@ -319,7 +332,7 @@ func RefuseproTaskCoop(ctx context.Context, taskIds []string, operatorid string,
 	db := GetWriteDB(ctx)
 	// 1. 校验
 	var count int64
-	err := db.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id IN ? AND task_stage = 3", taskIds).Count(&count).Error
+	err := db.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id IN ? AND task_stage = 1", taskIds).Count(&count).Error
 	if err != nil {
 		return false, err
 	}
@@ -404,9 +417,11 @@ func GetPreSketchList(ctx context.Context, request http_model.PreSketchListReque
 			Commentavg:         task.CommitAvg,
 			CurrentDefaultType: task.CurDefaultType,
 			From:               determineFrom(task.SupplierId, task.SupplierStatus),
+			SType:              stype(db, task.SupplierId, task.SupplierStatus),
 			NickName:           nickname,
 			HeadUrl:            headurl,
 			ISCoop:             Iscoop,
+			City:               task.City,
 		}
 		response := &http_model.TasksketchInfo{
 			Task: taskinfo,
@@ -447,6 +462,7 @@ func GetSketchList(ctx context.Context, request http_model.TasksketchlistRequest
 	}
 	taskInfoPointers := make([]*http_model.Tasksketchinfo, 0, len(projecrtaskinfo))
 	for _, task := range projecrtaskinfo {
+		nickname, headurl := getTalentinfo(db, task.TalentID)
 		taskinfo := &http_model.TaskInfo{
 			TaskId:             task.TaskID,
 			ProjectId:          task.ProjectID,
@@ -459,6 +475,10 @@ func GetSketchList(ctx context.Context, request http_model.TasksketchlistRequest
 			Commentavg:         task.CommitAvg,
 			CurrentDefaultType: task.CurDefaultType,
 			From:               determineFrom(task.SupplierId, task.SupplierStatus),
+			SType:              stype(db, task.SupplierId, task.SupplierStatus),
+			NickName:           nickname,
+			HeadUrl:            headurl,
+			City:               task.City,
 		}
 		var sketchinfo gorm_model.YounggeeSketchInfo
 		err := db.Model(&gorm_model.YounggeeSketchInfo{}).Where("task_id = ? and is_review = 0", task.TaskID).First(&sketchinfo).Error
@@ -522,9 +542,11 @@ func GetPreLinkList(ctx context.Context, request http_model.PreLinkListRequest)
 			Commentavg:         task.CommitAvg,
 			CurrentDefaultType: task.CurDefaultType,
 			From:               determineFrom(task.SupplierId, task.SupplierStatus),
+			SType:              stype(db, task.SupplierId, task.SupplierStatus),
 			NickName:           nickname,
 			HeadUrl:            headurl,
 			ISCoop:             Iscoop,
+			City:               task.City,
 		}
 		response := &http_model.Tasklinkinfo{
 			Task: taskinfo,
@@ -579,9 +601,11 @@ func GetLinkList(ctx context.Context, request http_model.TaskLinklistRequest) (*
 			Commentavg:         task.CommitAvg,
 			CurrentDefaultType: task.CurDefaultType,
 			From:               determineFrom(task.SupplierId, task.SupplierStatus),
+			SType:              stype(db, task.SupplierId, task.SupplierStatus),
 			NickName:           nickname,
 			HeadUrl:            headurl,
 			ISCoop:             Iscoop,
+			City:               task.City,
 		}
 		var linkinfo gorm_model.YounggeeLinkInfo
 		err := db.Model(&gorm_model.YounggeeLinkInfo{}).Where("task_id = ? and is_review = 0", task.TaskID).First(&linkinfo).Error
@@ -647,9 +671,11 @@ func GetPreDataList(ctx context.Context, request http_model.PreDataListRequest)
 			Commentavg:         task.CommitAvg,
 			CurrentDefaultType: task.CurDefaultType,
 			From:               determineFrom(task.SupplierId, task.SupplierStatus),
+			SType:              stype(db, task.SupplierId, task.SupplierStatus),
 			NickName:           nickname,
 			HeadUrl:            headurl,
 			ISCoop:             Iscoop,
+			City:               task.City,
 		}
 		response := &http_model.Taskdatainfo{
 			Task: taskinfo,
@@ -704,9 +730,11 @@ func GetDataList(ctx context.Context, request http_model.TaskDatalistRequest) (*
 			Commentavg:         task.CommitAvg,
 			CurrentDefaultType: task.CurDefaultType,
 			From:               determineFrom(task.SupplierId, task.SupplierStatus),
+			SType:              stype(db, task.SupplierId, task.SupplierStatus),
 			NickName:           nickname,
 			HeadUrl:            headurl,
 			ISCoop:             Iscoop,
+			City:               task.City,
 		}
 		var datainfo gorm_model.YounggeeDataInfo
 		err := db.Model(&gorm_model.YounggeeDataInfo{}).Where("task_id = ? and is_review = 0", task.TaskID).First(&datainfo).Error

db/sketch.go

@@ -166,6 +166,42 @@ func SketchOption(ctx context.Context, TaskID string, ReviseOpinion string, oper
 	return nil
 }
 
+// SketchOption 提交意见
+func LocalSketchOption(ctx context.Context, TaskID string, ReviseOpinion string, operatorid string, operatetype int, projectid 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, "b_operator": operatorid, "b_operator_type": operatetype}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Sketch db] call RevisieOption error,err:%+v", err)
+		return err
+	}
+	var project gorm_model.YounggeeLocalLifeInfo
+	err = db.Model(gorm_model.YounggeeLocalLifeInfo{}).Where("local_id = ?", projectid).Find(&project).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Sketch db] Find ProjectInfo error,err:%+v", err)
+		return err
+	}
+
+	var draft_default gorm_model.InfoAutoTask
+	err = db.Model(gorm_model.InfoAutoTask{}).Where("auto_task_id = ?", project.AutoTaskId).Find(&draft_default).Error
+	if err != nil {
+		return err
+	}
+
+	duration := time.Duration(draft_default.DraftDefault) * time.Hour
+	err = db.Model(gorm_model.YoungeeLocalTaskInfo{}).Where("task_id = ?", TaskID).Updates(gorm_model.YoungeeLocalTaskInfo{SketchStatus: 3, CurBreakAt: time.Now().Add(duration)}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Sketch db] Update YoungeeTaskInfo error,err:%+v", err)
+		return err
+	}
+	err = db.Model(gorm_model.YoungeeLocalTaskInfo{}).Where("task_id = ?", TaskID).Updates(gorm_model.YoungeeLocalTaskInfo{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 []string, operatorid string, operatetype int, projectid string, isspecial int) error {
 	db := GetReadDB(ctx)
@@ -226,6 +262,66 @@ func AcceptSketch(ctx context.Context, TaskIDs []string, operatorid string, oper
 	return nil
 }
 
+// AcceptSketch 同意初稿
+func LocalAcceptSketch(ctx context.Context, TaskIDs []string, operatorid string, operatetype int, projectid string, isspecial 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(), "b_operator": operatorid, "b_operator_type": operatetype}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Sketch db] Update YounggeeSketchInfo error,err:%+v", err)
+		return err
+	}
+
+	var project gorm_model.YounggeeLocalLifeInfo
+	err = db.Model(gorm_model.YounggeeLocalLifeInfo{}).Where("LocalId = ?", projectid).Find(&project).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Sketch db] Find ProjectInfo error,err:%+v", err)
+		return err
+	}
+	taskstages := 11
+	nextstage := [6]int{0, 0, 0, 0, 0, 0} // 数组长度为6，表示6种工具 4,9,11,13
+	if isspecial == 1 {
+
+		toolList := strings.Split(project.Tools, ",")
+		for _, tool := range toolList {
+			// 将 tool 转换为整数
+			if t, err := strconv.Atoi(tool); err == nil && t >= 0 && t <= len(nextstage) {
+				nextstage[t-1] = 1
+			}
+		}
+		for i := 3; i < len(nextstage); i++ { // 从位置1开始
+			if nextstage[i] == 1 {
+				switch i {
+				case 3:
+					taskstages = 11
+				case 4:
+					taskstages = 13
+				case 5:
+					taskstages = 15
+				}
+				break
+			}
+		}
+	}
+	var link_default gorm_model.InfoAutoTask
+	err = db.Model(gorm_model.InfoAutoTask{}).Where("auto_task_id = ?", project.AutoTaskId).Find(&link_default).Error //待确认
+	if err != nil {
+		return err
+	}
+	duration := time.Duration(link_default.LinkBreach) * time.Hour
+	err = db.Model(gorm_model.YoungeeLocalTaskInfo{}).Where("task_id in ?", TaskIDs).Updates(gorm_model.YoungeeLocalTaskInfo{SketchStatus: 5, CurBreakAt: time.Now().Add(duration)}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Sketch db] Update YoungeeTaskInfo error,err:%+v", err)
+		return err
+	}
+
+	err = db.Model(gorm_model.YoungeeLocalTaskInfo{}).Where("task_id in ?", TaskIDs).Updates(gorm_model.YoungeeLocalTaskInfo{TaskStage: taskstages}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Sketch db] Update YoungeeTaskInfo error,err:%+v", err)
+		return err
+	}
+	return nil
+}
+
 // RejectSketch 不同意初稿
 func RejectSketch(ctx context.Context, TaskIDs []string, operatorid string, operatetype int, projectid string) error {
 	db := GetReadDB(ctx)
@@ -262,6 +358,42 @@ func RejectSketch(ctx context.Context, TaskIDs []string, operatorid string, oper
 	return nil
 }
 
+// RejectSketch 不同意初稿
+func LocalRejectSketch(ctx context.Context, TaskIDs []string, operatorid string, operatetype int, projectid string) 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": 0, "is_review": 1, "reject_at": time.Now(), "b_operator": operatorid, "b_operator_type": operatetype}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Sketch db] Update YounggeeSketchInfo error,err:%+v", err)
+		return err
+	}
+
+	var project gorm_model.YounggeeLocalLifeInfo
+	err = db.Model(gorm_model.YounggeeLocalLifeInfo{}).Where("LocalId = ?", projectid).Find(&project).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Sketch db] Update YounggeeLocalLifeInfo error,err:%+v", err)
+		return err
+	}
+
+	var draft_default gorm_model.InfoAutoTask
+	err = db.Model(gorm_model.InfoAutoTask{}).Where("auto_task_id = ?", project.AutoTaskId).Find(&draft_default).Error
+	if err != nil {
+		return err
+	}
+	duration := time.Duration(draft_default.DraftDefault) * time.Hour
+	err = db.Model(gorm_model.YoungeeLocalTaskInfo{}).Where("task_id in ?", TaskIDs).Updates(gorm_model.YoungeeLocalTaskInfo{SketchStatus: 3, CurBreakAt: time.Now().Add(duration)}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Sketch db] Update YounggeeLocalLifeInfo error,err:%+v", err)
+		return err
+	}
+
+	err = db.Model(gorm_model.YoungeeLocalTaskInfo{}).Where("task_id in ?", TaskIDs).Updates(gorm_model.YoungeeLocalTaskInfo{TaskStage: 9}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Sketch db] Update YounggeeLocalLifeInfo error,err:%+v", err)
+		return err
+	}
+	return nil
+}
+
 // FindPhoto
 func FindSketchInfo(ctx context.Context, TaskID string) (*gorm_model.YounggeeSketchInfo, error) {
 	db := GetReadDB(ctx)

db/task.go

@@ -2,7 +2,6 @@ package db
 
 import (
 	"context"
-	"encoding/json"
 	"fmt"
 	"reflect"
 	"strconv"
@@ -187,33 +186,128 @@ func SetTaskFinish(ctx context.Context, TaskIDs []string) error {
 			return err1
 		}
 
-		// 2. 创建任务收益
-		var productStruct gorm_model.YounggeeProduct
-		if err = json.Unmarshal([]byte(projectInfo.ProductSnap), &productStruct); err != nil {
-			fmt.Println("Error:", err)
+		//// 2. 创建任务收益
+		//var productStruct gorm_model.YounggeeProduct
+		//if err = json.Unmarshal([]byte(projectInfo.ProductSnap), &productStruct); err != nil {
+		//	fmt.Println("Error:", err)
+		//	return err
+		//}
+		//var productPhotoStruct []gorm_model.YounggeeProductPhoto
+		//if err = json.Unmarshal([]byte(projectInfo.ProductPhotoSnap), &productPhotoStruct); err != nil {
+		//	fmt.Println("Error:", err)
+		//	return err
+		//}
+		//var mainPhoto = ""
+		//for _, w := range productPhotoStruct {
+		//	if w.Symbol == 1 {
+		//		mainPhoto = w.PhotoUrl
+		//	}
+		//}
+
+		t := time.Now()
+		income := gorm_model.YounggeeTalentIncome{
+			TalentID:  taskInfo.TalentID,
+			ProjectID: taskInfo.ProjectID,
+			TaskID:    taskInfo.TaskID,
+			Type:      1,
+			//BrandName:      productStruct.BrandName,
+			TaskName: projectInfo.ProjectName,
+			//PhotoUrl:       mainPhoto,
+			Income:         strconv.FormatFloat(taskInfo.SettleAmount, 'f', 10, 32),
+			IncomeType:     1,
+			WithdrawStatus: 1,
+			IncomeAt:       &t,
+			WithdrawAt:     nil,
+		}
+		err = CreateIncome(ctx, income, nil)
+		if err != nil {
+			logrus.WithContext(ctx).Errorf("[projectPay service] call SpecialSettlePay error,err:%+v", err)
 			return err
 		}
-		var productPhotoStruct []gorm_model.YounggeeProductPhoto
-		if err = json.Unmarshal([]byte(projectInfo.ProductPhotoSnap), &productPhotoStruct); err != nil {
-			fmt.Println("Error:", err)
+
+		// 3. 修改招募策略表，更新粉丝量、播放量、点赞数、收藏数、评论数、总支付、结案数量
+		// 更新招募策略
+		db = GetReadDB(ctx)
+		db = db.Model(gorm_model.RecruitStrategy{}).Where("project_id = ? and strategy_id = ?", taskInfo.ProjectID, taskInfo.StrategyID)
+		fansCount, _ := strconv.Atoi(conv.MustString(gjson.Get(taskInfo.TalentPlatformInfoSnap, "fans_count")))
+		err = db.Updates(map[string]interface{}{
+			"fan_number":     gorm.Expr("fan_number + ?", fansCount),
+			"play_number":    gorm.Expr("play_number + ?", dataInfo.PlayNumber),
+			"like_number":    gorm.Expr("like_number + ?", dataInfo.LikeNumber),
+			"collect_number": gorm.Expr("collect_number + ?", dataInfo.CollectNumber),
+			"comment_number": gorm.Expr("comment_number + ?", dataInfo.CommentNumber),
+			"finish_number":  gorm.Expr("finish_number + 1"),
+			"total_offer":    gorm.Expr("total_offer + ?", taskInfo.RealPayment)}).Error
+		if err != nil {
+			logrus.WithContext(ctx).Errorf("[Task db] Update YounggeeDataInfo error,err:%+v", err)
 			return err
 		}
-		var mainPhoto = ""
-		for _, w := range productPhotoStruct {
-			if w.Symbol == 1 {
-				mainPhoto = w.PhotoUrl
-			}
+	}
+	return nil
+}
+
+// SetTaskFinish 任务结案
+func SetLocalTaskFinish(ctx context.Context, TaskIDs []string) error {
+	db := GetReadDB(ctx)
+	// 1. 修改任务表，更新任务阶段为已结案，结案方式为正常结束，数据状态为已通过，
+	err := db.Model(gorm_model.YoungeeLocalTaskInfo{}).Where("task_id in ?", TaskIDs).Updates(gorm_model.YoungeeLocalTaskInfo{DataStatus: 5, TaskStage: 15, CompleteStatus: 2, WithdrawStatus: 2, CompleteDate: time.Now(), SettleStatus: 2}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Task db] Update YoungeeTaskInfo error,err:%+v", err)
+		return err
+	}
+
+	for _, v := range TaskIDs {
+		// 查询task_info
+		db = GetReadDB(ctx)
+		taskInfo := gorm_model.YoungeeLocalTaskInfo{}
+		err1 := db.Model(gorm_model.YoungeeLocalTaskInfo{}).Where("task_id = ?", v).Scan(&taskInfo).Error
+		if err1 != nil {
+			logrus.WithContext(ctx).Errorf("[Task db] Find YoungeeTaskInfo error,err:%+v", err)
+			return err1
+		}
+		//查询project_info
+		projectInfo := gorm_model.YounggeeLocalLifeInfo{}
+		err1 = db.Model(gorm_model.YounggeeLocalLifeInfo{}).Where("project_id = ?", taskInfo.LocalId).Scan(&projectInfo).Error
+		if err1 != nil {
+			logrus.WithContext(ctx).Errorf("[Task db] Find ProjectInfo error,err:%+v", err)
+			return err1
+		}
+		// 查询data_info
+		db = GetReadDB(ctx)
+		dataInfo := gorm_model.YounggeeDataInfo{}
+		err1 = db.Model(gorm_model.YounggeeDataInfo{}).Where("task_id = ? and is_ok = 1", v).Scan(&dataInfo).Error
+		if err1 != nil {
+			logrus.WithContext(ctx).Errorf("[Task db] Find YounggeeDataInfo error,err:%+v", err)
+			return err1
 		}
 
+		// 2. 创建任务收益
+		//var productStruct gorm_model.YounggeeProduct
+		//if err = json.Unmarshal([]byte(projectInfo.ProductSnap), &productStruct); err != nil {
+		//	fmt.Println("Error:", err)
+		//	return err
+		//}
+		//var productPhotoStruct []gorm_model.YounggeeProductPhoto
+		//if err = json.Unmarshal([]byte(projectInfo.ProductPhotoSnap), &productPhotoStruct); err != nil {
+		//	fmt.Println("Error:", err)
+		//	return err
+		//}
+		//var mainPhoto = ""
+		//for _, w := range productPhotoStruct {
+		//	if w.Symbol == 1 {
+		//		mainPhoto = w.PhotoUrl
+		//	}
+		//}
+
 		t := time.Now()
 		income := gorm_model.YounggeeTalentIncome{
-			TalentID:       taskInfo.TalentID,
-			ProjectID:      taskInfo.ProjectID,
-			TaskID:         taskInfo.TaskID,
-			Type:           1,
-			BrandName:      productStruct.BrandName,
-			TaskName:       projectInfo.ProjectName,
-			PhotoUrl:       mainPhoto,
+			TalentID:  taskInfo.TalentId,
+			ProjectID: taskInfo.LocalId,
+			TaskID:    taskInfo.TaskId,
+			Type:      1,
+			//BrandName:      productStruct.BrandName,
+			TaskName: projectInfo.LocalName,
+			//PhotoUrl:       mainPhoto,
 			Income:         strconv.FormatFloat(taskInfo.SettleAmount, 'f', 10, 32),
 			IncomeType:     1,
 			WithdrawStatus: 1,
@@ -229,7 +323,7 @@ func SetTaskFinish(ctx context.Context, TaskIDs []string) error {
 		// 3. 修改招募策略表，更新粉丝量、播放量、点赞数、收藏数、评论数、总支付、结案数量
 		// 更新招募策略
 		db = GetReadDB(ctx)
-		db = db.Model(gorm_model.RecruitStrategy{}).Where("project_id = ? and strategy_id = ?", taskInfo.ProjectID, taskInfo.StrategyID)
+		db = db.Model(gorm_model.RecruitStrategy{}).Where("project_id = ? and strategy_id = ?", taskInfo.LocalId, taskInfo.StrategyId)
 		fansCount, _ := strconv.Atoi(conv.MustString(gjson.Get(taskInfo.TalentPlatformInfoSnap, "fans_count")))
 		err = db.Updates(map[string]interface{}{
 			"fan_number":     gorm.Expr("fan_number + ?", fansCount),
@@ -259,6 +353,122 @@ func SetSpecialTaskFinish(ctx context.Context, TaskIDs []string) error {
 	return nil
 }
 
+// SetSpecialTaskSettleNum 结案人数+1
+func SetSpecialTaskSettleNum(ctx context.Context, TaskIDs []string) error {
+	db := GetReadDB(ctx)
+	//4.根据达人来源改变状态、阶段、数目
+	var tasks []gorm_model.YoungeeTaskInfo
+	err := db.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id IN ? ", TaskIDs).Find(&tasks).Error
+	if err != nil {
+		return err
+	}
+	for _, taskInfo := range tasks {
+		if taskInfo.SupplierId != 0 && taskInfo.SupplierStatus == 2 {
+			//project招募数+1,预估成本+服务商价格
+			var projectinfo gorm_model.ProjectInfo
+			err = db.Model(gorm_model.ProjectInfo{}).Where("project_id = ?", taskInfo.ProjectID).Find(&projectinfo).Error
+			if err != nil {
+				return err
+			}
+			projectinfo.SettleNum += 1
+			err = db.Model(gorm_model.ProjectInfo{}).Where("project_id = ? ", taskInfo.ProjectID).Updates(projectinfo).Error
+			if err != nil {
+				return err
+			}
+			//服务商s_project已招募人数+1
+			var sprojectinfo gorm_model.YounggeeSProjectInfo
+			err = db.Model(gorm_model.YounggeeSProjectInfo{}).Where(" s_project_id =?", taskInfo.SprojectId).Find(&sprojectinfo).Error
+			if err != nil {
+				return err
+			}
+			sprojectinfo.RecruitNum += 1
+			fmt.Println("......", projectinfo.RecruitNum)
+			err = db.Model(gorm_model.YounggeeSProjectInfo{}).Where(" s_project_id =?", taskInfo.SprojectId).Updates(sprojectinfo).Error
+			if err != nil {
+				return err
+			}
+		}
+		if taskInfo.SupplierId == 0 && taskInfo.SupplierStatus == 0 {
+			//project招募数+1
+			var projectinfo gorm_model.ProjectInfo
+			err = db.Model(gorm_model.ProjectInfo{}).Where("project_id = ?", taskInfo.ProjectID).Find(&projectinfo).Error
+			if err != nil {
+				return err
+			}
+			projectinfo.RecruitNum += 1
+			err = db.Model(gorm_model.ProjectInfo{}).Where("project_id = ? ", taskInfo.ProjectID).Updates(projectinfo).Error
+			if err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+// SetSpecialTaskSettleNum 结案人数+1
+func SetSpecialLocalTaskSettleNum(ctx context.Context, TaskIDs []string) error {
+	db := GetReadDB(ctx)
+	//4.根据达人来源改变状态、阶段、数目
+	var tasks []gorm_model.YoungeeLocalTaskInfo
+	err := db.Model(gorm_model.YoungeeLocalTaskInfo{}).Where("task_id IN ? ", TaskIDs).Find(&tasks).Error
+	if err != nil {
+		return err
+	}
+	for _, taskInfo := range tasks {
+		if taskInfo.SupplierId != 0 && taskInfo.SupplierStatus == 2 {
+			//project招募数+1,预估成本+服务商价格
+			var projectinfo gorm_model.YounggeeLocalLifeInfo
+			err = db.Model(gorm_model.YounggeeLocalLifeInfo{}).Where("local_id = ?", taskInfo.LocalId).Find(&projectinfo).Error
+			if err != nil {
+				return err
+			}
+			projectinfo.SettleNum += 1
+			err = db.Model(gorm_model.YounggeeLocalLifeInfo{}).Where("local_id = ? ", taskInfo.LocalId).Updates(projectinfo).Error
+			if err != nil {
+				return err
+			}
+			//服务商s_project已招募人数+1
+			var sprojectinfo gorm_model.YounggeeSLocalLifeInfo
+			err = db.Model(gorm_model.YounggeeSLocalLifeInfo{}).Where(" s_local_life_id =?", taskInfo.SLocalLifeId).Find(&sprojectinfo).Error
+			if err != nil {
+				return err
+			}
+			sprojectinfo.RecruitNum += 1
+			fmt.Println("......", projectinfo.RecruitNum)
+			err = db.Model(gorm_model.YounggeeSLocalLifeInfo{}).Where(" s_local_life_id =?", taskInfo.SLocalLifeId).Updates(sprojectinfo).Error
+			if err != nil {
+				return err
+			}
+		}
+		if taskInfo.SupplierId == 0 && taskInfo.SupplierStatus == 0 {
+			//project招募数+1
+			var projectinfo gorm_model.YounggeeLocalLifeInfo
+			err = db.Model(gorm_model.YounggeeLocalLifeInfo{}).Where("local_id = ?", taskInfo.LocalId).Find(&projectinfo).Error
+			if err != nil {
+				return err
+			}
+			projectinfo.RecruitNum += 1
+			err = db.Model(gorm_model.YounggeeLocalLifeInfo{}).Where("local_id = ? ", taskInfo.LocalId).Updates(projectinfo).Error
+			if err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+// SetTaskFinish 专项任务结案
+func SetSpecialLocalTaskFinish(ctx context.Context, TaskIDs []string) error {
+	db := GetReadDB(ctx)
+	// 1. 修改任务表，更新任务阶段为已结案，结案方式为正常结束，数据状态为已通过，
+	err := db.Model(gorm_model.YoungeeLocalTaskInfo{}).Where("task_id in ?", TaskIDs).Updates(gorm_model.YoungeeLocalTaskInfo{DataStatus: 5, TaskStage: 15, CompleteStatus: 2, WithdrawStatus: 2, CompleteDate: time.Now()}).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Task db] Update YoungeeTaskInfo error,err:%+v", err)
+		return err
+	}
+	return nil
+}
+
 func GetSpecialTaskInviteList(ctx context.Context, projectID string, pageSize, pageNum int64, conditions *common_model.TalentConditions) ([]*http_model.SpecialTaskInviteInfo, int64, error) {
 	db := GetReadDB(ctx)
 	// 查询task表信息
@@ -362,6 +572,27 @@ func SetTalentIncome(ctx context.Context, TaskIDs []string) error {
 	return nil
 }
 
+func SetLocalTalentIncome(ctx context.Context, TaskIDs []string) error {
+	db := GetReadDB(ctx)
+	var TaskInfoList []gorm_model.YoungeeLocalTaskInfo
+	fmt.Println("收入", TaskIDs)
+	err := db.Model(gorm_model.YoungeeLocalTaskInfo{}).Where("task_id in ?", TaskIDs).Scan(&TaskInfoList).Error
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Task db] Update SetTalentIncome error,err:%+v", err)
+		return err
+	}
+	for _, taskInfo := range TaskInfoList {
+		err := db.Model(gorm_model.YoungeeTalentInfo{}).Where("id = ?", taskInfo.TalentId).Updates(map[string]interface{}{
+			"income":      gorm.Expr("income + ?", taskInfo.SettleAmount),
+			"canwithdraw": gorm.Expr("canwithdraw + ?", taskInfo.SettleAmount)}).Error
+		if err != nil {
+			logrus.WithContext(ctx).Errorf("[Task db] Update SetTalentIncome error,err:%+v", err)
+			return err
+		}
+	}
+	return nil
+}
+
 // 获取任务ids
 func GetTaskIds(ctx context.Context, projectId string) ([]string, error) {
 	db := GetReadDB(ctx)

handler/LocalPrelinklist.go

@@ -0,0 +1,57 @@
+package handler
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+	"youngee_b_api/consts"
+	"youngee_b_api/model/http_model"
+	"youngee_b_api/service"
+	"youngee_b_api/util"
+)
+
+func WrapLocalPreLinkListHandler(ctx *gin.Context) {
+	handler := newLocalPreLinkListHandler(ctx)
+	baseRun(handler)
+}
+
+func newLocalPreLinkListHandler(ctx *gin.Context) *LocalPreLinkListHandler {
+	return &LocalPreLinkListHandler{
+		req:  http_model.NewLocalPreLinkListRequest(),
+		resp: http_model.NewLocalPreLinkListResponse(),
+		ctx:  ctx,
+	}
+}
+
+type LocalPreLinkListHandler struct {
+	req  *http_model.LocalPreLinkListRequest
+	resp *http_model.CommonResponse
+	ctx  *gin.Context
+}
+
+func (h LocalPreLinkListHandler) getRequest() interface{} {
+	return h.req
+}
+func (h LocalPreLinkListHandler) getContext() *gin.Context {
+	return h.ctx
+}
+func (h LocalPreLinkListHandler) getResponse() interface{} {
+	return h.resp
+}
+func (h LocalPreLinkListHandler) run() {
+	data := http_model.LocalPreLinkListRequest{}
+	data = *h.req
+	res, err := service.LocalTask.GetLocalPreLinkList(h.ctx, data)
+	if err != nil {
+		logrus.Errorf("[GetLocalPreLinkList] call GetLocalPreLinkList err:%+v\n", err)
+		util.HandlerPackErrorResp(h.resp, consts.ErrorParamCheck, "")
+		logrus.Info("GetLocalPreLinkList fail,req:%+v", h.req)
+		return
+	}
+	h.resp.Message = "成功查询链接待传列表"
+	h.resp.Data = res
+	h.resp.Status = consts.ErrorSuccess
+}
+
+func (h LocalPreLinkListHandler) checkParam() error {
+	return nil
+}

handler/PasslocalTaskCoop.go

@@ -0,0 +1,61 @@
+package handler
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+	"youngee_b_api/consts"
+	"youngee_b_api/model/http_model"
+	"youngee_b_api/service"
+	"youngee_b_api/util"
+)
+
+func WrapPasslocalTaskCoopHandler(ctx *gin.Context) {
+	handler := newPasslocalTaskCoopHandler(ctx)
+	baseRun(handler)
+}
+
+type PasslocalTaskCoop struct {
+	ctx  *gin.Context
+	req  *http_model.PasslocalTaskCoopRequest
+	resp *http_model.CommonResponse
+}
+
+func (c PasslocalTaskCoop) getContext() *gin.Context {
+	return c.ctx
+}
+
+func (c PasslocalTaskCoop) getResponse() interface{} {
+	return c.resp
+}
+
+func (c PasslocalTaskCoop) getRequest() interface{} {
+	return c.req
+}
+
+func (c PasslocalTaskCoop) run() {
+	data := *c.req
+	//auth := middleware.GetSessionAuth(c.ctx)
+	//enterpriseID := auth.EnterpriseID
+	res, err := service.LocalTask.PassCoop(c.ctx, data)
+	if err != nil {
+		logrus.Errorf("[PasslocalTaskCoop] call PasslocalTaskCoop err:%+v\n", err)
+		util.HandlerPackErrorResp(c.resp, consts.ErrorParamCheck, "")
+		logrus.Info("PasslocalTaskCoop fail,req:%+v", c.req)
+		return
+	}
+	c.resp.Message = "成功合作任务"
+	c.resp.Data = res
+	c.resp.Status = consts.ErrorSuccess
+}
+
+func (c PasslocalTaskCoop) checkParam() error {
+	return nil
+}
+
+func newPasslocalTaskCoopHandler(ctx *gin.Context) *PasslocalTaskCoop {
+	return &PasslocalTaskCoop{
+		ctx:  ctx,
+		req:  http_model.NewPasslocalTaskCoopRequest(),
+		resp: http_model.NewPasslocalTaskCoopResponse(),
+	}
+}

handler/PassproTaskCoop.go

@@ -40,12 +40,13 @@ func (c PassproTaskCoop) run() {
 	res, err := service.Task.PassCoop(c.ctx, data)
 	if err != nil {
 		logrus.Errorf("[PassproTaskCoop] call PassproTaskCoop err:%+v\n", err)
-		util.HandlerPackErrorResp(c.resp, consts.ErrorInternal, "")
+		util.HandlerPackErrorResp(c.resp, consts.ErrorParamCheck, "")
 		logrus.Info("PassproTaskCoop fail,req:%+v", c.req)
 		return
 	}
 	c.resp.Message = "成功合作种草任务"
 	c.resp.Data = res
+	c.resp.Status = consts.ErrorSuccess
 }
 
 func (c PassproTaskCoop) checkParam() error {

handler/Prelinklist.go

@@ -43,12 +43,13 @@ func (h PreLinkListHandler) run() {
 	res, err := service.Task.GetPreLinkList(h.ctx, data)
 	if err != nil {
 		logrus.Errorf("[GetPreLinkList] call GetPreLinkList err:%+v\n", err)
-		util.HandlerPackErrorResp(h.resp, consts.ErrorInternal, "")
+		util.HandlerPackErrorResp(h.resp, consts.ErrorParamCheck, "")
 		logrus.Info("GetPreLinkList fail,req:%+v", h.req)
 		return
 	}
 	h.resp.Message = "成功查询链接待传列表"
 	h.resp.Data = res
+	h.resp.Status = consts.ErrorSuccess
 }
 
 func (h PreLinkListHandler) checkParam() error {

handler/Refuseloacltaskcoop.go

@@ -0,0 +1,61 @@
+package handler
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+	"youngee_b_api/consts"
+	"youngee_b_api/model/http_model"
+	"youngee_b_api/service"
+	"youngee_b_api/util"
+)
+
+func WrapRefuselocalTaskCoopHandler(ctx *gin.Context) {
+	handler := newRefuselocalTaskCoopHandler(ctx)
+	baseRun(handler)
+}
+
+type RefuselocalTaskCoop struct {
+	ctx  *gin.Context
+	req  *http_model.RefuselocalTaskCoopRequest
+	resp *http_model.CommonResponse
+}
+
+func (c RefuselocalTaskCoop) getContext() *gin.Context {
+	return c.ctx
+}
+
+func (c RefuselocalTaskCoop) getResponse() interface{} {
+	return c.resp
+}
+
+func (c RefuselocalTaskCoop) getRequest() interface{} {
+	return c.req
+}
+
+func (c RefuselocalTaskCoop) run() {
+	data := *c.req
+	//auth := middleware.GetSessionAuth(c.ctx)
+	//enterpriseID := auth.EnterpriseID
+	res, err := service.LocalTask.RefuseCoop(c.ctx, data)
+	if err != nil {
+		logrus.Errorf("[RefuselocalTaskCoop] call RefuselocalTaskCoop err:%+v\n", err)
+		util.HandlerPackErrorResp(c.resp, consts.ErrorParamCheck, "")
+		logrus.Info("RefuselocalTaskCoop fail,req:%+v", c.req)
+		return
+	}
+	c.resp.Message = "成功拒绝任务"
+	c.resp.Data = res
+	c.resp.Status = consts.ErrorSuccess
+}
+
+func (c RefuselocalTaskCoop) checkParam() error {
+	return nil
+}
+
+func newRefuselocalTaskCoopHandler(ctx *gin.Context) *RefuselocalTaskCoop {
+	return &RefuselocalTaskCoop{
+		ctx:  ctx,
+		req:  http_model.NewRefuselocalTaskCoopRequest(),
+		resp: http_model.NewRefuselocalTaskCoopResponse(),
+	}
+}

handler/RefuseproTaskCoop.go

@@ -40,12 +40,13 @@ func (c RefuseproTaskCoop) run() {
 	res, err := service.Task.RefuseCoop(c.ctx, data)
 	if err != nil {
 		logrus.Errorf("[RefuseproTaskCoop] call RefuseproTaskCoop err:%+v\n", err)
-		util.HandlerPackErrorResp(c.resp, consts.ErrorInternal, "")
+		util.HandlerPackErrorResp(c.resp, consts.ErrorParamCheck, "")
 		logrus.Info("RefuseproTaskCoop fail,req:%+v", c.req)
 		return
 	}
 	c.resp.Message = "成功拒绝种草任务"
 	c.resp.Data = res
+	c.resp.Status = consts.ErrorSuccess
 }
 
 func (c RefuseproTaskCoop) checkParam() error {

handler/accept_data.go

@@ -46,12 +46,13 @@ func (h *AcceptDataHandler) run() {
 	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, "")
+		util.HandlerPackErrorResp(h.resp, consts.ErrorParamCheck, "")
 		log.Info("CreateProject fail,req:%+v", h.req)
 		return
 	}
 	h.resp.Message = "成功通过数据"
 	h.resp.Data = res
+	h.resp.Status = consts.ErrorSuccess
 }
 
 func (h *AcceptDataHandler) checkParam() error {

handler/accept_link.go

@@ -46,13 +46,13 @@ func (h *AcceptLinkHandler) run() {
 	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, "")
+		util.HandlerPackErrorResp(h.resp, consts.ErrorParamCheck, "")
 		log.Info("CreateProject fail,req:%+v", h.req)
 		return
 	}
 	h.resp.Message = "成功通过链接"
 	h.resp.Data = res
-	h.resp.Data = data
+	h.resp.Status = consts.ErrorSuccess
 }
 
 func (h *AcceptLinkHandler) checkParam() error {

handler/accept_sketch.go

@@ -45,45 +45,48 @@ func (h *AcceptSketchHandler) run() {
 	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, "")
+		util.HandlerPackErrorResp(h.resp, consts.ErrorParamCheck, "")
 		log.Info("CreateProject fail,req:%+v", h.req)
 		return
 	}
 	h.resp.Message = "成功通过初稿"
 	h.resp.Data = res
-	h.resp.Data = data
+	h.resp.Status = consts.ErrorSuccess
 }
 
-/***
-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
+/*
+**
+
+	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
 		}
-		h.resp.Message = "成功修改物流信息"
-		h.resp.Data = res
-	}
 
 }
-***/
+**
+*/
 func (h *AcceptSketchHandler) checkParam() error {
 	return nil
 }

handler/data_opinion.go

@@ -46,45 +46,48 @@ func (h *DataOpinionHandler) run() {
 	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, "")
+		util.HandlerPackErrorResp(h.resp, consts.ErrorParamCheck, "")
 		log.Info("CreateProject fail,req:%+v", h.req)
 		return
 	}
 	h.resp.Message = "提交数据审核修改意见成功"
 	h.resp.Data = res
-	h.resp.Data = data
+	h.resp.Status = consts.ErrorSuccess
 }
 
-/***
-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
+/*
+**
+
+	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
 		}
-		h.resp.Message = "成功修改物流信息"
-		h.resp.Data = res
-	}
 
 }
-***/
+**
+*/
 func (h *DataOpinionHandler) checkParam() error {
 	return nil
 }

handler/endtask.go

@@ -38,11 +38,12 @@ func (c EndTask) run() {
 	err := db.EndTask(c.ctx, data)
 	if err != nil {
 		logrus.Errorf("[GetSecTaskList] call EndTask err:%+v\n", err)
-		util.HandlerPackErrorResp(c.resp, consts.ErrorInternal, "")
+		util.HandlerPackErrorResp(c.resp, consts.ErrorParamCheck, "")
 		logrus.Info("GetSecTaskList fail,req:%+v", c.req)
 		return
 	}
 	c.resp.Message = "成功终止任务状态"
+	c.resp.Status = consts.ErrorSuccess
 }
 
 func (c EndTask) checkParam() error {

handler/executedata.go

@@ -40,12 +40,13 @@ func (c ExecuteData) run() {
 	res, err := service.Project.ExecuteData(c.ctx, data)
 	if err != nil {
 		logrus.Errorf("[ExecuteData] call ExecuteData err:%+v\n", err)
-		util.HandlerPackErrorResp(c.resp, consts.ErrorInternal, "")
+		util.HandlerPackErrorResp(c.resp, consts.ErrorParamCheck, "")
 		logrus.Info("ExecuteData fail,req:%+v", c.req)
 		return
 	}
 	c.resp.Message = "成功看数据"
 	c.resp.Data = res
+	c.resp.Status = consts.ErrorSuccess
 }
 
 func (c ExecuteData) checkParam() error {

handler/getlocaltasklist.go

@@ -0,0 +1,60 @@
+package handler
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+	"youngee_b_api/consts"
+	"youngee_b_api/model/http_model"
+	"youngee_b_api/service"
+	"youngee_b_api/util"
+)
+
+func WrapGetLocalTaskListHandler(ctx *gin.Context) {
+	handler := newGetLocalTaskListHandler(ctx)
+	baseRun(handler)
+}
+
+type GetLocalTaskList struct {
+	ctx  *gin.Context
+	req  *http_model.GetLocalTaskListRequest
+	resp *http_model.CommonResponse
+}
+
+func (c GetLocalTaskList) getContext() *gin.Context {
+	return c.ctx
+}
+
+func (c GetLocalTaskList) getResponse() interface{} {
+	return c.resp
+}
+
+func (c GetLocalTaskList) getRequest() interface{} {
+	return c.req
+}
+
+func (c GetLocalTaskList) run() {
+	data := http_model.GetLocalTaskListRequest{}
+	data = *c.req
+	res, err := service.LocalTask.GetLocalList(c.ctx, data)
+	if err != nil {
+		logrus.Errorf("[GetSecTaskList] call GetSecTaskList err:%+v\n", err)
+		util.HandlerPackErrorResp(c.resp, consts.ErrorParamCheck, "")
+		logrus.Info("GetSecTaskList fail,req:%+v", c.req)
+		return
+	}
+	c.resp.Message = "成功查询本地生活报名达人"
+	c.resp.Data = res
+	c.resp.Status = consts.ErrorSuccess
+}
+
+func (c GetLocalTaskList) checkParam() error {
+	return nil
+}
+
+func newGetLocalTaskListHandler(ctx *gin.Context) *GetLocalTaskList {
+	return &GetLocalTaskList{
+		ctx:  ctx,
+		req:  http_model.NewGetLocalTaskListRequest(),
+		resp: http_model.NewGetLocalTaskListResponse(),
+	}
+}

handler/gettasklist.go

@@ -38,12 +38,13 @@ func (c GetTaskList) run() {
 	res, err := service.Task.GetList(c.ctx, data)
 	if err != nil {
 		logrus.Errorf("[GetSecTaskList] call GetSecTaskList err:%+v\n", err)
-		util.HandlerPackErrorResp(c.resp, consts.ErrorInternal, "")
+		util.HandlerPackErrorResp(c.resp, consts.ErrorParamCheck, "")
 		logrus.Info("GetSecTaskList fail,req:%+v", c.req)
 		return
 	}
 	c.resp.Message = "成功查询种草达人"
 	c.resp.Data = res
+	c.resp.Status = consts.ErrorSuccess
 }
 
 func (c GetTaskList) checkParam() error {

handler/link_opinion.go

@@ -46,45 +46,48 @@ func (h *LinkOpinionHandler) run() {
 	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, "")
+		util.HandlerPackErrorResp(h.resp, consts.ErrorParamCheck, "")
 		log.Info("CreateProject fail,req:%+v", h.req)
 		return
 	}
 	h.resp.Message = "提交脚本修改意见成功"
 	h.resp.Data = res
-	h.resp.Data = data
+	h.resp.Status = consts.ErrorSuccess
 }
 
-/***
-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
+/*
+**
+
+	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
 		}
-		h.resp.Message = "成功修改物流信息"
-		h.resp.Data = res
-	}
 
 }
-***/
+**
+*/
 func (h *LinkOpinionHandler) checkParam() error {
 	return nil
 }

handler/localaccept_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 WrapLocalAcceptDataHandler(ctx *gin.Context) {
+	handler := newLocalAcceptDataHandler(ctx)
+	baseRun(handler)
+}
+
+func newLocalAcceptDataHandler(ctx *gin.Context) *LocalAcceptDataHandler {
+	return &LocalAcceptDataHandler{
+		req:  http_model.NewLocalAcceptDataRequest(),
+		resp: http_model.NewLocalAcceptDataResponse(),
+		ctx:  ctx,
+	}
+}
+
+type LocalAcceptDataHandler struct {
+	req  *http_model.LocalAcceptDataRequest
+	resp *http_model.CommonResponse
+	ctx  *gin.Context
+}
+
+func (h *LocalAcceptDataHandler) getRequest() interface{} {
+	return h.req
+}
+func (h *LocalAcceptDataHandler) getContext() *gin.Context {
+	return h.ctx
+}
+func (h *LocalAcceptDataHandler) getResponse() interface{} {
+	return h.resp
+}
+
+func (h *LocalAcceptDataHandler) run() {
+	data := http_model.LocalAcceptDataRequest{}
+	data = *h.req
+	res, err := service.Data.LocalAcceptData(h.ctx, data)
+	if err != nil {
+		logrus.Errorf("[ReviseOpinionHandler] call Create err:%+v\n", err)
+		util.HandlerPackErrorResp(h.resp, consts.ErrorParamCheck, "")
+		log.Info("CreateProject fail,req:%+v", h.req)
+		return
+	}
+	h.resp.Message = "成功通过数据"
+	h.resp.Data = res
+	h.resp.Status = consts.ErrorSuccess
+}
+
+func (h *LocalAcceptDataHandler) checkParam() error {
+	return nil
+}

handler/localaccept_link.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 WrapLocalAcceptLinkHandler(ctx *gin.Context) {
+	handler := newLocalAcceptLinkHandler(ctx)
+	baseRun(handler)
+}
+
+func newLocalAcceptLinkHandler(ctx *gin.Context) *LocalAcceptLinkHandler {
+	return &LocalAcceptLinkHandler{
+		req:  http_model.NewLocalAcceptLinkRequest(),
+		resp: http_model.NewLocalAcceptLinkResponse(),
+		ctx:  ctx,
+	}
+}
+
+type LocalAcceptLinkHandler struct {
+	req  *http_model.LocalAcceptLinkRequest
+	resp *http_model.CommonResponse
+	ctx  *gin.Context
+}
+
+func (h *LocalAcceptLinkHandler) getRequest() interface{} {
+	return h.req
+}
+func (h *LocalAcceptLinkHandler) getContext() *gin.Context {
+	return h.ctx
+}
+func (h *LocalAcceptLinkHandler) getResponse() interface{} {
+	return h.resp
+}
+
+func (h *LocalAcceptLinkHandler) run() {
+	data := http_model.LocalAcceptLinkRequest{}
+	data = *h.req
+	res, err := service.Link.LocalAcceptLink(h.ctx, data)
+	if err != nil {
+		logrus.Errorf("[ReviseOpinionHandler] call Create err:%+v\n", err)
+		util.HandlerPackErrorResp(h.resp, consts.ErrorParamCheck, "")
+		log.Info("CreateProject fail,req:%+v", h.req)
+		return
+	}
+	h.resp.Message = "成功通过链接"
+	h.resp.Data = res
+	h.resp.Status = consts.ErrorSuccess
+}
+
+func (h *LocalAcceptLinkHandler) checkParam() error {
+	return nil
+}

handler/localaccept_sketch.go

@@ -0,0 +1,59 @@
+package handler
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+	log "github.com/sirupsen/logrus"
+	"youngee_b_api/consts"
+	"youngee_b_api/model/http_model"
+	"youngee_b_api/service"
+	"youngee_b_api/util"
+)
+
+func WrapLocalAcceptSketchHandler(ctx *gin.Context) {
+	handler := newLocalAcceptSketchHandler(ctx)
+	baseRun(handler)
+}
+
+func newLocalAcceptSketchHandler(ctx *gin.Context) *LocalAcceptSketchHandler {
+	return &LocalAcceptSketchHandler{
+		req:  http_model.NewLocalAcceptSketchRequest(),
+		resp: http_model.NewLocalAcceptSketchResponse(),
+		ctx:  ctx,
+	}
+}
+
+type LocalAcceptSketchHandler struct {
+	req  *http_model.LocalAcceptSketchRequest
+	resp *http_model.CommonResponse
+	ctx  *gin.Context
+}
+
+func (h *LocalAcceptSketchHandler) getRequest() interface{} {
+	return h.req
+}
+func (h *LocalAcceptSketchHandler) getContext() *gin.Context {
+	return h.ctx
+}
+func (h *LocalAcceptSketchHandler) getResponse() interface{} {
+	return h.resp
+}
+
+func (h *LocalAcceptSketchHandler) run() {
+	data := http_model.LocalAcceptSketchRequest{}
+	data = *h.req
+	res, err := service.Sketch.LocalAcceptSketch(h.ctx, data)
+	if err != nil {
+		logrus.Errorf("[ReviseOpinionHandler] call Create err:%+v\n", err)
+		util.HandlerPackErrorResp(h.resp, consts.ErrorParamCheck, "")
+		log.Info("CreateProject fail,req:%+v", h.req)
+		return
+	}
+	h.resp.Message = "成功通过初稿"
+	h.resp.Data = res
+	h.resp.Status = consts.ErrorSuccess
+}
+
+func (h *LocalAcceptSketchHandler) checkParam() error {
+	return nil
+}

handler/localdata_opinion.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 WrapLocalDataOpinionHandler(ctx *gin.Context) {
+	handler := newLocalDataOpinionHandler(ctx)
+	baseRun(handler)
+}
+
+func newLocalDataOpinionHandler(ctx *gin.Context) *LocalDataOpinionHandler {
+	return &LocalDataOpinionHandler{
+		req:  http_model.NewLocalDataOpinionRequest(),
+		resp: http_model.NewLocalDataOpinionResponse(),
+		ctx:  ctx,
+	}
+}
+
+type LocalDataOpinionHandler struct {
+	req  *http_model.LocalDataOpinionRequest
+	resp *http_model.CommonResponse
+	ctx  *gin.Context
+}
+
+func (h *LocalDataOpinionHandler) getRequest() interface{} {
+	return h.req
+}
+func (h *LocalDataOpinionHandler) getContext() *gin.Context {
+	return h.ctx
+}
+func (h *LocalDataOpinionHandler) getResponse() interface{} {
+	return h.resp
+}
+
+func (h *LocalDataOpinionHandler) run() {
+	data := http_model.LocalDataOpinionRequest{}
+	data = *h.req
+	res, err := service.Data.LocalDataOpinion(h.ctx, data)
+	if err != nil {
+		logrus.Errorf("[LocalDataOpinionHandler] call Create err:%+v\n", err)
+		util.HandlerPackErrorResp(h.resp, consts.ErrorParamCheck, "")
+		log.Info("CreateProject fail,req:%+v", h.req)
+		return
+	}
+	h.resp.Message = "提交数据审核修改意见成功"
+	h.resp.Data = res
+	h.resp.Status = consts.ErrorSuccess
+}
+
+func (h *LocalDataOpinionHandler) checkParam() error {
+	return nil
+}

handler/locallifedata.go

@@ -0,0 +1,61 @@
+package handler
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+	"youngee_b_api/consts"
+	"youngee_b_api/model/http_model"
+	"youngee_b_api/service"
+	"youngee_b_api/util"
+)
+
+func WrapLocallifeDataHandler(ctx *gin.Context) {
+	handler := newLocallifeDataHandler(ctx)
+	baseRun(handler)
+}
+
+type LocallifeData struct {
+	ctx  *gin.Context
+	req  *http_model.LocallifeDataRequest
+	resp *http_model.CommonResponse
+}
+
+func (c LocallifeData) getContext() *gin.Context {
+	return c.ctx
+}
+
+func (c LocallifeData) getResponse() interface{} {
+	return c.resp
+}
+
+func (c LocallifeData) getRequest() interface{} {
+	return c.req
+}
+
+func (c LocallifeData) run() {
+	data := *c.req
+	//auth := middleware.GetSessionAuth(c.ctx)
+	//enterpriseID := auth.EnterpriseID
+	res, err := service.LocalTask.Data(c.ctx, data)
+	if err != nil {
+		logrus.Errorf("[LocallifeData] call LocallifeData err:%+v\n", err)
+		util.HandlerPackErrorResp(c.resp, consts.ErrorParamCheck, "")
+		logrus.Info("LocallifeData fail,req:%+v", c.req)
+		return
+	}
+	c.resp.Message = "成功看数据"
+	c.resp.Data = res
+	c.resp.Status = consts.ErrorSuccess
+}
+
+func (c LocallifeData) checkParam() error {
+	return nil
+}
+
+func newLocallifeDataHandler(ctx *gin.Context) *LocallifeData {
+	return &LocallifeData{
+		ctx:  ctx,
+		req:  http_model.NewLocallifeDataRequest(),
+		resp: http_model.NewLocallifeDataResponse(),
+	}
+}

handler/locallink_opinion.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 WrapLocalLinkOpinionHandler(ctx *gin.Context) {
+	handler := newLocalLinkOpinionHandler(ctx)
+	baseRun(handler)
+}
+
+func newLocalLinkOpinionHandler(ctx *gin.Context) *LocalLinkOpinionHandler {
+	return &LocalLinkOpinionHandler{
+		req:  http_model.NewLocalLinkOpinionRequest(),
+		resp: http_model.NewLocalLinkOpinionResponse(),
+		ctx:  ctx,
+	}
+}
+
+type LocalLinkOpinionHandler struct {
+	req  *http_model.LocalLinkOpinionRequest
+	resp *http_model.CommonResponse
+	ctx  *gin.Context
+}
+
+func (h *LocalLinkOpinionHandler) getRequest() interface{} {
+	return h.req
+}
+func (h *LocalLinkOpinionHandler) getContext() *gin.Context {
+	return h.ctx
+}
+func (h *LocalLinkOpinionHandler) getResponse() interface{} {
+	return h.resp
+}
+
+func (h *LocalLinkOpinionHandler) run() {
+	data := http_model.LocalLinkOpinionRequest{}
+	data = *h.req
+	res, err := service.Link.LocalLinkOpinion(h.ctx, data)
+	if err != nil {
+		logrus.Errorf("[LocalLinkOpinionHandler] call Create err:%+v\n", err)
+		util.HandlerPackErrorResp(h.resp, consts.ErrorParamCheck, "")
+		log.Info("CreateProject fail,req:%+v", h.req)
+		return
+	}
+	h.resp.Message = "提交脚本修改意见成功"
+	h.resp.Data = res
+	h.resp.Status = consts.ErrorSuccess
+}
+
+func (h *LocalLinkOpinionHandler) checkParam() error {
+	return nil
+}

handler/localpredatalist.go

@@ -0,0 +1,57 @@
+package handler
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+	"youngee_b_api/consts"
+	"youngee_b_api/model/http_model"
+	"youngee_b_api/service"
+	"youngee_b_api/util"
+)
+
+func WrapLocalPreDataListHandler(ctx *gin.Context) {
+	handler := newLocalPreDataListHandler(ctx)
+	baseRun(handler)
+}
+
+func newLocalPreDataListHandler(ctx *gin.Context) *LocalPreDataListHandler {
+	return &LocalPreDataListHandler{
+		req:  http_model.NewLocalPreDataListRequest(),
+		resp: http_model.NewLocalPreDataListResponse(),
+		ctx:  ctx,
+	}
+}
+
+type LocalPreDataListHandler struct {
+	req  *http_model.LocalPreDataListRequest
+	resp *http_model.CommonResponse
+	ctx  *gin.Context
+}
+
+func (h LocalPreDataListHandler) getRequest() interface{} {
+	return h.req
+}
+func (h LocalPreDataListHandler) getContext() *gin.Context {
+	return h.ctx
+}
+func (h LocalPreDataListHandler) getResponse() interface{} {
+	return h.resp
+}
+func (h LocalPreDataListHandler) run() {
+	data := http_model.LocalPreDataListRequest{}
+	data = *h.req
+	res, err := service.LocalTask.GetLocalPreDataList(h.ctx, data)
+	if err != nil {
+		logrus.Errorf("[GetLocalPreDataList] call GetLocalPreDataList err:%+v\n", err)
+		util.HandlerPackErrorResp(h.resp, consts.ErrorParamCheck, "")
+		logrus.Info("GetLocalPreDataList fail,req:%+v", h.req)
+		return
+	}
+	h.resp.Message = "成功查询数据待传列表"
+	h.resp.Data = res
+	h.resp.Status = consts.ErrorSuccess
+}
+
+func (h LocalPreDataListHandler) checkParam() error {
+	return nil
+}

handler/localpresketchlist.go

@@ -0,0 +1,60 @@
+package handler
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+	"youngee_b_api/consts"
+	"youngee_b_api/model/http_model"
+	"youngee_b_api/service"
+	"youngee_b_api/util"
+)
+
+func WrapLocalPreSketchListHandler(ctx *gin.Context) {
+	handler := newLocalPreSketchListHandler(ctx)
+	baseRun(handler)
+}
+
+type LocalPreSketchList struct {
+	ctx  *gin.Context
+	req  *http_model.LocalPreSketchListRequest
+	resp *http_model.CommonResponse
+}
+
+func (c LocalPreSketchList) getContext() *gin.Context {
+	return c.ctx
+}
+
+func (c LocalPreSketchList) getResponse() interface{} {
+	return c.resp
+}
+
+func (c LocalPreSketchList) getRequest() interface{} {
+	return c.req
+}
+
+func (c LocalPreSketchList) run() {
+	data := http_model.LocalPreSketchListRequest{}
+	data = *c.req
+	res, err := service.LocalTask.GetLocalPreSketchList(c.ctx, data)
+	if err != nil {
+		logrus.Errorf("[GetLocalPreSketchList] call GetLocalPreSketchList err:%+v\n", err)
+		util.HandlerPackErrorResp(c.resp, consts.ErrorParamCheck, "")
+		logrus.Info("GetLocalPreSketchList fail,req:%+v", c.req)
+		return
+	}
+	c.resp.Message = "成功查询待传初稿"
+	c.resp.Data = res
+	c.resp.Status = consts.ErrorSuccess
+}
+
+func (c LocalPreSketchList) checkParam() error {
+	return nil
+}
+
+func newLocalPreSketchListHandler(ctx *gin.Context) *LocalPreSketchList {
+	return &LocalPreSketchList{
+		ctx:  ctx,
+		req:  http_model.NewLocalPreSketchListRequest(),
+		resp: http_model.NewLocalPreSketchListResponse(),
+	}
+}

handler/localreject_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 WrapLocalRejectDataHandler(ctx *gin.Context) {
+	handler := newLocalRejectDataHandler(ctx)
+	baseRun(handler)
+}
+
+func newLocalRejectDataHandler(ctx *gin.Context) *LocalRejectDataHandler {
+	return &LocalRejectDataHandler{
+		req:  http_model.NewLocalRejectDataRequest(),
+		resp: http_model.NewLocalRejectDataResponse(),
+		ctx:  ctx,
+	}
+}
+
+type LocalRejectDataHandler struct {
+	req  *http_model.LocalRejectDataRequest
+	resp *http_model.CommonResponse
+	ctx  *gin.Context
+}
+
+func (h *LocalRejectDataHandler) getRequest() interface{} {
+	return h.req
+}
+func (h *LocalRejectDataHandler) getContext() *gin.Context {
+	return h.ctx
+}
+func (h *LocalRejectDataHandler) getResponse() interface{} {
+	return h.resp
+}
+
+func (h *LocalRejectDataHandler) run() {
+	data := http_model.LocalRejectDataRequest{}
+	data = *h.req
+	res, err := service.Data.LocalRejectData(h.ctx, data)
+	if err != nil {
+		logrus.Errorf("[ReviseOpinionHandler] call Create err:%+v\n", err)
+		util.HandlerPackErrorResp(h.resp, consts.ErrorParamCheck, "")
+		log.Info("CreateProject fail,req:%+v", h.req)
+		return
+	}
+	h.resp.Message = "成功拒绝数据"
+	h.resp.Data = res
+	h.resp.Status = consts.ErrorSuccess
+}
+
+func (h *LocalRejectDataHandler) checkParam() error {
+	return nil
+}

handler/localreject_link.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 WrapLocalRejectLinkHandler(ctx *gin.Context) {
+	handler := newLocalRejectLinkHandler(ctx)
+	baseRun(handler)
+}
+
+func newLocalRejectLinkHandler(ctx *gin.Context) *LocalRejectLinkHandler {
+	return &LocalRejectLinkHandler{
+		req:  http_model.NewLocalRejectLinkRequest(),
+		resp: http_model.NewLocalRejectLinkResponse(),
+		ctx:  ctx,
+	}
+}
+
+type LocalRejectLinkHandler struct {
+	req  *http_model.LocalRejectLinkRequest
+	resp *http_model.CommonResponse
+	ctx  *gin.Context
+}
+
+func (h *LocalRejectLinkHandler) getRequest() interface{} {
+	return h.req
+}
+func (h *LocalRejectLinkHandler) getContext() *gin.Context {
+	return h.ctx
+}
+func (h *LocalRejectLinkHandler) getResponse() interface{} {
+	return h.resp
+}
+
+func (h *LocalRejectLinkHandler) run() {
+	data := http_model.LocalRejectLinkRequest{}
+	data = *h.req
+	res, err := service.Link.LocalRejectLink(h.ctx, data)
+	if err != nil {
+		logrus.Errorf("[ReviseOpinionHandler] call Create err:%+v\n", err)
+		util.HandlerPackErrorResp(h.resp, consts.ErrorParamCheck, "")
+		log.Info("CreateProject fail,req:%+v", h.req)
+		return
+	}
+	h.resp.Message = "成功拒绝链接"
+	h.resp.Data = res
+	h.resp.Status = consts.ErrorSuccess
+}
+
+func (h *LocalRejectLinkHandler) checkParam() error {
+	return nil
+}

handler/localreject_sketch.go

@@ -0,0 +1,58 @@
+package handler
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+	log "github.com/sirupsen/logrus"
+	"youngee_b_api/consts"
+	"youngee_b_api/model/http_model"
+	"youngee_b_api/service"
+	"youngee_b_api/util"
+)
+
+func WrapLocalRejectSketchHandler(ctx *gin.Context) {
+	handler := newLocalRejectSketchHandler(ctx)
+	baseRun(handler)
+}
+
+func newLocalRejectSketchHandler(ctx *gin.Context) *LocalRejectSketchHandler {
+	return &LocalRejectSketchHandler{
+		req:  http_model.NewLocalRejectSketchRequest(),
+		resp: http_model.NewLocalRejectSketchResponse(),
+		ctx:  ctx,
+	}
+}
+
+type LocalRejectSketchHandler struct {
+	req  *http_model.LocalRejectSketchRequest
+	resp *http_model.CommonResponse
+	ctx  *gin.Context
+}
+
+func (h *LocalRejectSketchHandler) getRequest() interface{} {
+	return h.req
+}
+func (h *LocalRejectSketchHandler) getContext() *gin.Context {
+	return h.ctx
+}
+func (h *LocalRejectSketchHandler) getResponse() interface{} {
+	return h.resp
+}
+
+func (h *LocalRejectSketchHandler) run() {
+	data := http_model.LocalRejectSketchRequest{}
+	data = *h.req
+	res, err := service.Sketch.LocalRejectSketch(h.ctx, data)
+	if err != nil {
+		logrus.Errorf("[ReviseOpinionHandler] call Create err:%+v\n", err)
+		util.HandlerPackErrorResp(h.resp, consts.ErrorParamCheck, "")
+		log.Info("CreateProject fail,req:%+v", h.req)
+		return
+	}
+	h.resp.Message = "成功拒绝初稿"
+	h.resp.Data = res
+	h.resp.Status = consts.ErrorSuccess
+}
+func (h *LocalRejectSketchHandler) checkParam() error {
+	return nil
+}

handler/localsketch_opinion.go

@@ -0,0 +1,59 @@
+package handler
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+	log "github.com/sirupsen/logrus"
+	"youngee_b_api/consts"
+	"youngee_b_api/model/http_model"
+	"youngee_b_api/service"
+	"youngee_b_api/util"
+)
+
+func WrapLocalSketchOpinionHandler(ctx *gin.Context) {
+	handler := newLocalSketchOpinionHandler(ctx)
+	baseRun(handler)
+}
+
+func newLocalSketchOpinionHandler(ctx *gin.Context) *LocalSketchOpinionHandler {
+	return &LocalSketchOpinionHandler{
+		req:  http_model.NewLocalSketchOpinionRequest(),
+		resp: http_model.NewLocalSketchOpinionResponse(),
+		ctx:  ctx,
+	}
+}
+
+type LocalSketchOpinionHandler struct {
+	req  *http_model.LocalSketchOpinionRequest
+	resp *http_model.CommonResponse
+	ctx  *gin.Context
+}
+
+func (h *LocalSketchOpinionHandler) getRequest() interface{} {
+	return h.req
+}
+func (h *LocalSketchOpinionHandler) getContext() *gin.Context {
+	return h.ctx
+}
+func (h *LocalSketchOpinionHandler) getResponse() interface{} {
+	return h.resp
+}
+
+func (h *LocalSketchOpinionHandler) run() {
+	data := http_model.LocalSketchOpinionRequest{}
+	data = *h.req
+	res, err := service.Sketch.LocalSketchOption(h.ctx, data)
+	if err != nil {
+		logrus.Errorf("[LocalSketchOpinionHandler] call Create err:%+v\n", err)
+		util.HandlerPackErrorResp(h.resp, consts.ErrorParamCheck, "")
+		log.Info("CreateProject fail,req:%+v", h.req)
+		return
+	}
+	h.resp.Message = "提交初稿修改意见成功"
+	h.resp.Data = res
+	h.resp.Status = consts.ErrorSuccess
+}
+
+func (h *LocalSketchOpinionHandler) checkParam() error {
+	return nil
+}

handler/localtaskdatalist.go

@@ -0,0 +1,60 @@
+package handler
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+	"youngee_b_api/consts"
+	"youngee_b_api/model/http_model"
+	"youngee_b_api/service"
+	"youngee_b_api/util"
+)
+
+func WrapLocalTaskDatalistHandler(ctx *gin.Context) {
+	handler := newLocalTaskDatalistHandler(ctx)
+	baseRun(handler)
+}
+
+type LocalTaskDatalist struct {
+	ctx  *gin.Context
+	req  *http_model.LocalTaskDatalistRequest
+	resp *http_model.CommonResponse
+}
+
+func (c LocalTaskDatalist) getContext() *gin.Context {
+	return c.ctx
+}
+
+func (c LocalTaskDatalist) getResponse() interface{} {
+	return c.resp
+}
+
+func (c LocalTaskDatalist) getRequest() interface{} {
+	return c.req
+}
+
+func (c LocalTaskDatalist) run() {
+	data := http_model.LocalTaskDatalistRequest{}
+	data = *c.req
+	res, err := service.LocalTask.GetLocalTaskDatalist(c.ctx, data)
+	if err != nil {
+		logrus.Errorf("[GetLocalTaskDatalist] call GetLocalTaskDatalist err:%+v\n", err)
+		util.HandlerPackErrorResp(c.resp, consts.ErrorParamCheck, "")
+		logrus.Info("GetLocalTaskDatalist fail,req:%+v", c.req)
+		return
+	}
+	c.resp.Message = "成功查询数据待审列表"
+	c.resp.Data = res
+	c.resp.Status = consts.ErrorSuccess
+}
+
+func (c LocalTaskDatalist) checkParam() error {
+	return nil
+}
+
+func newLocalTaskDatalistHandler(ctx *gin.Context) *LocalTaskDatalist {
+	return &LocalTaskDatalist{
+		ctx:  ctx,
+		req:  http_model.NewLocalTaskDatalistRequest(),
+		resp: http_model.NewLocalTaskDatalistResponse(),
+	}
+}

handler/localtasklinklist.go

@@ -0,0 +1,60 @@
+package handler
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+	"youngee_b_api/consts"
+	"youngee_b_api/model/http_model"
+	"youngee_b_api/service"
+	"youngee_b_api/util"
+)
+
+func WrapLocalTaskLinklistHandler(ctx *gin.Context) {
+	handler := newLocalTaskLinklistHandler(ctx)
+	baseRun(handler)
+}
+
+type LocalTaskLinklist struct {
+	ctx  *gin.Context
+	req  *http_model.LocalTaskLinklistRequest
+	resp *http_model.CommonResponse
+}
+
+func (c LocalTaskLinklist) getContext() *gin.Context {
+	return c.ctx
+}
+
+func (c LocalTaskLinklist) getResponse() interface{} {
+	return c.resp
+}
+
+func (c LocalTaskLinklist) getRequest() interface{} {
+	return c.req
+}
+
+func (c LocalTaskLinklist) run() {
+	data := http_model.LocalTaskLinklistRequest{}
+	data = *c.req
+	res, err := service.LocalTask.GetLocalTaskLinklist(c.ctx, data)
+	if err != nil {
+		logrus.Errorf("[GetLocalTaskLinklist] call GetLocalTaskLinklist err:%+v\n", err)
+		util.HandlerPackErrorResp(c.resp, consts.ErrorParamCheck, "")
+		logrus.Info("GetLocalTaskLinklist fail,req:%+v", c.req)
+		return
+	}
+	c.resp.Message = "成功查询链接待审列表"
+	c.resp.Data = res
+	c.resp.Status = consts.ErrorSuccess
+}
+
+func (c LocalTaskLinklist) checkParam() error {
+	return nil
+}
+
+func newLocalTaskLinklistHandler(ctx *gin.Context) *LocalTaskLinklist {
+	return &LocalTaskLinklist{
+		ctx:  ctx,
+		req:  http_model.NewLocalTaskLinklistRequest(),
+		resp: http_model.NewLocalTaskLinklistResponse(),
+	}
+}

handler/localtasksketchlist.go

@@ -0,0 +1,60 @@
+package handler
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+	"youngee_b_api/consts"
+	"youngee_b_api/model/http_model"
+	"youngee_b_api/service"
+	"youngee_b_api/util"
+)
+
+func WrapLocalTasksketchlistHandler(ctx *gin.Context) {
+	handler := newLocalTasksketchlistHandler(ctx)
+	baseRun(handler)
+}
+
+type LocalTasksketchlist struct {
+	ctx  *gin.Context
+	req  *http_model.LocalTasksketchlistRequest
+	resp *http_model.CommonResponse
+}
+
+func (c LocalTasksketchlist) getContext() *gin.Context {
+	return c.ctx
+}
+
+func (c LocalTasksketchlist) getResponse() interface{} {
+	return c.resp
+}
+
+func (c LocalTasksketchlist) getRequest() interface{} {
+	return c.req
+}
+
+func (c LocalTasksketchlist) run() {
+	data := http_model.LocalTasksketchlistRequest{}
+	data = *c.req
+	res, err := service.LocalTask.GetLocalTasksketchlist(c.ctx, data)
+	if err != nil {
+		logrus.Errorf("[GetLocalTasksketchList] call GetLocalTasksketchList err:%+v\n", err)
+		util.HandlerPackErrorResp(c.resp, consts.ErrorParamCheck, "")
+		logrus.Info("GetLocalTasksketchList fail,req:%+v", c.req)
+		return
+	}
+	c.resp.Message = "成功查询初稿列表"
+	c.resp.Data = res
+	c.resp.Status = consts.ErrorSuccess
+}
+
+func (c LocalTasksketchlist) checkParam() error {
+	return nil
+}
+
+func newLocalTasksketchlistHandler(ctx *gin.Context) *LocalTasksketchlist {
+	return &LocalTasksketchlist{
+		ctx:  ctx,
+		req:  http_model.NewLocalTasksketchlistRequest(),
+		resp: http_model.NewLocalTasksketchlistResponse(),
+	}
+}

handler/predatalist.go

@@ -43,12 +43,13 @@ func (h PreDataListHandler) run() {
 	res, err := service.Task.GetPreDataList(h.ctx, data)
 	if err != nil {
 		logrus.Errorf("[GetPreDataList] call GetPreDataList err:%+v\n", err)
-		util.HandlerPackErrorResp(h.resp, consts.ErrorInternal, "")
+		util.HandlerPackErrorResp(h.resp, consts.ErrorParamCheck, "")
 		logrus.Info("GetPreDataList fail,req:%+v", h.req)
 		return
 	}
 	h.resp.Message = "成功查询数据待传列表"
 	h.resp.Data = res
+	h.resp.Status = consts.ErrorSuccess
 }
 
 func (h PreDataListHandler) checkParam() error {

handler/presketchlist.go

@@ -38,12 +38,13 @@ func (c PreSketchList) run() {
 	res, err := service.Task.GetPreSketchList(c.ctx, data)
 	if err != nil {
 		logrus.Errorf("[GetPreSketchList] call GetPreSketchList err:%+v\n", err)
-		util.HandlerPackErrorResp(c.resp, consts.ErrorInternal, "")
+		util.HandlerPackErrorResp(c.resp, consts.ErrorParamCheck, "")
 		logrus.Info("GetPreSketchList fail,req:%+v", c.req)
 		return
 	}
 	c.resp.Message = "成功查询待传初稿"
 	c.resp.Data = res
+	c.resp.Status = consts.ErrorSuccess
 }
 
 func (c PreSketchList) checkParam() error {

handler/projectdata.go

@@ -40,12 +40,13 @@ func (c ProjectData) run() {
 	res, err := service.Project.Data(c.ctx, data)
 	if err != nil {
 		logrus.Errorf("[ProjectData] call ProjectData err:%+v\n", err)
-		util.HandlerPackErrorResp(c.resp, consts.ErrorInternal, "")
+		util.HandlerPackErrorResp(c.resp, consts.ErrorParamCheck, "")
 		logrus.Info("ProjectData fail,req:%+v", c.req)
 		return
 	}
 	c.resp.Message = "成功看数据"
 	c.resp.Data = res
+	c.resp.Status = consts.ErrorSuccess
 }
 
 func (c ProjectData) checkParam() error {

handler/reject_data.go

@@ -46,13 +46,13 @@ func (h *RejectDataHandler) run() {
 	res, err := service.Data.RejectData(h.ctx, data)
 	if err != nil {
 		logrus.Errorf("[ReviseOpinionHandler] call Create err:%+v\n", err)
-		util.HandlerPackErrorResp(h.resp, consts.ErrorInternal, "")
+		util.HandlerPackErrorResp(h.resp, consts.ErrorParamCheck, "")
 		log.Info("CreateProject fail,req:%+v", h.req)
 		return
 	}
 	h.resp.Message = "成功拒绝数据"
 	h.resp.Data = res
-	h.resp.Data = data
+	h.resp.Status = consts.ErrorSuccess
 }
 
 func (h *RejectDataHandler) checkParam() error {

handler/reject_link.go

@@ -46,13 +46,13 @@ func (h *RejectLinkHandler) run() {
 	res, err := service.Link.RejectLink(h.ctx, data)
 	if err != nil {
 		logrus.Errorf("[ReviseOpinionHandler] call Create err:%+v\n", err)
-		util.HandlerPackErrorResp(h.resp, consts.ErrorInternal, "")
+		util.HandlerPackErrorResp(h.resp, consts.ErrorParamCheck, "")
 		log.Info("CreateProject fail,req:%+v", h.req)
 		return
 	}
 	h.resp.Message = "成功拒绝链接"
 	h.resp.Data = res
-	h.resp.Data = data
+	h.resp.Status = consts.ErrorSuccess
 }
 
 func (h *RejectLinkHandler) checkParam() error {

handler/reject_sketch.go

@@ -45,13 +45,13 @@ func (h *RejectSketchHandler) run() {
 	res, err := service.Sketch.RejectSketch(h.ctx, data)
 	if err != nil {
 		logrus.Errorf("[ReviseOpinionHandler] call Create err:%+v\n", err)
-		util.HandlerPackErrorResp(h.resp, consts.ErrorInternal, "")
+		util.HandlerPackErrorResp(h.resp, consts.ErrorParamCheck, "")
 		log.Info("CreateProject fail,req:%+v", h.req)
 		return
 	}
 	h.resp.Message = "成功拒绝初稿"
 	h.resp.Data = res
-	h.resp.Data = data
+	h.resp.Status = consts.ErrorSuccess
 }
 func (h *RejectSketchHandler) checkParam() error {
 	return nil

handler/sketch_info.go

@@ -48,11 +48,12 @@ func (h *GetSketchInfoHandler) run() {
 	if err != nil {
 		// 数据库查询失败，返回5001
 		logrus.Errorf("[GetSketchInfoHandler] call GetByID err:%+v\n", err)
-		util.HandlerPackErrorResp(h.resp, consts.ErrorInternal, "")
+		util.HandlerPackErrorResp(h.resp, consts.ErrorParamCheck, "")
 		log.Info("GetProduct fail,req:%+v", h.req)
 		return
 	}
 	h.resp.Data = res
+	h.resp.Status = consts.ErrorSuccess
 }
 func (h *GetSketchInfoHandler) checkParam() error {
 	return nil

handler/sketch_opinion.go

@@ -45,45 +45,48 @@ func (h *SketchOpinionHandler) run() {
 	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, "")
+		util.HandlerPackErrorResp(h.resp, consts.ErrorParamCheck, "")
 		log.Info("CreateProject fail,req:%+v", h.req)
 		return
 	}
 	h.resp.Message = "提交初稿修改意见成功"
 	h.resp.Data = res
-	h.resp.Data = data
+	h.resp.Status = consts.ErrorSuccess
 }
 
-/***
-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
+/*
+**
+
+	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
 		}
-		h.resp.Message = "成功修改物流信息"
-		h.resp.Data = res
-	}
 
 }
-***/
+**
+*/
 func (h *SketchOpinionHandler) checkParam() error {
 	return nil
 }

handler/sketch_photo.go

@@ -48,11 +48,12 @@ func (h *FindSketchPhotoHandler) run() {
 	if err != nil {
 		// 数据库查询失败，返回5001
 		logrus.Errorf("[FindSketchPhotoHandler] call FindByID err:%+v\n", err)
-		util.HandlerPackErrorResp(h.resp, consts.ErrorInternal, "")
+		util.HandlerPackErrorResp(h.resp, consts.ErrorParamCheck, "")
 		log.Info("FindProduct fail,req:%+v", h.req)
 		return
 	}
 	h.resp.Data = res
+	h.resp.Status = consts.ErrorSuccess
 }
 func (h *FindSketchPhotoHandler) checkParam() error {
 	return nil

handler/taskdatalist.go

@@ -38,12 +38,13 @@ func (c TaskDatalist) run() {
 	res, err := service.Task.GetTaskDatalist(c.ctx, data)
 	if err != nil {
 		logrus.Errorf("[GetTaskDatalist] call GetTaskDatalist err:%+v\n", err)
-		util.HandlerPackErrorResp(c.resp, consts.ErrorInternal, "")
+		util.HandlerPackErrorResp(c.resp, consts.ErrorParamCheck, "")
 		logrus.Info("GetTaskDatalist fail,req:%+v", c.req)
 		return
 	}
 	c.resp.Message = "成功查询数据待审列表"
 	c.resp.Data = res
+	c.resp.Status = consts.ErrorSuccess
 }
 
 func (c TaskDatalist) checkParam() error {

handler/tasklinklist.go

@@ -38,12 +38,13 @@ func (c TaskLinklist) run() {
 	res, err := service.Task.GetTaskLinklist(c.ctx, data)
 	if err != nil {
 		logrus.Errorf("[GetTaskLinklist] call GetTaskLinklist err:%+v\n", err)
-		util.HandlerPackErrorResp(c.resp, consts.ErrorInternal, "")
+		util.HandlerPackErrorResp(c.resp, consts.ErrorParamCheck, "")
 		logrus.Info("GetTaskLinklist fail,req:%+v", c.req)
 		return
 	}
 	c.resp.Message = "成功查询链接待审列表"
 	c.resp.Data = res
+	c.resp.Status = consts.ErrorSuccess
 }
 
 func (c TaskLinklist) checkParam() error {

handler/tasksketchlist.go

@@ -38,12 +38,13 @@ func (c Tasksketchlist) run() {
 	res, err := service.Task.GetTasksketchlist(c.ctx, data)
 	if err != nil {
 		logrus.Errorf("[GetTasksketchList] call GetTasksketchList err:%+v\n", err)
-		util.HandlerPackErrorResp(c.resp, consts.ErrorInternal, "")
+		util.HandlerPackErrorResp(c.resp, consts.ErrorParamCheck, "")
 		logrus.Info("GetTasksketchList fail,req:%+v", c.req)
 		return
 	}
 	c.resp.Message = "成功查询初稿待审列表"
 	c.resp.Data = res
+	c.resp.Status = consts.ErrorSuccess
 }
 
 func (c Tasksketchlist) checkParam() error {

model/gorm_model/locallife_info.go

@@ -0,0 +1,54 @@
+package gorm_model
+
+import (
+	"time"
+)
+
+type YounggeeLocalLifeInfo struct {
+	Id                  int        `gorm:"column:id;type:int(11);primary_key;AUTO_INCREMENT;comment:本地生活表主键ID" json:"id"`
+	LocalId             string     `gorm:"column:local_id;type:varchar(10);comment:项目id;NOT NULL" json:"local_id"`
+	LocalType           int        `gorm:"column:local_type;type:tinyint(4);comment:项目类型，1代表公开项目，2代表定向项目" json:"local_type"`
+	LocalPlatform       int        `gorm:"column:local_platform;type:tinyint(4);comment:项目平台，1-7分别代表小红书、抖音、微博、快手、b站、大众点评、知乎" json:"local_platform"`
+	ServiceChargeRate   float64    `gorm:"column:service_charge_rate;type:decimal(10,2);default:0.00;comment:公开服务费率;NOT NULL" json:"service_charge_rate"`
+	StoreId             int        `gorm:"column:store_id;type:int(11);comment:关联门店id" json:"store_id"`
+	StoreRelatedAt      *time.Time `gorm:"column:store_related_at;type:timestamp;comment:关联门店时间" json:"store_related_at"`
+	TeamBuyingId        int        `gorm:"column:team_buying_id;type:int(11);comment:关联团购id" json:"team_buying_id"`
+	TeamBuyingRelatedAt *time.Time `gorm:"column:team_buying_related_at;type:timestamp;comment:关联团购时间" json:"team_buying_related_at"`
+	PromoteBody         int        `gorm:"column:promote_body;type:int(11);comment:推广主体（1门店 2团购）" json:"promote_body"`
+	Donate              int        `gorm:"column:donate;type:int(11);comment:赠送达人套餐（1有赠送 2无赠送）" json:"donate"`
+	LocalName           string     `gorm:"column:local_name;type:varchar(50);comment:任务标题" json:"local_name"`
+	TalentType          string     `gorm:"column:talent_type;type:text;comment:达人类型（,分隔）" json:"talent_type"`
+	RecruitDdl          *time.Time `gorm:"column:recruit_ddl;type:timestamp;comment:招募截止时间" json:"recruit_ddl"`
+	TaskForm            int        `gorm:"column:task_form;type:tinyint(4);comment:任务形式，1-2分别代表线下探店,素材分发" json:"task_form"`
+	ContentType         int        `gorm:"column:content_type;type:tinyint(4);comment:内容形式，1代表图文，2代表视频" json:"content_type"`
+	TaskDetail          string     `gorm:"column:task_detail;type:varchar(1000);comment:任务详情" json:"task_detail"`
+	TaskStatus          int        `gorm:"column:task_status;type:tinyint(4);comment:项目状态，1-10分别代表创建中、待审核、审核通过、招募中、招募完毕、待支付、已支付、执行中、失效、已结案" json:"task_status"`
+	EnterpriseId        string     `gorm:"column:enterprise_id;type:varchar(10);comment:所属企业id" json:"enterprise_id"`
+	SubAccountId        int        `gorm:"column:sub_account_id;type:int(11);default:0;comment:子账号id;NOT NULL" json:"sub_account_id"`
+	OperatorType        int        `gorm:"column:operator_type;type:int(11);comment:创建者类型，1商家主账号，2商家子账号" json:"operator_type"`
+	ApplyNum            int64      `gorm:"column:apply_num;type:int(11);default:0;comment:报名人数;NOT NULL" json:"apply_num"`
+	RecruitNum          int64      `gorm:"column:recruit_num;type:int(11);default:0;comment:已招募人数;NOT NULL" json:"recruit_num"`
+	SettleNum           int64      `gorm:"column:settle_num;type:int(11);default:0;comment:结案人数;NOT NULL" json:"settle_num"`
+	CreatedAt           *time.Time `gorm:"column:created_at;type:timestamp;comment:创建时间" json:"created_at"`
+	UpdatedAt           *time.Time `gorm:"column:updated_at;type:timestamp;comment:修改时间" json:"updated_at"`
+	AutoFailAt          *time.Time `gorm:"column:auto_fail_at;type:timestamp;comment:失效自动处理时间" json:"auto_fail_at"`
+	AutoTaskId          int        `gorm:"column:auto_task_id;type:int(11);default:0;comment:定时任务id;NOT NULL" json:"auto_task_id"`
+	AutoDefaultId       int        `gorm:"column:auto_default_id;type:int(11);default:0;comment:违约状态id;NOT NULL" json:"auto_default_id"`
+	PaymentAmount       float64    `gorm:"column:payment_amount;type:float;comment:支付金额" json:"payment_amount"`
+	PayAt               *time.Time `gorm:"column:pay_at;type:timestamp;comment:支付时间" json:"pay_at"`
+	SubmitAt            *time.Time `gorm:"column:submit_at;type:timestamp;comment:提交审核时间" json:"submit_at"`
+	PassAt              *time.Time `gorm:"column:pass_at;type:timestamp;comment:审核通过时间" json:"pass_at"`
+	FinishAt            *time.Time `gorm:"column:finish_at;type:timestamp;comment:结案时间" json:"finish_at"`
+	EstimatedCost       float64    `gorm:"column:estimated_cost;type:decimal(10,2);comment:预估成本" json:"estimated_cost"`
+	SettlementAmount    float64    `gorm:"column:settlement_amount;type:decimal(10,2);comment:结算金额" json:"settlement_amount"`
+	TotalRecruitNum     int        `gorm:"column:total_recruit_num;type:int(11);comment:此任务各策略招募人数总和" json:"total_recruit_num"`
+	Tools               string     `gorm:"column:tools;type:varchar(255);comment:工具选择，1邀约招募 2样品物流 3审稿工具 4作品审查 5数据巡检 6结算账单（,分隔）;NOT NULL" json:"tools"`
+	NeedReview          int        `gorm:"column:need_review;type:int(11);default:0;comment:待审稿;NOT NULL" json:"need_review"`
+	NeedQuality         int        `gorm:"column:need_quality;type:int(11);default:0;comment:待质检;NOT NULL" json:"need_quality"`
+	NeedCalculate       int        `gorm:"column:need_calculate;type:int(11);default:0;comment:待结算;NOT NULL" json:"need_calculate"`
+	InvoiceStatus       int        `gorm:"column:invoice_status;type:int(11);default:0;comment:开票状态（1开票中 2已开票）;NOT NULL" json:"invoice_status"`
+}
+
+func (m *YounggeeLocalLifeInfo) TableName() string {
+	return "younggee_local_life_info"
+}

model/gorm_model/locallife_task_info.go

@@ -0,0 +1,86 @@
+package gorm_model
+
+import (
+	"time"
+)
+
+// 种草子任务
+type YoungeeLocalTaskInfo struct {
+	TaskId                 string    `gorm:"column:task_id;type:char(15);primary_key;comment:任务id" json:"task_id"`
+	LocalId                string    `gorm:"column:local_id;type:char(10);comment:项目id;NOT NULL" json:"local_id"`
+	TalentId               string    `gorm:"column:talent_id;type:char(25);comment:达人id;NOT NULL" json:"talent_id"`
+	AccountId              int       `gorm:"column:account_id;type:int(11);comment:账号id;NOT NULL" json:"account_id"`
+	StrategyId             int       `gorm:"column:strategy_id;type:int(11);comment:报名选择的招募策略id" json:"strategy_id"`
+	TalentPlatformInfoSnap string    `gorm:"column:talent_platform_info_snap;type:json;comment:达人平台信息快照;NOT NULL" json:"talent_platform_info_snap"`
+	TalentPersonalInfoSnap string    `gorm:"column:talent_personal_info_snap;type:json;comment:达人个人信息快照;NOT NULL" json:"talent_personal_info_snap"`
+	TalentPostAddrSnap     string    `gorm:"column:talent_post_addr_snap;type:json;comment:收货地址快照;NOT NULL" json:"talent_post_addr_snap"`
+	TaskReward             float64   `gorm:"column:task_reward;type:decimal(10,2);comment:达人报酬(3.0未用);NOT NULL" json:"task_reward"`
+	SettleAmount           float64   `gorm:"column:settle_amount;type:decimal(10,2);comment:达人实际所得（自动填充）（扣除违约扣款）;NOT NULL" json:"settle_amount"`
+	AllPayment             float64   `gorm:"column:all_payment;type:decimal(10,2);comment:企业支付(3.0未用);NOT NULL" json:"all_payment"`
+	RealPayment            float64   `gorm:"column:real_payment;type:decimal(10,2);comment:企业实际支付(加上服务商的服务费)（扣除违约扣款）;NOT NULL" json:"real_payment"`
+	ServiceRate            int       `gorm:"column:service_rate;type:int(11);comment:服务费率，千分之" json:"service_rate"`
+	ServiceCharge          float64   `gorm:"column:service_charge;type:decimal(10,2);comment:服务费" json:"service_charge"`
+	RealServiceCharge      float64   `gorm:"column:real_service_charge;type:decimal(10,2);comment:服务商实际所得服务费（扣除违约）" json:"real_service_charge"`
+	FeeForm                int       `gorm:"column:fee_form;type:tinyint(4);comment:稿费形式，1,2,3分别代表产品置换、一口价、自报价" json:"fee_form"`
+	ErrBreakRate           int       `gorm:"column:err_break_rate;type:int(11);default:0;comment:未上传类型违约扣款比例，百分之;NOT NULL" json:"err_break_rate"`
+	ScriptBreakRate        int       `gorm:"column:script_break_rate;type:int(11);default:0;comment:脚本上传超时违约扣款比例，百分之;NOT NULL" json:"script_break_rate"`
+	SketchBreakRate        int       `gorm:"column:sketch_break_rate;type:int(11);default:0;comment:初稿上传超时违约扣款比例，百分之;NOT NULL" json:"sketch_break_rate"`
+	LinkBreakRate          int       `gorm:"column:link_break_rate;type:int(11);default:0;comment:链接上传超时违约扣款比例，百分之;NOT NULL" json:"link_break_rate"`
+	DataBreakRate          int       `gorm:"column:data_break_rate;type:int(11);default:0;comment:数据上传超时违约扣款比例，百分之;NOT NULL" json:"data_break_rate"`
+	TaskStage              int       `gorm:"column:task_stage;type:tinyint(1);comment:任务阶段，1:已报名, 2:申请成功, 3:申请失败, 4:待预约探店, 5:预约确认中 6:  , 7:待传脚本, 8:脚本待审, 9:待传初稿, 10:初稿待审, 11:待传链接, 12:链接待审, 13:待传数据, 14:数据待审, 15:已结案, 16:解约, 17：终止合作（过渡态）;NOT NULL" json:"task_stage"`
+	TaskStatus             int       `gorm:"column:task_status;type:tinyint(4);default:1;comment:商家任务状态 1待选 2已选 3落选;NOT NULL" json:"task_status"`
+	LogisticsStatus        int       `gorm:"column:logistics_status;type:tinyint(1);default:1;comment:发货状态 1 待发货 2已发货 3 已签收" json:"logistics_status"`
+	BookStatus             uint      `gorm:"column:book_status;type:tinyint(4) unsigned;default:1;comment:预约探店状态 1-5分别代表待预约、已预约、待修改、已修改、已通过" json:"book_status"`
+	SketchStatus           uint      `gorm:"column:sketch_status;type:tinyint(4) unsigned;default:1;comment:初稿上传状态 1-5分别代表待添加、已添加、待修改、已修改、已通过" json:"sketch_status"`
+	LinkStatus             uint      `gorm:"column:link_status;type:tinyint(4) unsigned;default:1;comment:链接上传状态 1-5分别代表待添加、已添加、待修改、已修改、已通过" json:"link_status"`
+	DataStatus             uint      `gorm:"column:data_status;type:tinyint(4) unsigned;default:1;comment:数据上传状态 1-5分别代表待添加、已添加、待修改、已修改、已通过" json:"data_status"`
+	CompleteStatus         int       `gorm:"column:complete_status;type:tinyint(1);default:1;comment:结束方式 1未结束 2正常结束 3反选失败 4被解约" json:"complete_status"`
+	UpdateAt               time.Time `gorm:"column:update_at;type:datetime;comment:更新时间" json:"update_at"`
+	CreateDate             time.Time `gorm:"column:create_date;type:datetime;comment:创建时间，即报名时间;NOT NULL" json:"create_date"`
+	SelectDate             time.Time `gorm:"column:select_date;type:datetime;comment:反选时间，即任务开始执行时间" json:"select_date"`
+	DeliveryDate           time.Time `gorm:"column:delivery_date;type:datetime;comment:发货时间" json:"delivery_date"`
+	CompleteDate           time.Time `gorm:"column:complete_date;type:datetime;comment:结束时间" json:"complete_date"`
+	WithdrawDate           time.Time `gorm:"column:withdraw_date;type:datetime;comment:提现时间" json:"withdraw_date"`
+	CurDefaultType         int       `gorm:"column:cur_default_type;type:tinyint(4);comment:当前违约类型 0未违约 1脚本超时违约 2脚本未上传违约 3初稿超时违约 4初稿未上传违约 5链接超时违约 6链接未上传违约 7数据超时违约 8数据未上传违约 9解约待处理 10解约" json:"cur_default_type"`
+	WithdrawStatus         int       `gorm:"column:withdraw_status;type:tinyint(4);default:1;comment:提现状态，1-4分别代表不可提现、可提现、提现中、已提现" json:"withdraw_status"`
+	LeadTeamId             string    `gorm:"column:lead_team_id;type:char(10);comment:作为团长的young之团id，对应younggee_talent_team中的team_id字段" json:"lead_team_id"`
+	TeamId                 string    `gorm:"column:team_id;type:char(10);comment:作为团员的young之团id，对应younggee_talent_team中的team_id字段" json:"team_id"`
+	SettleStatus           int       `gorm:"column:settle_status;type:tinyint(4);default:1;comment:结算状态，1、2分别表示待结算、已结算" json:"settle_status"`
+	TeamIncome             float64   `gorm:"column:team_income;type:decimal(10,2);comment:young之团团长现金收益" json:"team_income"`
+	TeamPoint              int       `gorm:"column:team_point;type:int(11);comment:young之团团长积分收益" json:"team_point"`
+	CurBreakAt             time.Time `gorm:"column:cur_break_at;type:datetime;comment:当前阶段截止时间" json:"cur_break_at"`
+	SupplierId             int       `gorm:"column:supplier_id;type:int(11);default:0;comment:服务商ID" json:"supplier_id"`
+	SupplierStatus         int       `gorm:"column:supplier_status;type:int(11);default:0;comment:服务商任务状态 0表示达人来源非服务商 1待选 2已选 3落选" json:"supplier_status"`
+	DraftFee               float64   `gorm:"column:draft_fee;type:decimal(10,2);default:0.00;comment:达人稿费，达人所见的稿费金额" json:"draft_fee"`
+	SignedTime             time.Time `gorm:"column:signed_time;type:datetime;comment:签收时间" json:"signed_time"`
+	FansNum                int       `gorm:"column:fans_num;type:int(11);comment:粉丝数" json:"fans_num"`
+	VoteAvg                int       `gorm:"column:vote_avg;type:int(11);comment:平均点赞数" json:"vote_avg"`
+	CommitAvg              int       `gorm:"column:commit_avg;type:int(11);comment:平均评论数" json:"commit_avg"`
+	BOperator              string    `gorm:"column:b_operator;type:varchar(255);comment:商家确定达人操作人ID" json:"b_operator"`
+	BOperatorType          int       `gorm:"column:b_operator_type;type:int(11);default:0;comment:商家操作人类型，1商家用户，2商家子账号，3管理后台" json:"b_operator_type"`
+	SOperator              int       `gorm:"column:s_operator;type:int(11);default:0;comment:服务商提报达人操作人ID" json:"s_operator"`
+	SOperatorType          int       `gorm:"column:s_operator_type;type:int(11);default:0;comment:服务商操作人类型，1服务商主账号，2服务商子账号，3管理后台" json:"s_operator_type"`
+	OpenId                 string    `gorm:"column:open_id;type:varchar(255);comment:达人报名的快手唯一标识" json:"open_id"`
+	SLocalLifeId           int       `gorm:"column:s_local_life_id;type:int(11);comment:服务商种草任务ID" json:"s_local_life_id"`
+	SupportFee             float64   `gorm:"column:support_fee;type:decimal(10,2);comment:提报价格(达人自报价经过计算后,)" json:"support_fee"`
+	SketchMissingTime      time.Time `gorm:"column:sketch_missing_time;type:datetime;comment:未传初稿违约时间" json:"sketch_missing_time"`
+	SketchMissingStatus    int       `gorm:"column:sketch_missing_status;type:int(11);default:0;comment:未传初稿违约状态，0无违约，1有违约" json:"sketch_missing_status"`
+	LinkMissingTime        time.Time `gorm:"column:link_missing_time;type:datetime;comment:未发作品违约时间" json:"link_missing_time"`
+	LinkMissingStatus      int       `gorm:"column:link_missing_status;type:int(11);default:0;comment:未发作品违约状态，0无违约，1有违约" json:"link_missing_status"`
+	DataMissingTime        time.Time `gorm:"column:data_missing_time;type:datetime;comment:未传数据违约时间" json:"data_missing_time"`
+	DataMissingStatus      int       `gorm:"column:data_missing_status;type:int(11);default:0;comment:未传数据违约状态，0无违约，1有违约" json:"data_missing_status"`
+	TerminateOperatorType  int       `gorm:"column:terminate_operator_type;type:int(11);comment:终止合作操作人类型，1商家用户，2商家子账号，3管理后台" json:"terminate_operator_type"`
+	TerminateOperator      string    `gorm:"column:terminate_operator;type:varchar(255);comment:终止合作操作人ID" json:"terminate_operator"`
+	TerminateReason        string    `gorm:"column:terminate_reason;type:varchar(255);comment:终止理由" json:"terminate_reason"`
+	TerminateTime          time.Time `gorm:"column:terminate_time;type:datetime;comment:终止合作时间" json:"terminate_time"`
+	CancelOperatorType     int       `gorm:"column:cancel_operator_type;type:int(11);comment:解约操作人类型，1商家用户，2商家子账号，3管理后台" json:"cancel_operator_type"`
+	CancelOperator         string    `gorm:"column:cancel_operator;type:varchar(255);comment:解约操作人ID" json:"cancel_operator"`
+	CancelReason           string    `gorm:"column:cancel_reason;type:varchar(255);comment:解约原因" json:"cancel_reason"`
+	CancelTime             time.Time `gorm:"column:cancel_time;type:datetime;comment:解约时间" json:"cancel_time"`
+	PlatformId             int       `gorm:"column:platform_id;type:int(11);comment:平台" json:"platform_id"`
+	City                   string    `gorm:"column:city;type:varchar(255);comment:城市" json:"city"`
+}
+
+func (m *YoungeeLocalTaskInfo) TableName() string {
+	return "youngee_local_task_info"
+}

model/gorm_model/project.go

@@ -17,36 +17,37 @@ type ProjectInfo struct {
 	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      string     `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        int64      `gorm:"column:fail_reason"`                    // 失效原因，1、2分别表示逾期未支付、项目存在风险
-	PassAt            *time.Time `gorm:"column:pass_at"`                        // 审核通过时间
-	FinishAt          *time.Time `gorm:"column:finish_at"`                      // 结案时间
-	SubmitAt          *time.Time `gorm:"column:submit_at"`                      // 结案时间
-	EstimatedCost     float64    `gorm:"column:estimated_cost"`                 // 预估成本
-	IsRead            int64      `gorm:"column:is_read"`                        // 是否已读
-	SettlementAmount  float64    `gorm:"column:settlement_amount"`              // 结算金额
-	ProductSnap       string     `gorm:"column:product_snap"`                   // 商品信息快照
-	ProductPhotoSnap  string     `gorm:"column:product_photo_snap"`             // 商品图片快照
-	NeedReview        int64      `gorm:"column:need_review"`                    // 待审稿
-	NeedQuality       int64      `gorm:"column:need_quality"`                   // 待质检
-	NeedCalculate     int64      `gorm:"column:need_calculate"`                 // 待结算
-	ServiceChargeRate float64    `gorm:"column:service_charge_rate"`            // 公开服务费率
-	OperatorType      *int64     `gorm:"column:operator_type"`                  // 创建者类型，1商家主账号，2商家子账号
-	TotalRecruitNum   *int64     `gorm:"column:total_recruit_num"`              // 此任务各策略招募人数总和
-	ViewNum           int64      `gorm:"column:view_num"`                       // 浏览量
-	Tools             string     `gorm:"column:tools"`                          // 工具选择，1邀约招募 2结算账单 3样品物流 4审稿工具 5作品审查 6数据巡检（,分隔）
-	InvoiceStatus     int64      `gorm:"column:invoice_status"`                 // 开票状态（1开票中 2已开票）
+	SettleNum         int64      `gorm:"column:settle_num;type:int(11);default:0;comment:结案人数;NOT NULL" json:"settle_num"`
+	EnterpriseID      string     `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        int64      `gorm:"column:fail_reason"`              // 失效原因，1、2分别表示逾期未支付、项目存在风险
+	PassAt            *time.Time `gorm:"column:pass_at"`                  // 审核通过时间
+	FinishAt          *time.Time `gorm:"column:finish_at"`                // 结案时间
+	SubmitAt          *time.Time `gorm:"column:submit_at"`                // 结案时间
+	EstimatedCost     float64    `gorm:"column:estimated_cost"`           // 预估成本
+	IsRead            int64      `gorm:"column:is_read"`                  // 是否已读
+	SettlementAmount  float64    `gorm:"column:settlement_amount"`        // 结算金额
+	ProductSnap       string     `gorm:"column:product_snap"`             // 商品信息快照
+	ProductPhotoSnap  string     `gorm:"column:product_photo_snap"`       // 商品图片快照
+	NeedReview        int64      `gorm:"column:need_review"`              // 待审稿
+	NeedQuality       int64      `gorm:"column:need_quality"`             // 待质检
+	NeedCalculate     int64      `gorm:"column:need_calculate"`           // 待结算
+	ServiceChargeRate float64    `gorm:"column:service_charge_rate"`      // 公开服务费率
+	OperatorType      *int64     `gorm:"column:operator_type"`            // 创建者类型，1商家主账号，2商家子账号
+	TotalRecruitNum   *int64     `gorm:"column:total_recruit_num"`        // 此任务各策略招募人数总和
+	ViewNum           int64      `gorm:"column:view_num"`                 // 浏览量
+	Tools             string     `gorm:"column:tools"`                    // 工具选择，1邀约招募 2结算账单 3样品物流 4审稿工具 5作品审查 6数据巡检（,分隔）
+	InvoiceStatus     int64      `gorm:"column:invoice_status"`           // 开票状态（1开票中 2已开票）
 }
 
 func (m *ProjectInfo) TableName() string {

model/gorm_model/project_task.go

@@ -71,6 +71,7 @@ type YoungeeTaskInfo struct {
 	CancelOperator         string    `gorm:"column:cancel_operator;type:varchar(255);comment:解约操作人ID" json:"cancel_operator"`
 	CancelReason           string    `gorm:"column:cancel_reason;type:varchar(255);comment:解约原因" json:"cancel_reason"`
 	CancelTime             time.Time `gorm:"column:cancel_time;type:datetime;comment:解约时间" json:"cancel_time"`
+	City                   string    `gorm:"column:city"` //报名达人的所在城市
 }
 
 func (m *YoungeeTaskInfo) TableName() string {

model/gorm_model/s_locallife_info.go

@@ -0,0 +1,30 @@
+package gorm_model
+
+import (
+	"time"
+)
+
+type YounggeeSLocalLifeInfo struct {
+	SLocalLifeId        int       `gorm:"column:s_local_life_id;type:int(11);primary_key" json:"s_local_life_id"`
+	LocalLifeId         int       `gorm:"column:local_life_id;type:int(11);comment:被加入商单的原本地生活ID" json:"local_life_id"`
+	EnterpriseId        string    `gorm:"column:enterprise_id;type:varchar(255);comment:商家ID" json:"enterprise_id"`
+	SupplierId          int       `gorm:"column:supplier_id;type:int(11);comment:服务商ID" json:"supplier_id"`
+	ApplyNum            int       `gorm:"column:apply_num;type:int(11);comment:报名人数" json:"apply_num"`
+	RecruitNum          int       `gorm:"column:recruit_num;type:int(11);comment:已招募人数" json:"recruit_num"`
+	SettleNum           int       `gorm:"column:settle_num;type:int(11);default:0;comment:已结算人数" json:"settle_num"`
+	SubAccountId        int       `gorm:"column:sub_account_id;type:int(11);comment:服务商子账号ID" json:"sub_account_id"`
+	ServiceCharge       string    `gorm:"column:service_charge;type:varchar(255);comment:服务商预估可赚服务费" json:"service_charge"`
+	ServiceChargeActual string    `gorm:"column:service_charge_actual;type:varchar(255);comment:服务商实际可赚服务费" json:"service_charge_actual"`
+	OperatorType        string    `gorm:"column:operator_type;type:varchar(255);comment:添加商单操作人类型，1为服务商主账号，2为服务商子账号" json:"operator_type"`
+	SProjectStatus      string    `gorm:"column:s_project_status;type:varchar(255);comment:服务商本地生活任务状态，1待确认，2已确认，3已拒绝" json:"s_project_status"`
+	StrategyStatus      string    `gorm:"column:strategy_status;type:varchar(255);comment:定向本地生活任务是否替换招募策略" json:"strategy_status"`
+	BOperator           string    `gorm:"column:b_operator;type:varchar(255);comment:商家发起入库邀约人" json:"b_operator"`
+	BOperatorType       string    `gorm:"column:b_operator_type;type:varchar(255);comment:商家发起入库邀约人类型：1主账号 2子账号" json:"b_operator_type"`
+	CreateTime          time.Time `gorm:"column:create_time;type:datetime;comment:创建时间" json:"create_time"`
+	CreateStrategyId    int       `gorm:"column:create_strategy_id;type:int(11)" json:"create_strategy_id"`
+	CreateStrategyType  string    `gorm:"column:create_strategy_type;type:varchar(255)" json:"create_strategy_type"`
+}
+
+func (m *YounggeeSLocalLifeInfo) TableName() string {
+	return "younggee_s_local_life_info"
+}

model/http_model/LocalPrelinkList.go

@@ -0,0 +1,31 @@
+package http_model
+
+import "time"
+
+type LocalPreLinkListRequest struct {
+	PageSize     int    `json:"page_size"`
+	PageNum      int    `json:"page_num"`
+	ProjectId    string `json:"project_id"`  // 项目ID
+	LinkStatus   string `json:"link_status"` // 链接状态，11待传链接
+	EnterpriseId string `json:"enterprise_id"`
+}
+
+type GetLocalPreLinkListData struct {
+	TasklinkList []*LocalTasklinkinfo `json:"task_list"`
+	Total        string               `json:"total"`
+}
+
+type LocalTasklinkinfo struct {
+	Task *LocaLTaskInfo `json:"task_info"`
+	DDl  time.Time      `json:"ddl"` // 提交时间
+}
+
+func NewLocalPreLinkListRequest() *LocalPreLinkListRequest {
+	return new(LocalPreLinkListRequest)
+}
+
+func NewLocalPreLinkListResponse() *CommonResponse {
+	resp := new(CommonResponse)
+	resp.Data = new(GetLocalPreLinkListData)
+	return resp
+}

model/http_model/PassLocalTaskCoopRequest.go

@@ -0,0 +1,23 @@
+package http_model
+
+type PasslocalTaskCoopRequest struct {
+	ProjectId   string   `json:"project_id"`
+	TaskIds     []string `json:"task_ids"`
+	SProjectId  *int     `json:"s_project_id"`
+	OperatorId  string   `json:"operator_id"`
+	OperateType int      `json:"operate_type"`
+	IsSpecial   int      `json:"is_special"`
+}
+
+type PasslocalTaskCoopData struct {
+}
+
+func NewPasslocalTaskCoopRequest() *PasslocalTaskCoopRequest {
+	return new(PasslocalTaskCoopRequest)
+}
+
+func NewPasslocalTaskCoopResponse() *CommonResponse {
+	resp := new(CommonResponse)
+	resp.Data = new(PasslocalTaskCoopData)
+	return resp
+}

model/http_model/PreLinkList.go

@@ -26,6 +26,6 @@ func NewPreLinkListRequest() *PreLinkListRequest {
 
 func NewPreLinkListResponse() *CommonResponse {
 	resp := new(CommonResponse)
-	resp.Data = new(GetSketchTaskListData)
+	resp.Data = new(GetprelinkListData)
 	return resp
 }

model/http_model/data_accept.go

@@ -11,7 +11,7 @@ type AcceptDataRequest struct {
 
 type AcceptDataData struct {
 	TaskIds []string `json:"taskIds"` //任务id列表
-	IsEnd   int      `json:"is_end"`  // 项目是否结案
+	//IsEnd   int      `json:"is_end"`  // 项目是否结案
 }
 
 func NewAcceptDataRequest() *AcceptDataRequest {

model/http_model/data_localaccept.go

@@ -0,0 +1,24 @@
+package http_model
+
+type LocalAcceptDataRequest struct {
+	//Payment   float64 `json:"payment"`      //招募策略id
+	TaskIds     string `json:"task_id_list"` //任务id列表
+	ProjectId   string `json:"project_id"`   //项目id
+	IsSpecial   int    `json:"is_special"`   // 是否为专项项目
+	OperatorId  string `json:"operator_id"`
+	OperateType int    `json:"operate_type"`
+}
+
+type LocalAcceptDataData struct {
+	TaskIds []string `json:"taskIds"` //任务id列表
+	//IsEnd   int      `json:"is_end"`  // 项目是否结案
+}
+
+func NewLocalAcceptDataRequest() *LocalAcceptDataRequest {
+	return new(LocalAcceptDataRequest)
+}
+func NewLocalAcceptDataResponse() *CommonResponse {
+	resp := new(CommonResponse)
+	resp.Data = new(LocalAcceptDataData)
+	return resp
+}

model/http_model/getlocaltasklist.go

@@ -0,0 +1,52 @@
+package http_model
+
+import "time"
+
+type GetLocalTaskListRequest struct {
+	PageSize       int    `json:"page_size"`
+	PageNum        int    `json:"page_num"`
+	TalentFromList string `json:"talent_from_list"`
+	FeeFrom        *int   `json:"fee_from,omitempty"`
+	Type           *int   `json:"type,omitempty"` // 查询类型，1、2分别表示达人来源于公海(商家端)，服务商
+	ProjectId      string `json:"project_id"`
+	CoopType       int    `json:"coop_type"` //1未处理,2同意，3拒绝
+	EnterPriseId   string `json:"enterprise_id"`
+}
+
+type GetLocalTaskListData struct {
+	TaskList []*LocaLTaskInfo `json:"task_list"`
+	Total    string           `json:"total"`
+}
+
+type LocaLTaskInfo struct {
+	TaskId             string  `json:"task_id"`
+	ProjectId          string  `json:"project_id"`
+	TalentId           string  `json:"talent_id"`
+	FansNum            int     `json:"fans_num"`
+	DraftFee           float64 `json:"draft_fee"`
+	FeeFrom            int     `json:"fee_from"`
+	TaskStage          int     `json:"task_stage"`
+	Voteavg            int     `json:"vote_avg"`
+	Commentavg         int     `json:"commit_avg"`
+	CurrentDefaultType int     `json:"current_default_type"`
+	From               int     `json:"from"`   //1公海，2服务商
+	SType              int     `json:"s_type"` //1个人，2机构
+	Boperator          string  `json:"b_operator"`
+	//SettleAmount       float64   `json:"settle_amount"`
+	CreateAt   time.Time `json:"create_time"`
+	ISCoop     int       `json:"is_coop"`
+	NickName   string    `json:"nick_name"`
+	HeadUrl    string    `json:"head_url"`
+	Sprojectid int       `json:"sprojectid"`
+	City       string    `json:"city"`
+}
+
+func NewGetLocalTaskListRequest() *GetLocalTaskListRequest {
+	return new(GetLocalTaskListRequest)
+}
+
+func NewGetLocalTaskListResponse() *CommonResponse {
+	resp := new(CommonResponse)
+	resp.Data = new(GetLocalTaskListData)
+	return resp
+}

model/http_model/gettasklist.go

@@ -18,25 +18,26 @@ type GetTaskListData struct {
 }
 
 type TaskInfo struct {
-	TaskId             string    `json:"task_id"`
-	ProjectId          string    `json:"project_id"`
-	TalentId           string    `json:"talent_id"`
-	FansNum            int       `json:"fans_num"`
-	DraftFee           float64   `json:"draft_fee"`
-	FeeFrom            int       `json:"fee_from"`
-	TaskStage          int       `json:"task_stage"`
-	Voteavg            int       `json:"vote_avg"`
-	Commentavg         int       `json:"commit_avg"`
-	CurrentDefaultType int       `json:"current_default_type"`
-	From               int       `json:"from"`   //1公海，2服务商
-	SType              int       `json:"s_type"` //1个人，2机构
-	Boperator          string    `json:"b_operator"`
-	SettleAmount       float64   `json:"settle_amount"`
-	CreateAt           time.Time `json:"create_time"`
-	ISCoop             int       `json:"is_coop"`
-	NickName           string    `json:"nick_name"`
-	HeadUrl            string    `json:"head_url"`
-	Sprojectid         int       `json:"sprojectid"`
+	TaskId             string  `json:"task_id"`
+	ProjectId          string  `json:"project_id"`
+	TalentId           string  `json:"talent_id"`
+	FansNum            int     `json:"fans_num"`
+	DraftFee           float64 `json:"draft_fee"`
+	FeeFrom            int     `json:"fee_from"`
+	TaskStage          int     `json:"task_stage"`
+	Voteavg            int     `json:"vote_avg"`
+	Commentavg         int     `json:"commit_avg"`
+	CurrentDefaultType int     `json:"current_default_type"`
+	From               int     `json:"from"`   //1公海，2服务商
+	SType              int     `json:"s_type"` //1个人，2机构
+	Boperator          string  `json:"b_operator"`
+	//SettleAmount       float64   `json:"settle_amount"`
+	CreateAt   time.Time `json:"create_time"`
+	ISCoop     int       `json:"is_coop"`
+	NickName   string    `json:"nick_name"`
+	HeadUrl    string    `json:"head_url"`
+	City       string    `json:"city"`
+	Sprojectid int       `json:"sprojectid"`
 }
 
 func NewGetTaskListRequest() *GetTaskListRequest {

model/http_model/link_localaccept.go

@@ -0,0 +1,22 @@
+package http_model
+
+type LocalAcceptLinkRequest struct {
+	TaskIds     string `json:"task_id_list"` //任务id列表
+	ProjectId   string `json:"project_id"`
+	OperatorId  string `json:"operator_id"`
+	OperateType int    `json:"operate_type"`
+	Isspecial   int    `json:"is_special"`
+}
+
+type LocalAcceptLinkData struct {
+	TaskIds []string `json:"task_id_list"` //任务id列表
+}
+
+func NewLocalAcceptLinkRequest() *LocalAcceptLinkRequest {
+	return new(LocalAcceptLinkRequest)
+}
+func NewLocalAcceptLinkResponse() *CommonResponse {
+	resp := new(CommonResponse)
+	resp.Data = new(LocalAcceptLinkData)
+	return resp
+}

model/http_model/localdata_opinion.go

@@ -0,0 +1,22 @@
+package http_model
+
+type LocalDataOpinionRequest struct {
+	TaskID           string `json:"task_id"` //任务-id
+	ProjectId        string `json:"project_id"`
+	LocalDataOpinion string `json:"Data_opinion"` //数据审核意见
+	OperatorId       string `json:"operator_id"`
+	OperateType      int    `json:"operate_type"`
+}
+
+type LocalDataOpinionData struct {
+	TaskID string `json:"task_id"` // 任务ID
+}
+
+func NewLocalDataOpinionRequest() *LocalDataOpinionRequest {
+	return new(LocalDataOpinionRequest)
+}
+func NewLocalDataOpinionResponse() *CommonResponse {
+	resp := new(CommonResponse)
+	resp.Data = new(LocalDataOpinionData)
+	return resp
+}

model/http_model/locallifedatarequest.go

@@ -0,0 +1,31 @@
+package http_model
+
+import "time"
+
+type LocallifeDataRequest struct {
+	LocallifeId string `json:"Locallife_id"`
+}
+
+type LocallifeDataResponse struct {
+	RecruitDDl  time.Time      `json:"recruit_ddl"`
+	Recruittime time.Time      `json:"recruit_time"`
+	ApplyNum    int64          `json:"apply_num"`
+	AgreeNum    int64          `json:"agree_num"`
+	DraftFee    float64        `json:"draft_fee"`
+	AvgFansNum  int            `json:"avg_fans_num"`
+	FromType    float64        `json:"from_type"`
+	ManRatio    float64        `json:"man_ratio"`
+	FeeMap      map[int]int    `json:"fee_map"`
+	FansMap     map[int64]int  `json:"fans_map"`
+	DateStats   map[string]int `json:"date_stats"`
+}
+
+func NewLocallifeDataRequest() *LocallifeDataRequest {
+	return new(LocallifeDataRequest)
+}
+
+func NewLocallifeDataResponse() *CommonResponse {
+	resp := new(CommonResponse)
+	resp.Data = new(LocallifeDataResponse)
+	return resp
+}

model/http_model/locallink_opinion.go

@@ -0,0 +1,22 @@
+package http_model
+
+type LocalLinkOpinionRequest struct {
+	TaskID           string `json:"task_id"` //任务-id
+	ProjectId        string `json:"project_id"`
+	LocalLinkOpinion string `json:"Link_opinion"` //链接审核意见
+	OperatorId       string `json:"operator_id"`
+	OperateType      int    `json:"operate_type"`
+}
+
+type LocalLinkOpinionData struct {
+	TaskID string `json:"task_id"` // 任务ID
+}
+
+func NewLocalLinkOpinionRequest() *LocalLinkOpinionRequest {
+	return new(LocalLinkOpinionRequest)
+}
+func NewLocalLinkOpinionResponse() *CommonResponse {
+	resp := new(CommonResponse)
+	resp.Data = new(LocalLinkOpinionData)
+	return resp
+}

model/http_model/localpredatalist.go

@@ -0,0 +1,31 @@
+package http_model
+
+import "time"
+
+type LocalPreDataListRequest struct {
+	PageSize     int    `json:"page_size"`
+	PageNum      int    `json:"page_num"`
+	ProjectId    string `json:"project_id"`  // 项目ID
+	DataStatus   string `json:"data_status"` // 数据状态，13待传数据
+	EnterpriseId string `json:"enterprise_id"`
+}
+
+type GetLocalPreDataListData struct {
+	TaskdataList []*LocalTaskdatainfo `json:"task_list"`
+	Total        string               `json:"total"`
+}
+
+type LocalTaskdatainfo struct {
+	Task *LocaLTaskInfo `json:"task_info"`
+	DDl  time.Time      `json:"ddl"` // 截止时间
+}
+
+func NewLocalPreDataListRequest() *LocalPreDataListRequest {
+	return new(LocalPreDataListRequest)
+}
+
+func NewLocalPreDataListResponse() *CommonResponse {
+	resp := new(CommonResponse)
+	resp.Data = new(GetLocalPreDataListData)
+	return resp
+}

model/http_model/localpresketchlistrequest.go

@@ -0,0 +1,31 @@
+package http_model
+
+import "time"
+
+type LocalPreSketchListRequest struct {
+	PageSize     int    `json:"page_size"`
+	PageNum      int    `json:"page_num"`
+	ProjectId    string `json:"project_id"`    // 项目ID
+	ScriptStatus int    `json:"script_status"` // 稿件状态,10初稿待审
+	EnterpriseId string `json:"enterprise_id"`
+}
+
+type GetLocalSketchTaskListData struct {
+	TasksketchList []*LocalTasksketchInfo `json:"task_list"`
+	Total          string                 `json:"total"`
+}
+
+type LocalTasksketchInfo struct {
+	Task *LocaLTaskInfo `json:"task_info"`
+	DDl  time.Time      `json:"ddl"`
+}
+
+func NewLocalPreSketchListRequest() *LocalPreSketchListRequest {
+	return new(LocalPreSketchListRequest)
+}
+
+func NewLocalPreSketchListResponse() *CommonResponse {
+	resp := new(CommonResponse)
+	resp.Data = new(GetSketchTaskListData)
+	return resp
+}

model/http_model/localreject_data.go

@@ -0,0 +1,21 @@
+package http_model
+
+type LocalRejectDataRequest struct {
+	TaskIds     string `json:"task_id_list"` //任务id列表
+	ProjectId   string `json:"project_id"`
+	OperatorId  string `json:"operator_id"`
+	OperateType int    `json:"operate_type"`
+}
+
+type LocalRejectDataData struct {
+	TaskIds []string `json:"task_id_list"` //任务id列表
+}
+
+func NewLocalRejectDataRequest() *LocalRejectDataRequest {
+	return new(LocalRejectDataRequest)
+}
+func NewLocalRejectDataResponse() *CommonResponse {
+	resp := new(CommonResponse)
+	resp.Data = new(LocalRejectDataData)
+	return resp
+}

model/http_model/localreject_link.go

@@ -0,0 +1,21 @@
+package http_model
+
+type LocalRejectLinkRequest struct {
+	TaskIds     string `json:"task_id_list"` //任务id列表
+	ProjectId   string `json:"project_id"`
+	OperatorId  string `json:"operator_id"`
+	OperateType int    `json:"operate_type"`
+}
+
+type LocalRejectLinkData struct {
+	TaskIds []string `json:"task_id_list"` //任务id列表
+}
+
+func NewLocalRejectLinkRequest() *LocalRejectLinkRequest {
+	return new(LocalRejectLinkRequest)
+}
+func NewLocalRejectLinkResponse() *CommonResponse {
+	resp := new(CommonResponse)
+	resp.Data = new(LocalRejectLinkData)
+	return resp
+}

model/http_model/localsketch_opinion.go

@@ -0,0 +1,22 @@
+package http_model
+
+type LocalSketchOpinionRequest struct {
+	TaskID             string `json:"task_id"` //任务-id
+	ProjectId          string `json:"project_id"`
+	LocalSketchOpinion string `json:"sketch_opinion"` //初稿意见
+	OperatorId         string `json:"operator_id"`
+	OperateType        int    `json:"operate_type"`
+}
+
+type LocalSketchOpinionData struct {
+	TaskID string `json:"task_id"` // 脚本ID
+}
+
+func NewLocalSketchOpinionRequest() *LocalSketchOpinionRequest {
+	return new(LocalSketchOpinionRequest)
+}
+func NewLocalSketchOpinionResponse() *CommonResponse {
+	resp := new(CommonResponse)
+	resp.Data = new(LocalSketchOpinionData)
+	return resp
+}

model/http_model/localtaskdatalist.go

@@ -0,0 +1,41 @@
+package http_model
+
+import "time"
+
+type LocalTaskDatalistRequest struct {
+	PageSize     int    `json:"page_size"`
+	PageNum      int    `json:"page_num"`
+	ProjectId    string `json:"project_id"`  // 项目ID
+	DataStatus   string `json:"data_status"` // 链接状态，14
+	EnterpriseId string `json:"enterprise_id"`
+}
+
+type GetLocalTaskDatalistData struct {
+	LocalTaskDatalist []*LocalTaskDatainfo `json:"task_list"`
+	Total             string               `json:"total"`
+}
+
+type LocalTaskDatainfo struct {
+	Task          *LocaLTaskInfo `json:"task_info"`
+	SubmitAt      time.Time      `json:"submit_at"` // 提交时间
+	AgreeAt       time.Time      `json:"agree_at"`
+	DataId        int            `json:"data_id"` //初稿ID
+	PhotoUrl      string         `json:"photo_url"`
+	PlayNumber    int            `json:"play_number"`
+	LikeNumber    int            `json:"like_number"`
+	CommentNumber int            `json:"comment_number"`
+	CollectNumber int            `json:"collect_number"`
+	SettleAmount  float64        `json:"settle_amount"`
+	Breakrate     int            `json:"breakrate"`
+	Operator      string         `json:"operator"`
+}
+
+func NewLocalTaskDatalistRequest() *LocalTaskDatalistRequest {
+	return new(LocalTaskDatalistRequest)
+}
+
+func NewLocalTaskDatalistResponse() *CommonResponse {
+	resp := new(CommonResponse)
+	resp.Data = new(GetLocalTaskDatalistData)
+	return resp
+}

model/http_model/localtasklinklist.go

@@ -0,0 +1,36 @@
+package http_model
+
+import "time"
+
+type LocalTaskLinklistRequest struct {
+	PageSize     int    `json:"page_size"`
+	PageNum      int    `json:"page_num"`
+	ProjectId    string `json:"project_id"`  // 项目ID
+	LinkStatus   string `json:"link_status"` // 链接状态，12待审
+	EnterpriseId string `json:"enterprise_id"`
+}
+
+type GetLocalTaskLinkListData struct {
+	LocalTaskLinklist []*LocalTaskLinkinfo `json:"task_list"`
+	Total             string               `json:"total"`
+}
+
+type LocalTaskLinkinfo struct {
+	Task     *LocaLTaskInfo `json:"task_info"`
+	SubmitAt time.Time      `json:"submit_at"` // 提交时间
+	AgreeAt  time.Time      `json:"agree_at"`
+	LinkId   int            `json:"link_id"` //初稿ID
+	LinkUrl  string         `json:"link_url"`
+	PhotoUrl string         `json:"photo_url"`
+	Operator string         `json:"operator"`
+}
+
+func NewLocalTaskLinklistRequest() *LocalTaskLinklistRequest {
+	return new(LocalTaskLinklistRequest)
+}
+
+func NewLocalTaskLinklistResponse() *CommonResponse {
+	resp := new(CommonResponse)
+	resp.Data = new(GetLocalTaskLinkListData)
+	return resp
+}

model/http_model/localtasksketchlist.go

@@ -0,0 +1,33 @@
+package http_model
+
+import "time"
+
+type LocalTasksketchlistRequest struct {
+	PageSize     int    `json:"page_size"`
+	PageNum      int    `json:"page_num"`
+	ProjectId    string `json:"project_id"`    // 项目ID
+	ScriptStatus int    `json:"script_status"` // 稿件状态
+}
+
+type GetsketchlocaltaskListData struct {
+	LocalTasksketchList []*LocalTasksketchinfo `json:"task_list"`
+	Total               string                 `json:"total"`
+}
+
+type LocalTasksketchinfo struct {
+	Task     *LocaLTaskInfo `json:"task_info"`
+	SubmitAt time.Time      `json:"submit_at"` // 提交时间
+	AgreeAt  time.Time      `json:"agree_at"`
+	Operator string         `json:"operator"`
+	SketchId int            `json:"sketch_id"` //初稿ID
+}
+
+func NewLocalTasksketchlistRequest() *LocalTasksketchlistRequest {
+	return new(LocalTasksketchlistRequest)
+}
+
+func NewLocalTasksketchlistResponse() *CommonResponse {
+	resp := new(CommonResponse)
+	resp.Data = new(GetsketchlocaltaskListData)
+	return resp
+}

model/http_model/predatalist.go

@@ -26,6 +26,6 @@ func NewPreDataListRequest() *PreDataListRequest {
 
 func NewPreDataListResponse() *CommonResponse {
 	resp := new(CommonResponse)
-	resp.Data = new(GetSketchTaskListData)
+	resp.Data = new(GetPreDataListData)
 	return resp
 }

model/http_model/refuselocaltaskcooprequest.go

@@ -0,0 +1,20 @@
+package http_model
+
+type RefuselocalTaskCoopRequest struct {
+	TaskIds     []string `json:"task_ids"`
+	OperatorId  string   `json:"operator_id"`
+	OperateType int      `json:"operate_type"`
+}
+
+type RefuselocalTaskCoopData struct {
+}
+
+func NewRefuselocalTaskCoopRequest() *RefuselocalTaskCoopRequest {
+	return new(RefuselocalTaskCoopRequest)
+}
+
+func NewRefuselocalTaskCoopResponse() *CommonResponse {
+	resp := new(CommonResponse)
+	resp.Data = new(RefuselocalTaskCoopData)
+	return resp
+}

model/http_model/sketch_loaclaccept.go

@@ -0,0 +1,22 @@
+package http_model
+
+type LocalAcceptSketchRequest struct {
+	TaskIds     string `json:"task_id_list"` //任务id列表
+	ProjectId   string `json:"project_id"`
+	OperatorId  string `json:"operator_id"`
+	OperateType int    `json:"operate_type"`
+	IsSpecial   int    `json:"is_special"`
+}
+
+type LocalAcceptSketchData struct {
+	TaskIds []string `json:"task_id_list"` //任务id列表
+}
+
+func NewLocalAcceptSketchRequest() *LocalAcceptSketchRequest {
+	return new(LocalAcceptSketchRequest)
+}
+func NewLocalAcceptSketchResponse() *CommonResponse {
+	resp := new(CommonResponse)
+	resp.Data = new(LocalAcceptSketchData)
+	return resp
+}

model/http_model/sketch_localreject.go

@@ -0,0 +1,21 @@
+package http_model
+
+type LocalRejectSketchRequest struct {
+	TaskIds     string `json:"task_id_list"` //任务id列表
+	ProjectId   string `json:"project_id"`
+	OperatorId  string `json:"operator_id"`
+	OperateType int    `json:"operate_type"`
+}
+
+type LocalRejectSketchData struct {
+	TaskIds []string `json:"task_id_list"` //任务id列表
+}
+
+func NewLocalRejectSketchRequest() *LocalRejectSketchRequest {
+	return new(LocalRejectSketchRequest)
+}
+func NewLocalRejectSketchResponse() *CommonResponse {
+	resp := new(CommonResponse)
+	resp.Data = new(LocalRejectSketchData)
+	return resp
+}

model/http_model/taskdatalist.go

@@ -36,6 +36,6 @@ func NewTaskDatalistRequest() *TaskDatalistRequest {
 
 func NewTaskDatalistResponse() *CommonResponse {
 	resp := new(CommonResponse)
-	resp.Data = new(GetSketchTaskListData)
+	resp.Data = new(GetTaskDatalistData)
 	return resp
 }

model/http_model/tasklinklist.go

@@ -31,6 +31,6 @@ func NewTaskLinklistRequest() *TaskLinklistRequest {
 
 func NewTaskLinklistResponse() *CommonResponse {
 	resp := new(CommonResponse)
-	resp.Data = new(GetSketchTaskListData)
+	resp.Data = new(GettasklinkListData)
 	return resp
 }

model/http_model/tasksketchlist.go

@@ -28,6 +28,6 @@ func NewTasksketchlistRequest() *TasksketchlistRequest {
 
 func NewTasksketchlistResponse() *CommonResponse {
 	resp := new(CommonResponse)
-	resp.Data = new(GetSketchTaskListData)
+	resp.Data = new(GetsketchtaskListData)
 	return resp
 }

route/init.go

@@ -38,7 +38,7 @@ func InitRoute(r *gin.Engine) {
 	//	c.JSON(200, resp)
 	//	// 注意这里只是debug用的 接口要写成handler形式
 	//})
-	m := r.Group("/youngee/m")
+	m := r.Group("/youngee/b")
 	{
 		m.Use(middleware.LoginAuthMiddleware)
 		m.POST("/test", func(c *gin.Context) {
@@ -185,35 +185,59 @@ func InitRoute(r *gin.Engine) {
 		task.POST("/project/task/list", controller.TaskController{}.ProjectTaskList)         // 种草任务列表
 		task.POST("/project/del", controller.TaskController{}.ProjectDel)                    // 删除种草任务
 
-		task.POST("/project/getTasklist", handler.WrapGetTaskListHandler)            //招募中选达人列表/查名单
-		task.POST("/project/task/coop/pass", handler.WrapPassproTaskCoopHandler)     // 同意任务合作
-		task.POST("/project/task/coop/refuse", handler.WrapRefuseproTaskCoopHandler) // 拒绝任务合作
+		task.POST("/project/getTasklist", handler.WrapGetTaskListHandler)            //种草招募中选达人列表/查名单
+		task.POST("/project/task/coop/pass", handler.WrapPassproTaskCoopHandler)     // 种草同意任务合作
+		task.POST("/project/task/coop/refuse", handler.WrapRefuseproTaskCoopHandler) // 种草拒绝任务合作
 
-		task.POST("/project/projectdata", handler.WrapProjectDataHandler) //看数据
-		task.POST("/project/endtask", handler.WrapEndTaskHandler)         //暂时终止
+		task.POST("/project/projectdata", handler.WrapProjectDataHandler) //种草看数据
+		task.POST("/project/endtask", handler.WrapEndTaskHandler)         //种草暂时终止
 
-		task.POST("/project/presketchlist", handler.WrapPreSketchListHandler)     //初稿待传列表
-		task.POST("/project/tasksketchlist", handler.WrapTasksketchlistHandler)   //初稿待审列表.审核通过
-		task.POST("/project/sketchopinion", handler.WrapSketchOpinionHandler)     // 初稿审核意见提交
-		task.POST("/project/acceptsketch", handler.WrapAcceptSketchHandler)       // 同意初稿
-		task.POST("/project/rejectsketch", handler.WrapRejectSketchHandler)       // 拒绝初稿
-		task.POST("/project/findsketchphoto", handler.WrapFindSketchPhotoHandler) // 查询脚本配图和视频demo
-		task.POST("/project/getsketchinfo", handler.WrapGetSketchInfoHandler)     // 获取初稿
+		task.POST("/project/presketchlist", handler.WrapPreSketchListHandler)     //种草初稿待传列表
+		task.POST("/project/tasksketchlist", handler.WrapTasksketchlistHandler)   //种草初稿待审列表.审核通过
+		task.POST("/project/sketchopinion", handler.WrapSketchOpinionHandler)     //种草初稿审核意见提交
+		task.POST("/project/acceptsketch", handler.WrapAcceptSketchHandler)       //种草同意初稿
+		task.POST("/project/rejectsketch", handler.WrapRejectSketchHandler)       //种草拒绝初稿
+		task.POST("/project/findsketchphoto", handler.WrapFindSketchPhotoHandler) //种草查询脚本配图和视频demo
+		task.POST("/project/getsketchinfo", handler.WrapGetSketchInfoHandler)     //种草获取初稿
 
-		task.POST("/project/prelinklist", handler.WrapPreLinkListHandler)   //待传链接列表
-		task.POST("/project/tasklinklist", handler.WrapTaskLinklistHandler) //链接待审列表，通过
-		task.POST("/project/linkopinion", handler.WrapLinkOpinionHandler)   // 链接审核意见提交
-		task.POST("/project/acceptlink", handler.WrapAcceptLinkHandler)     // 同意链接
-		task.POST("/project/rejectlink", handler.WrapRejectLinkHandler)     // 拒绝链接
+		task.POST("/project/prelinklist", handler.WrapPreLinkListHandler)   //种草待传链接列表
+		task.POST("/project/tasklinklist", handler.WrapTaskLinklistHandler) //种草链接待审列表，通过
+		task.POST("/project/linkopinion", handler.WrapLinkOpinionHandler)   // 种草链接审核意见提交
+		task.POST("/project/acceptlink", handler.WrapAcceptLinkHandler)     // 种草同意链接
+		task.POST("/project/rejectlink", handler.WrapRejectLinkHandler)     // 种草拒绝链接
 
-		task.POST("/project/predatalist", handler.WrapPreDataListHandler)   //待传数据列表
-		task.POST("/project/taskdatalist", handler.WrapTaskDatalistHandler) //数据待审列表
-		task.POST("/project/dataopinion", handler.WrapDataOpinionHandler)   // 数据审核意见提交
-		task.POST("/project/acceptdata", handler.WrapAcceptDataHandler)     // 同意数据
-		task.POST("/project/rejectdata", handler.WrapRejectDataHandler)     // 拒绝数据
+		task.POST("/project/predatalist", handler.WrapPreDataListHandler)   //种草待传数据列表
+		task.POST("/project/taskdatalist", handler.WrapTaskDatalistHandler) //种草数据待审列表,审核通过
+		task.POST("/project/dataopinion", handler.WrapDataOpinionHandler)   // 种草数据审核意见提交
+		task.POST("/project/acceptdata", handler.WrapAcceptDataHandler)     // 种草同意数据
+		task.POST("/project/rejectdata", handler.WrapRejectDataHandler)     // 种草拒绝数据
 
 		task.POST("/project/executedata", handler.WrapExecuteDataHandler) //看数据
-		task.POST("/project/data", handler.WrapDataHandler)
+		task.POST("/project/data", handler.WrapDataHandler)               //暂未
+
+		task.POST("/locallife/getTasklist", handler.WrapGetLocalTaskListHandler)         //本地生活招募中选大人列表/查名单
+		task.POST("/locallife/task/coop/pass", handler.WrapPasslocalTaskCoopHandler)     // 本地生活同意任务合作
+		task.POST("/locallife/task/coop/refuse", handler.WrapRefuselocalTaskCoopHandler) // 本地生活拒绝任务合作
+
+		task.POST("/locallife/locallifedata", handler.WrapLocallifeDataHandler) //本地看数据
+
+		task.POST("/locallife/presketchlist", handler.WrapLocalPreSketchListHandler)   //本地生活初稿待传列表
+		task.POST("/locallife/tasksketchlist", handler.WrapLocalTasksketchlistHandler) //本地生活初稿待审列表.审核通过
+		task.POST("/locallife/sketchopinion", handler.WrapLocalSketchOpinionHandler)   //本地生活初稿审核意见提交
+		task.POST("/locallife/acceptsketch", handler.WrapLocalAcceptSketchHandler)     //本地生活同意初稿
+		task.POST("/locallife/rejectsketch", handler.WrapLocalRejectSketchHandler)     //本地生活拒绝初稿
+
+		task.POST("/locallife/prelinklist", handler.WrapLocalPreLinkListHandler)   //本地生活待传链接列表
+		task.POST("/locallife/tasklinklist", handler.WrapLocalTaskLinklistHandler) //本地生活链接待审列表，通过
+		task.POST("/locallife/linkopinion", handler.WrapLocalLinkOpinionHandler)   // 本地生活链接审核意见提交
+		task.POST("/locallife/acceptlink", handler.WrapLocalAcceptLinkHandler)     // 本地生活同意链接
+		task.POST("/locallife/rejectlink", handler.WrapLocalRejectLinkHandler)     // 本地生活拒绝链接
+
+		task.POST("/locallife/predatalist", handler.WrapLocalPreDataListHandler)   //本地生活待传数据列表
+		task.POST("/locallife/taskdatalist", handler.WrapLocalTaskDatalistHandler) //本地生活数据待审列表
+		task.POST("/locallife/dataopinion", handler.WrapLocalDataOpinionHandler)   // 本地生活数据审核意见提交
+		task.POST("/locallife/acceptdata", handler.WrapLocalAcceptDataHandler)     // 本地生活同意数据
+		task.POST("/locallife/rejectdata", handler.WrapLocalRejectDataHandler)     // 本地生活拒绝数据
 
 		task.POST("/draft/selection/list", controller.TaskController{}.GetSelectionDraftList) // 草稿箱——电商带货列表
 		task.POST("/draft/project/list", controller.TaskController{}.GetProjectDraftList)     // 草稿箱——品牌种草列表

service/Localtask.go

@@ -0,0 +1,110 @@
+package service
+
+import (
+	"context"
+	"github.com/sirupsen/logrus"
+	"youngee_b_api/db"
+	"youngee_b_api/model/http_model"
+)
+
+var LocalTask *localtask
+
+type localtask struct {
+}
+
+func (*localtask) GetLocalList(ctx context.Context, request http_model.GetLocalTaskListRequest) (*http_model.GetLocalTaskListData, error) {
+	localTaskList, err := db.GetLocallifetaskList(ctx, request)
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[localtask service] call GetLocalTaskList error,err:%+v", err)
+		return nil, err
+	}
+	return localTaskList, nil
+}
+
+func (*localtask) PassCoop(ctx context.Context, request http_model.PasslocalTaskCoopRequest) (*http_model.PassSecTaskCoopData, error) {
+	_, err := db.PassLocalTaskCoop(ctx, request)
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[localtask service] call PassCoop error,err:%+v", err)
+		return nil, err
+	}
+
+	selectionListData := http_model.PassSecTaskCoopData{}
+
+	return &selectionListData, nil
+}
+
+func (*localtask) RefuseCoop(ctx context.Context, request http_model.RefuselocalTaskCoopRequest) (*http_model.PasslocalTaskCoopData, error) {
+
+	_, err := db.RefuseLocalTaskCoop(ctx, request)
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[localtask] call RefuseCoop error,err:%+v", err)
+		return nil, err
+	}
+
+	projectListData := http_model.PasslocalTaskCoopData{}
+
+	return &projectListData, nil
+}
+
+func (*localtask) Data(ctx context.Context, Project http_model.LocallifeDataRequest) (*http_model.LocallifeDataResponse, error) {
+	projectdata, err := db.GetLocallifeData(ctx, Project)
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[localtask service] call Data error,err:%+v", err)
+		return nil, err
+	}
+	return &projectdata, nil
+}
+
+func (*localtask) GetLocalPreSketchList(ctx context.Context, request http_model.LocalPreSketchListRequest) (*http_model.GetLocalSketchTaskListData, error) {
+	secTaskList, err := db.GetLocalPreSketchList(ctx, request)
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[localtask service] call GetPreSketchList error,err:%+v", err)
+		return nil, err
+	}
+	return secTaskList, nil
+}
+
+func (*localtask) GetLocalTasksketchlist(ctx context.Context, request http_model.LocalTasksketchlistRequest) (*http_model.GetsketchlocaltaskListData, error) {
+	secTaskList, err := db.GetLocalSketchList(ctx, request)
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[localtask service] call GetLocalTasksketchlist error,err:%+v", err)
+		return nil, err
+	}
+	return secTaskList, nil
+}
+
+func (*localtask) GetLocalPreLinkList(ctx context.Context, request http_model.LocalPreLinkListRequest) (*http_model.GetLocalPreLinkListData, error) {
+	secTaskList, err := db.GetLocalPreLinkList(ctx, request)
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[sectask_service service] call PreLinkListRequest error,err:%+v", err)
+		return nil, err
+	}
+	return secTaskList, nil
+}
+
+func (*localtask) GetLocalTaskLinklist(ctx context.Context, request http_model.LocalTaskLinklistRequest) (*http_model.GetLocalTaskLinkListData, error) {
+	secTaskList, err := db.GetLocalLinkList(ctx, request)
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[sectask_service service] call GetTasksketchlist error,err:%+v", err)
+		return nil, err
+	}
+	return secTaskList, nil
+}
+
+func (*localtask) GetLocalPreDataList(ctx context.Context, request http_model.LocalPreDataListRequest) (*http_model.GetLocalPreDataListData, error) {
+	secTaskList, err := db.GetLocalPreDataList(ctx, request)
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[sectask_service service] call PreLinkListRequest error,err:%+v", err)
+		return nil, err
+	}
+	return secTaskList, nil
+}
+
+func (*localtask) GetLocalTaskDatalist(ctx context.Context, request http_model.LocalTaskDatalistRequest) (*http_model.GetLocalTaskDatalistData, error) {
+	secTaskList, err := db.GetLocalDataList(ctx, request)
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[sectask_service service] call GetTasksketchlist error,err:%+v", err)
+		return nil, err
+	}
+	return secTaskList, nil
+}

service/data.go

@@ -46,6 +46,36 @@ func (*data) DataOpinion(ctx context.Context, request http_model.DataOpinionRequ
 	return res, nil
 }
 
+// DataOpinion 在上传脚本表上提交修改意见
+func (*data) LocalDataOpinion(ctx context.Context, request http_model.LocalDataOpinionRequest) (*http_model.LocalDataOpinionData, error) {
+	Data := gorm_model.YounggeeDataInfo{
+		TaskID:        request.TaskID,
+		ReviseOpinion: request.LocalDataOpinion,
+	}
+	err := db.LocalDataOpinion(ctx, Data.TaskID, Data.ReviseOpinion, request.OperatorId, request.OperateType, request.ProjectId)
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Data service] call CreateData error,err:%+v", err)
+		return nil, err
+	}
+	// 记录任务日志
+	err = db.CreateTaskLog(ctx, Data.TaskID, "数据驳回")
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Link service] call CreateTaskLog error,err:%+v", err)
+		return nil, err
+	}
+
+	err = db.CreateMessageByTaskId(ctx, 19, 3, Data.TaskID)
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Data service] call CreateMessageByTaskId error,err:%+v", err)
+		return nil, err
+	}
+
+	res := &http_model.LocalDataOpinionData{
+		TaskID: Data.TaskID,
+	}
+	return res, nil
+}
+
 // 任务结案service
 func (*data) AcceptData(ctx context.Context, request http_model.AcceptDataRequest) (*http_model.AcceptDataData, error) {
 	var TaskIDList []string
@@ -78,7 +108,7 @@ func (*data) AcceptData(ctx context.Context, request http_model.AcceptDataReques
 
 	res := &http_model.AcceptDataData{
 		TaskIds: TaskIDList,
-		IsEnd:   0,
+		//IsEnd:   0,
 	}
 
 	if request.IsSpecial == 1 {
@@ -88,21 +118,27 @@ func (*data) AcceptData(ctx context.Context, request http_model.AcceptDataReques
 			logrus.WithContext(ctx).Errorf("[Data service] call SetTaskFinish error,err:%+v", err)
 			return nil, err
 		}
-		// 3. 判断是否全部任务已结案，若已全部结案则触发项目结案
-		// 查询task_stage<15的任务数量
-		unFinishedTaskNumber, err1 := db.GetUnfinishedTaskNumber(ctx, request.ProjectId)
-		if err1 != nil {
-			logrus.WithContext(ctx).Errorf("[Data service] call GetUnfinishedTaskNumber error,err:%+v", err)
+
+		err = db.SetSpecialTaskSettleNum(ctx, TaskIDList)
+		if err != nil {
+			logrus.WithContext(ctx).Errorf("[Data service] call SetSpecialTaskSettleNum error,err:%+v", err)
 			return nil, err
 		}
-		if *unFinishedTaskNumber == 0 { // 若为0则触发项目结案
-			err := db.SetSpecialProjectFinish(ctx, request.ProjectId)
-			if err1 != nil {
-				logrus.WithContext(ctx).Errorf("[Data service] call SetProjectFinish error,err:%+v", err)
-				return nil, err
-			}
-			res.IsEnd = 1
-		}
+		//// 3. 判断是否全部任务已结案，若已全部结案则触发项目结案
+		//// 查询task_stage<15的任务数量
+		//unFinishedTaskNumber, err1 := db.GetUnfinishedTaskNumber(ctx, request.ProjectId)
+		//if err1 != nil {
+		//	logrus.WithContext(ctx).Errorf("[Data service] call GetUnfinishedTaskNumber error,err:%+v", err)
+		//	return nil, err
+		//}
+		//if *unFinishedTaskNumber == 0 { // 若为0则触发项目结案
+		//	err := db.SetSpecialProjectFinish(ctx, request.ProjectId)
+		//	if err1 != nil {
+		//		logrus.WithContext(ctx).Errorf("[Data service] call SetProjectFinish error,err:%+v", err)
+		//		return nil, err
+		//	}
+		//	//res.IsEnd = 1
+		//}
 	} else {
 		// 2. 更新YoungeeTaskInfo表，将任务结案
 		fmt.Printf("acc request %+v", TaskIDList)
@@ -116,21 +152,125 @@ func (*data) AcceptData(ctx context.Context, request http_model.AcceptDataReques
 			logrus.WithContext(ctx).Errorf("[Data service] call SetTalentIncome error,err:%+v", err)
 			return nil, err
 		}
+		err = db.SetSpecialTaskSettleNum(ctx, TaskIDList)
+		if err != nil {
+			logrus.WithContext(ctx).Errorf("[Data service] call SetSpecialTaskSettleNum error,err:%+v", err)
+			return nil, err
+		}
 		// 3. 判断是否全部任务已结案，若已全部结案则触发项目结案
 		// 查询task_stage<15的任务数量
-		unFinishedTaskNumber, err1 := db.GetUnfinishedTaskNumber(ctx, request.ProjectId)
-		if err1 != nil {
-			logrus.WithContext(ctx).Errorf("[Data service] call GetUnfinishedTaskNumber error,err:%+v", err)
+		//unFinishedTaskNumber, err1 := db.GetUnfinishedTaskNumber(ctx, request.ProjectId)
+		//if err1 != nil {
+		//	logrus.WithContext(ctx).Errorf("[Data service] call GetUnfinishedTaskNumber error,err:%+v", err)
+		//	return nil, err
+		//}
+		//if *unFinishedTaskNumber == 0 { // 若为0则触发项目结案
+		//	err := db.SetProjectFinish(ctx, request.ProjectId)
+		//	if err1 != nil {
+		//		logrus.WithContext(ctx).Errorf("[Data service] call SetProjectFinish error,err:%+v", err)
+		//		return nil, err
+		//	}
+		//	res.IsEnd = 1
+		//}
+	}
+	return res, nil
+}
+
+// 任务结案service
+func (*data) LocalAcceptData(ctx context.Context, request http_model.LocalAcceptDataRequest) (*http_model.LocalAcceptDataData, error) {
+	var TaskIDList []string
+	TaskIDs := strings.Split(request.TaskIds, ",")
+	for _, taskId := range TaskIDs {
+		TaskIDList = append(TaskIDList, taskId)
+	}
+
+	// 1. 更新YounggeeDataInfo表，通过数据
+	fmt.Printf("acc request %+v", TaskIDList)
+	err := db.AcceptData(ctx, TaskIDList, request.OperatorId, request.OperateType)
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Data service] call AcceptData error,err:%+v", err)
+		return nil, err
+	}
+
+	// 记录任务日志和达人消息
+	for _, taskId := range TaskIDList {
+		err = db.CreateTaskLog(ctx, taskId, "数据通过")
+		if err != nil {
+			logrus.WithContext(ctx).Errorf("[Data service] call CreateTaskLog error,err:%+v", err)
+			return nil, err
+		}
+		err = db.CreateMessageByTaskId(ctx, 5, 1, taskId)
+		if err != nil {
+			logrus.WithContext(ctx).Errorf("[Script service] call CreateTaskLog error,err:%+v", err)
+			return nil, err
+		}
+	}
+
+	res := &http_model.LocalAcceptDataData{
+		TaskIds: TaskIDList,
+		//IsEnd:   0,
+	}
+
+	if request.IsSpecial == 1 {
+		// 2. 更新YoungeeTaskInfo表，将任务结案
+		err = db.SetSpecialLocalTaskFinish(ctx, TaskIDList)
+		if err != nil {
+			logrus.WithContext(ctx).Errorf("[Data service] call SetTaskFinish error,err:%+v", err)
+			return nil, err
+		}
+		err = db.SetSpecialLocalTaskSettleNum(ctx, TaskIDList)
+		if err != nil {
+			logrus.WithContext(ctx).Errorf("[Data service] call SetSpecialTaskSettleNum error,err:%+v", err)
 			return nil, err
 		}
-		if *unFinishedTaskNumber == 0 { // 若为0则触发项目结案
-			err := db.SetProjectFinish(ctx, request.ProjectId)
-			if err1 != nil {
-				logrus.WithContext(ctx).Errorf("[Data service] call SetProjectFinish error,err:%+v", err)
-				return nil, err
-			}
-			res.IsEnd = 1
+		//// 3. 判断是否全部任务已结案，若已全部结案则触发项目结案
+		//// 查询task_stage<15的任务数量
+		//unFinishedTaskNumber, err1 := db.GetUnfinishedTaskNumber(ctx, request.ProjectId)
+		//if err1 != nil {
+		//	logrus.WithContext(ctx).Errorf("[Data service] call GetUnfinishedTaskNumber error,err:%+v", err)
+		//	return nil, err
+		//}
+		//if *unFinishedTaskNumber == 0 { // 若为0则触发项目结案
+		//	err := db.SetSpecialProjectFinish(ctx, request.ProjectId)
+		//	if err1 != nil {
+		//		logrus.WithContext(ctx).Errorf("[Data service] call SetProjectFinish error,err:%+v", err)
+		//		return nil, err
+		//	}
+		//	res.IsEnd = 1
+		//}
+	} else {
+		// 2. 更新YoungeeTaskInfo表，将任务结案
+		fmt.Printf("acc request %+v", TaskIDList)
+		err = db.SetLocalTaskFinish(ctx, TaskIDList)
+		if err != nil {
+			logrus.WithContext(ctx).Errorf("[Data service] call SetTaskFinish error,err:%+v", err)
+			return nil, err
+		}
+		err = db.SetLocalTalentIncome(ctx, TaskIDList)
+		if err != nil {
+			logrus.WithContext(ctx).Errorf("[Data service] call SetTalentIncome error,err:%+v", err)
+			return nil, err
+		}
+		err = db.SetSpecialLocalTaskSettleNum(ctx, TaskIDList)
+		if err != nil {
+			logrus.WithContext(ctx).Errorf("[Data service] call SetSpecialTaskSettleNum error,err:%+v", err)
+			return nil, err
 		}
+		//// 3. 判断是否全部任务已结案，若已全部结案则触发项目结案
+		//// 查询task_stage<15的任务数量
+		//unFinishedTaskNumber, err1 := db.GetUnfinishedTaskNumber(ctx, request.ProjectId)
+		//if err1 != nil {
+		//	logrus.WithContext(ctx).Errorf("[Data service] call GetUnfinishedTaskNumber error,err:%+v", err)
+		//	return nil, err
+		//}
+		//if *unFinishedTaskNumber == 0 { // 若为0则触发项目结案
+		//	err := db.SetProjectFinish(ctx, request.ProjectId)
+		//	if err1 != nil {
+		//		logrus.WithContext(ctx).Errorf("[Data service] call SetProjectFinish error,err:%+v", err)
+		//		return nil, err
+		//	}
+		//	res.IsEnd = 1
+		//}
 	}
 	return res, nil
 }
@@ -167,3 +307,36 @@ func (*data) RejectData(ctx context.Context, request http_model.RejectDataReques
 	}
 	return res, nil
 }
+
+// RejectData
+func (*data) LocalRejectData(ctx context.Context, request http_model.LocalRejectDataRequest) (*http_model.LocalRejectDataData, error) {
+	var TaskIDList []string
+	TaskIDs := strings.Split(request.TaskIds, ",")
+	for _, taskId := range TaskIDs {
+		TaskIDList = append(TaskIDList, taskId)
+	}
+	fmt.Printf("acc request %+v", TaskIDList)
+	err := db.LocalRejectData(ctx, TaskIDList, request.OperatorId, request.OperateType, request.ProjectId)
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Link service] call CreateLink error,err:%+v", err)
+		return nil, err
+	}
+	// 记录任务日志
+	for _, taskId := range TaskIDList {
+		err = db.CreateTaskLog(ctx, taskId, "数据驳回")
+		if err != nil {
+			logrus.WithContext(ctx).Errorf("[Link service] call CreateTaskLog error,err:%+v", err)
+			return nil, err
+		}
+		err = db.CreateMessageByTaskId(ctx, 19, 3, taskId)
+		if err != nil {
+			logrus.WithContext(ctx).Errorf("[Script service] call CreateTaskLog error,err:%+v", err)
+			return nil, err
+		}
+	}
+
+	res := &http_model.LocalRejectDataData{
+		TaskIds: TaskIDList,
+	}
+	return res, nil
+}

service/link.go

@@ -46,6 +46,36 @@ func (*link) LinkOpinion(ctx context.Context, request http_model.LinkOpinionRequ
 	return res, nil
 }
 
+// LinkOpinion 在上传脚本表上提交修改意见
+func (*link) LocalLinkOpinion(ctx context.Context, request http_model.LocalLinkOpinionRequest) (*http_model.LocalLinkOpinionData, error) {
+	Link := gorm_model.YounggeeLinkInfo{
+		TaskID:        request.TaskID,
+		ReviseOpinion: request.LocalLinkOpinion,
+	}
+	err := db.LocalLinkOpinion(ctx, Link.TaskID, Link.ReviseOpinion, request.OperatorId, request.OperateType, request.ProjectId)
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Link service] call CreateLink error,err:%+v", err)
+		return nil, err
+	}
+	// 记录任务日志
+	err = db.CreateTaskLog(ctx, Link.TaskID, "链接驳回")
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Link service] call CreateTaskLog error,err:%+v", err)
+		return nil, err
+	}
+
+	err = db.CreateMessageByTaskId(ctx, 18, 3, Link.TaskID)
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Link service] call CreateMessageByTaskId error,err:%+v", err)
+		return nil, err
+	}
+
+	res := &http_model.LocalLinkOpinionData{
+		TaskID: Link.TaskID,
+	}
+	return res, nil
+}
+
 // AcceptLink
 func (*link) AcceptLink(ctx context.Context, request http_model.AcceptLinkRequest) (*http_model.AcceptLinkData, error) {
 	var TaskIDList []string
@@ -79,6 +109,39 @@ func (*link) AcceptLink(ctx context.Context, request http_model.AcceptLinkReques
 	return res, nil
 }
 
+// AcceptLink
+func (*link) LocalAcceptLink(ctx context.Context, request http_model.LocalAcceptLinkRequest) (*http_model.LocalAcceptLinkData, error) {
+	var TaskIDList []string
+	TaskIDs := strings.Split(request.TaskIds, ",")
+	for _, taskId := range TaskIDs {
+		TaskIDList = append(TaskIDList, taskId)
+	}
+	fmt.Printf("acc request %+v", TaskIDList)
+	err := db.LocalAcceptLink(ctx, TaskIDList, request.OperatorId, request.OperateType, request.ProjectId, request.Isspecial)
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Link service] call CreateLink error,err:%+v", err)
+		return nil, err
+	}
+	// 记录任务日志
+	for _, taskId := range TaskIDList {
+		err = db.CreateTaskLog(ctx, taskId, "链接通过")
+		if err != nil {
+			logrus.WithContext(ctx).Errorf("[Link service] call CreateTaskLog error,err:%+v", err)
+			return nil, err
+		}
+		err = db.CreateMessageByTaskId(ctx, 4, 1, taskId)
+		if err != nil {
+			logrus.WithContext(ctx).Errorf("[Script service] call CreateTaskLog error,err:%+v", err)
+			return nil, err
+		}
+	}
+
+	res := &http_model.LocalAcceptLinkData{
+		TaskIds: TaskIDList,
+	}
+	return res, nil
+}
+
 // RejectLink
 func (*link) RejectLink(ctx context.Context, request http_model.RejectLinkRequest) (*http_model.RejectLinkData, error) {
 	var TaskIDList []string
@@ -111,3 +174,36 @@ func (*link) RejectLink(ctx context.Context, request http_model.RejectLinkReques
 	}
 	return res, nil
 }
+
+// RejectLink
+func (*link) LocalRejectLink(ctx context.Context, request http_model.LocalRejectLinkRequest) (*http_model.LocalRejectLinkData, error) {
+	var TaskIDList []string
+	TaskIDs := strings.Split(request.TaskIds, ",")
+	for _, taskId := range TaskIDs {
+		TaskIDList = append(TaskIDList, taskId)
+	}
+	fmt.Printf("acc request %+v", TaskIDList)
+	err := db.LocalRejectLink(ctx, TaskIDList, request.OperatorId, request.OperateType, request.ProjectId)
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Link service] call CreateLink error,err:%+v", err)
+		return nil, err
+	}
+	// 记录任务日志
+	for _, taskId := range TaskIDList {
+		err = db.CreateTaskLog(ctx, taskId, "链接不通过")
+		if err != nil {
+			logrus.WithContext(ctx).Errorf("[Link service] call CreateTaskLog error,err:%+v", err)
+			return nil, err
+		}
+		err = db.CreateMessageByTaskId(ctx, 18, 3, taskId)
+		if err != nil {
+			logrus.WithContext(ctx).Errorf("[Script service] call CreateTaskLog error,err:%+v", err)
+			return nil, err
+		}
+	}
+
+	res := &http_model.LocalRejectLinkData{
+		TaskIds: TaskIDList,
+	}
+	return res, nil
+}

service/sketch.go

@@ -49,6 +49,37 @@ func (*sketch) SketchOption(ctx context.Context, request http_model.SketchOpinio
 	return res, nil
 }
 
+// SketchOption ReviseOption 在上传初稿表上提交修改意见
+func (*sketch) LocalSketchOption(ctx context.Context, request http_model.LocalSketchOpinionRequest) (*http_model.LocalSketchOpinionData, error) {
+	Sketch := gorm_model.YounggeeSketchInfo{
+		TaskID:        request.TaskID,
+		ReviseOpinion: request.LocalSketchOpinion,
+	}
+	err := db.LocalSketchOption(ctx, Sketch.TaskID, Sketch.ReviseOpinion, request.OperatorId, request.OperateType, request.ProjectId)
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Sketch service] call CreateSketch error,err:%+v", err)
+		return nil, err
+	}
+
+	// 记录任务日志
+	err = db.CreateTaskLog(ctx, Sketch.TaskID, "初稿驳回")
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Sketch service] call CreateTaskLog error,err:%+v", err)
+		return nil, err
+	}
+
+	err = db.CreateMessageByTaskId(ctx, 17, 3, Sketch.TaskID)
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Sketch service] call CreateMessageByTaskId error,err:%+v", err)
+		return nil, err
+	}
+
+	res := &http_model.LocalSketchOpinionData{
+		TaskID: Sketch.TaskID,
+	}
+	return res, nil
+}
+
 // AcceptSketch 同意初稿
 func (*sketch) AcceptSketch(ctx context.Context, request http_model.AcceptSketchRequest) (*http_model.AcceptSketchData, error) {
 	var TaskIDList []string
@@ -82,6 +113,39 @@ func (*sketch) AcceptSketch(ctx context.Context, request http_model.AcceptSketch
 	return res, nil
 }
 
+// AcceptSketch 本地生活同意初稿
+func (*sketch) LocalAcceptSketch(ctx context.Context, request http_model.LocalAcceptSketchRequest) (*http_model.LocalAcceptSketchData, error) {
+	var TaskIDList []string
+	TaskIDs := strings.Split(request.TaskIds, ",")
+	for _, taskId := range TaskIDs {
+		TaskIDList = append(TaskIDList, taskId)
+	}
+	fmt.Printf("acc request %+v", TaskIDList)
+	err := db.LocalAcceptSketch(ctx, TaskIDList, request.OperatorId, request.OperateType, request.ProjectId, request.IsSpecial)
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Sketch service] call LocalAcceptSketch error,err:%+v", err)
+		return nil, err
+	}
+	// 记录任务日志
+	for _, taskId := range TaskIDList {
+		err = db.CreateTaskLog(ctx, taskId, "初稿通过")
+		if err != nil {
+			logrus.WithContext(ctx).Errorf("[Sketch service] call CreateTaskLog error,err:%+v", err)
+			return nil, err
+		}
+		err = db.CreateMessageByTaskId(ctx, 3, 1, taskId)
+		if err != nil {
+			logrus.WithContext(ctx).Errorf("[Script service] call CreateTaskLog error,err:%+v", err)
+			return nil, err
+		}
+	}
+
+	res := &http_model.LocalAcceptSketchData{
+		TaskIds: TaskIDList,
+	}
+	return res, nil
+}
+
 // FindPhoto 查找初稿图片以及视频
 func (*sketch) FindPhoto(ctx context.Context, request http_model.FindSketchPhotoRequest) ([]http_model.SketchPhoto, error) {
 	var SketchPhotos []http_model.SketchPhoto
@@ -165,3 +229,36 @@ func (*sketch) RejectSketch(ctx context.Context, request http_model.RejectSketch
 	}
 	return res, nil
 }
+
+// AcceptSketch 不同意初稿
+func (*sketch) LocalRejectSketch(ctx context.Context, request http_model.LocalRejectSketchRequest) (*http_model.LocalRejectSketchData, error) {
+	var TaskIDList []string
+	TaskIDs := strings.Split(request.TaskIds, ",")
+	for _, taskId := range TaskIDs {
+		TaskIDList = append(TaskIDList, taskId)
+	}
+	fmt.Printf("acc request %+v", TaskIDList)
+	err := db.LocalRejectSketch(ctx, TaskIDList, request.OperatorId, request.OperateType, request.ProjectId)
+	if err != nil {
+		logrus.WithContext(ctx).Errorf("[Sketch service] call CreateSketch error,err:%+v", err)
+		return nil, err
+	}
+	// 记录任务日志
+	for _, taskId := range TaskIDList {
+		err = db.CreateTaskLog(ctx, taskId, "初稿未通过")
+		if err != nil {
+			logrus.WithContext(ctx).Errorf("[Sketch service] call CreateTaskLog error,err:%+v", err)
+			return nil, err
+		}
+		err = db.CreateMessageByTaskId(ctx, 17, 3, taskId)
+		if err != nil {
+			logrus.WithContext(ctx).Errorf("[Script service] call CreateTaskLog error,err:%+v", err)
+			return nil, err
+		}
+	}
+
+	res := &http_model.LocalRejectSketchData{
+		TaskIds: TaskIDList,
+	}
+	return res, nil
+}