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

package plat

import (
	"bytes"
	"context"
	"database/sql"
	"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"
)

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
}

// 任务信息列表
func (s *taskService) GetList(req *model.SearchPlatTaskReq) (total int, TaskList []*model.PlatTaskEx, err error) {
	TaskModel := s.Dao.InnerJoin("plat_task_handle", "plat_task_handle.task_id=plat_task.id")
	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.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" {
		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()))
	}
	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("plat_task.created_time DESC").Fields("plat_task.*,plat_task_handle.step").Scan(&TaskList)
	return
}

// 导出数据
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 == "超期" {
					data := ""
					if item.TaskStatus == "10" {
						data = "否"
					} else if item.TaskStatus == "20" {
						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 H:i:s"))
				}
				if value == "结束时间" {
					f.SetCellValue("Sheet1", service.Div(index+1)+strconv.Itoa(lineNum+2), item.TaskEndDate.Format("Y-m-d H:i:s"))
				}
				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
}

// 统计
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
}

// 添加信息
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 = 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)
	nextHandle := createNextTaskHandel(s, platTask, 10)
	_, err = s.Dao.DB.Insert("plat_task_handle", nextHandle)
	if err != nil {
		return
	}
	// 流程日志
	err = CreateTaskLog(s, nil, int(id), s.GetCxtUserId(), s.GetCxtUserName(), "创建督办", "创建督办成功", "")

	return
}

// 修改状态
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
}

//步骤号（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() + "审批通过"
				nextHandle = createNextTaskHandel(s, task, 40)
			} 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() + "审批通过"
				nextHandle = nil
				taskData["actual_close_date"] = now.Format("Y-m-d H:i:s")
				taskData["task_status"] = "30"
			} 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
			}
		}
	}

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

	return nil
}

// 任务日志创建方法
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) 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 保存新的数据
	_, err = s.Dao.DB.Save("plat_task_progress", req.ProgressList)
	if err != nil {
		return err
	}

	return nil
}