hongze_yb_en_api/controller/english_report/english_report.go

package english_report

import (
	"encoding/json"
	"github.com/gin-gonic/gin"
	"github.com/go-playground/validator/v10"
	"hongze/hongze_yb_en_api/controller/resp"
	"hongze/hongze_yb_en_api/global"
	"hongze/hongze_yb_en_api/models/base"
	"hongze/hongze_yb_en_api/models/english_classify"
	"hongze/hongze_yb_en_api/models/english_report"
	elasticService "hongze/hongze_yb_en_api/services/elastic"
	english_report_service "hongze/hongze_yb_en_api/services/english_report"
	"hongze/hongze_yb_en_api/utils"
	"html"
	"strconv"
)

type EnglishReportController struct {}

func (er *EnglishReportController) List(c *gin.Context) {
	req := new(english_report.ReportListReq)
	err := c.BindQuery(&req)
	if err != nil {
		errs, ok := err.(validator.ValidationErrors)
		if !ok {
			resp.FailData("参数解析失败", "Err:"+err.Error(), c)
			return
		}
		resp.FailData("参数解析失败", errs.Translate(global.Trans), c)
		return
	}
	page := new(base.Page)
	page.SetPageSize(req.PageSize)
	page.SetCurrent(req.Current)
	item := new(english_report.Report)

	condition := " state=2"
	var pars []interface{}
	var total int64
	var tmpList []*english_report.Report
	var list []*english_report.ReportListItem

	if req.ClassifyIdFirst >0 {
		condition += " and classify_id_first = ?"
		pars = append(pars, req.ClassifyIdFirst)
	}
	if req.ClassifyIdSecond >0 {
		condition += " and classify_id_second = ?"
		pars = append(pars, req.ClassifyIdSecond)
	}
	page.AddOrderItem(base.OrderItem{Column: "publish_time", Asc: false})
	page.AddOrderItem(base.OrderItem{Column: "id", Asc: false})
	total, tmpList, err = item.SelectPage(page, condition, pars)
	if err != nil {
		resp.FailMsg("获取失败", "获取失败,Err:"+err.Error(), c)
		return
	}
	if len(tmpList) > 0 {
		for _, v := range tmpList {
			tmp := &english_report.ReportListItem{
				Id:                 v.Id,
				AddType:            v.AddType,
				ClassifyIdFirst:    v.ClassifyIdFirst,
				ClassifyNameFirst:  v.ClassifyNameFirst,
				ClassifyIdSecond:   v.ClassifyIdSecond,
				ClassifyNameSecond: v.ClassifyNameSecond,
				Title:              v.Title,
				Abstract:           v.Abstract,
				Author:             v.Author,
				Frequency:          v.Frequency,
				PublishTime:        utils.TimeTransferString(utils.FormatDateTime, v.PublishTime),
				Stage:              v.Stage,
				VideoUrl:           v.VideoUrl,
				VideoName:          v.VideoName,
				VideoPlaySeconds:   v.VideoPlaySeconds,
				ReportCode:         v.ReportCode,
				ShareUrl:           "https://share.hzinsights.com/reportEn?code=" + v.ReportCode,
				CreateTime:         utils.TimeTransferString(utils.FormatDateTime, v.CreateTime),
				ModifyTime:         utils.TimeTransferString(utils.FormatDateTime, v.ModifyTime),
			}
			list = append(list, tmp)
		}
	}
	page.SetTotal(total)
	baseData := new(base.BaseData)
	baseData.SetPage(page)
	baseData.SetList(list)
	resp.OkData("获取成功", baseData, c)
}

