hongze_mobile_admin/services/seal/seal.go

package seal

import (
	"errors"
	"fmt"
	"github.com/astaxie/beego/logs"
	"hongze/hongze_mobile_admin/models/custom"
	sealResp "hongze/hongze_mobile_admin/models/response/seal"
	"hongze/hongze_mobile_admin/models/tables/admin"
	"hongze/hongze_mobile_admin/models/tables/contract_approval"
	"hongze/hongze_mobile_admin/models/tables/contract_approval_record"
	"hongze/hongze_mobile_admin/models/tables/seal"
	"hongze/hongze_mobile_admin/services"
	contractService "hongze/hongze_mobile_admin/services/contract"
	"hongze/hongze_mobile_admin/utils"
	"strings"
	"time"
)

//添加用印
func AddSeal(userId, contractId, fileNum int, userName, use, useCompanyName, companyName, creditCode, serviceType, sealType, remark, fileUrl string) (sealInfo *seal.Seal, err error) {
	useList := []string{"销售合同", "渠道合同", "付款通知函", "招投标", "战略合作协议"}
	serviceTypeList := []string{"新签合同", "续约合同", "补充协议"}
	sealTypeList := []string{"合同章", "公章", "法人章"}
	if !strings.Contains(strings.Join(useList, ","), use) {
		err = errors.New("用印用途异常")
		return
	}
	if !strings.Contains(strings.Join(serviceTypeList, ","), serviceType) {
		err = errors.New("业务类型异常")
		return
	}
	if !strings.Contains(strings.Join(sealTypeList, ","), sealType) {
		err = errors.New("加盖印章类型异常")
		return
	}

	sealCode, err := seal.GetSealCode()
	if err != nil {
		return
	}
	sealInfo = &seal.Seal{
		Code:           sealCode,
		UserId:         userId,
		UserName:       userName,
		Use:            use,
		CompanyName:    companyName,
		UseCompanyName: useCompanyName,
		CreditCode:     creditCode,
		ServiceType:    serviceType,
		SealType:       sealType,
		Status:         "待提交",
		Remark:         remark,
		FileUrl:        fileUrl,
		FileNum:        fileNum,
		ContractId:     contractId,
		ModifyTime:     time.Now(),
		CreateTime:     time.Now(),
	}
	err = seal.AddSeal(sealInfo)
	return
}

//修改用印
func Edit(sealId, userId, contractId, fileNum int, use, companyName, userCompanyName, creditCode, serviceType, sealType, remark, fileUrl string) (sealInfo *seal.Seal, err error) {
	useList := []string{"销售合同", "渠道合同", "付款通知函", "招投标", "战略合作协议"}
	serviceTypeList := []string{"新签合同", "续约合同", "补充协议"}
	sealTypeList := []string{"合同章", "公章", "法人章"}
	if !strings.Contains(strings.Join(useList, ","), use) {
		err = errors.New("用印用途异常")
		return
	}
	if !strings.Contains(strings.Join(serviceTypeList, ","), serviceType) {
		err = errors.New("业务类型异常")
		return
	}
	if !strings.Contains(strings.Join(sealTypeList, ","), sealType) {
		err = errors.New("加盖印章类型异常")
		return
	}

	//查询当前合同信息
	sealInfo, err = seal.GetSealInfoById(sealId)
	if err != nil {
		if err.Error() == utils.ErrNoRow() {
			err = errors.New(fmt.Sprint("根据用印编号:", sealId, " 找不到该用印"))
		}
		return
	}
	if sealInfo.UserId != userId {
		err = errors.New("当前账号无操作权限")
		return
	}
	ignoreStatus := []string{"待提交", "已撤回", "已驳回"}
	if !strings.Contains(strings.Join(ignoreStatus, ","), sealInfo.Status) {
		err = errors.New("用印状态异常，不允许修改，当前用印状态：" + sealInfo.Status)
		return
	}
	//sealId,userId int, userName, use, companyName, creditCode, serviceType, sealType, remark, fileUrl string
	sealInfo.Use = use
	sealInfo.CompanyName = companyName
	sealInfo.UseCompanyName = userCompanyName
	sealInfo.CreditCode = creditCode
	sealInfo.ServiceType = serviceType
	sealInfo.SealType = sealType
	sealInfo.Remark = remark
	sealInfo.FileUrl = fileUrl
	sealInfo.FileNum = fileNum
	sealInfo.ContractId = contractId
	sealInfo.ModifyTime = time.Now()
	sealInfo.Status = "待提交" //用印状态

	err = sealInfo.Update([]string{"Use", "CompanyName", "CreditCode", "ServiceType", "SealType", "Remark", "FileUrl", "ModifyTime", "Status"})

	return
}

