eta_mini_crm/controllers/report_push_status.go

package controllers

import (
	"encoding/json"
	"eta/eta_mini_crm/models"
	"eta/eta_mini_crm/models/request"
	"eta/eta_mini_crm/models/response"
	"eta/eta_mini_crm/utils"
	"fmt"
	"strconv"
	"strings"
	"time"

	"github.com/rdlucklib/rdluck_tools/paging"
)

type ReportPushStatusController struct {
	BaseAuthController
}

// List
// @Title pdf研报列表
// @Description pdf研报列表
// @Param   PageSize   query   int  true       "每页数据条数"
// @Param   CurrentIndex   query   int  true       "当前页页码，从1开始"
// @Param   ClassifyIds   query   string  true       "分类id,可多选用英文,隔开"
// @Param   ChartPermissionIds   query   string  true       "品种id,可多选用英文,隔开"
// @Param   PublishStartDate   query   string  true       "发布开始时间"
// @Param   PublishEndDate   query   string  true       "发布结束时间"
// @Param   PushStartDate   query   string  true       "推送开始时间"
// @Param   PushEndDate   query   string  true       "推送结束时间"
// @Param   KeyWord   query   string  true       "报告标题/创建人"
// @Param   SelectedIds   query   string  true       "选择的报告id, isSelectAll:为true时，反选"
// @Param   IsSelectAll   query   bool  true       "是否全选"
// @Param   SortParam   query   string  true       "排序字段"
// @Param   SortType   query   string  true       "排序方式"
// @Success 200 {object} models.ReportAuthorResp
// @router /list [get]
func (this *ReportPushStatusController) List() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

	pageSize, _ := this.GetInt("PageSize")
	currentIndex, _ := this.GetInt("CurrentIndex")
	classifyIds := this.GetString("ClassifyIds")
	selectedIds := this.GetString("SelectedIds")
	isSelectAll, _ := this.GetBool("IsSelectAll")
	chartPermissionIds := this.GetString("ChartPermissionIds")
	publishStartDate := this.GetString("PublishStartDate")
	publishEndDate := this.GetString("PublishEndDate")
	pushStartDate := this.GetString("PushStartDate")
	pushEndDate := this.GetString("PushEndDate")
	keyWord := this.GetString("KeyWord")
	sortParam := this.GetString("SortParam")
	sortType := this.GetString("SortType")

	if pageSize <= 0 {
		pageSize = utils.PageSize20
	}
	if currentIndex <= 0 {
		currentIndex = 1
	}
	var condition string
	var pars []interface{}
	if publishStartDate != "" && publishEndDate != "" {
		condition += " AND a.publish_time >= ?"
		publishStartTime, err := time.Parse(utils.FormatDate, publishStartDate)
		if err != nil {
			br.Msg = "日期格式有误"
			br.ErrMsg = "日期格式有误，Err:" + err.Error()
			return
		}
		publishStartDateStr := publishStartTime.Format(utils.FormatDateTime)
		pars = append(pars, publishStartDateStr)

		condition += " AND a.publish_time <= ?"
		publishEndTime, err := time.Parse(utils.FormatDate, publishEndDate)
		if err != nil {
			br.Msg = "日期格式有误"
			br.ErrMsg = "日期格式有误，Err:" + err.Error()
			return
		}
		publishEndTime = publishEndTime.Add(23*time.Hour + 59*time.Minute + 59*time.Second)
		publishEndDateStr := publishEndTime.Format(utils.FormatDateTime)
		pars = append(pars, publishEndDateStr)
	}
	if pushStartDate != "" && pushEndDate != "" {
		condition += " AND b.push_time >= ?"
		pushStartTime, err := time.Parse(utils.FormatDate, pushStartDate)
		if err != nil {
			br.Msg = "日期格式有误"
			br.ErrMsg = "日期格式有误，Err:" + err.Error()
			return
		}
		pushStartDateStr := pushStartTime.Format(utils.FormatDateTime)
		pars = append(pars, pushStartDateStr)

		condition += " AND b.push_time <= ?"
		pushEndTime, err := time.Parse(utils.FormatDate, pushEndDate)
		if err != nil {
			br.Msg = "日期格式有误"
			br.ErrMsg = "日期格式有误，Err:" + err.Error()
			return
		}
		pushEndTime = pushEndTime.Add(23*time.Hour + 59*time.Minute + 59*time.Second)
		pushEndDateStr := pushEndTime.Format(utils.FormatDateTime)
		pars = append(pars, pushEndDateStr)
	}
	if keyWord != "" {
		condition += ` AND a.title like ?  `
		pars = utils.GetLikeKeywordPars(pars, keyWord, 1)
	}
	var sortCondition string
	if sortParam != "" && sortType != "" {
		sortCondition = " ORDER BY "
		var param, sort string
		switch sortParam {
		case "PublishTime":
			param = "a.publish_time"
		case "PushTime":
			param = "b.push_time"
		}
		switch sortType {
		case "asc":
			sort = " ASC "
		case "desc":
			sort = " DESC "
		}
		if param != "" && sort != "" {
			sortCondition += param + " " + sort
		} else {
			sortCondition = ""
		}
	}
	if sortCondition == "" {
		sortCondition = ` ORDER BY a.publish_time DESC `
	}

	classifyIdList := make([]int, 0)
	if classifyIds != "" {
		classifyArrStr := strings.Split(classifyIds, ",")
		if len(classifyArrStr) > 0 {
			for _, v := range classifyArrStr {
				tmp, _ := strconv.Atoi(v)
				classifyIdList = append(classifyIdList, tmp)
			}
		}
	}
	if chartPermissionIds != "" {
		idStrs := strings.Split(chartPermissionIds, ",")
		idInts := make([]int, 0)
		for _, id := range idStrs {
			tmp, _ := strconv.Atoi(id)
			idInts = append(idInts, tmp)
		}
		tmpClassifyList, err := models.GetClassifyIdsListByIds(idInts)
		if err != nil {
			br.Msg = "获取研报列表失败"
			br.ErrMsg = "品种获取分类失败，Err:" + err.Error()
			return
		}
		classifyIdList = append(classifyIdList, tmpClassifyList...)
	}
	if len(classifyIdList) > 0 {
		classifyIdList = utils.Unique(classifyIdList)
		condition += ` AND (a.classify_id_first IN (%s) AND a.classify_id_second IN (%s) AND a.classify_id_third IN (%s))`
		condition = fmt.Sprintf(condition, utils.GetOrmReplaceHolder(len(classifyIdList)), utils.GetOrmReplaceHolder(len(classifyIdList)), utils.GetOrmReplaceHolder(len(classifyIdList)))
		pars = append(pars, classifyIdList, classifyIdList, classifyIdList)
	}
	if isSelectAll {
		if selectedIds != "" {
			selectIdStrs := strings.Split(selectedIds, ",")
			if len(selectIdStrs) > 0 {
				condition += ` AND a.id NOT IN (` + utils.GetOrmReplaceHolder(len(selectIdStrs)) + `)`
				pars = append(pars, selectedIds)
			}
		}
	} else {
		if selectedIds != "" {
			selectIdStrs := strings.Split(selectedIds, ",")
			if len(selectIdStrs) > 0 {
				condition += ` AND a.id IN (` + utils.GetOrmReplaceHolder(len(selectIdStrs)) + `)`
				pars = append(pars, selectedIds)
			}
		}
	}
	startSize := utils.StartIndex(currentIndex, pageSize)
	total, err := models.GetReportCountByCondition(condition, pars)
	if err != nil {
		br.Msg = "获取研报列表失败"
		br.ErrMsg = "获取研报列表统计失败，Err:" + err.Error()
		return
	}
	reportList, err := models.GetReportPushStatusListByCondition(condition, pars, startSize, pageSize)
	if err != nil {
		br.Msg = "获取研报列表失败"
		br.ErrMsg = "获取研报列表失败，Err:" + err.Error()
		return
	}
	page := paging.GetPaging(currentIndex, pageSize, total)
	resp := new(response.ReportPushStatusResp)
	resp.List = reportList
	resp.Paging = page

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

