opms_backend/opms_parent/app/service/work/deliver_order.go

package work

import (
	"context"
	model "dashoo.cn/micro/app/model/base"
	workflowModel "dashoo.cn/micro/app/model/workflow"
	workflowService "dashoo.cn/micro/app/service/workflow"
	"dashoo.cn/opms_libary/plugin/dingtalk/workflow"
	"database/sql"
	"fmt"
	"github.com/gogf/gf/os/glog"
	"github.com/gogf/gf/util/gconv"
	"strconv"
	"strings"

	basedao "dashoo.cn/micro/app/dao/base"
	contractdao "dashoo.cn/micro/app/dao/contract"
	custdao "dashoo.cn/micro/app/dao/cust"
	projdao "dashoo.cn/micro/app/dao/proj"
	workdao "dashoo.cn/micro/app/dao/work"
	contractmodel "dashoo.cn/micro/app/model/contract"
	work "dashoo.cn/micro/app/model/work"
	"dashoo.cn/micro/app/service"
	"dashoo.cn/opms_libary/plugin/dingtalk/message"

	"dashoo.cn/opms_libary/micro_srv"
	"dashoo.cn/opms_libary/myerrors"
	"dashoo.cn/opms_libary/request"
	"github.com/gogf/gf/database/gdb"
	"github.com/gogf/gf/frame/g"
	"github.com/gogf/gf/os/gtime"
	"github.com/gogf/gf/util/gvalid"
)

type DeliverOrderService struct {
	Dao                *workdao.DeliverOrderDao
	PlanDao            *workdao.DeliverOrderImpPlanDao
	ProductDao         *workdao.DeliverOrderProductDao
	ContractDao        *contractdao.CtrContractDao
	ProjBusinessDao    *projdao.ProjBusinessDao
	CustomerDao        *custdao.CustCustomerDao
	CtrProductDao      *contractdao.CtrContractProductDao
	BaseProductDao     *basedao.BaseProductDao
	ProgressProductDao *workdao.DeliverProgressProductDao

	Tenant    string
	userInfo  request.UserInfo
	DataScope g.Map `json:"dataScope"`
}

func NewDeliverOrderService(ctx context.Context) (*DeliverOrderService, error) {
	tenant, err := micro_srv.GetTenant(ctx)
	if err != nil {
		err = myerrors.TipsError(fmt.Sprintf("获取租户码异常：%s", err.Error()))
		return nil, err
	}
	// 获取用户信息
	userInfo, err := micro_srv.GetUserInfo(ctx)
	if err != nil {
		return nil, fmt.Errorf("获取用户信息异常：%s", err.Error())
	}
	return &DeliverOrderService{
		Dao:                workdao.NewDeliverOrderDao(tenant),
		PlanDao:            workdao.NewDeliverOrderImpPlanDao(tenant),
		ContractDao:        contractdao.NewCtrContractDao(tenant),
		ProjBusinessDao:    projdao.NewProjBusinessDao(tenant),
		CustomerDao:        custdao.NewCustCustomerDao(tenant),
		CtrProductDao:      contractdao.NewCtrContractProductDao(tenant),
		ProductDao:         workdao.NewDeliverOrderProductDao(tenant),
		BaseProductDao:     basedao.NewBaseProductDao(tenant),
		ProgressProductDao: workdao.NewDeliverProgressProductDao(tenant),
		Tenant:             tenant,
		userInfo:           userInfo,
		DataScope:          userInfo.DataScope,
	}, nil
}

func (s DeliverOrderService) Get(ctx context.Context, id int) (*work.DeliverOrderGetRsp, error) {
	number := 0
	ent, err := s.Dao.Where("Id = ?", id).One()
	if err != nil {
		return nil, err
	}
	if ent == nil {
		return nil, myerrors.TipsError("工单不存在")
	}
	plan, err := s.PlanDao.Where("deliver_order_id = ?", id).All()
	if err != nil {
		return nil, err
	}
	if plan == nil {
		plan = []*work.DeliverOrderImpPlan{}
	}
	product, err := s.ProductDao.Where("deliver_order_id = ?", id).All()
	if err != nil {
		return nil, err
	}
	if product == nil {
		product = []*work.DeliverOrderProduct{}
	}
	proj, err := s.ProjBusinessDao.Where("id = ?", ent.ProjectId).One()
	if err != nil {
		return nil, err
	}
	saleId := 0
	if proj != nil {
		saleId = proj.SaleId
	}
	progressProducts, err := s.ProgressProductDao.Where("deliver_order_id = ?", id).All()
	if err != nil {
		return nil, err
	}
	// 发货单数量
	number, err = s.Dao.DB.Model("deliver_order_imp_progress").Where(fmt.Sprintf("deliver_order_id='%v' AND progress_type='10'", id)).Count()
	if err != nil {
		return nil, err
	}

	return &work.DeliverOrderGetRsp{
		DeliverOrder:     *ent,
		Plan:             plan,
		Product:          product,
		ProgressProducts: progressProducts,
		SaleId:           saleId,
		Number:           number + 1,
	}, nil
}

