hongze_mobile_admin/services/company_approval/company_approval.go

package company_apply

import (
	"encoding/json"
	"errors"
	"fmt"
	"hongze/hongze_mobile_admin/models/custom"
	"hongze/hongze_mobile_admin/models/tables/admin"
	"hongze/hongze_mobile_admin/models/tables/approval_flow"
	"hongze/hongze_mobile_admin/models/tables/approval_flow_node"
	"hongze/hongze_mobile_admin/models/tables/company"
	"hongze/hongze_mobile_admin/models/tables/company_approval"
	"hongze/hongze_mobile_admin/models/tables/company_approval_message"
	"hongze/hongze_mobile_admin/models/tables/company_contract"
	"hongze/hongze_mobile_admin/models/tables/company_delay_permission"
	"hongze/hongze_mobile_admin/models/tables/company_product"
	"hongze/hongze_mobile_admin/models/tables/company_product_log"
	"hongze/hongze_mobile_admin/models/tables/company_product_update_log"
	"hongze/hongze_mobile_admin/models/tables/contract_approval"
	"hongze/hongze_mobile_admin/models/tables/contract_approval_record"
	"hongze/hongze_mobile_admin/services"
	"hongze/hongze_mobile_admin/services/flow"
	"hongze/hongze_mobile_admin/utils"
	"strings"
	"time"
)

var sourceType = 1 //来源客户
//提交审批
func Apply(companyApprovalId int, messageContent string) (err error) {
	//获取客户单详情
	recodeInfo, err := company_approval.GetCompanyApprovalByApprovalId(companyApprovalId)
	if err != nil {
		err = errors.New("获取合同信息失败，Err:" + err.Error())
		return
	}
	if recodeInfo == nil {
		err = errors.New("客户单异常，找不到客户单信息")
		return
	}
	//获取客户信息
	companyInfo, err := company.GetCompanyById(recodeInfo.CompanyId)
	if err != nil {
		err = errors.New("获取合同信息失败，Err:" + err.Error())
		return
	}
	if companyInfo == nil {
		err = errors.New("客户信息异常，找不到客户信息")
		return
	}

	//合同状态判断
	ignoreStatus := []string{"待审批", "已撤回", "驳回"}
	if !strings.Contains(strings.Join(ignoreStatus, ","), recodeInfo.ApproveStatus) {
		err = errors.New("客户单状态异常，不允许提交审批，当前客户单状态：" + recodeInfo.ApproveStatus)
		return
	}

	//待审内容
	applyContent := `试用转正式`
	switch recodeInfo.ApplyMethod { //"1:试用->正式,2:冻结—>试用,3:试用延期,4:原销售申请领取流失客户，5:正式客户申请服务更新"
	case 1:
		applyContent = `试用转正式`
	case 2:
		applyContent = `冻结转试用`
	case 3:
		applyContent = `试用延期`
	case 4:
		applyContent = `原销售申领客户`
	case 5:
		applyContent = `续约申请`
	case 6:
		applyContent = `补充协议`
	}

	contractDetailByte, err := json.Marshal(recodeInfo)
	if err != nil {
		err = errors.New(fmt.Sprint("合同状态异常，当前合同数据格式化失败：", err))
		return
	}

	//获取基础审批流
	var flowItemInfo *approval_flow.ApprovalFlowItem
	if recodeInfo.ProductId == 1 {
		tmpFlowItemInfo, tmpErr := flow.GetApprovalFlow(1)
		if tmpErr != nil {
			err = errors.New(fmt.Sprint("查找审批流程配置失败：", tmpErr))
			return
		}
		flowItemInfo = tmpFlowItemInfo
	} else {
		tmpFlowItemInfo, tmpErr := flow.GetApprovalFlow(2)
		if tmpErr != nil {
			err = errors.New(fmt.Sprint("查找审批流程配置失败：", tmpErr))
			return
		}
		flowItemInfo = tmpFlowItemInfo
	}

	//校验是否存在待审批的审批单（其实没有多大意义，只是为了 异常数据校验）
	contractApproval := &contract_approval.ContractApproval{
		ContractId:     recodeInfo.CompanyApprovalId,
		Status:         "待审批",
		ApprovalType:   "company",
		ApplyContent:   applyContent,
		ContractDetail: string(contractDetailByte),
		ApplyUserId:    recodeInfo.ApplyUserId,
		ApplyUserName:  recodeInfo.ApplyRealName,
		FlowId:         flowItemInfo.FlowId,
		FlowVersion:    flowItemInfo.CurrVersion,
		CurrNodeId:     flowItemInfo.NodeList[0].NodeId,
		StartNodeId:    flowItemInfo.NodeList[0].NodeId,
		ModifyTime:     time.Now(),
		CreateTime:     time.Now(),
	}
	has, err := contractApproval.CheckPendingByContractId(recodeInfo.CompanyApprovalId, "company")
	if err != nil {
		return
	}
	if has {
		err = errors.New("客户单异常，不允许提交审批，存在待审核的客户单")
		return
	}
	contractApprovalRecordList := make([]*contract_approval_record.ContractApprovalRecord, 0)

	ApproveUserMap := make(map[int]approval_flow_node.User)
	for _, nodeItem := range flowItemInfo.NodeList {
		//审批流记录
		if len(nodeItem.UserList) <= 0 {
			err = errors.New(fmt.Sprint("审批流程异常，没有可审批的人员,Err:", err))
			return
		}
		for _, userItem := range nodeItem.UserList {
			contractApprovalRecord := &contract_approval_record.ContractApprovalRecord{
				Status:              "待审批",
				ApproveRemark:       "",
				ApproveUserId:       userItem.AdminId,
				ApproveUserName:     userItem.Name,
				ApproveRoleTypeCode: userItem.RoleTypeCode,
				NodeId:              nodeItem.NodeId,
				NodeType:            nodeItem.NodeType,
				NextNodeId:          nodeItem.NextNodeId,
				PrevNodeId:          nodeItem.PrevNodeId,
				AuditType:           nodeItem.AuditType,
				CreateTime:          time.Now(),
				ModifyTime:          time.Now(),
			}
			contractApprovalRecordList = append(contractApprovalRecordList, contractApprovalRecord)
			ApproveUserMap[userItem.AdminId] = userItem
		}

	}

	err = contractApproval.Apply(contractApproval, contractApprovalRecordList)
	if err != nil {
		return
	}

	//待办通知
	{
		//发送消息下级审批人
		go messageToNodeUser(contractApproval.CurrNodeId, recodeInfo.ApplyUserId, companyInfo.CompanyId, contractApproval.ContractId, contractApproval.ContractApprovalId, 1, 1, companyInfo.CompanyName, messageContent)
	}
	return
}

