eta_api/controllers/assessment/assessment_form.go

package assessment

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

// AssessmentFormController 考核填报
type AssessmentFormController struct {
	controllers.BaseAuthController
}

// CheckAdd
// @Title 新建填报权限
// @Description 新建填报权限
// @Success 200 string "获取成功"
// @router /form/check_add [get]
func (this *AssessmentFormController) CheckAdd() {
	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
	}
	resp := new(models.AssessmentFormCheckAddResp)

	// 校验研究员身份，非研究员无权新增
	var researcherId int
	{
		researcherOb := new(models.AssessmentResearcher)
		cond := fmt.Sprintf(` AND %s = ?`, researcherOb.Cols().AdminId)
		pars := make([]interface{}, 0)
		pars = append(pars, sysUser.AdminId)
		item, e := researcherOb.GetItemByCondition(cond, pars, "")
		if e != nil && !utils.IsErrNoRow(e) {
			br.Msg = "获取失败"
			br.ErrMsg = "获取研究员失败"
			return
		}
		if item == nil || item.AssessmentResearcherId <= 0 {
			br.Data = resp
			br.Ret = 200
			br.Success = true
			br.Msg = "获取成功"
			return
		}
		researcherId = item.AssessmentResearcherId
		resp.IsResearcher = true
	}

	// 获取关联品种，无关联品种无权新增
	{
		mappingOb := new(models.AssessmentResearcherVarietyMapping)
		cond := fmt.Sprintf(` AND %s = ?`, mappingOb.Cols().AssessmentResearcherId)
		pars := make([]interface{}, 0)
		pars = append(pars, researcherId)
		mappings, e := mappingOb.GetItemsByCondition(cond, pars, []string{}, "")
		if e != nil {
			br.Msg = "获取失败"
			br.ErrMsg = fmt.Sprintf("获取研究员品种关联失败, %v", e)
			return
		}
		if len(mappings) == 0 {
			br.Data = resp
			br.Ret = 200
			br.Success = true
			br.Msg = "获取成功"
			return
		}
		resp.HasVariety = true
	}

	// 校验本周是否已填报过
	formOb := new(models.AssessmentForm)
	{
		weekStart, weekEnd := utils.GetWeekRange(time.Now().Local())
		cond := fmt.Sprintf(` AND %s = ? AND (%s BETWEEN ? AND ?)`, formOb.Cols().ResearcherId, formOb.Cols().CreateTime)
		pars := make([]interface{}, 0)
		pars = append(pars, researcherId, weekStart.Format(utils.FormatDateTime), weekEnd.Format(utils.FormatDateTime))
		count, e := formOb.GetCountByCondition(cond, pars)
		if e != nil {
			br.Msg = "获取失败"
			br.ErrMsg = fmt.Sprintf("获取本周填报单总数失败, %v", e)
			return
		}
		if count == 0 {
			resp.NewForm = true
		}
	}

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

