hongze_mobile_admin/models/tables/contract_approval/contract_approval.go

package contract_approval

import (
	"hongze/hongze_mobile_admin/models/tables/contract"
	"hongze/hongze_mobile_admin/models/tables/contract_approval_record"
	"hongze/hongze_mobile_admin/utils"
	"rdluck_tools/orm"
	"time"
)

//合同审批单
type ContractApproval struct {
	ContractApprovalId int       `orm:"column(contract_approval_id);pk"`
	ContractId         int       `orm:"column(contract_id)";description:"合同id"`
	Status             string    `description:"审批单状态，枚举值：待审批','已审批','已驳回','已撤回'，默认待审批"`
	ApplyContent       string    `description:"待审内容，长度255位"`
	ContractDetail     string    `description:"审批单详情，完整的合同json数据"`
	ApplyUserId        int       `description:"申请人id"`
	ApplyUserName      string    `description:"申请人名称"`
	ApproveRemark      string    `description:"审批人备注，可以是驳回理由，长度128位"`
	FlowId             int       `description:"审批流程id"`
	FlowVersion        int       `description:"审批流程版本"`
	CurrNodeId         int       `description:"当前审批节点id"`
	ModifyTime         time.Time `description:"发起申请时间"`
	CreateTime         time.Time `description:"最近一次审批单修改时间"`
}

//根据合同审批单id获取合同审批单信息
func GetContractApprovalById(contractApprovalId int) (contractApprovalInfo *ContractApproval, err error) {
	o := orm.NewOrm()
	sql := `select * from contract_approval where contract_approval_id = ? `
	err = o.Raw(sql, contractApprovalId).QueryRow(&contractApprovalInfo)
	return
}

//根据合同id获取最近一次待审批的合同审批单信息
func GetLastPendingContractApprovalByContractId(contractId int) (contractApprovalInfo *ContractApproval, err error) {
	o := orm.NewOrm()
	sql := `select * from contract_approval where status = "待审批" AND contract_id=? `
	err = o.Raw(sql, contractId).QueryRow(&contractApprovalInfo)
	return
}

//根据合同id获取总共被驳回的次数
func GetRejectContractCountByContractId(contractId int) (total int64, err error) {
	o := orm.NewOrm()
	sql := `select count(1) total from contract_approval where status = "已驳回" AND contract_id=? `
	err = o.Raw(sql, contractId).QueryRow(&total)
	return
}

//获取审批列表数据数量
func GetContractApprovalListCount(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
}

//审批列表
type ContractApprovalList 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 `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:"审批时间"`
	CanApprovalButton        bool                    `description:"是否具有审核操作权限，true才允许审核操作"`
	StartDateStr             string                  `description:"合同开始日期(字符串类型)"`
	EndDateStr               string                  `description:"合同结束日期(字符串类型)"`
	CreateTimeStr            string                  `description:"发起审批的时间(字符串类型)"`
	ModifyTimeStr            string                  `description:"最后一次修改的时间(字符串类型)"`
	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.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 contract c ON a.contract_id = c.contract_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
}

//根据合同id获取合同审批单信息
func (ContractApproval) CheckPendingByContractId(contractId int) (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)
	if err != nil {
		if err.Error() == utils.ErrNoRow() {
			//如果不存在待审批记录，那么报错信息置空，存在与否直接返回false
			err = nil
			return
		}
		//系统异常，返回错误信息
		return
	}
	//存在待审批的审批单
	has = true
	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) {
	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)

	for _, contractApprovalRecord := range contractApprovalRecordList {
		//审批流记录
		contractApprovalRecord.ContractApprovalId = contractApprovalInfo.ContractApprovalId
		contractApprovalRecordId, tmpErr := o.Insert(contractApprovalRecord)
		if tmpErr != nil {
			err = tmpErr
			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) 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
	}

	//修改合同状态为已撤回
	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) {
	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
	}

	//变更所有审批流记录
	for _, contractApprovalRecord := range contractApprovalRecordList {
		contractApprovalRecord.Status = "已撤回"
		contractApprovalRecord.ModifyTime = time.Now()
		_, tmpErr := o.Update(contractApprovalRecord)
		if tmpErr != nil {
			err = tmpErr
			return
		}
	}

	//修改合同状态为已撤回
	sql := `UPDATE contract SET status="已撤回",modify_time=NOW() WHERE contract_id = ?`
	_, err = o.Raw(sql, contractApprovalInfo.ContractId).Exec()
	return
}

