opms_backend/opms_parent/app/service/cust/cust_customer.go

package cust

import (
	"bytes"
	"context"
	"math"
	"strconv"

	"dashoo.cn/opms_libary/myerrors"
	"github.com/360EntSecGroup-Skylar/excelize"
	"github.com/gogf/gf/errors/gerror"
	"github.com/gogf/gf/frame/g"
	"github.com/gogf/gf/os/gtime"
	"github.com/gogf/gf/text/gstr"
	"github.com/gogf/gf/util/gconv"

	"dashoo.cn/micro/app/dao/cust"
	platdao "dashoo.cn/micro/app/dao/plat"
	model "dashoo.cn/micro/app/model/cust"
	"dashoo.cn/micro/app/service"
)

const TIME_LAYOUT = "2006-01-02 15:04:05"

type CustomerService struct {
	*service.ContextService
	Dao            *cust.CustCustomerDao
	BelongDao      *cust.CustCustomerBelongDao
	DynamicsDao    *cust.CustCustomerDynamicsDao
	ContactDao     *cust.CustCustomerContactDao
	FollowDao      *platdao.PlatFollowupDao
	BelongServer   *CustomerbelongService
	ContanctServer *CustomercontactService
}

var isPublic, noPublic = "10", "20"                                // 公海,非公海
var isTransfer int8 = 1                                            //转移
var isAllocation int8 = 2                                          //分配 Allocation
var OperaTion, AllocaTion, Receive, Merge = "20", "10", "30", "40" // 10分配20转移30领取40合并

type OpnType struct {
	OperaTion string
}

func NewCustomerService(ctx context.Context) (svc *CustomerService, err error) {
	svc = new(CustomerService)
	if svc.ContextService, err = svc.Init(ctx); err != nil {
		return nil, err
	}
	svc.Dao = cust.NewCustCustomerDao(svc.Tenant)
	svc.BelongDao = cust.NewCustCustomerBelongDao(svc.Tenant)
	svc.DynamicsDao = cust.NewCustCustomerDynamicsDao(svc.Tenant)
	svc.ContactDao = cust.NewCustCustomerContactDao(svc.Tenant)
	svc.FollowDao = platdao.NewPlatFollowupDao(svc.Tenant)
	svc.BelongServer, _ = NewCustomerBelongService(ctx)
	svc.ContanctServer, _ = NewCustomerContactService(ctx)
	return svc, nil
}

//创建客户
func (c *CustomerService) Create(req *model.CustomerAddSeq) (insertId int64, err error) {
	cusTomer := new(model.CustCustomer)
	count, err := c.Dao.Where(g.Map{"cust_name": req.CustName}).Count()
	if err != nil {
		err = myerrors.New("Sql执行异常", err)
		return
	}
	if count > 0 {
		err = myerrors.NewMsgError(nil, "该客户信息已存在,不可重复添加")
		return
	}

	if err = gconv.Struct(req, cusTomer); err != nil {
		return
	}
	service.SetCreatedInfo(cusTomer, c.GetCxtUserId(), c.GetCxtUserName())
	cusTomer.CustCode = "CT" + strconv.Itoa(int(gtime.Timestamp()))
	cusTomer.CustStatus = "10"

	roles := c.GetCxtUserRoles()
	isSales := false
	for _, v := range roles {
		if v == "Sales" { // 销售角色
			isSales = true
		}
	}
	// 销售角色
	if isSales {
		cusTomer.IsPublic = noPublic
		cusTomer.SalesId = c.GetCxtUserId()
		cusTomer.SalesName = c.GetCxtUserName()
		insertId, err = c.Dao.InsertAndGetId(cusTomer)
		if err != nil {
			return
		}
		c.CreateContact(int(insertId))

	} else {
		cusTomer.IsPublic = isPublic
		insertId, err = c.Dao.InsertAndGetId(cusTomer)
		if err != nil {
			err = gerror.New("创建失败")
			return
		}
	}
	return
}
func (c *CustomerService) CreateContact(cust_id int) (err error) {

	belongData := new(model.CustCustomerBelong)
	service.SetCreatedInfo(belongData, c.GetCxtUserId(), c.GetCxtUserName())
	belongData.CustId = cust_id
	belongData.SaleName = c.GetCxtUserName()
	belongData.OpnType = AllocaTion
	belongData.OpnPeople = c.GetCxtUserName()
	belongData.OpnDatetime = gtime.Now()
	_, err = c.BelongDao.InsertAndGetId(belongData)
	if err != nil {

		return
	}
	return
}