func (s DeliverOrderService) List(ctx context.Context, req *work.DeliverOrderListReq) (int, []*work.DeliverOrderInfo, error) {
	g.Log().Infof("DeliverOrderService List roles %v", s.userInfo.Roles)
	//dao := s.Dao.DeliverOrderDao.As("a").LeftJoin("ctr_contract b", "a.contract_id=b.id").Unscoped().Where("a.deleted_time is null") // 改为关联项目
	dao := s.Dao.DeliverOrderDao.As("a").LeftJoin("proj_business b", "a.project_id=b.id").LeftJoin("deliver_order_product p", "p.deliver_order_id=a.id").Unscoped().Where("a.deleted_time is null")
	where := ""
	//	系统管理员、研发主管、研发总监、品质主管、总经理、销售总监、销售助理看全部的
	if service.StringsContains(s.userInfo.Roles, "ResearchAndDevelopmentDirector") || service.StringsContains(s.userInfo.Roles, "ResearchAndDevelopmentSupervisor") || service.StringsContains(s.userInfo.Roles, "QualityAssuranceSupervisor") || service.StringsContains(s.userInfo.Roles, "GeneralManager") || service.StringsContains(s.userInfo.Roles, "SalesDirector") || service.StringsContains(s.userInfo.Roles, "SaleAssociate") || service.StringsContains(s.userInfo.Roles, "SysAdmin") {
		//	无条件，查询全部
		//	项目经理看对应的
	} else {
		where1 := "(1=0"
		if service.StringsContains(s.userInfo.Roles, "ProjectManager") {
			where1 += fmt.Sprintf(" OR a.project_man_id='%v'", s.userInfo.Id)
			//dao = dao.Where("a.project_man_id = ?", s.userInfo.Id)
			//	交付经理看对应的
		}
		if service.StringsContains(s.userInfo.Roles, "ProjectDeliveryManager") {
			where1 += fmt.Sprintf(" OR a.deliver_man_id='%v'", s.userInfo.Id)
			//dao = dao.Where("a.deliver_man_id = ?", s.userInfo.Id)
		}
		if service.StringsContains(s.userInfo.Roles, "ProductIntegrationManager") {
			//	丁岳嵩 查看全部硬件 交付类型：10软件；20硬件
			where1 += fmt.Sprintf(" OR a.order_type='20'")
			//dao = dao.Where("a.order_type = ?", "20")
			// 产品线负责人看自己负责的产品线
		}
		if service.StringsContains(s.userInfo.Roles, "ProductLineManager") {
			productCode, err := service.ColumnString(s.Dao.DB.Table("base_product_auth").Wheref("user_id = ?", s.userInfo.Id), "product_code")
			if err != nil {
				return 0, nil, err
			}
			g.Log().Infof("DeliverOrderService List product_code %v", productCode)
			if len(productCode) > 0 {
				where1 += fmt.Sprintf(" OR a.product IN (%v)", strings.Join(productCode, ","))
			}
			//dao = dao.Where("a.product in (?)", productCode)
			// 大区经理看所管理的销售的（包括自己）
		}
		if service.StringsContains(s.userInfo.Roles, "RegionalManager") {
			where1 += fmt.Sprintf(" OR b.sale_id IN (SELECT id FROM sys_user WHERE dept_id='%v')", s.userInfo.DeptId)
			//dao = dao.Where(fmt.Sprintf("b.sale_id IN (SELECT id FROM sys_user WHERE dept_id='%v')", s.userInfo.DeptId))
			// 销售工程师看自己负责的项目的
		}
		if service.StringsContains(s.userInfo.Roles, "SalesEngineer") {
			where1 += fmt.Sprintf(" OR b.sale_id='%v'", s.userInfo.Id)
			//dao = dao.Where("b.sale_id = ?", s.userInfo.Id)
		}
		where1 += ")"
		where = where1
	}
	dao = dao.Where(where)

	if req.OrderCode != "" {
		dao = dao.Where("a.order_code = ?", req.OrderCode)
	}
	if req.OrderStatus != "" {
		dao = dao.Where("a.order_status = ?", req.OrderStatus)
	}
	if req.OrderType != "" {
		dao = dao.Where("a.order_type = ?", req.OrderType)
	}
	if req.CustId != 0 {
		dao = dao.Where("a.cust_id = ?", req.CustId)
	}
	if req.CustName != "" {
		likestr := fmt.Sprintf("%%%s%%", req.CustName)
		dao = dao.Where("a.cust_name like ?", likestr)
	}
	if req.ProjectId != 0 {
		dao = dao.Where("a.project_id = ?", req.ProjectId)
	}
	if req.ProjectName != "" {
		likestr := fmt.Sprintf("%%%s%%", req.ProjectName)
		dao = dao.Where("a.project_name like ?", likestr)
	}
	if req.ContractId != 0 {
		dao = dao.Where("a.contract_id = ?", req.ContractId)
	}
	if req.ContractCode != "" {
		dao = dao.Where("a.contract_code = ?", req.ContractCode)
	}
	if req.ProjectManId != 0 {
		dao = dao.Where("a.project_man_id = ?", req.ProjectManId)
	}
	if req.ProjectManName != "" {
		likestr := fmt.Sprintf("%%%s%%", req.ProjectManName)
		dao = dao.Where("a.project_man_name like ?", likestr)
	}
	if req.DeliverManId != 0 {
		dao = dao.Where("a.deliver_man_id = ?", req.DeliverManId)
	}
	if req.DeliverManName != "" {
		likestr := fmt.Sprintf("%%%s%%", req.DeliverManName)
		dao = dao.Where("a.deliver_man_name like ?", likestr)
	}
	if req.Product != "" {
		dao = dao.Where("a.product = ?", req.Product)
	}
	if req.Status != "" {
		dao = dao.Where("a.order_status = ?", req.Status)
	}

	// 分组
	dao = dao.Group("a.id")

	total, err := dao.Count()
	if err != nil {
		return 0, nil, err
	}
	if req.PageNum != 0 {
		dao = dao.Page(req.GetPage())
	}
	orderby := "a.created_time desc"
	if req.OrderBy != "" {
		orderby = req.OrderBy
	}
	dao = dao.Order(orderby)

	var ents []*work.DeliverOrderInfo
	err = dao.Fields("a.*, group_concat(p.product_name) products, b.sale_id").Structs(&ents)
	if err != nil && err != sql.ErrNoRows {
		return 0, nil, err
	}
	return total, ents, err
}

