基础模块

opms_parent/app/handler/base/distributor.go

@@ -24,7 +24,7 @@ func (p *DistributorHandler) GetList(ctx context.Context, req *model.BaseDistrib
 	total, list, err := distributorServer.GetList(req)
 	_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
 	if err != nil {
-		g.Log().Error(err)
+
 		return err
 	}
 	rsp.Data = g.Map{"list": list, "total": total}

opms_parent/app/handler/base/district.go

@@ -4,6 +4,7 @@ import (
 	"context"
 
 	"dashoo.cn/common_definition/comm_def"
+	"dashoo.cn/opms_libary/myerrors"
 	"github.com/gogf/gf/frame/g"
 
 	server "dashoo.cn/micro/app/service/base"
@@ -15,38 +16,44 @@ type DistrictHandler struct{}
 func (d *DistrictHandler) GetList(ctx context.Context, req *comm_def.IdReq, rsp *comm_def.CommonMsg) error {
 	districtServer, err := server.NewDistrictService(ctx)
 	if err != nil {
-		g.Log().Error(err)
 		return err
 	}
-	//list := districtServer.ListToRegions()
-	list := districtServer.ListToTree(req.Id)
-	g.Log().Info("ID", req.Id)
+	list, err := districtServer.ListToTree(req.Id)
+	_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
+	if err != nil {
+		return err
+	}
 	rsp.Data = g.Map{"list": list}
 	return nil
 }
 
-//区域下所有的省份
-func (d *DistrictHandler) GetRegionList(ctx context.Context, req *comm_def.IdReq, rsp *comm_def.CommonMsg) error {
+//GetRegionList 区域下所有的省份
+func (s *DistrictHandler) GetRegionList(ctx context.Context, req *comm_def.IdReq, rsp *comm_def.CommonMsg) error {
 	districtServer, err := server.NewDistrictService(ctx)
 	if err != nil {
-		g.Log().Error(err)
 		return err
 	}
-	list := districtServer.ListToRegions()
-	//list := districtServer.ListToTree(req.Id)
-	g.Log().Info("ID", req.Id)
+	list, err := districtServer.ListToRegions()
+	_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
+	if err != nil {
+		return err
+	}
+
 	rsp.Data = g.Map{"list": list}
 	return nil
 }
 
-//返回所有省份的
-func (d *DistrictHandler) GetProvinceInfo(ctx context.Context, null, rsp *comm_def.CommonMsg) error {
+// GetProvinceList 返回所有省份的
+func (d *DistrictHandler) GetProvinceList(ctx context.Context, null, rsp *comm_def.CommonMsg) error {
 	districtServer, err := server.NewDistrictService(ctx)
 	if err != nil {
-		g.Log().Error(err)
 		return err
 	}
-	list := districtServer.GetProvinceInfo()
+	list, err := districtServer.GetProvinceList()
+	_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
+	if err != nil {
+		return err
+	}
 	rsp.Data = g.Map{"list": list}
 	return nil
 }

opms_parent/app/handler/base/product.go

@@ -5,7 +5,6 @@ import (
 
 	"dashoo.cn/common_definition/comm_def"
 	"dashoo.cn/opms_libary/myerrors"
-	"github.com/gogf/gf/errors/gerror"
 	"github.com/gogf/gf/frame/g"
 	"github.com/gogf/gf/util/gvalid"
 
@@ -16,10 +15,9 @@ import (
 type ProductHandler struct{}
 
 // GetList 获取列表
-func (h *ProductHandler) GetList(ctx context.Context, req *model.ProductSearchReq, rsp *comm_def.CommonMsg) error {
+func (b *ProductHandler) GetList(ctx context.Context, req *model.ProductSearchReq, rsp *comm_def.CommonMsg) error {
 	s, err := server.NewProductService(ctx)
 	if err != nil {
-
 		return err
 	}
 	total, list, err := s.GetList(req)
@@ -33,34 +31,32 @@ func (h *ProductHandler) GetList(ctx context.Context, req *model.ProductSearchRe
 }
 
 // Create 添加产品信息
-func (h *ProductHandler) Create(ctx context.Context, req *model.AddProductReq, rsp *comm_def.CommonMsg) error {
+func (b *ProductHandler) Create(ctx context.Context, req *model.AddProductReq, rsp *comm_def.CommonMsg) error {
 	// 参数校验
 	if err := gvalid.CheckStruct(ctx, req, nil); err != nil {
 		return err
 	}
 	s, err := server.NewProductService(ctx)
 	if err != nil {
-		g.Log().Error(err)
 		return err
 	}
 	_, err = s.Create(req)
 	_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
 	if err != nil {
-		g.Log().Error(err)
 		return err
 	}
 	return nil
 }
 
 //DeleteByIds 批量删除数据
-func (h *ProductHandler) DeleteByIds(ctx context.Context, req *model.DeIds, rsp *comm_def.CommonMsg) error {
+func (b *ProductHandler) DeleteByIds(ctx context.Context, req *model.DeIds, rsp *comm_def.CommonMsg) error {
 	// 参数校验
 	if len(req.Ids) == 0 {
-		return gerror.New("参数为空,操作失败")
+		return myerrors.NewMsgError(nil, "参数为空,操作失败")
 	}
 	s, err := server.NewProductService(ctx)
 	if err != nil {
-		g.Log().Error(err)
+
 		return err
 	}
 	err = s.DeleteByIds(req.Ids)
@@ -73,20 +69,19 @@ func (h *ProductHandler) DeleteByIds(ctx context.Context, req *model.DeIds, rsp
 }
 
 // GetEntityById 根据ID查询详细信息
-func (h *ProductHandler) GetEntityById(ctx context.Context, req *comm_def.IdReq, rsp *comm_def.CommonMsg) error {
+func (b *ProductHandler) GetEntityById(ctx context.Context, req *comm_def.IdReq, rsp *comm_def.CommonMsg) error {
 	// 参数校验
 	if req.Id == 0 {
-		return gerror.New("参数有误!")
+		return myerrors.NewMsgError(nil, "参数有误")
 	}
 	s, err := server.NewProductService(ctx)
 	if err != nil {
-		g.Log().Error(err)
 		return err
 	}
 	product, err := s.GetEntityById(req.Id)
 	_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
 	if err != nil {
-		g.Log().Error(err)
+
 		return err
 	}
 	rsp.Data = product
@@ -94,16 +89,16 @@ func (h *ProductHandler) GetEntityById(ctx context.Context, req *comm_def.IdReq,
 }
 
 //UpdateById 更新信息
-func (h *ProductHandler) UpdateById(ctx context.Context, req *model.UpdateProductReq, rsp *comm_def.CommonMsg) error {
+func (b *ProductHandler) UpdateById(ctx context.Context, req *model.UpdateProductReq, rsp *comm_def.CommonMsg) error {
 	s, err := server.NewProductService(ctx)
 	if err != nil {
-		g.Log().Error(err)
+
 		return err
 	}
 	err = s.UpdateById(req)
 	_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
 	if err != nil {
-		g.Log().Error(err)
+
 		return err
 	}
 	return nil

opms_parent/app/handler/base/region.go

@@ -19,30 +19,28 @@ type RegionHandler struct{}
 func (r *RegionHandler) GetList(ctx context.Context, req *model.SecBaseRegionDetailReq, rsp *comm_def.CommonMsg) error {
 	regionServer, err := server.NewSalesRegionDetailService(ctx)
 	if err != nil {
-		g.Log().Error(err)
+
 		return err
 	}
 	total, list, err := regionServer.GetList(req)
 	_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
 	if err != nil {
-		g.Log().Error(err)
+
 		return err
 	}
-	g.Log().Info("qr3r3", list)
+
 	rsp.Data = g.Map{"list": list, "total": total}
 	return nil
 }
 
 //创建区域
 func (r *RegionHandler) Create(ctx context.Context, req *model.AddBaseRegionDetailReq, rsp *comm_def.CommonMsg) error {
-	g.Log().Info("参数", req)
 
 	if err := gvalid.CheckStruct(ctx, req, nil); err != nil {
 		return err
 	}
 	productServer, err := server.NewSalesRegionDetailService(ctx)
 	if err != nil {
-		g.Log().Error(err)
 		return err
 	}
 	err = productServer.Create(req)
@@ -58,11 +56,16 @@ func (r *RegionHandler) Create(ctx context.Context, req *model.AddBaseRegionDeta
 func (p *RegionHandler) GetRegion(ctx context.Context, null, rsp *comm_def.CommonMsg) error {
 	regionServer, err := server.NewSalesRegionService(ctx)
 	if err != nil {
-		g.Log().Error(err)
+
+		return err
+	}
+	list, err := regionServer.GetListRegion()
+	_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
+	if err != nil {
+
 		return err
 	}
-	list := regionServer.GetListRegion()
-	g.Log().Info("region", list)
+
 	rsp.Data = g.Map{"list": list}
 	return nil
 }
@@ -71,7 +74,7 @@ func (p *RegionHandler) GetRegion(ctx context.Context, null, rsp *comm_def.Commo
 func (p *RegionHandler) UpdateById(ctx context.Context, req *model.UpdateBaseRegionDetailReq, rsp *comm_def.CommonMsg) error {
 	regionServer, err := server.NewSalesRegionDetailService(ctx)
 	if err != nil {
-		g.Log().Error(err)
+
 		return gerror.New("系统异常，请重新尝试")
 	}
 	err = regionServer.UpdateById(req)
@@ -103,14 +106,13 @@ func (p *RegionHandler) CreateRegion(ctx context.Context, req *model.AddRegionRe
 func (p *RegionHandler) DeleteByIds(ctx context.Context, req *model.DeleteBaseRegionDetailReq, rsp *comm_def.CommonMsg) error {
 	regionDetailServer, err := server.NewSalesRegionDetailService(ctx)
 	if err != nil {
-		g.Log().Error(err)
 		return err
 	}
-	err = regionDetailServer.DeleteById(req.Ids)
-	g.Log().Info("req", req)
+	err = regionDetailServer.DeleteByIds(req.Ids)
+
 	_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
 	if err != nil {
-		g.Log().Error(err)
+
 		return err
 	}
 	return nil

opms_parent/app/handler/cust/contant.go

@@ -6,7 +6,6 @@ import (
 	"dashoo.cn/common_definition/comm_def"
 	"dashoo.cn/opms_libary/myerrors"
 	"github.com/gogf/gf/frame/g"
-	"github.com/gogf/gf/os/gtime"
 	"github.com/gogf/gf/util/gconv"
 	"github.com/gogf/gf/util/gvalid"
 
@@ -16,12 +15,6 @@ import (
 
 type CustomerContantHeader struct{}
 
-const (
-	ContantCreate     = "创建联系人"
-	ContantUpdateById = "修改联系人"
-	ContantDeleteById = "删除联系人"
-)
-
 //Create 创建客户联系人
 func (c *CustomerContantHeader) Create(ctx context.Context, req *model.CustCustomerContactSeq, rsp *comm_def.CommonMsg) error {
 	if err := gvalid.CheckStruct(ctx, req, nil); err != nil {
@@ -38,10 +31,9 @@ func (c *CustomerContantHeader) Create(ctx context.Context, req *model.CustCusto
 
 		return err
 	}
-	var Ids []int64
-	Ids = append(Ids, gconv.Int64(req.CustId))
-	c.OperationLog(ctx, ContantCreate, Ids, req)
 
+	s, err := server.NewCustomerService(ctx)
+	s.CreateDynamics("创建联系人", req, gconv.Int64(req.CustId))
 	return nil
 }
 
@@ -59,9 +51,8 @@ func (c *CustomerContantHeader) UpdateById(ctx context.Context, req *model.Updat
 	if err != nil {
 		return err
 	}
-	var Ids []int64
-	Ids = append(Ids, gconv.Int64(req.CustId))
-	c.OperationLog(ctx, ContantUpdateById, Ids, req)
+	s, err := server.NewCustomerService(ctx)
+	s.CreateDynamics("修改联系人", req, gconv.Int64(req.CustId))
 	return nil
 }
 
@@ -98,18 +89,7 @@ func (c *CustomerContantHeader) DeleteById(ctx context.Context, req *model.DelCu
 		return err
 	}
 	//删除联系人 记录客户Id
-	var Ids []int64
-	Ids = append(Ids, gconv.Int64(req.CustId))
-	c.OperationLog(ctx, ContantDeleteById, Ids, req)
+	s, err := server.NewCustomerService(ctx)
+	s.CreateDynamics("删除联系人", req, gconv.Int64(req.CustId))
 	return nil
 }
-
-//OperationLog 操作日志
-func (c *CustomerContantHeader) OperationLog(ctx context.Context, custType string, Id []int64, req interface{}) {
-	CustomerService, _ := server.NewCustomerService(ctx)
-	custDynameics := new(model.AddCustomerDynameicsReq)
-	custDynameics.OpnType = custType
-	custDynameics.OpnDate = gtime.Now()
-	custDynameics.OpnContent = req
-	CustomerService.OperationLog(ctx, Id, custDynameics)
-}

opms_parent/app/handler/cust/customer.go

@@ -6,8 +6,6 @@ import (
 	"dashoo.cn/common_definition/comm_def"
 	"dashoo.cn/opms_libary/myerrors"
 	"github.com/gogf/gf/frame/g"
-	"github.com/gogf/gf/os/gtime"
-	"github.com/gogf/gf/util/gconv"
 	"github.com/gogf/gf/util/gvalid"
 
 	model "dashoo.cn/micro/app/model/cust"
@@ -18,60 +16,80 @@ type CustomerHeader struct{}
 
 var isPublic, noPublic = "10", "20" // 公海,非公海
 var noCustomer = true               // 区分公海列表 和 客户列表 true  公海
-const (
-	Creates          = "创建客户"
-	UpdateBytransfer = "转移客户"
-	DistriCustomer   = "分配客户"
-	DeleteById       = "删除客户"
-	MoveToPubic      = "移入公海"
-	Mergecustomer    = "合并客户"
-	UpdateById       = "修改客户"
-	Receive          = "领取"
-)
+
+//GetList 客户列表
+func (c *CustomerHeader) GetList(ctx context.Context, req *model.CustCustomerSearchReq, rsp *comm_def.CommonMsg) error {
+	customerServer, err := server.NewCustomerService(ctx)
+	if err != nil {
+		return err
+	}
+	total, list, err := customerServer.GetList(req)
+	_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
+	if err != nil {
+		return err
+	}
+	rsp.Data = g.Map{"list": list, "total": total}
+	return nil
+
+}
+
+//PublicGetList 公海列表
+func (c *CustomerHeader) PublicGetList(ctx context.Context, req *model.CustCustomerSearchReq, rsp *comm_def.CommonMsg) error {
+	customerServer, err := server.NewCustomerService(ctx)
+	if err != nil {
+
+		return err
+	}
+
+	req.IsPublic = noCustomer
+
+	total, list, err := customerServer.GetList(req)
+	_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
+	if err != nil {
+
+		return err
+	}
+	rsp.Data = g.Map{"list": list, "total": total}
+	return nil
+
+}
 
 //Create 创建客户
 func (c *CustomerHeader) Create(ctx context.Context, req *model.CustomerAddSeq, rsp *comm_def.CommonMsg) error {
-
 	if err := gvalid.CheckStruct(ctx, req, nil); err != nil {
 		return err
 	}
-	customerServer, err := server.NewCustomerService(ctx)
+	s, err := server.NewCustomerService(ctx)
 	if err != nil {
 
 		return err
 
 	}
-	id, err := customerServer.Create(req)
+	id, err := s.Create(req)
 	_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
 	if err != nil {
 
 		return err
 	}
-	var Ids []int64
-	Ids = append(Ids, gconv.Int64(id))
-	//创建客户
-	c.OperationLog(ctx, Creates, Ids, req)
+	s.CreateDynamics("创建客户", req, id)
 	rsp.Data = g.Map{"lastId": id}
 	return nil
 }
 
 //UpdateById 修改客户
 func (c *CustomerHeader) UpdateById(ctx context.Context, req *model.UpdateCustomer, rsp *comm_def.CommonMsg) error {
-
-	customerServer, err := server.NewCustomerService(ctx)
+	s, err := server.NewCustomerService(ctx)
 	if err != nil {
 
 		return err
 	}
-	err = customerServer.UpdateById(req)
+	err = s.UpdateById(req)
 	_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
 	if err != nil {
 
 		return err
 	}
-	var Ids []int64
-	Ids = append(Ids, gconv.Int64(req.Id))
-	c.OperationLog(ctx, UpdateById, Ids, req)
+	s.CreateDynamics("编辑客户", req, req.Id)
 	return nil
 }
 
@@ -99,17 +117,17 @@ func (c *CustomerHeader) DeleteById(ctx context.Context, req *model.DelCustomer,
 	if len(req.Ids) == 0 {
 		return myerrors.NewMsgError(nil, "参数有误")
 	}
-	customerServer, err := server.NewCustomerService(ctx)
+	s, err := server.NewCustomerService(ctx)
 	if err != nil {
 		return err
 	}
-	err = customerServer.DeleteByIds(req.Ids)
+	err = s.DeleteByIds(req.Ids)
 	_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
 	if err != nil {
 		return err
 	}
 	//删除客户
-	c.OperationLog(ctx, DeleteById, req.Ids, req)
+	s.CreateDynamics("删除客户", req, req.Ids...)
 	return nil
 }
 
@@ -131,85 +149,47 @@ func (c *CustomerHeader) GetCustNameIsExist(ctx context.Context, req *model.Cust
 	return nil
 }
 
-//PublicGetList 公海列表
-func (c *CustomerHeader) PublicGetList(ctx context.Context, req *model.CustCustomerSearchReq, rsp *comm_def.CommonMsg) error {
-	customerServer, err := server.NewCustomerService(ctx)
-	if err != nil {
-
-		return err
-	}
-
-	req.IsPublic = noCustomer
-
-	total, list, err := customerServer.GetList(req)
-	_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
-	if err != nil {
-
-		return err
-	}
-	rsp.Data = g.Map{"list": list, "total": total}
-	return nil
-
-}
-
-//GetList 客户列表
-func (c *CustomerHeader) GetList(ctx context.Context, req *model.CustCustomerSearchReq, rsp *comm_def.CommonMsg) error {
-	customerServer, err := server.NewCustomerService(ctx)
-	if err != nil {
-		return err
-	}
-	total, list, err := customerServer.GetList(req)
-	_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
-	if err != nil {
-		return err
-	}
-	rsp.Data = g.Map{"list": list, "total": total}
-	return nil
-
-}
-
 //TransCustomer 转移客户
 func (c *CustomerHeader) TransCustomer(ctx context.Context, req *model.AssignCustomerReq, rsp *comm_def.CommonMsg) error {
 	if len(req.Ids) == 0 || req.SalesId == 0 {
 		return myerrors.NewMsgError(nil, "参数有误")
 	}
-	customerServer, err := server.NewCustomerService(ctx)
+	s, err := server.NewCustomerService(ctx)
 	if err != nil {
 		return err
 	}
-	err = customerServer.TransCustomer(req)
+	err = s.TransCustomer(req)
 	_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
 	if err != nil {
 		return err
 	}
-	var Ids []int64
-	Ids = append(Ids, gconv.Int64(req.Ids))
+
 	//转移客户
-	c.OperationLog(ctx, UpdateBytransfer, Ids, req)
+	s.CreateDynamics("转移客户", req, req.Ids...)
 	return nil
 }
 
-//AssignCustomer 分配客户
+//AssignCustomer 分配,领取客户
 func (c *CustomerHeader) AssignCustomer(ctx context.Context, req *model.AssignCustomerReq, rsp *comm_def.CommonMsg) error {
 	if len(req.Ids) == 0 || req.SalesId == 0 {
 		return myerrors.NewMsgError(nil, "参数有误")
 	}
-	customerServer, err := server.NewCustomerService(ctx)
-	if err != nil {
-		return err
-	}
-	err = customerServer.AssignCustomer(req)
-	_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
+	s, err := server.NewCustomerService(ctx)
 	if err != nil {
 		return err
 	}
 	var behavior string
 	if req.Receive == "" {
-		behavior = DistriCustomer
+		behavior = "分配客户"
 	} else {
-		behavior = Receive
+		behavior = "领取"
+	}
+	err = s.AssignCustomer(req)
+	_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
+	if err != nil {
+		return err
 	}
-	c.OperationLog(ctx, behavior, req.Ids, req)
+	s.CreateDynamics(behavior, req, req.Ids...)
 	return nil
 
 }
@@ -219,11 +199,11 @@ func (c *CustomerHeader) MoveToPubic(ctx context.Context, req *model.MoveToPubic
 	if len(req.Ids) == 0 {
 		return myerrors.NewMsgError(nil, "参数有误")
 	}
-	customerServer, err := server.NewCustomerService(ctx)
+	s, err := server.NewCustomerService(ctx)
 	if err != nil {
 		return err
 	}
-	err = customerServer.MoveToPubic(req.Ids)
+	err = s.MoveToPubic(req.Ids)
 	_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
 	if err != nil {
 
@@ -232,8 +212,7 @@ func (c *CustomerHeader) MoveToPubic(ctx context.Context, req *model.MoveToPubic
 	if req.Remark == "" {
 		req.Remark = ""
 	}
-	c.OperationLog(ctx, MoveToPubic, req.Ids, req)
-
+	s.CreateDynamics("移入公海", req, req.Ids...)
 	return nil
 }
 
@@ -253,27 +232,26 @@ func (c *CustomerHeader) GetDynamicsList(ctx context.Context, req *model.Custome
 }
 
 //MergeCustomer 合并客户
-func (c *CustomerHeader) MergeCustomer(ctx context.Context, req *model.MergecustomerRep, rsp *comm_def.CommonMsg) error {
+func (c *CustomerHeader) MergeCustomer(ctx context.Context, req *model.MergeCustomerRep, rsp *comm_def.CommonMsg) error {
 	if err := gvalid.CheckStruct(ctx, req, nil); err != nil {
 		return err
 	}
-	customerServer, err := server.NewCustomerService(ctx)
+	s, err := server.NewCustomerService(ctx)
 	if err != nil {
 		return err
 	}
-	err = customerServer.MergeCustomer(req)
+	err = s.MergeCustomer(req)
 	_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
 	if err != nil {
 		return err
 	}
-	var Ids []int64
-	Ids = append(Ids, gconv.Int64(req.Id))
-	c.OperationLog(ctx, Mergecustomer, Ids, req)
+
+	s.CreateDynamics("合并客户", req, req.Id)
 	return nil
 }
 
-//CustAbstract 客户摘要
-func (c *CustomerHeader) CustAbstract(ctx context.Context, req *comm_def.IdReq, rsp *comm_def.CommonMsg) error {
+//GetCustAbstract 客户摘要
+func (c *CustomerHeader) GetCustAbstract(ctx context.Context, req *comm_def.IdReq, rsp *comm_def.CommonMsg) error {
 	if req.Id == 0 {
 		return myerrors.NewMsgError(nil, "参数有误")
 	}
@@ -290,18 +268,8 @@ func (c *CustomerHeader) CustAbstract(ctx context.Context, req *comm_def.IdReq,
 	return nil
 }
 
-//OperationLog 操作日志
-func (c *CustomerHeader) OperationLog(ctx context.Context, custType string, custId []int64, req interface{}) {
-	CustomerService, _ := server.NewCustomerService(ctx)
-	custDynameics := new(model.AddCustomerDynameicsReq)
-	custDynameics.OpnDate = gtime.Now()
-	custDynameics.OpnType = custType
-	custDynameics.OpnContent = req
-	CustomerService.OperationLog(ctx, custId, custDynameics)
-}
-
-//DeriveList 导出
-func (c *CustomerHeader) DeriveList(ctx context.Context, req *model.CustCustomerExport, rsp *comm_def.CommonMsg) error {
+//Export 导出
+func (c *CustomerHeader) Export(ctx context.Context, req *model.CustCustomerExport, rsp *comm_def.CommonMsg) error {
 	customerServer, err := server.NewCustomerService(ctx)
 	if err != nil {
 		return err

opms_parent/app/model/base/base_distributor.go

@@ -64,7 +64,7 @@ type UpdateDistributorReq struct {
 
 //删除
 type DeleteDistributorReq struct {
-	Ids int `p:"id" json:"ids" v:"required# id不能为空"`
+	Ids []int64 `p:"id" json:"ids" v:"required# id不能为空"`
 }
 type Contanct struct {
 	Name string `json:"name"` // 销售名

opms_parent/app/model/base/base_product.go

@@ -16,8 +16,9 @@ type BaseProduct internal.BaseProduct
 // Fill with you ideas below.
 
 type ProductSearchReq struct {
-	ProdCode string `json:"prodCode"`
-	ProdName string `json:"prodName"`
+	ProdCode  string `json:"prodCode"`
+	ProdName  string `json:"prodName"`
+	ProdClass string `json:"ProdClass"`
 	request.PageReq
 }
 

opms_parent/app/model/base/base_sales_region_detail.go

@@ -55,5 +55,9 @@ type BaseRegionCustomer struct {
 	Count        int    `p:"count"         json:"count"   `
 }
 type DeleteBaseRegionDetailReq struct {
-	Ids int `json:"ids" v:"required# id不能为空"`
+	Ids []int64 `json:"ids" v:"required# id不能为空"`
+}
+type BaseRegionCountNum struct {
+	//cust_dist_code
+	Count int `p:"count"         json:"count"   `
 }

opms_parent/app/model/cust/cust_customer.go

@@ -15,7 +15,9 @@ import (
 type CustCustomer internal.CustCustomer
 
 // Fill with you ideas below.
-// 列表搜索参数
+
+//CustCustomerSearchReq 列表搜索参数
+
 type CustCustomerSearchReq struct {
 	IsPublic     bool   `json:"isPublic,omitempty"` //区分是否是公海用户列表
 	CustCode     string `json:"custCode"`
@@ -29,8 +31,7 @@ type CustCustomerSearchReq struct {
 	request.PageReq
 }
 
-//导出参数
-
+//CustCustomerExport 导出参数
 type CustCustomerExport struct {
 	CustCustomerSearchReq
 	Columns []string `json:"columns"` // 导出列
@@ -43,24 +44,18 @@ type CustExport struct {
 	Content []byte `json:"content"` // 导出数据流
 }
 
-// 添加客户信息表
-type AddCustCustomerReq struct {
-	Cust *CustomerAddSeq
-	Info *Information
-}
-
-// 单表添加客户信息表
+//CustomerAddSeq 单表添加客户信息表
 type CustomerAddSeq struct {
-	CustName     string      `p:"custName"        json:"custName"   v:"required#客户名称不能为空"`
+	CustName     string      `p:"custName"        json:"custName"      v:"required#客户名称不能为空"`
 	AbbrName     string      `p:"abbrName"        json:"abbrName"   `                         // 助计名
 	CustLocation string      `p:"custLocation"    json:"custLocation"    `                    // 所在地区
 	CustAddress  string      `p:"custAddress"     json:"custAddress"   `                      // 详细地址
-	FollowUpDate *gtime.Time `p:"followUpDate"     json:"followUpDate"   `                    //跟进时间
-	CustIndustry string      `p:"custIndustry"     json:"custIndustry" v:"required#客户行业不能为空"` //客户行业
-	CustLevel    string      `p:"custLevel"     json:"custLevel"       v:"required#客户级别不能为空"` //客户级别
-	CustSource   string      `p:"custSource"     json:"source"       v:"required#客户来源不能为空"`   //客户级别
-	CustDistCode int         `p:"custDistCode" json:"custDistCode"  v:"required#省份不能为空" `     // 省份Id
-	Remark       string      `p:"remark" json:"remark""`                                      //备注
+	FollowUpDate *gtime.Time `p:"followUpDate"    json:"followUpDate"   `                     //跟进时间
+	CustIndustry string      `p:"custIndustry"    json:"custIndustry"  v:"required#客户行业不能为空"` //客户行业
+	CustLevel    string      `p:"custLevel"       json:"custLevel"     v:"required#客户级别不能为空"` //客户级别
+	CustSource   string      `p:"custSource"      json:"source"        v:"required#客户来源不能为空"` //客户级别
+	CustDistCode int         `p:"custDistCode"    json:"custDistCode"  v:"required#省份不能为空" `  // 省份Id
+	Remark       string      `p:"remark"          json:"remark""`                             //备注
 	SalesName    string      `p:"salesName"       json:"salesName"   `                        //
 	SalesId      int         `p:"salesId"         json:"salesId"   `                          //
 }
@@ -75,7 +70,8 @@ type Information struct {
 	Remark     string `p:"remark"      json:"remark"   `                                     // 备注
 }
 
-// 返回信息
+//返回信息
+
 type CustList struct {
 	Id           int    `orm:"id,primary"     json:"id"`           // 主键
 	CustCode     string `orm:"cust_code"      json:"custCode"`     // 客户编号
@@ -138,17 +134,16 @@ type DelCustomerContact struct {
 }
 
 // 合并客户参数
-type MergecustomerRep struct {
-	Id int `json:"id"` //目标Id
+type MergeCustomerRep struct {
+	Id int64 `json:"id"` //目标Id
 	*CustomerAddSeq
-	//*CustCustomerContactSeq
 	*CustomerBelongAddSeq
 	ChooseId []int64 `json:"chooseId,omitempty"` //被合并的客户id
 }
 
-// 修改客户
+//UpdateCustomer 修改客户
 type UpdateCustomer struct {
-	Id int `json:"id,omitempty"` //客户id
+	Id int64 `json:"id,omitempty"` //客户id
 	*CustomerAddSeq
 }
 

opms_parent/app/model/cust/cust_customer_dynamics.go

@@ -25,6 +25,7 @@ type AddCustomerDynameicsReq struct {
 	Remark      string      `json:"remark"`       //备注
 	OpnContent  interface{} ` json:"opnContent"`  // 操作内容
 }
+
 type CustomerDynameicsReq struct {
 	CustId int `    json:"custId"` // 客户Id
 	//request.PageReq

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

@@ -12,7 +12,7 @@ import (
 type CustCustomerDynamics struct {
 	Id          int         `orm:"id,primary"    json:"id"`          // 主键
 	OpnPeopleId int         `orm:"opn_people_id" json:"opnPeopleId"` // 操作人ID
-	CustId      int         `orm:"cust_id" json:"custId"`            // 客户ID
+	CustId      int         `orm:"cust_id"       json:"custId"`      // 客户ID
 	OpnPeople   string      `orm:"opn_people"    json:"opnPeople"`   // 操作人
 	OpnDate     *gtime.Time `orm:"opn_date"      json:"opnDate"`     // 操作日期
 	OpnType     string      `orm:"opn_type"      json:"opnType"`     // 操作类型

opms_parent/app/model/plat/plat_task.go

@@ -83,9 +83,9 @@ type ExportContent struct {
 
 // 督办处理接口
 type HandleReq struct {
-	TaskId       int    				`json:"taskId|min:1"  v:"required#任务Id不能为空|任务Id不能为空"`
+	TaskId       int    				`json:"taskId"  v:"required|min:1#任务Id不能为空|任务Id不能为空"`
 	Step         int    				`json:"step"    v:"required|min:10#步骤不能为空|步骤不能为空"` // 步骤号（10接收  15暂存  20提交  30审批（督办人）  40评价（监办人））
-	HandleStatus string 				`json:"handleStatus"  v:"required#处理结果不能为空"`
+	HandleStatus string 				`json:"handleStatus" `   // 处理结果（10接收20提交30审批通过40审批退回）
 	HandleDesc   string  				`json:"handleDesc"`
 	ProgressList []*PlatTaskProgress    `json:"progressList"`
 }

opms_parent/app/service/base/base_distributor.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"strconv"
 
+	"dashoo.cn/opms_libary/myerrors"
 	"github.com/gogf/gf/errors/gerror"
 	"github.com/gogf/gf/frame/g"
 	"github.com/gogf/gf/os/gtime"
@@ -31,21 +32,20 @@ func NewDistributorService(ctx context.Context) (svc *distributorService, err er
 	return svc, nil
 }
 
-//经销商信息列表
-func (d *distributorService) GetList(req *model.BaseDistributorSearchReq) (total int, distributorList []*model.DistributorRonp, err error) {
-	distributorModel := d.Dao.M
-	distributorModel = distributorModel.Where(d.Dao.Columns.DeletedTime + " is null")
+//GetList 经销商信息列表
+func (s *distributorService) GetList(req *model.BaseDistributorSearchReq) (total int, distributorList []*model.DistributorRonp, err error) {
+	distributorModel := s.Dao.M
 	if req.DistCode != "" {
-		distributorModel = distributorModel.Where(d.Dao.Columns.DistCode+" like ?", "%"+req.DistCode+"%")
+		distributorModel = distributorModel.Where(s.Dao.Columns.DistCode+" like ?", "%"+req.DistCode+"%")
 	}
 	if req.DistName != "" {
-		distributorModel = distributorModel.Where(d.Dao.Columns.DistName+" like ?", "%"+req.DistName+"%")
+		distributorModel = distributorModel.Where(s.Dao.Columns.DistName+" like ?", "%"+req.DistName+"%")
 	}
 	if req.BelongSale != "" {
-		distributorModel = distributorModel.Where(d.Dao.Columns.BelongSale+" like ?", "%"+req.BelongSale+"%")
+		distributorModel = distributorModel.Where(s.Dao.Columns.BelongSale+" like ?", "%"+req.BelongSale+"%")
 	}
 	if req.ProvinceId > 0 {
-		distributorModel = distributorModel.Where(d.Dao.Columns.ProvinceId+" in (?)", req.ProvinceId)
+		distributorModel = distributorModel.Where(s.Dao.Columns.ProvinceId+" in (?)", req.ProvinceId)
 	}
 
 	g.Log().Info("搜索条件", req.ProvinceId)
@@ -60,78 +60,88 @@ func (d *distributorService) GetList(req *model.BaseDistributorSearchReq) (total
 	return
 }
 
-//经销商创建
-func (d *distributorService) Create(req *model.AddDistributor) (err error) {
+//Create 经销商创建
+func (s *distributorService) Create(req *model.AddDistributor) (lastId int64, err error) {
 	DistributorData := new(model.BaseDistributor)
 	if err = gconv.Struct(req, DistributorData); err != nil {
 		return
 	}
-	service.SetCreatedInfo(DistributorData, d.GetCxtUserId(), d.GetCxtUserName())
-	Model := d.Dao.M
+	service.SetCreatedInfo(DistributorData, s.GetCxtUserId(), s.GetCxtUserName())
 	DistributorData.DistCode = gstr.SubStr(strconv.Itoa(int(gtime.Now().UnixNano()/1e6))+"Code", 0, -5)
-	res, err := Model.Insert(DistributorData)
+	lastId, err = s.Dao.InsertAndGetId(DistributorData)
 	if err != nil {
-		return
+		g.Log().Error(err)
+		return 0, err
 	}
-	InsertId, _ := res.LastInsertId()
-	fmt.Println(InsertId)
+
 	return
 }
 
-//详情
-func (p *distributorService) GetEntityById(id int64) (distributorInfo *model.DistributorRonp, err error) {
-	err = p.Dao.Where(base.BaseProduct.Columns.Id, id).Scan(&distributorInfo)
+//GetEntityById 详情
+func (s *distributorService) GetEntityById(id int64) (distributorInfo *model.DistributorRonp, err error) {
+	err = s.Dao.Where(base.BaseProduct.Columns.Id, id).Scan(&distributorInfo)
 	if err != nil {
 		g.Log().Error(err)
-		return nil, gerror.New("获取经销商数据失败")
+		return
 	}
 	return
 }
 
-//修改数据
-func (p *distributorService) UpdateById(req *model.UpdateDistributorReq) (err error) {
-	//uptime := gtime.New(time.Now())
-	Model := p.Dao.M
-	record, err := Model.FindOne("Id", req.Id)
-	if err != nil || record.IsEmpty() {
-		err = gerror.New("该数据不存在")
-		return err
+// UpdateById 修改数据
+func (s *distributorService) UpdateById(req *model.UpdateDistributorReq) (err error) {
+
+	count, err := s.Dao.Where("id = ", req.Id).Count()
+	if err != nil {
+		g.Log().Error(err)
+		return
 	}
-	proInfo := record.Map()
-	fmt.Println(proInfo["created_time"])
+	if count == 0 {
+		err = myerrors.NewMsgError(nil, "无修改数据")
+		return
+	}
+
 	distData := new(model.BaseDistributor)
 	if err = gconv.Struct(req, distData); err != nil {
 		return
 	}
-	service.SetUpdatedInfo(distData, p.GetCxtUserId(), p.GetCxtUserName())
-	_, err = Model.FieldsEx(p.Dao.Columns.DistCode, p.Dao.Columns.Id, p.Dao.Columns.CreatedName, p.Dao.Columns.CreatedBy, p.Dao.Columns.CreatedTime).WherePri(p.Dao.Columns.Id, req.Id).Update(distData)
+	service.SetUpdatedInfo(distData, s.GetCxtUserId(), s.GetCxtUserName())
+	_, err = s.Dao.FieldsEx(s.Dao.Columns.DistCode, s.Dao.Columns.Id,
+		s.Dao.Columns.CreatedName, s.Dao.Columns.CreatedBy, s.Dao.Columns.CreatedTime).WherePri(s.Dao.Columns.Id, req.Id).Update(distData)
 	if err != nil {
 		g.Log().Error(err)
-		err = gerror.New("修改信息失败")
 		return
 	}
 	return
 }
 
-//删除
-func (p *distributorService) DeleteByIds(req int) (err error) {
-	Model := p.Dao.M
-	distributor := new(model.BaseDistributor)
-	err = Model.Where(base.BaseProduct.Columns.Id, req).Scan(&distributor)
-
-	g.Log().Info("DeleteByIds", distributor)
-	if err != nil || distributor.Id == 0 {
-		g.Log().Error(err)
-		err = gerror.New("没有要删除的数据")
-		return
-	}
-	distributor.DeletedTime = gtime.Now()
-	_, err = Model.FieldsEx(EgionDetailFieldEx).
-		WherePri(p.Dao.Columns.Id, req).Update(distributor)
-	if err != nil {
-		g.Log().Error(err)
-		err = gerror.New("删除数据失败")
-		return err
+//DeleteByIds 删除
+func (s *distributorService) DeleteByIds(ids []int64) (err error) {
+	if len(ids) == 1 {
+		count, err := s.Dao.WherePri(ids[0]).Count()
+		if err != nil {
+			g.Log().Error(err)
+			return err
+		}
+		if count == 0 {
+			return myerrors.NewMsgError(nil, "数据不存在或已被删除，请刷新页面")
+		}
+	} else {
+		_, err := s.Dao.WhereIn(s.Dao.Columns.Id, ids).LockShared().Count()
+		if err != nil {
+			g.Log().Error(err)
+			return err
+		}
+		result, err := s.Dao.WhereIn(s.Dao.Columns.Id, ids).Delete()
+		if err != nil {
+			g.Log().Error(err)
+			return err
+		}
+		rows, err := result.RowsAffected()
+		if err == nil {
+			if len(ids) != int(rows) {
+				return myerrors.NewMsgError(nil, fmt.Sprintf("应更新%s行，实际更新%s行", len(ids), int(rows)))
+			}
+		}
 	}
 	return
 

opms_parent/app/service/base/base_district.go

@@ -3,7 +3,6 @@ package base
 import (
 	"context"
 
-	"github.com/gogf/gf/errors/gerror"
 	"github.com/gogf/gf/frame/g"
 	"github.com/gogf/gf/util/gconv"
 
@@ -29,15 +28,16 @@ func NewDistrictService(ctx context.Context) (svc *districtService, err error) {
 	svc.RegionDao = base.NewBaseSalesRegionDao(svc.Tenant)
 	return svc, nil
 }
-func (d *districtService) ListToTree(Id int64) []*model.T {
-	Model := d.Dao.M
+
+//ListToTree 所属区域列表
+func (s *districtService) ListToTree(Id int64) (treeList []*model.T, err error) {
 	ms := make(map[int]*model.T)
 	var distributorList []model.BaseDistrict
-	treeList := []*model.T{}
-	//if Id != 0 {
-	//	Model = Model.Where("parent_id =", Id).WhereOr("parent_id", Id)
-	//}
-	Model.Order("parent_id asc").Scan(&distributorList)
+	err = s.Dao.Order("parent_id asc").Scan(&distributorList)
+	if err != nil {
+		g.Log().Error(err)
+		return
+	}
 
 	for _, v := range distributorList {
 		ms[v.Id] = &model.T{
@@ -53,30 +53,39 @@ func (d *districtService) ListToTree(Id int64) []*model.T {
 		}
 		treeList = append(treeList, v)
 	}
-	return treeList
+	return
 }
-func (d *districtService) GetProvinceInfo() (list []*model.Province) {
 
-	Model := d.Dao.M
-	err := Model.Where(base.BaseDistrict.Columns.ParentId, 0).Scan(&list)
+// GetProvinceList 返回所有省份的
+func (s *districtService) GetProvinceList() (list []*model.Province, err error) {
+
+	err = s.Dao.Where(base.BaseDistrict.Columns.ParentId, 0).Scan(&list)
 	if err != nil {
 		g.Log().Error(err)
-		err = gerror.New("获取数据失败")
 		return
 	}
 
 	return
 }
-func (d *districtService) ListToRegions() (region []*model.Region) {
-	RegModel := d.RegionDao.M
-	RegModel.Fields(d.RegionDao.Columns.RegionDesc, d.RegionDao.Columns.Id).Scan(&region)
+
+//ListToRegions 区域下所有的省份
+func (s *districtService) ListToRegions() (region []*model.Region, err error) {
+
+	err = s.RegionDao.Fields(s.RegionDao.Columns.RegionDesc, s.RegionDao.Columns.Id).Scan(&region)
+	if err != nil {
+		g.Log().Error(err)
+		return
+	}
 	var districtList []int
 	for _, v := range region {
 		districtList = append(districtList, v.Id)
 	}
-	Model := d.Dao.M
-	list, _ := Model.As("dis").RightJoin("base_sales_region_detail deftail", "dis.id = deftail.province_code").
+	list, err := s.Dao.M.As("dis").RightJoin("base_sales_region_detail deftail", "dis.id = deftail.province_code").
 		Fields("dis.dist_name,dis.id,deftail.region_id").Where("deftail.region_id in (?)", districtList).All()
+	if err != nil {
+		g.Log().Error(err)
+		return
+	}
 	ms := make(map[int][]*model.District)
 	for _, v := range list.List() {
 		ms[gconv.Int(v["region_id"])] = append(ms[gconv.Int(v["region_id"])], &model.District{

opms_parent/app/service/base/base_product.go

@@ -37,6 +37,10 @@ func (s *productService) GetList(req *model.ProductSearchReq) (total int, produc
 		Dao = Dao.Where("prod_name like ?", "%"+req.ProdName+"%")
 	}
 
+	if req.ProdClass != "" {
+		Dao = Dao.Where("prod_class = ?", req.ProdClass)
+	}
+
 	total, err = Dao.Count()
 	if err != nil {
 		g.Log().Error(err)
@@ -90,7 +94,7 @@ func (s *productService) UpdateById(req *model.UpdateProductReq) (err error) {
 		return
 	}
 	service.SetUpdatedInfo(product, s.GetCxtUserId(), s.GetCxtUserName())
-	_, err = s.Dao.WherePri(req.Id).Update()
+	_, err = s.Dao.WherePri(req.Id).Update(product)
 	if err != nil {
 		g.Log().Error(err)
 		return
@@ -100,7 +104,6 @@ func (s *productService) UpdateById(req *model.UpdateProductReq) (err error) {
 
 //DeleteByIds 删掉数据
 func (s *productService) DeleteByIds(ids []int64) (err error) {
-
 	if len(ids) == 1 {
 		count, err := s.Dao.WherePri(ids[0]).Count()
 		if err != nil {
@@ -110,6 +113,12 @@ func (s *productService) DeleteByIds(ids []int64) (err error) {
 		if count == 0 {
 			return myerrors.NewMsgError(nil, "数据不存在或已被删除，请刷新页面")
 		}
+		_, err = s.Dao.WherePri(s.Dao.Columns.Id, ids[0]).Delete()
+		if err != nil {
+			g.Log().Error(err)
+			return err
+		}
+		return err
 	} else {
 		_, err := s.Dao.WhereIn(s.Dao.Columns.Id, ids).LockShared().Count()
 		if err != nil {

opms_parent/app/service/base/base_sales_region.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"strconv"
 
-	"github.com/gogf/gf/errors/gerror"
 	"github.com/gogf/gf/frame/g"
 	"github.com/gogf/gf/os/gtime"
 	"github.com/gogf/gf/util/gconv"
@@ -31,31 +30,30 @@ func NewSalesRegionService(ctx context.Context) (svc *salesRegionService, err er
 	return svc, nil
 }
 
-//获取区域
-func (p *salesRegionService) GetListRegion() (RegionList []*model.RegionRep) {
-	regionModel := p.Dao.M
-	err := regionModel.Order("id asc").Scan(&RegionList)
-	if err != nil {
-		g.Log().Error(err)
-		err = gerror.New("获取数据失败")
-		return
-	}
-	return
-}
-
-//创建区域
-func (p *salesRegionService) Create(req *model.AddRegionReq) (err error) {
+//Create 创建区域
+func (s *salesRegionService) Create(req *model.AddRegionReq) (err error) {
 
-	Model := p.Dao.M
 	regionData := new(model.BaseSalesRegion)
 	if err = gconv.Struct(req, regionData); err != nil {
 		return
 	}
-	service.SetCreatedInfo(regionData, p.GetCxtUserId(), p.GetCxtUserName())
+	service.SetCreatedInfo(regionData, s.GetCxtUserId(), s.GetCxtUserName())
 	regionData.RegionCode = strconv.Itoa(int(gtime.Timestamp()))
-	_, err = Model.Insert(regionData)
+	_, err = s.Dao.Insert(regionData)
 	if err != nil {
-		return err
+		g.Log().Error(err)
+		return
+
 	}
 	return nil
 }
+
+//GetListRegion 获取区域
+func (s *salesRegionService) GetListRegion() (RegionList []*model.RegionRep, err error) {
+	err = s.Dao.Order("id asc").Scan(&RegionList)
+	if err != nil {
+		g.Log().Error(err)
+		return
+	}
+	return
+}

opms_parent/app/service/base/base_sales_region_detail.go

@@ -2,10 +2,11 @@ package base
 
 import (
 	"context"
+	"fmt"
 
+	"dashoo.cn/opms_libary/myerrors"
 	"github.com/gogf/gf/errors/gerror"
 	"github.com/gogf/gf/frame/g"
-	"github.com/gogf/gf/os/gtime"
 	"github.com/gogf/gf/util/gconv"
 
 	"dashoo.cn/micro/app/dao/base"
@@ -42,10 +43,12 @@ func NewSalesRegionDetailService(ctx context.Context) (svc *salesRegionDetailSer
 	svc.CustomerDao = cust.NewCustCustomerDao(svc.Tenant)
 	return svc, nil
 }
-func (p *salesRegionDetailService) GetList(req *model.SecBaseRegionDetailReq) (total int, RegionList []*model.BaseRegionDetailRep, err error) {
 
-	Model := p.Dao.M
-	Model = Model.Where(p.Dao.Columns.RegionId, req.RegionId).Where(p.Dao.Columns.DeletedTime + " is null")
+//GetList 销售区域列表
+func (s *salesRegionDetailService) GetList(req *model.SecBaseRegionDetailReq) (total int, RegionList []*model.BaseRegionDetailRep, err error) {
+
+	Model := s.Dao.M
+	Model = Model.Where(s.Dao.Columns.RegionId, req.RegionId)
 	total, err = Model.Count()
 	if err != nil {
 		g.Log().Error(err)
@@ -65,30 +68,30 @@ func (p *salesRegionDetailService) GetList(req *model.SecBaseRegionDetailReq) (t
 	for _, v := range RegionList {
 		districtList = append(districtList, v.ProvinceCode)
 	}
-	CustModel := p.CustomerDao.M
-	CustModel = CustModel.Fields("count(*) as count,cust_dist_code").Where("cust_dist_code in (?)", districtList)
+	//CustModel := p.CustomerDao.M
+	CustModel := s.CustomerDao.M.Fields("count(*) as count,cust_dist_code").Where("cust_dist_code in (?)", districtList)
 	if req.CustName != "" {
 		g.Log().Info("custName", req.CustName)
 
-		CustModel = CustModel.Where(p.CustomerDao.Columns.CustName+" like ?", "%"+req.CustName+"%")
+		CustModel = CustModel.Where(s.CustomerDao.Columns.CustName+" like ?", "%"+req.CustName+"%")
 	}
 	if req.CustCode != "" {
 		g.Log().Info("客户编码搜索", req)
-		CustModel = CustModel.Where(p.CustomerDao.Columns.CustCode+" like ?", "%"+req.CustCode+"%")
+		CustModel = CustModel.Where(s.CustomerDao.Columns.CustCode+" like ?", "%"+req.CustCode+"%")
 	}
 	if req.CustIndustry != "" {
-		CustModel = CustModel.Where(p.CustomerDao.Columns.CustIndustry+" like ?", "%"+req.CustIndustry+"%")
+		CustModel = CustModel.Where(s.CustomerDao.Columns.CustIndustry+" like ?", "%"+req.CustIndustry+"%")
 	}
 	total, err = Model.Fields().Count()
 
-	dist, _ := p.District.M.Fields("dist_name,dist_code").Where("dist_code in (?)", districtList).All()
+	dist, _ := s.District.Fields("dist_name,dist_code").Where("dist_code in (?)", districtList).All()
 	custDist, _ := CustModel.Group("cust_dist_code").All()
 
 	for _, v := range RegionList {
 
 		for _, v2 := range dist {
-			if v.ProvinceCode == gconv.Int(v2["dist_code"]) {
-				v.DistName = gconv.String(v2["dist_name"])
+			if v.ProvinceCode == gconv.Int(v2.DistCode) {
+				v.DistName = gconv.String(v2.DistName)
 			}
 		}
 		for _, v3 := range custDist {
@@ -102,16 +105,15 @@ func (p *salesRegionDetailService) GetList(req *model.SecBaseRegionDetailReq) (t
 }
 
 //创建区域
-func (p *salesRegionDetailService) Create(req *model.AddBaseRegionDetailReq) (err error) {
-	Model := p.Dao.M
+func (s *salesRegionDetailService) Create(req *model.AddBaseRegionDetailReq) (err error) {
 	detailData := new(model.BaseSalesRegionDetail)
 	if err = gconv.Struct(req, detailData); err != nil {
 		return
 	}
 	detailData.RegionId = req.RegionId
 	detailData.ProvinceCode = req.ProvinceCode
-	service.SetCreatedInfo(detailData, p.GetCxtUserId(), p.GetCxtUserName())
-	_, err = Model.Insert(detailData)
+	service.SetCreatedInfo(detailData, s.GetCxtUserId(), s.GetCxtUserName())
+	_, err = s.Dao.Insert(detailData)
 	if err != nil {
 		return err
 	}
@@ -119,67 +121,63 @@ func (p *salesRegionDetailService) Create(req *model.AddBaseRegionDetailReq) (er
 
 }
 
-//更新
-func (p *salesRegionDetailService) UpdateById(req *model.UpdateBaseRegionDetailReq) (err error) {
-	//uptime := gtime.New(time.Now())
-	db := p.Dao.M
-	record, err := db.FindOne("Id", req.Id)
-	if err != nil || record.IsEmpty() {
-		err = gerror.New("该数据不存在")
-		return err
+//UpdateById   修改
+func (s *salesRegionDetailService) UpdateById(req *model.UpdateBaseRegionDetailReq) (err error) {
+	count, err := s.Dao.FindCount(req.Id)
+	if err != nil {
+		g.Log().Error(err)
+		return
+	}
+	if count == 0 {
+		err = myerrors.NewMsgError(nil, "无修改数据")
+		return
 	}
 
 	productData := new(model.BaseSalesRegionDetail)
 	if err = gconv.Struct(req, productData); err != nil {
+		g.Log().Error(err)
 		return
 	}
-	service.SetUpdatedInfo(productData, p.GetCxtUserId(), p.GetCxtUserName())
-	_, err = db.FieldsEx(base.BaseSalesRegionDetail.Columns.CreatedTime, base.BaseSalesRegionDetail.Columns.CreatedBy, base.BaseSalesRegionDetail.Columns.CreatedName).
+	service.SetUpdatedInfo(productData, s.GetCxtUserId(), s.GetCxtUserName())
+	_, err = s.Dao.FieldsEx(base.BaseSalesRegionDetail.Columns.CreatedTime, base.BaseSalesRegionDetail.Columns.CreatedBy, base.BaseSalesRegionDetail.Columns.CreatedName).
 		WherePri(base.BaseSalesRegionDetail.Columns.Id, req.Id).Update(productData)
 
 	if err != nil {
 		g.Log().Error(err)
-		err = gerror.New("修改信息失败")
 		return
 	}
 	return
 }
 
-//删除
-func (p *salesRegionDetailService) DeleteById(req int) (err error) {
-	Model := p.Dao.M
-	regionDetail := new(model.BaseSalesRegionDetail)
-	err = Model.Where(p.Dao.Columns.Id, req).Scan(&regionDetail)
-	//g.Log().Info("DeleteByIds", one)
-	if err != nil {
-		g.Log().Error(err)
-		err = gerror.New("没有要删除的数据")
-		return
-	}
-	regionDetail.DeletedTime = gtime.Now()
-	_, err = Model.FieldsEx(EgionDetailFieldEx).
-		WherePri(p.Dao.Columns.Id, req).Update(regionDetail)
-	if err != nil {
-		g.Log().Error(err)
-		err = gerror.New("删除数据失败")
-		return err
+//DeleteByIds 删除
+func (s *salesRegionDetailService) DeleteByIds(ids []int64) (err error) {
+	if len(ids) == 1 {
+		count, err := s.Dao.WherePri(ids[0]).Count()
+		if err != nil {
+			g.Log().Error(err)
+			return err
+		}
+		if count == 0 {
+			return myerrors.NewMsgError(nil, "数据不存在或已被删除，请刷新页面")
+		}
+	} else {
+		_, err := s.Dao.WhereIn(s.Dao.Columns.Id, ids).LockShared().Count()
+		if err != nil {
+			g.Log().Error(err)
+			return err
+		}
+		result, err := s.Dao.WhereIn(s.Dao.Columns.Id, ids).Delete()
+		if err != nil {
+			g.Log().Error(err)
+			return err
+		}
+		rows, err := result.RowsAffected()
+		if err == nil {
+			if len(ids) != int(rows) {
+				return myerrors.NewMsgError(nil, fmt.Sprintf("应更新%s行，实际更新%s行", len(ids), int(rows)))
+			}
+		}
 	}
 	return
 
 }
-
-//省份客户
-//func (p *salesRegionDetailService) GetCustomerList(distributor []string) (list []*model.BaseRegionCustomer, err error) {
-//	Model := p.CustomerDao.M
-//	Model.Where("cust_location", "%%")
-//
-//	//if req.CustName != "" {
-//	//	Model = Model.Where("cust_name ", req.CustName)
-//	//}
-//	////客户编码
-//	//if req.CustCode != "" {
-//	//	Model = Model.Where("cust_name ", req.CustCode)
-//	//}
-//	//err = Model.Fields("count(*) counts").Page(req.PageNum, req.PageSize).Order("id desc").Scan($list)
-//	return
-//}

opms_parent/app/service/cust/cust_customer.go

@@ -7,6 +7,8 @@ import (
 	"math"
 	"strconv"
 
+	"github.com/gogf/gf/encoding/gjson"
+
 	"dashoo.cn/opms_libary/myerrors"
 	"github.com/360EntSecGroup-Skylar/excelize"
 	"github.com/gogf/gf/frame/g"
@@ -368,7 +370,6 @@ func (s *CustomerService) TransCustomer(req *model.AssignCustomerReq) (err error
 	}
 	s.ChangeCustBelong(req.Ids, req.SalesId, req.SalesName)
 	s.BatchCreatebelong(data, req)
-
 	return
 }
 
@@ -390,31 +391,22 @@ func (s *CustomerService) ChangeCustBelong(Ids []int64, salesId int64, salesName
 	return
 }
 
-// OperationLog 客户操作日志
-func (s *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
-	}
-
-	maps := []map[string]interface{}{}
-	for _, v := range ids {
-		contact := map[string]interface{}{}
-		contact["cust_id"] = v
-		contact["opn_people_id"] = s.GetCxtUserId()
-		contact["opn_people"] = s.GetCxtUserName()
-		contact["opn_date"] = req.OpnDate
-		contact["opn_type"] = req.OpnType
-		contact["remark"] = ""
-		contact["created_by"] = s.GetCxtUserId()
-		contact["created_name"] = s.CxtUser.NickName
-		contact["created_by"] = s.GetCxtUserId()
-		contact["created_time"] = gtime.Now()
-		contact["opn_content"] = req.OpnContent
-		maps = append(maps, contact)
-	}
-	_, err = s.DynamicsDao.Insert(maps)
+//CreateDynamics 创建客户动态信息
+func (s *CustomerService) CreateDynamics(opnTpye string, content interface{}, ids ...int64) (err error) {
+	datas := make([]*model.CustCustomerDynamics, 0)
+	for _, id := range ids {
+		dynameics := new(model.CustCustomerDynamics)
+		dynameics.CustId = int(id)
+		dynameics.OpnPeopleId = s.GetCxtUserId()
+		dynameics.OpnPeople = s.GetCxtUserName()
+		dynameics.OpnDate = gtime.Now()
+		dynameics.OpnType = opnTpye
+		v, _ := gjson.Encode(content)
+		dynameics.OpnContent = gconv.String(v)
+		service.SetCreatedInfo(dynameics, s.GetCxtUserId(), s.GetCxtUserName())
+		datas = append(datas, dynameics)
+	}
+	_, err = s.DynamicsDao.Insert(datas)
 	if err != nil {
 		g.Log().Error(err)
 		return
@@ -454,14 +446,15 @@ func (s *CustomerService) GetDynamicsList(req *model.CustomerDynameicsReq) (tota
 }
 
 // MergeCustomer 合并客户
-func (s *CustomerService) MergeCustomer(req *model.MergecustomerRep) (err error) {
-	//当前目标客户是否存在
-	customerCount, err := s.Dao.FindCount(req.Id)
+func (s *CustomerService) MergeCustomer(req *model.MergeCustomerRep) (err error) {
+
+	//当前目标客户是否存在并取出合并前的销售
+	customer, err := s.Dao.Where("id = ", req.Id).One()
 	if err != nil {
 		g.Log().Error(err)
 		return
 	}
-	if customerCount == 0 {
+	if customer == nil {
 		return myerrors.NewMsgError(nil, "该客户不存在")
 	}
 	_, err = s.ContactDao.Where(" cust_id in (?)", req.ChooseId).Delete()
@@ -491,16 +484,18 @@ func (s *CustomerService) MergeCustomer(req *model.MergecustomerRep) (err error)
 		return
 	}
 	//删除 所选客户销售联系人
-	_, err = s.BelongDao.Where(" cust_id in (?)", req.ChooseId).WhereOr(" cust_id = ", req.Id).Delete()
+	_, err = s.BelongDao.Where(" cust_id in (?)", req.ChooseId).Delete()
 	if err != nil {
 		g.Log().Error(err)
 		return
 	}
+
 	//插入一条合并成功的归属记录
-	req.CustomerBelongAddSeq.CustId = req.Id
+	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)
 	return

opms_parent/app/service/cust/cust_customer_belong.go

@@ -42,7 +42,7 @@ func (s *CustomerbelongService) GetList(req *model.ReqCustomerBelongReq) (total
 
 //Create 插入归属销售
 func (s *CustomerbelongService) Create(req *model.CustomerBelongAddSeq) (err error) {
-
+	
 	cusTomerBelong := new(model.CustCustomerBelong)
 	if err = gconv.Struct(req, cusTomerBelong); err != nil {
 		g.Log().Error(err)

opms_parent/app/service/plat/plat_task.go

@@ -68,7 +68,7 @@ func (s *taskService) GetList(req *model.SearchPlatTaskReq) (total int, TaskList
 	} else if req.OperateType == "3" {
 		TaskModel = TaskModel.Where(fmt.Sprintf("plat_task_handle.task_status='20' AND plat_task_handle.handle_user_id=%v", s.GetCxtUserId()))
 	}
-	TaskModel.Group("plat_task.id")
+	TaskModel = TaskModel.Group("plat_task.id")
 
 	total, err = TaskModel.Count()
 	if err != nil {
@@ -128,9 +128,11 @@ func (s *taskService) Export(req *model.ExportReq) (content *model.ExportContent
 				if value == "状态" {
 					data := ""
 					if item.TaskStatus == "10" {
-						data = "进行中"
+						data = "发起"
 					} else if item.TaskStatus == "20" {
-						data = "关闭"
+						data = "进行中"
+					} else if item.TaskStatus == "30" {
+						data = "流程完成"
 					}
 					f.SetCellValue("Sheet1", service.Div(index+1)+strconv.Itoa(lineNum+2), data)
 				}
@@ -212,7 +214,7 @@ func (s *taskService) Create(req *model.AddPlatTaskReq) (err error) {
 	id, _ := res.LastInsertId()
 	platTask.Id = int(id)
 	nextHandle := createNextTaskHandel(s, platTask, 10)
-	_, err = s.Dao.DB.Model("plat_task_handle").Insert(nextHandle)
+	_, err = s.Dao.DB.Insert("plat_task_handle", nextHandle)
 	if err != nil {
 		return
 	}
@@ -271,15 +273,18 @@ func (s *taskService) ChangeStatus(req *model.ChangeStatusReq) (err error) {
 // 督办任务处理
 func (s *taskService) Handle(req *model.HandleReq) (err error) {
 	// 步骤号（10接收  15暂存  20提交  30审批（督办人）  40评价（监办人））
+	// 处理结果（10接收20提交30审批通过40审批退回）
 	logNodeName := ""
 	logDesc := ""
 	var taskHandle model.PlatTaskHandle
-	err = s.Dao.DB.Model("plat_task_handle").Where(fmt.Sprintf("task_id='%v' AND step=%v AND task_status='10' AND (main_user_id=%v OR FIND_IN_SET(%v, owner_user_id))", req.Step, req.TaskId, s.GetCxtUserId(), s.GetCxtUserId())).Scan(&taskHandle)
-	if err != nil {
-		if err == sql.ErrNoRows {
-			return fmt.Errorf("数据不匹配，刷新数据重试")
+	if req.Step != 15 {
+		err = s.Dao.DB.Model("plat_task_handle").Where(fmt.Sprintf("task_id='%v' AND step=%v AND task_status='10' AND (main_user_id=%v OR FIND_IN_SET(%v, owner_user_id))", req.TaskId, req.Step, s.GetCxtUserId(), s.GetCxtUserId())).Scan(&taskHandle)
+		if err != nil {
+			if err == sql.ErrNoRows {
+				return fmt.Errorf("数据不匹配，刷新数据重试")
+			}
+			return err
 		}
-		return err
 	}
 	now := gtime.Now()
 	// 数据暂存，不做任何流程修改
@@ -287,13 +292,8 @@ func (s *taskService) Handle(req *model.HandleReq) (err error) {
 		// 暂存
 		logNodeName = "暂存"
 		logDesc = s.GetCxtUserName() + "暂存进展信息"
-		// 1 标记删除旧的进展数据
-		_, err = s.Dao.DB.Model("plat_task_progress").Update(fmt.Sprintf("deleted_time='%v'", now.Format("Y-m-d H:i:s")), fmt.Sprintf("task_id='%v'", req.TaskId))
-		if err != nil {
-			return err
-		}
-		// 2 保存新的数据
-		_, err = s.Dao.DB.Model("plat_task_progress").Save(req.ProgressList)
+		// 更新进展数据
+		err = s.saveProgressList(req, now)
 		if err != nil {
 			return err
 		}
@@ -333,26 +333,10 @@ func (s *taskService) Handle(req *model.HandleReq) (err error) {
 			logNodeName = "提交"
 			logDesc = s.GetCxtUserName() + "提交督办任务"
 			// 更新进展数据
-			for index, progress := range req.ProgressList {
-				// 填充创建信息
-				if progress.CreatedBy == 0 {
-					service.SetCreatedInfo(req.ProgressList[index], s.GetCxtUserId(), s.GetCxtUserName())
-				}
-				//	填充更新信息
-				service.SetUpdatedInfo(req.ProgressList[index], s.GetCxtUserId(), s.GetCxtUserName())
-			}
-			// 保存督办进展
-			// 1 标记删除旧的进展数据
-			_, err = s.Dao.DB.Model("plat_task_progress").Update(fmt.Sprintf("deleted_time='%v'", now.Format("Y-m-d H:i:s")), fmt.Sprintf("task_id='%v'", req.TaskId))
+			err = s.saveProgressList(req, now)
 			if err != nil {
 				return err
 			}
-			// 2 保存新的数据
-			_, err = s.Dao.DB.Model("plat_task_progress").Save(req.ProgressList)
-			if err != nil {
-				return err
-			}
-
 		} else if req.Step == 30 {
 			// 督办人审批
 			taskData["approver_id"] = s.GetCxtUserId()
@@ -360,10 +344,10 @@ func (s *taskService) Handle(req *model.HandleReq) (err error) {
 			taskData["appro_status"] = req.HandleStatus
 			taskData["appro_desc"] = req.HandleDesc
 			logNodeName = "审批"
-			if req.HandleStatus == "审批通过" {
+			if req.HandleStatus == "30" {
 				logDesc = s.GetCxtUserName() + "审批通过"
 				nextHandle = createNextTaskHandel(s, task, 40)
-			} else if req.HandleStatus == "审批退回" {
+			} else if req.HandleStatus == "40" {
 				logDesc = s.GetCxtUserName() + "审批退回"
 				nextHandle = createNextTaskHandel(s, task, 20)
 			}
@@ -374,16 +358,18 @@ func (s *taskService) Handle(req *model.HandleReq) (err error) {
 			taskData["evaluate_status"] = req.HandleStatus
 			taskData["evaluate_desc"] = req.HandleDesc
 			logNodeName = "评价"
-			if req.HandleStatus == "审批通过" {
+			if req.HandleStatus == "30" {
 				// 监办人评价，审批通过，任务结束
 				logDesc = s.GetCxtUserName() + "审批通过"
 				nextHandle = nil
 				taskData["actual_close_date"] = now.Format("Y-m-d H:i:s")
 				taskData["task_status"] = "30"
-			} else if req.HandleStatus == "审批退回" {
-				logDesc = s.GetCxtUserName() + "审批通过"
+			} else if req.HandleStatus == "40" {
+				logDesc = s.GetCxtUserName() + "审批退回"
 				nextHandle = createNextTaskHandel(s, task, 20)
 			}
+		} else {
+			return fmt.Errorf("未知步骤，无法操作")
 		}
 
 		// 更新数据
@@ -393,13 +379,13 @@ func (s *taskService) Handle(req *model.HandleReq) (err error) {
 			return err
 		}
 		// 更新任务数据
-		_, err = s.Dao.DB.Model("plat_task_handle").Update(handleData, fmt.Sprintf("ID='%v'", taskHandle.ID))
+		_, err = s.Dao.DB.Update("plat_task_handle", handleData, fmt.Sprintf("ID='%v'", taskHandle.ID))
 		if err != nil {
 			return err
 		}
 		// 创建下一条任务
 		if nextHandle != nil {
-			_, err = s.Dao.DB.Model("plat_task_handle").Save(nextHandle)
+			_, err = s.Dao.DB.Save("plat_task_handle", nextHandle)
 			if err != nil {
 				return err
 			}
@@ -412,7 +398,7 @@ func (s *taskService) Handle(req *model.HandleReq) (err error) {
 		return err
 	}
 
-	return fmt.Errorf("未知步骤，无法操作")
+	return nil
 }
 
 // 任务日志创建方法
@@ -471,9 +457,13 @@ func createNextTaskHandel(s *taskService, task *model.PlatTask, step int) *model
 		personTask.MainUserId = task.MainUserId
 		personTask.OwnerUserId = task.OwnerUserId
 	} else if step == 20 {
+		// 创建提交任务
+		personTask.MainUserId = task.MainUserId
+		personTask.OwnerUserId = task.OwnerUserId
+	} else if step == 30 {
 		// 提交给督办人审批
 		personTask.MainUserId = task.SupervisorUserId
-	} else if step == 30 {
+	} else if step == 40 {
 		// 提交给监办人评价
 		personTask.MainUserId = task.WatchUserId
 	}
@@ -481,4 +471,42 @@ func createNextTaskHandel(s *taskService, task *model.PlatTask, step int) *model
 	service.SetCreatedInfo(&personTask, s.GetCxtUserId(), s.GetCxtUserName())
 
 	return &personTask
+}
+
+// 处理暂存、提交任务进展
+func (s *taskService) saveProgressList(req *model.HandleReq, now *gtime.Time) (err error) {
+	ids := ""
+	deleteWhere := fmt.Sprintf("task_id='%v'", req.TaskId)
+	for index, progress := range req.ProgressList {
+		if progress.Id != 0 {
+			if ids == "" {
+				ids = fmt.Sprintf("%v", progress.Id)
+			} else {
+				ids += fmt.Sprintf(",%v", progress.Id)
+			}
+		}
+		req.ProgressList[index].TaskId = req.TaskId
+		// 填充创建信息
+		if progress.CreatedBy == 0 {
+			service.SetCreatedInfo(req.ProgressList[index], s.GetCxtUserId(), s.GetCxtUserName())
+		}
+		//	填充更新信息
+		service.SetUpdatedInfo(req.ProgressList[index], s.GetCxtUserId(), s.GetCxtUserName())
+	}
+	if ids != "" {
+		deleteWhere += fmt.Sprintf(" AND ID NOT IN (%v)", ids)
+	}
+	// 保存督办进展
+	// 1 标记删除旧的进展数据
+	_, err = s.Dao.DB.Update("plat_task_progress", fmt.Sprintf("deleted_time='%v'", now.Format("Y-m-d H:i:s")), deleteWhere)
+	if err != nil {
+		return err
+	}
+	// 2 保存新的数据
+	_, err = s.Dao.DB.Save("plat_task_progress", req.ProgressList)
+	if err != nil {
+		return err
+	}
+
+	return nil
 }