eta_api/models/knowledge_approve/knowledge_approve.go

package knowledge_approve

import (
	"eta_gn/eta_api/global"
	"fmt"
	"time"
)

type KnowledgeApprove struct {
	KnowledgeApproveId int       `gorm:"column:knowledge_approve_id;primary_key"`
	KnowledgeId        int       `gorm:"column:knowledge_id"`
	KnowledgeTitle     string    `gorm:"column:knowledge_title"`
	ClassifyId         int       `gorm:"column:classify_id"`
	State              int       `gorm:"column:state"` //  '审批状态：1-待审批；2-已审批；3-已驳回；4-已撤回'
	FlowId             int       `gorm:"column:flow_id"`
	FlowVersion        int       `gorm:"column:flow_version"`
	StartNodeId        int       `gorm:"column:start_node_id"`
	CurrNodeId         int       `gorm:"column:curr_node_id"`
	ApplyUserId        int       `gorm:"column:apply_user_id"`
	ApplyUserName      string    `gorm:"column:apply_user_name"`
	ApproveRemark      string    `gorm:"column:approve_remark"`
	ApproveTime        time.Time `gorm:"column:approve_time"`
	CreateTime         time.Time `gorm:"column:create_time"`
	ModifyTime         time.Time `gorm:"column:update_time"`
}

var KnowledgeApproveCols = struct {
	KnowledgeApproveId string
	KnowledgeId        string
	KnowledgeTitle     string
	ClassifyId         string
	State              string //  '审批状态：1-待审批；2-已审批；3-已驳回；4-已撤回'
	FlowId             string
	FlowVersion        string
	StartNodeId        string
	CurrNodeId         string
	ApplyUserId        string
	ApplyUserName      string
	ApproveRemark      string
	ApproveTime        string
	CreateTime         string
	ModifyTime         string
}{
	KnowledgeApproveId: "knowledge_approve_id",
	KnowledgeId:        "knowledge_id",
	KnowledgeTitle:     "knowledge_title",
	ClassifyId:         "classify_id",
	State:              "state",
	FlowId:             "flow_id",
	FlowVersion:        "flow_version",
	StartNodeId:        "start_node_id",
	CurrNodeId:         "curr_node_id",
	ApplyUserId:        "apply_user_id",
	ApplyUserName:      "apply_user_name",
	ApproveRemark:      "approve_remark",
	ApproveTime:        "approve_time",
	CreateTime:         "create_time",
	ModifyTime:         "modify_time",
}

type KnowledgeApproveItemOrm struct {
	KnowledgeApproveId       int       `description:"审批ID"`
	KnowledgeApproveRecordId int       `description:"审批记录ID"`
	KnowledgeId              int       `description:"报告ID"`
	KnowledgeTitle           string    `description:"报告标题"`
	ClassifyId               int       `description:"分类ID"`
	State                    int       `description:"审批状态：1-待审批；2-已审批；3-已驳回；4-已撤回"`
	RecordState              int       `description:"审批记录状态：1-待审批；2-已通过；3-已驳回"`
	FlowId                   int       `description:"审批流ID"`
	FlowVersion              int       `description:"审批流版本"`
	StartNodeId              int       `description:"开始节点ID"`
	CurrNodeId               int       `description:"当前节点ID"`
	ApplyUserId              int       `description:"申请人ID"`
	ApplyUserName            string    `description:"申请人姓名"`
	ApproveRemark            string    `description:"审批备注"`
	ApproveTime              time.Time `description:"审批时间"`
	HandleTime               time.Time `description:"处理时间"`
	CreateTime               time.Time `description:"创建时间"`
	ModifyTime               time.Time `description:"修改时间"`
	NodeState                int       `description:"当前节点审批状态：1-待审批；2-已审批；3-已驳回；4-已撤回" json:"-"`
	NodeApproveTime          time.Time `description:"当前节点审批时间" json:"-"`
}

func (b *KnowledgeApprove) TableName() string {
	return "knowledge_approve"
}

func (b *KnowledgeApprove) Update(cols []string) (err error) {
	db := global.DmSQL["rddp"]
	err = db.Model(b).Select(cols).Updates(b).Error
	return
}

func (b *KnowledgeApprove) Create() (err error) {
	db := global.DmSQL["rddp"]
	err = db.Create(b).Error
	return
}

func GetKnowledgeApproveByFlowIdAndVersionId(knowledgeFlowId int, flowVersion int) (item []*KnowledgeApprove, err error) {
	db := global.DmSQL["rddp"]
	err = db.Where("flow_id = ? AND flow_version = ?", knowledgeFlowId, flowVersion).Find(&item).Error
	return
}

func GetKnowledgeApproveById(knowledgeApproveId int) (item *KnowledgeApprove, err error) {
	db := global.DmSQL["rddp"]
	err = db.Where("knowledge_approve_id = ?", knowledgeApproveId).First(&item).Error
	return
}

