package service

import (
	"fmt"
	"strconv"
	"strings"
	"time"

	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/log_opt"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/utils/xtime"

	"github.com/linmadan/egglib-go/core/application"
	"github.com/linmadan/egglib-go/utils/tool_funs"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/factory"
	roleService "gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/role"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/task/adapter"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/task/command"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/domain"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/infrastructure/dao"
)

type TaskService struct{}

func NewTaskService() *TaskService {
	newService := &TaskService{}
	return newService
}

func dayEndTime(t time.Time) time.Time {
	y, m, d := t.Local().Date()
	t2 := time.Date(y, m, d, 23, 59, 59, 0, time.Local)
	return t2
}

func dayZeroTime(t time.Time) time.Time {
	y, m, d := t.Local().Date()
	t2 := time.Date(y, m, d, 0, 0, 0, 0, time.Local)
	return t2
}

// CreateTask 重评估模板中创建
func (srv TaskService) CreateTaskByProject(transactionContext application.TransactionContext, param *command.CreateTaskByProjectCommand) error {
	taskRepo := factory.CreateTaskRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	cnt, _, err := taskRepo.Find(map[string]interface{}{
		"name":      param.Name,
		"leaderId":  strconv.Itoa(param.LeaderId),
		"createdBy": 0,
		"limit":     1,
	})
	if err != nil {
		return application.ThrowError(application.INTERNAL_SERVER_ERROR, "查询任务失败:"+err.Error())
	}
	if cnt > 0 {

		//任务已存在
		return nil
	}
	userRepo := factory.CreateUserRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})

	_, leaderList, err := userRepo.Find(map[string]interface{}{
		"id": param.LeaderId,
	})
	if err != nil {
		return application.ThrowError(application.INTERNAL_SERVER_ERROR, "查询人员失败:"+err.Error())
	}
	if len(leaderList) == 0 {
		return application.ThrowError(application.INTERNAL_SERVER_ERROR, "没有查询到人员")
	}
	leaderData := leaderList[0]
	nowTime := time.Now()
	newTask := domain.Task{
		Id:        0,
		CreatedAt: time.Time{},
		UpdatedAt: time.Time{},
		DeletedAt: nil,
		CompanyId: int(leaderData.CompanyId),
		Name:      param.Name,
		Alias:     param.Name,
		Leader: domain.TaskLeader{
			Id:      leaderData.Id,
			Account: leaderData.Account,
			Name:    leaderData.Name,
		},
		Status:        domain.TaskRunning,
		Level:         0,
		LevelName:     "",
		RelatedUser:   []int{int(leaderData.Id)},
		RunAt:         nowTime.Unix(),
		StopAt:        0,
		SortBy:        domain.TaskSortNull,
		CreatedBy:     0, //标记为 通过每日评估生成的任务
		AssistFlagMax: 1, //默认一天
	}
	if int(leaderData.ParentId) != 0 {
		newTask.RelatedUser = append(newTask.RelatedUser, int(leaderData.ParentId))
	}
	newTask.ApplyLevelName("战略任务")
	err = taskRepo.Save(&newTask)
	if err != nil {
		return application.ThrowError(application.INTERNAL_SERVER_ERROR, "创建任务失败:"+err.Error())
	}
	newTaskStage := []*domain.TaskStage{}
	//记录待执行的里程碑
	newTask.SetCurrentStage(newTaskStage)
	err = taskRepo.Save(&newTask)
	if err != nil {
		return application.ThrowError(application.INTERNAL_SERVER_ERROR, "保存任务失败:"+err.Error())
	}
	return nil
}

// CreateTask 创建任务
func (srv TaskService) CreateTask(param *command.CreateTaskCommand, userReq *domain.UserAuth) (map[string]interface{}, error) {
	sortNamed := domain.TaskSortBy(param.SortBy)
	if sortNamed.Named() == "" {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, "优先级设置错误")
	}
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	taskRepo := factory.CreateTaskRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	cnt, _, err := taskRepo.Find(map[string]interface{}{
		"name":      param.Alias,
		"leaderId":  strconv.Itoa(param.LeaderId),
		"createdBy": 1,
		"limit":     1,
	})
	if err != nil {
		return map[string]interface{}{}, application.ThrowError(application.INTERNAL_SERVER_ERROR, "创建任务失败:"+err.Error())
	}
	if cnt > 0 {
		return map[string]interface{}{}, application.ThrowError(application.BUSINESS_ERROR, "已经存在相同的任务")
	}
	userRepo := factory.CreateUserRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})

	_, leaderList, err := userRepo.Find(map[string]interface{}{
		"id":        param.LeaderId,
		"companyId": param.CompanyId,
	})
	if err != nil {
		return map[string]interface{}{}, application.ThrowError(application.INTERNAL_SERVER_ERROR, "查询人员失败:"+err.Error())
	}
	if len(leaderList) == 0 {
		return map[string]interface{}{}, application.ThrowError(application.INTERNAL_SERVER_ERROR, "没有查询到人员")
	}
	leaderData := leaderList[0]
	//默认填入人员的上级
	relatedUserIds := []int{int(leaderData.ParentId)}
	for _, val := range param.RelatedUserId {
		id, _ := strconv.Atoi(val)
		relatedUserIds = append(relatedUserIds, id)
	}
	var relatedUser []*domain.User
	if len(relatedUserIds) > 0 {
		_, relatedUser, err = userRepo.Find(map[string]interface{}{
			"ids":       relatedUserIds,
			"companyId": param.CompanyId,
		})
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取任务的相关人员"+err.Error())
		}
	}

	nowTime := time.Now()
	newTask := domain.Task{
		Id:        0,
		CreatedAt: time.Time{},
		UpdatedAt: time.Time{},
		DeletedAt: nil,
		CompanyId: int(leaderData.CompanyId),
		Name:      param.Alias,
		Alias:     param.Alias,
		Leader: domain.TaskLeader{
			Id:      leaderData.Id,
			Account: leaderData.Account,
			Name:    leaderData.Name,
		},
		Status:        domain.TaskRunning,
		Level:         0,
		LevelName:     "",
		RelatedUser:   []int{int(leaderData.Id)},
		RunAt:         nowTime.Unix(),
		StopAt:        0,
		SortBy:        domain.TaskSortBy(param.SortBy),
		CreatedBy:     1, //标记为页面上直接创建的任务
		AssistFlagMax: 1, //默认一天
	}
	//处理endTime
	if param.EndTime == 0 {
		newTask.EndTime = 0
	} else {
		newTask.EndTime = dayEndTime(time.Unix(param.EndTime, 10)).Unix()
	}
	newTask.ApplyLevelName(param.LevelName)
	newTask.RelatedUser = []int{}
	for _, val := range relatedUser {
		newTask.RelatedUser = append(newTask.RelatedUser, int(val.Id))
	}

	err = taskRepo.Save(&newTask)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	// 生成创建日志
	_ = log_opt.CreateTask(userReq, newTask)

	return map[string]interface{}{"id": newTask.Id}, nil
}