// PushCancel
// @Title 取消推送报告
// @Description 取消推送报告
// @Param	request	body request.ReportPdfEditReq true "type json string"
// @Success 200 {object} models.ReportAuthorResp
// @router /pushCancel [post]
func (this *ReportPushStatusController) PushCancel() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	var req request.ReportPushStatusReq
	if err := json.Unmarshal(this.Ctx.Input.RequestBody, &req); err != nil {
		br.Msg = "参数错误"
		br.ErrMsg = "参数错误，Err:" + err.Error()
		return
	}

	reportPush, err := models.GetReportPushStatusByReportId(req.ReportId, 1)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "推送失败"
		br.ErrMsg = "获取推送消息失败，Err:" + err.Error()
		return
	}
	if reportPush != nil {
		reportPush.State = 0
		reportPush.ModifyTime = time.Now()
		err = reportPush.Update([]string{"state", "modify_time"})
		if err != nil {
			br.Msg = "取消推送失败"
			br.ErrMsg = "取消推送失败，Err:" + err.Error()
			return
		}
	} else {
		reportPush := &models.ReportPushStatus{}
		reportPush.ReportId = req.ReportId
		reportPush.ReportType = 1
		reportPush.State = 0
		reportPush.CreateTime = time.Now()
		reportPush.ModifyTime = time.Now()
		_, err = reportPush.Insert()
		if err != nil {
			br.Msg = "取消推送失败"
			br.ErrMsg = "新增推送记录失败，Err:" + err.Error()
			return
		}
	}

	br.Msg = "取消推送成功"
	br.Success = true
	br.Ret = 200
}