//删除客户
func (c *CustomerService) DeleteById(id int) error {
	Model := c.Dao
	ContactModel := c.ContactDao //联系人
	BelongModel := c.BelongDao
	//regionDetail := new(model.CustCustomer)
	customerCount, err := Model.Where(c.Dao.Columns.Id, id).Count()
	if err != nil {
		return myerrors.New(" 删除客户 DeleteById Sql执行异常", err)
	}
	if customerCount == 0 {
		err = myerrors.NewMsgError(nil, "客户信息不存在")
		return err
	}

	//删除客户表
	_, err = Model.Where(c.Dao.Columns.Id, id).Delete()
	if err == nil {
		_, err = ContactModel.Where(c.ContactDao.Columns.CustId, id).Delete()
		if err == nil {
			_, err = BelongModel.Where(c.BelongDao.Columns.CustId, id).Delete()
			if err != nil {
				return myerrors.New(" 删除客户 BelongModel Sql执行异常", err)

			}
		} else {
			return myerrors.New(" 删除客户 ContactModel Sql执行异常", err)

		}
	} else {

		return myerrors.New(" 删除客户 ColumnsModel Sql执行异常", err)
	}
	return nil
}

//修改客户
func (c *CustomerService) UpdateById(req *model.UpdateCustomer) (err error) {
	db := c.Dao.M
	count, err := db.Where(c.Dao.Columns.Id, req.Id).Count()
	if err != nil {
		err = myerrors.New(" UpdateById Sql执行异常", err)
		return
	}
	if count == 0 {
		err = myerrors.NewMsgError(nil, "用户信息不存在")
		return
	}
	countNums, err := db.Where(c.Dao.Columns.CustName+" = ", req.CustName).Where(c.Dao.Columns.Id+" not in (?)", req.Id).Count()
	if err != nil {
		err = myerrors.New("  Sql执行异常", err)
		return
	}
	if countNums > 0 {
		err = myerrors.NewMsgError(nil, "客户名称已存在")
		return
	}

	CustomertData := new(model.CustomerAddSeq)
	if err = gconv.Struct(req, CustomertData); err != nil {
		return
	}
	service.SetUpdatedInfo(CustomertData, c.GetCxtUserId(), c.GetCxtUserName())
	_, err = db.FieldsEx(c.Dao.Columns.CreatedTime, c.Dao.Columns.CreatedBy, c.Dao.Columns.CreatedName, c.Dao.Columns.Id, c.Dao.Columns.CustCode, c.Dao.Columns.SalesName, c.Dao.Columns.SalesId).
		WherePri(c.Dao.Columns.Id, req.Id).Update(CustomertData)
	if err != nil {
		err = myerrors.New("修改用户信息失败", err)
		return
	}
	return
}

//客户列表列表
func (c *CustomerService) GetList(req *model.CustCustomerSearchReq) (total int, customerList []*model.CustList, err error) {
	Model := c.Dao.M
	if req.TargetType == "" {
		if !req.IsPublic {

			Model = Model.Where(c.Dao.Columns.SalesId, c.CxtUser.Id).Where(c.Dao.Columns.IsPublic, noPublic)
		} else {

			Model = Model.Where(c.Dao.Columns.IsPublic, isPublic)
		}
	}
	//客户名称
	if req.CustName != "" {
		Model = Model.Where(c.Dao.Columns.CustName+" like ?", "%"+req.CustName+"%")
	}
	//客户编码
	if req.CustCode != "" {
		Model = Model.Where(c.Dao.Columns.CustCode+" like ?", "%"+req.CustCode+"%")
	}
	//客户行业
	if req.CustIndustry != "" {
		Model = Model.Where(c.Dao.Columns.CustIndustry+" like ?", "%"+req.CustIndustry+"%")
	}
	//客户级别
	if req.CustLevel != "" {

		Model = Model.Where(c.Dao.Columns.CustLevel, req.CustLevel)
	}
	//
	if req.FollowUpDate != "" {
		Model = Model.Where(c.Dao.Columns.FollowUpDate+" like ? ", req.FollowUpDate+"%")
	}
	total, err = Model.Count()
	if err != nil {
		err = myerrors.New("获取总行数失败", err)

		return
	}

	err = Model.Page(req.GetPage()).Order("id desc").Scan(&customerList)
	if err != nil {
		err = myerrors.New("获取列表失败", err)
		return
	}
	for _, v := range customerList {
		times := gconv.String(v.CreatedTime)
		v.FollowUpDate = gstr.SubStr(v.FollowUpDate, 0, 16)
		v.CreatedTime = gstr.SubStr(times, 0, 16)
	}
	return
}