func (s DeliverOrderService) Add(ctx context.Context, req *work.DeliverOrderAddReq) ([]int, error) {
	validErr := gvalid.CheckStruct(ctx, req, nil)
	if validErr != nil {
		return nil, myerrors.TipsError(validErr.Current().Error())
	}

	var productInfo work.ProductInfo

	var products []*model.BaseProduct
	err := s.Dao.DB.Model("base_product").Scan(&products)
	if err != nil {
		return nil, err
	}

	// 处理产品线
	var pl string
	for _, v := range req.FormData {
		if v.Name == "产品线" {
			pl, _ = v.Value.(string)
		}
		if v.Name == "备注" {
			productInfo.Remark, _ = v.Value.(string)
		}
		if v.Name == "产品信息" {
			pts := v.Value.([]interface{})
			for _, fields := range pts {
				var product contractmodel.CtrContractProduct
				prodNum := 0
				prodCode := ""
				prodName := ""
				for _, field := range fields.([]interface{}) {
					data := field.(map[string]interface{})
					if data["name"] == "产品名称" {
						prodName = data["value"].(string)
					}
					if data["name"] == "产品型号" {
						prodCode = data["value"].(string)
					}
					if data["name"] == "数量" {
						prodNum = gconv.Int(data["value"])
					}
				}

				product.ProdNum = prodNum
				product.ProdCode = prodCode
				product.ProdName = prodName
				for _, p := range products {
					if p.ProdCode == product.ProdCode && p.ProdName == product.ProdName {
						product.ProdClass = p.ProdClass
					}
				}
				productInfo.Products = append(productInfo.Products, &product)
			}
		}
	}
	if pl != "" {
		productLine, err := service.GetDictDataByType(ctx, "sys_product_line")
		if err != nil {
			return nil, err
		}
		productLineMap := map[string]string{}
		for k, v := range productLine {
			productLineMap[v] = k
		}
		productInfo.ProductLine = productLineMap[pl]
	}

	var id []int
	txerr := s.Dao.DB.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
		var err error
		// 交付状态(0发起 10项目立项 15进行中 20 完成 30审批拒绝40关闭)
		id, err = DeliverOrderAdd(tx, req.ContractId, s.userInfo, &productInfo, "0")
		if err != nil {
			return err
		}

		// 提交工单 审批
		workflowSrv, _ := workflowService.NewFlowService(ctx)
		bizCode := gconv.String(id[0]) + ":" + req.OrderTypeCode
		formComponentValues := make([]*workflow.StartProcessInstanceRequestFormComponentValues, 0)
		if err = gconv.Structs(req.FormData, &formComponentValues); err != nil {
			return err
		}

		workflowId, err := workflowSrv.StartProcessInstance(bizCode, workflowModel.DeliverOrderCreate, "", &workflow.StartProcessInstanceRequest{
			ProcessCode:         &req.OrderTypeCode,
			FormComponentValues: formComponentValues,
		})
		g.Log().Info("工单审批流ID ", workflowId)
		if err != nil {
			g.Log().Error(err)
			return err
		}

		return err
	})
	return id, txerr
}

