eta_api/controllers/report_approve/report_approve.go

package report_approve

import (
	"encoding/json"
	"eta/eta_api/controllers"
	"eta/eta_api/models"
	"eta/eta_api/models/report_approve"
	"eta/eta_api/models/smart_report"
	"eta/eta_api/utils"
	"fmt"
	"github.com/rdlucklib/rdluck_tools/paging"
	"html"
	"strings"
	"time"
)

// ReportApproveController 报告审批
type ReportApproveController struct {
	controllers.BaseAuthController
}

// List
// @Title 审批列表
// @Description 审批列表
// @Param   PageSize			query	int		true	"每页数据条数"
// @Param   CurrentIndex		query	int		true	"当前页页码"
// @Param   ListType			query   int     true	"列表类型：1-待处理；2-已处理；3-我发起的"
// @Param   ReportType			query   int     false	"报告类型：1-中文研报；2-英文研报；3-智能研报"
// @Param   ClassifyIdFirst		query	int		false	"一级分类ID"
// @Param   ClassifyIdSecond	query	int		false	"二级分类ID"
// @Param   Keyword				query	string	false	"搜索关键词"
// @Param   ApproveState		query	int		false	"审批状态：1-待审批；2-已审批；3-已驳回；4-已撤回"
// @Param   TimeType			query	int		false	"时间类型：1-提交时间；2-处理时间；3-审批时间"
// @Param   StartTime			query	string	false	"开始时间"
// @Param   EndTime				query	string	false	"结束时间"
// @Param   SortField			query	int		false	"排序字段：1-提交时间；2-处理时间；3-审批时间"
// @Param   SortRule			query	int		false	"排序方式: 1-正序; 2-倒序(默认)"
// @Success 200 {object} report_approve.ReportApproveListResp
// @router /list [get]
func (this *ReportApproveController) List() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	params := new(report_approve.ReportApproveListReq)
	if e := this.ParseForm(params); e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "入参解析失败, Err: " + e.Error()
		return
	}
	if params.ListType != 1 && params.ListType != 2 && params.ListType != 3 {
		br.Msg = "列表类型有误"
		return
	}

	// 报告分类
	cnClassifyIdName, enClassifyIdName := make(map[int]string), make(map[int]string)
	cnClassify, e := models.GetAllClassify()
	if e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取中文分类失败, Err: " + e.Error()
		return
	}
	for _, v := range cnClassify {
		cnClassifyIdName[v.Id] = v.ClassifyName
	}
	enClassify, e := models.GetAllEnglishClassify()
	if e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取英文分类失败, Err: " + e.Error()
		return
	}
	enRootIdMap := make(map[int]int) // 英文分类的一级分类ID
	for _, v := range enClassify {
		enClassifyIdName[v.Id] = v.ClassifyName
		enRootIdMap[v.Id] = v.RootId
	}

	// 分页
	var startSize int
	if params.PageSize <= 0 {
		params.PageSize = utils.PageSize20
	}
	if params.CurrentIndex <= 0 {
		params.CurrentIndex = 1
	}
	startSize = utils.StartIndex(params.CurrentIndex, params.PageSize)

	resp := new(report_approve.ReportApproveListResp)
	respTotal := 0
	respList := make([]*report_approve.ReportApproveItem, 0)
	timeField := map[int]string{1: fmt.Sprintf("a.%s", report_approve.ReportApproveCols.CreateTime), 2: fmt.Sprintf("b.%s", report_approve.ReportApproveRecordCols.ApproveTime), 3: fmt.Sprintf("b.%s", report_approve.ReportApproveCols.ApproveTime)}
	orderRules := map[int]string{1: "ASC", 2: "DESC"}
	ormList := make([]*report_approve.ReportApproveItemOrm, 0)

	// 待处理
	if params.ListType == 1 {
		cond := fmt.Sprintf(` AND a.%s = ? AND b.%s = ? AND b.%s = ?`, report_approve.ReportApproveCols.State, report_approve.ReportApproveRecordCols.ApproveUserId, report_approve.ReportApproveRecordCols.State)
		pars := make([]interface{}, 0)
		pars = append(pars, report_approve.ReportApproveStateApproving, sysUser.AdminId, report_approve.ReportApproveStateApproving)
		order := ""

		// 筛选条件
		if params.ReportType > 0 && params.ClassifySecondId > 0 {
			cond += fmt.Sprintf(` AND a.%s = ? AND a.%s = ?`, report_approve.ReportApproveCols.ReportType, report_approve.ReportApproveCols.ClassifySecondId)
			pars = append(pars, params.ReportType, params.ClassifySecondId)
		}
		if params.TimeType <= 0 {
			params.TimeType = 1
		}
		if params.TimeType == 1 && params.StartTime != "" && params.EndTime != "" {
			_, e := time.Parse(utils.FormatDate, params.StartTime)
			if e != nil {
				br.Msg = "开始时间格式有误"
				return
			}
			_, e = time.Parse(utils.FormatDate, params.EndTime)
			if e != nil {
				br.Msg = "结束时间格式有误"
				return
			}
			st := fmt.Sprintf("%s %s", params.StartTime, "00:00:00")
			ed := fmt.Sprintf("%s %s", params.EndTime, "23:59:59")
			cond += fmt.Sprintf(` AND (a.%s BETWEEN ? AND ?)`, report_approve.ReportApproveCols.CreateTime)
			pars = append(pars, st, ed)
		}
		params.Keyword = strings.TrimSpace(params.Keyword)
		if params.Keyword != "" {
			kw := fmt.Sprint("%", params.Keyword, "%")
			cond += fmt.Sprintf(` AND a.%s LIKE ?`, report_approve.ReportApproveCols.ReportTitle)
			pars = append(pars, kw)
		}
		if params.SortField > 0 && params.SortRule > 0 {
			orderField := timeField[params.SortField]
			if orderField == "" {
				br.Msg = "时间排序字段有误"
				return
			}
			orderRule := orderRules[params.SortRule]
			if orderRule == "" {
				br.Msg = "时间排序方式有误"
				return
			}
			order = fmt.Sprintf("%s %s", orderField, orderRule)
		}
		total, e := report_approve.GetApprovingReportApproveCount(cond, pars)
		if e != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "GetApprovingReportApproveCount err: " + e.Error()
			return
		}
		respTotal = total
		list, e := report_approve.GetApprovingReportApprovePageList(cond, pars, order, startSize, params.PageSize)
		if e != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "GetApprovingReportApprovePageList err: " + e.Error()
			return
		}
		ormList = list
	}

	// 已处理
	if params.ListType == 2 {
		cond := fmt.Sprintf(` AND b.%s = ? AND b.%s IN (%s)`, report_approve.ReportApproveRecordCols.ApproveUserId, report_approve.ReportApproveRecordCols.State, utils.GetOrmInReplace(2))
		pars := make([]interface{}, 0)
		pars = append(pars, sysUser.AdminId, []int{report_approve.ReportApproveStatePass, report_approve.ReportApproveStateRefuse})
		order := ""

		// 筛选条件
		if params.ReportType > 0 && params.ClassifySecondId > 0 {
			cond += fmt.Sprintf(` AND a.%s = ? AND a.%s = ?`, report_approve.ReportApproveCols.ReportType, report_approve.ReportApproveCols.ClassifySecondId)
			pars = append(pars, params.ReportType, params.ClassifySecondId)
		}
		if params.TimeType > 0 && params.StartTime != "" && params.EndTime != "" {
			_, e := time.Parse(utils.FormatDate, params.StartTime)
			if e != nil {
				br.Msg = "开始时间格式有误"
				return
			}
			_, e = time.Parse(utils.FormatDate, params.EndTime)
			if e != nil {
				br.Msg = "结束时间格式有误"
				return
			}
			st := fmt.Sprintf("%s %s", params.StartTime, "00:00:00")
			ed := fmt.Sprintf("%s %s", params.EndTime, "23:59:59")
			cond += fmt.Sprintf(` AND (a.%s BETWEEN ? AND ?)`, timeField[params.TimeType])
			pars = append(pars, st, ed)
		}
		params.Keyword = strings.TrimSpace(params.Keyword)
		if params.Keyword != "" {
			kw := fmt.Sprint("%", params.Keyword, "%")
			cond += fmt.Sprintf(` AND a.%s LIKE ?`, report_approve.ReportApproveCols.ReportTitle)
			pars = append(pars, kw)
		}
		if params.SortField > 0 && params.SortRule > 0 {
			orderField := timeField[params.SortField]
			if orderField == "" {
				br.Msg = "时间排序字段有误"
				return
			}
			orderRule := orderRules[params.SortRule]
			if orderRule == "" {
				br.Msg = "时间排序方式有误"
				return
			}
			order = fmt.Sprintf("%s %s", orderField, orderRule)
		}
		if params.ApproveState > 0 {
			cond += fmt.Sprintf(` AND b.%s = ?`, report_approve.ReportApproveRecordCols.State)
			pars = append(pars, params.ApproveState)
		}
		total, e := report_approve.GetApprovedReportApproveCount(cond, pars)
		if e != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "GetApprovedReportApproveCount err: " + e.Error()
			return
		}
		respTotal = total
		list, e := report_approve.GetApprovedReportApprovePageList(cond, pars, order, startSize, params.PageSize)
		if e != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "GetApprovedReportApprovePageList err: " + e.Error()
			return
		}
		ormList = list
	}

	// 我发起的
	if params.ListType == 3 {
		cond := fmt.Sprintf(` AND a.%s = ?`, report_approve.ReportApproveCols.ApplyUserId)
		pars := make([]interface{}, 0)
		pars = append(pars, sysUser.AdminId)
		order := ""

		// 筛选条件
		if params.ReportType > 0 && params.ClassifySecondId > 0 {
			cond += fmt.Sprintf(` AND a.%s = ? AND a.%s = ?`, report_approve.ReportApproveCols.ReportType, report_approve.ReportApproveCols.ClassifySecondId)
			pars = append(pars, params.ReportType, params.ClassifySecondId)
		}
		if params.TimeType > 0 && params.StartTime != "" && params.EndTime != "" {
			_, e := time.Parse(utils.FormatDate, params.StartTime)
			if e != nil {
				br.Msg = "开始时间格式有误"
				return
			}
			_, e = time.Parse(utils.FormatDate, params.EndTime)
			if e != nil {
				br.Msg = "结束时间格式有误"
				return
			}
			st := fmt.Sprintf("%s %s", params.StartTime, "00:00:00")
			ed := fmt.Sprintf("%s %s", params.EndTime, "23:59:59")
			cond += fmt.Sprintf(` AND (a.%s BETWEEN ? AND ?)`, timeField[params.TimeType])
			pars = append(pars, st, ed)
		}
		params.Keyword = strings.TrimSpace(params.Keyword)
		if params.Keyword != "" {
			kw := fmt.Sprint("%", params.Keyword, "%")
			cond += fmt.Sprintf(` AND a.%s LIKE ?`, report_approve.ReportApproveCols.ReportTitle)
			pars = append(pars, kw)
		}
		if params.SortField > 0 && params.SortRule > 0 {
			orderField := timeField[params.SortField]
			if orderField == "" {
				br.Msg = "时间排序字段有误"
				return
			}
			orderRule := orderRules[params.SortRule]
			if orderRule == "" {
				br.Msg = "时间排序方式有误"
				return
			}
			order = fmt.Sprintf("%s %s", orderField, orderRule)
		}
		if params.ApproveState > 0 {
			cond += fmt.Sprintf(` AND b.%s = ?`, report_approve.ReportApproveRecordCols.State)
			pars = append(pars, params.ApproveState)
		}
		total, e := report_approve.GetApplyReportApproveCount(cond, pars)
		if e != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "GetApplyReportApproveCount err: " + e.Error()
			return
		}
		respTotal = total
		list, e := report_approve.GetApplyReportApprovePageList(cond, pars, order, startSize, params.PageSize)
		if e != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "GetApplyReportApprovePageList err: " + e.Error()
			return
		}
		ormList = list
	}

	// 格式化列表
	for _, v := range ormList {
		t := report_approve.FormatReportApproveOrm2Item(v)
		if v.ReportType == report_approve.FlowReportTypeEnglish {
			t.ReportClassify = fmt.Sprintf("%s/%s/%s/%s", report_approve.FlowReportTypeMap[v.ReportType], enClassifyIdName[enRootIdMap[v.ClassifySecondId]], enClassifyIdName[v.ClassifyFirstId], enClassifyIdName[v.ClassifySecondId])
		} else {
			t.ReportClassify = fmt.Sprintf("%s/%s/%s", report_approve.FlowReportTypeMap[v.ReportType], cnClassifyIdName[v.ClassifyFirstId], cnClassifyIdName[v.ClassifySecondId])
		}
		respList = append(respList, t)
	}

	page := paging.GetPaging(params.CurrentIndex, params.PageSize, respTotal)
	resp.Paging = page
	resp.List = respList
	br.Data = resp
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
}