// CancelApply 撤回审批
func CancelApply(recordInfo *company_approval.CompanyApproval, opUserId int) (err error) {
	if recordInfo == nil {
		err = errors.New("客户单异常，没有客户单信息")
		return
	}

	//客户单状态判断
	if recordInfo.ApproveStatus != "待审批" {
		err = errors.New("客户单状态异常，不允许撤回申请，当前客户单状态：" + recordInfo.ApproveStatus)
		return
	}

	//校验操作人与客户单申请人是否同一人
	if recordInfo.ApplyUserId != opUserId {
		err = errors.New(fmt.Sprint("操作人异常，不允许撤回非本人提交的申请；客户单发起人：", recordInfo.ApplyUserId, ";撤销人：", opUserId))
		return
	}

	//获取最近一次待审批的审批单信息
	approval, err := contract_approval.GetLastContractApprovalByContractId(recordInfo.CompanyApprovalId, "company")
	if err != nil {
		return
	}
	//是否一级审批节点判断，如果不是一级审批节点，那么不允许撤回
	if approval.StartNodeId != approval.CurrNodeId {
		err = errors.New("审批单状态异常，不允许撤回申请，当前审批单已被审批操作，进入了下一级审批节点")
		return
	}

	//获取当前待审批的审批流信息
	approvalRecord, err := contract_approval_record.GetCurrContractApprovalRecordByContractId(approval.ContractApprovalId)
	if err != nil {
		return
	}
	//判断当前节点是否存在上级节点，如果存在，那么说明
	if approvalRecord.PrevNodeId > 0 {
		err = errors.New("合同已存在审批操作，不允许撤回申请")
		return
	}

	//获取当前审批单中所有待审批的流程流
	approvalRecordList, err := contract_approval_record.GetPendingContractApprovalRecordListByContractId(approval.ContractApprovalId, approvalRecord.NodeId)
	if err != nil {
		return
	}

	//撤回审批流
	err = approval.Cancel(approval, approvalRecordList)
	if err != nil {
		return
	}

	//添加操作日志 （？？这个看情况再说，或许没有必要）

	//作废原有消息
	//for _, contractApprovalRecord := range approvalRecordList {
	//	go company_approval_message.CancelCompanyApprovalMessage(contractApprovalRecord.ContractApprovalRecordId, 2)
	//}
	go company_approval_message.CancelCompanyApprovalMessage(approval.ContractId, 2)

	return
}

// Reject 驳回审批
func Reject(approvalRecord *contract_approval_record.ContractApprovalRecord, opUser *custom.AdminWx, rejectRemark string) (err error) {
	if approvalRecord == nil {
		err = errors.New("审批流异常，没有审批流信息")
		return
	}

	//审批流状态判断
	if approvalRecord.Status != "待审批" {
		err = errors.New("审批流状态异常，不允许驳回申请，当前审批流状态：" + approvalRecord.Status)
		return
	}

	//判断是否审批类型，如果不是审批类型，那么就没有审批权限
	if approvalRecord.NodeType != "check" {
		err = errors.New("当前账号没有审批权限")
		return
	}

	//操作人
	opUserId := opUser.AdminId
	opUserName := opUser.RealName

	//操作权限校验
	if opUser.RoleTypeCode != approvalRecord.ApproveRoleTypeCode {
		err = errors.New("当前账号没有审批权限")
		return
	}
	if approvalRecord.ApproveUserId > 0 && approvalRecord.ApproveUserId != opUserId {
		err = errors.New("当前账号没有审批权限，需要指定人操作")
		return
	}

	//获取审批单详情
	approval, err := contract_approval.GetContractApprovalById(approvalRecord.ContractApprovalId)
	if err != nil {
		return
	}

	//审批单状态判断
	if approval.Status != "待审批" {
		err = errors.New("审批单状态异常，不允许驳回申请，当前审批单状态：" + approval.Status)
		return
	}

	//获取 客户单 信息
	recordInfo, err := company_approval.GetCompanyApprovalById(approval.ContractId)
	if err != nil {
		return
	}

	//客户单 状态判断
	if recordInfo.ApproveStatus != "待审批" {
		err = errors.New("客户单状态异常，不允许驳回申请，当前客户单状态：" + recordInfo.ApproveStatus)
		return
	}

	//获取 客户 信息
	companyInfo, err := company.GetCompanyById(recordInfo.CompanyId)
	if err != nil {
		return
	}
	err = approval.Reject(approval, approvalRecord, opUserId, opUserName, rejectRemark)
	if err != nil {
		return
	}

	//添加操作日志
	//remark := "驳回申请"
	//_ = contract.AddContractOperationRecord(contractInfo.ContractId, opUserId, approvalRecord.ContractApprovalRecordId, "reject", opUserName, remark)

	//完成审批后的驳回操作
	go afterReject(approval.ContractId, opUserId, opUserName, rejectRemark)

	//待办通知
	{
		//content := contractInfo.CompanyName + " 合同模板已驳回"
		content := companyInfo.CompanyName + " " + recordInfo.ApproveContent + "审批驳回"
		approvalSysUser, _ := admin.GetAdminById(approval.ApplyUserId)
		go services.AddCompanyApprovalMessage(opUserId, approval.ApplyUserId, companyInfo.CompanyId, approval.ContractId, 2, sourceType, 3, companyInfo.CompanyName, content, content, approvalSysUser.Mobile)
	}
	return
}

