zmkgC/test/schdule_test.go

package test

import (
	"context"
	"encoding/json"
	"fmt"
	"strconv"
	"testing"
	"time"
	"unsafe"

	"github.com/gogf/gf/v2/frame/g"
	"github.com/samber/lo"
	"github.com/tiger1103/gfast/v3/api/v1/system"
	"github.com/tiger1103/gfast/v3/internal/app/system/dao"
	"github.com/tiger1103/gfast/v3/internal/app/system/model"
	"github.com/tiger1103/gfast/v3/internal/app/system/model/entity"
	"github.com/tiger1103/gfast/v3/internal/app/system/service"

	lop "github.com/samber/lo/parallel"
)

func Test_A(t *testing.T) {
	service.WorkSchedule().List(context.Background(), &system.WorkScheduleSearchReq{
		WorkId: "505482040829870446",
	})
}

// 测试计划表进度
func Test_Progress(t *testing.T) {
	// resp, err := service.WorkStatus().Progress(context.Background(), &system.WorkStatusGetProgressReq{
	// 	FangzhenId: "2",
	// })
	// if err != nil {
	// 	t.Fatal(err)
	// }

	// body, _ := json.Marshal(resp)
	// t.Log(string(body))
}

// 获取指定方针下所有的数据，拼接父级和子集
func Test_GetAll(t *testing.T) {
	fangzhenID := 2
	parentID := 78

	detailData := []entity.WorkStatus{}
	// 查询父级下的所有子集的排期
	err := dao.WorkStatus.Ctx(context.Background()).
		Where(dao.WorkStatus.Columns().FangzhenId, fangzhenID).
		Where(dao.WorkStatus.Columns().Parent, parentID).Scan(&detailData)
	if err != nil {
		t.Fatal(err)
	}

	fmt.Println(detailData)
}

// 获取所有数据
func Test_GetAllData(t *testing.T) {
	fangzhenID := 2

	workStatusList := []entity.WorkStatus{}
	// 查询父级下的所有子集的排期
	if err := dao.WorkStatus.Ctx(context.Background()).Where(dao.WorkStatus.Columns().FangzhenId, fangzhenID).Scan(&workStatusList); err != nil {
		t.Fatal(err)
	}

	// 父列表
	parentList := []entity.WorkStatus{}
	// 子列表，使用 map 存储，键为父元素的 ID
	childrenMap := make(map[int][]entity.WorkStatus)

	// 遍历所有数据，将父级和子集分开
	for _, item := range workStatusList {
		if item.Parent == 0 {
			parentList = append(parentList, item)
		} else {
			childrenMap[item.Parent] = append(childrenMap[item.Parent], item)
		}
	}

	projectList := []*model.WorkStatusProgressRes{}

	index := 1
	// 遍历父级，将子集添加到父级的字段中
	for _, parent := range parentList {
		projectItem := model.WorkStatusProgressRes{
			ID:       index,
			WorkID:   parent.WorkId,
			Startat:  parent.StartAt.String(),
			Endat:    parent.EndAt.String(),
			Name:     parent.WorkName,
			Total:    parent.Total,
			Finished: parent.Finished,
			Status:   parent.Status,
			Children: make([]model.WorkStatusProgressRes, 0, len(workStatusList)),
		}
		index++

		// 从 map 中获取子元素，将子元素添加到父元素的字段中
		for _, child := range childrenMap[int(parent.Id)] {
			projectItem.Children = append(projectItem.Children, model.WorkStatusProgressRes{
				ID:       index,
				WorkID:   child.WorkId,
				Startat:  child.StartAt.String(),
				Endat:    child.EndAt.String(),
				Name:     child.WorkName,
				Total:    child.Total,
				Finished: child.Finished,
				Status:   child.Status,
			})
			index++
		}
		projectList = append(projectList, &projectItem)
	}
}

type Scheduler struct {
	// 总进度
	FinishedPtr int
	// 总量
	Total int
	// 实体
	WorkStatus *entity.WorkSchedule
}

type Schdule map[string]Scheduler

// 获取指定 WorkID 的计划和总量
func (s Schdule) Get(workID string) (int, int) {
	if scheduler, ok := s[workID]; ok {
		return scheduler.FinishedPtr, scheduler.Total
	}
	return 0, 0
}

