opms_backend/opms_parent/app/service/plat/plat_task.go

package plat

import (
	"bytes"
	"context"
	workflowModel "dashoo.cn/micro/app/model/workflow"
	workflowService "dashoo.cn/micro/app/service/workflow"
	"dashoo.cn/opms_libary/plugin/dingtalk/message"
	"dashoo.cn/opms_libary/plugin/dingtalk/workflow"
	"dashoo.cn/opms_libary/utils"
	"database/sql"
	"errors"
	"fmt"
	"strconv"
	"strings"

	"dashoo.cn/opms_libary/myerrors"
	"github.com/360EntSecGroup-Skylar/excelize"
	"github.com/gogf/gf/frame/g"
	"github.com/gogf/gf/os/gtime"
	"github.com/gogf/gf/util/gconv"

	"dashoo.cn/micro/app/dao/plat"
	model "dashoo.cn/micro/app/model/plat"
	"dashoo.cn/micro/app/service"
)

var PlatTaskApprovalProcessCode = "PROC-B2BE7E92-8A12-4CFF-83CD-FF23F397CCE2"

type taskService struct {
	*service.ContextService

	Dao *plat.PlatTaskDao
}

func NewTaskService(ctx context.Context) (svc *taskService, err error) {
	svc = new(taskService)
	if svc.ContextService, err = svc.Init(ctx); err != nil {
		return nil, err
	}
	svc.Dao = plat.NewPlatTaskDao(svc.Tenant)
	return svc, nil
}

// GetList 任务信息列表
func (s *taskService) GetList(req *model.SearchPlatTaskReq) (total int, TaskList []*model.PlatTaskEx, err error) {
	orderBy := "plat_task.created_time DESC"
	TaskModel := s.Dao.LeftJoin("plat_task_handle", "plat_task_handle.task_id=plat_task.id")
	if req.TaskId != "" {
		TaskModel = TaskModel.Where("plat_task.id", req.TaskId)
	}
	if req.TaskTitle != "" {
		TaskModel = TaskModel.Where("plat_task.task_title LIKE ?", "%"+req.TaskTitle+"%")
	}
	if req.TaskType != "" {
		TaskModel = TaskModel.Where("plat_task.task_type", req.TaskType)
	}
	if req.Source != "" {
		TaskModel = TaskModel.Where("plat_task.source", req.Source)
	}
	if req.TaskStatus != "" {
		TaskModel = TaskModel.Where("plat_task.task_status", req.TaskStatus)
	}
	if req.IsOverdue != "" {
		TaskModel = TaskModel.Where("plat_task.is_overdue", req.IsOverdue)
	}
	if req.MainUserId != "" {
		TaskModel = TaskModel.Where("plat_task.main_user_id", req.MainUserId)
	}
	if req.TargetId != "" {
		TaskModel = TaskModel.Where("plat_task.target_id", req.TargetId)
	}
	if req.TargetType != "" {
		TaskModel = TaskModel.Where("plat_task.target_type", req.TargetType)
	}
	if req.MySelf == "1" {
		TaskModel = TaskModel.Where("plat_task.created_by", s.GetCxtUserId())
	}
	if req.IsMain == "1" {
		TaskModel = TaskModel.Where("plat_task.main_user_id", s.GetCxtUserId())
	}
	if req.OperateType == "1" { // 我的待办
		orderBy = "plat_task.task_status ASC, plat_task.created_time DESC"
		TaskModel = TaskModel.Where(fmt.Sprintf("plat_task_handle.task_status='10' AND (plat_task_handle.main_user_id=%v OR FIND_IN_SET(%v, plat_task_handle.owner_user_id))", s.GetCxtUserId(), s.GetCxtUserId()))
	} else if req.OperateType == "2" { // 我发起的
		TaskModel = TaskModel.Where("plat_task.created_by", s.GetCxtUserId())
	} else if req.OperateType == "3" { // 我处理的
		TaskModel = TaskModel.Where(fmt.Sprintf("plat_task_handle.task_status='20' AND plat_task_handle.handle_user_id=%v", s.GetCxtUserId()))
	} else if req.OperateType == "4" { // 抄送我的
		TaskModel = TaskModel.Where(fmt.Sprintf("FIND_IN_SET(%v, plat_task.copy_user_id)", s.GetCxtUserId()))
	}
	TaskModel = TaskModel.Group("plat_task.id")

	total, err = TaskModel.Count()
	if err != nil {
		g.Log().Error(err)
		err = myerrors.DbError("获取总行数失败。")
		return
	}

	err = TaskModel.Page(req.GetPage()).Order(orderBy).Fields("plat_task.*,plat_task_handle.step").Scan(&TaskList)
	return
}