// Approved 审批通过
func Approved(approvalRecord *contract_approval_record.ContractApprovalRecord, opUser *custom.AdminWx, approvedRemark string) (err error) {
	if approvalRecord == nil {
		err = errors.New("审批流异常，没有审批流信息")
		return
	}

	//审批流状态判断
	if approvalRecord.Status != "待审批" {
		err = errors.New("审批流状态异常，不允许审批，当前审批流状态：" + approvalRecord.Status)
		return
	}

	//判断是否审批类型，如果不是审批类型，那么就没有审批权限
	if approvalRecord.NodeType != "check" {
		err = errors.New("当前账号没有审批权限")
		return
	}

	//操作人
	opUserId := opUser.AdminId
	//opUserName := opUser.RealName
	//操作权限校验
	if opUser.RoleTypeCode != approvalRecord.ApproveRoleTypeCode {
		err = errors.New("当前账号没有审批权限")
		return
	}
	if approvalRecord.ApproveUserId > 0 && approvalRecord.ApproveUserId != opUserId {
		err = errors.New("当前账号没有审批权限，需要指定人操作")
		return
	}

	//获取审批单详情
	approval, err := contract_approval.GetContractApprovalById(approvalRecord.ContractApprovalId)
	if err != nil {
		return
	}

	//审批单状态判断
	if approval.Status != "待审批" {
		err = errors.New("审批单状态异常，不允许审批，当前审批单状态：" + approval.Status)
		return
	}

	//获取 客户单 信息
	recordInfo, err := company_approval.GetCompanyApprovalById(approval.ContractId)
	if err != nil {
		return
	}
	//客户单 状态判断
	if recordInfo.ApproveStatus != "待审批" {
		err = errors.New("客户单状态异常，不允许审批，当前客户单状态：" + recordInfo.ApproveStatus)
		return
	}

	//获取 客户 信息
	companyInfo, err := company.GetCompanyById(recordInfo.CompanyId)
	if err != nil {
		return
	}

	//if contractApprovalRecord
	err = approval.Approved(approval, approvalRecord, approvedRemark)
	if err != nil {
		return
	}

	//添加操作日志
	//remark := "审批通过"
	//_ = contract.AddContractOperationRecord(contractInfo.ContractId, opUserId, approvalRecord.ContractApprovalRecordId, "approval", opUserName, remark)

	//发送信息给所有抄送人
	content := companyInfo.CompanyName + " " + recordInfo.ApproveContent + "审批通过"

	//如果下一个节点属于结束节点，那么通知对应的销售，同时，异步生成合同pdf
	if approvalRecord.NextNodeId == 0 {
		//待办通知（通知销售已经审核通过了）
		{
			approvalSysUser, _ := admin.GetAdminById(approval.ApplyUserId)
			go services.AddCompanyApprovalMessage(opUserId, approval.ApplyUserId, companyInfo.CompanyId, approval.ContractId, 2, sourceType, 2, companyInfo.CompanyName, content, content, approvalSysUser.Mobile)
		}

		// 客户单审批后的异步操作（修改客户单信息、修改合同权限等）
		go afterApproved(recordInfo.CompanyApprovalId, opUser.AdminId, opUser.RealName)
	} else {
		//获取下级节点信息
		flowNodeInfo, tmpErr := approval_flow_node.GetByNodeId(approvalRecord.NextNodeId)
		if tmpErr != nil {
			err = tmpErr
			return
		}

		//如果该级节点是抄送类型，那么需要将该节点给处理掉
		if flowNodeInfo.NodeType == "cc" {
			go approvedByCc(approvedRemark, approvalRecord)
		} else {
			//发送消息下级审批人
			go messageToNodeUser(approvalRecord.NextNodeId, approval.ApplyUserId, companyInfo.CompanyId, approval.ContractId, approval.ContractApprovalId, 1, 1, companyInfo.CompanyName, content)
		}
	}

	return
}