// 测试构建计划数据
func Test_Schduler(t *testing.T) {
	ScheduleData := []entity.WorkSchedule{}
	if err := dao.WorkSchedule.Ctx(context.Background()).Scan(&ScheduleData); err != nil {
		t.Fatal(err)
	}

	// 遍历 ScheduleData，将数据按照 WorkID 分组
	scheduleMap := make(Schdule)
	for _, item := range ScheduleData {
		// 预计进度
		planNum := item.PlanNum
		// 实际进度
		// finishedNum := item.FinishedNum

		// 如果不存在的话，创建一个新的 Scheduler
		if _, ok := scheduleMap[item.WorkId]; !ok {
			scheduleMap[item.WorkId] = Scheduler{
				WorkStatus: &item,
				Total:      planNum,
				// FinishedPtr: finishedNum,
			}
			continue
		}

		// 如果存在的话，将计划进度和实际进度相加
		scheduler := scheduleMap[item.WorkId]
		scheduler.Total += planNum
		// scheduler.FinishedPtr += finishedNum
	}
}

// 指针情况下忽略进度字段
func Test_ProgressJson(t *testing.T) {
	fangzhenID := 2

	ScheduleData := []entity.WorkSchedule{}
	if err := dao.WorkSchedule.Ctx(context.Background()).Scan(&ScheduleData); err != nil {
		return
	}

	// 遍历 ScheduleData，将数据按照 WorkID 分组
	scheduleMap := make(Schdule)
	for _, item := range ScheduleData {
		// 预计进度
		planNum := item.PlanNum
		// 实际进度
		// finishedNum := item.FinishedNum

		// 如果不存在的话，创建一个新的 Scheduler
		if _, ok := scheduleMap[item.WorkId]; !ok {
			scheduleMap[item.WorkId] = Scheduler{
				WorkStatus: &item,
				Total:      planNum,
				// FinishedPtr: finishedNum,
			}
			continue
		}

		// 如果存在的话，将计划进度和实际进度相加
		scheduler := scheduleMap[item.WorkId]
		scheduler.Total += planNum
		// scheduler.FinishedPtr += finishedNum
		scheduleMap[item.WorkId] = scheduler
	}

	workStatusList := []entity.WorkStatus{}
	// 查询父级下的所有子集的排期
	if err := dao.WorkStatus.Ctx(context.Background()).Where(dao.WorkStatus.Columns().FangzhenId, fangzhenID).Scan(&workStatusList); err != nil {
		return
	}

	// 父列表
	parentList := []entity.WorkStatus{}
	// 子列表，使用 map 存储，键为父元素的 ID
	childrenMap := make(map[int][]entity.WorkStatus)

	// 遍历所有数据，将父级和子集分开
	for _, item := range workStatusList {
		if item.Parent == 0 {
			parentList = append(parentList, item)
		} else {
			childrenMap[item.Parent] = append(childrenMap[item.Parent], item)
		}
	}

	projectList := []*model.WorkStatusProgressRes{}

	index := 1
	// 遍历父级，将子集添加到父级的字段中
	for _, parent := range parentList {
		projectItem := model.WorkStatusProgressRes{
			ID:       index,
			WorkID:   parent.WorkId,
			Startat:  parent.StartAt.String(),
			Endat:    parent.EndAt.String(),
			Name:     parent.WorkName,
			Total:    parent.Total,
			Finished: parent.Finished,
			Status:   parent.Status,
			Children: make([]model.WorkStatusProgressRes, 0, len(workStatusList)),
		}
		index++

		// 从 map 中获取子元素，将子元素添加到父元素的字段中
		for _, child := range childrenMap[int(parent.Id)] {
			// 根据 WorkID 获取计划和总量
			finishedPtr, total := scheduleMap.Get(child.WorkId)

			// 创建计划进度对象
			var planProgress *model.PlanProgress
			// 如果 finishedPtr 和 total 不为 0 ，那么创建计划进度对象
			if finishedPtr != 0 || total != 0 {
				planProgress = &model.PlanProgress{
					Finished: &finishedPtr,
					Total:    &total,
				}
			}

			projectItem.Children = append(projectItem.Children, model.WorkStatusProgressRes{
				ID:           index,
				WorkID:       child.WorkId,
				Startat:      child.StartAt.String(),
				Endat:        child.EndAt.String(),
				Name:         child.WorkName,
				Total:        child.Total,
				Finished:     child.Finished,
				Status:       child.Status,
				PlanProgress: planProgress,
			})
			index++
		}
		projectList = append(projectList, &projectItem)
	}

	body, _ := json.Marshal(projectList)
	println(string(body))
}