// Export 导出数据
func (s *taskService) Export(req *model.ExportReq) (content *model.ExportContent, err error) {
	var con model.ExportContent
	// 获取数据
	total, list, err := s.GetList(&req.SearchPlatTaskReq)
	if err != nil {
		return nil, err
	}
	//rsp.List
	f := excelize.NewFile()
	// Create a new sheet.
	index := f.NewSheet("Sheet1")
	for index, item := range req.Columns {
		sheetPosition := service.Div(index+1) + "1"
		f.SetCellValue("Sheet1", sheetPosition, item)
	}

	if total > 0 {
		// 构造用户和类型填充数据
		userMap := make(map[int]string, 0)
		typeMap := make(map[string]string, 0)
		users, err := s.Dao.DB.Model("sys_user").FindAll()
		if err != nil {
			return nil, err
		}
		types, err := s.Dao.DB.Model("sys_dict_data").Where("dict_type='TaskType'").FindAll()
		if err != nil {
			return nil, err
		}
		for _, item := range users {
			userMap[item["id"].Int()] = item["nick_name"].String()
		}
		for _, item := range types {
			typeMap[item["dict_value"].String()] = item["dict_label"].String()
		}
		// 构造excel数据
		for lineNum, item := range list {
			for index, value := range req.Columns {
				if value == "督办标题" {
					f.SetCellValue("Sheet1", service.Div(index+1)+strconv.Itoa(lineNum+2), item.TaskTitle)
				}
				if value == "督办类型" {
					f.SetCellValue("Sheet1", service.Div(index+1)+strconv.Itoa(lineNum+2), typeMap[item.TaskType])
				}
				if value == "状态" {
					data := ""
					if item.TaskStatus == "10" {
						data = "发起"
					} else if item.TaskStatus == "20" {
						data = "进行中"
					} else if item.TaskStatus == "30" {
						data = "流程完成"
					}
					f.SetCellValue("Sheet1", service.Div(index+1)+strconv.Itoa(lineNum+2), data)
				}
				if value == "督办事项来源" {
					f.SetCellValue("Sheet1", service.Div(index+1)+strconv.Itoa(lineNum+2), item.Source)
				}
				if value == "超期" {
					data := ""
					if gtime.Now().Format("Y-m-d H:i:s") <= item.TaskEndDate.Format("Y-m-d 23:59:59") {
						data = "否"
					} else {
						data = "是"
					}
					f.SetCellValue("Sheet1", service.Div(index+1)+strconv.Itoa(lineNum+2), data)
				}
				if value == "督办说明" {
					f.SetCellValue("Sheet1", service.Div(index+1)+strconv.Itoa(lineNum+2), item.TaskDesc)
				}
				if value == "关联对象" {
					f.SetCellValue("Sheet1", service.Div(index+1)+strconv.Itoa(lineNum+2), item.TargetName)
				}
				if value == "负责人" {
					f.SetCellValue("Sheet1", service.Div(index+1)+strconv.Itoa(lineNum+2), userMap[item.MainUserId])
				}
				if value == "协办人" {
					names := ""
					if item.OwnerUserId != "" {
						ids := strings.Split(item.OwnerUserId, ",")
						for _, id := range ids {
							if names == "" {
								names = userMap[gconv.Int(id)]
							} else {
								names += "," + userMap[gconv.Int(id)]
							}
						}
					}

					f.SetCellValue("Sheet1", service.Div(index+1)+strconv.Itoa(lineNum+2), names)
				}
				if value == "督办人" {
					f.SetCellValue("Sheet1", service.Div(index+1)+strconv.Itoa(lineNum+2), userMap[item.SupervisorUserId])
				}
				if value == "发布时间" {
					f.SetCellValue("Sheet1", service.Div(index+1)+strconv.Itoa(lineNum+2), item.TaskStartDate.Format("Y-m-d"))
				}
				if value == "要求完成时间" {
					f.SetCellValue("Sheet1", service.Div(index+1)+strconv.Itoa(lineNum+2), item.TaskEndDate.Format("Y-m-d"))
				}
				if value == "创建时间" {
					f.SetCellValue("Sheet1", service.Div(index+1)+strconv.Itoa(lineNum+2), item.CreatedTime.Format("Y-m-d H:i:s"))
				}
			}
		}
	}

	f.SetActiveSheet(index)

	var buffer *bytes.Buffer
	buffer, _ = f.WriteToBuffer()
	con.Content = buffer.Bytes()

	return &con, err
}