//移入公海
func (c *CustomerService) MoveToPubic(ids []int64) (err error) {
	Model := c.Dao
	columnsCount, err := Model.Fields(c.Dao.Columns.CreatedTime).Where(c.Dao.Columns.Id+" in (?) ", ids).Count()
	if err != nil {

		err = myerrors.New("MoveToPubic Sql 执行异常", err)
		return
	}
	if columnsCount == 0 {
		err = myerrors.NewMsgError(nil, "没有要移除的数据")
		return
	}

	_, err = Model.Data(g.Map{
		"is_public":    isPublic,
		"sales_id":     0,
		"sales_name":   "",
		"dept_id":      0,
		"dept_name":    "",
		"create_time":  gtime.Now(),
		"updated_by":   c.GetCxtUserId(),
		"updated_name": c.GetCxtUserName(),
		"updated_time": gtime.Now(),
	}).Where(c.ContactDao.Columns.Id+" in (?)", ids).Update()

	if err != nil {
		err = myerrors.New("MoveToPubic updateSql 执行异常", err)
		return
	}
	return nil
}

//分配客户
func (c *CustomerService) DistriCustomer(req *model.DistriCustomer) (err error) {
	custModel := c.Dao
	customerData, err := custModel.Where(cust.CustCustomer.Columns.Id+" in (?)  ", req.Ids).All()
	if err != nil {
		err = myerrors.New("DistriCustomer Sql执行异常", err)
		return
	}
	if len(customerData) == 0 {
		err = myerrors.NewMsgError(nil, "无可分配客户")
		return
	}
	var custMap = make(map[int]string)
	for _, v := range customerData {
		custMap[v.Id] = v.SalesName
	}
	for _, v := range req.Ids {
		g.Log().Info("req.Ids", v)
		if custMap[gconv.Int(v)] != "" {
			err = myerrors.NewMsgError(nil, "ID"+gconv.String(v)+"已被认领")
			return
		}
	}
	c.updateCustomer(req.Ids, req.SalesId, req.SalesName)
	//if err != nil {
	//	err = myerrors.New("DistriCustomer update Sql执行异常", err)
	//	return
	//
	//}
	if req.Receive != "" {
		req.Receive = Receive
	} else {
		req.Receive = AllocaTion
	}

	c.Createbelong(customerData, req)
	return
}

//客户详情
func (c *CustomerService) GetEntityById(ids []int64) (entityInfo []*model.CustList, err error) {
	Model := c.Dao //
	err = Model.Where(cust.CustCustomer.Columns.Id+" in (?)", ids).Scan(&entityInfo)
	if err != nil {
		return nil, myerrors.New("获取用户数据失败", err)

	}
	for _, v := range entityInfo {
		v.FollowUpDate = gstr.SubStr(v.FollowUpDate, 0, 16)
		v.CreatedTime = gstr.SubStr(v.CreatedTime, 0, 16)
	}

	return
}

//获取客户名称
func (c *CustomerService) GetCustNameIsExist(name string) (exist bool, err error) {
	Model := c.Dao //
	count, err := Model.Where(cust.CustCustomer.Columns.CustName, name).Count()
	if err != nil {
		err = myerrors.New("获取用户名称是否存在 GetCustName Sql执行异常", err)
		return
	}
	exist = false
	if count > 0 {
		exist = true
	}

	return
}

