opms_backend/opms_parent/app/service/proj/train_head_office.go

package proj

import (
	"context"
	projDao "dashoo.cn/micro/app/dao/proj"
	model "dashoo.cn/micro/app/model/proj"
	"dashoo.cn/micro/app/service"
	"dashoo.cn/opms_libary/myerrors"
	"database/sql"
	"github.com/gogf/gf/database/gdb"
	"github.com/gogf/gf/frame/g"
	"github.com/gogf/gf/os/gtime"
)

type trainHeadService struct {
	*service.ContextService
	Dao       *projDao.TrainHeadOfficeDao
	FeedDao   *projDao.TrainHeadOfficeFeedbackDao
	DetailDao *projDao.TrainHeadOfficeFeedbackDetailDao
}

func NewtrainHeadService(ctx context.Context) (svc *trainHeadService, err error) {
	svc = new(trainHeadService)
	if svc.ContextService, err = svc.Init(ctx); err != nil {
		return nil, err
	}
	svc.Dao = projDao.NewTrainHeadOfficeDao(svc.Tenant)
	svc.FeedDao = projDao.NewTrainHeadOfficeFeedbackDao(svc.Tenant)
	svc.DetailDao = projDao.NewTrainHeadOfficeFeedbackDetailDao(svc.Tenant)

	return svc, nil
}

func (s *trainHeadService) GetList(req *model.SearchTrainHeadReq) (total int, list []*model.SearchTrainHeadRes, err error) {
	db := s.Dao.Ctx(s.Ctx)

	if req.TrainTitle != "" {
		db = db.WhereLike(s.Dao.C.TrainTitle, "%"+req.TrainTitle+"%")
	}
	//if req.TrainStartDate != nil {
	//	db = db.Where("train_date >=?", req.TrainStartDate)
	//}
	//if req.TrainEndDate != nil {
	//	db = db.Where("train_date <=?", req.TrainEndDate)
	//}

	total, err = db.Count()
	if err != nil {
		return 0, nil, err
	}

	err = db.OrderDesc(s.Dao.C.CreatedTime).Page(req.GetPage()).Scan(&list)
	//if err != nil && err != sql.ErrNoRows {
	if err != nil {

		return 0, nil, err
	}
	return total, list, nil
}

func (s *trainHeadService) GetEntityById(id int64) (detail *model.TrainHeadDetail, err error) {

	err = s.Dao.WherePri(id).Scan(&detail)

	if err == sql.ErrNoRows {
		return nil, myerrors.TipsError("工单不存在")
	}
	if err != nil {
		return nil, err
	}
	settingList := make([]*model.FeedbackDetail, 0)
	err = s.FeedDao.Where(s.FeedDao.C.TrainId, id).Scan(&settingList)

	detail.FeedbackList = settingList
	for _, feedbackDetail := range settingList {
		Distributor := make([]*model.Distributor, 0)
		err = s.DetailDao.Where(s.DetailDao.C.MainId, feedbackDetail.Id).Scan(&Distributor)
		if err != nil {
			return nil, myerrors.TipsError("工单查询失败，请稍后重试")
		}
		feedbackDetail.DistributorList = Distributor

	}
	if err != nil {
		return nil, myerrors.TipsError("工单查询失败，请稍后重试")
	}
	return detail, nil
}

func (s *trainHeadService) GetDetailById(id int64) (detail *model.TrainHeadDetailForFeedBack, err error) {

	err = s.Dao.WherePri(id).Scan(&detail)

	if err == sql.ErrNoRows {
		return nil, myerrors.TipsError("工单不存在")
	}
	if err != nil {
		return nil, err
	}
	settingList := make([]*model.FeedbackDetailRes, 0)
	err = s.DetailDao.As("fd").LeftJoin("train_head_office_feedback as f", "f.id = fd.main_id").Where("f.train_id", id).
		Fields("fd.*,f.sale_id,f.sale_name").
		Scan(&settingList)
	if err != nil {
		return nil, myerrors.TipsError("工单查询失败，请稍后重试")
	}
	detail.FeedbackDetailList = settingList

	return detail, nil
}

