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 }