// Statistics 统计
func (s *taskService) Statistics(req *model.SearchPlatTaskReq) (*model.TaskNumberCount, error) {
	var result model.TaskNumberCount
	// 统计数量
	count, err := s.Dao.InnerJoin("plat_task_handle", "plat_task.Id=plat_task_handle.task_id").Where(fmt.Sprintf("plat_task_handle.task_status='10' AND (plat_task_handle.main_user_id=%v OR FIND_IN_SET(%v, plat_task_handle.owner_user_id))", s.GetCxtUserId(), s.GetCxtUserId())).Group("plat_task.Id").Count()
	if err != nil {
		return nil, err
	}
	result.ToDoNumber = count

	return &result, nil
}

// Create 添加信息
func (s *taskService) Create(req *model.AddPlatTaskReq) (err error) {
	platTask := new(model.PlatTask)
	if err = gconv.Struct(req, platTask); err != nil {
		return
	}

	// 初始数据
	platTask.IsOverdue = "10" // 是否超期（10否20是）
	if platTask.TaskStartDate == nil || platTask.TaskStartDate.IsZero() {
		platTask.TaskStartDate = gtime.Now()
	}

	// 填充创建信息
	service.SetCreatedInfo(platTask, s.GetCxtUserId(), s.GetCxtUserName())
	// 填充更新信息
	//service.SetUpdatedInfo(platTask, s.GetCxtUserId(), s.GetCxtUserName())
	res, err := s.Dao.Insert(platTask)
	if err != nil {
		return
	}
	// 创建操作任务
	id, _ := res.LastInsertId()
	platTask.Id = int(id)
	err = s.startDingApproval(platTask)
	if err != nil {
		return
	}
	// 流程日志
	err = CreateTaskLog(s, nil, int(id), s.GetCxtUserId(), s.GetCxtUserName(), "创建督办", "创建督办成功", "")

	return
}

// AddTaskApproval 创建督办之后，需要钉钉审批才能生效
func (s *taskService) AddTaskApproval(flow *workflowModel.PlatWorkflow, msg *message.MixMessage) error {
	task, err := s.Dao.Where("id = ?", flow.BizCode).FindOne()
	if err != nil {
		return fmt.Errorf("创建督办审批 bizCode 不合法：%s Id: %d", flow.BizCode, flow.Id)
	}
	if err != nil {
		return err
	}
	if task == nil {
		return fmt.Errorf("督办不存在：%s Id: %d", flow.BizCode, flow.Id)
	}

	if msg.ProcessType != "finish" && msg.ProcessType != "terminate" {
		return fmt.Errorf("无法识别的 ProcessType ：%s", msg.ProcessType)
	}
	if msg.Result != "agree" && msg.Result != "refuse" && msg.Result != "" {
		return fmt.Errorf("无法识别的 Result ：%s", msg.Result)
	}
	if msg.ProcessType == "terminate" {
		_, err = s.Dao.Update("task_status='50'", fmt.Sprintf("id='%v'", task.Id))
		if err != nil {
			return err
		}
		// 流程日志
		err = CreateTaskLog(s, nil, task.Id, s.GetCxtUserId(), s.GetCxtUserName(), "督办审批", "撤销", "")
	} else {
		if msg.Result == "agree" {
			nextHandle := createNextTaskHandel(s, task, 10)
			_, err = s.Dao.DB.Insert("plat_task_handle", nextHandle)
			if err != nil {
				return err
			}
			// 发送消息通知
			go taskNotifyMessage(task.MainUserId, task.OwnerUserId, fmt.Sprintf("%v督办任务需要处理", task.TaskTitle))
			// 流程日志
			err = CreateTaskLog(s, nil, task.Id, s.GetCxtUserId(), s.GetCxtUserName(), "督办审批", "通过", "")
		} else if msg.Result == "refuse" {
			_, err = s.Dao.Update("task_status='40'", fmt.Sprintf("id='%v'", task.Id))
			if err != nil {
				return err
			}
			// 流程日志
			err = CreateTaskLog(s, nil, task.Id, s.GetCxtUserId(), s.GetCxtUserName(), "督办审批", "拒绝", "")
		}
	}

	return err
}