func DeliverOrderAdd(tx *gdb.TX, contractId int, userInfo request.UserInfo, productInfo *work.ProductInfo, state string) ([]int, error) {
	// 该状态为合同审批通过之后自动生成的交付工单
	if state == "10" {
		// 校验是否已自动生成交付工单
		count, err := tx.Model("deliver_order").Where(fmt.Sprintf("contract_id='%v' AND created_by=0", contractId)).Count()
		if err != nil {
			return nil, err
		}
		if count > 0 {
			return nil, nil
		}
	}
	var c contractmodel.CtrContract
	err := tx.GetStruct(&c, "select * from ctr_contract where id = ?", contractId)
	if err == sql.ErrNoRows {
		return nil, myerrors.TipsError(fmt.Sprintf("合同：%d 不存在", contractId))
	}
	if err != nil {
		return nil, err
	}

	var product []*contractmodel.CtrContractProduct
	remark := ""
	if productInfo == nil {
		err = tx.GetStructs(&product, "select * from ctr_contract_product where contract_id = ? AND deleted_time IS NULL", contractId)
		if err == sql.ErrNoRows {
			return nil, myerrors.TipsError(fmt.Sprintf("合同产品为空: %d", contractId))
		}
		if err != nil {
			return nil, err
		}
	} else {
		product = append(product, productInfo.Products...)
		remark = productInfo.Remark
	}

	var deliverSoft *work.DeliverOrder
	var deliverHard *work.DeliverOrder
	deliverProductSoft := []work.DeliverOrderProduct{}
	deliverProductHard := []work.DeliverOrderProduct{}
	// 交付类型(10 软件 20 硬件)
	projectManId1, projectManName1, deliverManId1, deliverManName1 := getProjectUser(tx, &c, true)
	projectManId2, projectManName2, deliverManId2, deliverManName2 := getProjectUser(tx, &c, false)

	for _, p := range product {
		var orderType string
		if p.ProdClass == "10" || p.ProdClass == "20" || p.ProdClass == "30" {
			orderType = "10"
		}
		// 参考218上的产品类型设置
		if p.ProdClass == "40" || p.ProdClass == "50" || p.ProdClass == "60" || p.ProdClass == "90" {
			orderType = "20"
		}

		projectManId, projectManName, deliverManId, deliverManName := projectManId2, projectManName2, deliverManId2, deliverManName2
		// 交付类型(10 软件 20 硬件)
		if orderType == "20" {
			projectManId, projectManName, deliverManId, deliverManName = projectManId1, projectManName1, deliverManId1, deliverManName1
		}
		line := c.ProductLine
		if productInfo != nil {
			line = productInfo.ProductLine
		}

		// 交付状态(0发起 10项目立项 15进行中 20 完成 30审批拒绝40关闭)
		o := work.DeliverOrder{
			OrderCode:      fmt.Sprintf("%s%s", c.ContractCode, orderType),
			OrderStatus:    state,
			OrderType:      orderType,
			CustId:         c.CustId,
			CustName:       c.CustName,
			ProjectId:      c.NboId,
			ProjectName:    c.NboName,
			ContractId:     c.Id,
			ContractCode:   c.ContractCode,
			ProjectManId:   projectManId,
			ProjectManName: projectManName,
			DeliverManId:   deliverManId,
			DeliverManName: deliverManName,
			Product:        line,
			Remark:         remark,
			CreatedBy:      userInfo.Id,
			CreatedName:    userInfo.NickName,
			CreatedTime:    gtime.Now(),
			UpdatedBy:      userInfo.Id,
			UpdatedName:    userInfo.NickName,
			UpdatedTime:    gtime.Now(),
		}
		op := work.DeliverOrderProduct{
			DeliverOrderId: 0,
			ProductCode:    p.ProdCode,
			ProductName:    p.ProdName,
			ProductType:    p.ProdClass,
			ProductNum:     p.ProdNum,
			IsDeliver:      "10", // 10 未开始；20 已操作
			IsComplete:     "10",
			IsInstall:      "10",
			Remark:         "",
			CreatedBy:      userInfo.Id,
			CreatedName:    userInfo.NickName,
			CreatedTime:    gtime.Now(),
			UpdatedBy:      userInfo.Id,
			UpdatedName:    userInfo.NickName,
			UpdatedTime:    gtime.Now(),
		}
		if orderType == "10" {
			deliverSoft = &o
			deliverProductSoft = append(deliverProductSoft, op)
		}
		if orderType == "20" {
			deliverHard = &o
			deliverProductHard = append(deliverProductHard, op)
		}
	}

	var id = []int{}
	if deliverHard != nil {
		oid, err := tx.InsertAndGetId("deliver_order", *deliverHard)
		if err != nil {
			return nil, err
		}
		err = DeliverOrderBindProduct(tx, int(oid), deliverProductHard)
		if err != nil {
			return nil, err
		}
		id = append(id, int(oid))
	}
	if deliverSoft != nil {
		oid, err := tx.InsertAndGetId("deliver_order", *deliverSoft)
		if err != nil {
			return nil, err
		}
		err = DeliverOrderBindProduct(tx, int(oid), deliverProductSoft)
		if err != nil {
			return nil, err
		}
		id = append(id, int(oid))
	}
	return id, nil
}