func (s *trainHeadService) Create(req *model.CreateTrainHead) (err error) {

	ent := model.TrainHeadOffice{
		Id:                     0,
		TrainTitle:             req.TrainTitle,
		TrainDate:              req.TrainDate,
		TrainConcreteStartTime: req.TrainConcreteStartTime,
		TrainConcreteEndTime:   req.TrainConcreteEndTime,
		CreatedBy:              s.GetCxtUserId(),
		CreatedName:            s.GetCxtUserName(),
		CreatedTime:            gtime.Now(),
	}
	//service.SetCreatedInfo(ent, s.GetCxtUserId(), s.GetCxtUserName())

	e := s.Dao.Transaction(s.Ctx, func(ctx context.Context, tx *gdb.TX) error {
		id, err := s.Dao.TX(tx).InsertAndGetId(ent)
		if err != nil {
			return myerrors.TipsError("提取方案创建失败，请联系管理员")
		}
		//CreateSetting := make([]*model.TrainHeadOfficeFeedback, 0)
		DetailList := make([]*model.TrainHeadOfficeFeedbackDetail, 0)
		for _, feedBack := range req.FeedbackList {
			TrainHeadSetting := model.TrainHeadOfficeFeedback{
				TrainId:     int(id),
				SaleId:      feedBack.Sale.SaleId,
				SaleName:    feedBack.Sale.SaleName,
				CreatedBy:   s.GetCxtUserId(),
				CreatedName: s.GetCxtUserName(),
				CreatedTime: gtime.Now(),
			}
			//CreateSetting = append(CreateSetting, &TrainHeadSetting)
			settingId, err := s.FeedDao.TX(tx).InsertAndGetId(TrainHeadSetting)
			if err != nil {
				return myerrors.TipsError("提取方案创建失败，请联系管理员")
			}
			for _, Dis := range feedBack.DistributorList {
				detail := model.TrainHeadOfficeFeedbackDetail{
					MainId:          int(settingId),
					DistributorId:   Dis.DistributorId,
					DistributorName: Dis.DistributorName,
					CreatedBy:       s.GetCxtUserId(),
					CreatedName:     s.GetCxtUserName(),
					CreatedTime:     gtime.Now(),
				}
				DetailList = append(DetailList, &detail)

			}
			_, err = s.DetailDao.TX(tx).Insert(DetailList)
			if err != nil {
				return myerrors.TipsError("提取方案创建失败，请联系管理员")
			}

		}

		if err != nil {
			return myerrors.TipsError("提取方案创建失败，请联系管理员")
		}
		return nil
	})

	return e
}