// ChangeStatus 修改状态
func (s *taskService) ChangeStatus(req *model.ChangeStatusReq) (err error) {
	data := ""
	where := fmt.Sprintf("id='%v'", req.TaskId)
	nodeName := "状态修改"
	desc := "修改成功"
	// 类型合规判断
	if req.Type == "TaskStatus" {
		data = fmt.Sprintf("task_status='%v'", req.NowStatus)
		nodeName = "状态修改"
		if req.NowStatus == "20" {
			desc = "关闭"
			data += fmt.Sprintf(",task_end_date='%v'", gtime.Now().Format("Y-m-d H:i:s"))
		}
	} else if req.Type == "IsOverdue" {
		nodeName = "超期状态修改"
		if req.NowStatus == "20" {
			desc = "超期"
		}
		data = fmt.Sprintf("is_overdue='%v'", req.NowStatus)
	} else {
		err = myerrors.TipsError("类型不匹配，请仔细检查。")
		return err
	}
	// 读取现有数据
	task, err := s.Dao.Where(where).FindOne()
	if err != nil {
		return err
	}
	if task == nil {
		err = myerrors.TipsError("数据异常，无匹配数据。")
		return err
	}
	// 状态数据一致性判断
	if (req.Type == "TaskStatus" && task.TaskStatus != req.OldStatus) || (req.Type == "IsOverdue" && task.IsOverdue != req.OldStatus) {
		err = myerrors.TipsError("状态不匹配，进行该操作")
		return err
	}
	// 更新数据
	_, err = s.Dao.Update(data, where)
	if err != nil {
		return
	}

	// 流程日志
	taskId, _ := strconv.Atoi(req.TaskId)
	err = CreateTaskLog(s, nil, taskId, s.GetCxtUserId(), s.GetCxtUserName(), nodeName, desc, "")

	return
}