// DeliverOrderNotify 工单 审批结果通知
func (s *DeliverOrderService) DeliverOrderNotify(flow *workflowModel.PlatWorkflow, msg *message.MixMessage) error {
	bizCode := strings.Split(flow.BizCode, ":")
	if len(bizCode) != 2 {
		return fmt.Errorf("工单审批 bizCode 不合法：%s Id: %d", flow.BizCode, flow.Id)
	}
	workOrderId := bizCode[0]
	if msg.ProcessType != "finish" && msg.ProcessType != "terminate" {
		return fmt.Errorf("无法识别的 ProcessType ：%s", msg.ProcessType)
	}
	if msg.Result != "agree" && msg.Result != "refuse" && msg.Result != "" {
		return fmt.Errorf("无法识别的 Result ：%s", msg.Result)
	}
	fmt.Println(msg)

	workOrder, err := s.Dao.WherePri(workOrderId).One()
	if err != nil {
		return err
	}
	if workOrder == nil {
		return fmt.Errorf("工单不存在：%s Id: %d", flow.BizCode, flow.Id)
	}

	var data = g.Map{}
	// 工单状态（10发起20审批中30审批通过40审批拒绝50关闭）
	// 交付状态(0发起 10项目立项 15进行中 20 完成 30审批拒绝40关闭)
	if msg.ProcessType == "terminate" {
		data[s.Dao.C.OrderStatus] = "40"
	}
	if msg.ProcessType == "finish" && msg.Result == "refuse" {
		data[s.Dao.C.OrderStatus] = "30"
	}
	if msg.ProcessType == "finish" && msg.Result == "agree" {
		data[s.Dao.C.OrderStatus] = "10"
	}

	if data[s.Dao.C.OrderStatus] == "10" {
		s.workOrderSendMsg(workOrder, "交付工单审批通过提醒", fmt.Sprintf("<p>工单:%s 已审批通过</p>", workOrder.OrderCode))
	}

	// 项目修改
	_, err = s.Dao.WherePri(workOrder.Id).Update(fmt.Sprintf("order_status='%v'", data[s.Dao.C.OrderStatus]))
	if err != nil {
		return err
	}
	return err
}