// UpdateTask 更新任务
func (srv TaskService) UpdateTask(param *command.UpdateTaskCommand, userReq *domain.UserAuth) (map[string]interface{}, error) {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	if len(param.StageList) > 5 {
		return map[string]interface{}{
			"id": param.Id,
		}, application.ThrowError(application.INTERNAL_SERVER_ERROR, "里程碑数量太多")
	}
	taskRepo := factory.CreateTaskRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	userRepo := factory.CreateUserRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	taskStageRepo := factory.CreateTaskStageRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	taskData, err := taskRepo.FindOne(map[string]interface{}{
		"id": param.Id,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	_, stageList, err := taskStageRepo.Find(map[string]interface{}{
		"taskId": param.Id,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	//检查leaderid

	_, leaderList, err := userRepo.Find(map[string]interface{}{"id": param.LeaderId, "limit": 1})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if len(leaderList) == 0 {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "负责人数据验证不通过")
	}
	if leaderList[0].CompanyId != int64(param.CompanyId) {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "负责人数据验证不通过")
	}

	// 拷贝数据
	var copyTask = taskData.Copy()
	var copyStageList = make([]*domain.TaskStage, 0)
	for _, v := range stageList {
		c := v.Copy()
		copyStageList = append(copyStageList, &c)
	}

	//更新任务的相关人员
	relatedUserIds := []int{}
	for _, val := range param.RelatedUserId {
		id, _ := strconv.Atoi(val)
		relatedUserIds = append(relatedUserIds, id)
	}
	var relatedUser []*domain.User
	if len(relatedUserIds) > 0 {
		_, relatedUser, err = userRepo.Find(map[string]interface{}{
			"ids":       relatedUserIds,
			"companyId": param.CompanyId,
		})
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取任务的相关人员"+err.Error())
		}
	}
	taskData.RelatedUser = []int{}
	for _, val := range relatedUser {
		taskData.RelatedUser = append(taskData.RelatedUser, int(val.Id))
	}
	//更新任务名称，任务分类
	taskData.Alias = param.Alias
	taskData.ApplyLevelName(param.LevelName)

	nowTime := time.Now()
	//更新里程碑数据
	stageMap := map[int]*domain.TaskStage{}
	for _, val := range stageList {
		val.DeletedAt = &nowTime
		stageMap[val.Id] = val
	}
	lastPlanCompletedAt := time.Time{}
	newStageList := []*domain.TaskStage{}
	//标记 变更完成时间的 里程碑
	//markStage := []domain.TaskStage{}
	for i, val2 := range param.StageList {
		t, err := time.ParseInLocation("2006-01-02", val2.PlanCompletedAt, time.Local)
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "请填写里程碑完成时间")
		}
		if i > 0 {
			if lastPlanCompletedAt.After(t) {
				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "里程碑["+val2.Name+"]完成时间填写错误")
			}
		}
		lastPlanCompletedAt = t
		if val2.Id == 0 {
			newStage := domain.TaskStage{
				Id:              0,
				TaskId:          taskData.Id,
				Name:            val2.Name,
				SortBy:          i + 1,
				PlanCompletedAt: 0,
				RealCompletedAt: 0,
			}
			newStage.SetPlanCompleted(t)
			newStageList = append(newStageList, &newStage)
			continue
		}
		oldStage, ok := stageMap[val2.Id]
		if !ok {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "里程碑数据被其他人变更")
		}
		oldStage.DeletedAt = nil
		oldStage.SortBy = i + 1
		oldStage.Name = val2.Name
		oldStage.SetPlanCompleted(t)
	}
	stageList = append(stageList, newStageList...)
	//查询是否已经有每日评估
	taskRecordRepo := factory.CreateTaskRecordRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	for _, v := range stageList {
		if v.DeletedAt != nil {
			cnt, _, err := taskRecordRepo.Find(map[string]interface{}{
				"taskId":         taskData.Id,
				"taskStageCheck": fmt.Sprintf(`{"id":"%d"}`, v.Id),
				"limit":          1,
			})
			if err != nil {
				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "相关联的任务反馈信息"+err.Error())
			}
			if cnt > 0 {
				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, fmt.Sprintf("里程碑[%s]已有日评数据，不能删除", v.Name))
			}
		}
	}
	//更新当前 执行的里程碑
	err = taskStageRepo.Save(stageList)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if taskData.CreatedBy == 1 {
		taskData.Leader = domain.TaskLeader{
			Id:      leaderList[0].Id,
			Account: leaderList[0].Account,
			Name:    leaderList[0].Name,
		}
	}
	taskData.SetCurrentStage(stageList)
	taskData.SetSortBy(param.SortBy)
	//处理endTime
	if param.EndTime == 0 {
		taskData.EndTime = 0
	} else {
		taskData.EndTime = dayEndTime(time.Unix(param.EndTime, 10)).Unix()
	}
	taskData.UseEndTime = param.UseEndTime
	if param.AssistFlagMax > 0 {
		taskData.AssistFlagMax = param.AssistFlagMax
	}
	err = taskRepo.Save(taskData)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	// messageRepo := factory.CreateMessagePersonalRepository(map[string]interface{}{
	// 	"transactionContext": transactionContext,
	// })
	//根据markStage 记录的里程碑数据生成通知
	// for _, val := range markStage {
	// for _, val2 := range taskData.RelatedUser {
	// 	t1 := time.Unix(val.PlanCompletedAt, 0).Format("2006-01-02")
	// 	s := fmt.Sprintf(`%s 负责的任务 %s 的里程碑 %s 计划完成时间变更为 %s，请知晓！`, taskData.Leader.Name, taskData.Alias, val.Name, t1)
	// 	payload := map[string]string{
	// 		"id":            strconv.Itoa(val.Id),
	// 		"taskName":      taskData.Name,
	// 		"taskStageName": val.Name,
	// 	}
	// 	payloadStr, _ := json.Marshal(payload)
	// 	newMessage := domain.MessagePersonal{
	// 		Id:           0,
	// 		Types:        domain.MessageTypesTaskModify,
	// 		TargetUserId: val2,
	// 		ReadFlag:     domain.MessageUnread,
	// 		Title:        s,
	// 		Content:      s,
	// 		Payload:      string(payloadStr),
	// 	}
	// 	err = messageRepo.Save(&newMessage)
	// 	if err != nil {
	// 		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	// 	}
	// }
	// }
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	// 生成更新日志
	_ = log_opt.UpdateTask(userReq, &copyTask, taskData, copyStageList, stageList)

	return map[string]interface{}{
		"id": param.Id,
	}, nil
}