// Push
// @Title 推送报告
// @Description 推送报告
// @Param	request	body request.ReportPdfEditReq true "type json string"
// @Success 200 {object} models.ReportAuthorResp
// @router /push [post]
func (this *ReportPushStatusController) Push() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	var req request.ReportPushStatusReq
	if err := json.Unmarshal(this.Ctx.Input.RequestBody, &req); err != nil {
		br.Msg = "参数错误"
		br.ErrMsg = "参数错误，Err:" + err.Error()
		return
	}

	count, err := models.GetReportCountById(req.ReportId)
	if err != nil {
		br.Msg = "研报未发布或已删除"
		br.ErrMsg = "研报查询失败，Err:" + err.Error()
		return
	}
	if count == 0 {
		br.Msg = "研报未发布或已删除"
		return
	}
	reportPush, err := models.GetReportPushStatusByReportId(req.ReportId, 0)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "推送失败"
		br.ErrMsg = "获取推送消息失败，Err:" + err.Error()
		return
	}
	if reportPush != nil {
		reportPush.State = 1
		reportPush.ModifyTime = time.Now()
		reportPush.PushTime = time.Now()
		err = reportPush.Update([]string{"state", "modify_time", "push_time"})
		if err != nil {
			br.Msg = "推送失败"
			br.ErrMsg = "推送失败，Err:" + err.Error()
			return
		}

	} else {
		reportPush := &models.ReportPushStatus{}
		reportPush.ReportId = req.ReportId
		reportPush.ReportType = 1
		reportPush.State = 1
		reportPush.PushTime = time.Now()
		reportPush.CreateTime = time.Now()
		reportPush.ModifyTime = time.Now()
		_, err = reportPush.Insert()
		if err != nil {
			br.Msg = "推送失败"
			br.ErrMsg = "推送失败，Err:" + err.Error()
			return
		}
	}

	br.Msg = "推送成功"
	br.Success = true
	br.Ret = 200
}