func (s *DeliverOrderService) workOrderSendMsg(order *work.DeliverOrder, title, content string) {
	recvUserIds := []int{}
	if order.ProjectManId != 0 {
		recvUserIds = append(recvUserIds, order.ProjectManId)
	}
	if order.DeliverManId != 0 {
		recvUserIds = append(recvUserIds, order.DeliverManId)
	}
	contract, err := s.ContractDao.Where(fmt.Sprintf("id='%v'", order.ContractId)).One()
	if err != nil {
		glog.Error(err)
	}
	if contract != nil {
		recvUserIds = append(recvUserIds, contract.InchargeId)
	}
	recvUserIds = service.SliceIntDeduplication(recvUserIds)
	if len(recvUserIds) == 0 {
		return
	}
	recvUserIdString := []string{}
	for _, uid := range recvUserIds {
		recvUserIdString = append(recvUserIdString, strconv.Itoa(uid))
	}
	msg := g.MapStrStr{
		"msgTitle":    title,
		"msgContent":  content,
		"msgType":     "20",
		"recvUserIds": strings.Join(recvUserIdString, ","),
		"msgStatus":   "10",
		"sendType":    "10",
	}
	fmt.Println(title, strings.Join(recvUserIdString, ","))
	if err := service.CreateSystemMessage(msg); err != nil {
		g.Log().Error("交付工单 %s 提醒异常：%s", title, err)
	}
}

func getProjectUser(tx *gdb.TX, c *contractmodel.CtrContract, isDeliver bool) (int, string, int, string) {
	projectManId, projectManName, deliverManId, deliverManName := 0, "", 0, ""
	// 根据产品线，设置项目经理：  10 BIOBANK; 20 CELLSOP; 30 LIMS+基因; 40 智能硬件; 50 液氮罐; 60 MCS;
	// 非交付工单产品线： 70 咨询服务; 80 石油; 90 外购
	if c.ProductLine == "10" {
		projectManName = "姜辉"
		projectManId = 0
	} else if c.ProductLine == "20" {
		projectManName = "王晓宇"
		projectManId = 0
	} else if c.ProductLine == "30" {
		projectManName = "程健"
		projectManId = 0
	} else if c.ProductLine == "40" || c.ProductLine == "50" || c.ProductLine == "60" {
		projectManName = "孙淼"
		projectManId = 0
	}
	if projectManName != "" {
		user, err := tx.Model("sys_user").Where(fmt.Sprintf("nick_name='%v'", projectManName)).One()
		if err != nil && err != sql.ErrNoRows {
			glog.Error(err)
		}
		if user != nil {
			projectManId = user["id"].Int()
		}
	}
	if isDeliver {
		deliverManName = "丁岳嵩"
		user, err := tx.Model("sys_user").Where(fmt.Sprintf("nick_name='%v'", deliverManName)).One()
		if err != nil && err != sql.ErrNoRows {
			glog.Error(err)
		}
		if user != nil {
			deliverManId = user["id"].Int()
		}
	}

	return projectManId, projectManName, deliverManId, deliverManName
}

func DeliverOrderBindProduct(tx *gdb.TX, id int, product []work.DeliverOrderProduct) error {
	_, err := tx.Delete("deliver_order_product", "deliver_order_id = ?", id)
	if err != nil {
		return err
	}
	for i := range product {
		product[i].DeliverOrderId = id
	}
	if len(product) != 0 {
		_, err = tx.Insert("deliver_order_product", product)
		if err != nil {
			return err
		}
	}
	return nil
}

func (s DeliverOrderService) Update(ctx context.Context, req *work.DeliverOrderUpdateReq) error {
	validErr := gvalid.CheckStruct(ctx, req, nil)
	if validErr != nil {
		return myerrors.TipsError(validErr.Current().Error())
	}

	ent, err := s.Dao.Where("id = ?", req.Id).One()
	if err != nil {
		return err
	}
	if ent == nil {
		return myerrors.TipsError(fmt.Sprintf("工单不存在: %d", req.Id))
	}

	toupdate := map[string]interface{}{}
	if req.OrderStatus != "" {
		toupdate["order_status"] = req.OrderStatus
	}
	if req.ProjectManId != 0 {
		toupdate["project_man_id"] = req.ProjectManId
	}
	if req.ProjectManName != "" {
		toupdate["project_man_name"] = req.ProjectManName
	}
	if req.DeliverManId != 0 {
		toupdate["deliver_man_id"] = req.DeliverManId
	}
	if req.DeliverManName != "" {
		toupdate["deliver_man_name"] = req.DeliverManName
	}
	if len(toupdate) != 0 {
		toupdate["updated_by"] = int(s.userInfo.Id)
		toupdate["updated_name"] = s.userInfo.NickName
		toupdate["updated_time"] = gtime.Now()
		txerr := s.Dao.DB.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
			_, err = tx.Update("deliver_order", toupdate, "id = ?", req.Id)
			if err != nil {
				return err
			}
			return nil
		})
		if txerr != nil {
			return txerr
		}
	}
	return nil
}