// approvedByCc 审批通过（抄送节点）
func approvedByCc(approvedRemark string, sourceApprovalRecord *contract_approval_record.ContractApprovalRecord) (err error) {
	//下个流程节点id
	nextNodeId := 0
	//获取审批单中抄送节点的所有数据列表
	approvalRecordList, err := contract_approval_record.GetContractApprovalRecordListByContractIdAndNode(sourceApprovalRecord.ContractApprovalId, sourceApprovalRecord.NextNodeId)
	if err != nil {
		return
	}
	//遍历所有的抄送单
	for _, contractApprovalRecord := range approvalRecordList {
		nextNodeId = contractApprovalRecord.NextNodeId
		//审批流状态判断
		if contractApprovalRecord.Status != "待审批" {
			err = errors.New("审批流状态异常，不允许审批，当前审批流状态：" + contractApprovalRecord.Status)
			return
		}
		//判断是否审批类型，如果不是审批类型，那么就没有审批权限
		if contractApprovalRecord.NodeType != "cc" {
			err = errors.New("当前账号不是抄送权限")
			return
		}
	}

	//获取审批单详情
	approval, err := contract_approval.GetContractApprovalById(sourceApprovalRecord.ContractApprovalId)
	if err != nil {
		return
	}

	//获取 客户单 信息
	recordInfo, err := company_approval.GetCompanyApprovalById(approval.ContractId)
	if err != nil {
		return
	}
	//客户单 状态判断
	if recordInfo.ApproveStatus != "待审批" {
		err = errors.New("客户单状态异常，不允许审批，当前客户单状态：" + recordInfo.ApproveStatus)
		return
	}

	//获取 客户 信息
	companyInfo, err := company.GetCompanyById(recordInfo.CompanyId)
	if err != nil {
		return
	}

	//if contractApprovalRecord
	err = approval.ApprovedByCc(approval, approvalRecordList, approvedRemark, nextNodeId)
	if err != nil {
		return
	}

	content := companyInfo.CompanyName + " " + recordInfo.ApproveContent + "审批通过"
	//发送消息给抄送人
	go messageToNodeUser(approvalRecordList[0].NodeId, approval.ApplyUserId, companyInfo.CompanyId, approval.ContractId, approval.ContractApprovalId, 1, 1, companyInfo.CompanyName, content)

	//如果下一个节点属于结束节点，那么通知对应的销售，同时，异步生成合同pdf
	if nextNodeId == 0 {
		//待办通知
		{
			approvalSysUser, _ := admin.GetAdminById(approval.ApplyUserId)
			go services.AddCompanyApprovalMessage(sourceApprovalRecord.ApproveUserId, approval.ApplyUserId, companyInfo.CompanyId, approval.ContractId, 2, sourceType, 2, companyInfo.CompanyName, content, content, approvalSysUser.Mobile)
		}

		//客户单审批后的异步操作（修改客户单信息、修改合同权限等）
		go afterApproved(recordInfo.CompanyApprovalId, sourceApprovalRecord.ApproveUserId, sourceApprovalRecord.ApproveUserName)
	} else {
		//获取下级节点信息
		flowNodeInfo, tmpErr := approval_flow_node.GetByNodeId(nextNodeId)
		if tmpErr != nil {
			err = tmpErr
			return
		}
		//如果下级节点是抄送类型，那么还是需要处理抄送节点逻辑
		if flowNodeInfo.NodeType == "cc" {
			go approvedByCc(approvedRemark, sourceApprovalRecord)
		} else {
			//如果下级级节点是审批类型
			//发送消息下级审批人
			go messageToNodeUser(nextNodeId, approval.ApplyUserId, companyInfo.CompanyId, approval.ContractId, approval.ContractApprovalId, 1, 1, companyInfo.CompanyName, content)
		}
	}

	return
}

// messageToNodeUser 抄送信息给用户（根据节点来推送）
func messageToNodeUser(flowNodeId, createUserId, companyId, companyApprovalId, contractApprovalId, messageType, approvalStatus int, companyName, content string) (err error) {
	//获取审批单中抄送节点的所有数据列表
	contractApprovalRecordList, err := contract_approval_record.GetContractApprovalRecordListByContractIdAndNode(contractApprovalId, flowNodeId)

	if err != nil {
		return
	}
	err = messageToUser(contractApprovalRecordList, createUserId, companyId, companyApprovalId, messageType, approvalStatus, companyName, content)
	return
}

// messageToAllCcUser 发送信息给所有抄送人
// @param createUserId 消息发起人
// @param contractApprovalId 审批单id
// @param messageType 消息类型：1:申请消息，2:审批结果
// @param approvalStatus 审批状态：1:待审批，2:已审批，3:已驳回"
// @param companyName 企业客户名称
// @param content 消息内容
func messageToAllCcUser(createUserId, companyId, companyApprovalId, contractApprovalId, messageType, approvalStatus int, companyName, content string) (err error) {
	//获取审批单中抄送节点的所有数据列表
	contractApprovalRecordList, err := contract_approval_record.GetContractApprovalRecordListByContractApprovalId(contractApprovalId)

	if err != nil {
		return
	}
	err = messageToUser(contractApprovalRecordList, createUserId, companyId, companyApprovalId, messageType, approvalStatus, companyName, content)
	return
}

// messageToUser 抄送信息给用户（发送给所有抄送人）
// @param createUserId 待审批、抄送记录
// @param createUserId 消息发起人
// @param contractApprovalId 审批单id
// @param messageType 消息类型：1:申请消息，2:审批结果
// @param approvalStatus 审批状态：1:待审批，2:已审批，3:已驳回"
// @param companyName 企业客户名称
// @param content 消息内容
func messageToUser(contractApprovalRecordList []*contract_approval_record.ContractApprovalRecord, createUserId, companyId, companyApprovalId, messageType, approvalStatus int, companyName, content string) (err error) {
	for _, contractApprovalRecord := range contractApprovalRecordList {
		sysUserMobile := ""
		sysUser, _ := admin.GetAdminById(contractApprovalRecord.ApproveUserId)
		if sysUser != nil {
			sysUserMobile = sysUser.Mobile
		}
		//接收人，就是审批记录里面的待审核人（抄送人）
		receiveUserId := contractApprovalRecord.ApproveUserId

		go services.AddCompanyApprovalMessage(createUserId, receiveUserId, companyId, companyApprovalId, messageType, sourceType, approvalStatus, companyName, content, content, sysUserMobile)
	}
	return
}