// 新增
func Test_Add(t *testing.T) {
	workID := "505482040829935982"
	ID := 14
	SubmitTime := "2024-03-22"
	FinishedNum := 2

	ctx := context.Background()

	// 获取指定 WorkID 的计划和总量
	workSchedule := entity.WorkSchedule{}
	if err := dao.WorkSchedule.Ctx(ctx).Where(dao.WorkSchedule.Columns().WorkId, workID).
		Where(dao.WorkSchedule.Columns().Id, ID).Scan(&workSchedule); err != nil {
		return
	}

	// 反序列化 workSchedule.Detail
	var scheduleDetails []model.WorkScheduleDetail
	if err := json.Unmarshal([]byte(workSchedule.Detail), &scheduleDetails); err != nil {
		return
	}

	// 遍历 scheduleDetails 匹配 req.submitDate 的时间
	totalFinishedNum := 0
	for i, scheduleDetail := range scheduleDetails {
		if scheduleDetail.Date == SubmitTime {
			// 修改其 FinishedNum
			scheduleDetails[i].FinishedNum = FinishedNum
		}
		totalFinishedNum += scheduleDetails[i].FinishedNum
	}

	// 序列化 scheduleDetails
	schedulesJSON, _ := json.Marshal(scheduleDetails)
	schedulesJSONStr := *(*string)(unsafe.Pointer(&schedulesJSON))

	// 修改计划表中的数据
	_, err := dao.WorkSchedule.Ctx(ctx).Where(dao.WorkSchedule.Columns().WorkId, workID).
		Where(dao.WorkSchedule.Columns().Id, ID).
		Data(g.Map{
			dao.WorkSchedule.Columns().FinishedNum: totalFinishedNum,
			dao.WorkSchedule.Columns().Detail:      schedulesJSONStr,
		}).
		Update()
	if err != nil {
		return
	}

	// 重新统计 work_schduler 的状态后更新 work_status 表
	// 获取指定 WorkID 的计划和总量
	finishedNum, err := dao.WorkSchedule.Ctx(ctx).Where(dao.WorkSchedule.Columns().WorkId, workID).
		Sum(dao.WorkSchedule.Columns().FinishedNum)
	if err != nil {
		return
	}

	// 更新 work_status 表
	_, err = dao.WorkStatus.Ctx(ctx).Where(dao.WorkStatus.Columns().WorkId, workID).
		Data(g.Map{
			dao.WorkStatus.Columns().Finished: int(finishedNum),
		}).Update()
	if err != nil {
		return
	}
}

// 测试更新 workschedule 表
func Test_Update(t *testing.T) {
	ctx := context.Background()
	workID := "505482040830329198"

	var finishedNum float64 = 0

	if _, err := dao.WorkStatus.Ctx(ctx).Where(dao.WorkStatus.Columns().WorkId, workID).
		Data(dao.WorkStatus.Columns().Finished, finishedNum).Update(); err != nil {
		println(err)
	}
}

type scheduler struct {
	// 总进度
	FinishedPtr int
	// 总量
	Total int
	// 实体
	WorkStatus *entity.WorkSchedule
}

// 传入 WorkID 获取计划状态
func (s Schdule) GetStatus(workID string) (int, bool) {
	if scheduler, ok := s[workID]; ok {
		return scheduler.WorkStatus.Status, true
	}
	return 0, false
}

// 传入方阵ID 构造出 model.ProjectHierarchy 结构
// func getTree(id string) []model.ProjectHierarchy {
// 	ctx := context.Background()

// 	ScheduleData := []entity.WorkSchedule{}
// 	if err := dao.WorkSchedule.Ctx(ctx).Scan(&ScheduleData); err != nil {
// 		return nil
// 	}

// 	// 遍历 ScheduleData，将数据按照 WorkID 分组
// 	scheduleMap := make(Schdule)
// 	for _, item := range ScheduleData {
// 		// 预计进度
// 		planNum := item.PlanNum
// 		// 实际进度
// 		finishedNum := item.FinishedNum