// WeekBase
// @Title 获取本周填报信息
// @Description 获取本周填报信息
// @Success 200 string "获取成功"
// @router /form/week_base [get]
func (this *AssessmentFormController) WeekBase() {
	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
	}
	resp := new(models.AssessmentFormViewResp)

	// 校验研究员身份
	researcher := new(models.AssessmentResearcher)
	{
		researcherOb := new(models.AssessmentResearcher)
		cond := fmt.Sprintf(` AND %s = ?`, researcherOb.Cols().AdminId)
		pars := make([]interface{}, 0)
		pars = append(pars, sysUser.AdminId)
		item, e := researcherOb.GetItemByCondition(cond, pars, "")
		if e != nil {
			if utils.IsErrNoRow(e) {
				br.Msg = "您不是研究员，不可填报观点"
				return
			}
			br.Msg = "获取失败"
			br.ErrMsg = "获取研究员失败"
			return
		}
		if item == nil || item.AssessmentResearcherId <= 0 {
			br.Msg = "您不是研究员，不可填报观点"
			return
		}
		researcher = item
	}

	// 获取关联品种
	varietyOb := new(models.AssessmentVariety)
	varietyMatch := make(map[int]*models.AssessmentVariety)
	{
		varieties, e := varietyOb.GetItemsByCondition(``, make([]interface{}, 0), []string{}, "")
		if e != nil {
			br.Msg = "获取失败"
			br.ErrMsg = fmt.Sprintf("获取品种列表失败, %v", e)
			return
		}
		for _, v := range varieties {
			varietyMatch[v.AssessmentVarietyId] = v
		}
	}
	varietyMappings := make([]*models.AssessmentResearcherVarietyMapping, 0)
	{
		mappingOb := new(models.AssessmentResearcherVarietyMapping)
		cond := fmt.Sprintf(` AND %s = ?`, mappingOb.Cols().AdminId)
		pars := make([]interface{}, 0)
		pars = append(pars, sysUser.AdminId)
		mappings, e := mappingOb.GetItemsByCondition(cond, pars, []string{}, "")
		if e != nil {
			br.Msg = "获取失败"
			br.ErrMsg = fmt.Sprintf("获取研究员品种关联失败, %v", e)
			return
		}
		varietyMappings = mappings
	}
	if len(varietyMappings) == 0 {
		br.Msg = "您无关联品种，不可填报观点"
		return
	}

	// 校验本周是否已填报过
	formOb := new(models.AssessmentForm)
	{
		weekStart, weekEnd := utils.GetWeekRange(time.Now().Local())
		cond := fmt.Sprintf(` AND %s = ? AND (%s BETWEEN ? AND ?)`, formOb.Cols().ResearcherId, formOb.Cols().CreateTime)
		pars := make([]interface{}, 0)
		pars = append(pars, researcher.AssessmentResearcherId, weekStart.Format(utils.FormatDateTime), weekEnd.Format(utils.FormatDateTime))
		count, e := formOb.GetCountByCondition(cond, pars)
		if e != nil {
			br.Msg = "获取失败"
			br.ErrMsg = fmt.Sprintf("获取本周填报单总数失败, %v", e)
			return
		}
		if count > 0 {
			br.Msg = "本周已填报，请勿重复填报"
			return
		}
	}

	// 获取单号、周度、价格基准日期
	formCode, e := services.GenerateAssessmentFormCode()
	if e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = fmt.Sprintf("获取填报单单号失败, %v", e)
		return
	}
	weekTime, _, friday := services.GetAssessmentWeekAndFriday(time.Now().Local())

	resp.List = make([]*models.AssessmentFormDetail, 0)
	for _, v := range varietyMappings {
		variety := varietyMatch[v.VarietyId]
		if variety == nil {
			continue
		}
		t := new(models.AssessmentFormDetail)
		t.FormCode = formCode
		t.ResearcherId = researcher.AssessmentResearcherId
		t.ResearcherAdminId = researcher.AdminId
		t.ResearcherName = researcher.RealName
		t.VarietyId = variety.AssessmentVarietyId
		t.VarietyCode = variety.VarietyCode
		t.VarietyName = variety.VarietyName
		t.WeekTime = weekTime
		t.BaseDate = utils.TimeTransferString(utils.FormatDate, friday)
		resp.List = append(resp.List, t)
	}

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

// Detail
// @Title 填报单详情
// @Description 填报单详情
// @Param   FormCode  query  string  true  "填报单号"
// @Success 200 string "获取成功"
// @router /form/detail [get]
func (this *AssessmentFormController) 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
	}
	formCode := this.GetString("FormCode")
	if formCode == "" {
		br.Msg = "参数有误"
		return
	}
	resp := new(models.AssessmentFormViewResp)

	// 根据单号获取填报单
	formOb := new(models.AssessmentForm)
	cond := fmt.Sprintf(` AND %s = ?`, formOb.Cols().FormCode)
	pars := make([]interface{}, 0)
	pars = append(pars, formCode)
	list, e := formOb.GetItemsByCondition(cond, pars, []string{}, "")
	if e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = fmt.Sprintf("获取本周填报单总数失败, %v", e)
		return
	}
	resp.List = make([]*models.AssessmentFormDetail, 0)
	for _, v := range list {
		resp.List = append(resp.List, v.Format2Detail())
	}

	// 获取品种价格详情及观点评价
	varietyPrice, forecastComment, e := services.GetVarietyPriceAndForecastComment(list)
	if e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = fmt.Sprintf("获取品种价格详情及观点评价失败, %v", e)
		return
	}
	resp.VarietyPrice = varietyPrice
	resp.ForecastComment = forecastComment

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