// afterApproved 审批完成后操作
func afterApproved(companyApprovalId int, opUserId int, opUserName string) (err error) {
	defer func() {
		if err != nil {
			//fmt.Println("异常提醒:"+utils.RunMode, "合同审批通过后，生成pdf失败，ERR:"+err.Error()+"", utils.EmailSendToUsers)
			go utils.SendEmail("异常提醒:"+utils.RunMode, "合同审批通过后，生成pdf失败，ERR:"+err.Error()+"", utils.EmailSendToUsers)
		}

	}()
	opUser := custom.AdminWx{
		AdminId:  opUserId,
		RealName: opUserName,
	}
	//获取客户单详情
	recodeInfo, err := company_approval.GetCompanyApprovalByApprovalId(companyApprovalId)
	if err != nil {
		err = errors.New("获取合同信息失败，Err:" + err.Error())
		return
	}
	if recodeInfo == nil {
		err = errors.New("客户单异常，找不到客户单信息")
		return
	}
	//获取客户信息
	companyInfo, err := company.GetCompanyById(recodeInfo.CompanyId)
	if err != nil {
		err = errors.New("获取合同信息失败，Err:" + err.Error())
		return
	}
	if companyInfo == nil {
		err = errors.New("客户信息异常，找不到客户信息")
		return
	}

	//客户产品信息
	companyProduct, err := company_product.GetCompanyProductByCompanyIdAndProductId(recodeInfo.CompanyId, recodeInfo.ProductId)
	if err != nil {
		err = errors.New(fmt.Sprint("获取信息客户产品失败", ";Err:"+err.Error()))
		return
	}
	if companyProduct == nil {
		err = errors.New("获取信息客户产品失败2")
		return
	}

	logSellerId := recodeInfo.ApplyUserId
	logSellerName := recodeInfo.ApplyRealName
	isAddCompanyProductUpdateLog := true //是否添加变更日志

	switch recodeInfo.ApplyMethod {
	case 1: //试用转正式
		//获取合同信息
		contractInfo, tmpErr := company_contract.GetCompanyContractDetail(recodeInfo.CompanyId, recodeInfo.ProductId, recodeInfo.CompanyContractId)
		if tmpErr != nil {
			err = errors.New(fmt.Sprint("待审批信息不存在,CompanyId:", recodeInfo.CompanyId, ";productId:", recodeInfo.ProductId, ";Err:"+tmpErr.Error()))
			return
		}
		if contractInfo == nil {
			err = errors.New(fmt.Sprint("待审批信息不存在,CompanyId:", recodeInfo.CompanyId, ";productId:", recodeInfo.ProductId))
			return
		}

		//格式化合同开始时间
		contractStartDate, tmpErr := time.Parse(utils.FormatDate, contractInfo.StartDate)
		if tmpErr != nil {
			err = errors.New("合同开始时间转换失败,Err:" + tmpErr.Error())
			return
		}
		//格式化合同结束日期
		contractEndDate, tmpErr := time.Parse(utils.FormatDate, contractInfo.EndDate)
		if tmpErr != nil {
			err = errors.New("合同结束时间转换失败,Err:" + tmpErr.Error())
			return
		}
		//格式化 产品中 合同结束日期
		//productContractEndDate, err := time.Parse(utils.FormatDate, companyProduct.ContractEndDate)
		//if err != nil {
		//	br.Msg = "审批失败"
		//	br.ErrMsg = "产品中合同结束时间转换失败,Err:" + err.Error()
		//	return
		//}
		//如果合同时间小于等于今天，那么立马执行合同内容
		if time.Now().After(contractStartDate) {
			tmpErr = company_approval.TryOutToFormal(recodeInfo.CompanyId, recodeInfo.ProductId, opUser.AdminId, recodeInfo.CompanyApprovalId, contractInfo.CompanyContractId, contractInfo.StartDate, contractInfo.EndDate, opUser.RealName, companyProduct.ProductName, contractInfo.PackageType)
			if tmpErr != nil {
				err = errors.New("试用转正式失败,Err:" + tmpErr.Error())
				return
			}
		} else {
			tmpErr = company_approval.ApplyApproveContract(recodeInfo.CompanyId, recodeInfo.ProductId, recodeInfo.CompanyApprovalId, contractInfo.CompanyContractId)
			if tmpErr != nil {
				err = errors.New("试用转正式失败,Err:" + tmpErr.Error())
				return
			}
			//不添加日志
			isAddCompanyProductUpdateLog = false
		}
		//如果合同中的结束日期大于产品中的合同结束日期，那么就去修改产品中的合同结束日期
		if contractEndDate.After(companyProduct.ContractEndDate) {
			companyProduct.ContractEndDate = contractEndDate
			cols := make([]string, 0)
			cols = append(cols, "ContractEndDate")
			_ = companyProduct.Update(cols)
		}
	case 2: //冻结->试用
		tmpErr := company_approval.FreezeToTryOut(recodeInfo.CompanyId, recodeInfo.ProductId, opUser.AdminId, recodeInfo.CompanyApprovalId, recodeInfo.ApplyUserId, opUser.RealName, companyProduct.ProductName)
		if tmpErr != nil {
			err = errors.New("冻结转试用失败,Err:" + tmpErr.Error())
			return
		}
	case 3: //试用延期
		tmpErr := company_approval.TryOutDelay(recodeInfo.CompanyId, recodeInfo.ProductId, opUser.AdminId, recodeInfo.CompanyApprovalId, opUser.RealName, companyProduct.EndDate, companyProduct.ProductName)
		if tmpErr != nil {
			err = errors.New("试用延期失败,Err:" + tmpErr.Error())
			return
		}
	case 4: //原销售申请领取流失客户
		tmpErr := company_approval.ApplyReceive(recodeInfo.CompanyId, recodeInfo.ProductId, opUser.AdminId, recodeInfo.CompanyApprovalId, recodeInfo.ApplyUserId, opUser.RealName, companyProduct.ProductName)
		if tmpErr != nil {
			err = errors.New("原销售申请领取流失客户失败,Err:" + tmpErr.Error())
			return
		}
	case 5, 6: //正式客户申请服务更新
		//获取合同信息
		contractInfo, tmpErr := company_contract.GetCompanyContractDetail(recodeInfo.CompanyId, recodeInfo.ProductId, recodeInfo.CompanyContractId)
		if tmpErr != nil {
			err = errors.New(fmt.Sprint("正式客户申请服务更新失败，待审批合同信息不存在,CompanyId：", recodeInfo.CompanyId, ";productId:", recodeInfo.ProductId, ";Err:"+tmpErr.Error()))
			return
		}
		if contractInfo == nil {
			err = errors.New(fmt.Sprint("正式客户申请服务更新失败，待审批合同信息不存在2,CompanyId：", recodeInfo.CompanyId, ";productId:", recodeInfo.ProductId))
			return
		}
		//格式化合同开始时间
		contractStartDate, tmpErr := time.Parse(utils.FormatDate, contractInfo.StartDate)
		if tmpErr != nil {
			err = errors.New(fmt.Sprint("正式客户申请服务更新失败，合同开始时间转换失败;Err:" + tmpErr.Error()))
			return
		}

		//格式化合同结束日期
		contractEndDate, tmpErr := time.Parse(utils.FormatDate, contractInfo.EndDate)
		if tmpErr != nil {
			err = errors.New(fmt.Sprint("正式客户申请服务更新失败，合同结束时间转换失败;Err:" + tmpErr.Error()))
			return
		}
		//格式化 产品中 合同结束日期
		//productContractEndDate, err := time.Parse(utils.FormatDate, companyProduct.ContractEndDate)
		//if err != nil {
		//	br.Msg = "审批失败"
		//	br.ErrMsg = "产品中合同结束时间转换失败,Err:" + err.Error()
		//	return
		//}

		//如果合同时间小于等于今天，那么立马执行合同内容
		if time.Now().After(contractStartDate) {
			err = company_approval.ApplyServiceUpdate(recodeInfo.CompanyId, recodeInfo.ProductId, opUser.AdminId, recodeInfo.CompanyApprovalId, recodeInfo.CompanyContractId, companyProduct.StartDate, contractInfo.EndDate, opUser.RealName, companyProduct.ProductName, contractInfo.PackageType)
			if tmpErr != nil {
				err = errors.New(fmt.Sprint("正式客户申请服务更新失败，执行失败;Err:" + tmpErr.Error()))
				return
			}
		} else {
			tmpErr = company_approval.ApplyApproveContract(recodeInfo.CompanyId, recodeInfo.ProductId, recodeInfo.CompanyApprovalId, recodeInfo.CompanyContractId)
			if tmpErr != nil {
				err = errors.New(fmt.Sprint("正式客户申请服务更新失败，执行失败2;Err:" + tmpErr.Error()))
				return
			}
			//不添加日志
			isAddCompanyProductUpdateLog = false
		}

		//如果合同中的结束日期大于产品中的合同结束日期，那么就去修改产品中的合同结束日期
		if contractEndDate.After(companyProduct.ContractEndDate) {
			companyProduct.ContractEndDate = contractEndDate
			cols := make([]string, 0)
			cols = append(cols, "ContractEndDate")
			_ = companyProduct.Update(cols)
		}
	default:
		err = errors.New(fmt.Sprint("无效的审批状态,CompanyId:", recodeInfo.CompanyId, ";productId:", recodeInfo.ProductId, ";ApplyMethod:", recodeInfo.ApplyMethod, ";ApproveStatus:", recodeInfo.ApproveStatus))
		return
	}

	//新增客户产品日志
	{
		productLog := new(company_product_log.CompanyProductLog)
		productLog.CompanyProductId = companyProduct.CompanyProductId
		productLog.CompanyId = companyProduct.CompanyId
		productLog.ProductId = companyProduct.ProductId
		productLog.ProductName = companyProduct.ProductName
		productLog.CompanyName = companyProduct.CompanyName
		productLog.CompanyName = companyProduct.CompanyName
		productLog.Source = companyProduct.Source
		productLog.Reasons = companyProduct.Reasons
		productLog.Status = companyProduct.Status
		productLog.IndustryId = companyProduct.IndustryId
		productLog.IndustryName = companyProduct.IndustryName
		productLog.SellerId = companyProduct.SellerId
		productLog.SellerName = companyProduct.SellerName
		productLog.GroupId = companyProduct.GroupId
		productLog.DepartmentId = companyProduct.DepartmentId
		productLog.IsSuspend = companyProduct.IsSuspend
		productLog.SuspendTime = companyProduct.SuspendTime
		productLog.ApproveStatus = companyProduct.ApproveStatus
		productLog.FreezeTime = companyProduct.FreezeTime
		productLog.Remark = companyProduct.Remark
		productLog.StartDate = companyProduct.StartDate
		productLog.EndDate = companyProduct.EndDate
		productLog.CreateTime = companyProduct.CreateTime
		productLog.ModifyTime = companyProduct.ModifyTime
		productLog.LoseReason = companyProduct.LoseReason
		productLog.LossTime = companyProduct.LossTime
		productLog.LogType = "modify"
		productLog.LogCreateTime = time.Now()
		productLog.AdminId = opUserId
		go company_product_log.AddCompanyProductLog(productLog)
	}
	//新增操作记录
	{
		remark := "审批"
		operation := "approve"
		approveContent := "审批通过"

		services.AddCompanyOperationRecord(recodeInfo.CompanyId, companyProduct.SellerId, opUserId, recodeInfo.ProductId, opUserId, companyProduct.CompanyName,
			companyProduct.ProductName, opUserName, remark, operation, approveContent, opUserName, "", companyProduct.Status)
	}

	//新增客户产品状态变更日志
	if isAddCompanyProductUpdateLog {
		updateSource := ``
		switch recodeInfo.ApplyMethod {
		case 1: //试用转正式
			updateSource = `turn_positive`
		case 2: //冻结->试用
			updateSource = "thaw"
		case 3: //试用延期
			updateSource = "delay"
		case 4: //原销售申请领取流失客户
			updateSource = "apply_receive"
		case 5: //正式客户申请续约
			updateSource = "service_update"
		case 6: //正式客户新增补充协议
			updateSource = "add_agreement"
		}
		companyProductUpdateLog := &company_product_update_log.CompanyProductUpdateLog{
			Id:         0,
			CompanyId:  companyProduct.CompanyId,
			ProductId:  companyProduct.ProductId,
			Status:     companyProduct.Status,
			SellerId:   logSellerId,
			SellerName: logSellerName,
			Source:     updateSource,
			IsFormal:   companyProduct.IsFormal, //是否已经转正式，0是没有转正式，1是已经转过正式
			CreateTime: time.Now(),
		}
		go company_product_update_log.AddCompanyProductUpdateLog(companyProductUpdateLog)
	}
	return
}