// 		// 如果不存在的话，创建一个新的 Scheduler
// 		if _, ok := scheduleMap[item.WorkId]; !ok {
// 			scheduleMap[item.WorkId] = Scheduler{
// 				WorkStatus:  &item,
// 				Total:       planNum,
// 				FinishedPtr: finishedNum,
// 			}
// 			continue
// 		}

// 		// 如果存在的话，则将多个计划数据叠加
// 		scheduler := scheduleMap[item.WorkId]
// 		scheduler.Total += planNum
// 		scheduler.FinishedPtr += finishedNum
// 		scheduleMap[item.WorkId] = scheduler
// 	}

// 	// 获取指定方阵ID的所有项目
// 	workStatusList := []entity.WorkStatus{}
// 	if err := dao.WorkStatus.Ctx(context.Background()).Where(dao.WorkStatus.Columns().FangzhenId, id).Scan(&workStatusList); err != nil {
// 		return nil
// 	}

// 	// 父列表
// 	parentList := []entity.WorkStatus{}
// 	// 子列表，使用 map 存储，键为父元素的 ID
// 	childrenMap := make(map[int][]entity.WorkStatus)

// 	// 遍历所有数据，将父级和子集分开
// 	for _, item := range workStatusList {
// 		if item.Parent == 0 {
// 			parentList = append(parentList, item)
// 		} else {
// 			childrenMap[item.Parent] = append(childrenMap[item.Parent], item)
// 		}
// 	}

// 	// 树形结构
// 	projectList := []model.ProjectHierarchy{}

// 	for _, parent := range parentList {
// 		projectItem := model.ProjectHierarchy{
// 			Name:        parent.WorkName,
// 			SubProjects: make([]model.SubProject, 0, len(workStatusList)),
// 		}

// 		temp := []model.SubProject{}

// 		for _, child := range childrenMap[int(parent.Id)] {
// 			// 根据 WorkID 获取计划和总量
// 			finishedPtr, total := scheduleMap.Get(child.WorkId)

// 			temp = append(temp, model.SubProject{
// 				Name: child.WorkName,

// 			})
// 		}
// 		projectList = append(projectList, projectItem)
// 	}

// 	return projectList
// }

// func Test_GetTree(t *testing.T) {
// 	// 获取指定方阵ID的所有项目
// 	result := getTree("489")
// 	body, _ := json.Marshal(result)
// 	println(string(body))
// }

// 传入子项目ID 删除及其关联数据
func Test_Delete(t *testing.T) {
	ctx := context.Background()

	subProjectName := "多傍屯15MW"
	// subProjectName := "上令中令屯20MW"

	// 获取子项目的主键ID
	subProject := entity.SubProject{}
	if err := dao.SubProject.Ctx(ctx).Where(dao.SubProject.Columns().ProjectName, subProjectName).Scan(&subProject); err != nil {
		return
	}

	// 获取子项目下的所有方阵
	fangzhens := []entity.QianqiFangzhen{}
	if err := dao.QianqiFangzhen.Ctx(ctx).Where(dao.QianqiFangzhen.Columns().ProjectId, subProject.Id).Scan(&fangzhens); err != nil {
		return
	}

	// 获取所有方阵的ID
	fangzhenIds := lo.Map[entity.QianqiFangzhen, int](fangzhens, func(x entity.QianqiFangzhen, _ int) int {
		return x.Id
	})

	// 删除所有方阵
	dao.QianqiFangzhen.Ctx(ctx).WhereIn(dao.QianqiFangzhen.Columns().Id, fangzhenIds).Delete()

	// 删除在 work_status 表中的数据
	dao.WorkStatus.Ctx(ctx).WhereIn(dao.WorkStatus.Columns().WorkId, fangzhenIds).Delete()

	// 删除子项目下的 pv
	dao.PvModule.Ctx(ctx).WhereIn(dao.PvModule.Columns().FangzhenId, fangzhenIds).Delete()

	// 删除箱变
	dao.QianqiXiangbian.Ctx(ctx).WhereIn(dao.QianqiXiangbian.Columns().ProjectId, fangzhenIds).Delete()
}