func (srv TaskService) SaveTaskLevel(param *command.CreateTaskLevelCommand) error {
	defalutLevel := domain.DefaultTaskLevel()
	for _, val := range defalutLevel {
		if val.LevelName == param.LevelName {
			return nil
		}
	}
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	taskLevelRepo := factory.CreateTaskLevelRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	cnt, _, err := taskLevelRepo.Find(map[string]interface{}{
		"companyId": param.CompanyId,
		"levelName": param.LevelName,
		"limit":     1,
	})
	if err != nil {
		return application.ThrowError(application.INTERNAL_SERVER_ERROR, "检查任务优先级失败:"+err.Error())
	}
	if cnt > 0 {
		return nil
	}
	newTaskLevel := domain.TaskLevel{
		Id:        0,
		LevelName: param.LevelName,
		CompanyId: param.CompanyId,
	}
	err = taskLevelRepo.Save(&newTaskLevel)
	if err != nil {
		return application.ThrowError(application.INTERNAL_SERVER_ERROR, "保存任务优先级失败:"+err.Error())
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	return nil
}

// 获取任务详情
func (srv TaskService) GetTaskInfo(param *command.GetTaskCommand) (*adapter.TaskInfoAdapter, error) {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	taskRepo := factory.CreateTaskRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	taskStageRepo := factory.CreateTaskStageRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	userRepo := factory.CreateUserRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	taskData, err := taskRepo.FindOne(map[string]interface{}{
		"id": param.TaskId,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	_, stageList, err := taskStageRepo.Find(map[string]interface{}{
		"taskId": param.TaskId,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	relatedUserId := taskData.RelatedUser
	var relatedUserList []*domain.User
	if len(relatedUserId) > 0 {
		_, relatedUserList, err = userRepo.Find(map[string]interface{}{
			"ids":       relatedUserId,
			"companyId": param.CompanyId,
		})
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取相关人员"+err.Error())
		}
	}
	_, leaderDataList, err := userRepo.Find(map[string]interface{}{
		"id": taskData.Leader.Id,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取相关人员"+err.Error())
	}
	var leaderData domain.User
	if len(leaderDataList) > 0 {
		leaderData = *leaderDataList[0]
	}
	//查询是否已经有每日评估
	taskRecordRepo := factory.CreateTaskRecordRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	result := adapter.TaskInfoAdapter{
		Id:       taskData.Id,
		Name:     taskData.Name,
		Alias:    taskData.Alias,
		LeaderId: taskData.Leader.Id,
		Leader: adapter.UserData{
			Id:       taskData.Leader.Id,
			Account:  taskData.Leader.Account,
			Name:     taskData.Leader.Name,
			ParentId: leaderData.ParentId,
		},
		Status:            int(taskData.Status),
		StatusDescription: taskData.Status.Named(),
		LevelName:         taskData.LevelName,
		SortBy:            int(taskData.SortBy),
		EndTime:           taskData.EndTime,
		UseEndtime:        taskData.UseEndTime,
		RelatedUserId:     []string{},
		RelatedUser:       []adapter.UserData{},
		StageList:         []adapter.TaskStage{},
		AssistFlagMax:     taskData.AssistFlagMax,
		CreatedBy:         taskData.CreatedBy,
	}
	for _, val := range relatedUserList {
		idStr := strconv.Itoa(int(val.Id))
		result.RelatedUserId = append(result.RelatedUserId, idStr)
		result.RelatedUser = append(result.RelatedUser, adapter.UserData{
			Id:       val.Id,
			Account:  val.Account,
			Name:     val.Name,
			ParentId: val.ParentId,
		})

	}

	for _, val := range stageList {
		t1 := ""
		t2 := ""
		if val.PlanCompletedAt > 0 {
			t1 = time.Unix(val.PlanCompletedAt, 0).Local().Format("2006-01-02")
		}
		if val.RealCompletedAt > 0 {
			t2 = time.Unix(val.RealCompletedAt, 0).Local().Format("2006-01-02")
		}
		stage := adapter.TaskStage{
			Id:                val.Id,
			Name:              val.Name,
			PlanCompletedAt:   t1,
			RealCompletedAt:   t2,
			SortBy:            val.SortBy,
			StatusDescription: val.StatusDescription(),
		}
		cnt, _, _ := taskRecordRepo.Find(map[string]interface{}{
			"taskId":         taskData.Id,
			"taskStageCheck": fmt.Sprintf(`{"id":"%d"}`, val.Id),
			"limit":          1,
		})
		if cnt > 0 {
			stage.IsRef = true
		}
		result.StageList = append(result.StageList, stage)
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	return &result, nil
}

// RunTask 启动任务
func (srv TaskService) RunTask(param *command.RunTaskCommand) (map[string]interface{}, error) {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	taskRepo := factory.CreateTaskRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	taskData, err := taskRepo.FindOne(map[string]interface{}{
		"id": param.TaskId,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if taskData.Status == domain.TaskRunning {
		return map[string]interface{}{"id": param.TaskId}, nil
	}
	taskData.Status = domain.TaskRunning
	taskData.RunAt = time.Now().Unix()
	err = taskRepo.Save(taskData)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "保存任务数据"+err.Error())
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	return map[string]interface{}{"id": param.TaskId}, nil
}

// RunTask 停止任务
func (srv TaskService) StopTask(param *command.StopTaskCommand) (map[string]interface{}, error) {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	taskRepo := factory.CreateTaskRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	taskData, err := taskRepo.FindOne(map[string]interface{}{
		"id": param.TaskId,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if taskData.Status == domain.TaskStop {
		return map[string]interface{}{"id": param.TaskId}, nil
	}

	taskData.Status = domain.TaskStop
	taskData.StopAt = time.Now().Unix()
	err = taskRepo.Save(taskData)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "保存任务数据"+err.Error())
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	return map[string]interface{}{"id": param.TaskId}, nil
}

// ListTask 任务列表
func (srv TaskService) ListTask(param *command.ListTaskCommand) (map[string]interface{}, error) {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	taskRepo := factory.CreateTaskRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	taskStageRepo := factory.CreateTaskStageRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	//
	condition := map[string]interface{}{
		"offset":    0,
		"limit":     20,
		"companyId": param.CompanyId,
	}
	param.SearchWord = strings.TrimSpace(param.SearchWord)
	if len(param.SearchWord) > 0 {
		condition["aliasOrLeader"] = "%" + param.SearchWord + "%"
	}
	if len(param.LevelName) > 0 {
		condition["levelName"] = param.LevelName
	}
	if param.PageSize > 0 {
		condition["limit"] = param.PageSize
		if param.PageNumber > 0 {
			condition["offset"] = (param.PageNumber - 1) * param.PageSize
		}
	}

	taskCnt, taskList, err := taskRepo.Find(condition)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "查询任务数据"+err.Error())
	}
	taskIdList := []int{}
	for _, val := range taskList {
		taskIdList = append(taskIdList, val.Id)
	}
	var stageList []*domain.TaskStage
	if len(taskIdList) > 0 {
		_, stageList, err = taskStageRepo.Find(map[string]interface{}{
			"taskIdList": taskIdList,
		})
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "查询任务阶段数据"+err.Error())
		}
	}

	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	taskResult := []*adapter.TaskItem{}
	taskMapResult := map[int]*adapter.TaskItem{}
	for _, val := range taskList {
		tk := adapter.TaskItem{
			Id:        val.Id,
			Name:      val.Name,
			Alias:     val.Alias,
			Leader:    val.Leader.Name,
			Status:    int(val.Status),
			SortBy:    int(val.SortBy),
			LevelName: val.LevelName,
			Anomaly:   val.Anomaly,
			WarnFlag:  int(val.WarnFlag),
			// StageA:    adapter.TaskStage{},
			// StageB:    adapter.TaskStage{},
			// StageC:    adapter.TaskStage{},
			// StageD:    adapter.TaskStage{},
			// StageE:    adapter.TaskStage{},
		}
		taskResult = append(taskResult, &tk)
		taskMapResult[val.Id] = &tk
	}
	for _, val := range stageList {
		taskData, ok := taskMapResult[val.TaskId]
		if !ok {
			continue
		}
		stage := adapter.TaskStage{
			Id:                val.Id,
			Name:              val.Name,
			StatusDescription: val.StatusDescription(),
			SortBy:            val.SortBy,
			PlanCompletedAt:   time.Unix(int64(val.PlanCompletedAt), 0).Local().Format("2006-01-02"),
			RealCompletedAt:   "",
		}
		if val.RealCompletedAt > 0 {
			stage.RealCompletedAt = time.Unix(int64(val.RealCompletedAt), 0).Local().Format("2006-01-02")
		}
		switch val.SortBy {
		case 1:
			taskData.StageA = stage
		case 2:
			taskData.StageB = stage
		case 3:
			taskData.StageC = stage
		case 4:
			taskData.StageD = stage
		case 5:
			taskData.StageE = stage
		}
	}
	result := tool_funs.SimpleWrapGridMap(int64(taskCnt), taskResult)
	return result, nil
}

// CancelAttention 用户取消关注某个任务
func (srv TaskService) CancelAttention(param *command.CancelAttentionCommand) error {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	taskIgnoreRepo := factory.CreateTaskIgnoreRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	taskIgnore := domain.TaskIgnore{
		Id:        0,
		TaskId:    param.TaskId,
		UserId:    param.UserId,
		CreatedAt: time.Time{},
	}
	err = taskIgnoreRepo.Save(&taskIgnore)
	if err != nil {
		return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	return nil
}

// ReplyTaskStage 根据每日的任务反馈 ，更新任务里程碑
func (srv TaskService) ReplyTaskStage(transactionContext application.TransactionContext, param []*domain.TaskRecord) error {
	taskRepo := factory.CreateTaskRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	taskStageRepo := factory.CreateTaskStageRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	for _, val := range param {
		_, taskDataList, err := taskRepo.Find(map[string]interface{}{"id": val.TaskId})
		if err != nil {
			return application.ThrowError(application.INTERNAL_SERVER_ERROR, "找不到任务数据"+err.Error())
		}
		if len(taskDataList) == 0 {
			continue
		}
		taskData := taskDataList[0]
		_, stageList, err := taskStageRepo.Find(map[string]interface{}{"taskId": val.TaskId})
		if err != nil {
			return application.ThrowError(application.INTERNAL_SERVER_ERROR, "找不到任务里程碑数据"+err.Error())
		}
		if len(stageList) == 0 {
			continue
		}

		//改为定时检查每日任务反馈，并计算反馈异常数
		//这边仅记录 里程碑的完成情况
		for _, val2 := range stageList {
			if val2.Id != val.TaskStageCheck.Id {
				continue
			}
			val2.RealCompletedAt = val.TaskStageCheck.RealCompletedAt
			break
		}
		err = taskStageRepo.Save(stageList)
		if err != nil {
			return application.ThrowError(application.INTERNAL_SERVER_ERROR, "保存任务里程碑数据"+err.Error())
		}
		taskData.SetCurrentStage(stageList)
		err = taskRepo.Save(taskData)
		if err != nil {
			return application.ThrowError(application.INTERNAL_SERVER_ERROR, "保存任务数据"+err.Error())
		}
	}
	return nil
}

// 获取任务的反馈
func (srv TaskService) ListTaskRecord(param *command.ListTaskRecordCommand) (map[string]interface{}, error) {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	taskRecordRepo := factory.CreateTaskRecordRepository(map[string]interface{}{"transactionContext": transactionContext})

	cnt, taskRecordList, err := taskRecordRepo.Find(map[string]interface{}{
		"companyId": param.CompanyId,
		"taskId":    param.TaskId,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取任务反馈数据"+err.Error())
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	resultList := []adapter.TaskRecordAdapter{}
	nowDay := time.Now().Format("2006-01-02")
	for _, val := range taskRecordList {
		recordCreatedAt := val.CreatedAt.Local().Format("2006-01-02")
		item := adapter.TaskRecordAdapter{
			Id:            val.Id,
			StaffAssessId: val.StaffAssessId,
			TaskId:        val.TaskId,
			TaskCategory:  val.TaskCategory,
			TaskName:      val.TaskName,
			TaskAlias:     val.TaskAlias,
			TaskLeader:    val.TaskLeader.Name,
			RemarkContent: val.RemarkContent, // 填写反馈内容
			AssistLevel:   val.AssistLevel,   // 上级辅助等级
			AssistContent: val.AssistContent, // 上级辅助内容
			AnomalyState:  val.AnomalyState,
			TaskStageCheck: adapter.TaskStage{
				Id:                val.Id,
				Name:              val.TaskStageCheck.Name,
				StatusDescription: val.TaskStageCheck.StatusDescription(),
				SortBy:            val.TaskStageCheck.SortBy,
				PlanCompletedAt:   "",
				RealCompletedAt:   "",
			},
			CreatedAt: recordCreatedAt,
		}
		if val.AnomalyState == domain.AnomalyStateInit {
			item.AnomalyState = domain.AnomalyState0
		}
		if nowDay == recordCreatedAt {
			item.AnomalyState = domain.AnomalyState1
		}
		t1 := time.Unix(val.TaskStageCheck.PlanCompletedAt, 0).Local().Format("2006-01-02")
		item.TaskStageCheck.PlanCompletedAt = t1
		if val.TaskStageCheck.RealCompletedAt > 0 {
			t2 := time.Unix(val.TaskStageCheck.RealCompletedAt, 0).Local().Format("2006-01-02")
			item.TaskStageCheck.RealCompletedAt = t2
		}
		//_, contentList, err := assessContentRepo.Find(map[string]interface{}{
		//	"staffAssessId": val.StaffAssessId,
		//	"category":      val.TaskCategory,
		//	"name":          val.TaskName,
		//})
		//if err != nil {
		//	return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取评估反馈数据"+err.Error())
		//}
		//if len(contentList) > 0 {
		//	for _, val2 := range contentList[0].Remark {
		//		item.AssistContent += val2.RemarkText + "\n"
		//	}
		//}
		resultList = append(resultList, item)
	}

	result := tool_funs.SimpleWrapGridMap(int64(cnt), resultList)
	return result, nil
}

// 删除任务
func (srv TaskService) DeleteTaskInfo(param *command.GetTaskCommand) (*adapter.TaskInfoAdapter, error) {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	taskRepo := factory.CreateTaskRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	taskData, err := taskRepo.FindOne(map[string]interface{}{
		"id": param.TaskId,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "xx"+err.Error())
	}
	if taskData.CompanyId != param.CompanyId {
		return nil, nil
	}
	nowTime := time.Now()
	taskData.DeletedAt = &nowTime
	err = taskRepo.Save(taskData)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "xx"+err.Error())
	}

	taskIgnoreRepo := factory.CreateTaskIgnoreRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	_, taskIgnoreList, err := taskIgnoreRepo.Find(map[string]interface{}{
		"taskId": param.TaskId,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "xx"+err.Error())
	}
	for _, v := range taskIgnoreList {
		err = taskIgnoreRepo.Remove(v.Id)
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	return nil, nil
}

// 员工绩效-任务管理-列表筛选项
func (srv TaskService) ConditionForListTask2(param *command.GetSelcetCommand) (map[string]interface{}, error) {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	taskDao := dao.NewTaskDao(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	hrbpFlag, err := roleService.GetHrBp(transactionContext, int(param.CompanyId), int(param.UserId))
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取用户的角色信息"+err.Error())
	}
	var tasklistData []dao.TaskData1
	if hrbpFlag == domain.RoleTypeSystem {
		tasklistData, err = taskDao.ListTask2ForHrbp(param.UserId, param.CompanyId)
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取任务列表"+err.Error())
		}
	} else {
		tasklistData, err = taskDao.ListTask2(param.UserId)
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取任务列表"+err.Error())
		}
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	selectList := []adapter.ConditionSelect{}
	uniqueMap := map[string]struct{}{}
	// 任务名称,负责人,优先级
	switch param.Cmd {
	case "任务名称":
		for _, val := range tasklistData {
			if _, ok := uniqueMap[val.Name]; ok {
				continue
			}
			uniqueMap[val.Name] = struct{}{}
			selectList = append(selectList, adapter.ConditionSelect{Name: val.Name})
		}
	case "负责人":
		for _, val := range tasklistData {
			if _, ok := uniqueMap[val.LeaderName]; ok {
				continue
			}
			uniqueMap[val.LeaderName] = struct{}{}
			selectList = append(selectList, adapter.ConditionSelect{Name: val.LeaderName})
		}
	case "优先级":
		for _, val := range tasklistData {
			if _, ok := uniqueMap[val.LevelName]; ok {
				continue
			}
			uniqueMap[val.LevelName] = struct{}{}
			if len(val.LevelName) > 0 {
				selectList = append(selectList, adapter.ConditionSelect{Name: val.LevelName})
			}
		}
	}
	result := map[string]interface{}{
		"list": selectList,
	}
	return result, nil
}

// 员工绩效-任务管理-列表 (新)
func (srv TaskService) ListTask3(param *command.SearchTaskCommand) (map[string]interface{}, error) {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	hrbpFlag, err := roleService.GetHrBp(transactionContext, int(param.CompanyId), int(param.UserId))
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取用户的角色信息"+err.Error())
	}
	if hrbpFlag == domain.RoleTypeSystem {
		listData, err := srv.listTask3ForHrbp(param)
		return listData, err
	}
	// 获取我的上级人员
	userRepo := factory.CreateUserRepository(map[string]interface{}{"transactionContext": transactionContext})
	_, me, err := userRepo.Find(map[string]interface{}{"id": param.UserId})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取用户的信息"+err.Error())
	}
	if len(me) == 0 {
		return nil, nil
	}
	var meParent []*domain.User
	if me[0].ParentId > 0 {
		_, meParent, _ = userRepo.Find(map[string]interface{}{"id": me[0].ParentId})
	}

	param.SearchWord = strings.TrimSpace(param.SearchWord)
	if len(param.SearchWord) > 0 {
		param.SearchWord = "%" + param.SearchWord + "%"
	}
	var limit = 20
	var offset = 0
	if param.PageSize > 0 {
		limit = param.PageSize
		if param.PageNumber > 0 {
			offset = (param.PageNumber - 1) * param.PageSize
		}
	}
	condition := dao.ListTaskCondition{
		Limit:      limit,
		Offset:     offset,
		UserId:     param.UserId,
		CompanyId:  param.CompanyId,
		OnlyMy:     param.OnlyMy,
		SearchWord: param.SearchWord,
		LevelName:  param.LevelName,
	}

	taskDao := dao.NewTaskDao(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	//任务列表数据
	taskListData, err := taskDao.ListTaskNotHrbpV2(condition)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取任务列表"+err.Error())
	}
	//查到的任务数据总数
	taskCount, err := taskDao.CountTaskNotHrbp(condition)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "统计任务总数"+err.Error())
	}
	//里程碑异常
	taskStageAnomalyCnt, err := taskDao.CountTaskStageAnomalyNotHrbp(condition)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "统计异常的任务里程碑总数"+err.Error())
	}
	//反馈异常数
	taskAnomalyCnt, err := taskDao.CountTaskAnomalyNotHrbp(condition)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "统计任务反馈异常总数"+err.Error())
	}
	userDao := dao.NewUserDao(map[string]interface{}{"transactionContext": transactionContext})
	// 获取员工全部子集
	childUser, err := userDao.AllChildUser(param.UserId)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取下级员工"+err.Error())
	}

	var taskAnomalyList []*domain.TaskAnomaly
	//获取异常的任务反馈记录
	taskAnomalyRepo := factory.CreateTaskAnomalyRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	for _, val := range taskListData {
		_, listData, err := taskAnomalyRepo.Find(map[string]interface{}{
			"taskId": val.TaskId,
			"isLast": 1,
		})
		if err == nil {
			taskAnomalyList = append(taskAnomalyList, listData...)
		}
	}
	taskResult := []*adapter.TaskItem{}
	taskStageRepo := factory.CreateTaskStageRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	for _, val := range taskListData {
		tk := adapter.TaskItem{
			Id:        val.TaskId,
			Name:      "",
			Alias:     val.Alias,
			Leader:    val.LeaderName,
			Status:    val.Status,
			SortBy:    val.SortBy,
			LevelName: val.LevelName,
			UpdatedAt: val.UpdatedAt.Local().Format("2006-01-02 15:04:05"),
			Anomaly:   val.Anomaly,
			WarnFlag:  val.WarnFlag,
			LastStage: adapter.TaskStage{
				Id:                val.LastStage.Id,
				Name:              val.LastStage.Name,
				StatusDescription: val.LastStage.StatusDescription(),
				SortBy:            val.LastStage.SortBy,
				PlanCompletedAt:   time.Unix(int64(val.LastStage.PlanCompletedAt), 0).Local().Format("2006-01-02"),
				RealCompletedAt:   "",
				IsRef:             false,
			},
			CurrentStage: adapter.TaskStage{
				Id:                val.CurrentStage.Id,
				Name:              val.CurrentStage.Name,
				StatusDescription: val.CurrentStage.StatusDescription(),
				SortBy:            val.CurrentStage.SortBy,
				PlanCompletedAt:   time.Unix(int64(val.CurrentStage.PlanCompletedAt), 0).Local().Format("2006-01-02"),
				RealCompletedAt:   "",
				IsRef:             false,
			},
			AnomalyDesc:  []string{},
			AnomalyDesc2: []map[string]string{},
			Marks:        map[string]string{},
		}
		if val.LastStage.RealCompletedAt > 0 {
			tk.LastStage.RealCompletedAt = time.Unix(int64(val.LastStage.RealCompletedAt), 0).Local().Format("2006-01-02")
		}
		if val.CurrentStage.RealCompletedAt > 0 {
			tk.CurrentStage.RealCompletedAt = time.Unix(int64(val.CurrentStage.RealCompletedAt), 0).Local().Format("2006-01-02")
		}
		if val.WarnFlag > 0 {
			tk.WarnFlag = 1
		}

		_, stageList, err := taskStageRepo.Find(map[string]interface{}{
			"taskId": val.TaskId,
		})
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取任务里程碑"+err.Error())
		}
		for _, val2 := range stageList {
			stage := adapter.TaskStage{
				Id:              val2.Id,
				Name:            val2.Name,
				SortBy:          val2.SortBy,
				PlanCompletedAt: time.Unix(int64(val2.PlanCompletedAt), 0).Local().Format("2006-01-02"),
				RealCompletedAt: "",
			}
			if val2.RealCompletedAt > 0 {
				stage.RealCompletedAt = time.Unix(int64(val2.RealCompletedAt), 0).Local().Format("2006-01-02")
			}
			switch val2.SortBy {
			case 1:
				tk.StageA = stage
			case 2:
				tk.StageB = stage
			case 3:
				tk.StageC = stage
			case 4:
				tk.StageD = stage
			case 5:
				tk.StageE = stage
			}
		}
		tk.GenStatusDescript()
		for _, val3 := range taskAnomalyList {
			if tk.Id != val3.TaskId {
				continue
			}
			if len(val3.Marks) == 0 {
				val3.Marks = map[string]string{"a": "去更新", "b": "去反馈", "c": "找上级", "d": "去辅导"}
			}
			noticeWho := []string{}
			for _, val2 := range val3.NoticeWho {
				noticeWho = append(noticeWho, val2["name"])
			}
			switch val3.Category {
			case domain.AnomalyCategoryType1:
				{
					//里程碑异常
					if val3.TaskStageCheck.RealCompletedAt == 0 && val3.TaskStageCheck.Id > 0 {
						//逾期未完成
						planCompletedAt := time.Unix(val3.TaskStageCheck.PlanCompletedAt, 0)
						subDay := xtime.SubDayAbs(val3.CreatedAt, planCompletedAt)
						tk.AnomalyDesc = append(tk.AnomalyDesc, fmt.Sprintf("里程碑%s已逾期%d天", val3.TaskStageCheck.Name, subDay))
						tk.AnomalyDesc2 = append(tk.AnomalyDesc2, map[string]string{
							"types":     "10",
							"stageName": val3.TaskStageCheck.Name,
							"interval":  strconv.Itoa(subDay),
							"noticeWho": strings.Join(noticeWho, ","),
						})
					} else if val3.TaskStageCheck.RealCompletedAt > 0 && val3.TaskStageCheck.Id > 0 {
						//逾期完成
						planCompletedAt := time.Unix(val3.TaskStageCheck.PlanCompletedAt, 0)
						realCompletedAt := time.Unix(val3.TaskStageCheck.RealCompletedAt, 0)
						subDay := xtime.SubDayAbs(realCompletedAt, planCompletedAt)
						tk.AnomalyDesc = append(tk.AnomalyDesc, fmt.Sprintf("里程碑%s逾期%d天完成", val3.TaskStageCheck.Name, subDay))
						tk.AnomalyDesc2 = append(tk.AnomalyDesc2, map[string]string{
							"types":     "11",
							"stageName": val3.TaskStageCheck.Name,
							"interval":  strconv.Itoa(subDay),
							"noticeWho": strings.Join(noticeWho, ","),
						})
					}
				}
			case domain.AnomalyCategoryType2:
				//反馈异常
				{
					recordBegin := time.Unix(val3.RecordBegin, 0)
					subDay := xtime.SubDayAbs(val3.CreatedAt, recordBegin)
					tk.AnomalyDesc = append(tk.AnomalyDesc, fmt.Sprintf(
						"本任务自%s未正常反馈项目进度,已异常%d天",
						recordBegin.Local().Format("2006-01-02"),
						subDay,
					))
					tk.AnomalyDesc2 = append(tk.AnomalyDesc2, map[string]string{
						"types":     "2",
						"dayTime":   recordBegin.Local().Format("2006-01-02"),
						"interval":  strconv.Itoa(subDay),
						"noticeWho": strings.Join(noticeWho, ","),
					})
				}
			case domain.AnomalyCategoryType3:
				//辅导异常
				{
					recordBegin := time.Unix(val3.RecordBegin, 0)
					subDay := xtime.SubDayAbs(val3.CreatedAt, recordBegin)
					tk.AnomalyDesc = append(tk.AnomalyDesc, fmt.Sprintf(
						"本任务计划于%s完成辅导,已逾期%d天",
						recordBegin.Local().Format("2006-01-02"),
						subDay,
					))
					tk.AnomalyDesc2 = append(tk.AnomalyDesc2, map[string]string{
						"types":     "3",
						"dayTime":   recordBegin.Local().Format("2006-01-02"),
						"interval":  strconv.Itoa(subDay),
						"noticeWho": strings.Join(noticeWho, ","),
					})
				}
			}
			//设置操作标识
			userId := strconv.Itoa(param.UserId)
			isChildUser := false
			for _, child := range childUser {
				if child.Level == 1 {
					continue
				}
				cid := strconv.Itoa(child.Id)
				if cid == val.LeaderId {
					isChildUser = true
					break
				}
			}
			switch val3.Category {
			case domain.AnomalyCategoryType1:
				// 里程碑异常
				if userId == val.LeaderId {
					// 去更新
					tk.Marks["a"] = val3.Marks["a"]
					if len(meParent) > 0 {
						// 找上级
						tk.Marks["c"] = val3.Marks["c"]
					}
				} else if isChildUser {
					// 去辅导
					tk.Marks["d"] = val3.Marks["d"]
				}
			case domain.AnomalyCategoryType2:
				if userId == val.LeaderId {
					// 去反馈
					tk.Marks["b"] = val3.Marks["b"]
				} else if isChildUser {
					// 去辅导
					tk.Marks["d"] = val3.Marks["d"]
				}
			case domain.AnomalyCategoryType3:
				if userId == val.LeaderId {
					//空
				} else if isChildUser {
					// 去辅导
					tk.Marks["d"] = val3.Marks["d"]
				}
			}
		}
		taskResult = append(taskResult, &tk)
	}
	result := tool_funs.SimpleWrapGridMap(int64(taskCount), taskResult)
	result["taskStageAnomaly"] = taskStageAnomalyCnt
	result["taskAnomalyCnt"] = taskAnomalyCnt
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	return result, nil
}