// afterReject 驳回完成后操作
func afterReject(companyApprovalId, opUserId int, opUserName, remark string) (err error) {
	defer func() {
		if err != nil {
			fmt.Println("异常提醒:"+utils.RunMode, "合同审批通过后，生成pdf失败，ERR:"+err.Error()+"", utils.EmailSendToUsers)
			go utils.SendEmail("异常提醒:"+utils.RunMode, "合同审批通过后，生成pdf失败，ERR:"+err.Error()+"", utils.EmailSendToUsers)
		}

	}()
	//获取客户单详情
	recodeInfo, err := company_approval.GetCompanyApprovalByApprovalId(companyApprovalId)
	if err != nil {
		err = errors.New("获取合同信息失败，Err:" + err.Error())
		return
	}
	if recodeInfo == nil {
		err = errors.New("客户单异常，找不到客户单信息")
		return
	}
	//获取客户信息
	companyInfo, err := company.GetCompanyById(recodeInfo.CompanyId)
	if err != nil {
		err = errors.New("获取合同信息失败，Err:" + err.Error())
		return
	}
	if companyInfo == nil {
		err = errors.New("客户信息异常，找不到客户信息")
		return
	}
	//客户产品信息
	companyProduct, err := company_product.GetCompanyProductByCompanyIdAndProductId(recodeInfo.CompanyId, recodeInfo.ProductId)
	if err != nil {
		err = errors.New(fmt.Sprint("获取信息客户产品失败", ";Err:"+err.Error()))
		return
	}
	if companyProduct == nil {
		err = errors.New("获取信息客户产品失败2")
		return
	}

	approveStatus := "驳回"
	err = company_approval.ApproveRefuse(recodeInfo.CompanyId, recodeInfo.ProductId, approveStatus, remark)
	if err != nil {
		err = errors.New("客户单审批驳回失败,Err:" + err.Error())
		return
	}

	//新增客户产品日志
	{
		productLog := new(company_product_log.CompanyProductLog)
		productLog.CompanyProductId = companyProduct.CompanyProductId
		productLog.CompanyId = companyProduct.CompanyId
		productLog.ProductId = companyProduct.ProductId
		productLog.ProductName = companyProduct.ProductName
		productLog.CompanyName = companyProduct.CompanyName
		productLog.CompanyName = companyProduct.CompanyName
		productLog.Source = companyProduct.Source
		productLog.Reasons = companyProduct.Reasons
		productLog.Status = companyProduct.Status
		productLog.IndustryId = companyProduct.IndustryId
		productLog.IndustryName = companyProduct.IndustryName
		productLog.SellerId = companyProduct.SellerId
		productLog.SellerName = companyProduct.SellerName
		productLog.GroupId = companyProduct.GroupId
		productLog.DepartmentId = companyProduct.DepartmentId
		productLog.IsSuspend = companyProduct.IsSuspend
		productLog.SuspendTime = companyProduct.SuspendTime
		productLog.ApproveStatus = companyProduct.ApproveStatus
		productLog.FreezeTime = companyProduct.FreezeTime
		productLog.Remark = companyProduct.Remark
		productLog.StartDate = companyProduct.StartDate
		productLog.EndDate = companyProduct.EndDate
		productLog.CreateTime = companyProduct.CreateTime
		productLog.ModifyTime = companyProduct.ModifyTime
		productLog.LoseReason = companyProduct.LoseReason
		productLog.LossTime = companyProduct.LossTime
		productLog.LogType = "modify"
		productLog.LogCreateTime = time.Now()
		productLog.AdminId = opUserId
		go company_product_log.AddCompanyProductLog(productLog)
	}
	//新增操作记录
	{
		remark := "审批"
		operation := "approve"
		approveContent := "审批驳回"

		services.AddCompanyOperationRecord(recodeInfo.CompanyId, companyProduct.SellerId, opUserId, recodeInfo.ProductId, opUserId, companyProduct.CompanyName,
			companyProduct.ProductName, opUserName, remark, operation, approveContent, opUserName, remark, companyProduct.Status)
	}
	return
}

