opms_backend/opms_parent/app/service/proj/business.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"
	"dashoo.cn/opms_libary/utils"
	"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"
)

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) GetBusinessDynamics(req *model.BusinessReq) (total int, result g.ListStrAny, err error) {
	result = make(g.ListStrAny, 0)
	dynamicsDao := projDao.NewProjBusinessDynamicsDao(p.Tenant).ProjBusinessDynamicsDao.Where(projDao.ProjBusinessDynamics.Columns.BusId, req.BusId)
	total, err = dynamicsDao.Count()
	if err != nil {
		g.Log().Error(err)
		return
	}
	dynamicsList, err := dynamicsDao.Page(req.GetPage()).Order("created_time desc").All()
	if err != nil || len(dynamicsList) == 0 {
		g.Log().Error(err)
		return
	}
	// 数据树格式转换
	opnDateFlag := gtime.New(dynamicsList[0].OpnDate).Format("Y-m-d")
	for k, v := range dynamicsList {
		opnDate := gtime.New(v.OpnDate).Format("Y-m-d")
		if opnDateFlag == opnDate && k != 0 {
			result[len(result)-1][opnDate] = append(result[len(result)-1][opnDate].(g.ListStrAny), g.Map{
				"opnPeople":  v.OpnPeople,
				"opnDate":    v.OpnDate,
				"opnType":    v.OpnType,
				"opnContent": gconv.Map(v.OpnContent),
			})
		} else {
			temp := make(g.ListStrAny, 0)
			temp = append(temp, g.Map{
				"opnPeople":  v.OpnPeople,
				"opnDate":    v.OpnDate,
				"opnType":    v.OpnType,
				"opnContent": gconv.Map(v.OpnContent),
			})
			result = append(result, g.Map{
				opnDate: temp,
			})
		}
	}
	return
}

func (p *businessService) GetBusinessDynamicsList(req *model.BusinessReq) (total int, list []map[string]interface{}, err error) {
	dynamicsDao := projDao.NewProjBusinessDynamicsDao(p.Tenant).ProjBusinessDynamicsDao.Where(projDao.ProjBusinessDynamics.Columns.BusId, req.BusId)
	if req.OpnType != "" {
		dynamicsDao = dynamicsDao.Where(projDao.ProjBusinessDynamics.Columns.OpnType+" = ?", req.OpnType)
	}
	total, err = dynamicsDao.Count()
	if err != nil {
		g.Log().Error(err)
		return
	}

	dynamicsList, err := dynamicsDao.Page(req.GetPage()).Order("created_time desc").All()
	for _, v := range dynamicsList {
		val := gconv.Map(v)
		val["opnContent"] = gconv.Map(v.OpnContent)
		list = append(list, val)
	}
	return
}