//客户摘要
func (c *CustomerService) CustAbstract(id int64) (followInfo *model.Follow, err error) {
	custModel := c.Dao //
	Model := c.FollowDao
	count, err := Model.Where(c.FollowDao.Columns.CustId, id).Count()
	if err != nil {
		return nil, myerrors.New(" CustAbstract Sql执行异常", err)
	}
	followInfo = new(model.Follow)
	followInfo.FollowCount = count
	followTime, err := custModel.Fields(c.Dao.Columns.FollowUpDate, c.Dao.Columns.CreatedTime).FindOne(id)
	if err != nil {
		err = myerrors.New("CustAbstract Sql执行错误", err)
		return
	}
	now := gtime.Now()
	var hours float64
	if followTime.FollowUpDate == nil {
		poor := now.Sub(gtime.New(followTime.CreatedTime))
		hours = float64(poor.Hours() / 24)
	} else {
		poor := now.Sub(gtime.New(followTime.FollowUpDate))
		hours = float64(poor.Hours() / 24)
	}
	if hours < 0 {
		followInfo.NotFollowDay = 0
	} else {
		followInfo.NotFollowDay = int(math.Floor(hours))
	}
	return
}

//转移客户
func (c *CustomerService) UpdateBytransfer(req *model.DistriCustomer) (err error) {
	custModel := c.Dao
	data, err := custModel.Fields("sales_id,sales_name,id").Where(cust.CustCustomer.Columns.Id+" in (?)", req.Ids).All()
	if err != nil {
		err = myerrors.New("Sql执行异常", err)
		return err
	}

	if len(data) == 0 {
		err = myerrors.New("该数据不存在", err)
		return
	}
	err = c.updateCustomer(req.Ids, req.SalesId, req.SalesName)
	if err != nil {
		return
	}
	err = c.Createbelong(data, req)
	if err != nil {
		return
	}
	return
}

//变更客户所属关系
func (c *CustomerService) updateCustomer(ids []int64, salesId int64, salesName string) error {
	custModel := c.Dao.M

	_, err := custModel.Data(g.Map{
		"sales_id":     salesId,
		"is_public":    noPublic,
		"sales_name":   salesName,
		"updated_by":   c.GetCxtUserId(),
		"updated_name": c.GetCxtUserName(),
		"updated_time": gtime.Now(),
	}).Where(cust.CustCustomer.Columns.Id+" in (?)", ids).Update()

	if err != nil {
		err = myerrors.New("updateCustomer 变更Sql执行失败", err)
		return err
	}
	return nil
}

//客户操作日志
func (c *CustomerService) OperationLog(ctx context.Context, ids []int64, req *model.AddCustomerDynameicsReq) (err error) {
	cusDynameics := new(model.CustCustomerDynamics)
	if err = gconv.Struct(req, cusDynameics); err != nil {
		err = myerrors.NewMsgError(nil, "操作日志验证结构体失败")
		return
	}
	Model := c.DynamicsDao.M
	g.Log().Info("IDS", ids)

	maps := []map[string]interface{}{}
	for _, v := range ids {
		contact := map[string]interface{}{}
		contact["cust_id"] = v
		contact["opn_people_id"] = c.GetCxtUserId()
		contact["opn_people"] = c.GetCxtUserName()
		contact["opn_date"] = req.OpnDate
		contact["opn_type"] = req.OpnType
		contact["remark"] = ""
		contact["created_by"] = c.GetCxtUserId()
		contact["created_name"] = c.GetCxtUserName()
		contact["created_by"] = c.GetCxtUserId()
		contact["created_time"] = gtime.Now()
		contact["opn_content"] = req.OpnContent
		maps = append(maps, contact)
	}
	lastId, err := Model.InsertAndGetId(maps)
	if err != nil {
		err = myerrors.New("OperationLog Sql执行失败", err)
		return
	}
	if lastId == 0 {
		err = myerrors.New("客户操作日志失败", err)
		return
	}
	return
}