// Detail
// @Title 审批详情
// @Description 审批详情
// @Param   ReportApproveId  query  int  true  "审批ID"
// @Success 200 {object} report_approve.ReportApproveListResp
// @router /detail [get]
func (this *ReportApproveController) Detail() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	approveId, _ := this.GetInt("ReportApproveId")
	if approveId <= 0 {
		br.Msg = "参数有误"
		br.ErrMsg = fmt.Sprintf("参数有误, ReportApproveId: %d", approveId)
		return
	}

	approveOb := new(report_approve.ReportApprove)
	approveItem, e := approveOb.GetItemById(approveId)
	if e != nil {
		if e.Error() == utils.ErrNoRow() {
			br.Msg = "审批已被删除, 请刷新页面"
			return
		}
		br.Msg = "获取失败"
		br.ErrMsg = "获取审批失败, Err: " + e.Error()
		return
	}

	// 审批信息
	detail := new(report_approve.ReportApproveDetail)
	detail.Approve = new(report_approve.ReportApproveDetailItem)
	detail.Approve.ReportApproveId = approveItem.ReportApproveId
	detail.Approve.State = approveItem.State
	detail.Approve.FlowId = approveItem.FlowId
	detail.Approve.FlowVersion = approveItem.FlowVersion
	detail.Approve.StartNodeId = approveItem.StartNodeId
	detail.Approve.CurrNodeId = approveItem.CurrNodeId
	detail.Approve.ApplyUserId = approveItem.ApplyUserId
	detail.Approve.ApplyUserName = approveItem.ApplyUserName
	detail.Approve.ApproveTime = utils.TimeTransferString(utils.FormatDateTime, approveItem.ApproveTime)
	detail.Approve.CreateTime = utils.TimeTransferString(utils.FormatDateTime, approveItem.CreateTime)
	detail.Approve.ModifyTime = utils.TimeTransferString(utils.FormatDateTime, approveItem.ModifyTime)

	// 审批流
	//flowOb := new(report_approve.ReportApproveFlow)
	//flowItem, e := flowOb.GetItemById(approveItem.FlowId)
	//if e != nil {
	//	if e.Error() == utils.ErrNoRow() {
	//		br.Msg = "审批流已被删除, 请刷新页面"
	//		return
	//	}
	//	br.Msg = "获取失败"
	//	br.ErrMsg = "获取审批流失败, Err: " + e.Error()
	//	return
	//}
	//detail.ApproveFlow = report_approve.FormatReportApproveFlow2Item(flowItem)

	// 审批节点
	nodeOb := new(report_approve.ReportApproveNode)
	nodeCond := fmt.Sprintf(` AND %s = ? AND %s = ?`, report_approve.ReportApproveNodeCols.ReportApproveFlowId, report_approve.ReportApproveNodeCols.CurrVersion)
	nodePars := make([]interface{}, 0)
	nodePars = append(nodePars, approveItem.FlowId, approveItem.FlowVersion)
	nodeItems, e := nodeOb.GetItemsByCondition(nodeCond, nodePars, []string{}, "")
	if e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取审批节点失败, Err: " + e.Error()
		return
	}

	// 审批记录
	recordOb := new(report_approve.ReportApproveRecord)
	recordCond := fmt.Sprintf(` AND %s = ?`, report_approve.ReportApproveRecordCols.ReportApproveId)
	recordPars := make([]interface{}, 0)
	recordPars = append(recordPars, approveItem.ReportApproveId)
	recordItems, e := recordOb.GetItemsByCondition(recordCond, recordPars, []string{}, fmt.Sprintf("%s DESC", report_approve.ReportApproveRecordCols.ApproveTime))
	if e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取审批记录失败, Err: " + e.Error()
		return
	}
	recordMap := make(map[string]*report_approve.ReportApproveRecord)
	for _, v := range recordItems {
		k := fmt.Sprintf("%d-%d", v.NodeId, v.ApproveUserId)
		recordMap[k] = v
	}

	// 审批流节点详情
	detail.ApproveFlowNodes = make([]*report_approve.ReportApproveDetailNodes, 0)
	for _, v := range nodeItems {
		t := new(report_approve.ReportApproveDetailNodes)
		t.ReportApproveNodeId = v.ReportApproveNodeId
		t.ReportApproveFlowId = v.ReportApproveFlowId
		t.PrevNodeId = v.PrevNodeId
		t.NextNodeId = v.NextNodeId
		t.NodeType = v.NodeType
		t.ApproveType = v.ApproveType
		t.Users = make([]*report_approve.ReportApproveDetailNodeUser, 0)
		us := make([]*report_approve.ReportApproveNodeUserReq, 0)
		if v.Users != "" {
			e = json.Unmarshal([]byte(v.Users), &us)
			if e != nil {
				br.Msg = "获取失败"
				br.ErrMsg = "节点用户解析失败, Err: " + e.Error()
				return
			}
		}
		for _, vu := range us {
			u := new(report_approve.ReportApproveDetailNodeUser)
			u.UserType = vu.UserType
			u.UserId = vu.UserId
			u.UserName = vu.UserName
			u.Sort = vu.Sort
			// 审批记录
			k := fmt.Sprintf("%d-%d", v.ReportApproveNodeId, vu.UserId)
			r := recordMap[k]
			if r != nil {
				u.ApproveRecord = new(report_approve.ReportApproveDetailNodeUserRecord)
				u.ApproveRecord.State = r.State
				u.ApproveRecord.ApproveUserId = r.ApproveUserId
				u.ApproveRecord.ApproveUserName = r.ApproveUserName
				u.ApproveRecord.ApproveRemark = r.ApproveRemark
				u.ApproveRecord.ApproveTime = utils.TimeTransferString(utils.FormatDateTime, r.ApproveTime)
			}
			t.Users = append(t.Users, u)
		}
		detail.ApproveFlowNodes = append(detail.ApproveFlowNodes, t)
	}

	// 报告信息
	detail.Report = new(report_approve.ReportApproveDetailReport)
	detail.Report.ReportType = approveItem.ReportType
	detail.Report.ReportId = approveItem.ReportId
	if approveItem.ReportType == report_approve.FlowReportTypeChinese {
		rp, e := models.GetReportById(approveItem.ReportId)
		if e != nil {
			if e.Error() == utils.ErrNoRow() {
				br.Msg = "报告已被删除, 请刷新页面"
				return
			}
			br.Msg = "获取失败"
			br.ErrMsg = "获取中文研报失败, Err: " + e.Error()
			return
		}
		detail.Report.ReportTitle = rp.Title
		detail.Report.ClassifyFirstId = rp.ClassifyIdFirst
		detail.Report.ClassifySecondId = rp.ClassifyIdSecond
		detail.Report.Content = html.UnescapeString(rp.Content)
	}
	if approveItem.ReportType == report_approve.FlowReportTypeEnglish {
		rp, e := models.GetEnglishReportById(approveItem.ReportId)
		if e != nil {
			if e.Error() == utils.ErrNoRow() {
				br.Msg = "报告已被删除, 请刷新页面"
				return
			}
			br.Msg = "获取失败"
			br.ErrMsg = "获取英文研报失败, Err: " + e.Error()
			return
		}
		detail.Report.ReportTitle = rp.Title
		detail.Report.ClassifyFirstId = rp.ClassifyIdFirst
		detail.Report.ClassifySecondId = rp.ClassifyIdSecond
		detail.Report.Content = html.UnescapeString(rp.Content)
	}
	if approveItem.ReportType == report_approve.FlowReportTypeSmart {
		smartOb := new(smart_report.SmartReport)
		rp, e := smartOb.GetItemById(approveItem.ReportId)
		if e != nil {
			if e.Error() == utils.ErrNoRow() {
				br.Msg = "报告已被删除, 请刷新页面"
				return
			}
			br.Msg = "获取失败"
			br.ErrMsg = "获取智能研报失败, Err: " + e.Error()
			return
		}
		detail.Report.ReportTitle = rp.Title
		detail.Report.ClassifyFirstId = rp.ClassifyIdFirst
		detail.Report.ClassifySecondId = rp.ClassifyIdSecond
		detail.Report.Content = html.UnescapeString(rp.Content)
	}

	br.Data = detail
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
}