// PageList
// @Title 填报单列表-分页
// @Description 填报单列表-分页
// @Param	request	body models.AssessmentFormPageListReq true "type json string"
// @Success 200 string "获取成功"
// @router /form/page_list [get]
func (this *AssessmentFormController) PageList() {
	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(models.AssessmentFormPageListReq)
	if e := this.ParseForm(params); e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "参数解析失败, Err: " + e.Error()
		return
	}
	resp := new(models.AssessmentFormPageListResp)
	resp.List = make([]*models.AssessmentFormDetail, 0)

	// 分页
	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)

	// 当前用户是否为研究员
	researcher := new(models.AssessmentResearcher)
	{
		researcherOb := new(models.AssessmentResearcher)
		cond := fmt.Sprintf(` AND %s = ?`, researcherOb.Cols().AdminId)
		pars := make([]interface{}, 0)
		pars = append(pars, sysUser.AdminId)
		item, e := researcherOb.GetItemByCondition(cond, pars, "")
		if e != nil && !utils.IsErrNoRow(e) {
			br.Msg = "获取失败"
			br.ErrMsg = fmt.Sprintf("获取研究员失败, %v", e)
			return
		}
		if item != nil && item.AssessmentResearcherId > 0 {
			researcher = item
		}
	}
	var authResearcherIds []int

	// 筛选项
	formOb := new(models.AssessmentForm)
	condList := ``
	parsList := make([]interface{}, 0)
	{
		// 可查看的其他研究员的填报
		var researcherIds []int
		if researcher != nil && researcher.AssessmentResearcherId > 0 {
			researcherIds = append(researcherIds, researcher.AssessmentResearcherId)
			authResearcherIds = append(authResearcherIds, researcher.AssessmentResearcherId)
		}
		mappingOb := new(models.AssessmentResearcherAdminMapping)
		mappingCond := fmt.Sprintf(` AND %s = ?`, mappingOb.Cols().AuthAdminId)
		mappingPars := make([]interface{}, 0)
		mappingPars = append(mappingPars, sysUser.AdminId)
		mappings, e := mappingOb.GetItemsByCondition(mappingCond, mappingPars, []string{}, "")
		if e != nil {
			br.Msg = "获取失败"
			br.ErrMsg = fmt.Sprintf("获取研究员权限失败, %v", e)
			return
		}
		for _, v := range mappings {
			if v.AuthType == models.AssessmentResearcherAdminAuthTypeView {
				researcherIds = append(researcherIds, v.AssessmentResearcherId)
				authResearcherIds = append(authResearcherIds, v.AssessmentResearcherId)
			}
		}

		// 研究员筛选项，与有权限的取交集
		if params.AssessmentResearcherIds != "" {
			var parResearcherIds []int
			arr := strings.Split(params.AssessmentResearcherIds, ",")
			for _, v := range arr {
				i, _ := strconv.Atoi(v)
				if i > 0 {
					parResearcherIds = append(parResearcherIds, i)
				}
			}
			researcherIds = utils.IntersectInt(researcherIds, parResearcherIds)
		}
		if len(researcherIds) == 0 {
			resp.Paging = paging.GetPaging(params.CurrentIndex, params.PageSize, 0)
			br.Data = resp
			br.Ret = 200
			br.Success = true
			br.Msg = "获取成功"
			return
		}
		condList += fmt.Sprintf(` AND %s IN (?)`, formOb.Cols().ResearcherId)
		parsList = append(parsList, researcherIds)

		// 品种
		if params.AssessmentVarietyIds != "" {
			var varietyIds []int
			arr := strings.Split(params.AssessmentVarietyIds, ",")
			for _, v := range arr {
				i, _ := strconv.Atoi(v)
				if i > 0 {
					varietyIds = append(varietyIds, i)
				}
			}
			if len(varietyIds) == 0 {
				resp.Paging = paging.GetPaging(params.CurrentIndex, params.PageSize, 0)
				br.Data = resp
				br.Ret = 200
				br.Success = true
				br.Msg = "获取成功"
				return
			}
			condList += fmt.Sprintf(` AND %s IN (?)`, formOb.Cols().VarietyId)
			parsList = append(parsList, varietyIds)
		}

		// 基准日期筛选
		params.StartTime = strings.TrimSpace(params.StartTime)
		params.EndTime = strings.TrimSpace(params.EndTime)
		if params.StartTime != "" && params.EndTime != "" {
			_, e = time.ParseInLocation(utils.FormatDate, params.StartTime, time.Local)
			if e != nil {
				br.Msg = "开始日期格式有误"
				return
			}
			_, e = time.ParseInLocation(utils.FormatDate, params.EndTime, time.Local)
			if e != nil {
				br.Msg = "结束日期格式有误"
				return
			}
			st := fmt.Sprintf("%s 00:00:00", params.StartTime)
			ed := fmt.Sprintf("%s 23:59:59", params.EndTime)
			condList += fmt.Sprintf(` AND (%s BETWEEN ? AND ?)`, formOb.Cols().BaseDate)
			parsList = append(parsList, st, ed)
		}
	}

	// 列表
	total, e := formOb.GetCountByCondition(condList, parsList)
	if e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = fmt.Sprintf("获取研究员列表总数失败, %v", e)
		return
	}
	orderRule := fmt.Sprintf(`%s ASC, %s DESC`, formOb.Cols().Status, formOb.Cols().SubmitTime) // 排序规则：未提交在最前面，然后按提交时间降序
	list, e := formOb.GetPageItemsByCondition(condList, parsList, []string{}, orderRule, startSize, params.PageSize)
	if e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = fmt.Sprintf("获取研究员失败, %v", e)
		return
	}
	if total == 0 || len(list) == 0 {
		resp.Paging = paging.GetPaging(params.CurrentIndex, params.PageSize, 0)
		br.Data = resp
		br.Ret = 200
		br.Success = true
		br.Msg = "获取成功"
		return
	}
	for _, v := range list {
		d := v.Format2Detail()
		d.Button = services.CheckAssessmentFormButton(v, sysUser.AdminId, authResearcherIds)
		resp.List = append(resp.List, d)
	}

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

