lc_finance/server/dao/process.go

package dao

import (
	"gorm.io/gorm"
	"server/global"
)

type Process struct {
	global.GVA_MODEL
	ProcessName    string `json:"processName" form:"processName" gorm:"comment:审批流程名称"`
	ProcessContent string `json:"processContent" form:"processContent" gorm:"审批流程内容"`
	ProcessType    string `json:"processType" form:"processType" gorm:"审批流程类型"`
	IsUse          bool   `json:"isUse" form:"isUse" gorm:"comment:是否使用"`
	Nodes          []Node `json:"nodes" form:"nodes" gorm:"many2many:process_nodes;"`
}

func (Process) TableName() string {
	return "process"
}

func QueryAllProcess() (processes []Process, err error) {
	err = global.GVA_DB.Model(&Process{}).Find(&processes).Error
	return processes, err
}

func QueryProcessList(limit, offset int) (processes []Process, total int64, err error) {
	// 创建db
	db := global.GVA_DB.Model(&Process{})
	// 如果有条件搜索 下方会自动创建搜索语句
	err = db.Count(&total).Error
	if err != nil {
		return
	}
	err = db.Order("id desc").Limit(limit).Offset(offset).Find(&processes).Error

	for i, process := range processes {
		var processNodes []ProcessNodes
		err := global.GVA_DB.Model(&ProcessNodes{}).Where("process_id = ?", process.ID).Find(&processNodes).Error
		if err != nil {
			return nil, 0, err
		}
		var nodes []Node
		for _, node := range processNodes {
			var node1 Node
			err := global.GVA_DB.Model(&Node{}).Where("id = ?", node.NodeId).Preload("Approver").Find(&node1).Error
			if err != nil {
				return nil, 0, err
			}
			node1.Order = node.NodeOrder
			nodes = append(nodes, node1)
		}
		processes[i].Nodes = nodes
	}

	return processes, total, err
}

// QueryProcessByType 按类型查询 已使用的流程
func QueryProcessByType(genre string) (process Process, err error) {
	err = global.GVA_DB.Model(&Process{}).Where("process_type = ? AND is_use = 1", genre).First(&process).Error
	return process, err
}

func QueryProcessById(id int) (process Process, err error) {
	err = global.GVA_DB.Model(&Process{}).Where("id = ?", id).Find(&process).Error
	return process, err
}

func CreateProcess(process Process, nodes []ProcessNodes) error {
	return global.GVA_DB.Transaction(func(tx *gorm.DB) error {
		txErr := tx.Model(&Process{}).Create(&process).Error
		if txErr != nil {
			return txErr
		}
		for i, _ := range nodes {
			nodes[i].ProcessId = int(process.ID)
		}
		txErr = tx.Model(&ProcessNodes{}).Create(&nodes).Error
		if txErr != nil {
			return txErr
		}
		return nil
	})
}

func UpdateProcess(process Process, nodes []ProcessNodes) error {
	return global.GVA_DB.Transaction(func(tx *gorm.DB) error {
		txErr := tx.Model(&Process{}).Select("*").Omit("created_at").Where("id = ?", process.ID).Updates(&process).Error
		if txErr != nil {
			return txErr
		}
		txErr = tx.Model(&ProcessNodes{}).Unscoped().Where("process_id = ?", process.ID).Delete(&ProcessNodes{}).Error
		if txErr != nil {
			return txErr
		}
		for i, _ := range nodes {
			nodes[i].ProcessId = int(process.ID)
		}
		txErr = tx.Model(&ProcessNodes{}).Create(&nodes).Error
		if txErr != nil {
			return txErr
		}
		return nil
	})
}

func SwitchProcess(process Process) error {
	return global.GVA_DB.Transaction(func(tx *gorm.DB) error {
		txErr := tx.Model(&Process{}).Where("process_type = ?", process.ProcessType).Update("is_use", false).Error
		if txErr != nil {
			return txErr
		}
		txErr = tx.Model(&process).Update("is_use", process.IsUse).Error
		if txErr != nil {
			return txErr
		}
		return nil
	})
}

func (p Process) DeleteProcess() error {
	return global.GVA_DB.Transaction(func(tx *gorm.DB) error {
		txErr := tx.Unscoped().Delete(&p).Error
		if txErr != nil {
			return txErr
		}
		txErr = tx.Unscoped().Model(&ProcessNodes{}).Where("process_id = ?", p.ID).Delete(&ProcessNodes{}).Error
		if txErr != nil {
			return txErr
		}
		return nil
	})
}