func (p *businessService) Create(req *model.AddProjBusinessReq) (err error) {
	businessData := new(model.ProjBusiness)
	if err = gconv.Struct(req, businessData); err != nil {
		return
	}
	contact := g.Map{
		projDao.ProjBusinessContact.Columns.ContactId: req.ContactId,
	}
	service.SetCreatedInfo(contact, p.GetCxtUserId(), p.GetCxtUserName())

	products := make([]*model.ProjBusinessProduct, len(req.Products))
	if err = gconv.Structs(req.Products, &products); err != nil {
		return
	}
	var totalPrice float64
	for _, v := range products {
		v.TotalPrice = v.ProdPrice * float64(v.ProdNum)
		totalPrice += v.TotalPrice
		service.SetCreatedInfo(v, p.GetCxtUserId(), p.GetCxtUserName())
	}

	businessData.NboType = "C"
	businessData.ApproStatus = "10"
	businessData.EstTransPrice = totalPrice
	businessData.DeptId = p.GetCxtUserDeptId()
	service.SetCreatedInfo(businessData, p.GetCxtUserId(), p.GetCxtUserName())
	err = p.Dao.Transaction(context.TODO(), func(ctx context.Context, tx *gdb.TX) error {
		// 添加项目
		lastId, err := p.Dao.TX(tx).InsertAndGetId(businessData)
		if err != nil {
			return err
		}
		// 创建了联系人
		contact[projDao.ProjBusinessContact.Columns.BusId] = lastId
		_, err = projDao.NewProjBusinessContactDao(p.Tenant).TX(tx).Insert(contact)
		if err != nil {
			return err
		}

		// 处理项目产品信息
		for _, v := range products {
			v.BusId = int(lastId)
		}
		// 添加项目产品
		_, err = projDao.NewProjBusinessProductDao(p.Tenant).TX(tx).Insert(products)
		if err != nil {
			return err
		}
		// 添加项目动态
		dynamics := model.ProjBusinessDynamics{
			BusId:   int(lastId),
			OpnType: "10",
			Remark:  businessData.Remark,
		}
		err = p.CreateProjBusinessDynamics(tx, dynamics, businessData)
		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 := gconv.Map(req)
	businessData = utils.MapKeySnakeCamelCase(businessData, "snake")
	products := make([]*model.ProjBusinessProduct, len(req.Products))
	if err = gconv.Structs(req.Products, &products); err != nil {
		return
	}
	var totalPrice float64
	for _, v := range products {
		v.Id = 0
		v.TotalPrice = v.ProdPrice * float64(v.ProdNum)
		totalPrice += v.TotalPrice
		service.SetCreatedInfo(v, p.GetCxtUserId(), p.GetCxtUserName())
	}
	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
		}
		// 添加项目产品
		_, err = projDao.NewProjBusinessProductDao(p.Tenant).TX(tx).Where(projDao.ProjBusinessProduct.Columns.BusId, req.Id).Delete()
		if err != nil {
			return err
		}
		// 添加项目产品
		_, err = projDao.NewProjBusinessProductDao(p.Tenant).TX(tx).Insert(products)
		if err != nil {
			return err
		}

		// 添加项目动态
		dynamics := model.ProjBusinessDynamics{
			BusId:   req.Id,
			OpnType: "20",
			Remark:  req.Remark,
		}
		err = p.CreateProjBusinessDynamics(tx, dynamics, req)
		return err
	})
	return
}

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

// BusinessTransfer 项目转移
func (p *businessService) BusinessTransfer(req *model.BusinessTransferReq) error {
	business, err := p.Dao.WherePri(req.Id).One()
	if err != nil {
		return err
	}
	if business == nil {
		return myerrors.NewMsgError(nil, "项目不存在")
	}
	businessMap := g.Map{
		p.Dao.Columns.SaleId:   req.UserId,
		p.Dao.Columns.SaleName: req.UserName,
		p.Dao.Columns.Remark:   req.Remark,
	}
	service.SetUpdatedInfo(businessMap, p.GetCxtUserId(), p.GetCxtUserName())

	opnContent := businessMap
	opnContent["origSaleId"] = business.SaleId
	opnContent["origSaleName"] = business.SaleName
	err = p.Dao.Transaction(context.TODO(), func(ctx context.Context, tx *gdb.TX) error {
		// 更新项目
		_, err = p.Dao.TX(tx).WherePri(projDao.ProjBusiness.Columns.Id, req.Id).Data(businessMap).Update()
		if err != nil {
			return err
		}
		// 添加项目动态
		dynamics := model.ProjBusinessDynamics{
			BusId:   req.Id,
			OpnType: "30",
			Remark:  req.Remark,
		}
		err = p.CreateProjBusinessDynamics(tx, dynamics, opnContent)
		return err
	})
	return err
}