// 员工绩效-任务管理-列表 (新)
func (srv TaskService) listTask3ForHrbp(param *command.SearchTaskCommand) (map[string]interface{}, error) {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	// 获取我的上级人员
	userRepo := factory.CreateUserRepository(map[string]interface{}{"transactionContext": transactionContext})
	_, me, err := userRepo.Find(map[string]interface{}{"id": param.UserId})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取用户的信息"+err.Error())
	}
	if len(me) == 0 {
		return nil, nil
	}
	var meParent []*domain.User
	if me[0].ParentId > 0 {
		_, meParent, _ = userRepo.Find(map[string]interface{}{"id": me[0].ParentId})
	}
	var limit = 20
	var offset = 0
	if param.PageSize > 0 {
		limit = param.PageSize
		if param.PageNumber > 0 {
			offset = (param.PageNumber - 1) * param.PageSize
		}
	}
	param.SearchWord = strings.TrimSpace(param.SearchWord)
	if len(param.SearchWord) > 0 {
		param.SearchWord = "%" + param.SearchWord + "%"
	}
	condition := dao.ListTaskCondition{
		Limit:      limit,
		Offset:     offset,
		UserId:     param.UserId,
		CompanyId:  param.CompanyId,
		OnlyMy:     param.OnlyMy,
		SearchWord: param.SearchWord,
		LevelName:  param.LevelName,
	}

	taskDao := dao.NewTaskDao(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	//任务列表数据
	taskListData, err := taskDao.ListTaskByHrbpV2(condition)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取任务列表"+err.Error())
	}
	//查到的任务数据总数
	taskCount, err := taskDao.CountTaskByHrbp(condition)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "统计任务总数"+err.Error())
	}
	userDao := dao.NewUserDao(map[string]interface{}{"transactionContext": transactionContext})
	// 获取员工全部子集
	childUser, err := userDao.AllChildUser(param.UserId)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取下级员工"+err.Error())
	}
	//里程碑异常
	taskStageAnomalyCnt, err := taskDao.CountTaskStageAnomalyByHrbp(condition)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "统计异常的任务里程碑总数"+err.Error())
	}
	//反馈异常数
	taskAnomalyCnt, err := taskDao.CountTaskAnomalyByHrbp(condition)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "统计任务反馈异常总数"+err.Error())
	}
	var taskAnomalyList []*domain.TaskAnomaly
	//获取异常的任务反馈记录
	taskAnomalyRepo := factory.CreateTaskAnomalyRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	for _, val := range taskListData {
		_, listData, err := taskAnomalyRepo.Find(map[string]interface{}{
			"taskId": val.TaskId,
			"isLast": 1,
		})
		if err == nil {
			taskAnomalyList = append(taskAnomalyList, listData...)
		}
	}
	taskResult := []*adapter.TaskItem{}
	taskStageRepo := factory.CreateTaskStageRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	for _, val := range taskListData {
		tk := adapter.TaskItem{
			Id:        val.TaskId,
			Name:      "",
			Alias:     val.Alias,
			Leader:    val.LeaderName,
			Status:    val.Status,
			SortBy:    val.SortBy,
			LevelName: val.LevelName,
			UpdatedAt: val.UpdatedAt.Local().Format("2006-01-02 15:04:05"),
			Anomaly:   val.Anomaly,
			WarnFlag:  val.WarnFlag,
			LastStage: adapter.TaskStage{
				Id:                val.LastStage.Id,
				Name:              val.LastStage.Name,
				StatusDescription: val.LastStage.StatusDescription(),
				SortBy:            val.LastStage.SortBy,
				PlanCompletedAt:   time.Unix(int64(val.LastStage.PlanCompletedAt), 0).Local().Format("2006-01-02"),
				RealCompletedAt:   "",
			},
			CurrentStage: adapter.TaskStage{
				Id:                val.CurrentStage.Id,
				Name:              val.CurrentStage.Name,
				StatusDescription: val.CurrentStage.StatusDescription(),
				SortBy:            val.CurrentStage.SortBy,
				PlanCompletedAt:   time.Unix(int64(val.CurrentStage.PlanCompletedAt), 0).Local().Format("2006-01-02"),
				RealCompletedAt:   "",
			},
			Marks: map[string]string{},
		}
		if val.LastStage.RealCompletedAt > 0 {
			tk.LastStage.RealCompletedAt = time.Unix(int64(val.LastStage.RealCompletedAt), 0).Local().Format("2006-01-02")
		}
		if val.CurrentStage.RealCompletedAt > 0 {
			tk.CurrentStage.RealCompletedAt = time.Unix(int64(val.CurrentStage.RealCompletedAt), 0).Local().Format("2006-01-02")
		}
		if tk.WarnFlag > 0 {
			tk.WarnFlag = 1
		}
		_, stageList, err := taskStageRepo.Find(map[string]interface{}{
			"taskId": val.TaskId,
		})
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取任务里程碑"+err.Error())
		}

		for _, val2 := range stageList {
			stage := adapter.TaskStage{
				Id:              val2.Id,
				Name:            val2.Name,
				SortBy:          val2.SortBy,
				PlanCompletedAt: time.Unix(int64(val2.PlanCompletedAt), 0).Local().Format("2006-01-02"),
				RealCompletedAt: "",
			}
			if val2.RealCompletedAt > 0 {
				stage.RealCompletedAt = time.Unix(int64(val2.RealCompletedAt), 0).Local().Format("2006-01-02")
			}
			switch val2.SortBy {
			case 1:
				tk.StageA = stage
			case 2:
				tk.StageB = stage
			case 3:
				tk.StageC = stage
			case 4:
				tk.StageD = stage
			case 5:
				tk.StageE = stage
			}
		}
		tk.GenStatusDescript()
		for _, val3 := range taskAnomalyList {
			if tk.Id != val3.TaskId {
				continue
			}
			if val3.Marks == nil {
				val3.Marks = map[string]string{}
			}
			noticeWho := []string{}
			for _, val2 := range val3.NoticeWho {
				noticeWho = append(noticeWho, val2["name"])
			}
			switch val3.Category {
			case domain.AnomalyCategoryType1:
				{
					//里程碑异常
					if val3.TaskStageCheck.RealCompletedAt == 0 && val3.TaskStageCheck.Id > 0 {
						//逾期未完成
						planCompletedAt := time.Unix(val3.TaskStageCheck.PlanCompletedAt, 0)
						subDay := xtime.SubDayAbs(val3.CreatedAt, planCompletedAt)
						tk.AnomalyDesc = append(tk.AnomalyDesc, fmt.Sprintf("里程碑%s已逾期%d天", val3.TaskStageCheck.Name, subDay))
						tk.AnomalyDesc2 = append(tk.AnomalyDesc2, map[string]string{
							"types":     "10",
							"stageName": val3.TaskStageCheck.Name,
							"interval":  strconv.Itoa(subDay),
							"noticeWho": strings.Join(noticeWho, ","),
						})
					} else if val3.TaskStageCheck.RealCompletedAt > 0 && val3.TaskStageCheck.Id > 0 {
						//逾期完成
						planCompletedAt := time.Unix(val3.TaskStageCheck.PlanCompletedAt, 0)
						realCompletedAt := time.Unix(val3.TaskStageCheck.RealCompletedAt, 0)
						subDay := xtime.SubDayAbs(realCompletedAt, planCompletedAt)
						tk.AnomalyDesc = append(tk.AnomalyDesc, fmt.Sprintf("里程碑%s逾期%d天完成", val3.TaskStageCheck.Name, subDay))
						tk.AnomalyDesc2 = append(tk.AnomalyDesc2, map[string]string{
							"types":     "11",
							"stageName": val3.TaskStageCheck.Name,
							"interval":  strconv.Itoa(subDay),
							"noticeWho": strings.Join(noticeWho, ","),
						})
					}
				}
			case domain.AnomalyCategoryType2:
				//反馈异常
				{
					recordBegin := time.Unix(val3.RecordBegin, 0)
					subDay := xtime.SubDayAbs(val3.CreatedAt, recordBegin)
					tk.AnomalyDesc = append(tk.AnomalyDesc, fmt.Sprintf(
						"本任务自%s未正常反馈项目进度,已异常%d天",
						recordBegin.Local().Format("2006-01-02"),
						subDay,
					))
					tk.AnomalyDesc2 = append(tk.AnomalyDesc2, map[string]string{
						"types":     "2",
						"dayTime":   recordBegin.Local().Format("2006-01-02"),
						"interval":  strconv.Itoa(subDay),
						"noticeWho": strings.Join(noticeWho, ","),
					})
				}
			case domain.AnomalyCategoryType3:
				//辅导异常
				{
					recordBegin := time.Unix(val3.RecordBegin, 0)
					subDay := xtime.SubDayAbs(val3.CreatedAt, recordBegin)
					tk.AnomalyDesc = append(tk.AnomalyDesc, fmt.Sprintf(
						"本任务计划于%s完成辅导,已逾期%d天",
						recordBegin.Local().Format("2006-01-02"),
						subDay,
					))
					tk.AnomalyDesc2 = append(tk.AnomalyDesc2, map[string]string{
						"types":     "3",
						"dayTime":   recordBegin.Local().Format("2006-01-02"),
						"interval":  strconv.Itoa(subDay),
						"noticeWho": strings.Join(noticeWho, ","),
					})
				}
			}
			if len(val3.Marks) == 0 {
				val3.Marks = map[string]string{"a": "去更新", "b": "去反馈", "c": "找上级", "d": "去辅导"}
			}
			userId := strconv.Itoa(param.UserId)
			isChildUser := false
			for _, child := range childUser {
				cid := strconv.Itoa(child.Id)
				if cid == val.LeaderId {
					isChildUser = true
					break
				}
			}
			switch val3.Category {
			case domain.AnomalyCategoryType1:
				// 里程碑异常
				if userId == val.LeaderId {
					// 去更新
					tk.Marks["a"] = val3.Marks["a"]
					if len(meParent) > 0 {
						// 找上级
						tk.Marks["c"] = val3.Marks["c"]
					}
				} else if isChildUser {
					// 去辅导
					tk.Marks["d"] = val3.Marks["d"]
				}
			case domain.AnomalyCategoryType2:
				if userId == val.LeaderId {
					// 去反馈
					tk.Marks["b"] = val3.Marks["b"]
				} else if isChildUser {
					// 去辅导
					tk.Marks["d"] = val3.Marks["d"]
				}
			case domain.AnomalyCategoryType3:
				if userId == val.LeaderId {
					//空
				} else if isChildUser {
					// 去辅导
					tk.Marks["d"] = val3.Marks["d"]
				}
			}
		}
		taskResult = append(taskResult, &tk)
	}
	result := tool_funs.SimpleWrapGridMap(int64(taskCount), taskResult)
	result["taskStageAnomaly"] = taskStageAnomalyCnt
	result["taskAnomalyCnt"] = taskAnomalyCnt
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	return result, nil
}