// Save
// @Title 保存填报单
// @Description 保存填报单
// @Param	request	body models.AssessmentFormSaveReq true "type json string"
// @Success 200 string "操作成功"
// @router /form/save [post]
func (this *AssessmentFormController) Save() {
	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 models.AssessmentFormSaveReq
	if e := json.Unmarshal(this.Ctx.Input.RequestBody, &req); e != nil {
		br.Msg = "参数有误"
		br.ErrMsg = fmt.Sprintf("参数解析失败, %v", e)
		return
	}
	if len(req.List) == 0 {
		br.Msg = "填报单品种有误"
		br.ErrMsg = "参数异常, 填报单品种数有误"
		return
	}
	formOb := new(models.AssessmentForm)
	firstFormId := req.List[0].AssessmentFormId
	status := req.List[0].Status
	researcherId := req.List[0].ResearcherId

	// 如果是新增那么，校验本周是否已填报过
	if firstFormId <= 0 {
		weekStart, weekEnd := utils.GetWeekRange(time.Now().Local())
		cond := fmt.Sprintf(` AND %s = ? AND (%s BETWEEN ? AND ?)`, formOb.Cols().ResearcherId, formOb.Cols().CreateTime)
		pars := make([]interface{}, 0)
		pars = append(pars, researcherId, weekStart.Format(utils.FormatDateTime), weekEnd.Format(utils.FormatDateTime))
		count, e := formOb.GetCountByCondition(cond, pars)
		if e != nil {
			br.Msg = "操作失败"
			br.ErrMsg = fmt.Sprintf("获取本周填报单总数失败, %v", e)
			return
		}
		if count > 0 {
			br.Msg = "本周已填报，请勿重复填报"
			return
		}
	}

	insertForms, updateForms := make([]*models.AssessmentForm, 0), make([]*models.AssessmentForm, 0)
	for _, v := range req.List {
		if v.FormCode == "" {
			br.Msg = "单号异常"
			br.ErrMsg = "参数异常：单号"
			return
		}
		if v.ResearcherId <= 0 {
			br.Msg = "研究员异常"
			br.ErrMsg = "参数异常：研究员ID"
			return
		}
		if v.VarietyId <= 0 {
			br.Msg = "品种异常"
			br.ErrMsg = "参数异常：品种ID"
			return
		}
		if v.WeekTime == "" {
			br.Msg = "周度异常"
			br.ErrMsg = "参数异常：周度"
			return
		}
		if v.BaseDate == "" {
			br.Msg = "价格基准日期异常"
			br.ErrMsg = "参数异常：价格基准日期"
			return
		}
		baseDate, e := time.ParseInLocation(utils.FormatDate, v.BaseDate, time.Local)
		if e != nil {
			br.Msg = "价格基准日期格式异常"
			br.ErrMsg = fmt.Sprintf("价格基准日期格式异常, %s", v.BaseDate)
			return
		}
		weekStart, weekEnd := utils.GetWeekRange(baseDate)

		fm := new(models.AssessmentForm)
		fm.AssessmentFormId = v.AssessmentFormId
		fm.FormCode = v.FormCode
		fm.ResearcherId = v.ResearcherId
		fm.ResearcherAdminId = v.ResearcherAdminId
		fm.ResearcherName = v.ResearcherName
		fm.VarietyId = v.VarietyId
		fm.VarietyCode = v.VarietyCode
		fm.VarietyName = v.VarietyName
		fm.WeekTime = v.WeekTime
		fm.WeekStart = weekStart
		fm.WeekEnd = weekEnd
		fm.BaseDate = baseDate
		fm.Status = status
		fm.MonthlyPriceForecast = v.MonthlyPriceForecast
		fm.WeeklyUpForecast = v.WeeklyUpForecast
		fm.WeeklyDownForecast = v.WeeklyDownForecast
		fm.ModifyTime = time.Now().Local()

		// 提交时才校验必填项
		if status == models.AssessmentFormStatusSubmitted {
			if v.MonthlyPriceForecast == "" {
				br.Msg = "请选择月度涨跌"
				return
			}
			if v.WeeklyUpForecast == "" {
				br.Msg = "请选择周度上行风险"
				return
			}
			if v.WeeklyDownForecast == "" {
				br.Msg = "请选择周度下行风险"
				return
			}
			// 当周填报单据如果超过周日未提交则不可再提交，但是可以编辑
			if time.Now().After(weekEnd) {
				br.Msg = fmt.Sprintf("该单据已超过最晚提交时间: %s，不允许提交", weekEnd.Format(utils.FormatDateTime))
				return
			}
			fm.SubmitTime = time.Now().Local()
		}
		if firstFormId > 0 {
			updateForms = append(updateForms, fm)
		} else {
			fm.CreateTime = time.Now().Local()
			insertForms = append(insertForms, fm)
			continue
		}
	}

	// 首行表单ID大于0为更新
	if firstFormId > 0 && len(updateForms) > 0 {
		updateCols := []string{formOb.Cols().MonthlyPriceForecast, formOb.Cols().WeeklyUpForecast, formOb.Cols().WeeklyDownForecast, formOb.Cols().ModifyTime}
		if status == models.AssessmentFormStatusSubmitted {
			updateCols = append(updateCols, formOb.Cols().Status, formOb.Cols().SubmitTime)
		}
		for _, v := range updateForms {
			if e := v.Update(updateCols); e != nil {
				br.Msg = "操作失败"
				br.ErrMsg = fmt.Sprintf("更新填报单失败, %v", e)
				return
			}
		}
	}

	// 新增
	if firstFormId <= 0 && len(insertForms) > 0 {
		if e := formOb.CreateMulti(insertForms); e != nil {
			br.Msg = "操作失败"
			br.ErrMsg = fmt.Sprintf("批量新增填报单失败, %v", e)
			return
		}
	}

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

// Submit
// @Title 提交填报单
// @Description 提交填报单
// @Param	request	body models.AssessmentFormSubmitReq true "type json string"
// @Success 200 string "操作成功"
// @router /form/submit [post]
func (this *AssessmentFormController) Submit() {
	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 models.AssessmentFormSubmitReq
	if e := json.Unmarshal(this.Ctx.Input.RequestBody, &req); e != nil {
		br.Msg = "参数有误"
		br.ErrMsg = fmt.Sprintf("参数解析失败, %v", e)
		return
	}
	req.FormCode = strings.TrimSpace(req.FormCode)
	if req.FormCode == "" {
		br.Msg = "参数有误"
		br.ErrMsg = "参数有误, FormCode"
		return
	}

	// 获取单号关联的填报单
	formOb := new(models.AssessmentForm)
	cond := fmt.Sprintf(` AND %s = ?`, formOb.Cols().FormCode)
	pars := make([]interface{}, 0)
	pars = append(pars, req.FormCode)
	list, e := formOb.GetItemsByCondition(cond, pars, []string{}, "")
	if e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = fmt.Sprintf("获取单号关联填报单失败, %v", e)
		return
	}
	if len(list) == 0 {
		br.Msg = "填报单有误"
		br.ErrMsg = "单号无关联填报单"
		return
	}

	// 提交校验
	adminId := list[0].ResearcherAdminId
	if sysUser.AdminId != adminId {
		br.Msg = "无权操作"
		return
	}
	status := list[0].Status
	if status == models.AssessmentFormStatusSubmitted {
		br.Msg = "该单据已提交，请勿重复提交"
		return
	}
	weekEnd := list[0].WeekEnd
	submitOk := !weekEnd.IsZero() && time.Now().Local().Before(weekEnd)
	if !submitOk {
		br.Msg = fmt.Sprintf("该单据已超过最晚提交时间: %s，不允许提交", weekEnd.Format(utils.FormatDateTime))
		return
	}
	for _, v := range list {
		if v.MonthlyPriceForecast == "" {
			br.Msg = "请选择月度涨跌"
			return
		}
		if v.WeeklyUpForecast == "" {
			br.Msg = "请选择周度上行风险"
			return
		}
		if v.WeeklyDownForecast == "" {
			br.Msg = "请选择周度下行风险"
			return
		}
	}

	// 更新状态
	updateCols := []string{formOb.Cols().Status, formOb.Cols().SubmitTime, formOb.Cols().ModifyTime}
	for _, v := range list {
		v.Status = models.AssessmentFormStatusSubmitted
		v.SubmitTime = time.Now().Local()
		v.ModifyTime = time.Now().Local()
		if e = v.Update(updateCols); e != nil {
			br.Msg = "操作失败"
			br.ErrMsg = fmt.Sprintf("更新填报单状态失败, %v", e)
			return
		}
	}

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

// Cancel
// @Title 撤销填报单
// @Description 撤销填报单
// @Param	request	body models.AssessmentFormCancelReq true "type json string"
// @Success 200 string "操作成功"
// @router /form/cancel [post]
func (this *AssessmentFormController) 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 models.AssessmentFormCancelReq
	if e := json.Unmarshal(this.Ctx.Input.RequestBody, &req); e != nil {
		br.Msg = "参数有误"
		br.ErrMsg = fmt.Sprintf("参数解析失败, %v", e)
		return
	}
	req.FormCode = strings.TrimSpace(req.FormCode)
	if req.FormCode == "" {
		br.Msg = "参数有误"
		br.ErrMsg = "参数有误, FormCode"
		return
	}

	// 获取单号关联的填报单
	formOb := new(models.AssessmentForm)
	cond := fmt.Sprintf(` AND %s = ?`, formOb.Cols().FormCode)
	pars := make([]interface{}, 0)
	pars = append(pars, req.FormCode)
	list, e := formOb.GetItemsByCondition(cond, pars, []string{}, "")
	if e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = fmt.Sprintf("获取单号关联填报单失败, %v", e)
		return
	}
	if len(list) == 0 {
		br.Msg = "填报单有误"
		br.ErrMsg = "单号无关联填报单"
		return
	}

	// 撤销校验
	adminId := list[0].ResearcherAdminId
	if sysUser.AdminId != adminId {
		br.Msg = "无权操作"
		return
	}
	status := list[0].Status
	if status == models.AssessmentFormStatusDraft {
		br.Msg = "单据状态有误，请刷新页面"
		return
	}
	weekEnd := list[0].WeekEnd
	cancelOk := !weekEnd.IsZero() && time.Now().Local().Before(weekEnd)
	if !cancelOk {
		br.Msg = fmt.Sprintf("该单据已超过最晚撤销时间: %s，不允许撤销", weekEnd.Format(utils.FormatDateTime))
		return
	}
	// TODO:这里象屿会有一个外部条件：当周周报未提交，暂不处理视作true

	// 更新状态
	updateCols := []string{formOb.Cols().Status, formOb.Cols().SubmitTime, formOb.Cols().ModifyTime}
	for _, v := range list {
		v.Status = models.AssessmentFormStatusDraft
		v.SubmitTime = time.Time{}
		v.ModifyTime = time.Now().Local()
		if e = v.Update(updateCols); e != nil {
			br.Msg = "操作失败"
			br.ErrMsg = fmt.Sprintf("更新填报单状态失败, %v", e)
			return
		}
	}

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