//审核驳回
func (ContractApproval) Reject(contractApprovalInfo *ContractApproval, contractApprovalRecord *contract_approval_record.ContractApprovalRecord, approveUserId int, approveUserName, remark string) (err error) {
	o := orm.NewOrm()
	o.Begin()
	defer func() {
		if err != nil {
			o.Rollback()
		} else {
			o.Commit()
		}
	}()
	//变更审批单记录
	contractApprovalInfo.Status = "已驳回"
	contractApprovalInfo.ApproveRemark = remark //审核失败理由
	contractApprovalInfo.ModifyTime = time.Now()
	contractApprovalInfo.CurrNodeId = 0 //当前节点变更为0，代表当前审批流程已经结束了
	_, err = o.Update(contractApprovalInfo)
	if err != nil {
		return
	}

	//变更审批流记录
	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
	}

	//修改合同状态为已驳回
	sql := `UPDATE contract SET status="已驳回",modify_content="",approval_remark=?,modify_time=NOW() WHERE contract_id = ?`
	_, err = o.Raw(sql, remark, contractApprovalInfo.ContractId).Exec()
	return
}

//下级审批人信息
type NextApproval struct {
	ApproveRoleTypeCode string
	ApproveUserId       int
	ApproveUserName     string
}

//审核通过
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()
	defer func() {
		if err != nil {
			o.Rollback()
		} else {
			o.Commit()
		}
	}()

	//变更审批流记录
	contractApprovalRecord.Status = "已审批"
	contractApprovalRecord.ApproveRemark = remark   //审核失败理由
	contractApprovalRecord.ApproveTime = time.Now() //审批时间
	contractApprovalRecord.ModifyTime = time.Now()
	_, err = o.Update(contractApprovalRecord, "Status", "ApproveRemark", "ApproveTime", "ModifyTime")
	if err != nil {
		return
	}

	//如果没有下级节点了，那么完成该审批单
	if contractApprovalRecord.NextNodeId <= 0 {
		//变更审批单记录
		contractApprovalInfo.Status = "已审批"
		contractApprovalInfo.ApproveRemark = remark                         //审核理由
		contractApprovalInfo.CurrNodeId = contractApprovalRecord.NextNodeId //下级审批节点id
		contractApprovalInfo.ModifyTime = time.Now()
		_, tmpErr := o.Update(contractApprovalInfo, "Status", "ApproveRemark", "CurrNodeId", "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
		}
	} else {
		//变更审批单记录
		contractApprovalInfo.ApproveRemark = remark                         //审核理由
		contractApprovalInfo.CurrNodeId = contractApprovalRecord.NextNodeId //下级审批节点id
		contractApprovalInfo.ModifyTime = time.Now()
		_, tmpErr := o.Update(contractApprovalInfo, "ApproveRemark", "CurrNodeId", "ModifyTime")
		if tmpErr != nil {
			err = tmpErr
			return
		}
	}

	return
}

//抄送
func (ContractApproval) ApprovedByCc(contractApprovalInfo *ContractApproval, contractApprovalRecordList []*contract_approval_record.ContractApprovalRecord, remark string, nextNodeId int) (err error) {
	o := orm.NewOrm()
	o.Begin()
	defer func() {
		if err != nil {
			o.Rollback()
		} else {
			o.Commit()
		}
	}()

	for _, contractApprovalRecord := range contractApprovalRecordList {
		//变更审批流记录
		contractApprovalRecord.Status = "已审批"
		contractApprovalRecord.ApproveTime = time.Now() //审批时间
		contractApprovalRecord.ModifyTime = time.Now()
		_, err = o.Update(contractApprovalRecord, "Status", "ApproveTime", "ModifyTime")
		if err != nil {
			return
		}

	}
	if err != nil {
		return
	}

	//如果没有下级节点了，那么完成该审批单
	if nextNodeId <= 0 {
		//变更审批单记录
		contractApprovalInfo.Status = "已审批"
		contractApprovalInfo.CurrNodeId = nextNodeId //下级审批节点id
		contractApprovalInfo.ModifyTime = time.Now()
		_, tmpErr := o.Update(contractApprovalInfo, "Status", "CurrNodeId", "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
		}
	} else {
		//变更审批单记录
		contractApprovalInfo.CurrNodeId = nextNodeId //下级审批节点id
		contractApprovalInfo.ModifyTime = time.Now()
		_, tmpErr := o.Update(contractApprovalInfo, "CurrNodeId", "ModifyTime")
		if tmpErr != nil {
			err = tmpErr
			return
		}
	}

	return
}