暂存

@@ -216,3 +216,18 @@ func CreateMessagePersonalRepository(options map[string]interface{}) domain.Mess
 	}
 	return repository.NewMessagePersonalRepository(transactionContext)
 }
+func CreateTaskRepository(options map[string]interface{}) domain.TaskRepository {
+	var transactionContext *pg.TransactionContext
+	if value, ok := options["transactionContext"]; ok {
+		transactionContext = value.(*pg.TransactionContext)
+	}
+	return repository.NewTaskRepository(transactionContext)
+}
+
+func CreateTaskStageRepository(options map[string]interface{}) domain.TaskStageRepository {
+	var transactionContext *pg.TransactionContext
+	if value, ok := options["transactionContext"]; ok {
+		transactionContext = value.(*pg.TransactionContext)
+	}
+	return repository.NewTaskStageRepository(transactionContext)
+}

+package command
+
+type CreateTaskCommand struct {
+	Name     string `json:"name"`     //任务名称
+	LeaderId int    `json:"leaderId"` //赋值人id
+}

+package command
+
+type RunTaskCommand struct{}

+package command
+
+type StopTaskCommand struct{}

+package command
+
+type UpdateTaskCommand struct {
+	Id        int    `json:"id"`
+	Name      string `json:"name"`      //任务名称
+	LeaderId  int    `json:"leaderId"`  //赋值人id
+	LevelName string `json:"levelName"` //优先级
+	StageList []struct {
+		Id              int    `json:"id"`
+		Name            string `json:"name"`            //里程碑名称
+		PlanCompletedAt string `json:"planCompletedAt"` //计划完成时间, 例:2006-01-02
+	} `json:"stageList"`
+}

+package service
+
+import (
+	"time"
+
+	"github.com/linmadan/egglib-go/core/application"
+	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/factory"
+	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/task/command"
+	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/domain"
+)
+
+type TaskService struct{}
+
+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 (srv TaskService) CreateTask(transactionContext application.TransactionContext, param *command.CreateTaskCommand) error {
+	taskRepo := factory.CreateTaskRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	})
+	taskStageRepo := factory.CreateTaskStageRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	})
+	cnt, _, err := taskRepo.Find(map[string]interface{}{
+		"name":     param.Name,
+		"leaderId": param.LeaderId,
+	})
+	if err != nil {
+		return application.ThrowError(application.INTERNAL_SERVER_ERROR, "查询任务失败:"+err.Error())
+	}
+	if cnt > 0 {
+		//任务已存在
+		return nil
+	}
+	nowTime := time.Now()
+	newTask := domain.Task{
+		Id:          0,
+		Name:        param.Name,
+		Alias:       param.Name,
+		Status:      domain.TaskRunning,
+		Level:       0,
+		LevalName:   "",
+		RelatedUser: []int{},
+		RunAt:       nowTime.Unix(),
+	}
+	newTask.ApplyLevelName("")
+	err = taskRepo.Save(&newTask)
+	if err != nil {
+		return application.ThrowError(application.INTERNAL_SERVER_ERROR, "创建任务失败:"+err.Error())
+	}
+
+	nowEndTime := dayEndTime(nowTime)
+
+	newTaskStage := []*domain.TaskStage{
+		{
+			Id:              0,
+			TaskId:          newTask.Id,
+			Name:            "里程碑1",
+			SortBy:          1,
+			Status:          domain.TaskStageUncompleted,
+			PlanCompletedAt: nowEndTime.Add(30 * 24 * time.Hour).Unix(),
+			RealCompletedAt: 0,
+		},
+		{
+			Id:              0,
+			TaskId:          newTask.Id,
+			Name:            "里程碑2",
+			SortBy:          2,
+			Status:          domain.TaskStageUncompleted,
+			PlanCompletedAt: nowEndTime.Add(60 * 24 * time.Hour).Unix(),
+			RealCompletedAt: 0,
+		},
+		{
+			Id:              0,
+			TaskId:          newTask.Id,
+			Name:            "里程碑3",
+			SortBy:          3,
+			Status:          domain.TaskStageUncompleted,
+			PlanCompletedAt: nowEndTime.Add(90 * 24 * time.Hour).Unix(),
+			RealCompletedAt: 0,
+		},
+	}
+	err = taskStageRepo.Save(newTaskStage)
+	if err != nil {
+		return application.ThrowError(application.INTERNAL_SERVER_ERROR, "创建任务失败:"+err.Error())
+	}
+	return nil
+}
+
+func (srv TaskService) UpdateTask(param *command.UpdateTaskCommand) (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,
+	})
+	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,
+	})
+	_ = taskData
+	_ = stageList
+
+	if err := transactionContext.CommitTransaction(); err != nil {
+		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	return nil, nil
+}
+
+func (srv TaskService) RunTask() error {
+	return nil
+}
+
+func (srv TaskService) StopTask() error {
+	return nil
+}