func (er *EnglishReportController) Classify(c *gin.Context) {
	item := new(english_classify.Classify)
	parentList, err := item.GetParent()
	if err != nil {
		resp.FailMsg("获取失败", "获取失败,Err:"+err.Error(), c)
		return
	}
	childList, err := item.GetChild()
	if err != nil {
		resp.FailMsg("获取失败", "获取失败,Err:"+err.Error(), c)
		return
	}
	parentMap := make(map[int][]*english_classify.ClassifyItem, 0)
	for _, v := range childList {
		tmp := &english_classify.ClassifyItem{
			Id:            v.Id,
			ClassifyName:  v.ClassifyName,
			Sort:          v.Sort,
			ParentId:      v.ParentId,
			ClassifyLabel: v.ClassifyLabel,
			ShowType:      v.ShowType,
			IsShow:        v.IsShow,
			CreateTime:    utils.TimeTransferString(utils.FormatDateTime, v.CreateTime),
			ModifyTime:    utils.TimeTransferString(utils.FormatDateTime, v.ModifyTime),
		}
		parentMap[v.ParentId] = append(parentMap[v.ParentId], tmp)
	}
	list := make([]*english_classify.ClassifyListItem, 0)
	for _, v := range parentList {
		tmp := &english_classify.ClassifyListItem{
			Id:            v.Id,
			ClassifyName:  v.ClassifyName,
			Sort:          v.Sort,
			ParentId:      v.ParentId,
			ClassifyLabel: v.ClassifyLabel,
			ShowType:      v.ShowType,
			IsShow:        v.IsShow,
			CreateTime:    utils.TimeTransferString(utils.FormatDateTime, v.CreateTime),
			ModifyTime:    utils.TimeTransferString(utils.FormatDateTime, v.ModifyTime),
		}
		if child, ok := parentMap[v.Id]; ok {
			tmp.Child = child
		}else{
			continue
		}
		list = append(list, tmp)
	}
	baseData := new(base.BaseOnlyData)
	baseData.SetList(list)
	resp.OkData("获取成功", baseData, c)
}

func (er *EnglishReportController) FilterByEs(c *gin.Context) {
	req := new(english_report.ReportSearchReq)
	err := c.BindQuery(&req)
	if err != nil {
		errs, ok := err.(validator.ValidationErrors)
		if !ok {
			resp.FailData("参数解析失败", "Err:"+err.Error(), c)
			return
		}
		resp.FailData("参数解析失败", errs.Translate(global.Trans), c)
		return
	}
	page := new(base.Page)
	page.SetPageSize(req.PageSize)
	page.SetCurrent(req.Current)

	if req.KeyWord == "" {
		resp.FailMsg("请输入搜索词", "", c)
		return
	}
	from := (req.Current - 1) * req.PageSize
	reportList := make([]*english_report.SearchEnglishReportItem, 0)
	searchResp, total, err := elasticService.SearchESEnglishReport(req.KeyWord, from, req.PageSize)
	if err != nil {
		resp.FailMsg("报告搜索失败", "报告搜索失败，Err:" + err.Error(), c)
		return
	}
	if searchResp.Hits != nil {
		for _, v := range searchResp.Hits.Hits {
			temp := new(english_report.SearchEnglishReportItem)
			itemJson, tmpErr := v.Source.MarshalJSON()
			if tmpErr != nil {
				resp.FailMsg("报告搜索失败 解析出错", "报告搜索失败，Err:" + tmpErr.Error(), c)
				return
			}
			reportItem := new(english_report.ElasticEnglishReportDetail)
			tmpErr = json.Unmarshal(itemJson, &reportItem)
			if tmpErr != nil {
				resp.FailMsg("报告搜索失败 解析出错", "报告搜索失败，Err:" + tmpErr.Error(), c)
				return
			}
			temp.Id = reportItem.ReportId
			temp.ClassifyIdFirst = reportItem.ClassifyIdFirst
			temp.ClassifyNameFirst = reportItem.ClassifyNameFirst
			temp.ClassifyIdSecond = reportItem.ClassifyIdSecond
			temp.ClassifyNameSecond = reportItem.ClassifyNameSecond
			temp.Title = reportItem.Title
			temp.Author = reportItem.Author
			temp.CreateTime = reportItem.CreateTime
			// 默认应该从数据库中查询
			temp.ContentSub = reportItem.ContentSub
			temp.PublishTime = reportItem.PublishTime
			temp.ReportCode = reportItem.ReportCode
			if len(v.Highlight["Title"]) > 0 {
				temp.Title = v.Highlight["Title"][0]
			}
			if len(v.Highlight["BodyContent"]) > 0 {
				temp.ContentSub = v.Highlight["BodyContent"][0]
			}

			temp.ContentSub = "<div style=\"-webkit-line-clamp: 3;-webkit-box-orient: vertical;display: -webkit-box;overflow: hidden;text-overflow: ellipsis;\">" + temp.ContentSub + "</div>"
			reportList = append(reportList, temp)
		}
	}
	page.SetTotal(total)
	baseData := new(base.BaseData)
	baseData.SetPage(page)
	baseData.SetList(reportList)
	resp.OkData("搜索成功", baseData, c)
}