// 前端 type 键值
func Test_Type(t *testing.T) {
	ctx := context.Background()

	fangzhenid := 625
	SubProjectId := 26

	workStatusList := []entity.WorkStatus{}
	if err := dao.PvModule.Ctx(ctx).Where(dao.PvModule.Columns().FangzhenId, fangzhenid).
		Where(dao.PvModule.Columns().SubProjectid, SubProjectId).
		Fields(dao.PvModule.Columns().Type).Distinct().Scan(&workStatusList); err != nil {
		t.Fatal(err)
	}

	// 当前方阵所导入的 Type 列表
	typeList := lop.Map[entity.WorkStatus](workStatusList, func(item entity.WorkStatus, index int) int {
		return item.Type
	})

	// 遍历 typeList
	// 	SELECT work_id,
	//        GROUP_CONCAT(name) AS names,
	//        GROUP_CONCAT(detail) AS details,
	//        type
	// FROM pv_module
	// WHERE fangzhen_id = 625 AND sub_projectid = 26 AND type = 2
	// GROUP BY work_id;

	for i := 0; i <= len(typeList); i++ {
		a := entity.WorkStatus{}
		if err := dao.PvModule.Ctx(ctx).Where(dao.PvModule.Columns().FangzhenId, fangzhenid).
			Where(dao.PvModule.Columns().SubProjectid, SubProjectId).
			Where(dao.PvModule.Columns().Type, typeList[i]).
			Fields(dao.PvModule.Columns().WorkId, dao.PvModule.Columns().Name, dao.PvModule.Columns().Detail).
			Group(dao.PvModule.Columns().WorkId).
			Scan(&a); err != nil {
			t.Fatal(err)
		}

		fmt.Printf("a: %v\n", a)
	}
}

// 测试泛型分组
// func Test_Group(t *testing.T) {
// 	group := lo.GroupBy[pv]([]int{1, 2, 3, 4, 5, 6, 7, 8}, func(i int) int {
// 		return i % 3
// 	})
// 	fmt.Println(group)
// }

// 根据 WorkID 反向找到其对应的大项目，子项目，方阵
func Test_GetProject(t *testing.T) {
	//	select sp.id as sub_projectid,sp.project_id as projectid,fz.name
	//
	// from work_status as wsa
	// Inner join qianqi_fangzhen as fz on wsa.fangzhen_id = fz.id
	// Inner join sub_project as sp on fz.project_id = sp.id
	// where wsa.work_id = "507070097236492777"

	// 获取所有的计划
	d := []entity.WorkStatus{}
	if err := dao.WorkSchedule.Ctx(context.Background()).Scan(&d); err != nil {
		t.Fatal(err)
	}

	// 遍历所有的计划
	for i := 0; i < len(d); i++ {
		workschdule := d[i]

		// 获取该计划对应的大项目，子项目，方阵
		projectID, subProjectID, _, err := getWorkDetail(workschdule.WorkId)
		if err != nil {
			t.Fatal(err)
		}

		// 为其插入对应的大项目，子项目，方阵
		_, err = dao.WorkStatus.Ctx(context.Background()).Where(dao.WorkSchedule.Columns().WorkId, workschdule.WorkId).
			Data(g.Map{
				dao.WorkStatus.Columns().ProjectId:    projectID,
				dao.WorkStatus.Columns().SubProjectid: subProjectID,
				// dao.WorkStatus.Columns().FangzhenId:   fangzhenid,
			}).Update()
		if err != nil {
			t.Fatal(err)
		}
	}

	// 507070881722466793
	// a, b, c, err := getWorkDetail("507070881722466793")
	// if err != nil {
	// 	t.Fatal(err)
	// }

	// fmt.Printf("a: %v, b: %v, c: %v\n", a, b, c)
}

func getWorkDetail(workID string) (int, int, int, error) {
	//	select sp.id as sub_projectid,sp.project_id as projectid,fz.name
	//
	// from work_status as wsa
	// Inner join qianqi_fangzhen as fz on wsa.fangzhen_id = fz.id
	// Inner join sub_project as sp on fz.project_id = sp.id
	// where wsa.work_id = "507070097236492777"
	type WorkDetail struct {
		SubProjectID int `json:"sub_project_id"`
		ProjectID    int `json:"project_id"`
		FangzhenID   int `json:"id"`
	}

	workDetail := WorkDetail{}

	err := dao.WorkStatus.Ctx(context.Background()).As("workStatusAlias").Where("workStatusAlias.work_id", workID).
		InnerJoin("qianqi_fangzhen as fangzhenAlias", "workStatusAlias.fangzhen_id = fangzhenAlias.id").
		InnerJoin("sub_project as subProjectAlias", "fangzhenAlias.project_id = subProjectAlias.id").
		Fields("subProjectAlias.id as sub_project_id", "subProjectAlias.project_id as project_id", "fangzhenAlias.id").Scan(&workDetail)

	return workDetail.ProjectID, workDetail.SubProjectID, workDetail.FangzhenID, err
}

