852 lines
24 KiB
Go
852 lines
24 KiB
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"),
|
||
})
|
||
}
|
||
}
|
||
}
|