// GetApprovingKnowledgeApproveCount 获取待处理的审批分页列表总数
func GetApprovingKnowledgeApproveCount(cond string, pars []interface{}) (count int, err error) {
	base := fmt.Sprintf(`SELECT a.knowledge_approve_record_id
		FROM knowledge_approve_record AS a
		JOIN knowledge_approve AS b ON a.knowledge_approve_id = b.knowledge_approve_id AND a.node_id = b.curr_node_id
		WHERE 1 = 1 %s`, cond)
	sql := fmt.Sprintf(`SELECT COUNT(1) FROM (%s) t`, base)
	err = global.DmSQL["rddp"].Raw(sql, pars...).Scan(&count).Error
	return
}

// GetApprovingKnowledgeApprovePageList 获取待处理的审批列表-分页
func GetApprovingKnowledgeApprovePageList(cond string, pars []interface{}, orderRule string, startSize, pageSize int) (items []*KnowledgeApproveItemOrm, err error) {
	order := `ORDER BY a.create_time DESC`
	if orderRule != "" {
		order = ` ORDER BY ` + orderRule
	}
	sql := fmt.Sprintf(`SELECT a.knowledge_approve_record_id, a.state AS record_state, b.*
		FROM knowledge_approve_record AS a
		JOIN knowledge_approve AS b ON a.knowledge_approve_id = b.knowledge_approve_id AND a.node_id = b.curr_node_id
		WHERE 1 = 1 %s %s
		LIMIT ?,?`, cond, order)
	pars = append(pars, startSize, pageSize)
	err = global.DmSQL["rddp"].Raw(sql, pars...).Find(&items).Error
	return
}

// GetApprovedKnowledgeApproveCount 获取已处理的审批分页列表总数
func GetApprovedKnowledgeApproveCount(cond string, pars []interface{}) (count int, err error) {
	base := fmt.Sprintf(`SELECT a.knowledge_approve_record_id
		FROM knowledge_approve_record AS a
		JOIN knowledge_approve AS b ON a.knowledge_approve_id = b.knowledge_approve_id
		WHERE 1 = 1 %s`, cond)
	sql := fmt.Sprintf(`SELECT COUNT(1) FROM (%s) t`, base)
	err = global.DmSQL["rddp"].Raw(sql, pars...).Scan(&count).Error
	return
}

// GetApprovedKnowledgeApprovePageList 获取已处理的审批列表-分页
func GetApprovedKnowledgeApprovePageList(cond string, pars []interface{}, orderRule string, startSize, pageSize int) (items []*KnowledgeApproveItemOrm, err error) {
	order := `ORDER BY a.create_time DESC`
	if orderRule != "" {
		order = ` ORDER BY ` + orderRule
	}
	sql := fmt.Sprintf(`SELECT a.knowledge_approve_record_id, a.node_state AS record_state,a.node_state,a.node_approve_time, a.node_approve_time AS handle_time, b.*
		FROM knowledge_approve_record AS a
		JOIN knowledge_approve AS b ON a.knowledge_approve_id = b.knowledge_approve_id
		WHERE 1 = 1 %s %s
		LIMIT ?,?`, cond, order)
	pars = append(pars, startSize, pageSize)
	err = global.DmSQL["rddp"].Raw(sql, pars...).Find(&items).Error
	return
}

// GetApplyKnowledgeApproveCount 获取我发起的审批分页列表总数
func GetApplyKnowledgeApproveCount(cond string, pars []interface{}) (count int, err error) {
	base := fmt.Sprintf(`SELECT a.* FROM knowledge_approve AS a WHERE 1 = 1 %s`, cond)
	sql := fmt.Sprintf(`SELECT COUNT(1) FROM (%s) t`, base)
	err = global.DmSQL["rddp"].Raw(sql, pars...).Scan(&count).Error
	return
}

// GetApplyKnowledgeApprovePageList 获取我发起的审批列表-分页
func GetApplyKnowledgeApprovePageList(cond string, pars []interface{}, orderRule string, startSize, pageSize int) (items []*KnowledgeApproveItemOrm, err error) {
	order := `ORDER BY a.create_time DESC`
	if orderRule != "" {
		order = ` ORDER BY ` + orderRule
	}
	sql := fmt.Sprintf(`SELECT a.* FROM knowledge_approve AS a WHERE 1 = 1 %s %s LIMIT ?,?`, cond, order)
	pars = append(pars, startSize, pageSize)
	err = global.DmSQL["rddp"].Raw(sql, pars...).Find(&items).Error
	return
}

func GetKnowledgeApproveByBoardId(knowledgeApproveId int) (item *KnowledgeApprove, err error) {
	db := global.DmSQL["rddp"]
	err = db.Where("knowledge_id = ?", knowledgeApproveId).Order("create_time DESC").First(&item).Error
	return
}

func GetKnowledgeApproveCountByState(state int) (count int, err error) {
	db := global.DmSQL["rddp"]
	sql := `SELECT COUNT(*) FROM knowledge_approve WHERE state = ?`
	err = db.Raw(sql, state).Scan(&count).Error
	return
}