func getByFangzhenID(fangzhenid string) (int, int, error) {
	type Project struct {
		ProjectID int `json:"project_id" orm:"project_id"`
		SubID     int `json:"sub_id" orm:"sub_id"`
	}

	project := Project{}

	err := dao.QianqiFangzhen.Ctx(context.Background()).As("fangzhenAlias").Where("fangzhenAlias.id", 1959).
		InnerJoin("sub_project as subProjectAlias", "fangzhenAlias.project_id = subProjectAlias.id").
		InnerJoin("sys_project as projectAlias", "projectAlias.id = subProjectAlias.project_id").
		Fields("projectAlias.id as project_id", "subProjectAlias.id as sub_id").Scan(&project)
	if err != nil {
		return 0, 0, err
	}

	return project.ProjectID, project.SubID, nil
}

// 根据fangzhen_ID 找到对应的主项目和子项目
func Test_GetProjectByFangzhenID(t *testing.T) {
	// projectID, subID, err := getByFangzhenID("1959")
	// if err != nil {
	// 	t.Fatal(err)
	// }

	// fmt.Printf("projectID: %v, subID: %v\n", projectID, subID)

	// 获取所有的 work_status
	d := []entity.WorkStatus{}
	if err := dao.WorkStatus.Ctx(context.Background()).Scan(&d); err != nil {
		t.Fatal(err)
	}

	// 遍历所有的 work_status
	for i := 0; i <= len(d); i++ {
		workStatus := d[i]

		// 获取该 work_status 对应的主项目和子项目
		projectID, subID, err := getByFangzhenID(workStatus.FangzhenId)
		if err != nil {
			t.Fatal(err)
		}

		// 为其插入对应的主项目和子项目
		_, err = dao.WorkStatus.Ctx(context.Background()).Where(dao.WorkStatus.Columns().FangzhenId, workStatus.FangzhenId).
			Data(g.Map{
				dao.WorkStatus.Columns().ProjectId:    projectID,
				dao.WorkStatus.Columns().SubProjectid: subID,
			}).Update()
		if err != nil {
			t.Fatal(err)
		}
	}
}

// 获取一个方阵的的所有夫级进度
func Test_GetParent(t *testing.T) {
	// 根据子项目获取所有的方阵
	subProjectID := 26

	fangzhenList := []entity.QianqiFangzhen{}
	if err := dao.QianqiFangzhen.Ctx(context.Background()).
		Where(dao.QianqiFangzhen.Columns().ProjectId, subProjectID).Scan(&fangzhenList); err != nil {
		t.Fatal(err)
	}

	cumulativeProjects := []*model.WorkStatusProgressRes{}
	firstTime := true

	// 遍历项目列表
	for index := 0; index < len(fangzhenList); index++ {
		// 获取当前项目
		project := fangzhenList[index]

		// 获取当前项目的子项目
		childProjects, err := GetPrarent(strconv.Itoa(project.Id))
		if err != nil {
			t.Fatal(err)
		}

		// 如果是第一次迭代，将子项目列表赋值给累积项目列表
		if firstTime {
			cumulativeProjects = childProjects
			// 更新标志变量，表示已经不是第一次迭代
			firstTime = false
			continue
		}

		// 遍历子项目列表后叠加到累积项目列表
		for childIndex := 0; childIndex < len(childProjects); childIndex++ {
			// 获取根据索引获取当前的 cumulativeProjects
			singleChild := childProjects[childIndex]
			comulativeChild := cumulativeProjects[childIndex]

			// 将 singleChild 的 Total 和 Finished 叠加到 comulativeChild
			comulativeChild.Total += singleChild.Total
			comulativeChild.Finished += singleChild.Finished
		}
	}

	// 序列化 cumulativeProjects
	body, _ := json.Marshal(cumulativeProjects)
	println(string(body))
}

