This commit is contained in:
2025-07-07 20:11:59 +08:00
parent ab0fdbc447
commit 06e3aa2eb3
2009 changed files with 193082 additions and 0 deletions

View File

@ -0,0 +1,323 @@
// ==========================================================================
// GFast自动生成logic操作代码。
// 生成日期2024-03-19 11:45:09
// 生成路径: internal/app/system/logic/work_status.go
// 生成人gfast
// desc:工作状态
// company:云南奇讯科技有限公司
// ==========================================================================
package logic
import (
"context"
"fmt"
"time"
"github.com/gogf/gf/v2/frame/g"
"github.com/gogf/gf/v2/util/gconv"
"github.com/tiger1103/gfast/v3/api/v1/system"
"github.com/tiger1103/gfast/v3/internal/app/system/consts"
"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/do"
"github.com/tiger1103/gfast/v3/internal/app/system/model/entity"
"github.com/tiger1103/gfast/v3/internal/app/system/service"
"github.com/tiger1103/gfast/v3/library/liberr"
"github.com/tiger1103/gfast/v3/third/progress"
"github.com/tiger1103/gfast/v3/third/schduler"
)
func init() {
service.RegisterWorkStatus(New())
}
func New() *sWorkStatus {
return &sWorkStatus{}
}
type sWorkStatus struct{}
func (s *sWorkStatus) List(ctx context.Context, req *system.WorkStatusSearchReq) (listRes *system.WorkStatusSearchRes, err error) {
listRes = new(system.WorkStatusSearchRes)
err = g.Try(ctx, func(ctx context.Context) {
m := dao.WorkStatus.Ctx(ctx).WithAll()
if req.Id != "" {
m = m.Where(dao.WorkStatus.Columns().Id+" = ?", req.Id)
}
if req.FangzhenId != "" {
m = m.Where(dao.WorkStatus.Columns().FangzhenId+" = ?", req.FangzhenId)
}
if req.Parent != "" {
m = m.Where(dao.WorkStatus.Columns().Parent+" = ?", gconv.Int(req.Parent))
}
if req.WorkId != "" {
m = m.Where(dao.WorkStatus.Columns().WorkId+" = ?", req.WorkId)
}
if req.WorkName != "" {
m = m.Where(dao.WorkStatus.Columns().WorkName+" like ?", "%"+req.WorkName+"%")
}
if req.Total != "" {
m = m.Where(dao.WorkStatus.Columns().Total+" = ?", gconv.Int(req.Total))
}
if req.Finished != "" {
m = m.Where(dao.WorkStatus.Columns().Finished+" = ?", gconv.Int(req.Finished))
}
if req.StartAt != "" {
m = m.Where(dao.WorkStatus.Columns().StartAt+" = ?", gconv.Time(req.StartAt))
}
if req.EndAt != "" {
m = m.Where(dao.WorkStatus.Columns().EndAt+" = ?", gconv.Time(req.EndAt))
}
if req.Status != "" {
m = m.Where(dao.WorkStatus.Columns().Status+" = ?", gconv.Int(req.Status))
}
if len(req.DateRange) != 0 {
m = m.Where(dao.WorkStatus.Columns().CreatedAt+" >=? AND "+dao.WorkStatus.Columns().CreatedAt+" <=?", req.DateRange[0], req.DateRange[1])
}
listRes.Total, err = m.Count()
liberr.ErrIsNil(ctx, err, "获取总行数失败")
if req.PageNum == 0 {
req.PageNum = 1
}
listRes.CurrentPage = req.PageNum
if req.PageSize == 0 {
req.PageSize = consts.PageSize
}
order := "id asc"
if req.OrderBy != "" {
order = req.OrderBy
}
var res []*model.WorkStatusInfoRes
err = m.Fields(system.WorkStatusSearchRes{}).Page(req.PageNum, req.PageSize).Order(order).Scan(&res)
liberr.ErrIsNil(ctx, err, "获取数据失败")
listRes.List = make([]*model.WorkStatusListRes, len(res))
for k, v := range res {
listRes.List[k] = &model.WorkStatusListRes{
Id: v.Id,
FangzhenId: v.FangzhenId,
Parent: v.Parent,
WorkId: v.WorkId,
WorkName: v.WorkName,
Total: v.Total,
Finished: v.Finished,
StartAt: v.StartAt,
EndAt: v.EndAt,
Status: v.Status,
CreatedAt: v.CreatedAt,
}
}
})
return
}
func (s *sWorkStatus) GetById(ctx context.Context, id uint) (res *model.WorkStatusInfoRes, err error) {
err = g.Try(ctx, func(ctx context.Context) {
err = dao.WorkStatus.Ctx(ctx).WithAll().Where(dao.WorkStatus.Columns().Id, id).Scan(&res)
liberr.ErrIsNil(ctx, err, "获取信息失败")
})
return
}
func (s *sWorkStatus) Add(ctx context.Context, req *system.WorkStatusAddReq) (err error) {
err = g.Try(ctx, func(ctx context.Context) {
_, err = dao.WorkStatus.Ctx(ctx).Insert(do.WorkStatus{
FangzhenId: req.FangzhenId,
Parent: req.Parent,
WorkId: req.WorkId,
WorkName: req.WorkName,
Total: req.Total,
Finished: req.Finished,
StartAt: req.StartAt,
EndAt: req.EndAt,
Status: req.Status,
})
liberr.ErrIsNil(ctx, err, "添加失败")
})
return
}
func (s *sWorkStatus) Edit(ctx context.Context, req *system.WorkStatusEditReq) (err error) {
err = g.Try(ctx, func(ctx context.Context) {
_, err = dao.WorkStatus.Ctx(ctx).WherePri(req.Id).Update(do.WorkStatus{
FangzhenId: req.FangzhenId,
Parent: req.Parent,
WorkId: req.WorkId,
WorkName: req.WorkName,
Total: req.Total,
Finished: req.Finished,
StartAt: req.StartAt,
EndAt: req.EndAt,
Status: req.Status,
})
liberr.ErrIsNil(ctx, err, "修改失败")
})
return
}
func (s *sWorkStatus) Delete(ctx context.Context, ids []uint) (err error) {
err = g.Try(ctx, func(ctx context.Context) {
_, err = dao.WorkStatus.Ctx(ctx).Delete(dao.WorkStatus.Columns().Id+" in (?)", ids)
liberr.ErrIsNil(ctx, err, "删除失败")
})
return
}
func (s *sWorkStatus) Progress(ctx context.Context, fangzhenID string) ([]*model.WorkStatusProgressRes, error) {
// 获取指定方阵ID的所有计划
ScheduleData := []entity.WorkSchedule{}
if err := dao.WorkSchedule.Ctx(ctx).Where(dao.WorkSchedule.Columns().FangzhenId, fangzhenID).
Scan(&ScheduleData); err != nil {
return nil, err
}
// 遍历所有计划,将计划按照 WorkID 分组
scheduleMap, err := schduler.New(ScheduleData)
if err != nil {
return nil, fmt.Errorf("初始化计划失败: %w", err)
}
// 获取指定方阵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 i := 0; i < len(workStatusList); i++ {
task := workStatusList[i]
if task.Parent == 0 {
parentList = append(parentList, task)
} else {
childrenMap[task.Parent] = append(childrenMap[task.Parent], task)
}
}
index := 1
// 待修改状态的子集
var statuFinished []string
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++
// 遍历子集
for _, child := range childrenMap[int(parent.Id)] {
// 根据 WorkID 获取计划总量和实际进度
finishedPtr, total := scheduleMap.Get(child.WorkId)
// 如果总量和实际完成量相等
if child.Finished >= child.Finished && child.Status != 3 {
if child.Total != 0 && child.Finished != 0 { // 防止两者都为初始化值
child.Status = 2 // 修改状态为已完成
statuFinished = append(statuFinished, child.WorkId)
}
}
// 如果计划总量大于实际进度,则取实际总量
if total > child.Total {
total = child.Total
}
// 判断是否延期
isDelay := scheduleMap.GetStatus(child.WorkId, child.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,
IsPercent: child.IsPercent,
Status: child.Status,
IsDelay: &isDelay,
WorkType: child.Type,
PlanProgress: &model.PlanProgress{
Finished: &finishedPtr,
Total: &total,
},
})
index++
}
projectList = append(projectList, &projectItem)
}
go func() {
// 修改状态为已完成
if len(statuFinished) > 0 {
_, _ = dao.WorkStatus.Ctx(ctx).Where(dao.WorkStatus.Columns().WorkId+" in (?)", statuFinished).Data(g.Map{
dao.WorkStatus.Columns().Status: 2,
}).Update()
}
}()
return projectList, nil
}
// 获取所有父项的总进度和当前进度
func (s *sWorkStatus) GetParentProgress(ctx context.Context, req *system.WorkStatusGetParentProgressReq) (*system.WorkStatusGetProgressRes, error) {
var (
workStatusProgressList []*model.WorkStatusProgressRes
err error
)
switch {
// 通过方阵ID获取进度
case req.FangzhenId != "":
workStatusProgressList, err = progress.WorkStatusGetProgress(req.FangzhenId)
// 通过子项目获取进度
case req.SubProjectID != "":
workStatusProgressList, err = progress.GetProgressBySubID(req.SubProjectID)
// 通过大项目获取进度
case req.ProjectID != "":
workStatusProgressList, err = progress.GetProgressByProjectID(req.ProjectID)
default:
return nil, nil
}
if err != nil {
return nil, err
}
return &system.WorkStatusGetProgressRes{Progress: workStatusProgressList}, nil
}
// isDelay 如果实际完成数量小于计划数量,且当前时间大于结束时间,则判断为延期
// endAt 结束时间
// planNum 计划数量
// finishedNum 实际数量
func isDelay(endAt string, planNum, finishedNum int) int {
// 当天时间
nowTime := time.Now().Format("2006-01-02")
// 如果实际完成数量小于计划数量,且当前时间大于结束时间,则判断为延期
if finishedNum < planNum && nowTime > endAt {
return 1
}
return 0
}