// CheckApproveAuth 校验审批操作权限
func CheckApproveAuth(companyId, productId int, opUser *custom.AdminWx) (approvalItem *company_approval.CompanyApproval, approvalInfo *contract_approval.ContractApproval, approvalRecord *contract_approval_record.ContractApprovalRecord, err error) {
	//客户单详情
	approvalItem, err = company_approval.GetCompanyApprovalByCompanyId(companyId, productId)
	if err != nil {
		err = errors.New("获取客户单失败，Err:" + err.Error())
		return
	}
	//客户单状态判断
	if approvalItem.ApproveStatus != "待审批" {
		err = errors.New("客户单状态异常，不允许操作申请，当前客户单状态：" + approvalItem.ApproveStatus)
		return
	}

	//获取该最近一条审批单详情
	approvalInfo, err = contract_approval.GetLastContractApprovalByContractId(approvalItem.CompanyApprovalId, "company")
	if err != nil {
		err = errors.New("获取审批单失败，Err:" + err.Error())
		return
	}
	if approvalInfo.Status != "待审批" {
		err = errors.New("当前审批单状态异常，不允许审批，审批单状态：" + approvalInfo.Status)
		return
	}

	//审批流
	approvalRecordList, err := contract_approval_record.GetContractApprovalRecordListByContractApprovalIdAndNodeId(approvalInfo.ContractApprovalId, approvalInfo.CurrNodeId)
	if err != nil {
		err = errors.New("获取审批失败，Err:" + err.Error())
		return
	}
	for _, tmpApprovalRecord := range approvalRecordList {
		if tmpApprovalRecord.NodeType == "check" && tmpApprovalRecord.ApproveUserId == opUser.AdminId {
			approvalRecord = tmpApprovalRecord
		}
	}

	if approvalRecord == nil {
		err = errors.New("当前账号没有审批权限")
		return
	}
	return
}