//客户动态
func (c *CustomerService) DynamicsList(req *model.CustomerDynameicsReq) (total int, result []interface{}, err error) {
	Model := c.DynamicsDao
	total, err = Model.Where("cust_id = ", req.CustId).Count()
	if err != nil {
		err = myerrors.New("DynamicsList Sql执行异常", err)
		return
	}
	//if req.PageNum == 0 {
	//	req.PageNum = 1
	//}
	dynamics := []*model.CustomerDynameicsRep{}
	err = Model.Where("cust_id = ", req.CustId).Order("created_time desc").Scan(&dynamics)
	dynamicsList := make(map[string][]*model.CustomerDynameicsRep)

	for _, v := range dynamics {
		gt1 := gtime.New(v.OpnDate)
		opnDate := gt1.Format("Y-m-d")
		dynamicsList[opnDate] = append(dynamicsList[opnDate], &model.CustomerDynameicsRep{
			OpnPeople:  v.OpnPeople,
			OpnDate:    v.OpnDate,
			OpnType:    v.OpnType,
			OpnContent: v.OpnContent,
		})

	}
	result = append(result, dynamicsList)
	return
}

//合并客户
func (c *CustomerService) Mergecustomer(req *model.MergecustomerRep) (err error) {
	Model := c.Dao.M
	//ContactModel := c.ContactDao.M
	BelongDao := c.BelongDao
	//当前目标客户是否存在
	customerCount, err := Model.Where(c.Dao.Columns.Id, req.Id).Count()
	if err != nil {
		err = myerrors.New("Mergecustomer 合并客户 Sql执行异常", err)
		return
	}
	if customerCount == 0 {
		err = myerrors.NewMsgError(nil, "该客户不存在")
		return
	}
	ContactModel := c.ContactDao
	_, err = ContactModel.Where(c.ContactDao.Columns.CustId+" in (?)", req.ChooseId).WhereOr(c.ContactDao.Columns.CustId, req.Id).Delete()
	if err != nil {
		err = myerrors.New("Mergecustomer 合并联系人 Sql执行异常", err)
		return

	}
	CustomertData := new(model.CustomerAddSeq)
	if err = gconv.Struct(req, CustomertData); err != nil {
		return
	}
	service.SetUpdatedInfo(CustomertData, c.GetCxtUserId(), c.GetCxtUserName())
	_, err = Model.FieldsEx(c.Dao.Columns.CreatedTime, c.Dao.Columns.CreatedBy,
		c.Dao.Columns.CreatedName, c.Dao.Columns.Id,
		c.Dao.Columns.CustCode).WherePri(c.Dao.Columns.Id, req.Id).Update(CustomertData)
	if err != nil {
		err = myerrors.New("Mergecustomer 合并客户 update Sql执行异常", err)
		return
	}
	//删除被合并的客户信息
	_, err = Model.Where(c.Dao.Columns.Id+" in (?)", req.ChooseId).Delete()
	if err != nil {
		err = myerrors.New("Mergecustomer 删除被合并的客户信息 Sql执行异常", err)
		return
	}
	//删除 所选客户销售联系人
	_, err = BelongDao.Where(c.BelongDao.Columns.CustId+" in (?)", req.ChooseId).WhereOr(c.BelongDao.Columns.CustId, req.Id).Delete()
	if err != nil {
		err = myerrors.New("Mergecustomer 删除所选客户销售联系人 Sql执行异常", err)
		return
	}

	//插入一条合并成功的归属记录
	belongService := c.BelongServer //
	req.AddCustomerBelong.CustId = req.Id
	req.AddCustomerBelong.OpnType = Merge
	req.AddCustomerBelong.OpnPeople = c.GetCxtUserName()
	req.AddCustomerBelong.OpnDatetime = gtime.Now()
	req.AddCustomerBelong.SaleName = req.SalesName
	belongService.Create(req.AddCustomerBelong)
	return
}