// 获取一个方阵的所有子级进度
func GetPrarent(fangzhenID string) ([]*model.WorkStatusProgressRes, error) {
	ctx := context.Background()

	ScheduleData := []entity.WorkSchedule{}
	if err := dao.WorkSchedule.Ctx(ctx).Scan(&ScheduleData); err != nil {
		return nil, nil
	}

	// 遍历 ScheduleData，将数据按照 WorkID 分组
	scheduleMap := make(Schdule)
	for _, item := range ScheduleData {
		// 预计进度
		planNum := item.PlanNum
		// 实际进度
		finishedNum := item.FinishedNum

		// 如果不存在的话，创建一个新的 Scheduler
		if _, ok := scheduleMap[item.WorkId]; !ok {
			scheduleMap[item.WorkId] = Scheduler{
				WorkStatus:  &item,
				Total:       planNum,
				FinishedPtr: finishedNum,
			}
			continue
		}

		// 如果存在的话，则将多个计划数据叠加
		scheduler := scheduleMap[item.WorkId]
		scheduler.Total += planNum
		scheduler.FinishedPtr += finishedNum
		scheduleMap[item.WorkId] = scheduler
	}

	// 获取指定方阵ID的所有项目
	workStatusList := []entity.WorkStatus{}
	if err := dao.WorkStatus.Ctx(ctx).Where(dao.WorkStatus.Columns().FangzhenId, fangzhenID).Scan(&workStatusList); err != nil {
		return nil, err
	}

	// 父列表
	parentList := []entity.WorkStatus{}
	// 子列表，使用 map 存储，键为父元素的 ID
	childrenMap := make(map[int][]entity.WorkStatus)

	// 遍历所有数据，将父级和子集分开
	for _, item := range workStatusList {
		if item.Parent == 0 {
			parentList = append(parentList, item)
		} else {
			childrenMap[item.Parent] = append(childrenMap[item.Parent], item)
		}
	}

	index := 1

	projectList := make([]*model.WorkStatusProgressRes, 0, len(parentList))
	// 遍历父级，将子集添加到父级的字段中
	for _, parent := range parentList {
		projectItem := model.WorkStatusProgressRes{
			ID:       index,
			WorkID:   parent.WorkId,
			Startat:  parent.StartAt.String(),
			Endat:    parent.EndAt.String(),
			Name:     parent.WorkName,
			Total:    parent.Total,
			Finished: parent.Finished,
			Status:   parent.Status,
			WorkType: parent.Type,
			Children: make([]model.WorkStatusProgressRes, 0, len(workStatusList)),
		}
		index++

		// 从 map 中获取子元素，将子元素添加到父元素的字段中
		for _, child := range childrenMap[int(parent.Id)] {

			projectItem.Total += child.Total
			projectItem.Finished += child.Finished
		}

		// 如果计划数量等于实际数量，且原状态非3，则更新状态为2
		if projectItem.Total == projectItem.Finished {
			// 并且 total,finished 不为 0
			projectItem.Status = 2
		} else {
			projectItem.Status = 1
		}

		projectList = append(projectList, &projectItem)
	}

	return projectList, nil
}

// 测试子项目是否已完成
func Test_SubProject(t *testing.T) {
	ctx := context.Background()

	// 获取所有的子项目
	var projectList []entity.SubProject
	if err := dao.SubProject.Ctx(ctx).Scan(&projectList); err != nil {
		return
	}

	// 遍历每个项目
	for _, project := range projectList {
		result, err := dao.WorkStatus.Ctx(ctx).Where(dao.WorkStatus.Columns().SubProjectid, project.Id).Fields("sum(total) as total ,sum(finished) as finished").All()
		if err != nil {
			continue
		}

		total := result[0]["total"].Int()
		finished := result[0]["finished"].Int()

		if total == 0 || finished == 0 {
			continue
		}

		// 如果总量和完成量相等，则将其子项目添加完成日期
		if total == finished {
			// 更新项目状态
			dao.SubProject.Ctx(ctx).Where(dao.SubProject.Columns().Id, project.Id).
				WhereNull(dao.SubProject.Columns().DoneTime).
				Update(g.Map{
					dao.SubProject.Columns().DoneTime: time.Now().Format("2006-01-02"),
				})
		}
	}
}