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

package proj

import (
	"context"
	"github.com/gogf/gf/database/gdb"
	"github.com/gogf/gf/errors/gerror"
	"github.com/gogf/gf/frame/g"
	"github.com/gogf/gf/os/gtime"
	"github.com/gogf/gf/util/gconv"
	"strings"

	projDao "dashoo.cn/micro/app/dao/proj"
	model "dashoo.cn/micro/app/model/proj"
	"dashoo.cn/micro/app/service"
)

type businessService struct {
	*service.ContextService
	Dao *projDao.ProjBusinessDao
}

func NewBusinessService(ctx context.Context) (svc *businessService, err error) {
	svc = new(businessService)
	if svc.ContextService, err = svc.Init(ctx); err != nil {
		return nil, err
	}
	svc.Dao = projDao.NewProjBusinessDao(svc.Tenant)
	return svc, nil
}

func (p *businessService) GetList(req *model.ProjBusinessSearchReq) (total int, businessList []*model.ProjBusiness, err error) {
	db := p.Dao.M
	if req.NboName != "" {
		db = db.WhereLike(p.Dao.Columns.NboName, "%"+req.NboName+"%")
	}
	if req.CustName != "" {
		db = db.WhereLike(p.Dao.Columns.CustName, "%"+req.CustName+"%")
	}
	if req.SaleName != "" {
		db = db.WhereLike(p.Dao.Columns.SaleName, "%"+req.SaleName+"%")
	}
	if req.NboType != "" {
		db = db.Where(p.Dao.Columns.NboType, req.NboType)
	}
	total, err = db.Count()
	if err != nil {
		g.Log().Error(err)
		err = gerror.New("获取总行数失败")
		return
	}

	err = db.Page(req.PageNum, req.PageSize).Order("id asc").Scan(&businessList)
	return
}

func (p *businessService) GetEntityById(id int64) (business *model.ProjBusiness, err error) {
	err = p.Dao.Where(projDao.ProjBusiness.Columns.Id, id).Scan(&business)
	return
}

func (p *businessService) GetBusinessProduct(id int64) (productList []*model.ProjBusinessProduct, err error) {
	productDao := projDao.NewProjBusinessProductDao(p.Tenant)
	err = productDao.Where(productDao.ProjBusinessProductDao.Columns.BusId, id).Scan(&productList)
	return
}

func (p *businessService) Create(req *model.AddProjBusinessReq) (err error) {
	businessData := new(model.ProjBusiness)
	if err = gconv.Struct(req, businessData); err != nil {
		return
	}
	products := make([]*model.ProjBusinessProduct, len(req.Products))
	if err = gconv.Structs(req.Products, &products); err != nil {
		return
	}

	service.SetCreatedInfo(businessData, p.GetCxtUserId(), p.GetCxtUserName())
	err = p.Dao.Transaction(context.TODO(), func(ctx context.Context, tx *gdb.TX) error {
		// 添加项目
		res, err := p.Dao.TX(tx).Insert(businessData)
		if err != nil {
			return err
		}
		// 处理项目产品信息
		lastId, _ := res.LastInsertId()
		for _, v := range products {
			v.BusId = int(lastId)
			v.TotalPrice = v.SellingPrice * v.Quantity
			service.SetCreatedInfo(v, p.GetCxtUserId(), p.GetCxtUserName())
		}
		// 添加项目产品
		_, err = projDao.NewProjBusinessProductDao(p.Tenant).TX(tx).Insert(products)
		if err != nil {
			return err
		}
		// 添加项目动态
		dynamics := model.ProjBusinessDynamics{
			OpnPeopleId: p.GetCxtUserId(),
			OpnPeople:   p.GetCxtUserName(),
			OpnDate:     gtime.Now(),
			OpnType:     "CREATED",
			OpnContent:  "创建项目",
			Remark:      gconv.String(businessData),
		}
		service.SetCreatedInfo(dynamics, p.GetCxtUserId(), p.GetCxtUserName())
		_, err = projDao.NewProjBusinessDao(p.Tenant).TX(tx).Insert(&dynamics)
		return err
	})

	return
}

