归属记录添加开始结束时间字段

opms_parent/app/dao/cust/internal/cust_customer_belong.go

@@ -31,6 +31,8 @@ type custCustomerBelongColumns struct {
 	CustId       string // 关联客户
 	SalesName    string // 归属销售
 	OrigSaleName string // 原来归属
+	StartDate    string // 开始时间
+	EndDate      string // 结束时间
 	OpnType      string // 操作方式（10分配20转移）
 	OpnPeople    string // 操作人
 	OpnDatetime  string // 操作时间
@@ -55,6 +57,8 @@ var (
 			CustId:       "cust_id",
 			SalesName:    "sales_name",
 			OrigSaleName: "orig_sale_name",
+			StartDate:    "start_date",
+			EndDate:      "end_date",
 			OpnType:      "opn_type",
 			OpnPeople:    "opn_people",
 			OpnDatetime:  "opn_datetime",
@@ -81,6 +85,8 @@ func NewCustCustomerBelongDao(tenant string) CustCustomerBelongDao {
 			CustId:       "cust_id",
 			SalesName:    "sales_name",
 			OrigSaleName: "orig_sale_name",
+			StartDate:    "start_date",
+			EndDate:      "end_date",
 			OpnType:      "opn_type",
 			OpnPeople:    "opn_people",
 			OpnDatetime:  "opn_datetime",

opms_parent/app/handler/cust/customer.go

@@ -132,7 +132,7 @@ func (c *CustomerHeader) DeleteById(ctx context.Context, req *model.DelCustomer,
 }
 
 //GetCustNameIsExist 判断客户名称是否存在  bool
-func (c *CustomerHeader) GetCustNameIsExist(ctx context.Context, req *model.CustName, rsp *comm_def.CommonMsg) error {
+func (c *CustomerHeader) GetCustNameIsExist(ctx context.Context, req *model.IsExistsCustName, rsp *comm_def.CommonMsg) error {
 	if err := gvalid.CheckStruct(ctx, req, nil); err != nil {
 		return err
 	}
@@ -140,7 +140,7 @@ func (c *CustomerHeader) GetCustNameIsExist(ctx context.Context, req *model.Cust
 	if err != nil {
 		return err
 	}
-	exist, err := customerServer.GetCustNameIsExist(req.CustName)
+	exist, err := customerServer.GetCustNameIsExist(req)
 	_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
 	if err != nil {
 		return err

opms_parent/app/model/cust/cust_customer.go

@@ -105,15 +105,6 @@ type Follow struct {
 	DrawTotal       float64 `json "drawTotal"`       // 开票总额
 }
 
-// 转移客户参数
-type CustSalesReq struct {
-	Ids       []int64 `json:"ids,omitempty"`
-	SalesIds  int64   `json:"salesIds,omitempty"`
-	SalesName string  `json:"salesName,omitempty"`
-	Remark    string  `json:"remark,omitempty"`
-	Receive   string  `json:"receive,omitempty"` //有值领取 无值分配
-}
-
 // 分配 领取 转移 客户参数
 type AssignCustomerReq struct {
 	Ids       []int64 `json:"ids,omitempty"`       //客户id
@@ -154,6 +145,7 @@ type MoveToPubicRep struct {
 }
 
 // 客户名称
-type CustName struct {
-	CustName string `json:"custName"` // 客户名称
+type IsExistsCustName struct {
+	Id       int    `json:"id,omitempty"` //客户id
+	CustName string `json:"custName"`     // 客户名称
 }

opms_parent/app/model/cust/cust_customer_belong.go

@@ -17,27 +17,29 @@ type CustCustomerBelong internal.CustCustomerBelong
 // Fill with you ideas below.
 
 type CustomerBelongAddSeq struct {
-	CustId       int         `       json:"custId" v:"required#关联客户ID不能为空"` // 关联客户
-	SaleName     string      `      json:"saleName" v:"required#归属销售不能为空"`  // 归属销售
-	OrigSaleName string      `      json:"origSaleName"   `                 // 原来归属
-	OpnType      string      `      json:"opnType"`                         // 操作方式（10分配20转移）
-	OpnPeople    string      `      json:"opnPeople" `                      // 操作人
-	OpnDatetime  *gtime.Time `   json:"opnDatetime" `                       // 操作时间
+	CustId       int         `      json:"custId" v:"required#关联客户ID不能为空"`   // 关联客户
+	SaleName     string      `      json:"saleName" v:"required#归属销售不能为空"`   // 归属销售
+	OrigSaleName string      `      json:"origSaleName"   `                  // 原来归属
+	OpnType      string      `      json:"opnType"`                          // 操作方式（10分配20转移）
+	OpnPeople    string      `      json:"opnPeople" `                       // 操作人
+	StartDate    *gtime.Time `      json:""startDate" v:"required#开始时间不能为空"` //开始时间
+	OpnDatetime  *gtime.Time `   json:"opnDatetime" `                        // 操作时间
 }
 
 // 返回信息
 type CustomerBelongInfo struct {
 	CustId       int         `       json:"custId"`  // 关联客户
 	SaleName     string      `     json:"saleName"`  // 归属销售
-	OrigSaleName string      ` json:"origSaleName"`  // 原来归属
+	OrigSaleName string      `  json:"origSaleName"` // 原来归属
 	OpnType      string      `      json:"opnType"`  // 操作方式（10分配20转移）
 	OpnPeople    string      `     json:"opnPeople"` // 操作人
 	OpnDatetime  *gtime.Time `   json:"opnDatetime"` // 操作时间
 	Remark       string      `        json:"remark"` // 备注
 	CreatedBy    int         `     json:"createdBy"` // 创建者
 	CreatedName  string      `   json:"createdName"` // 创建人
-	CreatedTime  *gtime.Time `  json:"createdTime"`  // 创建时间
-
+	CreatedTime  *gtime.Time `   json:"createdTime"` // 创建时间
+	StartDate    *gtime.Time `   json:"startDate"`   // 开始时间
+	EndDate      *gtime.Time `   json:"endDate"`     // 结束时间
 }
 
 //列表操作

opms_parent/app/model/cust/internal/cust_customer_belong.go

@@ -14,6 +14,8 @@ type CustCustomerBelong struct {
 	CustId       int         `orm:"cust_id"        json:"custId"`       // 关联客户
 	SaleName     string      `orm:"sale_name"      json:"saleName"`     // 归属销售
 	OrigSaleName string      `orm:"orig_sale_name" json:"origSaleName"` // 原来归属
+	StartDate    *gtime.Time `orm:"start_date"     json:"start_date"`   // 开始时间
+	EndDate      *gtime.Time `orm:"end_date"       json:"end_date"`     // 结束时间
 	OpnType      string      `orm:"opn_type"       json:"opnType"`      // 操作方式（10分配20转移）
 	OpnPeople    string      `orm:"opn_people"     json:"opnPeople"`    // 操作人
 	OpnDatetime  *gtime.Time `orm:"opn_datetime"   json:"opnDatetime"`  // 操作时间

opms_parent/app/service/cust/cust_customer.go

@@ -7,6 +7,7 @@ import (
 	"math"
 	"strconv"
 
+	"github.com/gogf/gf/database/gdb"
 	"github.com/gogf/gf/encoding/gjson"
 
 	"dashoo.cn/opms_libary/myerrors"
@@ -142,8 +143,8 @@ func (s *CustomerService) Create(req *model.CustomerAddSeq) (insertId int64, err
 			g.Log().Error(err)
 			return 0, err
 		}
-		s.CreateBelong(int(insertId))
-
+		s.CreateBelong(gconv.Int(insertId))
+		return
 	} else {
 		cusTomer.IsPublic = isPublic
 		insertId, err = s.Dao.InsertAndGetId(cusTomer)
@@ -156,13 +157,12 @@ func (s *CustomerService) Create(req *model.CustomerAddSeq) (insertId int64, err
 }
 
 // CreateBelong 创建客户归属信息
-func (s *CustomerService) CreateBelong(custId int) (insertId int64, err error) {
+func (s *CustomerService) CreateBelong(custId int) (err error) {
 	belong := new(model.CustomerBelongAddSeq)
 	belong.CustId = custId
 	belong.SaleName = s.CxtUser.NickName
 	belong.OpnType = AllocaTion
 	belong.OpnPeople = s.CxtUser.NickName
-	belong.OpnDatetime = gtime.Now()
 	err = s.BelongServer.Create(belong)
 	if err != nil {
 		g.Log().Error(err)
@@ -252,24 +252,39 @@ func (s *CustomerService) MoveToPubic(Ids []int64) (err error) {
 		err = myerrors.NewMsgError(nil, "没有要移除的数据")
 		return
 	}
-
-	_, err = s.Dao.Data(g.Map{
-		"is_public":    isPublic,
-		"sales_id":     0,
-		"sales_name":   "",
-		"dept_id":      0,
-		"dept_name":    "",
-		"create_time":  gtime.Now(),
-		"updated_by":   s.GetCxtUserId(),
-		"updated_name": s.GetCxtUserName(),
-		"updated_time": gtime.Now(),
-	}).WhereIn(s.ContactDao.Columns.Id, Ids).Update()
-
-	if err != nil {
-		g.Log().Error(err)
-		return
-	}
-	return nil
+	userName := s.GetCxtUserName()
+	currentTime := gtime.Now()
+	s.Dao.Transaction(context.TODO(), func(ctx context.Context, tx *gdb.TX) error {
+		//更新客户信息
+		_, err = s.Dao.Data(g.Map{
+			"is_public":    isPublic,
+			"sales_id":     0,
+			"sales_name":   "",
+			"dept_id":      0,
+			"dept_name":    "",
+			"create_time":  currentTime,
+			"updated_by":   s.GetCxtUserId(),
+			"updated_name": userName,
+			"updated_time": currentTime,
+		}).WhereIn(s.ContactDao.Columns.Id, Ids).Update()
+		if err != nil {
+			g.Log().Error(err)
+			return err
+		}
+		//更新销售归属表结束时间
+		_, err = s.BelongDao.Data(
+			g.Map{
+				"updated_by":   s.GetCxtUserId(),
+				"updated_name": userName,
+				"end_date":     currentTime,
+			}).WhereIn(s.BelongDao.Columns.CustId, Ids).Update()
+		if err != nil {
+			g.Log().Error(err)
+			return err
+		}
+		return nil
+	})
+	return
 }
 
 // AssignCustomer 分配客户
@@ -289,14 +304,15 @@ func (s *CustomerService) AssignCustomer(req *model.AssignCustomerReq) (err erro
 		}
 	}
 
-	s.ChangeCustBelong(req.Ids, req.SalesId, req.SalesName)
-
+	err = s.ChangeCustBelong(req.Ids, req.SalesId, req.SalesName)
+	if err != nil {
+		return
+	}
 	if req.Receive != "" {
 		req.Receive = Receive
 	} else {
 		req.Receive = AllocaTion
 	}
-
 	s.BatchCreatebelong(data, req)
 	return
 }
@@ -312,9 +328,15 @@ func (s *CustomerService) GetEntityById(Ids []int64) (entityInfo []*model.CustLi
 	return
 }
 
-// GetCustNameIsExist 获取客户名称
-func (s *CustomerService) GetCustNameIsExist(name string) (exist bool, err error) {
-	count, err := s.Dao.Where(cust.CustCustomer.Columns.CustName, name).Count()
+// GetCustNameIsExist 判断客户名称是否存在
+func (s *CustomerService) GetCustNameIsExist(req *model.IsExistsCustName) (exist bool, err error) {
+	custDao := s.Dao.M
+	if req.Id > 0 {
+		custDao = custDao.Where("cust_name = ", req.CustName).WhereNot(" id ", req.Id)
+	} else {
+		custDao = custDao.Where("cust_name = ", req.CustName)
+	}
+	count, err := custDao.Count()
 	if err != nil {
 		g.Log().Error(err)
 		return
@@ -368,7 +390,12 @@ func (s *CustomerService) TransCustomer(req *model.AssignCustomerReq) (err error
 	if len(data) == 0 {
 		return myerrors.NewMsgError(nil, "数据不存在")
 	}
-	s.ChangeCustBelong(req.Ids, req.SalesId, req.SalesName)
+	err = s.ChangeCustBelong(req.Ids, req.SalesId, req.SalesName)
+	if err != nil {
+		g.Log().Error(err)
+		return
+	}
+	req.Receive = OperaTion
 	s.BatchCreatebelong(data, req)
 	return
 }
@@ -491,10 +518,20 @@ func (s *CustomerService) MergeCustomer(req *model.MergeCustomerRep) (err error)
 	}
 
 	//插入一条合并成功的归属记录
+	//更新销售归属表销售结束时间
+	_, err = s.BelongDao.Data(
+		g.Map{
+			"updated_by":   s.GetCxtUserId(),
+			"updated_name": s.GetCxtUserName(),
+			"end_date":     gtime.Now(),
+		}).WhereIn(s.BelongDao.Columns.CustId, req.Id).Update()
+	if err != nil {
+		g.Log().Error(err)
+		return
+	}
 	req.CustomerBelongAddSeq.CustId = int(req.Id)
 	req.CustomerBelongAddSeq.OpnType = Merge
 	req.CustomerBelongAddSeq.OpnPeople = s.GetCxtUserName()
-	req.CustomerBelongAddSeq.OpnDatetime = gtime.Now()
 	req.CustomerBelongAddSeq.OrigSaleName = customer.SalesName
 	req.CustomerBelongAddSeq.SaleName = req.SalesName
 	s.BelongServer.Create(req.CustomerBelongAddSeq)
@@ -514,6 +551,17 @@ func (s *CustomerService) Createcontact(Ids []int64, req *model.CustCustomerCont
 
 // BatchCreatebelong 批量插入客户归属记录表
 func (s *CustomerService) BatchCreatebelong(rep []*model.CustCustomer, req *model.AssignCustomerReq, n ...interface{}) (err error) {
+	//更新销售归属表销售结束时间
+	_, err = s.BelongDao.Data(
+		g.Map{
+			"updated_by":   s.GetCxtUserId(),
+			"updated_name": s.GetCxtUserName(),
+			"end_date":     gtime.Now(),
+		}).WhereIn(s.BelongDao.Columns.CustId, req.Ids).Update()
+	if err != nil {
+		g.Log().Error(err)
+		return
+	}
 	var belongData []*model.CustCustomerBelong
 	userName := s.GetCxtUserName()
 	for _, v := range rep {
@@ -525,6 +573,7 @@ func (s *CustomerService) BatchCreatebelong(rep []*model.CustCustomer, req *mode
 		belong.OpnType = req.Receive
 		belong.OpnPeople = userName
 		belong.CreatedName = userName
+		belong.StartDate = gtime.Now() //新增开始时间
 		belong.OpnDatetime = gtime.Now()
 		belong.Remark = req.Remark
 		belong.CreatedBy = s.GetCxtUserId()

opms_parent/app/service/cust/cust_customer_belong.go

@@ -4,6 +4,7 @@ import (
 	"context"
 
 	"github.com/gogf/gf/frame/g"
+	"github.com/gogf/gf/os/gtime"
 	"github.com/gogf/gf/util/gconv"
 
 	"dashoo.cn/micro/app/dao/cust"
@@ -32,7 +33,7 @@ func (s *CustomerbelongService) GetList(req *model.ReqCustomerBelongReq) (total
 		g.Log().Error(err)
 		return
 	}
-	total, err = s.Dao.Count()
+	total, err = s.Dao.Where("cust_id = ", req.CustId).Count()
 	if err != nil {
 		g.Log().Error(err)
 		return
@@ -48,6 +49,8 @@ func (s *CustomerbelongService) Create(req *model.CustomerBelongAddSeq) (err err
 		g.Log().Error(err)
 		return
 	}
+	cusTomerBelong.OpnDatetime = gtime.Now()
+	cusTomerBelong.StartDate = gtime.Now()
 	service.SetCreatedInfo(cusTomerBelong, s.GetCxtUserId(), s.GetCxtUserName())
 	_, err = s.Dao.Insert(cusTomerBelong)
 	if err != nil {
@@ -56,3 +59,5 @@ func (s *CustomerbelongService) Create(req *model.CustomerBelongAddSeq) (err err
 	}
 	return nil
 }
+
+//