//审批者修改用印
func CheckEdit(sealInfo *seal.Seal, approvalInfo *contract_approval.ContractApproval, approvalRecord *contract_approval_record.ContractApprovalRecord, fileNum int, use, sealType, remark string, opUser *custom.AdminWx) (err error) {
	useList := []string{"销售合同", "渠道合同", "付款通知函", "招投标", "战略合作协议"}
	sealTypeList := []string{"合同章", "公章", "法人章"}
	if !strings.Contains(strings.Join(useList, ","), use) {
		err = errors.New("用印用途异常")
		return
	}
	if !strings.Contains(strings.Join(sealTypeList, ","), sealType) {
		err = errors.New("加盖印章类型异常")
		return
	}

	//判断是否是合规账号
	if opUser.RoleTypeCode != utils.ROLE_TYPE_CODE_COMPLIANCE {
		err = errors.New("当前账号无修改权限")
		return
	}

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

	//变更字段判断
	updateCol := make([]string, 0)
	updateContent := make([]string, 0)
	if sealInfo.Use != use {
		updateCol = append(updateCol, "Use")
		updateContent = append(updateContent, "用印用途")
	}
	if sealInfo.SealType != sealType {
		updateCol = append(updateCol, "SealType")
		updateContent = append(updateContent, "加盖何种印章")
	}
	if sealInfo.Remark != remark {
		updateCol = append(updateCol, "Remark")
		updateContent = append(updateContent, "备注")
	}
	if sealInfo.FileNum != fileNum {
		updateCol = append(updateCol, "FileNum")
		updateContent = append(updateContent, "文件份数")
	}
	if len(updateCol) <= 0 {
		err = errors.New("没有变更信息")
		return
	}
	content := "用印修改：" + opUser.AdminName + "修改了" + strings.Join(updateContent, "、")

	//如果变更了盖章类型（涉及到审批流程变更），那么需要变更审批流
	//变更审批流：先驳回用印申请，再修改用印，再发消息给申请人，再替申请人重新发起申请，
	//然后遍历审批流程，当前操作人节点之前的全部审核通过，最后通过当前操作人的节点（改成如果一级审批人如果是自己，那么直接通过这一级审批，否则不通过，让审批单重走流程）
	if (sealInfo.SealType == "合同章" && strings.Contains("公章,法人章", sealType)) || (strings.Contains("公章,法人章", sealInfo.SealType) && sealType == "合同章") {
		//先驳回
		err = Reject(sealInfo, approvalInfo, approvalRecord, opUser, "")
		if err != nil {
			return
		}
		//修改用印申请，给申请人发消息
		sealInfo.Use = use
		sealInfo.SealType = sealType
		sealInfo.Remark = remark
		sealInfo.FileNum = fileNum
		sealInfo.ModifyTime = time.Now()
		checkEdit(sealInfo, updateCol, approvalRecord.ContractApprovalRecordId, content, opUser)

		//重新获取最新的用印单
		sealInfo, tmpErr := seal.GetSealInfoById(sealInfo.SealId)
		if tmpErr != nil {
			err = tmpErr
			return
		}
		//重新发起申请
		err = CheckApply(sealInfo, opUser)
		if err != nil {
			return
		}

	} else { //修改用印基础信息 并 审批通过

		//修改用印申请，给申请人发消息
		sealInfo.Use = use
		sealInfo.SealType = sealType
		sealInfo.Remark = remark
		sealInfo.FileNum = fileNum
		sealInfo.ModifyTime = time.Now()
		checkEdit(sealInfo, updateCol, approvalRecord.ContractApprovalRecordId, content, opUser)

		//审核通过
		err = Approved(sealInfo, approvalInfo, approvalRecord, opUser, "")

	}

	return
}