// BusinessGradation 项目调级
func (p *businessService) BusinessGradation(req *model.BusinessGradationReq) error {
	business, err := p.Dao.Where(projDao.ProjBusiness.Columns.Id, req.Id).One()
	if err != nil {
		return err
	}
	if business == nil {
		return myerrors.NewMsgError(nil, "项目不存在")
	}
	if business.NboType == req.NboType {
		return myerrors.NewMsgError(nil, "同级无法进行调级。")
	}
	opnType := "40"
	opnContent := "项目升级 " + business.NboType + " => " + req.NboType
	// A < B return -1 项目降级
	if strings.Compare(business.NboType, req.NboType) < 0 {
		opnContent = "项目降级 " + business.NboType + " => " + req.NboType
		opnType = "50"
	}

	businessMap := g.Map{
		p.Dao.Columns.NboType: req.NboType,
	}
	service.SetUpdatedInfo(businessMap, p.GetCxtUserId(), p.GetCxtUserName())
	err = p.Dao.Transaction(context.TODO(), func(ctx context.Context, tx *gdb.TX) error {
		// 更新项目调级
		_, err = p.Dao.TX(tx).WherePri(projDao.ProjBusiness.Columns.Id, req.Id).Data(businessMap).Update()
		if err != nil {
			return err
		}
		// 添加项目动态
		dynamics := model.ProjBusinessDynamics{
			BusId:   business.Id,
			OpnType: opnType,
		}
		err = p.CreateProjBusinessDynamics(tx, dynamics, opnContent)
		return err
	})
	return err
}

// SetPrimacyContact 项目设置首要联系人
func (p *businessService) SetPrimacyContact(req *model.BusinessPrimacyContactReq) (err error) {
	business, err := p.Dao.Where(projDao.ProjBusiness.Columns.Id, req.Id).One()
	if err != nil {
		return err
	}
	if business == nil {
		return myerrors.NewMsgError(nil, "项目不存在")
	}
	businessMap := g.Map{
		p.Dao.Columns.ContactId:        req.ContactId,
		p.Dao.Columns.ContactName:      req.ContactName,
		p.Dao.Columns.ContactPostion:   req.ContactPostion,
		p.Dao.Columns.ContactTelephone: req.ContactTelephone,
	}
	service.SetUpdatedInfo(businessMap, p.GetCxtUserId(), p.GetCxtUserName())

	opnContent := businessMap
	opnContent["origContactId"] = business.ContactId
	opnContent["origContactName"] = business.ContactName
	opnContent["origContactPostion"] = business.ContactPostion
	opnContent["origContactTelephone"] = business.ContactTelephone
	err = p.Dao.Transaction(context.TODO(), func(ctx context.Context, tx *gdb.TX) error {
		// 更新项目
		_, err = p.Dao.TX(tx).WherePri(projDao.ProjBusiness.Columns.Id, req.Id).Data(businessMap).Update()
		if err != nil {
			return err
		}
		// 添加项目动态
		dynamics := model.ProjBusinessDynamics{
			BusId:   req.Id,
			OpnType: "60",
			Remark:  req.Remark,
		}
		err = p.CreateProjBusinessDynamics(tx, dynamics, opnContent)
		return err
	})
	return err
}

// CreateProjBusinessDynamics 创建项目动态
func (p *businessService) CreateProjBusinessDynamics(tx *gdb.TX, dynamics model.ProjBusinessDynamics, opnContent interface{}) error {
	if v, ok := opnContent.(g.Map); ok {
		opnContent = utils.MapKeySnakeCamelCase(v)
	}
	// 添加项目动态
	dynamics.OpnPeopleId = p.GetCxtUserId()
	dynamics.OpnPeople = p.GetCxtUserName()
	dynamics.OpnDate = gtime.Now()
	dynamics.OpnContent = gconv.String(opnContent)
	service.SetCreatedInfo(&dynamics, p.GetCxtUserId(), p.GetCxtUserName())
	_, err := projDao.NewProjBusinessDynamicsDao(p.Tenant).TX(tx).Insert(&dynamics)
	return err
}