func (s *trainHeadService) UpdateById(req *model.UpdateTrainHead) error {

	ent := model.TrainHeadOffice{}
	err := s.Dao.WherePri(req.Id).Scan(&ent)
	if err == sql.ErrNoRows {
		return myerrors.TipsError("该培训工单不存在")
	}
	if err != nil {
		return err
	}

	updateMap := g.Map{
		s.Dao.C.TrainTitle:             req.TrainTitle,
		s.Dao.C.TrainDate:              req.TrainDate,
		s.Dao.C.TrainConcreteStartTime: req.TrainConcreteStartTime,
		s.Dao.C.TrainConcreteEndTime:   req.TrainConcreteEndTime,
		s.Dao.C.UpdatedBy:              s.GetCxtUserId(),
		s.Dao.C.UpdatedName:            s.GetCxtUserName(),
		s.Dao.C.UpdatedTime:            gtime.Now(),
	}
	e := s.Dao.Transaction(s.Ctx, func(ctx context.Context, tx *gdb.TX) error {
		_, err = s.Dao.Ctx(ctx).TX(tx).Data(updateMap).WherePri(req.Id).FieldsEx(service.UpdateFieldEx...).Update()
		if err != nil {
			return myerrors.TipsError("修改培训工单失败")
		}
		for _, feedBack := range req.FeedbackList {
			switch feedBack.Operate {
			case "10":
				TrainHeadSetting := model.TrainHeadOfficeFeedback{
					TrainId:     int(req.Id),
					SaleId:      feedBack.Sale.SaleId,
					SaleName:    feedBack.Sale.SaleName,
					CreatedBy:   s.GetCxtUserId(),
					CreatedName: s.GetCxtUserName(),
					CreatedTime: gtime.Now(),
				}
				//service.SetCreatedInfo(TrainHeadSetting, s.GetCxtUserId(), s.GetCxtUserName())
				DetailList := make([]*model.TrainHeadOfficeFeedbackDetail, 0)
				//CreateSetting = append(CreateSetting, &TrainHeadSetting)
				settingId, err := s.FeedDao.TX(tx).InsertAndGetId(TrainHeadSetting)
				//CreateSetting := make([]*model.TrainHeadOfficeFeedback, 0)
				for _, Dis := range feedBack.DistributorList {
					detail := model.TrainHeadOfficeFeedbackDetail{
						MainId:          int(settingId),
						DistributorId:   Dis.DistributorId,
						DistributorName: Dis.DistributorName,
						CreatedBy:       s.GetCxtUserId(),
						CreatedName:     s.GetCxtUserName(),
						CreatedTime:     gtime.Now(),
					}
					//service.SetCreatedInfo(detail, s.GetCxtUserId(), s.GetCxtUserName())
					DetailList = append(DetailList, &detail)

				}
				_, err = s.DetailDao.TX(tx).Insert(DetailList)
				if err != nil {
					return myerrors.TipsError("培训工单修改失败")
				}

			case "20":

				_, err = s.FeedDao.Ctx(ctx).TX(tx).Data(g.Map{
					s.FeedDao.C.SaleId:   feedBack.Sale.SaleId,
					s.FeedDao.C.SaleName: feedBack.Sale.SaleId,
					s.Dao.C.UpdatedBy:    s.GetCxtUserId(),
					s.Dao.C.UpdatedName:  s.GetCxtUserName(),
					s.Dao.C.UpdatedTime:  gtime.Now(),
				}).WherePri(feedBack.Id).FieldsEx(service.UpdateFieldEx...).Update()
				_, err = s.DetailDao.TX(tx).Where(s.DetailDao.C.MainId, feedBack.Id).Delete()
				if err != nil {
					return myerrors.TipsError("培训工单修改失败")
				}
				DetailList := make([]*model.TrainHeadOfficeFeedbackDetail, 0)
				for _, Dis := range feedBack.DistributorList {
					detail := model.TrainHeadOfficeFeedbackDetail{
						MainId:          int(feedBack.Id),
						DistributorId:   Dis.DistributorId,
						DistributorName: Dis.DistributorName,
						CreatedBy:       s.GetCxtUserId(),
						CreatedName:     s.GetCxtUserName(),
						CreatedTime:     gtime.Now(),
					}
					DetailList = append(DetailList, &detail)

				}
				_, err = s.DetailDao.TX(tx).Insert(DetailList)

				if err != nil {
					return myerrors.TipsError("培训工单修改失败")
				}

			case "30":
				_, err := s.FeedDao.Ctx(ctx).TX(tx).WherePri(feedBack.Id).Delete()
				if err != nil {
					return myerrors.TipsError("培训工单修改失败")
				}
			}

		}
		return nil
	})

	return e
}
func (s *trainHeadService) FeedBackTrain(req *model.FeedBackTrainReq) error {
	for _, feedback := range req.FeedBackTrainList {
		_, err := s.DetailDao.Data(g.Map{
			s.DetailDao.C.TrainingPersNum:     feedback.TrainingPersNum,
			s.DetailDao.C.DistributorFeedback: feedback.DistributorFeedback,
			s.Dao.C.UpdatedBy:                 s.GetCxtUserId(),
			s.Dao.C.UpdatedName:               s.GetCxtUserName(),
			s.Dao.C.UpdatedTime:               gtime.Now(),
		}).FieldsEx(service.UpdateFieldEx...).WherePri(feedback.Id).Update()
		if err != nil {
			return myerrors.TipsError("培训工单反馈提交失败，请稍后重试")
		}
	}

	return nil
}

func (s *trainHeadService) DeleteByIds(ids []int64) error {
	if len(ids) == 0 {
		return nil
	}
	e := s.Dao.Transaction(s.Ctx, func(ctx context.Context, tx *gdb.TX) error {
		_, err := s.Dao.Ctx(ctx).WhereIn(s.Dao.C.Id, ids).Delete()
		if err != nil {
			return myerrors.TipsError("培训工单删除失败，请稍后重试")
		}
		_, err = s.FeedDao.Ctx(ctx).TX(tx).WhereIn(s.FeedDao.C.TrainId, ids).Delete()
		if err != nil {
			return myerrors.TipsError("培训工单删除失败，请稍后重试")
		}

		return nil
	})

	return e
}