func checkEdit(sealInfo *seal.Seal, updateCol []string, approvalRecordId int, content string, opUser *custom.AdminWx) {
	_ = sealInfo.Update(updateCol)

	//给用印人，发送修改消息
	sysUserMobile := ""
	sysUser, _ := admin.GetAdminById(opUser.AdminId)
	if sysUser != nil {
		sysUserMobile = sysUser.Mobile
	}
	go services.AddCompanyApprovalMessage(opUser.AdminId, sealInfo.UserId, 0, approvalRecordId, 3, sourceType, 2, sealInfo.CompanyName, content, content, sysUserMobile)
	return
}

//作废用印
func Invalid(sealId int, opUser *custom.AdminWx, isInvalidContract bool) (err error) {
	//查询当前合同信息
	sealInfo, err := seal.GetSealInfoById(sealId)
	if err != nil {
		if err.Error() == utils.ErrNoRow() {
			err = errors.New(fmt.Sprint("根据用印编号:", sealId, " 找不到初始用印"))
		}
		return
	}
	if sealInfo.UserId != opUser.AdminId && opUser.RoleTypeCode != utils.ROLE_TYPE_CODE_COMPLIANCE {
		err = errors.New("当前账号无操作权限")
		return
	}
	if sealInfo.Status != "已审批" {
		err = errors.New("用印状态异常，不允许作废，当前用印状态：" + sealInfo.Status)
		return
	}

	//如果删除状态 >0，那么代表已经被删除了
	if sealInfo.IsDelete > 0 {
		err = errors.New("该用印已删除")
		return
	}

	//用印作废
	err = seal.Invalid(sealInfo)
	if err != nil {
		return
	}

	//如果是系统合同，同时需要同步作废合同时，那么逻辑处理
	if sealInfo.ContractId > 0 && isInvalidContract {
		err = contractService.InvalidContract(sealInfo.ContractId, opUser)
		if err != nil {
			logs.Info("作废用印时，同步作废合同失败，Err:", err.Error())
		}
	}
	//添加操作日志
	//remark := "作废合同模板"
	//_ = contract_operation_record.AddContractOperationRecord(nowContract.ContractId, opUser.AdminId, 0, "invalid", opUser.RealName, remark)
	return
}

//获取审批流和权限
func GetOpButton(sealInfo *seal.Seal, contractApprovalInfo *contract_approval.ContractApproval, opUser *custom.AdminWx) (sealOpButton sealResp.OpButton, 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" {
				sealOpButton.Approval = true
			}

			//合规在审批过程中具有 部分修改权限
			if opUser.AdminId == approvalRecord.ApproveUserId && opUser.RoleTypeCode == utils.ROLE_TYPE_CODE_COMPLIANCE && approvalRecord.NodeType == "check" {
				sealOpButton.CheckEdit = 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])
	}

	//作废权限
	if (opUser.RoleTypeCode == utils.ROLE_TYPE_CODE_COMPLIANCE || opUser.AdminId == sealInfo.UserId) && sealInfo.Status == "已审批" {
		sealOpButton.Invalid = true
	}

	//编辑权限
	editStatus := []string{"已驳回", "待提交", "已撤回"}
	if opUser.AdminId == sealInfo.UserId && strings.Contains(strings.Join(editStatus, ","), sealInfo.Status) {
		sealOpButton.Edit = true
	}
	return
}