//获取审批流和权限
func GetOpButton(approvalItem *company_approval.CompanyApprovalList, contractApprovalInfo *contract_approval.ContractApproval, opUser *custom.AdminWx) (flowNodeListResp [][]contract_approval_record.ContractApprovalRecord, err error) {
	//审批流
	approvalRecordList, err := contract_approval_record.GetContractApprovalRecordListByContractApprovalId(contractApprovalInfo.ContractApprovalId)
	if err != nil {
		err = errors.New("获取审批失败，Err:" + err.Error())
		return
	}
	flowNodeMap := make(map[int][]contract_approval_record.ContractApprovalRecord, 0)
	keySort := make([]int, 0)
	for _, approvalRecord := range approvalRecordList {
		//如果当前节点正好是该节点，同时审批单状态是待审批状态，然后当前账号又有权限，该账号也正是审批人，那么允许审批操作
		if contractApprovalInfo.CurrNodeId == approvalRecord.NodeId && contractApprovalInfo.Status == "待审批" {
			if opUser.AdminId == approvalRecord.ApproveUserId && approvalRecord.NodeType == "check" {
				approvalItem.OpButton = true
			}
		}
		//如果当前节点正好是该节点，同时审批单状态又是第一层节点
		if contractApprovalInfo.CurrNodeId == approvalRecord.NodeId && approvalRecord.PrevNodeId == 0 && contractApprovalInfo.Status == "待审批" {
			//发起人具有撤回审批单权限
			//if opUser.AdminId == sealInfo.UserId {
			//	sealOpButton.Cancel = true
			//}
		}
		if tmpFlowNodeList, ok := flowNodeMap[approvalRecord.NodeId]; ok {
			flowNodeMap[approvalRecord.NodeId] = append(tmpFlowNodeList, *approvalRecord)
		} else {
			tmpFlowNodeList := make([]contract_approval_record.ContractApprovalRecord, 1)
			tmpFlowNodeList[0] = *approvalRecord
			flowNodeMap[approvalRecord.NodeId] = tmpFlowNodeList

			keySort = append(keySort, approvalRecord.NodeId)
		}
	}
	for _, key := range keySort {
		flowNodeListResp = append(flowNodeListResp, flowNodeMap[key])
	}

	return
}

// GetApprovalDetailByCompanyApprovalId 根据客户单id获取客户单审批详情
func GetApprovalDetailByCompanyApprovalId(companyApprovalId int, opUser *custom.AdminWx) (approvalItem *company_approval.CompanyApprovalList, flowNodeListResp [][]contract_approval_record.ContractApprovalRecord, err error) {
	var condition string
	var pars []interface{}
	approvalItem, err = company_approval.GetApprovalInfoByApprovalId(condition, pars, companyApprovalId)
	if err != nil {
		err = errors.New("获取客户单详情失败,ERR:" + err.Error())
		return
	}
	if approvalItem.FreezeStartDate != "" && approvalItem.FreezeEndDate != "" && approvalItem.Status == utils.COMPANY_STATUS_FREEZE {
		freezeEndDate, _ := time.Parse(utils.FormatDate, approvalItem.FreezeEndDate)
		if time.Now().Before(freezeEndDate) {
			expireDays := freezeEndDate.Sub(time.Now()).Hours() / 24
			approvalItem.FreezeExpireDays = int(expireDays)
		}
	}
	if approvalItem.StartDate != "" && approvalItem.EndDate != "" {
		endDate, _ := time.Parse(utils.FormatDate, approvalItem.EndDate)
		if time.Now().Before(endDate) {
			expireDays := endDate.Sub(time.Now()).Hours() / 24
			approvalItem.ExpireDay = int(expireDays)
		}
	}

	switch approvalItem.ApplyMethod {
	case 2:
		//客户冻结转试用次数
		approvalCount, tmpErr := company_approval.GetFreezeToTryCompanyApprovalCount(approvalItem.CompanyId, approvalItem.ProductId, approvalItem.ApplyUserId)
		if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
			err = tmpErr
			return
		}
		approvalItem.ApprovalCount = approvalCount
	case 3:
		delayPermission, tmpErr := company_delay_permission.GetApplyDelayPermission(approvalItem.CompanyApprovalId)
		if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
			err = tmpErr
			return
		}
		approvalItem.DelayPermission = delayPermission

		//客户审批试用延期次数
		approvalCount, tmpErr := company_approval.GetCompanyTryDelayApprovalCount(approvalItem.CompanyId, approvalItem.ProductId)
		if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
			err = tmpErr
			return
		}
		approvalItem.ApprovalCount = approvalCount
	}

	//查询最近一次审批单信息
	lastApprovalInfo, err := contract_approval.GetLastContractApprovalByContractId(approvalItem.CompanyApprovalId, "company")
	if err != nil {
		if err.Error() != utils.ErrNoRow() {
			err = errors.New("获取最近一次审批单信息失败,ERR:" + err.Error())
		}
		err = nil
		return
	}
	if lastApprovalInfo != nil {
		//获取审批操作和审批流数据
		tmpFlowNodeListResp, tmpErr := GetOpButton(approvalItem, lastApprovalInfo, opUser)
		if tmpErr != nil {
			err = errors.New("获取客户单按钮权限、审批流程失败，Err:" + tmpErr.Error())
			return
		}
		flowNodeListResp = tmpFlowNodeListResp
	}
	return
}