fix(合同/用印审批)：调整合同/用印审批操作

controllers/contract.go

@@ -5,9 +5,12 @@ import (
 	contractReq "hongze/hongze_mobile_admin/models/request/contract"
 	contractResp "hongze/hongze_mobile_admin/models/response/contract"
 	"hongze/hongze_mobile_admin/models/tables/contract"
+	"hongze/hongze_mobile_admin/models/tables/contract_approval"
+	"hongze/hongze_mobile_admin/models/tables/contract_approval_record"
 	contractService "hongze/hongze_mobile_admin/services/contract"
 	"hongze/hongze_mobile_admin/utils"
 	"rdluck_tools/paging"
+	"strings"
 )
 
 //合同模块
@@ -45,7 +48,7 @@ func (this *ContractCommon) UploadCheckBackFile() {
 // @Title 获取合同详情
 // @Description 获取合同详情接口
 // @Param   ContractId   query   int  true       "合同id"
-// @Success 200 {object} contract.ContractDetail
+// @Success 200 {object} contract.ContractDetailResp
 // @router /detail [get]
 func (this *ContractCommon) Detail() {
 	//合同类型、产品类型、合同状态、更新时间、所选销售
@@ -67,7 +70,66 @@ func (this *ContractCommon) Detail() {
 	contractInfo.ModifyTimeStr = contractInfo.ModifyTime.Format(utils.FormatDateTime)
 	contractInfo.CreateTimeStr = contractInfo.CreateTime.Format(utils.FormatDateTime)
 
-	this.OkDetailed(contractInfo, "获取成功")
+	//审批流
+	flowNodeListResp := make([][]contract_approval_record.ContractApprovalRecord, 0)
+
+	//审批操作权限，上传签回文件权限
+	var contractOpButton contractResp.OpButton
+
+	//查询最近一次审批单信息
+	lastApprovalInfo, err := contract_approval.GetLastContractApprovalByContractId(contractInfo.ContractId, "contract")
+	if err != nil {
+		if err.Error() != utils.NotEmpty() {
+			this.FailWithMessage("获取最近一次审批单信息失败！", "获取最近一次审批单信息失败,ERR:"+err.Error())
+			return
+		}
+	}
+	if lastApprovalInfo != nil {
+		flowNodeMap := make(map[int][]contract_approval_record.ContractApprovalRecord, 0)
+		//审批流
+		approvalRecordList, err := contract_approval_record.GetContractApprovalRecordListByContractApprovalId(lastApprovalInfo.ContractApprovalId)
+		if err != nil {
+			this.FailWithMessage("获取审批失败！", "获取审批失败，Err:"+err.Error())
+			return
+		}
+		keySort := make([]int, 0)
+		for _, approvalRecord := range approvalRecordList {
+			//如果当前节点正好是该节点，同时审批单状态是待审批状态，然后当前账号又有权限，该账号也正是审批人，那么允许审批操作
+			if lastApprovalInfo.CurrNodeId == approvalRecord.NodeId && lastApprovalInfo.Status == "待审批" {
+				if this.AdminWx.AdminId == approvalRecord.ApproveUserId && approvalRecord.NodeType == "check" {
+					contractOpButton.Approval = 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])
+		}
+
+		uploadStatus := []string{"已审批", "已签回"}
+		if this.AdminWx.RoleTypeCode == utils.ROLE_TYPE_CODE_COMPLIANCE && strings.Contains(strings.Join(uploadStatus, ","), contractInfo.Status) {
+			contractOpButton.UploadFile = true
+		}
+
+		//作废权限
+		if (this.AdminWx.RoleTypeCode == utils.ROLE_TYPE_CODE_COMPLIANCE || this.AdminWx.AdminId == contractInfo.SellerId) && contractInfo.Status == "已审批" {
+			contractOpButton.Invalid = true
+		}
+	}
+	resp := contractResp.ContractDetailResp{
+		ContractDetail: contractInfo,
+		FlowNodeList:   flowNodeListResp,
+		OpButton:       contractOpButton,
+	}
+	this.OkDetailed(resp, "获取成功")
 }
 
 // @Title 根据客户名称获取已存在合同系统中客户名称列表

controllers/contract_approval.go

@@ -217,8 +217,8 @@ func (this *ContractApprovalCommon) Detail() {
 		this.FailWithMessage("获取审批单失败！", "获取审批单失败，Err:"+err.Error())
 		return
 	}
-	var contractDetail contractResp.ContractDetail
-	jsonErr := json.Unmarshal([]byte(contractApprovalInfo.ContractDetail), &contractDetail)
+	var contractDetail *contract.ContractDetail
+	jsonErr := json.Unmarshal([]byte(contractApprovalInfo.ContractDetail), contractDetail)
 	if jsonErr != nil {
 		this.FailWithMessage("审批合同数据转换失败！", "审批合同数据转换失败，Err:"+jsonErr.Error())
 		return
@@ -237,7 +237,7 @@ func (this *ContractApprovalCommon) Detail() {
 	contractDetail.CheckBackFileUrl = contractInfo.CheckBackFileUrl
 
 	//审批操作权限，上传签回文件权限
-	var contractOpButton contractResp.ContractOpButton
+	var contractOpButton contractResp.OpButton
 
 	//审批流
 	approvalRecordList, err := contract_approval_record.GetContractApprovalRecordListByContractApprovalId(contractApprovalId)
@@ -251,7 +251,7 @@ func (this *ContractApprovalCommon) Detail() {
 		//如果当前节点正好是该节点，同时审批单状态是待审批状态，然后当前账号又有权限，该账号也正是审批人，那么允许审批操作
 		if contractApprovalInfo.CurrNodeId == approvalRecord.NodeId && contractApprovalInfo.Status == "待审批" {
 			if this.AdminWx.AdminId == approvalRecord.ApproveUserId && approvalRecord.NodeType == "check" {
-				contractOpButton.ApprovalButton = true
+				contractOpButton.Approval = true
 			}
 		}
 		if tmpFlowNodeList, ok := flowNodeMap[approvalRecord.NodeId]; ok {
@@ -271,12 +271,17 @@ func (this *ContractApprovalCommon) Detail() {
 
 	uploadStatus := []string{"已审批", "已签回"}
 	if this.AdminWx.RoleTypeCode == utils.ROLE_TYPE_CODE_COMPLIANCE && strings.Contains(strings.Join(uploadStatus, ","), contractInfo.Status) {
-		contractOpButton.UploadFileButton = true
+		contractOpButton.UploadFile = true
+	}
+
+	//作废权限
+	if (this.AdminWx.RoleTypeCode == utils.ROLE_TYPE_CODE_COMPLIANCE || this.AdminWx.AdminId == contractInfo.SellerId) && contractInfo.Status == "已审批" {
+		contractOpButton.Invalid = true
 	}
 	resp := contractResp.ContractDetailResp{
-		ContractDetail:   contractDetail,
-		FlowNodeList:     flowNodeListResp,
-		ContractOpButton: contractOpButton,
+		ContractDetail: contractDetail,
+		FlowNodeList:   flowNodeListResp,
+		OpButton:       contractOpButton,
 	}
 	this.OkDetailed(resp, "获取成功")
 }
@@ -293,38 +298,20 @@ func (this *ContractApprovalCommon) Reject() {
 		this.FailWithMessage("参数解析异常！", "参数解析失败，Err:"+err.Error())
 		return
 	}
-	//审批单id编号
-	contractApprovalId := req.ApprovalId
-	if contractApprovalId <= 0 {
-		this.FailWithMessage("请传入审批单编号！", "请传入审批单编号！")
-		return
-	}
-	//审批单详情
-	approvalInfo, err := contract_approval.GetContractApprovalById(contractApprovalId)
-	if err != nil {
-		this.FailWithMessage("获取审批单失败！", "获取审批单失败，Err:"+err.Error())
+	//合同id编号
+	contractId := req.ContractId
+	if contractId <= 0 {
+		this.FailWithMessage("请传入合同编号！", "请传入合同编号！")
 		return
 	}
-	if approvalInfo.Status != "待审批" {
-		this.FailWithMessage("当前审批单状态异常，不允许审批", "当前审批单状态异常，不允许审批，审批单状态："+approvalInfo.Status)
-	}
-	//审批流
-	approvalRecordList, err := contract_approval_record.GetContractApprovalRecordListByContractApprovalIdAndNodeId(contractApprovalId, approvalInfo.CurrNodeId)
+
+	//数据校验
+	contractInfo, approvalInfo, approvalRecord, err := contractService.CheckApproveAuth(contractId, this.AdminWx)
 	if err != nil {
-		this.FailWithMessage("获取审批失败！", "获取审批失败，Err:"+err.Error())
+		this.FailWithMessage("驳回审批失败！", "驳回审批失败，Err:"+err.Error())
 		return
 	}
-	var approvalRecord *contract_approval_record.ContractApprovalRecord
-	for _, tmpApprovalRecord := range approvalRecordList {
-		if tmpApprovalRecord.NodeType == "check" && tmpApprovalRecord.ApproveUserId == this.AdminWx.AdminId {
-			approvalRecord = tmpApprovalRecord
-		}
-	}
-
-	if approvalRecord == nil {
-		this.FailWithMessage("当前账号没有审批权限", "当前账号没有审批权限")
-	}
-	err = contractService.Reject(approvalRecord, this.AdminWx, req.Remark)
+	err = contractService.Reject(contractInfo, approvalInfo, approvalRecord, this.AdminWx, req.Remark)
 	if err != nil {
 		this.FailWithMessage("驳回审批失败！", "驳回审批失败，Err:"+err.Error())
 		return
@@ -338,45 +325,25 @@ func (this *ContractApprovalCommon) Reject() {
 // @Success Ret=200 申请成功
 // @router /approved [post]
 func (this *ContractApprovalCommon) Approved() {
-
 	var req contractReq.ApprovedReq
 	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
 	if err != nil {
 		this.FailWithMessage("参数解析异常！", "参数解析失败，Err:"+err.Error())
 		return
 	}
-	//审批单id编号
-	contractApprovalId := req.ApprovalId
-	if contractApprovalId <= 0 {
-		this.FailWithMessage("请传入审批单编号！", "请传入审批单编号！")
+	//合同id编号
+	contractId := req.ContractId
+	if contractId <= 0 {
+		this.FailWithMessage("请传入合同编号！", "请传入合同编号！")
 		return
 	}
-	//审批单详情
-	approvalInfo, err := contract_approval.GetContractApprovalById(contractApprovalId)
+	//数据校验
+	contractInfo, approvalInfo, approvalRecord, err := contractService.CheckApproveAuth(contractId, this.AdminWx)
 	if err != nil {
-		this.FailWithMessage("获取审批单失败！", "获取审批单失败，Err:"+err.Error())
-		return
-	}
-	if approvalInfo.Status != "待审批" {
-		this.FailWithMessage("当前审批单状态异常，不允许审批", "当前审批单状态异常，不允许审批，审批单状态："+approvalInfo.Status)
-	}
-	//审批流
-	approvalRecordList, err := contract_approval_record.GetContractApprovalRecordListByContractApprovalIdAndNodeId(contractApprovalId, approvalInfo.CurrNodeId)
-	if err != nil {
-		this.FailWithMessage("获取审批失败！", "获取审批失败，Err:"+err.Error())
+		this.FailWithMessage("驳回审批失败！", "驳回审批失败，Err:"+err.Error())
 		return
 	}
-	var approvalRecord *contract_approval_record.ContractApprovalRecord
-	for _, tmpApprovalRecord := range approvalRecordList {
-		if tmpApprovalRecord.NodeType == "check" && tmpApprovalRecord.ApproveUserId == this.AdminWx.AdminId {
-			approvalRecord = tmpApprovalRecord
-		}
-	}
-
-	if approvalRecord == nil {
-		this.FailWithMessage("当前账号没有审批权限", "当前账号没有审批权限")
-	}
-	err = contractService.Approved(approvalRecord, this.AdminWx, req.Remark)
+	err = contractService.Approved(contractInfo, approvalInfo, approvalRecord, this.AdminWx, req.Remark)
 	if err != nil {
 		this.FailWithMessage("审核失败！", "审核失败，Err:"+err.Error())
 		return

controllers/seal_approval.go

@@ -2,10 +2,11 @@ package controllers
 
 import (
 	"encoding/json"
-	contractReq "hongze/hongze_mobile_admin/models/request/contract"
+	sealReq "hongze/hongze_mobile_admin/models/request/seal"
 	sealResp "hongze/hongze_mobile_admin/models/response/seal"
 	"hongze/hongze_mobile_admin/models/tables/contract_approval"
 	"hongze/hongze_mobile_admin/models/tables/contract_approval_record"
+	"hongze/hongze_mobile_admin/models/tables/seal"
 	sealService "hongze/hongze_mobile_admin/services/seal"
 	"hongze/hongze_mobile_admin/utils"
 	"rdluck_tools/paging"
@@ -211,50 +212,109 @@ func (this *SealApprovalCommon) List() {
 	}, "获取成功")
 }
 
-// @Title 驳回审批
-// @Description 驳回审批接口
-// @Param	request	body contract.RejectReq true "type json string"
-// @Success Ret=200 驳回成功
-// @router /reject [post]
-func (this *SealApprovalCommon) Reject() {
-	var req contractReq.RejectReq
-	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
+// @Title 审批单详情
+// @Description 审批单详情接口
+// @Param   ContractApprovalId   query   int  false       "审批单id"
+// @Success 200 {object} contract.ContractDetailResp
+// @router /detail [get]
+func (this *SealApprovalCommon) Detail() {
+	//审批单id
+	contractApprovalId, _ := this.GetInt("ContractApprovalId")
+
+	//审批单详情
+	contractApprovalInfo, err := contract_approval.GetContractApprovalById(contractApprovalId)
 	if err != nil {
-		this.FailWithMessage("参数解析异常！", "参数解析失败，Err:"+err.Error())
+		this.FailWithMessage("获取审批单失败！", "获取审批单失败，Err:"+err.Error())
 		return
 	}
-	//审批单id编号
-	contractApprovalId := req.ApprovalId
-	if contractApprovalId <= 0 {
-		this.FailWithMessage("请传入审批单编号！", "请传入审批单编号！")
+	var sealDetail *seal.Seal
+	jsonErr := json.Unmarshal([]byte(contractApprovalInfo.ContractDetail), sealDetail)
+	if jsonErr != nil {
+		this.FailWithMessage("审批合同数据转换失败！", "审批合同数据转换失败，Err:"+jsonErr.Error())
 		return
 	}
-	//审批单详情
-	approvalInfo, err := contract_approval.GetContractApprovalById(contractApprovalId)
+
+	//合同详情
+	sealInfo, err := seal.GetSealInfoById(contractApprovalInfo.ContractId)
 	if err != nil {
-		this.FailWithMessage("获取审批单失败！", "获取审批单失败，Err:"+err.Error())
+		this.FailWithMessage("获取用印详情失败！", "获取用印详情失败，Err:"+err.Error())
 		return
 	}
-	if approvalInfo.Status != "待审批" {
-		this.FailWithMessage("当前审批单状态异常，不允许审批", "当前审批单状态异常，不允许审批，审批单状态："+approvalInfo.Status)
-	}
+
+	//替换快照数据
+	sealDetail.Status = sealInfo.Status
+
+	//审批操作权限，上传签回文件权限
+	var sealOpButton sealResp.OpButton
+
 	//审批流
-	approvalRecordList, err := contract_approval_record.GetContractApprovalRecordListByContractApprovalIdAndNodeId(contractApprovalId, approvalInfo.CurrNodeId)
+	approvalRecordList, err := contract_approval_record.GetContractApprovalRecordListByContractApprovalId(contractApprovalId)
 	if err != nil {
 		this.FailWithMessage("获取审批失败！", "获取审批失败，Err:"+err.Error())
 		return
 	}
-	var approvalRecord *contract_approval_record.ContractApprovalRecord
-	for _, tmpApprovalRecord := range approvalRecordList {
-		if tmpApprovalRecord.NodeType == "check" && tmpApprovalRecord.ApproveUserId == this.AdminWx.AdminId {
-			approvalRecord = tmpApprovalRecord
+	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 this.AdminWx.AdminId == approvalRecord.ApproveUserId && approvalRecord.NodeType == "check" {
+				sealOpButton.ApprovalButton = 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)
+		}
+	}
+	flowNodeListResp := make([][]contract_approval_record.ContractApprovalRecord, 0)
+	for _, key := range keySort {
+		flowNodeListResp = append(flowNodeListResp, flowNodeMap[key])
 	}
 
-	if approvalRecord == nil {
-		this.FailWithMessage("当前账号没有审批权限", "当前账号没有审批权限")
+	//作废权限
+	if (this.AdminWx.RoleTypeCode == utils.ROLE_TYPE_CODE_COMPLIANCE || this.AdminWx.AdminId == sealInfo.UserId) && sealInfo.Status == "已审批" {
+		sealOpButton.Invalid = true
 	}
-	err = sealService.Reject(approvalRecord, this.AdminWx, req.Remark)
+	resp := sealResp.SealDetailResp{
+		SealDetail:   sealDetail,
+		FlowNodeList: flowNodeListResp,
+		OpButton:     sealOpButton,
+	}
+	this.OkDetailed(resp, "获取成功")
+}
+
+// @Title 驳回审批
+// @Description 驳回审批接口
+// @Param	request	body contract.RejectReq true "type json string"
+// @Success Ret=200 驳回成功
+// @router /reject [post]
+func (this *SealApprovalCommon) Reject() {
+	var req sealReq.RejectReq
+	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
+	if err != nil {
+		this.FailWithMessage("参数解析异常！", "参数解析失败，Err:"+err.Error())
+		return
+	}
+	//用印id编号
+	sealId := req.SealId
+	if sealId <= 0 {
+		this.FailWithMessage("请传入用印单编号！", "请传入用印单编号！")
+		return
+	}
+
+	//数据校验
+	sealInfo, approvalInfo, approvalRecord, err := sealService.CheckApproveAuth(sealId, this.AdminWx)
+	if err != nil {
+		this.FailWithMessage("驳回审批失败！", "驳回审批失败，Err:"+err.Error())
+		return
+	}
+	err = sealService.Reject(sealInfo, approvalInfo, approvalRecord, this.AdminWx, req.Remark)
 	if err != nil {
 		this.FailWithMessage("驳回审批失败！", "驳回审批失败，Err:"+err.Error())
 		return
@@ -268,45 +328,26 @@ func (this *SealApprovalCommon) Reject() {
 // @Success Ret=200 申请成功
 // @router /approved [post]
 func (this *SealApprovalCommon) Approved() {
-
-	var req contractReq.ApprovedReq
+	var req sealReq.ApprovedReq
 	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
 	if err != nil {
 		this.FailWithMessage("参数解析异常！", "参数解析失败，Err:"+err.Error())
 		return
 	}
-	//审批单id编号
-	contractApprovalId := req.ApprovalId
-	if contractApprovalId <= 0 {
-		this.FailWithMessage("请传入审批单编号！", "请传入审批单编号！")
+	//用印编号id编号
+	sealId := req.SealId
+	if sealId <= 0 {
+		this.FailWithMessage("请传入用印单编号！", "请传入用印单编号！")
 		return
 	}
-	//审批单详情
-	approvalInfo, err := contract_approval.GetContractApprovalById(contractApprovalId)
-	if err != nil {
-		this.FailWithMessage("获取审批单失败！", "获取审批单失败，Err:"+err.Error())
-		return
-	}
-	if approvalInfo.Status != "待审批" {
-		this.FailWithMessage("当前审批单状态异常，不允许审批", "当前审批单状态异常，不允许审批，审批单状态："+approvalInfo.Status)
-	}
-	//审批流
-	approvalRecordList, err := contract_approval_record.GetContractApprovalRecordListByContractApprovalIdAndNodeId(contractApprovalId, approvalInfo.CurrNodeId)
+
+	//数据校验
+	sealInfo, approvalInfo, approvalRecord, err := sealService.CheckApproveAuth(sealId, this.AdminWx)
 	if err != nil {
-		this.FailWithMessage("获取审批失败！", "获取审批失败，Err:"+err.Error())
+		this.FailWithMessage("驳回审批失败！", "驳回审批失败，Err:"+err.Error())
 		return
 	}
-	var approvalRecord *contract_approval_record.ContractApprovalRecord
-	for _, tmpApprovalRecord := range approvalRecordList {
-		if tmpApprovalRecord.NodeType == "check" && tmpApprovalRecord.ApproveUserId == this.AdminWx.AdminId {
-			approvalRecord = tmpApprovalRecord
-		}
-	}
-
-	if approvalRecord == nil {
-		this.FailWithMessage("当前账号没有审批权限", "当前账号没有审批权限")
-	}
-	err = sealService.Approved(approvalRecord, this.AdminWx, req.Remark)
+	err = sealService.Approved(sealInfo, approvalInfo, approvalRecord, this.AdminWx, req.Remark)
 	if err != nil {
 		this.FailWithMessage("审核失败！", "审核失败，Err:"+err.Error())
 		return

models/request/contract/contract_approval.go

@@ -2,12 +2,12 @@ package contract
 
 //驳回申请合同请求
 type RejectReq struct {
-	ApprovalId int    `description:"审批单id"`
+	ContractId int    `description:"合同id"`
 	Remark     string `description:"备注字段"`
 }
 
 //通过申请合同请求
 type ApprovedReq struct {
-	ApprovalId int    `description:"审批单id"`
+	ContractId int    `description:"合同id"`
 	Remark     string `description:"驳回理由"`
 }

models/request/seal/seal_approval.go

@@ -2,14 +2,12 @@ package seal
 
 //驳回申请合同请求
 type RejectReq struct {
-	ContractApprovalRecordId int    `description:"审批流id"`
-	Remark                   string `description:"驳回理由"`
+	SealId int    `description:"用印id"`
+	Remark string `description:"备注字段"`
 }
 
 //通过申请合同请求
 type ApprovedReq struct {
-	ContractApprovalRecordId int    `description:"审批流id"`
-	Remark                   string `description:"驳回理由"`
-	NextApproval             bool   `description:"是否需要下级批准，预留字段，一期用不到，二期加入合规审批流程的时候，合规审批操作后可能会用到"`
-	NextApprovalUserId       int    `description:"是否指定下级审批人，预留字段，一期用不到，二期加入合规审批流程的时候，合规审批操作后可能会用到"`
+	SealId int    `description:"用印id"`
+	Remark string `description:"驳回理由"`
 }

models/response/contract/contract.go

@@ -1,7 +1,6 @@
 package contract
 
 import (
-	contractCustom "hongze/hongze_mobile_admin/models/custom/contract"
 	"hongze/hongze_mobile_admin/models/tables/contract"
 	"hongze/hongze_mobile_admin/models/tables/contract_approval"
 	"hongze/hongze_mobile_admin/models/tables/contract_approval_record"
@@ -34,55 +33,14 @@ type ContractApprovalListResp struct {
 
 //审批列表
 type ContractDetailResp struct {
-	ContractDetail   ContractDetail                                      `description:"审批单详情"`
-	FlowNodeList     [][]contract_approval_record.ContractApprovalRecord `description:"审批流"`
-	ContractOpButton ContractOpButton                                    `description:"操作权限"`
+	ContractDetail *contract.ContractDetail                            `description:"审批单详情"`
+	FlowNodeList   [][]contract_approval_record.ContractApprovalRecord `description:"审批流"`
+	OpButton       OpButton                                            `description:"操作权限"`
 }
 
 //合同操作按钮
-type ContractOpButton struct {
-	ApprovalButton   bool `description:"是否有审批权限"`
-	UploadFileButton bool `description:"是否有上传签回文件权限"`
-}
-
-//合同详情信息（包含服务信息等）
-type ContractDetail struct {
-	ContractId       int       `description:"合同唯一id"`
-	ContractCode     string    `description:"合同编号,长度32位"`
-	SellerId         int       `description:"所属销售id"`
-	SellerName       string    `description:"所属销售名称"`
-	ProductId        int       `description:"产品id，1：ficc；2：权益"`
-	ContractType     string    `description:"合同类型，枚举值：'新签合同','续约合同','补充协议'"`
-	Status           string    `description:"合同状态，枚举值：'待提交','待审批','已撤回','已审批','已驳回','已作废'"`
-	StartDate        time.Time `description:"合同开始日期"`
-	EndDate          time.Time `description:"合同结束日期"`
-	OriginalPrice    float64   `description:"合同原金额，优惠前的金额"`
-	Price            float64   `description:"实际金额，优惠后的金额"`
-	PayRemark        string    `description:"付款方式说明,长度255位"`
-	CompanyName      string    `description:"客户名称，甲方名称,长度32位"`
-	CreditCode       string    `description:"社会统一信用代码,长度64位"`
-	ProvinceId       int       `description:"省级id"`
-	Province         string    `description:"省级名称,长度16位"`
-	CityId           int       `description:"市级id"`
-	City             string    `description:"市级名称,长度32位"`
-	Address          string    `description:"详细地址"`
-	Fax              string    `description:"传真,长度32位"`
-	Phone            string    `description:"电话,长度32位"`
-	Postcode         string    `description:"邮编,长度16位"`
-	Remark           string    `description:"补充内容,长度255位"`
-	ModifyContent    string    `description:"修改内容"`
-	ApprovalRemark   string    `description:"审核备注"`
-	FileUrl          string    `description:"合同文件地址"`
-	CheckBackFileUrl string    `description:"签回合同文件地址"`
-	TemplateId       int       `description:"模板id"`
-	SourceId         int       `description:"来源合同id，默认是0；如果是通过其他合同复制过来的，那么就是原合同的id"`
-	IsDelete         int       `json:"-";description:"是否已经删除，0：未删除，1：已删除"`
-	ModifyTime       time.Time `description:"合同最近一次修改时间"`
-	CreateTime       time.Time `description:"合同添加时间"`
-
-	StartDateStr  string `description:"合同起始时间"`
-	EndDateStr    string `description:"合同结束时间"`
-	ModifyTimeStr string `description:"最近一次更新时间"`
-	CreateTimeStr string `description:"合同添加时间"`
-	Service       []*contractCustom.ContractServiceAndDetail
+type OpButton struct {
+	Approval   bool `description:"是否有审批权限"`
+	UploadFile bool `description:"是否有上传签回文件权限"`
+	Invalid    bool `description:"是否有作废合同权限"`
 }

models/response/seal/seal.go

@@ -2,6 +2,8 @@ package seal
 
 import (
 	"hongze/hongze_mobile_admin/models/tables/contract_approval"
+	"hongze/hongze_mobile_admin/models/tables/contract_approval_record"
+	"hongze/hongze_mobile_admin/models/tables/seal"
 	"rdluck_tools/paging"
 )
 
@@ -14,3 +16,16 @@ type SealApprovalListResp struct {
 	Paging *paging.PagingItem
 	List   []*contract_approval.SealApprovalList `description:"列表数据"`
 }
+
+//审批列表
+type SealDetailResp struct {
+	SealDetail   *seal.Seal                                          `description:"审批单详情"`
+	FlowNodeList [][]contract_approval_record.ContractApprovalRecord `description:"审批流"`
+	OpButton     OpButton                                            `description:"操作权限"`
+}
+
+//合同操作按钮
+type OpButton struct {
+	ApprovalButton bool `description:"是否有审批权限"`
+	Invalid        bool `description:"是否有作废合同权限"`
+}

models/tables/contract_approval/contract_approval.go

@@ -37,11 +37,19 @@ func GetContractApprovalById(contractApprovalId int) (contractApprovalInfo *Cont
 //根据合同id获取最近一次待审批的合同审批单信息
 func GetLastPendingContractApprovalByContractId(contractId int) (contractApprovalInfo *ContractApproval, err error) {
 	o := orm.NewOrm()
-	sql := `select * from contract_approval where status = "待审批" AND contract_id=? `
+	sql := `select * from contract_approval where status = "待审批" AND contract_id=? order by contract_approval_id desc`
 	err = o.Raw(sql, contractId).QueryRow(&contractApprovalInfo)
 	return
 }
 
+//根据合同id获取最近一次提交的合同审批单信息
+func GetLastContractApprovalByContractId(contractId int, approvalType string) (contractApprovalInfo *ContractApproval, err error) {
+	o := orm.NewOrm()
+	sql := `select * from contract_approval where contract_id=? and approval_type =? order by contract_approval_id desc`
+	err = o.Raw(sql, contractId, approvalType).QueryRow(&contractApprovalInfo)
+	return
+}
+
 //根据合同id获取总共被驳回的次数
 func GetRejectContractCountByContractId(contractId int) (total int64, err error) {
 	o := orm.NewOrm()
@@ -63,7 +71,7 @@ c.contract_type,c.start_date,c.end_date,c.price,c.company_name,c.seller_id,c.sel
 	sql += `  GROUP BY contract_id ) b on a.contract_approval_id=b.max_id
 	JOIN contract c ON a.contract_id = c.contract_id 
 	JOIN contract_approval_record d on a.contract_approval_id=d.contract_approval_id
-WHERE c.is_delete = 0 `
+WHERE c.is_delete = 0  AND a.approval_type="contract" `
 	sql += condition
 	sql += ` group by contract_id `
 
@@ -116,7 +124,7 @@ c.contract_type,c.start_date,c.end_date,c.price,c.company_name,c.seller_id,c.sel
 	sql += `  GROUP BY contract_id ) b on a.contract_approval_id=b.max_id
 	JOIN contract c ON a.contract_id = c.contract_id 
 	JOIN contract_approval_record d on a.contract_approval_id=d.contract_approval_id
-WHERE c.is_delete = 0 `
+WHERE c.is_delete = 0  AND a.approval_type="contract" `
 	sql += condition
 	sql += ` group by contract_id order by modify_time desc LIMIT ?,? `
 	_, err = o.Raw(sql, childPars, pars, startSize, pageSize).QueryRows(&list)
@@ -441,7 +449,7 @@ c.seal_type,c.company_name,c.user_id,c.user_name,c.file_url,c.code from contract
 	sql += `  GROUP BY contract_id ) b on a.contract_approval_id=b.max_id
 	JOIN seal c ON c.seal_id = a.contract_id 
 	JOIN contract_approval_record d on a.contract_approval_id=d.contract_approval_id
-WHERE c.is_delete = 0 `
+WHERE c.is_delete = 0  AND a.approval_type="seal" `
 	sql += condition
 	sql += ` group by contract_id `
 
@@ -488,7 +496,7 @@ c.seal_type,c.company_name,c.user_id,c.user_name,c.file_url,c.code from contract
 	sql += `  GROUP BY contract_id ) b on a.contract_approval_id=b.max_id
 	JOIN seal c ON c.seal_id = a.contract_id 
 	JOIN contract_approval_record d on a.contract_approval_id=d.contract_approval_id
-WHERE c.is_delete = 0 `
+WHERE c.is_delete = 0 AND a.approval_type="seal" `
 	sql += condition
 	sql += ` group by contract_id order by modify_time desc LIMIT ?,? `
 	_, err = o.Raw(sql, childPars, pars, startSize, pageSize).QueryRows(&list)

services/contract/contract_approval.go

@@ -275,8 +275,52 @@ func CancelApply(contractApprovalRecord *contract_approval_record.ContractApprov
 	return
 }
 
-//驳回审批
-func Reject(contractApprovalRecord *contract_approval_record.ContractApprovalRecord, opUser *custom.AdminWx, rejectRemark string) (err error) {
+//校验审批操作权限
+func CheckApproveAuth(contractId int, opUser *custom.AdminWx) (contractInfo *contract.Contract, approvalInfo *contract_approval.ContractApproval, approvalRecord *contract_approval_record.ContractApprovalRecord, err error) {
+	//合同详情
+	contractInfo, err = contract.GetContractById(contractId)
+	if err != nil {
+		err = errors.New("获取合同失败，Err:" + err.Error())
+		return
+	}
+	//合同状态判断
+	if contractInfo.Status != "待审批" {
+		err = errors.New("合同状态异常，不允许驳回申请，当前合同状态：" + contractInfo.Status)
+		return
+	}
+
+	//获取该最近一条审批单详情
+	approvalInfo, err = contract_approval.GetLastContractApprovalByContractId(contractInfo.ContractId, "contract")
+	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 Reject(contractInfo *contract.Contract, approvalInfo *contract_approval.ContractApproval, contractApprovalRecord *contract_approval_record.ContractApprovalRecord, opUser *custom.AdminWx, rejectRemark string) (err error) {
 	if contractApprovalRecord == nil {
 		err = errors.New("审批流异常，没有审批流信息")
 		return
@@ -308,29 +352,14 @@ func Reject(contractApprovalRecord *contract_approval_record.ContractApprovalRec
 		return
 	}
 
-	//获取审批单详情
-	contractApproval, err := contract_approval.GetContractApprovalById(contractApprovalRecord.ContractApprovalId)
-	if err != nil {
-		return
-	}
-
 	//审批单状态判断
-	if contractApproval.Status != "待审批" {
-		err = errors.New("审批单状态异常，不允许驳回申请，当前审批单状态：" + contractApproval.Status)
+	if approvalInfo.Status != "待审批" {
+		err = errors.New("审批单状态异常，不允许驳回申请，当前审批单状态：" + approvalInfo.Status)
 		return
 	}
 
-	//获取合同信息
-	contractInfo, err := contract.GetContractById(contractApproval.ContractId)
-	if err != nil {
-		return
-	}
-	//合同状态判断
-	if contractInfo.Status != "待审批" {
-		err = errors.New("合同状态异常，不允许驳回申请，当前合同状态：" + contractInfo.Status)
-		return
-	}
-	err = contractApproval.Reject(contractApproval, contractApprovalRecord, opUserId, opUserName, rejectRemark)
+	//驳回操作
+	err = approvalInfo.Reject(approvalInfo, contractApprovalRecord, opUserId, opUserName, rejectRemark)
 	if err != nil {
 		return
 	}
@@ -352,7 +381,7 @@ func Reject(contractApprovalRecord *contract_approval_record.ContractApprovalRec
 }
 
 //审批通过
-func Approved(contractApprovalRecord *contract_approval_record.ContractApprovalRecord, opUser *custom.AdminWx, approvedRemark string) (err error) {
+func Approved(contractInfo *contract.Contract, approvalInfo *contract_approval.ContractApproval, contractApprovalRecord *contract_approval_record.ContractApprovalRecord, opUser *custom.AdminWx, approvedRemark string) (err error) {
 	if contractApprovalRecord == nil {
 		err = errors.New("审批流异常，没有审批流信息")
 		return
@@ -383,26 +412,103 @@ func Approved(contractApprovalRecord *contract_approval_record.ContractApprovalR
 		return
 	}
 
-	//获取审批单详情
-	contractApproval, err := contract_approval.GetContractApprovalById(contractApprovalRecord.ContractApprovalId)
+	//审批单状态判断
+	if approvalInfo.Status != "待审批" {
+		err = errors.New("审批单状态异常，不允许审批，当前审批单状态：" + approvalInfo.Status)
+		return
+	}
+
+	//合同状态判断
+	if contractInfo.Status != "待审批" {
+		err = errors.New("合同状态异常，不允许审批，当前合同状态：" + contractInfo.Status)
+		return
+	}
+
+	//if contractApprovalRecord
+	err = approvalInfo.Approved(approvalInfo, contractApprovalRecord, approvedRemark)
 	if err != nil {
 		return
 	}
 
-	//审批单状态判断
-	if contractApproval.Status != "待审批" {
-		err = errors.New("审批单状态异常，不允许审批，当前审批单状态：" + contractApproval.Status)
+	//添加操作日志
+	remark := "审批通过"
+	_ = contract_operation_record.AddContractOperationRecord(contractInfo.ContractId, opUserId, contractApprovalRecord.ContractApprovalRecordId, "approval", opUserName, remark)
+
+	//发送信息给所有抄送人
+	content := contractInfo.CompanyName + " 合同模板已审核"
+	go messageToAllCcUser(opUserId, contractApprovalRecord.ContractApprovalId, 2, 2, contractInfo.CompanyName, content)
+	//如果下一个节点属于结束节点，那么通知对应的销售，同时，异步生成合同pdf
+	if contractApprovalRecord.NextNodeId == 0 {
+		//待办通知（通知销售已经审核通过了）
+		{
+			content := contractInfo.CompanyName + " 合同模板已审核"
+			approvalSysUser, _ := admin.GetAdminById(contractInfo.SellerId)
+			go services.AddCompanyApprovalMessage(opUserId, contractInfo.SellerId, 0, contractApprovalRecord.ContractApprovalRecordId, 2, 2, 2, contractInfo.CompanyName, content, content, approvalSysUser.Mobile)
+		}
+
+		//审核通过后的异步操作（pdf生成、修改数据等）
+		go AfterApproved(contractInfo.ContractId)
+	} else {
+		//获取下级节点信息
+		flowNodeInfo, tmpErr := approval_flow_node.GetByNodeId(contractApprovalRecord.NextNodeId)
+		if tmpErr != nil {
+			err = tmpErr
+			return
+		}
+
+		//如果该级节点是抄送类型，那么需要将该节点给处理掉
+		if flowNodeInfo.NodeType == "cc" {
+			go approvedByCc(approvedRemark, contractApprovalRecord)
+		} else {
+			//发送消息下级审批人
+			go messageToNodeUser(contractApprovalRecord.NextNodeId, contractInfo.SellerId, approvalInfo.ContractApprovalId, 1, 1, contractInfo.CompanyName, content)
+		}
+	}
+
+	return
+}
+
+//审批通过（实际操作）
+func approved(contractInfo *contract.Contract, contractApprovalRecord *contract_approval_record.ContractApprovalRecord, opUser *custom.AdminWx, approvedRemark string) (err error) {
+	if contractApprovalRecord == nil {
+		err = errors.New("审批流异常，没有审批流信息")
 		return
 	}
 
-	//获取合同信息
-	contractInfo, err := contract.GetContractById(contractApproval.ContractId)
+	//审批流状态判断
+	if contractApprovalRecord.Status != "待审批" {
+		err = errors.New("审批流状态异常，不允许审批，当前审批流状态：" + contractApprovalRecord.Status)
+		return
+	}
+
+	//判断是否审批类型，如果不是审批类型，那么就没有审批权限
+	if contractApprovalRecord.NodeType != "check" {
+		err = errors.New("当前账号没有审批权限")
+		return
+	}
+
+	//操作人
+	opUserId := opUser.AdminId
+	opUserName := opUser.RealName
+	//操作权限校验
+	if opUser.RoleTypeCode != contractApprovalRecord.ApproveRoleTypeCode {
+		err = errors.New("当前账号没有审批权限")
+		return
+	}
+	if contractApprovalRecord.ApproveUserId > 0 && contractApprovalRecord.ApproveUserId != opUserId {
+		err = errors.New("当前账号没有审批权限，需要指定人操作")
+		return
+	}
+
+	//获取审批单详情
+	contractApproval, err := contract_approval.GetContractApprovalById(contractApprovalRecord.ContractApprovalId)
 	if err != nil {
 		return
 	}
-	//合同状态判断
-	if contractInfo.Status != "待审批" {
-		err = errors.New("合同状态异常，不允许审批，当前合同状态：" + contractInfo.Status)
+
+	//审批单状态判断
+	if contractApproval.Status != "待审批" {
+		err = errors.New("审批单状态异常，不允许审批，当前审批单状态：" + contractApproval.Status)
 		return
 	}
 

services/seal/approval.go

@@ -52,6 +52,7 @@ func Apply(sealInfo *seal.Seal) (err error) {
 	//校验是否存在待审批的审批单（其实没有多大意义，只是为了 异常数据校验）
 	approval := &contract_approval.ContractApproval{
 		ContractId:     sealInfo.SealId,
+		ApprovalType:   "seal",
 		Status:         "待审批",
 		ApplyContent:   sealInfo.Use,
 		ContractDetail: string(sealDetailByte),
@@ -115,8 +116,52 @@ func Apply(sealInfo *seal.Seal) (err error) {
 	return
 }
 
+//校验审批操作权限
+func CheckApproveAuth(sealId int, opUser *custom.AdminWx) (sealInfo *seal.Seal, approvalInfo *contract_approval.ContractApproval, approvalRecord *contract_approval_record.ContractApprovalRecord, err error) {
+	//用印详情
+	sealInfo, err = seal.GetSealInfoById(sealId)
+	if err != nil {
+		err = errors.New("获取用印失败，Err:" + err.Error())
+		return
+	}
+	//合同状态判断
+	if sealInfo.Status != "待审批" {
+		err = errors.New("用印状态异常，不允许驳回申请，当前合同状态：" + sealInfo.Status)
+		return
+	}
+
+	//获取该最近一条审批单详情
+	approvalInfo, err = contract_approval.GetLastContractApprovalByContractId(sealInfo.SealId, "seal")
+	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 Reject(approvalRecord *contract_approval_record.ContractApprovalRecord, opUser *custom.AdminWx, rejectRemark string) (err error) {
+func Reject(sealInfo *seal.Seal, approvalInfo *contract_approval.ContractApproval, approvalRecord *contract_approval_record.ContractApprovalRecord, opUser *custom.AdminWx, rejectRemark string) (err error) {
 	if approvalRecord == nil {
 		err = errors.New("审批流异常，没有审批流信息")
 		return
@@ -148,23 +193,12 @@ func Reject(approvalRecord *contract_approval_record.ContractApprovalRecord, opU
 		return
 	}
 
-	//获取审批单详情
-	approvalInfo, err := contract_approval.GetContractApprovalById(approvalRecord.ContractApprovalId)
-	if err != nil {
-		return
-	}
-
 	//审批单状态判断
 	if approvalInfo.Status != "待审批" {
 		err = errors.New("审批单状态异常，不允许驳回申请，当前审批单状态：" + approvalInfo.Status)
 		return
 	}
 
-	//获取用印信息
-	sealInfo, err := seal.GetSealInfoById(approvalInfo.ContractId)
-	if err != nil {
-		return
-	}
 	//用印状态判断
 	if sealInfo.Status != "待审批" {
 		err = errors.New("用印状态异常，不允许驳回申请，当前用印状态：" + sealInfo.Status)
@@ -192,7 +226,7 @@ func Reject(approvalRecord *contract_approval_record.ContractApprovalRecord, opU
 }
 
 //审批通过
-func Approved(approvalRecord *contract_approval_record.ContractApprovalRecord, opUser *custom.AdminWx, approvedRemark string) (err error) {
+func Approved(sealInfo *seal.Seal, approvalInfo *contract_approval.ContractApproval, approvalRecord *contract_approval_record.ContractApprovalRecord, opUser *custom.AdminWx, approvedRemark string) (err error) {
 	if approvalRecord == nil {
 		err = errors.New("审批流异常，没有审批流信息")
 		return
@@ -223,23 +257,12 @@ func Approved(approvalRecord *contract_approval_record.ContractApprovalRecord, o
 		return
 	}
 
-	//获取审批单详情
-	approvalInfo, err := contract_approval.GetContractApprovalById(approvalRecord.ContractApprovalId)
-	if err != nil {
-		return
-	}
-
 	//审批单状态判断
 	if approvalInfo.Status != "待审批" {
 		err = errors.New("审批单状态异常，不允许审批，当前审批单状态：" + approvalInfo.Status)
 		return
 	}
 
-	//获取用印信息
-	sealInfo, err := seal.GetSealInfoById(approvalInfo.ContractId)
-	if err != nil {
-		return
-	}
 	//用印状态判断
 	if sealInfo.Status != "待审批" {
 		err = errors.New("用印状态异常，不允许审批，当前用印状态：" + sealInfo.Status)