// Handle 督办任务处理
//步骤号（10接收  15暂存  20提交  30审批（督办人）  40评价（监办人））
func (s *taskService) Handle(req *model.HandleReq) (err error) {
	// 步骤号（10接收  15暂存  20提交  30审批（督办人）  40评价（监办人））
	// 处理结果（10接收20提交30审批通过40审批退回）
	logNodeName := ""
	logDesc := ""
	var taskHandle model.PlatTaskHandle
	if req.Step != 15 {
		err = s.Dao.DB.Model("plat_task_handle").Where(fmt.Sprintf("task_id='%v' AND step=%v AND task_status='10' AND (main_user_id=%v OR FIND_IN_SET(%v, owner_user_id))", req.TaskId, req.Step, s.GetCxtUserId(), s.GetCxtUserId())).Scan(&taskHandle)
		if err != nil {
			if err == sql.ErrNoRows {
				err = myerrors.TipsError("数据不匹配，刷新数据重试")
				return err
			}
			return err
		}
	}
	now := gtime.Now()
	// 数据暂存，不做任何流程修改
	if req.Step == 15 {
		// 暂存
		logNodeName = "暂存"
		logDesc = s.GetCxtUserName() + "暂存进展信息"
		// 更新进展数据
		err = s.saveProgressList(req, now)
		if err != nil {
			return err
		}
	} else {
		var nextHandle = new(model.PlatTaskHandle)
		task, err := s.Dao.Where("id", req.TaskId).FindOne()
		if err != nil {
			return err
		}
		if task == nil {
			err = myerrors.TipsError("数据异常，无匹配数据")
			return err
		}
		// 构造更新数据
		handleData := g.Map{
			"task_status":    "20",
			"handle_user_id": s.GetCxtUserId(),
			"handle_date":    now.Format("Y-m-d H:i:s"),
			"handle_status":  req.HandleStatus,
			"handle_desc":    req.HandleDesc,
			"updated_by":     s.GetCxtUserId(),
			"updated_name":   s.GetCxtUserName(),
			"updated_time":   now.Format("Y-m-d H:i:s"),
		}
		taskData := g.Map{
			"updated_by":   s.GetCxtUserId(),
			"updated_name": s.GetCxtUserName(),
			"updated_time": now.Format("Y-m-d H:i:s"),
		}
		// 督办任务接收
		if req.Step == 10 {
			// 接收任务
			taskData["task_status"] = "20"
			taskData["receive_date"] = now.Format("Y-m-d H:i:s")
			nextHandle = createNextTaskHandel(s, task, 20)
			logNodeName = "接收"
			logDesc = s.GetCxtUserName() + "接收督办任务"
		} else if req.Step == 20 {
			// 提交数据
			nextHandle = createNextTaskHandel(s, task, 30)
			logNodeName = "提交"
			logDesc = s.GetCxtUserName() + "提交督办任务"
			// 更新进展数据
			err = s.saveProgressList(req, now)
			if err != nil {
				return err
			}
		} else if req.Step == 30 {
			// 督办人审批
			taskData["approver_id"] = s.GetCxtUserId()
			taskData["appro_date"] = now.Format("Y-m-d H:i:s")
			taskData["appro_status"] = req.HandleStatus
			taskData["appro_desc"] = req.HandleDesc
			logNodeName = "审批"
			if req.HandleStatus == "30" {
				logDesc = s.GetCxtUserName() + "审批通过"
				if req.IsComplete == "10" {
					// 任务完成
					nextHandle = createNextTaskHandel(s, task, 40)
				} else {
					// 任务未完成，继续执行
					nextHandle = createNextTaskHandel(s, task, 20)
				}
			} else if req.HandleStatus == "40" {
				logDesc = s.GetCxtUserName() + "审批退回"
				nextHandle = createNextTaskHandel(s, task, 20)
			}
		} else if req.Step == 40 {
			// 监办人评价
			taskData["evaluator_id"] = s.GetCxtUserId()
			taskData["evaluate_date"] = now.Format("Y-m-d H:i:s")
			taskData["evaluate_status"] = req.HandleStatus
			taskData["evaluate_desc"] = req.HandleDesc
			logNodeName = "评价"
			if req.HandleStatus == "30" {
				// 监办人评价，审批通过，任务结束
				logDesc = s.GetCxtUserName() + "审批通过"
				if req.IsComplete == "10" {
					// 任务完成
					nextHandle = nil
					taskData["actual_close_date"] = now.Format("Y-m-d H:i:s")
					taskData["task_status"] = "30"
				} else {
					// 任务未完成，继续执行
					nextHandle = createNextTaskHandel(s, task, 20)
				}
			} else if req.HandleStatus == "40" {
				logDesc = s.GetCxtUserName() + "审批退回"
				nextHandle = createNextTaskHandel(s, task, 20)
			}
		} else {
			err = myerrors.TipsError("未知步骤，无法操作")
			return err
		}

		// 更新数据
		// 更新督办任务数据
		_, err = s.Dao.Update(taskData, fmt.Sprintf("id='%v'", req.TaskId))
		if err != nil {
			return err
		}
		// 更新任务数据
		_, err = s.Dao.DB.Update("plat_task_handle", handleData, fmt.Sprintf("ID='%v'", taskHandle.ID))
		if err != nil {
			return err
		}
		// 创建下一条任务
		if nextHandle != nil {
			_, err = s.Dao.DB.Save("plat_task_handle", nextHandle)
			if err != nil {
				return err
			}
			// 只有督办、监办人需要发送提醒
			if req.Step == 20 {
				go taskNotifyMessage(task.SupervisorUserId, "", fmt.Sprintf("%v督办任务需要处理", task.TaskTitle))
			} else if req.Step == 30 && req.HandleStatus == "30" {
				go taskNotifyMessage(task.WatchUserId, "", fmt.Sprintf("%v督办任务需要处理", task.TaskTitle))
			}
		}
	}

	// 流程日志
	err = CreateTaskLog(s, nil, req.TaskId, s.GetCxtUserId(), s.GetCxtUserName(), logNodeName, logDesc, "")
	if err != nil {
		return err
	}

	return nil
}