//联系人（合并）
func (c *CustomerService) Createcontact(id int, Ids []int64, req *model.CustCustomerContactSeq) (err error) {
	ContactModel := c.ContactDao
	_, err = ContactModel.Where(c.ContactDao.Columns.CustId+" in (?)", Ids).WhereOr(c.ContactDao.Columns.CustId, id).Delete()
	if err != nil {
		err = myerrors.New("Createcontact  合并删除联系人 Sql执行异常", err)
		return
	}
	contactService := c.ContanctServer //new(CustomercontactService)
	err = contactService.Create(req)
	if err != nil {
		err = myerrors.New("Createcontact  合并删除并创建联系人 Sql执行异常", err)
		return
	}
	return
}

//批量插入客户归属记录表//parameter map[string]string
func (c *CustomerService) Createbelong(rep []*model.CustCustomer, req *model.DistriCustomer) (err error) {
	belongModel := c.BelongDao
	var belongData []*model.CustCustomerBelong
	date_time := gtime.Now()
	userName := c.GetCxtUserName()
	for _, v := range rep {
		orig_sale_name := v.SalesName
		belong := new(model.CustCustomerBelong) //map[string]interface{}{}
		belong.CustId = v.Id
		belong.SaleName = req.SalesName
		belong.OrigSaleName = orig_sale_name
		belong.OpnType = req.Receive
		belong.OpnPeople = userName
		belong.CreatedName = userName
		belong.OpnDatetime = date_time
		belong.Remark = req.Remark
		belong.CreatedBy = c.GetCxtUserId()
		belongData = append(belongData, belong)
	}
	lastId, err := belongModel.InsertAndGetId(belongData)
	g.Log().Info("belong", belongData)
	if err != nil {
		err = myerrors.New("Createbelong Sql执行异常", err)
		return err
	}
	if lastId == 0 {
		err = myerrors.New("Createbelong 插入", err)
		return err
	}
	return
}

//导出数据
func (c *CustomerService) Export(req *model.CustCustomerExport) (content *model.CustExport, err error) {
	var con model.CustExport
	total, data, err := c.GetList(&req.CustCustomerSearchReq)
	if err != nil {
		return
	}
	f := excelize.NewFile()
	index := f.NewSheet("Sheet1")
	for index, item := range req.Columns {
		sheetPosition := service.Div(index+1) + "1"
		f.SetCellValue("Sheet1", sheetPosition, item)
	}
	if total > 0 {

		for ck, item := range data {
			for index, v := range req.Columns {
				// "CustCode":客户编码
				if v == "客户编码" {
					f.SetCellValue("Sheet1", service.Div(index+1)+strconv.Itoa(ck+2), item.CustCode)
				}
				if v == "客户名称" {
					f.SetCellValue("Sheet1", service.Div(index+1)+strconv.Itoa(ck+2), item.CustName)
				}
				if v == "助记名" {
					f.SetCellValue("Sheet1", service.Div(index+1)+strconv.Itoa(ck+2), item.AbbrName)
				}
				if v == "助记名" {
					f.SetCellValue("Sheet1", service.Div(index+1)+strconv.Itoa(ck+2), item.AbbrName)
				}
				if v == "所在地区" {
					f.SetCellValue("Sheet1", service.Div(index+1)+strconv.Itoa(ck+2), item.CustLocation)
				}
				if v == "客户行业" {
					f.SetCellValue("Sheet1", service.Div(index+1)+strconv.Itoa(ck+2), item.CustIndustry)
				}
				if v == "客户级别" {
					f.SetCellValue("Sheet1", service.Div(index+1)+strconv.Itoa(ck+2), item.CustLevel)
				}
				if v == "客户状态" {
					var CustStatus string
					CustStatus = "正常"
					if item.CustStatus != "10" {
						CustStatus = "异常"
					}
					f.SetCellValue("Sheet1", service.Div(index+1)+strconv.Itoa(ck+2), CustStatus)
				}
				if v == "最后跟进时间" {
					f.SetCellValue("Sheet1", service.Div(index+1)+strconv.Itoa(ck+2), item.FollowUpDate)
				}
				if v == "创建时间" {
					f.SetCellValue("Sheet1", service.Div(index+1)+strconv.Itoa(ck+2), item.CreatedTime)
				}
			}

		}

	}
	f.SetActiveSheet(index)

	var buffer *bytes.Buffer
	buffer, _ = f.WriteToBuffer()
	con.Content = buffer.Bytes()

	return &con, err
}