// Approve
// @Title 通过审批
// @Description 通过审批
// @Param	request	body report_approve.ReportApproveFlowAddReq true "type json string"
// @Success 200 {object} report_approve.ReportApproveDetailItem
// @router /approve [post]
func (this *ReportApproveFlowController) Approve() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req report_approve.ReportApproveFlowAddReq
	if e := json.Unmarshal(this.Ctx.Input.RequestBody, &req); e != nil {
		br.Msg = "参数有误"
		br.ErrMsg = "参数解析失败, Err: " + e.Error()
		return
	}

	br.Ret = 200
	br.Success = true
	br.Msg = "操作成功"
}

// Refuse
// @Title 驳回审批
// @Description 驳回审批
// @Param	request	body report_approve.ReportApproveFlowAddReq true "type json string"
// @Success 200 {object} report_approve.ReportApproveDetailItem
// @router /refuse [post]
func (this *ReportApproveFlowController) Refuse() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req report_approve.ReportApproveFlowAddReq
	if e := json.Unmarshal(this.Ctx.Input.RequestBody, &req); e != nil {
		br.Msg = "参数有误"
		br.ErrMsg = "参数解析失败, Err: " + e.Error()
		return
	}

	br.Ret = 200
	br.Success = true
	br.Msg = "操作成功"
}

// Cancel
// @Title 撤销审批
// @Description 撤销审批
// @Param	request	body report_approve.ReportApproveFlowAddReq true "type json string"
// @Success 200 {object} report_approve.ReportApproveDetailItem
// @router /cancel [post]
func (this *ReportApproveFlowController) Cancel() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req report_approve.ReportApproveFlowAddReq
	if e := json.Unmarshal(this.Ctx.Input.RequestBody, &req); e != nil {
		br.Msg = "参数有误"
		br.ErrMsg = "参数解析失败, Err: " + e.Error()
		return
	}

	br.Ret = 200
	br.Success = true
	br.Msg = "操作成功"
}