// CreateTaskLog 任务日志创建方法
func CreateTaskLog(s1 *taskService, s2 *taskProgressService, taskId, userId int, userName, nodeName, desc, remark string) (err error) {
	var log model.PlatTaskLog
	startTime := gtime.Now()
	endTime := startTime
	// 默认为当前时间，然后随已有日志情况进行更新
	if s1 != nil {
		logs, err := s1.Dao.DB.Model(plat.PlatTaskLog.Table).Where(fmt.Sprintf("task_id='%v'", taskId)).Order("created_time DESC").FindAll()
		if err != nil && err != sql.ErrNoRows {
			return err
		}
		if len(logs) > 0 {
			startTime = logs[0]["end_time"].GTime()
		}
	} else {
		logs, err := s2.Dao.DB.Model(plat.PlatTaskLog.Table).Where(fmt.Sprintf("task_id='%v'", taskId)).Order("created_time DESC").FindAll()
		if err != nil && err != sql.ErrNoRows {
			return err
		}
		if len(logs) > 0 {
			startTime = logs[0]["end_time"].GTime()
		}
	}

	// 填入日志相关数据
	log.TaskId = taskId
	log.NodeName = nodeName
	log.Desc = desc
	log.StartTime = startTime
	log.EndTime = endTime
	log.Remark = remark
	log.CreatedTime = endTime
	log.CreatedName = userName
	log.CreatedBy = userId

	if s1 != nil {
		_, err = s1.Dao.DB.Save(plat.PlatTaskLog.Table, log)
	} else {
		_, err = s2.Dao.DB.Save(plat.PlatTaskLog.Table, log)
	}

	return err
}

// 创建个人的督办任务（其中，暂存不会生成个人任务，不会改变任何东西，只会新增一条日志）
func createNextTaskHandel(s *taskService, task *model.PlatTask, step int) *model.PlatTaskHandle {
	// 步骤号（10接收  15暂存  20提交  30审批（督办人）  40评价（监办人））
	var personTask model.PlatTaskHandle
	personTask.TaskId = task.Id
	personTask.TaskStatus = "10"
	personTask.Step = step
	// 督办任务为发起时
	if step == 10 {
		personTask.MainUserId = task.MainUserId
		personTask.OwnerUserId = task.OwnerUserId
	} else if step == 20 {
		// 创建提交任务
		personTask.MainUserId = task.MainUserId
		personTask.OwnerUserId = task.OwnerUserId
	} else if step == 30 {
		// 提交给督办人审批
		personTask.MainUserId = task.SupervisorUserId
	} else if step == 40 {
		// 提交给监办人评价
		personTask.MainUserId = task.WatchUserId
	}
	// 填充创建信息
	service.SetCreatedInfo(&personTask, s.GetCxtUserId(), s.GetCxtUserName())

	return &personTask
}