// Remove
// @Title 删除填报单
// @Description 删除填报单
// @Param	request	body models.AssessmentFormRemoveReq true "type json string"
// @Success 200 string "操作成功"
// @router /form/remove [post]
func (this *AssessmentFormController) Remove() {
	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 models.AssessmentFormRemoveReq
	if e := json.Unmarshal(this.Ctx.Input.RequestBody, &req); e != nil {
		br.Msg = "参数有误"
		br.ErrMsg = fmt.Sprintf("参数解析失败, %v", e)
		return
	}
	req.FormCode = strings.TrimSpace(req.FormCode)
	if req.FormCode == "" {
		br.Msg = "参数有误"
		br.ErrMsg = "参数有误, FormCode"
		return
	}

	// 获取单号关联的填报单
	formOb := new(models.AssessmentForm)
	cond := fmt.Sprintf(` AND %s = ?`, formOb.Cols().FormCode)
	pars := make([]interface{}, 0)
	pars = append(pars, req.FormCode)
	list, e := formOb.GetItemsByCondition(cond, pars, []string{}, "")
	if e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = fmt.Sprintf("获取单号关联填报单失败, %v", e)
		return
	}
	if len(list) == 0 {
		br.Ret = 200
		br.Success = true
		br.Msg = "操作成功"
		return
	}

	// 撤销校验
	adminId := list[0].ResearcherAdminId
	if sysUser.AdminId != adminId {
		br.Msg = "无权操作"
		return
	}
	status := list[0].Status
	if status != models.AssessmentFormStatusDraft {
		br.Msg = "单据状态有误，请刷新页面"
		return
	}

	// 删除填报单
	cond = fmt.Sprintf(`%s = ?`, formOb.Cols().FormCode)
	if e = formOb.RemoveByCondition(cond, pars); e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = fmt.Sprintf("批量删除填报单失败, %v", e)
		return
	}

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