// BatchPush
// @Title 批量推送报告
// @Description 批量推送报告
// @Param	request	body request.BatchReportModifyPushStatusReq true "type json string"
// @Success 200 {object} models.ReportAuthorResp
// @router /batch/push [post]
func (this *ReportPushStatusController) BatchPush() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	var req request.BatchReportModifyPushStatusReq
	if err := json.Unmarshal(this.Ctx.Input.RequestBody, &req); err != nil {
		br.Msg = "参数错误"
		br.ErrMsg = "参数错误，Err:" + err.Error()
		return
	}
	var condition string
	var pars []interface{}
	if req.PublishStartDate != "" && req.PublishEndDate != "" {
		condition += " AND a.publish_time >= ?"
		publishStartTime, err := time.Parse(utils.FormatDate, req.PublishStartDate)
		if err != nil {
			br.Msg = "日期格式有误"
			br.ErrMsg = "日期格式有误，Err:" + err.Error()
			return
		}
		publishStartDateStr := publishStartTime.Format(utils.FormatDateTime)
		pars = append(pars, publishStartDateStr)

		condition += " AND a.publish_time <= ?"
		publishEndTime, err := time.Parse(utils.FormatDate, req.PublishEndDate)
		if err != nil {
			br.Msg = "日期格式有误"
			br.ErrMsg = "日期格式有误，Err:" + err.Error()
			return
		}
		publishEndTime = publishEndTime.Add(23*time.Hour + 59*time.Minute + 59*time.Second)
		publishEndDateStr := publishEndTime.Format(utils.FormatDateTime)
		pars = append(pars, publishEndDateStr)
	}
	if req.PushStartDate != "" && req.PushEndDate != "" {
		condition += " AND b.push_time >= ?"
		pushStartTime, err := time.Parse(utils.FormatDate, req.PushStartDate)
		if err != nil {
			br.Msg = "日期格式有误"
			br.ErrMsg = "日期格式有误，Err:" + err.Error()
			return
		}
		pushStartDateStr := pushStartTime.Format(utils.FormatDateTime)
		pars = append(pars, pushStartDateStr)

		condition += " AND b.push_time <= ?"
		pushEndTime, err := time.Parse(utils.FormatDate, req.PushEndDate)
		if err != nil {
			br.Msg = "日期格式有误"
			br.ErrMsg = "日期格式有误，Err:" + err.Error()
			return
		}
		pushEndTime = pushEndTime.Add(23*time.Hour + 59*time.Minute + 59*time.Second)
		pushEndDateStr := pushEndTime.Format(utils.FormatDateTime)
		pars = append(pars, pushEndDateStr)
	}
	if req.KeyWord != "" {
		condition += ` AND a.title like ?  `
		pars = utils.GetLikeKeywordPars(pars, req.KeyWord, 1)
	}
	classifyIdList := make([]int, 0)
	classifyIdList = append(classifyIdList, req.ClassifyIds...)
	tmpClassifyList, err := models.GetClassifyIdsListByIds(req.ChartPermissionIds)
	if err != nil {
		br.Msg = "获取研报列表失败"
		br.ErrMsg = "品种获取分类失败，Err:" + err.Error()
		return
	}
	classifyIdList = append(classifyIdList, tmpClassifyList...)
	if len(classifyIdList) > 0 {
		classifyIdList = utils.Unique(classifyIdList)
		condition += ` AND (a.classify_id_first IN (%s) AND a.classify_id_second IN (%s) AND a.classify_id_third IN (%s))`
		condition = fmt.Sprintf(condition, utils.GetOrmReplaceHolder(len(classifyIdList)), utils.GetOrmReplaceHolder(len(classifyIdList)), utils.GetOrmReplaceHolder(len(classifyIdList)))
		pars = append(pars, classifyIdList, classifyIdList, classifyIdList)
	}
	if req.IsSelectAll {
		if len(req.SelectedIds) > 0 {
			condition += ` AND a.id NOT IN (` + utils.GetOrmReplaceHolder(len(req.SelectedIds)) + `)`
			pars = append(pars, req.SelectedIds)
		}
	} else {
		if len(req.SelectedIds) > 0 {
			condition += ` AND a.id IN (` + utils.GetOrmReplaceHolder(len(req.SelectedIds)) + `)`
			pars = append(pars, req.SelectedIds)
		}
	}
	reportIds, err := models.GetReportIdListByCondition(condition, pars)
	if err != nil {
		br.Msg = "批量推送失败"
		br.ErrMsg = "查询研报失败，Err:" + err.Error()
		return
	}
	reportPush, err := models.GetReportPushStatusByReportIds(reportIds, 1)
	if err != nil {
		br.Msg = "批量推送失败"
		br.ErrMsg = "查询推送状态失败，Err:" + err.Error()
		return
	}
	existReportMap := make(map[int]struct{})
	for _, v := range reportPush {
		existReportMap[v.ReportId] = struct{}{}
	}
	existReportIds := make([]int, 0)
	noExistReportIds := make([]int, 0)
	for _, v := range reportIds {
		if _, ok := existReportMap[v]; !ok {
			noExistReportIds = append(noExistReportIds, v)
		} else {
			existReportIds = append(existReportIds, v)
		}
	}

	err = models.BatchPushReport(existReportIds)
	if err != nil {
		br.Msg = "批量推送失败"
		br.ErrMsg = "批量修改推送失败，Err:" + err.Error()
		return
	}
	insertReportPushList := make([]*models.ReportPushStatus, 0)
	for _, v := range noExistReportIds {
		insertReportPushList = append(insertReportPushList, &models.ReportPushStatus{
			ReportId:   v,
			State:      1,
			ReportType: 1,
			CreateTime: time.Now(),
			ModifyTime: time.Now(),
			PushTime:   time.Now(),
		})
	}
	obj := &models.ReportPushStatus{}
	err = obj.MultiInsert(insertReportPushList)
	if err != nil {
		br.Msg = "批量推送失败"
		br.ErrMsg = "批量插入推送状态失败，Err:" + err.Error()
		return
	}

	br.Msg = "推送成功"
	br.Success = true
	br.Ret = 200
}

