feat(新增用印申请)

controllers/contract_approval.go

@@ -3,7 +3,8 @@ package controllers
 import (
 	"encoding/json"
 	contractReq "hongze/hongze_mobile_admin/models/request/contract"
-	"hongze/hongze_mobile_admin/models/response/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"
@@ -163,33 +164,31 @@ func (this *ContractApprovalCommon) List() {
 
 			//list[i].ContractInfo = contractDetail
 			//校验最新审批流数据
-			if contractApprovalRecord, has := contractApprovalRecordMap[item.ContractApprovalId]; has {
-				//审批流id
-				list[i].ContractApprovalRecordId = contractApprovalRecord.ContractApprovalRecordId
-				//审批时间
-				list[i].ApproveTime = contractApprovalRecord.ApproveTime
-				list[i].ApproveTimeStr = contractApprovalRecord.ApproveTime.Format(utils.FormatDateTime)
-				//判断是否有操作权限
-				list[i].Status = contractApprovalRecord.Status
-
-				//判断是否处于待审批状态
-				if contractApprovalRecord.Status == "待审批" {
-					//如果不是审批者，那么不能审批操作
-					if contractApprovalRecord.NodeType != "check" {
-						continue
-					}
-					//如果没有指定审批人的话
-					if contractApprovalRecord.ApproveUserId <= 0 {
-						//判断是否与审批角色一致，如果一致，那么允许操作审批
-						if contractApprovalRecord.ApproveRoleTypeCode == sysUser.RoleTypeCode {
-							list[i].CanApprovalButton = true
-						}
-					} else if contractApprovalRecord.ApproveUserId == sysUser.AdminId {
-						//如果指定审批人就是自己的话，那么操作审批
-						list[i].CanApprovalButton = true
-					}
-				}
-			}
+			//if contractApprovalRecord, has := contractApprovalRecordMap[item.ContractApprovalId]; has {
+			//	//审批流id
+			//	list[i].ContractApprovalRecordId = contractApprovalRecord.ContractApprovalRecordId
+			//	//审批时间
+			//	list[i].ApproveTime = contractApprovalRecord.ApproveTime
+			//	list[i].ApproveTimeStr = contractApprovalRecord.ApproveTime.Format(utils.FormatDateTime)
+			//
+			//	////判断是否处于待审批状态
+			//	//if contractApprovalRecord.Status == "待审批" {
+			//	//	//如果不是审批者，那么不能审批操作
+			//	//	if contractApprovalRecord.NodeType != "check" {
+			//	//		continue
+			//	//	}
+			//	//	//如果没有指定审批人的话
+			//	//	if contractApprovalRecord.ApproveUserId <= 0 {
+			//	//		//判断是否与审批角色一致，如果一致，那么允许操作审批
+			//	//		if contractApprovalRecord.ApproveRoleTypeCode == sysUser.RoleTypeCode {
+			//	//			list[i].CanApprovalButton = true
+			//	//		}
+			//	//	} else if contractApprovalRecord.ApproveUserId == sysUser.AdminId {
+			//	//		//如果指定审批人就是自己的话，那么操作审批
+			//	//		list[i].CanApprovalButton = true
+			//	//	}
+			//	//}
+			//}
 
 			//合同状态（突然说要改成展示合同状态，那就根据业务需求，改成返回：合同状态咯）
 			list[i].Status = item.ContractStatus
@@ -197,12 +196,37 @@ func (this *ContractApprovalCommon) List() {
 	}
 
 	page := paging.GetPaging(currentIndex, pageSize, total)
-	this.OkDetailed(contract.ContractApprovalListResp{
+	this.OkDetailed(contractResp.ContractApprovalListResp{
 		List:   list,
 		Paging: page,
 	}, "获取成功")
 }
 
+// @Title 审批单详情
+// @Description 审批单详情接口
+// @Param   ContractApprovalId   query   int  false       "审批单id"
+// @Success 200 {object} response.ContractApprovalListResp
+// @router /detail [get]
+func (this *ContractApprovalCommon) Detail() {
+
+	//审批单id
+	contractApprovalId, _ := this.GetInt("ContractApprovalId")
+
+	//审批单详情
+	contractApprovalInfo, err := contract_approval.GetContractApprovalById(contractApprovalId)
+	if err != nil {
+		this.FailWithMessage("获取审批单失败！", "获取审批单失败，Err:"+err.Error())
+		return
+	}
+	var contractDetail contract.ContractDetail
+	jsonErr := json.Unmarshal([]byte(contractApprovalInfo.ContractDetail), &contractDetail)
+	if jsonErr != nil {
+		this.FailWithMessage("审批合同数据转换失败！", "审批合同数据转换失败，Err:"+jsonErr.Error())
+		return
+	}
+	this.OkDetailed(contractDetail, "获取成功")
+}
+
 // @Title 驳回审批
 // @Description 驳回审批接口
 // @Param	request	body contract.RejectReq true "type json string"

controllers/seal.go

@@ -0,0 +1,112 @@
+package controllers
+
+import (
+	"encoding/json"
+	sealReq "hongze/hongze_mobile_admin/models/request/seal"
+	sealResp "hongze/hongze_mobile_admin/models/response/seal"
+	"hongze/hongze_mobile_admin/services/seal"
+	sealService "hongze/hongze_mobile_admin/services/seal"
+	"hongze/hongze_mobile_admin/utils"
+)
+
+//用印模块
+type SealCommon struct {
+	BaseAuth
+}
+
+// @Title 新增用印
+// @Description 新增用印接口
+// @Param	request	body sealReq.AddReq true "type json string"
+// @Success Ret=200 新增用印成功
+// @router /add [post]
+func (this *SealCommon) Add() {
+	var req sealReq.AddReq
+	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
+	if err != nil {
+		this.FailWithMessage("参数解析异常！", "参数解析失败，Err:"+err.Error())
+		return
+	}
+
+	//参数校验
+	paramVerify := utils.Rules{
+		"Use":         {utils.NotEmpty()},
+		"CompanyName": {utils.NotEmpty()},
+		"CreditCode":  {utils.NotEmpty()},
+		"ServiceType": {utils.NotEmpty()},
+		"SealType":    {utils.NotEmpty()},
+		"FileUrl":     {utils.NotEmpty()},
+	}
+	err = utils.Verify(req, paramVerify, utils.LANG_CN)
+
+	if err != nil {
+		this.FailWithMessage("缺少参数", err.Error())
+		return
+	}
+	sealInfo, err := seal.AddSeal(this.AdminWx.AdminId, this.AdminWx.RealName, req.Use, req.CompanyName, req.CreditCode, req.ServiceType, req.SealType, req.Remark, req.FileUrl)
+	if err != nil {
+		this.FailWithMessage("用印添加失败", err.Error())
+		return
+	}
+
+	msg := "添加用印成功"
+	if req.IsAudit {
+		err = sealService.Apply(sealInfo)
+		if err != nil {
+			this.FailWithMessage("发起用印审批失败", "发起用印审批失败，Err:"+err.Error())
+			return
+		}
+		msg = "发起用印审批成功"
+	}
+	this.OkDetailed(sealResp.AddSealResp{
+		SealId: sealInfo.SealId,
+	}, msg)
+}
+
+// @Title 编辑用印
+// @Description 编辑用印接口
+// @Param	request	body request.EditContractReq true "type json string"
+// @Success 200 {object} response.AddContractResp
+// @router /edit [post]
+func (this *SealCommon) Edit() {
+	var req sealReq.EditReq
+	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
+	if err != nil {
+		this.FailWithMessage("参数解析异常！", "参数解析失败，Err:"+err.Error())
+		return
+	}
+
+	//参数校验
+	paramVerify := utils.Rules{
+		"SealId":      {utils.NotEmpty()},
+		"Use":         {utils.NotEmpty()},
+		"CompanyName": {utils.NotEmpty()},
+		"CreditCode":  {utils.NotEmpty()},
+		"ServiceType": {utils.NotEmpty()},
+		"SealType":    {utils.NotEmpty()},
+		"FileUrl":     {utils.NotEmpty()},
+	}
+	err = utils.Verify(req, paramVerify, utils.LANG_CN)
+
+	if req.SealId <= 0 {
+		this.FailWithMessage("合同编号必传！", "合同编号必传！")
+		return
+	}
+	sealInfo, err := seal.Edit(req.SealId, this.AdminWx.AdminId, this.AdminWx.RealName, req.Use, req.CompanyName, req.CreditCode, req.ServiceType, req.SealType, req.Remark, req.FileUrl)
+	if err != nil {
+		this.FailWithMessage("修改合同失败！", "修改合同失败，Err:"+err.Error())
+		return
+	}
+	msg := "修改成功"
+	//如果发起重新审核，那么
+	if req.ReAudit {
+		tmpErr := sealService.Apply(sealInfo)
+		if tmpErr != nil {
+			this.FailWithMessage("发起重申失败！", "发起重申失败，Err:"+tmpErr.Error())
+			return
+		}
+		msg = "发起重申成功"
+	}
+	this.OkDetailed(sealResp.AddSealResp{
+		SealId: sealInfo.SealId,
+	}, msg)
+}

controllers/seal_approval.go

@@ -0,0 +1,270 @@
+package controllers
+
+import (
+	"encoding/json"
+	contractReq "hongze/hongze_mobile_admin/models/request/contract"
+	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"
+	contractService "hongze/hongze_mobile_admin/services/contract"
+	"hongze/hongze_mobile_admin/utils"
+	"rdluck_tools/paging"
+	"strconv"
+	"strings"
+)
+
+//用印审批模块
+type SealApprovalCommon struct {
+	BaseAuth
+}
+
+// @Title 审批单列表
+// @Description 审批单列表接口
+// @Param   ContractType   query   string  false       "合同类型，枚举值：'新签合同','续约合同','补充协议'"
+// @Param   Status   query   string  false       "合同状态，枚举值：'待审批','已审批','已驳回','已撤回'"
+// @Param   ProductId   query   int  false       "客户类型：传0或者不传为当前账号权限,1 代表是：ficc；2 代表是：权益"
+// @Param   SellerId   query   string  false       "选择的销售id"
+// @Param   Keyword   query   string  false       "搜索关键字"
+// @Param   ModifyStartTime   query   string  false       "服务更新时间的选择开始时间，格式：2021-05-23 00:00:00"
+// @Param   ModifyEndTime   query   string  false       "服务更新时间的选择结束时间，格式：2021-05-26 23:59:59"
+// @Success 200 {object} response.ContractApprovalListResp
+// @router /list [get]
+func (this *SealApprovalCommon) List() {
+	sysUser := this.AdminWx
+
+	//合同类型、产品类型、合同状态、更新时间、所选销售
+	//关键字：合同编号、客户名称，社会信用码
+	contractType := this.GetString("ContractType")
+	status := this.GetString("Status")
+	productId, _ := this.GetInt("ProductId")
+	sellerIds := this.GetString("SellerId")
+	keyword := this.GetString("Keyword")
+	modifyStartTime := this.GetString("ModifyStartTime")
+	modifyEndTime := this.GetString("ModifyEndTime")
+
+	childCondition := ""
+	condition := ""
+	childPars := make([]interface{}, 0)
+	pars := make([]interface{}, 0)
+	////如果不是超管或者合规，那么只能查看自己的合同
+	//if sysUser.RoleTypeCode == utils.ROLE_TYPE_CODE_RAI_ADMIN { //权益管理员
+	//	condition += ` AND c.product_id = ? `
+	//	pars = append(pars, 2)
+	//} else if sysUser.RoleTypeCode == utils.ROLE_TYPE_CODE_FICC_ADMIN { //ficc管理员
+	//	condition += ` AND c.product_id = ? `
+	//	pars = append(pars, 1)
+	//} else {
+	//	if sysUser.RoleTypeCode != utils.ROLE_TYPE_CODE_COMPLIANCE && sysUser.RoleTypeCode != utils.ROLE_TYPE_CODE_ADMIN {
+	//		condition += ` AND c.seller_id = ? `
+	//		pars = append(pars, sysUser.AdminId)
+	//	}
+	//}
+
+	condition += ` AND (c.user_id = ? or d.approve_user_id = ?)`
+	pars = append(pars, sysUser.AdminId, sysUser.AdminId)
+
+	//合同类型、、更新时间、所选销售
+	//关键字：合同编号、客户名称，社会信用码
+	if contractType != "" {
+		condition += ` AND c.contract_type = ? `
+		pars = append(pars, contractType)
+	}
+	//审批状态
+	if status != "" {
+		//childCondition += ` AND status = ? `
+		//childPars = append(childPars, status)
+
+		if status == "已审批" {
+			condition += ` AND c.status in ("已审批","已驳回")  `
+		} else {
+			condition += ` AND c.status = ? `
+			pars = append(pars, status)
+		}
+	} else {
+		//childCondition += ` AND status != "已撤回" `
+
+		condition += ` AND c.status not in ("已撤回","待提交")  `
+	}
+	//产品类型
+	if productId > 0 {
+		condition += ` AND c.product_id = ? `
+		pars = append(pars, productId)
+	}
+	//所选销售
+	if sellerIds != "" {
+		condition += ` AND c.user_id IN (` + sellerIds + `) `
+	}
+	//更新开始时间
+
+	//更新开始时间
+	if modifyStartTime != "" {
+		condition += ` AND a.modify_time >= ? `
+		pars = append(pars, modifyStartTime)
+	}
+	//更新结束时间
+	if modifyEndTime != "" {
+		condition += ` AND a.modify_time <= ? `
+		pars = append(pars, modifyEndTime)
+	}
+	//关键字
+	if keyword != "" {
+		condition += ` AND (c.contract_code LIKE '%` + keyword + `%' OR c.company_name LIKE '%` + keyword + `%' OR c.credit_code LIKE '%` + keyword + `%' ) `
+	}
+
+	pageSize, _ := this.GetInt("PageSize")
+	currentIndex, _ := this.GetInt("CurrentIndex")
+
+	var startSize int
+	if pageSize <= 0 {
+		pageSize = utils.PageSize20
+	}
+	if currentIndex <= 0 {
+		currentIndex = 1
+	}
+	startSize = paging.StartIndex(currentIndex, pageSize)
+
+	total, err := contract_approval.GetSealApprovalListCount(childCondition, condition, childPars, pars)
+	if err != nil {
+		this.FailWithMessage("获取失败", "获取数据总数失败，Err:"+err.Error())
+		return
+	}
+
+	list, err := contract_approval.GetSealApprovalList(childCondition, condition, childPars, pars, startSize, pageSize)
+	if err != nil {
+		this.FailWithMessage("获取审批列表失败！", "获取审批列表失败，Err:"+err.Error())
+		return
+	}
+
+	if len(list) > 0 {
+		contractApprovalIdSlice := make([]string, 0)
+		for i := 0; i < len(list); i++ {
+			contractApprovalIdSlice = append(contractApprovalIdSlice, strconv.Itoa(list[i].ContractApprovalId))
+		}
+		contractApprovalIdStr := strings.Join(contractApprovalIdSlice, ",")
+
+		//获取审批流列表数据
+		contractApprovalRecordList, err := contract_approval_record.GetContractApprovalRecordList(contractApprovalIdStr, sysUser.AdminId)
+		if err != nil {
+			this.FailWithMessage("获取审批列表失败！", "获取审批列表失败，Err:"+err.Error())
+			return
+		}
+		contractApprovalRecordMap := make(map[int]*contract_approval_record.ContractApprovalRecord)
+		for i := 0; i < len(contractApprovalRecordList); i++ {
+			contractApprovalRecordMap[contractApprovalRecordList[i].ContractApprovalId] = contractApprovalRecordList[i]
+		}
+
+		for i := 0; i < len(list); i++ {
+			item := list[i]
+			list[i].StartDateStr = item.StartDate.Format(utils.FormatDate)
+			list[i].EndDateStr = item.EndDate.Format(utils.FormatDate)
+			list[i].CreateTimeStr = item.CreateTime.Format(utils.FormatDateTime)
+			list[i].ModifyTimeStr = item.ModifyTime.Format(utils.FormatDateTime)
+
+			//list[i].ContractInfo = contractDetail
+			//校验最新审批流数据
+			if contractApprovalRecord, has := contractApprovalRecordMap[item.ContractApprovalId]; has {
+				//审批流id
+				list[i].ContractApprovalRecordId = contractApprovalRecord.ContractApprovalRecordId
+				//审批时间
+				list[i].ApproveTime = contractApprovalRecord.ApproveTime
+				list[i].ApproveTimeStr = contractApprovalRecord.ApproveTime.Format(utils.FormatDateTime)
+				//判断是否有操作权限
+				list[i].Status = contractApprovalRecord.Status
+
+				//判断是否处于待审批状态
+				//if contractApprovalRecord.Status == "待审批" {
+				//	//如果不是审批者，那么不能审批操作
+				//	if contractApprovalRecord.NodeType != "check" {
+				//		continue
+				//	}
+				//	//如果没有指定审批人的话
+				//	if contractApprovalRecord.ApproveUserId <= 0 {
+				//		//判断是否与审批角色一致，如果一致，那么允许操作审批
+				//		if contractApprovalRecord.ApproveRoleTypeCode == sysUser.RoleTypeCode {
+				//			list[i].CanApprovalButton = true
+				//		}
+				//	} else if contractApprovalRecord.ApproveUserId == sysUser.AdminId {
+				//		//如果指定审批人就是自己的话，那么操作审批
+				//		list[i].CanApprovalButton = true
+				//	}
+				//}
+			}
+
+			//合同状态（突然说要改成展示合同状态，那就根据业务需求，改成返回：合同状态咯）
+			list[i].Status = item.ContractStatus
+		}
+	}
+
+	page := paging.GetPaging(currentIndex, pageSize, total)
+	this.OkDetailed(sealResp.SealApprovalListResp{
+		List:   list,
+		Paging: page,
+	}, "获取成功")
+}
+
+// @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)
+	if err != nil {
+		this.FailWithMessage("参数解析异常！", "参数解析失败，Err:"+err.Error())
+		return
+	}
+	//审批流id编号
+	contractApprovalRecordId := req.ContractApprovalRecordId
+	if contractApprovalRecordId <= 0 {
+		this.FailWithMessage("请传入审批流编号！", "请传入审批流编号")
+		return
+	}
+
+	//获取审批流信息
+	contractApprovalRecord, err := contract_approval_record.GetContractApprovalRecordById(contractApprovalRecordId)
+	if err != nil {
+		this.FailWithMessage("获取审批流信息失败！", "获取审批流信息失败，Err:"+err.Error())
+		return
+	}
+	err = contractService.Reject(contractApprovalRecord, this.AdminWx, req.Remark)
+	if err != nil {
+		this.FailWithMessage("驳回审批失败！", "驳回审批失败，Err:"+err.Error())
+		return
+	}
+	this.OkWithMessage("驳回成功")
+}
+
+// @Title 处理审批单
+// @Description 处理审批单
+// @Param	request	body request.ApprovedReq true "type json string"
+// @Success Ret=200 申请成功
+// @router /approved [post]
+func (this *SealApprovalCommon) Approved() {
+
+	var req contractReq.ApprovedReq
+	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
+	if err != nil {
+		this.FailWithMessage("参数解析异常！", "参数解析失败，Err:"+err.Error())
+		return
+	}
+	//审批流id编号
+	contractApprovalRecordId := req.ContractApprovalRecordId
+	if contractApprovalRecordId <= 0 {
+		this.FailWithMessage("请传入审批流编号！", "请传入审批流编号")
+		return
+	}
+
+	//获取审批流信息
+	contractApprovalRecord, err := contract_approval_record.GetContractApprovalRecordById(contractApprovalRecordId)
+	if err != nil {
+		this.FailWithMessage("获取审批流信息失败！", "获取审批流信息失败，Err:"+err.Error())
+		return
+	}
+	err = contractService.Approved(contractApprovalRecord, this.AdminWx, req.Remark)
+	if err != nil {
+		this.FailWithMessage("审核失败！", "审核失败，Err:"+err.Error())
+		return
+	}
+	this.OkWithMessage("审核通过")
+}

models/db_init.go

@@ -27,6 +27,7 @@ import (
 	"hongze/hongze_mobile_admin/models/tables/h5_admin_session"
 	"hongze/hongze_mobile_admin/models/tables/report"
 	"hongze/hongze_mobile_admin/models/tables/resource"
+	"hongze/hongze_mobile_admin/models/tables/seal"
 	"hongze/hongze_mobile_admin/models/tables/wx_token"
 	"hongze/hongze_mobile_admin/models/tables/wx_user"
 	"hongze/hongze_mobile_admin/utils"
@@ -79,6 +80,7 @@ func init() {
 		new(resource.Resource),
 		new(wx_token.WxToken),
 		new(wx_user.WxUser),
+		new(seal.Seal),
 	)
 
 }

models/request/seal/sale.go

@@ -0,0 +1,26 @@
+package seal
+
+//新增用印请求
+type AddReq struct {
+	Use         string `description:"用印用途，枚举值：'销售合同', '渠道合同', '付款通知函', '招投标', '战略合作协议'；默认：销售合同"`
+	CompanyName string `description:"客户名称，甲方名称,长度32位"`
+	CreditCode  string `description:"社会统一信用代码,长度64位"`
+	ServiceType string `description:"业务类型，枚举值：'新增业务', '续约业务', '补充协议'；默认：新增业务"`
+	SealType    string `description:"加盖印章类型，枚举值：'合同章', '公章', '法人章';默认：合同章"`
+	Remark      string `description:"备注,长度255位"`
+	FileUrl     string `description:"文件附件地址"`
+	IsAudit     bool   `description:"是否发起审批"`
+}
+
+//编辑用印请求
+type EditReq struct {
+	SealId      int    `description:"用印id"`
+	Use         string `description:"用印用途，枚举值：'销售合同', '渠道合同', '付款通知函', '招投标', '战略合作协议'；默认：销售合同"`
+	CompanyName string `description:"客户名称，甲方名称,长度32位"`
+	CreditCode  string `description:"社会统一信用代码,长度64位"`
+	ServiceType string `description:"业务类型，枚举值：'新增业务', '续约业务', '补充协议'；默认：新增业务"`
+	SealType    string `description:"加盖印章类型，枚举值：'合同章', '公章', '法人章';默认：合同章"`
+	Remark      string `description:"备注,长度255位"`
+	FileUrl     string `description:"文件附件地址"`
+	ReAudit     bool   `description:"是否重新发起审批"`
+}

models/request/seal/seal_approval.go

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

models/response/contract/contract.go

@@ -1,6 +1,7 @@
 package contract
 
 import (
+	"hongze/hongze_mobile_admin/models/custom/contract"
 	"hongze/hongze_mobile_admin/models/tables/company_contract"
 	"hongze/hongze_mobile_admin/models/tables/contract_approval"
 	"rdluck_tools/paging"
@@ -28,3 +29,44 @@ type ContractApprovalListResp struct {
 	Paging *paging.PagingItem
 	List   []*contract_approval.ContractApprovalList `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:"合同文件地址"`
+	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       []*contract.ContractServiceAndDetail
+}

models/response/seal/seal.go

@@ -0,0 +1,16 @@
+package seal
+
+import (
+	"hongze/hongze_mobile_admin/models/tables/contract_approval"
+	"rdluck_tools/paging"
+)
+
+type AddSealResp struct {
+	SealId int `description:"用印id"`
+}
+
+//审批列表
+type SealApprovalListResp struct {
+	Paging *paging.PagingItem
+	List   []*contract_approval.SealApprovalList `description:"列表数据"`
+}

models/tables/contract_approval/contract_approval.go

@@ -11,6 +11,7 @@ import (
 //合同审批单
 type ContractApproval struct {
 	ContractApprovalId int       `orm:"column(contract_approval_id);pk"`
+	ApprovalType       string    `description:"审批单类型，枚举值，合同：contract；用印：seal；默认：contract"`
 	ContractId         int       `orm:"column(contract_id)";description:"合同id"`
 	Status             string    `description:"审批单状态，枚举值：待审批','已审批','已驳回','已撤回'，默认待审批"`
 	ApplyContent       string    `description:"待审内容，长度255位"`
@@ -49,20 +50,7 @@ func GetRejectContractCountByContractId(contractId int) (total int64, err error)
 	return
 }
 
-//获取审批列表数据数量
-func GetContractApprovalListCountOld(condition string, pars []interface{}) (count int, err error) {
-	o := orm.NewOrm()
-	sql := `
-SELECT a.* from contract_approval a
-	JOIN contract c ON a.contract_id = c.contract_id 
-WHERE
-	c.is_delete = 0  `
-	sql += condition
-	sql += ` GROUP BY a.contract_id `
-	sql = `select count(*) count from (` + sql + `) b`
-	err = o.Raw(sql, pars).QueryRow(&count)
-	return
-}
+//获取合同审批列表数据数量
 func GetContractApprovalListCount(childCondition, condition string, childPars, pars []interface{}) (count int, err error) {
 	o := orm.NewOrm()
 	sql := `
@@ -84,7 +72,7 @@ WHERE c.is_delete = 0 `
 	return
 }
 
-//审批列表
+//合同审批列表
 type ContractApprovalList struct {
 	ContractApprovalId       int                     `description:"审批单id"`
 	ContractId               int                     `description:"合同id"`
@@ -108,7 +96,6 @@ type ContractApprovalList struct {
 	CreateTime               time.Time               `description:"发起审批的时间"`
 	ModifyTime               time.Time               `description:"最后一次修改的时间"`
 	ApproveTime              time.Time               `description:"审批时间"`
-	CanApprovalButton        bool                    `description:"是否具有审核操作权限，true才允许审核操作"`
 	StartDateStr             string                  `description:"合同开始日期(字符串类型)"`
 	EndDateStr               string                  `description:"合同结束日期(字符串类型)"`
 	CreateTimeStr            string                  `description:"发起审批的时间(字符串类型)"`
@@ -116,12 +103,12 @@ type ContractApprovalList struct {
 	ApproveTimeStr           string                  `description:"审批时间（字符串类型）"`
 }
 
-//获取审批列表数据
+//获取合同审批列表数据
 func GetContractApprovalList(childCondition, condition string, childPars, pars []interface{}, startSize, pageSize int) (list []*ContractApprovalList, err error) {
 	o := orm.NewOrm()
 	sql := `
 SELECT
-a.contract_approval_id,a.contract_id,a.apply_content,a.approve_remark,a.create_time,a.modify_time,a.status,c.status contract_status,c.product_id,
+a.contract_approval_id,d.contract_approval_record_id,a.contract_id,a.apply_content,a.approve_remark,a.create_time,a.modify_time,a.status,c.status contract_status,c.product_id,
 c.contract_type,c.start_date,c.end_date,c.price,c.company_name,c.seller_id,c.seller_name,c.file_url,c.contract_code from contract_approval a
 	join 
 	( SELECT max( contract_approval_id ) max_id,contract_id FROM contract_approval where 1=1 `
@@ -137,11 +124,11 @@ WHERE c.is_delete = 0 `
 }
 
 //根据合同id获取合同审批单信息
-func (ContractApproval) CheckPendingByContractId(contractId int) (has bool, err error) {
+func (ContractApproval) CheckPendingByContractId(contractId int, approvalType string) (has bool, err error) {
 	o := orm.NewOrm()
 	var contractApprovalInfo ContractApproval
-	sql := `select * from contract_approval where contract_id = ? AND status="待审批" limit 1`
-	err = o.Raw(sql, contractId).QueryRow(&contractApprovalInfo)
+	sql := `select * from contract_approval where contract_id = ? AND approval_type =? AND status="待审批" limit 1`
+	err = o.Raw(sql, contractId, approvalType).QueryRow(&contractApprovalInfo)
 	if err != nil {
 		if err.Error() == utils.ErrNoRow() {
 			//如果不存在待审批记录，那么报错信息置空，存在与否直接返回false
@@ -156,42 +143,8 @@ func (ContractApproval) CheckPendingByContractId(contractId int) (has bool, err
 	return
 }
 
-//发起审批
-func (ContractApproval) Apply(contractApprovalInfo *ContractApproval, contractApprovalRecord *contract_approval_record.ContractApprovalRecord) (err error) {
-	o := orm.NewOrm()
-	o.Begin()
-	defer func() {
-		if err != nil {
-			o.Rollback()
-		} else {
-			o.Commit()
-		}
-	}()
-	//审批单记录
-	ContractApprovalId, err := o.Insert(contractApprovalInfo)
-	if err != nil {
-		return
-	}
-	//审批单id
-	contractApprovalInfo.ContractApprovalId = int(ContractApprovalId)
-
-	//审批流记录
-	contractApprovalRecord.ContractApprovalId = contractApprovalInfo.ContractApprovalId
-	contractApprovalRecordId, err := o.Insert(contractApprovalRecord)
-	if err != nil {
-		return
-	}
-	//审批流id
-	contractApprovalRecord.ContractApprovalRecordId = int(contractApprovalRecordId)
-
-	//修改合同状态为待审批
-	sql := `UPDATE contract SET status="待审批",modify_time=NOW() WHERE contract_id = ?`
-	_, err = o.Raw(sql, contractApprovalInfo.ContractId).Exec()
-	return
-}
-
 //发起审批（工作流）
-func (ContractApproval) Apply2(contractApprovalInfo *ContractApproval, contractApprovalRecordList []*contract_approval_record.ContractApprovalRecord) (err error) {
+func (ContractApproval) Apply(contractApprovalInfo *ContractApproval, contractApprovalRecordList []*contract_approval_record.ContractApprovalRecord) (err error) {
 	o := orm.NewOrm()
 	o.Begin()
 	defer func() {
@@ -221,46 +174,21 @@ func (ContractApproval) Apply2(contractApprovalInfo *ContractApproval, contractA
 		contractApprovalRecord.ContractApprovalRecordId = int(contractApprovalRecordId)
 	}
 
-	//修改合同状态为待审批
-	sql := `UPDATE contract SET status="待审批",modify_time=NOW() WHERE contract_id = ?`
-	_, err = o.Raw(sql, contractApprovalInfo.ContractId).Exec()
-	return
-}
-
-//撤回审核单
-func (ContractApproval) Cancel(contractApprovalInfo *ContractApproval, contractApprovalRecord *contract_approval_record.ContractApprovalRecord) (err error) {
-	o := orm.NewOrm()
-	o.Begin()
-	defer func() {
-		if err != nil {
-			o.Rollback()
-		} else {
-			o.Commit()
-		}
-	}()
-	//变更审批单记录
-	contractApprovalInfo.Status = "已撤回"
-	contractApprovalInfo.ModifyTime = time.Now()
-	_, err = o.Update(contractApprovalInfo)
-	if err != nil {
-		return
-	}
-
-	//变更审批流记录
-	contractApprovalRecord.Status = "已撤回"
-	contractApprovalRecord.ModifyTime = time.Now()
-	_, err = o.Update(contractApprovalRecord)
-	if err != nil {
-		return
+	switch contractApprovalInfo.ApprovalType {
+	case "contract":
+		//修改合同状态为待审批
+		sql := `UPDATE contract SET status="待审批",modify_time=NOW() WHERE contract_id = ?`
+		_, err = o.Raw(sql, contractApprovalInfo.ContractId).Exec()
+	case "seal":
+		//修改用印状态为待审批
+		sql := `UPDATE seal SET status="待审批",modify_time=NOW() WHERE seal_id = ?`
+		_, err = o.Raw(sql, contractApprovalInfo.ContractId).Exec()
 	}
-
-	//修改合同状态为已撤回
-	sql := `UPDATE contract SET status="已撤回",modify_time=NOW() WHERE contract_id = ?`
-	_, err = o.Raw(sql, contractApprovalInfo.ContractId).Exec()
 	return
 }
 
-func (ContractApproval) Cancel2(contractApprovalInfo *ContractApproval, contractApprovalRecordList []*contract_approval_record.ContractApprovalRecord) (err error) {
+//撤回审核单
+func (ContractApproval) Cancel(contractApprovalInfo *ContractApproval, contractApprovalRecordList []*contract_approval_record.ContractApprovalRecord) (err error) {
 	o := orm.NewOrm()
 	o.Begin()
 	defer func() {
@@ -289,9 +217,16 @@ func (ContractApproval) Cancel2(contractApprovalInfo *ContractApproval, contract
 		}
 	}
 
-	//修改合同状态为已撤回
-	sql := `UPDATE contract SET status="已撤回",modify_time=NOW() WHERE contract_id = ?`
-	_, err = o.Raw(sql, contractApprovalInfo.ContractId).Exec()
+	switch contractApprovalInfo.ApprovalType {
+	case "contract":
+		//修改合同状态为已撤回
+		sql := `UPDATE contract SET status="已撤回",modify_time=NOW() WHERE contract_id = ?`
+		_, err = o.Raw(sql, contractApprovalInfo.ContractId).Exec()
+	case "seal":
+		//修改用印状态为已撤回
+		sql := `UPDATE seal SET status="已撤回",modify_time=NOW() WHERE seal_id = ?`
+		_, err = o.Raw(sql, contractApprovalInfo.ContractId).Exec()
+	}
 	return
 }
 
@@ -310,8 +245,8 @@ func (ContractApproval) Reject(contractApprovalInfo *ContractApproval, contractA
 	contractApprovalInfo.Status = "已驳回"
 	contractApprovalInfo.ApproveRemark = remark //审核失败理由
 	contractApprovalInfo.ModifyTime = time.Now()
-	contractApprovalInfo.CurrNodeId = 0 //当前节点变更为0，代表当前审批流程已经结束了
-	_, err = o.Update(contractApprovalInfo)
+	//contractApprovalInfo.CurrNodeId = 0 //当前节点变更为0，代表当前审批流程已经结束了
+	_, err = o.Update(contractApprovalInfo, "Status", "ApproveRemark", "ModifyTime")
 	if err != nil {
 		return
 	}
@@ -328,9 +263,16 @@ func (ContractApproval) Reject(contractApprovalInfo *ContractApproval, contractA
 		return
 	}
 
-	//修改合同状态为已驳回
-	sql := `UPDATE contract SET status="已驳回",modify_content="",approval_remark=?,modify_time=NOW() WHERE contract_id = ?`
-	_, err = o.Raw(sql, remark, contractApprovalInfo.ContractId).Exec()
+	switch contractApprovalInfo.ApprovalType {
+	case "contract":
+		//修改合同状态为已驳回
+		sql := `UPDATE contract SET status="已驳回",modify_content="",approval_remark=?,modify_time=NOW() WHERE contract_id = ?`
+		_, err = o.Raw(sql, remark, contractApprovalInfo.ContractId).Exec()
+	case "seal":
+		//修改用印状态为已驳回
+		sql := `UPDATE seal SET status="已驳回",approval_remark=?,modify_time=NOW() WHERE contract_id = ?`
+		_, err = o.Raw(sql, remark, contractApprovalInfo.ContractId).Exec()
+	}
 	return
 }
 
@@ -342,69 +284,6 @@ type NextApproval struct {
 }
 
 //审核通过
-func (ContractApproval) ApprovedOld(contractApprovalInfo *ContractApproval, contractApprovalRecord *contract_approval_record.ContractApprovalRecord, approveUserId int, approveUserName, remark string, nextApproval NextApproval) (err error) {
-	o := orm.NewOrm()
-	o.Begin()
-	defer func() {
-		if err != nil {
-			o.Rollback()
-		} else {
-			o.Commit()
-		}
-	}()
-
-	//变更审批流记录
-	contractApprovalRecord.Status = "已审批"
-	contractApprovalRecord.ApproveRemark = remark            //审核失败理由
-	contractApprovalRecord.ApproveUserId = approveUserId     //审批人id
-	contractApprovalRecord.ApproveUserName = approveUserName //审批人名称
-	contractApprovalRecord.ApproveTime = time.Now()          //审批人名称
-	contractApprovalRecord.ModifyTime = time.Now()
-	_, err = o.Update(contractApprovalRecord)
-	if err != nil {
-		return
-	}
-
-	//判断是否存在下一级的审批人，如果不存在，那么就去变更审批单和合同的状态
-	if nextApproval.ApproveRoleTypeCode == "" && nextApproval.ApproveUserId == 0 {
-		//变更审批单记录
-		contractApprovalInfo.Status = "已审批"
-		contractApprovalInfo.ApproveRemark = remark //审核理由
-		contractApprovalInfo.ModifyTime = time.Now()
-		_, tmpErr := o.Update(contractApprovalInfo)
-		if tmpErr != nil {
-			err = tmpErr
-			return
-		}
-
-		//修改合同状态为已审批
-		sql := `UPDATE contract SET status="已审批",approval_remark=?,modify_time=NOW() WHERE contract_id = ?`
-		_, tmpErr = o.Raw(sql, remark, contractApprovalInfo.ContractId).Exec()
-		if tmpErr != nil {
-			err = tmpErr
-			return
-		}
-	} else {
-		//如果还存在下一级审批人，那么进入下级审批流
-		nextContractApprovalRecord := &contract_approval_record.ContractApprovalRecord{
-			ContractApprovalId:  contractApprovalInfo.ContractApprovalId,
-			Status:              "待审批",
-			ApproveRoleTypeCode: nextApproval.ApproveRoleTypeCode,
-			ApproveUserId:       nextApproval.ApproveUserId,
-			ApproveUserName:     nextApproval.ApproveUserName,
-			ModifyTime:          time.Now(),
-			CreateTime:          time.Now(),
-		}
-		nextContractApprovalRecordId, tmpErr := o.Insert(nextContractApprovalRecord)
-		if tmpErr != nil {
-			err = tmpErr
-			return
-		}
-		nextContractApprovalRecord.ContractApprovalRecordId = int(nextContractApprovalRecordId)
-	}
-
-	return
-}
 func (ContractApproval) Approved(contractApprovalInfo *ContractApproval, contractApprovalRecord *contract_approval_record.ContractApprovalRecord, remark string) (err error) {
 	o := orm.NewOrm()
 	o.Begin()
@@ -430,21 +309,32 @@ func (ContractApproval) Approved(contractApprovalInfo *ContractApproval, contrac
 	if contractApprovalRecord.NextNodeId <= 0 {
 		//变更审批单记录
 		contractApprovalInfo.Status = "已审批"
-		contractApprovalInfo.ApproveRemark = remark                         //审核理由
-		contractApprovalInfo.CurrNodeId = contractApprovalRecord.NextNodeId //下级审批节点id
+		contractApprovalInfo.ApproveRemark = remark //审核理由
+		//contractApprovalInfo.CurrNodeId = contractApprovalRecord.NextNodeId //下级审批节点id
 		contractApprovalInfo.ModifyTime = time.Now()
-		_, tmpErr := o.Update(contractApprovalInfo, "Status", "ApproveRemark", "CurrNodeId", "ModifyTime")
+		_, tmpErr := o.Update(contractApprovalInfo, "Status", "ApproveRemark", "ModifyTime")
 		if tmpErr != nil {
 			err = tmpErr
 			return
 		}
 
-		//修改合同状态为已审批
-		sql := `UPDATE contract SET status="已审批",approval_remark=?,modify_time=NOW() WHERE contract_id = ?`
-		_, tmpErr = o.Raw(sql, remark, contractApprovalInfo.ContractId).Exec()
-		if tmpErr != nil {
-			err = tmpErr
-			return
+		switch contractApprovalInfo.ApprovalType {
+		case "contract":
+			//修改合同状态为已审批
+			sql := `UPDATE contract SET status="已审批",approval_remark=?,modify_time=NOW() WHERE contract_id = ?`
+			_, tmpErr = o.Raw(sql, remark, contractApprovalInfo.ContractId).Exec()
+			if tmpErr != nil {
+				err = tmpErr
+				return
+			}
+		case "seal":
+			//修改用印状态为已审批
+			sql := `UPDATE seal SET status="已审批",approval_remark=?,modify_time=NOW() WHERE contract_id = ?`
+			_, tmpErr = o.Raw(sql, remark, contractApprovalInfo.ContractId).Exec()
+			if tmpErr != nil {
+				err = tmpErr
+				return
+			}
 		}
 	} else {
 		//变更审批单记录
@@ -492,20 +382,31 @@ func (ContractApproval) ApprovedByCc(contractApprovalInfo *ContractApproval, con
 	if nextNodeId <= 0 {
 		//变更审批单记录
 		contractApprovalInfo.Status = "已审批"
-		contractApprovalInfo.CurrNodeId = nextNodeId //下级审批节点id
+		//contractApprovalInfo.CurrNodeId = nextNodeId //下级审批节点id
 		contractApprovalInfo.ModifyTime = time.Now()
-		_, tmpErr := o.Update(contractApprovalInfo, "Status", "CurrNodeId", "ModifyTime")
+		_, tmpErr := o.Update(contractApprovalInfo, "Status", "ModifyTime")
 		if tmpErr != nil {
 			err = tmpErr
 			return
 		}
 
-		//修改合同状态为已审批
-		sql := `UPDATE contract SET status="已审批",approval_remark=?,modify_time=NOW() WHERE contract_id = ?`
-		_, tmpErr = o.Raw(sql, remark, contractApprovalInfo.ContractId).Exec()
-		if tmpErr != nil {
-			err = tmpErr
-			return
+		switch contractApprovalInfo.ApprovalType {
+		case "contract":
+			//修改合同状态为已审批
+			sql := `UPDATE contract SET status="已审批",approval_remark=?,modify_time=NOW() WHERE contract_id = ?`
+			_, tmpErr = o.Raw(sql, remark, contractApprovalInfo.ContractId).Exec()
+			if tmpErr != nil {
+				err = tmpErr
+				return
+			}
+		case "seal":
+			//修改用印状态为已审批
+			sql := `UPDATE seal SET status="已审批",approval_remark=?,modify_time=NOW() WHERE contract_id = ?`
+			_, tmpErr = o.Raw(sql, remark, contractApprovalInfo.ContractId).Exec()
+			if tmpErr != nil {
+				err = tmpErr
+				return
+			}
 		}
 	} else {
 		//变更审批单记录
@@ -528,3 +429,76 @@ func GetContractApprovalByIds(contractApprovalIds string) (contractApprovalList
 	_, err = o.Raw(sql).QueryRows(&contractApprovalList)
 	return
 }
+
+//获取用印审批列表数据数量
+func GetSealApprovalListCount(childCondition, condition string, childPars, pars []interface{}) (count int, err error) {
+	o := orm.NewOrm()
+	sql := `
+SELECT
+a.contract_approval_id,a.contract_id,a.apply_content,a.contract_detail,a.approve_remark,a.create_time,a.modify_time,a.status,c.status contract_status,c.product_id,
+c.contract_type,c.start_date,c.end_date,c.price,c.company_name,c.seller_id,c.seller_name,c.file_url,c.contract_code from contract_approval a
+	join 
+	( SELECT max( contract_approval_id ) max_id,contract_id FROM contract_approval where 1=1 `
+	sql += childCondition
+	sql += `  GROUP BY contract_id ) b on a.contract_approval_id=b.max_id
+	JOIN seal c ON a.seal_id = c.contract_id 
+	JOIN contract_approval_record d on a.contract_approval_id=d.contract_approval_id
+WHERE c.is_delete = 0 `
+	sql += condition
+	sql += ` group by contract_id `
+
+	sql = `select count(*) count from (` + sql + `) g`
+	err = o.Raw(sql, childPars, pars).QueryRow(&count)
+	return
+}
+
+//用印审批列表
+type SealApprovalList struct {
+	ContractApprovalId       int                     `description:"审批单id"`
+	ContractId               int                     `description:"合同id"`
+	ContractApprovalRecordId int                     `description:"审批流id"`
+	ContractCode             string                  `description:"合同编号"`
+	Status                   string                  `description:"审批单状态，枚举值：待审批','已审批','已驳回','已撤回'，默认待审批"`
+	ContractStatus           string                  `json:"-";description:"合同状态，枚举值：待审批','已审批','已驳回','已撤回'，默认待审批"`
+	ApplyContent             string                  `description:"待审内容"`
+	ContractDetail           string                  `json:"-";description:"提交审批时的合同信息；合同快照"`
+	ContractInfo             contract.ContractDetail `json:"-";description:"提交审批时的合同信息；合同快照"`
+	ApproveRemark            string                  `description:"审核备注"`
+	ContractType             string                  `description:"合同类型"`
+	Price                    float64                 `description:"合同金额"`
+	CompanyName              string                  `description:"客户名称"`
+	FileUrl                  string                  `description:"合同下载地址"`
+	SellerId                 int                     `description:"销售id"`
+	ProductId                int                     `description:"产品id，1：ficc；2：权益"`
+	SellerName               string                  `description:"销售名称"`
+	StartDate                time.Time               `description:"合同开始日期"`
+	EndDate                  time.Time               `description:"合同结束日期"`
+	CreateTime               time.Time               `description:"发起审批的时间"`
+	ModifyTime               time.Time               `description:"最后一次修改的时间"`
+	ApproveTime              time.Time               `description:"审批时间"`
+	StartDateStr             string                  `description:"合同开始日期(字符串类型)"`
+	EndDateStr               string                  `description:"合同结束日期(字符串类型)"`
+	CreateTimeStr            string                  `description:"发起审批的时间(字符串类型)"`
+	ModifyTimeStr            string                  `description:"最后一次修改的时间(字符串类型)"`
+	ApproveTimeStr           string                  `description:"审批时间（字符串类型）"`
+}
+
+//获取合同审批列表数据
+func GetSealApprovalList(childCondition, condition string, childPars, pars []interface{}, startSize, pageSize int) (list []*SealApprovalList, err error) {
+	o := orm.NewOrm()
+	sql := `
+SELECT
+a.contract_approval_id,a.contract_id,a.apply_content,a.approve_remark,a.create_time,a.modify_time,a.status,c.status contract_status,c.product_id,
+c.contract_type,c.start_date,c.end_date,c.price,c.company_name,c.seller_id,c.seller_name,c.file_url,c.contract_code from contract_approval a
+	join 
+	( SELECT max( contract_approval_id ) max_id,contract_id FROM contract_approval where 1=1 `
+	sql += childCondition
+	sql += `  GROUP BY contract_id ) b on a.contract_approval_id=b.max_id
+	JOIN seal c ON a.seal_id = c.contract_id 
+	JOIN contract_approval_record d on a.contract_approval_id=d.contract_approval_id
+WHERE c.is_delete = 0 `
+	sql += condition
+	sql += ` group by contract_id order by modify_time desc LIMIT ?,? `
+	_, err = o.Raw(sql, childPars, pars, startSize, pageSize).QueryRows(&list)
+	return
+}

models/tables/seal/seal.go

@@ -0,0 +1,87 @@
+package seal
+
+import (
+	"fmt"
+	"hongze/hongze_mobile_admin/utils"
+	"rdluck_tools/orm"
+	"time"
+)
+
+//用印
+type Seal struct {
+	SealId         int       `orm:"column(seal_id);pk"`
+	Code           string    `description:"用印编号,长度32位"`
+	UserId         int       `description:"申请人id"`
+	UserName       string    `description:"申请人名称"`
+	Use            string    `description:"用印用途，枚举值：'销售合同', '渠道合同', '付款通知函', '招投标', '战略合作协议'；默认：销售合同"`
+	CompanyName    string    `description:"客户名称，甲方名称,长度32位"`
+	CreditCode     string    `description:"社会统一信用代码,长度64位"`
+	ServiceType    string    `description:"业务类型，枚举值：'新增业务', '续约业务', '补充协议'；默认：新增业务"`
+	SealType       string    `description:"加盖印章类型，枚举值：'合同章', '公章', '法人章';默认：合同章"`
+	Status         string    `description:"合同状态，枚举值：'待提交','待审批','已撤回','已审批','已驳回','已作废'"`
+	Remark         string    `description:"补充内容,长度255位"`
+	ApprovalRemark string    `description:"审核备注"`
+	FileUrl        string    `description:"文件附件地址"`
+	IsDelete       int       `description:"是否已经删除，0：未删除，1：已删除",json:"-"`
+	ModifyTime     time.Time `description:"最近一次修改时间"`
+	CreateTime     time.Time `description:"添加时间"`
+}
+
+//根据合同id获取合同信息
+func GetSealInfoById(sealId int) (sealInfo *Seal, err error) {
+	o := orm.NewOrm()
+	sql := `select * from seal where seal_id = ? `
+	err = o.Raw(sql, sealId).QueryRow(&sealInfo)
+	return
+}
+
+//用印添加
+func AddSeal(sealInfo *Seal) (err error) {
+	o := orm.NewOrm()
+	//用印数据入库
+	sealId, err := o.Insert(sealInfo)
+	if err != nil {
+		return
+	}
+	sealInfo.SealId = int(sealId)
+	return
+}
+
+//更新用印信息
+func (seal *Seal) Update(cols []string) (err error) {
+	o := orm.NewOrm()
+	_, err = o.Update(seal, cols...)
+	return
+}
+
+//删除用印
+func DeleteSeal(sealInfo *Seal) (err error) {
+	sealInfo.IsDelete = 1
+	sealInfo.ModifyTime = time.Now()
+	err = sealInfo.Update([]string{"IsDelete", "ModifyTime"})
+	return
+}
+
+//作废用印
+func InvalidSeal(sealInfo *Seal) (err error) {
+	sealInfo.Status = "已作废"
+	sealInfo.ModifyTime = time.Now()
+	//修改用印数据入库
+	err = sealInfo.Update([]string{"IsDelete", "ModifyTime"})
+	return
+}
+
+//生成合同编号
+func GetSealCode() (code string, err error) {
+	var num int
+	o := orm.NewOrm()
+	today := utils.GetToday(utils.FormatDate)
+	sql := `SELECT COUNT(1) AS num FROM seal where create_time>=?`
+	err = o.Raw(sql, today).QueryRow(&num)
+	if err != nil {
+		return
+	}
+
+	code = "HZ" + time.Now().Format("20060102") + fmt.Sprintf("%03d", num)
+	return
+}

services/contract/contract_approval.go

@@ -99,7 +99,7 @@ func Apply(contractId int) (err error) {
 		ModifyTime:     time.Now(),
 		CreateTime:     time.Now(),
 	}
-	has, err := contractApproval.CheckPendingByContractId(contractInfo.ContractId)
+	has, err := contractApproval.CheckPendingByContractId(contractInfo.ContractId, "contract")
 	if err != nil {
 		return
 	}
@@ -135,7 +135,7 @@ func Apply(contractId int) (err error) {
 
 	}
 
-	err = contractApproval.Apply2(contractApproval, contractApprovalRecordList)
+	err = contractApproval.Apply(contractApproval, contractApprovalRecordList)
 	if err != nil {
 		return
 	}
@@ -197,7 +197,7 @@ func CancelApplyByContract(contractInfo *contract.Contract, opUserId int) (err e
 	}
 
 	//撤回审批流
-	err = contractApproval.Cancel2(contractApproval, contractApprovalRecordList)
+	err = contractApproval.Cancel(contractApproval, contractApprovalRecordList)
 	if err != nil {
 		return
 	}
@@ -255,7 +255,12 @@ func CancelApply(contractApprovalRecord *contract_approval_record.ContractApprov
 		err = errors.New("操作人异常，不允许撤回非本人提交的申请：" + contractInfo.Status)
 		return
 	}
-	err = contractApproval.Cancel(contractApproval, contractApprovalRecord)
+	//获取当前审批单中所有待审批的流程流
+	contractApprovalRecordList, err := contract_approval_record.GetPendingContractApprovalRecordListByContractId(contractApproval.ContractApprovalId, contractApprovalRecord.NodeId)
+	if err != nil {
+		return
+	}
+	err = contractApproval.Cancel(contractApproval, contractApprovalRecordList)
 	if err != nil {
 		return
 	}

services/seal/approval.go

@@ -0,0 +1,522 @@
+package seal
+
+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_node"
+	"hongze/hongze_mobile_admin/models/tables/company_approval_message"
+	"hongze/hongze_mobile_admin/models/tables/contract"
+	"hongze/hongze_mobile_admin/models/tables/contract_approval"
+	"hongze/hongze_mobile_admin/models/tables/contract_approval_record"
+	"hongze/hongze_mobile_admin/models/tables/contract_operation_record"
+	"hongze/hongze_mobile_admin/models/tables/seal"
+	"hongze/hongze_mobile_admin/services"
+	"hongze/hongze_mobile_admin/services/flow"
+	"strings"
+	"time"
+)
+
+//提交审批
+func Apply(sealInfo *seal.Seal) (err error) {
+	//合同状态判断
+	ignoreStatus := []string{"待提交", "已撤回", "已驳回"}
+	if !strings.Contains(strings.Join(ignoreStatus, ","), sealInfo.Status) {
+		err = errors.New("用印单状态异常，不允许提交审批，当前用印单状态：" + sealInfo.Status)
+		return
+	}
+
+	contractDetailByte, err := json.Marshal(sealInfo)
+	if err != nil {
+		err = errors.New(fmt.Sprint("用印单异常，当前用印单数据格式化失败：", err))
+		return
+	}
+
+	//获取基础审批流
+
+	flowItemInfo, err := flow.GetApprovalFlow(5)
+	if err != nil {
+		return
+	}
+	fmt.Println(flowItemInfo)
+
+	//校验是否存在待审批的审批单（其实没有多大意义，只是为了 异常数据校验）
+	contractApproval := &contract_approval.ContractApproval{
+		ContractId:     sealInfo.SealId,
+		Status:         "待审批",
+		ApplyContent:   sealInfo.Use,
+		ContractDetail: string(contractDetailByte),
+		ApplyUserId:    sealInfo.UserId,
+		ApplyUserName:  sealInfo.UserName,
+		FlowId:         flowItemInfo.FlowId,
+		FlowVersion:    flowItemInfo.CurrVersion,
+		CurrNodeId:     flowItemInfo.NodeList[0].NodeId,
+		ModifyTime:     time.Now(),
+		CreateTime:     time.Now(),
+	}
+	has, err := contractApproval.CheckPendingByContractId(sealInfo.SealId, "seal")
+	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,
+				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(contractApprovalRecordList[0].NodeId, contractApproval.ApplyUserId, contractApproval.ContractApprovalId, 1, 1, sealInfo.CompanyName, sealInfo.Use)
+
+		//发送消息给所有的抄送人
+		go messageToAllCcUser(contractApproval.ApplyUserId, contractApproval.ContractApprovalId, 1, 1, sealInfo.CompanyName, sealInfo.Use)
+	}
+	return
+}
+
+//撤销合同
+func CancelApplyByContract(contractInfo *contract.Contract, opUserId int) (err error) {
+	if contractInfo == nil {
+		err = errors.New("审批流异常，没有审批流信息")
+		return
+	}
+
+	//合同状态判断
+	if contractInfo.Status != "待审批" {
+		err = errors.New("合同状态异常，不允许撤回申请，当前合同状态：" + contractInfo.Status)
+		return
+	}
+
+	//校验操作人与合同申请人是否同一人
+	if contractInfo.SellerId != opUserId {
+		err = errors.New("操作人异常，不允许撤回非本人提交的申请：" + contractInfo.Status)
+		return
+	}
+
+	//获取最近一次待审批的审批单信息
+	contractApproval, err := contract_approval.GetLastPendingContractApprovalByContractId(contractInfo.ContractId)
+	if err != nil {
+		return
+	}
+	//获取当前待审批的审批流信息
+	contractApprovalRecord, err := contract_approval_record.GetCurrContractApprovalRecordByContractId(contractApproval.ContractApprovalId)
+	if err != nil {
+		return
+	}
+	//判断当前节点是否存在上级节点，如果存在，那么说明
+	if contractApprovalRecord.PrevNodeId > 0 {
+		err = errors.New("合同已存在审批操作，不允许撤回申请")
+		return
+	}
+
+	//获取当前审批单中所有待审批的流程流
+	contractApprovalRecordList, err := contract_approval_record.GetPendingContractApprovalRecordListByContractId(contractApproval.ContractApprovalId, contractApprovalRecord.NodeId)
+	if err != nil {
+		return
+	}
+
+	//撤回审批流
+	err = contractApproval.Cancel(contractApproval, contractApprovalRecordList)
+	if err != nil {
+		return
+	}
+
+	//添加操作日志
+	remark := "撤回申请"
+	_ = contract_operation_record.AddContractOperationRecord(contractInfo.ContractId, contractInfo.SellerId, contractApprovalRecord.ContractApprovalRecordId, "cancel_apply", contractInfo.SellerName, remark)
+
+	//作废原有消息
+	for _, contractApprovalRecord := range contractApprovalRecordList {
+		go company_approval_message.CancelCompanyApprovalMessage(contractApprovalRecord.ContractApprovalRecordId, 2)
+	}
+
+	return
+}
+
+//撤回审批单
+func CancelApply(contractApprovalRecord *contract_approval_record.ContractApprovalRecord, opUserId int) (err error) {
+	if contractApprovalRecord == nil {
+		err = errors.New("审批流异常，没有审批流信息")
+		return
+	}
+
+	//审批流状态判断
+	if contractApprovalRecord.Status != "待审批" {
+		err = errors.New("审批流状态异常，不允许撤回申请，当前审批流状态：" + contractApprovalRecord.Status)
+		return
+	}
+
+	//获取审批单详情
+	contractApproval, err := contract_approval.GetContractApprovalById(contractApprovalRecord.ContractApprovalId)
+	if err != nil {
+		return
+	}
+
+	//审批单状态判断
+	if contractApproval.Status != "待审批" {
+		err = errors.New("审批单状态异常，不允许撤回申请，当前审批单状态：" + contractApproval.Status)
+		return
+	}
+
+	//获取合同信息
+	contractInfo, err := contract.GetContractById(contractApproval.ContractId)
+	if err != nil {
+		return
+	}
+	//合同状态判断
+	if contractInfo.Status != "待审批" {
+		err = errors.New("合同状态异常，不允许撤回申请，当前合同状态：" + contractInfo.Status)
+		return
+	}
+
+	//校验操作人与合同申请人是否同一人
+	if contractInfo.SellerId != opUserId {
+		err = errors.New("操作人异常，不允许撤回非本人提交的申请：" + contractInfo.Status)
+		return
+	}
+	//获取当前审批单中所有待审批的流程流
+	contractApprovalRecordList, err := contract_approval_record.GetPendingContractApprovalRecordListByContractId(contractApproval.ContractApprovalId, contractApprovalRecord.NodeId)
+	if err != nil {
+		return
+	}
+	err = contractApproval.Cancel(contractApproval, contractApprovalRecordList)
+	if err != nil {
+		return
+	}
+
+	//添加操作日志
+	remark := "撤回申请"
+	_ = contract_operation_record.AddContractOperationRecord(contractInfo.ContractId, contractInfo.SellerId, contractApprovalRecord.ContractApprovalRecordId, "cancel_apply", contractInfo.SellerName, remark)
+
+	//作废原有消息
+	go company_approval_message.CancelCompanyApprovalMessage(contractApprovalRecord.ContractApprovalRecordId, 2)
+
+	return
+}
+
+//驳回审批
+func Reject(contractApprovalRecord *contract_approval_record.ContractApprovalRecord, opUser *custom.AdminWx, rejectRemark string) (err error) {
+	if contractApprovalRecord == nil {
+		err = errors.New("审批流异常，没有审批流信息")
+		return
+	}
+
+	//审批流状态判断
+	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 contractApproval.Status != "待审批" {
+		err = errors.New("审批单状态异常，不允许驳回申请，当前审批单状态：" + contractApproval.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)
+	if err != nil {
+		return
+	}
+
+	//添加操作日志
+	remark := "驳回申请"
+	_ = contract_operation_record.AddContractOperationRecord(contractInfo.ContractId, opUserId, contractApprovalRecord.ContractApprovalRecordId, "reject", opUserName, remark)
+
+	//待办通知
+	{
+		content := contractInfo.CompanyName + " 合同模板已驳回"
+		approvalSysUser, _ := admin.GetAdminById(contractInfo.SellerId)
+		go services.AddCompanyApprovalMessage(opUserId, contractInfo.SellerId, 0, contractApprovalRecord.ContractApprovalRecordId, 2, 2, 3, contractInfo.CompanyName, content, content, approvalSysUser.Mobile)
+
+		//发送消息给所有的抄送人
+		go messageToAllCcUser(opUserId, contractApprovalRecord.ContractApprovalId, 2, 3, contractInfo.CompanyName, content)
+	}
+	return
+}
+
+//审批通过
+func Approved(contractApprovalRecord *contract_approval_record.ContractApprovalRecord, opUser *custom.AdminWx, approvedRemark string) (err error) {
+	if contractApprovalRecord == nil {
+		err = errors.New("审批流异常，没有审批流信息")
+		return
+	}
+
+	//审批流状态判断
+	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 contractApproval.Status != "待审批" {
+		err = errors.New("审批单状态异常，不允许审批，当前审批单状态：" + contractApproval.Status)
+		return
+	}
+
+	//获取合同信息
+	contractInfo, err := contract.GetContractById(contractApproval.ContractId)
+	if err != nil {
+		return
+	}
+	//合同状态判断
+	if contractInfo.Status != "待审批" {
+		err = errors.New("合同状态异常，不允许审批，当前合同状态：" + contractInfo.Status)
+		return
+	}
+
+	//if contractApprovalRecord
+	err = contractApproval.Approved(contractApproval, contractApprovalRecord, approvedRemark)
+	if err != nil {
+		return
+	}
+
+	//添加操作日志
+	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)
+		}
+	} 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, contractApproval.ContractApprovalId, 1, 1, contractInfo.CompanyName, content)
+		}
+	}
+
+	return
+}
+
+//审批通过（抄送节点）
+func approvedByCc(approvedRemark string, sourceContractApprovalRecord *contract_approval_record.ContractApprovalRecord) (err error) {
+	//下个流程节点id
+	nextNodeId := 0
+	//获取审批单中抄送节点的所有数据列表
+	contractApprovalRecordList, err := contract_approval_record.GetContractApprovalRecordListByContractIdAndNode(sourceContractApprovalRecord.ContractApprovalId, sourceContractApprovalRecord.NextNodeId)
+	if err != nil {
+		return
+	}
+	//遍历所有的抄送单
+	for _, contractApprovalRecord := range contractApprovalRecordList {
+		nextNodeId = contractApprovalRecord.NextNodeId
+		//审批流状态判断
+		if contractApprovalRecord.Status != "待审批" {
+			err = errors.New("审批流状态异常，不允许审批，当前审批流状态：" + contractApprovalRecord.Status)
+			return
+		}
+		//判断是否审批类型，如果不是审批类型，那么就没有审批权限
+		if contractApprovalRecord.NodeType != "cc" {
+			err = errors.New("当前账号不是抄送权限")
+			return
+		}
+	}
+
+	//获取审批单详情
+	contractApproval, err := contract_approval.GetContractApprovalById(sourceContractApprovalRecord.ContractApprovalId)
+	if err != nil {
+		return
+	}
+
+	//获取合同信息
+	contractInfo, err := contract.GetContractById(contractApproval.ContractId)
+	if err != nil {
+		return
+	}
+
+	//if contractApprovalRecord
+	err = contractApproval.ApprovedByCc(contractApproval, contractApprovalRecordList, approvedRemark, nextNodeId)
+	if err != nil {
+		return
+	}
+
+	//如果下一个节点属于结束节点，那么通知对应的销售，同时，异步生成合同pdf
+	if nextNodeId == 0 {
+		//待办通知
+		{
+			content := contractInfo.CompanyName + " 合同模板已审核"
+			approvalSysUser, _ := admin.GetAdminById(contractInfo.SellerId)
+			go services.AddCompanyApprovalMessage(sourceContractApprovalRecord.ApproveUserId, contractInfo.SellerId, 0, sourceContractApprovalRecord.ContractApprovalRecordId, 2, 2, 2, contractInfo.CompanyName, content, content, approvalSysUser.Mobile)
+		}
+	} else {
+		//获取下级节点信息
+		flowNodeInfo, tmpErr := approval_flow_node.GetByNodeId(nextNodeId)
+		if tmpErr != nil {
+			err = tmpErr
+			return
+		}
+		//如果下级节点是抄送类型，那么还是需要处理抄送节点逻辑
+		if flowNodeInfo.NodeType == "cc" {
+			go approvedByCc(approvedRemark, sourceContractApprovalRecord)
+		} else {
+			//如果下级级节点是审批类型
+			//发送消息下级审批人
+			go messageToNodeUser(nextNodeId, contractInfo.SellerId, contractApproval.ContractApprovalId, 1, 1, contractInfo.CompanyName, contractApproval.ApplyContent)
+		}
+	}
+
+	return
+}
+
+//抄送信息给用户（根据节点来推送）
+func messageToNodeUser(flowNodeId, createUserId, 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, messageType, approvalStatus, companyName, content)
+	return
+}
+
+//发送信息给所有抄送人
+// @param createUserId 消息发起人
+// @param contractApprovalId 审批单id
+// @param messageType 消息类型：1:申请消息，2:审批结果
+// @param approvalStatus 审批状态：1:待审批，2:已审批，3:已驳回"
+// @param companyName 企业客户名称
+// @param content 消息内容
+func messageToAllCcUser(createUserId, contractApprovalId, messageType, approvalStatus int, companyName, content string) (err error) {
+	//获取审批单中抄送节点的所有数据列表
+	contractApprovalRecordList, err := contract_approval_record.GetContractApprovalRecordListByContractApprovalId(contractApprovalId)
+
+	if err != nil {
+		return
+	}
+	err = messageToUser(contractApprovalRecordList, createUserId, messageType, approvalStatus, companyName, content)
+	return
+}
+
+//抄送信息给用户（发送给所有抄送人）
+// @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, 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, 0, contractApprovalRecord.ContractApprovalRecordId, messageType, 2, approvalStatus, companyName, content, content, sysUserMobile)
+	}
+	return
+}

services/seal/seal.go

@@ -0,0 +1,102 @@
+package seal
+
+import (
+	"errors"
+	"fmt"
+	"hongze/hongze_mobile_admin/models/tables/seal"
+	"hongze/hongze_mobile_admin/utils"
+	"strings"
+	"time"
+)
+
+//添加用印
+func AddSeal(userId int, userName, use, 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,
+		CreditCode:  creditCode,
+		ServiceType: serviceType,
+		SealType:    sealType,
+		Status:      "待提交",
+		Remark:      remark,
+		FileUrl:     fileUrl,
+		ModifyTime:  time.Now(),
+		CreateTime:  time.Now(),
+	}
+	err = seal.AddSeal(sealInfo)
+	return
+}
+
+//修改用印
+func Edit(sealId, userId int, userName, use, 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
+	}
+
+	//查询当前合同信息
+	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.CreditCode = creditCode
+	sealInfo.ServiceType = serviceType
+	sealInfo.SealType = sealType
+	sealInfo.Remark = remark
+	sealInfo.FileUrl = fileUrl
+	sealInfo.ModifyTime = time.Now()
+	sealInfo.Status = "待提交" //用印状态
+
+	err = sealInfo.Update([]string{"Use", "CompanyName", "CreditCode", "ServiceType", "SealType", "Remark", "FileUrl", "ModifyTime", "Status"})
+
+	return
+}

utils/email.go

@@ -30,4 +30,4 @@ func SendEmail(title, content string, touser string)bool {
 		return false
 	}
 	return true
-}
+}

utils/validator.go

@@ -241,4 +241,4 @@ func getVerifyErrInfo(errType string,lang string) (errInfo string) {
 		}
 	}
 	return
-}
+}