func (er *EnglishReportController) Detail(c *gin.Context) {
	req := new(english_report.ReportDetailReq)
	err := c.BindQuery(&req)
	if err != nil {
		errs, ok := err.(validator.ValidationErrors)
		if !ok {
			resp.FailData("参数解析失败", "Err:"+err.Error(), c)
			return
		}
		resp.FailData("参数解析失败", errs.Translate(global.Trans), c)
		return
	}

	reportItem := new(english_report.Report)
	reportItem, err = reportItem.GetEnglishReportByCode(req.ReportCode)
	if err != nil {
		resp.FailMsg("该报告已删除", "报告查询失败，Err:" + err.Error(), c)
		return
	}
	err = reportItem.UpdatePvByReportCode(req.ReportCode)
	if err != nil {
		resp.FailMsg("更新失败", "更新失败，Err:" + err.Error(), c)
		return
	}
	reportItem.ContentSub = html.UnescapeString(reportItem.ContentSub)
	reportItem.Content = html.UnescapeString(reportItem.Content)

	shareEmailId := req.ShareEmail
	if shareEmailId == 0 {
		shareEmailIdStr := c.GetString("shareEmailId")
		shareEmailId, _ = strconv.Atoi(shareEmailIdStr)
	}
	// 记录邮箱
	if shareEmailId > 0 {
		go english_report_service.DealEmail(reportItem, req.ReportCode, shareEmailId)
	}
	reportDetail := &english_report.ReportDetail{
		Id:                 reportItem.Id,
		AddType:            reportItem.AddType,
		ClassifyIdFirst:    reportItem.ClassifyIdFirst,
		ClassifyNameFirst:  reportItem.ClassifyNameFirst,
		ClassifyIdSecond:   reportItem.ClassifyIdSecond,
		ClassifyNameSecond: reportItem.ClassifyNameSecond,
		Title:              reportItem.Title,
		Abstract:           reportItem.Abstract,
		Author:             reportItem.Author,
		Overview:           reportItem.Overview,
		Content:            reportItem.Content,
		ContentSub:         reportItem.ContentSub,
		Frequency:          reportItem.Frequency,
		PublishTime:        utils.TimeTransferString(utils.FormatDateTime, reportItem.PublishTime),
		Stage:              reportItem.Stage,
		VideoUrl:           reportItem.VideoUrl,
		VideoName:          reportItem.VideoName,
		VideoPlaySeconds:   reportItem.VideoPlaySeconds,
		VideoSize:          reportItem.VideoSize,
		ReportCode:         reportItem.ReportCode,
		CreateTime:         utils.TimeTransferString(utils.FormatDateTime, reportItem.CreateTime),
		ModifyTime:         utils.TimeTransferString(utils.FormatDateTime, reportItem.ModifyTime),
	}
	baseData := new(english_report.ReportDetailResp)
	baseData.Report = reportDetail
	resp.OkData("查询成功", baseData, c)
}