func (srv TaskService) ListTaskLevel(companyId int) (map[string]interface{}, error) {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	taskLevelRepo := factory.CreateTaskLevelRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	_, taskLevelList, err := taskLevelRepo.Find(map[string]interface{}{
		"companyId": companyId,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "检查任务优先级失败:"+err.Error())
	}

	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	taskLevelAll := []*domain.TaskLevel{}
	taskLevelAll = append(taskLevelAll, domain.DefaultTaskLevel()...)
	taskLevelAll = append(taskLevelAll, taskLevelList...)
	result := map[string]interface{}{
		"list": taskLevelAll,
	}
	return result, nil
}

// 取消关注的任务列表
func (srv *TaskService) ListTaskIgnore(param *command.SearchTaskCommand) (result map[string]interface{}, err error) {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	var limit = 20
	var offset = 0
	if param.PageSize > 0 {
		limit = param.PageSize
		if param.PageNumber > 0 {
			offset = (param.PageNumber - 1) * param.PageSize
		}
	}
	param.SearchWord = strings.TrimSpace(param.SearchWord)
	if len(param.SearchWord) > 0 {
		param.SearchWord = "%" + param.SearchWord + "%"
	}
	condition := dao.ListTaskCondition{
		Limit:      limit,
		Offset:     offset,
		UserId:     param.UserId,
		CompanyId:  param.CompanyId,
		OnlyMy:     param.OnlyMy,
		SearchWord: param.SearchWord,
		LevelName:  param.LevelName,
	}

	taskDao := dao.NewTaskDao(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	//任务列表数据
	taskListData, err := taskDao.ListTaskIgnore(condition)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取任务列表"+err.Error())
	}
	//查到的任务数据总数
	taskCount, err := taskDao.CountTaskIgnore(condition)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "统计任务总数"+err.Error())
	}

	taskResult := []*adapter.TaskItem{}
	taskStageRepo := factory.CreateTaskStageRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	// nowDay := xtime.DayEndTime(time.Now()).Unix()
	for _, val := range taskListData {
		tk := adapter.TaskItem{
			Id:        val.TaskId,
			Name:      "",
			Alias:     val.Alias,
			Leader:    val.LeaderName,
			Status:    val.Status,
			SortBy:    val.SortBy,
			LevelName: val.LevelName,
			UpdatedAt: val.UpdatedAt.Local().Format("2006-01-02 15:04:05"),
			Anomaly:   val.Anomaly,
			WarnFlag:  val.WarnFlag,
			LastStage: adapter.TaskStage{
				Id:                val.LastStage.Id,
				Name:              val.LastStage.Name,
				StatusDescription: val.LastStage.StatusDescription(),
				SortBy:            val.LastStage.SortBy,
				PlanCompletedAt:   time.Unix(int64(val.LastStage.PlanCompletedAt), 0).Local().Format("2006-01-02"),
				RealCompletedAt:   "",
			},
			CurrentStage: adapter.TaskStage{
				Id:                val.CurrentStage.Id,
				Name:              val.CurrentStage.Name,
				StatusDescription: val.CurrentStage.StatusDescription(),
				SortBy:            val.CurrentStage.SortBy,
				PlanCompletedAt:   time.Unix(int64(val.CurrentStage.PlanCompletedAt), 0).Local().Format("2006-01-02"),
				RealCompletedAt:   "",
			},
		}
		if val.LastStage.RealCompletedAt > 0 {
			tk.LastStage.RealCompletedAt = time.Unix(int64(val.LastStage.RealCompletedAt), 0).Local().Format("2006-01-02")
		}
		if val.CurrentStage.RealCompletedAt > 0 {
			tk.CurrentStage.RealCompletedAt = time.Unix(int64(val.CurrentStage.RealCompletedAt), 0).Local().Format("2006-01-02")
		}

		if tk.WarnFlag > 0 {
			tk.WarnFlag = 1
		}

		_, stageList, err := taskStageRepo.Find(map[string]interface{}{
			"taskId": val.TaskId,
		})
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取任务里程碑"+err.Error())
		}

		for _, val2 := range stageList {
			stage := adapter.TaskStage{
				Id:              val2.Id,
				Name:            val2.Name,
				SortBy:          val2.SortBy,
				PlanCompletedAt: time.Unix(int64(val2.PlanCompletedAt), 0).Local().Format("2006-01-02"),
				RealCompletedAt: "",
			}
			if val2.RealCompletedAt > 0 {
				stage.RealCompletedAt = time.Unix(int64(val2.RealCompletedAt), 0).Local().Format("2006-01-02")
			}
			switch val2.SortBy {
			case 1:
				tk.StageA = stage
			case 2:
				tk.StageB = stage
			case 3:
				tk.StageC = stage
			case 4:
				tk.StageD = stage
			case 5:
				tk.StageE = stage
			}
		}
		tk.GenStatusDescript()
		taskResult = append(taskResult, &tk)
	}

	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	result = tool_funs.SimpleWrapGridMap(int64(taskCount), taskResult)
	return
}

// 从取消关注的列表中移除数据
func (srv *TaskService) CancleTaskIgnore(param *command.CancelIgnoreCommand) (result map[string]interface{}, err error) {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()

	taskIgnoreRepo := factory.CreateTaskIgnoreRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	_, taskIgnoreList, err := taskIgnoreRepo.Find(map[string]interface{}{
		"userId": param.UserId,
		"taskId": param.TaskId,
	})
	if len(taskIgnoreList) == 0 {
		return
	}

	err = taskIgnoreRepo.Remove(taskIgnoreList[0].Id)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	return nil, nil
}