func (p *businessService) UpdateById(req *model.UpdateProjBusinessReq) (err error) {
	record, err := p.Dao.Count("Id", req.Id)
	if err != nil || record == 0 {
		err = gerror.New("该数据不存在")
		return err
	}
	businessData := new(model.ProjBusiness)
	if err = gconv.Struct(req, businessData); err != nil {
		return
	}
	service.SetUpdatedInfo(businessData, p.GetCxtUserId(), p.GetCxtUserName())

	err = p.Dao.Transaction(context.TODO(), func(ctx context.Context, tx *gdb.TX) error {
		// 更新项目
		_, err = p.Dao.TX(tx).FieldsEx(service.UpdateFieldEx).WherePri(projDao.ProjBusiness.Columns.Id, req.Id).Update(businessData)
		if err != nil {
			return err
		}
		// 添加项目动态
		dynamics := model.ProjBusinessDynamics{
			OpnPeopleId: p.GetCxtUserId(),
			OpnPeople:   p.GetCxtUserName(),
			OpnDate:     gtime.Now(),
			OpnType:     "UPDATED",
			OpnContent:  "编辑项目",
			Remark:      gconv.String(businessData),
		}
		service.SetCreatedInfo(dynamics, p.GetCxtUserId(), p.GetCxtUserName())
		_, err = projDao.NewProjBusinessDao(p.Tenant).TX(tx).Insert(&dynamics)
		return err
	})
	return
}

func (p *businessService) DeleteByIds(ids []int64) (err error) {
	_, err = p.Dao.WhereIn(projDao.ProjBusiness.Columns.Id, ids).Delete()
	return
}

// 项目调级
func (p *businessService) BusinessGradation(req *model.BusinessGradationReq) error {
	var business model.ProjBusiness
	err := p.Dao.Where(projDao.ProjBusiness.Columns.Id, req.Id).Scan(&business)
	if err != nil {
		return err
	}
	if business.NboType == req.NboType {
		return gerror.New("同级无法进行调级。")
	}
	opnContent := "项目升级 " + business.NboType + " => " + req.NboType
	// A < B return -1 项目降级
	if strings.Compare(business.NboType, req.NboType) < 0 {
		opnContent = "项目降级 " + business.NboType + " => " + req.NboType
	}
	business.NboType = req.NboType
	service.SetUpdatedInfo(business, p.GetCxtUserId(), p.GetCxtUserName())

	err = p.Dao.Transaction(context.TODO(), func(ctx context.Context, tx *gdb.TX) error {
		// 更新项目调级
		_, err = p.Dao.TX(tx).Fields(p.Dao.Columns.NboType).WherePri(projDao.ProjBusiness.Columns.Id, req.Id).Update(business)
		if err != nil {
			return err
		}
		// 添加项目动态
		dynamics := model.ProjBusinessDynamics{
			OpnPeopleId: p.GetCxtUserId(),
			OpnPeople:   p.GetCxtUserName(),
			OpnDate:     gtime.Now(),
			OpnType:     "UPDATED",
			OpnContent:  opnContent,
		}
		service.SetCreatedInfo(dynamics, p.GetCxtUserId(), p.GetCxtUserName())
		_, err = projDao.NewProjBusinessDao(p.Tenant).TX(tx).Insert(&dynamics)
		return err
	})
	return err
}

// 项目转移
func (p *businessService) BusinessTransfer(req *model.BusinessTransferReq) error {
	var business model.ProjBusiness
	err := p.Dao.Where(projDao.ProjBusiness.Columns.Id, req.Id).Scan(&business)
	if err != nil {
		return err
	}
	business.SaleId = req.UserId
	business.SaleName = req.UserName
	business.Remark = req.Remark
	service.SetUpdatedInfo(business, p.GetCxtUserId(), p.GetCxtUserName())

	err = p.Dao.Transaction(context.TODO(), func(ctx context.Context, tx *gdb.TX) error {
		// 更新项目调级
		_, err = p.Dao.TX(tx).Fields(p.Dao.Columns.SaleId, p.Dao.Columns.SaleName).WherePri(projDao.ProjBusiness.Columns.Id, req.Id).Update(business)
		if err != nil {
			return err
		}
		// 添加项目动态
		dynamics := model.ProjBusinessDynamics{
			OpnPeopleId: p.GetCxtUserId(),
			OpnPeople:   p.GetCxtUserName(),
			OpnDate:     gtime.Now(),
			OpnType:     "UPDATED",
			OpnContent:  "项目转移",
			Remark:      gconv.String(business),
		}
		service.SetCreatedInfo(dynamics, p.GetCxtUserId(), p.GetCxtUserName())
		_, err = projDao.NewProjBusinessDao(p.Tenant).TX(tx).Insert(&dynamics)
		return err
	})
	return err
}