// ResultStatistic
// @Title 结果统计
// @Description 结果统计
// @Param	request	body models.AssessmentFormResultStatisticReq true "type json string"
// @Success 200 string "获取成功"
// @router /form/result_statistic [get]
func (this *AssessmentFormController) ResultStatistic() {
	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(models.AssessmentFormResultStatisticReq)
	if e := this.ParseForm(params); e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "参数解析失败, Err: " + e.Error()
		return
	}
	params.AssessmentResearcherIds = strings.TrimSpace(params.AssessmentResearcherIds)
	if params.AssessmentResearcherIds == "" {
		br.Msg = "请选择研究员"
		return
	}
	params.StartTime = strings.TrimSpace(params.StartTime)
	params.EndTime = strings.TrimSpace(params.EndTime)
	if params.StartTime == "" || params.EndTime == "" {
		br.Msg = "请选择开始结束时间"
		return
	}
	_, e := time.Parse(utils.FormatDate, params.StartTime)
	if e != nil {
		br.Msg = "开始时间格式有误"
		return
	}
	ed, e := time.Parse(utils.FormatDate, params.EndTime)
	if e != nil {
		br.Msg = "结束时间格式有误"
		return
	}
	parEndDate := ed.AddDate(0, 0, 28).Format(utils.FormatDate) // 实际填报单和数据的取值范围为结束日期+4周
	resp := make([]*models.AssessmentFormResultStatisticItem, 0)

	var researcherIds []int
	arr := strings.Split(params.AssessmentResearcherIds, ",")
	for _, v := range arr {
		i, _ := strconv.Atoi(v)
		if i > 0 {
			researcherIds = append(researcherIds, i)
		}
	}
	if len(researcherIds) == 0 {
		br.Msg = "研究员有误"
		br.ErrMsg = fmt.Sprintf("选择的研究员IDs有误, %s", params.AssessmentResearcherIds)
		return
	}

	// 获取研究员在[开始日期至结束日期+4周]的填报单
	forms := make([]*models.AssessmentForm, 0)
	{
		formOb := new(models.AssessmentForm)
		cond := fmt.Sprintf(` AND %s = ? AND %s IN (?) AND (%s BETWEEN ? AND ?)`, formOb.Cols().Status, formOb.Cols().ResearcherId, formOb.Cols().BaseDate)
		pars := make([]interface{}, 0)
		pars = append(pars, models.AssessmentFormStatusSubmitted, researcherIds, params.StartTime, parEndDate)
		list, e := formOb.GetItemsByCondition(cond, pars, []string{}, "")
		if e != nil {
			br.Msg = "获取失败"
			br.ErrMsg = fmt.Sprintf("获取填报单失败, %v", e)
			return
		}
		forms = list
	}
	if len(forms) == 0 {
		br.Data = resp
		br.Ret = 200
		br.Success = true
		br.Msg = "获取成功"
		return
	}

	// 初始化响应结果，取出填报单关联的品种
	var varietyIds []int
	existVarietyId := make(map[int]bool)
	existRespKey := make(map[string]bool)
	for _, v := range forms {
		if !existVarietyId[v.VarietyId] {
			existVarietyId[v.VarietyId] = true
			varietyIds = append(varietyIds, v.VarietyId)
		}
		k := fmt.Sprintf("%d-%d", v.ResearcherId, v.VarietyId)
		if existRespKey[k] {
			continue
		}
		t := new(models.AssessmentFormResultStatisticItem)
		t.ResearcherId = v.ResearcherId
		t.ResearcherAdminId = v.ResearcherAdminId
		t.ResearcherName = v.ResearcherName
		t.VarietyId = v.VarietyId
		t.VarietyName = v.VarietyName
		t.VarietyCode = v.VarietyCode
		resp = append(resp, t)
	}

	// 并查询对应时间的品种数据
	varietyData := make([]*models.AssessmentVarietyData, 0)
	{
		dataOb := new(models.AssessmentVarietyData)
		cond := fmt.Sprintf(` AND %s IN (?) AND (%s BETWEEN ? AND ?)`, dataOb.Cols().VarietyId, dataOb.Cols().WeekDate)
		pars := make([]interface{}, 0)
		pars = append(pars, varietyIds, params.StartTime, parEndDate)
		list, e := dataOb.GetItemsByCondition(cond, pars, []string{}, "")
		if e != nil {
			br.Msg = "获取失败"
			br.ErrMsg = fmt.Sprintf("获取品种数据失败, %v", e)
			return
		}
		varietyData = list
	}

	// 计算正确率
	resp, e = services.CalculateResultStatistic(forms, varietyData, resp)

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