// BatchPushCancel
// @Title 批量撤销推送报告
// @Description 批量撤销推送报告
// @Param	request	body request.BatchReportModifyPushStatusReq true "type json string"
// @Success 200 {object} models.ReportAuthorResp
// @router /batch/pushCancel [post]
func (this *ReportPushStatusController) BatchPushCancel() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	var req request.BatchReportModifyPushStatusReq
	if err := json.Unmarshal(this.Ctx.Input.RequestBody, &req); err != nil {
		br.Msg = "参数错误"
		br.ErrMsg = "参数错误，Err:" + err.Error()
		return
	}
	var condition string
	var pars []interface{}
	if req.PublishStartDate != "" && req.PublishEndDate != "" {
		condition += " AND a.publish_time >= ?"
		publishStartTime, err := time.Parse(utils.FormatDate, req.PublishStartDate)
		if err != nil {
			br.Msg = "日期格式有误"
			br.ErrMsg = "日期格式有误，Err:" + err.Error()
			return
		}
		publishStartDateStr := publishStartTime.Format(utils.FormatDateTime)
		pars = append(pars, publishStartDateStr)

		condition += " AND a.publish_time <= ?"
		publishEndTime, err := time.Parse(utils.FormatDate, req.PublishEndDate)
		if err != nil {
			br.Msg = "日期格式有误"
			br.ErrMsg = "日期格式有误，Err:" + err.Error()
			return
		}
		publishEndTime = publishEndTime.Add(23*time.Hour + 59*time.Minute + 59*time.Second)
		publishEndDateStr := publishEndTime.Format(utils.FormatDateTime)
		pars = append(pars, publishEndDateStr)
	}
	if req.PushStartDate != "" && req.PushEndDate != "" {
		condition += " AND b.push_time >= ?"
		pushStartTime, err := time.Parse(utils.FormatDate, req.PushStartDate)
		if err != nil {
			br.Msg = "日期格式有误"
			br.ErrMsg = "日期格式有误，Err:" + err.Error()
			return
		}
		pushStartDateStr := pushStartTime.Format(utils.FormatDateTime)
		pars = append(pars, pushStartDateStr)

		condition += " AND b.push_time <= ?"
		pushEndTime, err := time.Parse(utils.FormatDate, req.PushEndDate)
		if err != nil {
			br.Msg = "日期格式有误"
			br.ErrMsg = "日期格式有误，Err:" + err.Error()
			return
		}
		pushEndTime = pushEndTime.Add(23*time.Hour + 59*time.Minute + 59*time.Second)
		pushEndDateStr := pushEndTime.Format(utils.FormatDateTime)
		pars = append(pars, pushEndDateStr)
	}
	if req.KeyWord != "" {
		condition += ` AND a.title like ?  `
		pars = utils.GetLikeKeywordPars(pars, req.KeyWord, 1)
	}
	classifyIdList := make([]int, 0)
	classifyIdList = append(classifyIdList, req.ClassifyIds...)
	tmpClassifyList, err := models.GetClassifyIdsListByIds(req.ChartPermissionIds)
	if err != nil {
		br.Msg = "获取研报列表失败"
		br.ErrMsg = "品种获取分类失败，Err:" + err.Error()
		return
	}
	classifyIdList = append(classifyIdList, tmpClassifyList...)
	if len(classifyIdList) > 0 {
		classifyIdList = utils.Unique(classifyIdList)
		condition += ` AND (a.classify_id_first IN (%s) AND a.classify_id_second IN (%s) AND a.classify_id_third IN (%s))`
		condition = fmt.Sprintf(condition, utils.GetOrmReplaceHolder(len(classifyIdList)), utils.GetOrmReplaceHolder(len(classifyIdList)), utils.GetOrmReplaceHolder(len(classifyIdList)))
		pars = append(pars, classifyIdList, classifyIdList, classifyIdList)
	}
	if req.IsSelectAll {
		if len(req.SelectedIds) > 0 {
			condition += ` AND a.id NOT IN (` + utils.GetOrmReplaceHolder(len(req.SelectedIds)) + `)`
			pars = append(pars, req.SelectedIds)
		}
	} else {
		if len(req.SelectedIds) > 0 {
			condition += ` AND a.id IN (` + utils.GetOrmReplaceHolder(len(req.SelectedIds)) + `)`
			pars = append(pars, req.SelectedIds)
		}
	}
	reportIds, err := models.GetReportIdListByCondition(condition, pars)
	if err != nil {
		br.Msg = "批量推送失败"
		br.ErrMsg = "查询研报失败，Err:" + err.Error()
		return
	}
	reportPush, err := models.GetReportPushStatusByReportIds(reportIds, 1)
	if err != nil {
		br.Msg = "批量推送失败"
		br.ErrMsg = "查询推送状态失败，Err:" + err.Error()
		return
	}
	existReportMap := make(map[int]struct{})
	for _, v := range reportPush {
		existReportMap[v.ReportId] = struct{}{}
	}
	existReportIds := make([]int, 0)
	noExistReportIds := make([]int, 0)
	for _, v := range reportIds {
		if _, ok := existReportMap[v]; !ok {
			noExistReportIds = append(noExistReportIds, v)
		} else {
			existReportIds = append(existReportIds, v)
		}
	}

	err = models.BatchPushCancelReport(existReportIds)
	if err != nil {
		br.Msg = "批量取消推送失败"
		br.ErrMsg = "批量修改推送失败，Err:" + err.Error()
		return
	}
	insertReportPushList := make([]*models.ReportPushStatus, 0)
	for _, v := range noExistReportIds {
		insertReportPushList = append(insertReportPushList, &models.ReportPushStatus{
			ReportId:   v,
			State:      0,
			ReportType: 1,
			CreateTime: time.Now(),
			ModifyTime: time.Now(),
		})
	}
	obj := &models.ReportPushStatus{}
	err = obj.MultiInsert(insertReportPushList)
	if err != nil {
		br.Msg = "批量撤销推送失败"
		br.ErrMsg = "批量插入推送状态失败，Err:" + err.Error()
		return
	}

	br.Msg = "撤销推送成功"
	br.Success = true
	br.Ret = 200
}