func (s *taskService) startDingApproval(task *model.PlatTask) error {
	dictMap := make(map[string]string, 0)
	userMap := make(map[int]string, 0)
	teamNames := ""
	dicts, err := s.Dao.DB.Model("sys_dict_data").Where("dict_type = 'plat_task_source'").FindAll()
	if err != nil && err != sql.ErrNoRows {
		return err
	}
	if len(dicts) == 0 {
		return errors.New("督办来源数据缺失，请前往配置")
	}
	for _, dict := range dicts {
		dictMap[dict["dict_value"].String()] = dict["dict_label"].String()
	}
	users, err := s.Dao.DB.Model("sys_user").FindAll()
	if err != nil && err != sql.ErrNoRows {
		return err
	}
	if len(users) == 0 {
		return errors.New("用户数据数据缺失，请前往配置")
	}
	for _, user := range users {
		userMap[user["id"].Int()] = user["nick_name"].String()
	}
	if task.OwnerUserId != "" {
		ids := strings.Split(task.OwnerUserId, ",")
		for _, id := range ids {
			if teamNames == "" {
				teamNames = userMap[gconv.Int(id)]
			} else {
				teamNames += "," + userMap[gconv.Int(id)]
			}
		}
	}

	workflowSrv, err := workflowService.NewFlowService(s.Ctx)
	if err != nil {
		return err
	}

	_, err = workflowSrv.StartProcessInstance(gconv.String(task.Id), "40", "", &workflow.StartProcessInstanceRequest{
		ProcessCode: &PlatTaskApprovalProcessCode,
		FormComponentValues: []*workflow.StartProcessInstanceRequestFormComponentValues{
			{
				Id:    utils.String("TextField-K2AD4O5B"),
				Name:  utils.String("督办标题"),
				Value: utils.String(task.TaskTitle),
			},
			{
				Id:    utils.String("DDDateField_C7LJMHNU6N40"),
				Name:  utils.String("发布时间"),
				Value: utils.String(task.CreatedTime.Format("Y-m-d")),
			},
			{
				Id:    utils.String("DDSelectField_OF3POKFZ43K"),
				Name:  utils.String("督办来源"),
				Value: utils.String(dictMap[task.Source]),
			},
			{
				Id:    utils.String("TextField_VPO2N6I4N5S0"),
				Name:  utils.String("督办内容"),
				Value: utils.String(task.TaskDesc),
			},
			{
				Id:    utils.String("DDAttachment_18RP41VRTITC0"),
				Name:  utils.String("附件"),
				Value: utils.String(""),
			},
			{
				Id:    utils.String("DDPhotoField_11WXOUDIZ85C0"),
				Name:  utils.String("图片"),
				Value: utils.String(""),
			},
			{
				Id:    utils.String("TextField_1ER7VNEEGU0W0"),
				Name:  utils.String("督办人"),
				Value: utils.String(userMap[task.SupervisorUserId]),
			},
			{
				Id:    utils.String("TextField_OKAEW6GD2FK0"),
				Name:  utils.String("监办人"),
				Value: utils.String(userMap[task.WatchUserId]),
			},
			{
				Id:    utils.String("TextField_G97RO96HMXK0"),
				Name:  utils.String("被督办人"),
				Value: utils.String(userMap[task.MainUserId]),
			},
			{
				Id:    utils.String("TextField_1FKS6CUW7REO0"),
				Name:  utils.String("共同完成人"),
				Value: utils.String(teamNames),
			},
			{
				Id:    utils.String("DDDateField_T9YBZCDTB680"),
				Name:  utils.String("要求完成时间"),
				Value: utils.String(task.TaskEndDate.Format("Y-m-d")),
			},
			{
				Id:    utils.String("TextField_LMV0Q71JD5C0"),
				Name:  utils.String("备注"),
				Value: utils.String(task.Remark),
			},
		},
	})
	if err != nil {
		return err
	}
	return err
}

// 处理暂存、提交任务进展
func (s *taskService) saveProgressList(req *model.HandleReq, now *gtime.Time) (err error) {
	ids := ""
	deleteWhere := fmt.Sprintf("task_id='%v'", req.TaskId)
	for index, progress := range req.ProgressList {
		if progress.Id != 0 {
			if ids == "" {
				ids = fmt.Sprintf("%v", progress.Id)
			} else {
				ids += fmt.Sprintf(",%v", progress.Id)
			}
		}
		req.ProgressList[index].TaskId = req.TaskId
		// 填充创建信息
		if progress.CreatedBy == 0 {
			service.SetCreatedInfo(req.ProgressList[index], s.GetCxtUserId(), s.GetCxtUserName())
		}
		//	填充更新信息
		service.SetUpdatedInfo(req.ProgressList[index], s.GetCxtUserId(), s.GetCxtUserName())
	}
	if ids != "" {
		deleteWhere += fmt.Sprintf(" AND ID NOT IN (%v)", ids)
	}
	// 保存督办进展
	// 1 标记删除旧的进展数据
	_, err = s.Dao.DB.Update("plat_task_progress", fmt.Sprintf("deleted_time='%v'", now.Format("Y-m-d H:i:s")), deleteWhere)
	if err != nil {
		return err
	}
	// 2 保存新的数据
	if len(req.ProgressList) > 0 {
		_, err = s.Dao.DB.Save("plat_task_progress", req.ProgressList)
		if err != nil {
			return err
		}
	}

	return nil
}