@@ -14,12 +14,16 @@ type Task struct {
 	Id          int        `json:"id"`
 	CreatedAt   time.Time  `json:"createdAt"`
 	UpdatedAt   time.Time  `json:"updatedAt"`
-	DeletedAt time.Time  `json:"deletedAt"`
+	DeletedAt   *time.Time `json:"deletedAt"`
 	Name        string     `json:"name"`        // 任务名称
+	Alias       string     `json:"alias"`       // 任务别名
 	Leader      TaskLeader `json:"leader"`      // 任务负责人
 	Status      TaskState  `json:"status"`      // 任务的状态
 	Level       int        `json:"level"`       // 优先级,值越小优先级越高
 	LevalName   string     `json:"levalName"`   // 优先级名称
+	RelatedUser []int      `json:"relatedUser"` // 相关的员工id
+	RunAt       int64      `json:"runAt"`       // 启动的时间戳,秒
+	StopAt      int64      `json:"stopAt"`      // 停止的时间戳,秒
 }
 
 type TaskLeader struct {

@@ -15,12 +15,12 @@ type TaskStage struct {
 	TaskId          int            `json:"taskId"`
 	CreatedAt       time.Time      `json:"createdAt"`
 	UpdatedAt       time.Time      `json:"updatedAt"`
-	DeletedAt       time.Time      `json:"deletedAt"`
+	DeletedAt       *time.Time     `json:"deletedAt"`
 	Name            string         `json:"name"`            //里程碑名称
 	SortBy          int            `json:"sortBy"`          //排序
 	Status          TaskStageState `json:"status"`          //里程碑完成情况
-	PlanCompletedAt int            `json:"planCompletedAt"` //计划完成时间
-	RealCompletedAt int            `json:"realCompletedAt"` //时间完成时间
+	PlanCompletedAt int64          `json:"planCompletedAt"` //计划完成时间戳,秒
+	RealCompletedAt int64          `json:"realCompletedAt"` //时间完成时间戳,秒
 }
 type TaskStageRepository interface {
 	Save(param []*TaskStage) error

@@ -12,11 +12,14 @@ type Task struct {
 	Id          int               `pg:"id,pk"`
 	CreatedAt   time.Time         `pg:"created_at"`
 	UpdatedAt   time.Time         `pg:"updated_at"`
-	DeletedAt time.Time          `pg:"deleted_at"`
+	DeletedAt   *time.Time        `pg:"deleted_at"`
 	Name        string            `pg:"name"` // 任务名称
+	Alias       string            `pg:"alias"`
 	Leader      domain.TaskLeader `pg:"leader"`       // 任务负责人
 	Status      int               `pg:"status"`       // 任务的状态
-	StageList []domain.TaskStage `pg:"stage_list"` // 里程碑
 	Level       int               `pg:"level"`        // 优先级,值越小优先级越高
 	LevalName   string            `pg:"leval_name"`   // 优先级名称
+	RelatedUser []int             `pg:"related_user"` //
+	RunAt       int64             `pg:"run_at"`       // 启动的时间
+	StopAt      int64             `pg:"stop_at"`      // 停止的时间
 }

@@ -9,10 +9,10 @@ type TaskStage struct {
 	TaskId          int        `pg:"task_id"`
 	CreatedAt       time.Time  `pg:"created_at"`
 	UpdatedAt       time.Time  `pg:"updated_at"`
-	DeletedAt       time.Time `pg:"deleted_at"`
+	DeletedAt       *time.Time `pg:"deleted_at"`
 	Name            string     `pg:"name"`              //里程碑名称
 	SortBy          int        `pg:"sort_by"`           //排序
 	Status          int        `pg:"status"`            //里程碑完成情况
-	PlanCompletedAt int       `pg:"plan_completed_at"` //计划完成时间
-	RealCompletedAt int       `pg:"real_completed_at"` //时间完成时间
+	PlanCompletedAt int64      `pg:"plan_completed_at"` //计划完成时间
+	RealCompletedAt int64      `pg:"real_completed_at"` //时间完成时间
 }

@@ -19,6 +19,10 @@ type TaskRepository struct {
 
 var _ domain.TaskRepository = (*TaskRepository)(nil)
 
+func NewTaskRepository(transactionContext *pgTransaction.TransactionContext) *TaskRepository {
+	return &TaskRepository{transactionContext: transactionContext}
+}
+
 func (repo *TaskRepository) TransformToDomain(d *models.Task) *domain.Task {
 	return &domain.Task{
 		Id:          d.Id,
@@ -26,10 +30,14 @@ func (repo *TaskRepository) TransformToDomain(d *models.Task) *domain.Task {
 		UpdatedAt:   d.UpdatedAt,
 		DeletedAt:   d.DeletedAt,
 		Name:        d.Name,
+		Alias:       d.Alias,
 		Leader:      d.Leader,
 		Status:      domain.TaskState(d.Status),
 		Level:       d.Level,
 		LevalName:   d.LevalName,
+		RelatedUser: d.RelatedUser,
+		RunAt:       d.RunAt,
+		StopAt:      d.StopAt,
 	}
 }
 
@@ -45,10 +53,14 @@ func (repo *TaskRepository) Save(param *domain.Task) error {
 		UpdatedAt:   param.UpdatedAt,
 		DeletedAt:   param.DeletedAt,
 		Name:        param.Name,
+		Alias:       param.Alias,
 		Leader:      param.Leader,
 		Status:      int(param.Status),
 		Level:       param.Level,
 		LevalName:   param.LevalName,
+		RelatedUser: param.RelatedUser,
+		RunAt:       param.RunAt,
+		StopAt:      param.StopAt,
 	}
 	db := repo.transactionContext.PgTx
 	if m.Id == 0 {
@@ -102,7 +114,12 @@ func (repo *TaskRepository) Find(queryOptions map[string]interface{}) (int, []*d
 	query := tx.Model(&m).
 		Where("deleted_at isnull").
 		Limit(20)
-
+	if val, ok := queryOptions["name"]; ok {
+		query.Where("task.name like ?", val)
+	}
+	if val, ok := queryOptions["leaderId"]; ok {
+		query.Where("task.leader->>'userId'='?'", val)
+	}
 	query.Order("id desc")
 	count, err := query.SelectAndCount()
 	if err != nil {

@@ -19,6 +19,10 @@ type TaskStageRepository struct {
 
 var _ domain.TaskStageRepository = (*TaskStageRepository)(nil)
 
+func NewTaskStageRepository(transactionContext *pgTransaction.TransactionContext) *TaskStageRepository {
+	return &TaskStageRepository{transactionContext: transactionContext}
+}
+
 func (repo *TaskStageRepository) TransformToDomain(d *models.TaskStage) *domain.TaskStage {
 	return &domain.TaskStage{
 		Id:              d.Id,
@@ -102,8 +106,10 @@ func (repo *TaskStageRepository) Find(queryOptions map[string]interface{}) (int,
 	query := tx.Model(&m).
 		Where("deleted_at isnull").
 		Limit(20)
-
-	query.Order("id desc")
+	if val, ok := queryOptions["taskId"]; ok {
+		query.Where("task_stage.task_id = ?", val)
+	}
+	query.Order("sort_by")
 	count, err := query.SelectAndCount()
 	if err != nil {
 		return 0, nil, err