func (s *DeliverOrderService) Finish(ctx context.Context, req *work.DeliverOrderFinishReq) error {
	ent, err := s.Dao.Where("id = ?", req.OrderId).One()
	if err != nil {
		return err
	}
	if ent == nil {
		return myerrors.TipsError("工单不存在")
	}
	// if ent.OrderStatus != "30" {
	// 	return myerrors.TipsError("当前工单不可完成")
	// }

	return s.Dao.DB.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
		_, err = tx.Update("deliver_order", map[string]interface{}{
			"order_status":   "20",
			"finish_remark":  req.FinishRemark,
			"finish_time":    gtime.Now(),
			"finish_by":      int(s.userInfo.Id),
			"finish_by_name": s.userInfo.NickName,
			"updated_by":     int(s.userInfo.Id),
			"updated_name":   s.userInfo.NickName,
			"updated_time":   gtime.Now(),
		}, "id = ?", req.OrderId)
		return err
	})
}

func (s DeliverOrderService) Delete(ctx context.Context, id []int) error {
	if len(id) == 0 {
		return nil
	}
	_, err := s.Dao.Where("Id  IN (?)", id).Delete()
	return err
}

// Start 硬件交付启动
func (s DeliverOrderService) Start(ctx context.Context, req *work.StartReq) error {
	if req.OrderId == 0 {
		return myerrors.TipsError("交付工单Id为空，操作失败")
	}
	order, err := s.Dao.Where(fmt.Sprintf("id='%v'", req.OrderId)).FindOne()
	if err != nil {
		return err
	}
	// 交付状态(10项目立项 15进行中 20 完成)
	if order.OrderStatus != "10" {
		return myerrors.TipsError("该状态的工单不可启动")
	}
	order.OrderStatus = "15"
	order.RequiredDeliveryTime = req.RequiredDeliveryTime
	order.ReceivingInfo = req.ReceivingInfo
	order.SpecialRequirements = req.SpecialRequirements

	_, err = s.Dao.Save(order)
	if err != nil {
		return err
	}
	// 生成发货计划
	var plan work.DeliverOrderImpPlan
	plan.DeliverOrderId = req.OrderId
	plan.PlanTitle = "硬件交付计划"
	plan.PlanStatus = "10"
	plan.PlanStartDate = gtime.Now()
	plan.PlanEndDate = req.RequiredDeliveryTime
	service.SetCreatedInfo(&plan, s.userInfo.Id, s.userInfo.NickName)
	_, err = s.PlanDao.Save(plan)
	if err != nil {
		return err
	}

	msg := g.MapStrStr{
		"msgTitle":    "硬件交付工单提醒",
		"msgContent":  fmt.Sprintf("<p>%v的交付工单：<a href='%v'>%v</a>已经启动，请前去查看。</p>", order.ProjectName, fmt.Sprintf("#/work/deliveryPlan?id=%v", order.Id), order.OrderCode),
		"msgType":     "20",
		"recvUserIds": gconv.String(order.DeliverManId),
		"msgStatus":   "10",
		"sendType":    "10",
	}
	if err := service.CreateSystemMessage(msg); err != nil {
		g.Log().Error("消息提醒异常：", err)
	}

	return err
}

func (s DeliverOrderService) GetHardwareUserInfo(ctx context.Context, req *work.HardwareReq) (map[string]interface{}, error) {
	user, err := s.Dao.DB.Model("sys_user").Where(fmt.Sprintf("nick_name='%v'", req.Name)).One()
	if err != nil {
		if err == sql.ErrNoRows {
			return nil, nil
		}
		return nil, err
	}

	return map[string]interface{}{
		"id":       user["id"],
		"nickName": user["nick_name"],
	}, nil
}