hongze_cygx/controllers/article.go

package controllers

import (
	"bufio"
	"github.com/pdfcpu/pdfcpu/pkg/api"
	"github.com/pdfcpu/pdfcpu/pkg/pdfcpu"
	"io"

	//"bufio"
	"encoding/json"
	"fmt"
	"github.com/medivhzhan/weapp/v2"
	"os"

	//"github.com/pdfcpu/pdfcpu/pkg/api"
	//"github.com/pdfcpu/pdfcpu/pkg/pdfcpu"
	"hongze/hongze_cygx/models"
	"hongze/hongze_cygx/services"
	"hongze/hongze_cygx/utils"
	"html"

	nhttp "net/http"
	//"os"
	"regexp"
	"strconv"
	"strings"
	"time"
)

type ArticleController struct {
	BaseAuthController
}

type ArticleCommonController struct {
	BaseCommonController
}

// @Title 获取报告详情
// @Description 获取报告详情接口
// @Param   ArticleId   query   int  true       "报告ID"
// @Success 200 {object} models.ArticleDetailResp
// @router /detail [get]
func (this *ArticleController) Detail() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	user := this.User
	if user == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，用户信息为空"
		br.Ret = 408
		return
	}

	uid := user.UserId
	articleId, err := this.GetInt("ArticleId")
	if articleId <= 0 {
		br.Msg = "文章不存在"
		br.ErrMsg = "文章不存在，文章ID错误"
		return
	}
	detail := new(models.ArticleDetail)
	hasPermission := 0
	hasFree := 0
	var haveResearch bool
	//判断是否已经申请过
	applyCount, err := models.GetApplyRecordCount(uid)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "获取信息失败"
		br.ErrMsg = "判断是否已申请过试用失败，Err:" + err.Error()
		return
	}
	//`description:"1:有该行业权限,正常展示，2：无该行业权限，不存在权益客户下，3:无该品类权限，4：潜在客户，未提交过申请，5：潜在客户,已提交过申请"`
	if user.CompanyId > 1 {
		companyPermission, err := models.GetCompanyPermission(user.CompanyId)
		if err != nil {
			br.Msg = "获取信息失败"
			br.ErrMsg = "判断是否已申请访谈失败，Err:" + strconv.Itoa(uid) + ";articleId" + strconv.Itoa(articleId)
			return
		}
		detail, err = models.GetArticleDetailById(articleId)
		if err != nil {
			br.Msg = "获取信息失败"
			br.ErrMsg = "获取信息失败,Err:" + err.Error()
			return
		}
		detail.Body = html.UnescapeString(detail.Body)
		detail.Body = strings.Replace(detail.Body, "<p data-f-id=\"pbf\" style=\"text-align: center; font-size: 14px; margin-top: 30px; opacity: 0.65; font-family: sans-serif;\">Powered by <a href=\"https://www.froala.com/wysiwyg-editor?pb=1\" title=\"Froala Editor\">Froala Editor</a></p>", "", -1)
		detail.Body = strings.Replace(detail.Body, "pre", "div", -1)
		//detail.Abstract = html.UnescapeString(detail.Abstract)
		detail.Abstract, _ = services.GetReportContentTextSub(detail.Abstract)
		if companyPermission == "" {
			if applyCount > 0 {
				hasPermission = 5
			} else {
				hasPermission = 2
			}
			hasFree = 2
			goto Loop
		} else {
			hasFree = 1
			var articlePermissionPermissionName string
			if detail.CategoryId > 0 {
				articlePermission, err := models.GetArticlePermission(detail.CategoryId)
				if err != nil {
					br.Msg = "获取信息失败"
					br.ErrMsg = "获取报告权限失败，Err:" + err.Error() + strconv.Itoa(uid) + ";articleId" + strconv.Itoa(articleId)
					return
				}
				if articlePermission == nil {
					br.Msg = "获取信息失败"
					br.ErrMsg = "报告权限不存在，Err:" + strconv.Itoa(uid) + ";articleId" + strconv.Itoa(articleId)
					return
				}
				articlePermissionPermissionName = articlePermission.PermissionName
			} else {
				articlePermissionPermissionName = detail.CategoryName
			}

			var hasPersion bool
			slice := strings.Split(articlePermissionPermissionName, ",")
			for _, v := range slice {
				if strings.Contains(companyPermission, v) {
					hasPersion = true
				}
			}
			if strings.Contains(detail.CategoryName, "研选") {
				detail.IsResearch = true
			}
			userType, _, err := services.GetUserType(user.CompanyId)
			if err != nil {
				br.Msg = "获取信息失败"
				br.ErrMsg = "获取用户信息失败,Err:" + err.Error()
				return
			}
			if userType == 1 && strings.Contains(detail.CategoryName, "研选") {
				hasPersion = false
			}

			if detail.IsReport == 1 {
				fmt.Println("报告权限")
				detailCategory, err := models.GetdetailByCategoryIdSando(detail.CategoryId)
				if err != nil && err.Error() != utils.ErrNoRow() {
					br.Msg = "获取信息失败"
					br.ErrMsg = "获取信息失败,Err:" + err.Error() + "categoryID 不存在：" + strconv.Itoa(detail.CategoryId)
					return
				}
				fmt.Println(detailCategory)
				permissionStr, err := models.GetCompanyPermissionByUser(user.CompanyId)
				if err != nil {
					br.Msg = "获取信息失败"
					br.ErrMsg = "获取客户信息失败,Err:" + err.Error()
					return
				}
				if detailCategory != nil {
					if detailCategory.PermissionType == 1 {
						if !strings.Contains(permissionStr, detailCategory.ChartPermissionName+"(主观)") {
							hasPersion = false
						}
					} else if detailCategory.PermissionType == 2 {
						if !strings.Contains(permissionStr, detailCategory.ChartPermissionName+"(客观)") {
							hasPersion = false
						}
					}
				}
			}
			if hasPersion {
				hasPermission = 1
				historyRecord := new(models.CygxArticleHistoryRecord)
				historyRecord.UserId = uid
				historyRecord.ArticleId = articleId
				historyRecord.CreateTime = time.Now()
				historyRecord.Mobile = user.Mobile
				historyRecord.Email = user.Email
				historyRecord.CompanyId = user.CompanyId
				historyRecord.CompanyName = user.CompanyName
				recordCount, _ := models.GetNoAddStoptimeArticleCount(uid, articleId)
				if recordCount == 0 {
					go models.AddCygxArticleHistoryRecord(historyRecord)
				} else {
					detailNew, err := models.GetNewArticleHistoryRecord(uid, articleId)
					if err != nil {
						br.Msg = "获取信息失败"
						br.ErrMsg = "获取信息失败,Err:" + err.Error()
						return
					}
					if detailNew.StopTime > 0 {
						go models.AddCygxArticleHistoryRecord(historyRecord)
					}
				}
			} else { //无该行业权限
				companyDetail, err := models.GetCompanyDetailById(user.CompanyId)
				if err == nil && companyDetail.ProductId == 1 {
					hasPermission = 2
				} else {
					hasPermission = 3
				}
			}
			if hasPermission == 1 {
				key := "CYGX_ARTICLE_" + strconv.Itoa(articleId) + "_" + strconv.Itoa(uid)
				if !utils.Rc.IsExist(key) {
					//新增浏览记录
					record := new(models.CygxArticleViewRecord)
					record.UserId = uid
					record.ArticleId = articleId
					record.CreateTime = time.Now()
					record.Mobile = user.Mobile
					record.Email = user.Email
					record.CompanyId = user.CompanyId
					record.CompanyName = user.CompanyName
					go models.AddCygxArticleViewRecord(record)
					utils.Rc.Put(key, 1, 5*time.Second)
					models.ModifyReportLastViewTime(uid)
				}
			}
		}

		collectCount, err := models.GetArticleCollectCount(uid, articleId)
		if err != nil && err.Error() != utils.ErrNoRow() {
			br.Msg = "获取信息失败"
			br.ErrMsg = "判断是否已收藏失败，Err:" + strconv.Itoa(uid) + ";articleId" + strconv.Itoa(articleId)
			return
		}
		if collectCount > 0 {
			detail.IsCollect = true
		}
		interviewApplyItem, err := models.GetArticleInterviewApply(uid, articleId)
		if err != nil && err.Error() != utils.ErrNoRow() {
			br.Msg = "获取信息失败"
			br.ErrMsg = "判断是否已申请访谈失败，Err:" + strconv.Itoa(uid) + ";articleId" + strconv.Itoa(articleId)
			return
		}
		if interviewApplyItem != nil && interviewApplyItem.InterviewApplyId > 0 {
			detail.IsInterviewApply = true
			detail.InterviewApplyStatus = interviewApplyItem.Status
		}
		//获取销售手机号
		sellerItem, err := models.GetSellerByCompanyId(user.CompanyId)
		if err != nil {
			br.Msg = "获取信息失败"
			br.ErrMsg = "获取销售数据失败2，Err:" + strconv.Itoa(uid) + ";articleId" + strconv.Itoa(articleId)
			return
		}
		if sellerItem != nil {
			detail.SellerMobile = sellerItem.Mobile
			detail.SellerName = sellerItem.RealName
		}
		sellerList, err := models.GetSellerList(articleId)
		if err != nil {
			br.Msg = "获取信息失败"
			br.ErrMsg = "获取销售数据失败，Err:" + err.Error() + strconv.Itoa(uid) + ";articleId" + strconv.Itoa(articleId)
			return
		}
		if detail.ArticleId >= utils.SummaryArticleId && strings.Contains(detail.SellerAndMobile, "-") {
			strnum := strings.Index(detail.SellerAndMobile, "-")
			detail.SellerAndMobile = detail.SellerAndMobile[0:strnum]
			if strnum > 0 {
				nickName := detail.SellerAndMobile[0:strnum]
				sellerAndMobile := &models.SellerRep{
					SellerMobile: "",
					SellerName:   nickName,
				}
				sellerList = append(sellerList, sellerAndMobile)
			}
		}
		detail.SellerList = sellerList
	} else { //潜在客户
		if applyCount > 0 {
			hasPermission = 5
		} else {
			hasPermission = 4
		}
	}
Loop:
	if hasPermission != 1 {
		detail.Body = ""
		detail.BodyText = ""
	} else {
		articleFollowdetail, err := models.GetArticleFollowDetail(articleId, uid)
		if err != nil {
			br.Msg = "获取信息失败"
			br.ErrMsg = "获取关注信息失败，Err:" + err.Error()
			return
		}
		detail.FollowNum = articleFollowdetail.DNum
		detail.CollectionNum = articleFollowdetail.AcNum
		if articleFollowdetail.MdNum > 0 {
			detail.IsFollow = true
		}
		if detail.IsSummary == 1 {
			detail.IsBelongSummary = true
		}
		if detail.IsReport == 1 {
			detail.IsBelongReport = true
		}
		haveResearch = true
	}

	fmt.Println("hasPermission", hasPermission)
	if hasPermission == 2 || hasPermission == 4 {
		//获取销售手机号
		sellerItemQy, err := models.GetSellerByCompanyIdCheckFicc(user.CompanyId, 2)
		if err != nil && err.Error() != utils.ErrNoRow() {
			br.Msg = "获取信息失败"
			br.ErrMsg = "获取销售信息失败,Err:" + err.Error()
			return
		}
		if sellerItemQy != nil {
			hasPermission = 3
			detail.SellerMobile = sellerItemQy.Mobile
			detail.SellerName = sellerItemQy.RealName
		}
	}
	resp := new(models.ArticleDetailResp)
	resp.HasPermission = hasPermission
	resp.HaveResearch = haveResearch
	resp.HasFree = hasFree
	resp.Detail = detail
	if user.Mobile != "" {
		resp.Mobile = user.Mobile
	} else {
		resp.Mobile = user.Email
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// @Title 收藏
// @Description 收藏
// @Param	request	body models.ArticleCollectReq true "type json string"
// @Success 200 {object} models.FontsCollectResp
// @router /collect [post]
func (this *ArticleController) ArticleCollect() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	user := this.User
	if user == nil {
		br.Msg = "请重新登录"
		br.Ret = 408
		return
	}
	uid := user.UserId
	var req models.ArticleCollectReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	count, err := models.GetArticleCollectCount(uid, req.ArticleId)
	if err != nil {
		br.Msg = "获取数据失败！"
		br.ErrMsg = "获取数据失败，Err:" + err.Error()
		return
	}
	resp := new(models.ArticleCollectResp)
	if count <= 0 {
		item := new(models.CygxArticleCollect)
		item.ArticleId = req.ArticleId
		item.UserId = uid
		item.CreateTime = time.Now()
		_, err = models.AddCygxArticleCollect(item)
		if err != nil {
			br.Msg = "收藏失败"
			br.ErrMsg = "收藏失败,Err:" + err.Error()
			return
		}
		br.Msg = "收藏成功"
		resp.Status = 1
	} else {
		err = models.RemoveArticleCollect(uid, req.ArticleId)
		if err != nil {
			br.Msg = "取消收藏失败"
			br.ErrMsg = "取消收藏失败,Err:" + err.Error()
			return
		}
		br.Msg = "已取消收藏"
		resp.Status = 2
	}
	collectTotal, err := models.GetArticleCollectUsersCount(req.ArticleId)
	if err != nil {
		br.Msg = "获取数据失败"
		br.ErrMsg = "获取数据失败，Err:" + err.Error()
		return
	}
	resp.CollectCount = collectTotal
	br.Ret = 200
	br.Success = true
	br.Data = resp
}

// @Title 访谈申请
// @Description 访谈申请
// @Param	request	body models.ArticleInterviewApplyReq true "type json string"
// @Success 200 {object} models.FontsCollectResp
// @router /interview/apply [post]
func (this *ArticleController) InterviewApply() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	user := this.User
	if user == nil {
		br.Msg = "请重新登录"
		br.Ret = 408
		return
	}
	uid := user.UserId
	var req models.ArticleInterviewApplyReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}

	article, err := models.GetArticleDetailById(req.ArticleId)
	if err != nil {
		br.Msg = "获取纪要失败！"
		br.ErrMsg = "获取纪要失败，Err:" + err.Error()
		return
	}

	count, err := models.GetArticleInterviewApplyCount(uid, req.ArticleId)
	if err != nil {
		br.Msg = "获取数据失败！"
		br.ErrMsg = "获取数据失败，Err:" + err.Error()
		return
	}
	resp := new(models.ArticleInterviewApplyResp)
	if count <= 0 {
		item := new(models.CygxInterviewApply)
		item.ArticleId = req.ArticleId
		item.UserId = uid
		item.CompanyId = user.CompanyId
		item.Status = "待邀请"
		item.Sort = 1
		item.ArticleTitle = article.Title
		item.CreateTime = time.Now()
		item.ModifyTime = time.Now()
		item.ArticleIdMd5 = article.ArticleIdMd5
		_, err = models.AddCygxInterviewApply(item)
		if err != nil {
			br.Msg = "申请失败"
			br.ErrMsg = "申请失败,Err:" + err.Error()
			return
		}
		br.Msg = "申请成功"
		resp.Status = 1
		//发送模板消息
		if user.CompanyId > 1 {
			mobile := user.Mobile
			if mobile == "" {
				mobile = user.Email
			}
			sellerItem, _ := models.GetSellerByCompanyId(user.CompanyId)
			if sellerItem != nil && sellerItem.AdminId > 0 && user.Mobile != "" {
				openIpItem, _ := models.GetUserRecordByUserIdByXzs(sellerItem.Mobile, 4)
				fmt.Println(openIpItem)
				if openIpItem != nil && openIpItem.OpenId != "" {
					go services.SendInterviewApplyTemplateMsg(user.RealName, sellerItem.CompanyName, mobile, article.Title, openIpItem.OpenId)
				}
			}
		}
	} else {
		err = models.RemoveArticleInterviewApply(uid, req.ArticleId)
		if err != nil {
			br.Msg = "取消申请失败"
			br.ErrMsg = "取消申请失败,Err:" + err.Error()
			return
		}
		br.Msg = "已取消申请"
		resp.Status = 2
		if user.CompanyId > 1 {
			mobile := user.Mobile
			if mobile == "" {
				mobile = user.Email
			}
			sellerItem, _ := models.GetSellerByCompanyId(user.CompanyId)
			if sellerItem != nil && sellerItem.AdminId > 0 && user.Mobile != "" {
				openIpItem, _ := models.GetUserRecordByUserIdByXzs(sellerItem.Mobile, 4)
				fmt.Println(openIpItem)
				if openIpItem != nil && openIpItem.OpenId != "" {
					go services.SendInterviewApplyCancelTemplateMsg(user.RealName, sellerItem.CompanyName, mobile, article.Title, openIpItem.OpenId)
				}
			}
		}
	}
	br.Ret = 200
	br.Success = true
	br.Data = resp
}

// @Title 获取报告详情
// @Description 获取报告详情接口
// @Param   ArticleIdMd5   query   int  true       "报告ID"
// @Success 200 {object} models.ArticleDetailResp
// @router /look/detail [get]
func (this *ArticleCommonController) Detail() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

	articleIdMd5 := this.GetString("ArticleIdMd5")
	if articleIdMd5 == "" {
		br.Msg = "参数错误"
		br.ErrMsg = "参数错误"
		return
	}
	resp := new(models.ArticleDetailResp)
	detail, err := models.GetArticleDetailByIdMd5(articleIdMd5)
	if err != nil {
		br.Msg = "获取信息失败"
		br.ErrMsg = "获取信息失败,Err:" + err.Error()
		return
	}
	detail.Body = html.UnescapeString(detail.Body)
	//detail.Abstract = html.UnescapeString(detail.Abstract)
	sellerList, err := models.GetSellerList(detail.ArticleId)
	if err != nil {
		br.Msg = "获取信息失败"
		br.ErrMsg = "获取销售数据失败，Err:" + err.Error() + ";articleId" + strconv.Itoa(detail.ArticleId)
		return
	}
	if detail.ArticleId > 1000000 {
		var hrefRegexp = regexp.MustCompile("[0-9]\\d*")
		match := hrefRegexp.FindAllString(detail.SellerAndMobile, -1)
		if match != nil {
			for _, v := range match {
				sellerAndMobile := &models.SellerRep{
					SellerMobile: v,
					SellerName:   strings.Replace(detail.SellerAndMobile, v, "", -1),
				}
				sellerList = append(sellerList, sellerAndMobile)
			}
		}
	}
	resp.HasPermission = 1
	detail.Abstract, _ = services.GetReportContentTextSub(detail.Abstract)
	detail.SellerList = sellerList
	resp.Detail = detail
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// @Title 上传文章阅读时间
// @Description 上传文章阅读时间接口
// @Param  request	body models.AddStopTimeRep true "type json string"
// @Success 200 {object} models.ArticleDetailResp
// @router /addStopTime [post]
func (this *ArticleController) AddStopTime() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	user := this.User
	if user == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，用户信息为空"
		br.Ret = 408
		return
	}
	var req models.AddStopTimeRep
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	uid := user.UserId
	articleId := req.ArticleId
	stopTime := req.StopTime
	outType := req.OutType
	source := req.Source
	if articleId <= 0 {
		br.Msg = "参数错误"
		br.ErrMsg = "参数错误"
		return
	}
	if stopTime == 0 {
		stopTime = 1
	}
	if outType != 2 {
		outType = 1
	}
	if source != "PC" {
		source = "MOBILE"
	}

	detail := new(models.ArticleDetail)
	hasPermission := 0
	hasFree := 0

	//判断是否已经申请过
	applyCount, err := models.GetApplyRecordCount(uid)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "获取信息失败"
		br.ErrMsg = "判断是否已申请过试用失败，Err:" + err.Error()
		return
	}
	//`description:"1:有该行业权限,正常展示，2：无该行业权限，不存在权益客户下，3:无该品类权限，4：潜在客户，未提交过申请，5：潜在客户,已提交过申请"`
	if user.CompanyId > 1 {
		companyPermission, err := models.GetCompanyPermission(user.CompanyId)
		if err != nil {
			br.Msg = "获取信息失败"
			br.ErrMsg = "判断是否已申请访谈失败，Err:" + strconv.Itoa(uid) + ";articleId" + strconv.Itoa(articleId)
			return
		}
		detail, err = models.GetArticleDetailById(articleId)
		if err != nil {
			br.Msg = "获取信息失败"
			br.ErrMsg = "获取文章信息失败,Err:" + err.Error() + strconv.Itoa(uid) + ";articleId" + strconv.Itoa(articleId)
			return
		}
		if companyPermission == "" {
			if applyCount > 0 {
				hasPermission = 5
			} else {
				hasPermission = 2
			}
			hasFree = 2
			goto Loop
		} else {
			hasFree = 1
			var articlePermissionPermissionName string
			if detail.CategoryId > 0 {
				articlePermission, err := models.GetArticlePermission(detail.CategoryId)
				if err != nil {
					br.Msg = "获取信息失败"
					br.ErrMsg = "获取报告权限失败，Err:" + err.Error() + strconv.Itoa(uid) + ";articleId" + strconv.Itoa(articleId)
					return
				}
				if articlePermission == nil {
					br.Msg = "获取信息失败"
					br.ErrMsg = "报告权限不存在，Err:" + strconv.Itoa(uid) + ";articleId" + strconv.Itoa(articleId)
					return
				}
				articlePermissionPermissionName = articlePermission.PermissionName
			} else {
				articlePermissionPermissionName = detail.CategoryName
			}
			var hasPersion bool
			slice := strings.Split(articlePermissionPermissionName, ",")
			for _, v := range slice {
				if strings.Contains(companyPermission, v) {
					hasPersion = true
				}
			}
			if hasPersion {
				detailNew, err := models.GetNewArticleHistoryRecord(uid, articleId)
				if err == nil {
					hasPermission = 1
					historyRecord := new(models.AddStopTimeNewRep)
					historyRecord.StopTime = detailNew.StopTime + stopTime
					historyRecord.Id = detailNew.Id
					historyRecord.OutType = outType
					go models.UpdateArticleStopTime(historyRecord)
				}

				//不统计本公司的阅读记录、正常退出的不做时间差统计
				if user.CompanyId != 16 && stopTime > 3 {
					key := "CYGX_ARTICLE_PV" + strconv.Itoa(articleId) + "_" + strconv.Itoa(uid) + "_" + strconv.Itoa(user.CompanyId) + "_" + strconv.Itoa(outType)
					record := new(models.CygxArticleHistoryRecordNewpv)
					record.UserId = uid
					record.ArticleId = articleId
					record.CreateTime = time.Now().Add(-time.Second * time.Duration(stopTime))
					record.ModifyTime = time.Now()
					record.Mobile = user.Mobile
					record.Email = user.Email
					record.CompanyId = user.CompanyId
					record.CompanyName = user.CompanyName
					record.StopTime = stopTime
					record.OutType = outType
					record.Source = source
					if !utils.Rc.IsExist(key) || outType != 2 {
						//新增浏览记录
						go models.AddCygxArticleViewRecordNewpv(record)
						recordRedis := new(services.ReportViewRecord)
						recordRedis.UserId = user.UserId
						recordRedis.ReportId = articleId
						recordRedis.Mobile = user.Mobile
						recordRedis.Email = user.Email
						recordRedis.RealName = user.RealName
						recordRedis.CompanyName = user.CompanyName
						recordRedis.CreateTime = time.Now().Add(-time.Second * time.Duration(stopTime))
						go services.PushViewRecordNewRedisData(recordRedis, user.CompanyId)
					} else {
						go models.UpdateCygxArticleViewRecordNewpv(record, stopTime)
					}
					utils.Rc.Put(key, 1, 10*time.Minute)
				}

				models.ModifyReportLastViewTime(uid)
			} else { //无该行业权限
				hasPermission = 3
			}
		}
	} else { //潜在客户
		if applyCount > 0 {
			hasPermission = 5
		} else {
			hasPermission = 4
		}
	}
Loop:
	resp := new(models.ArticleDetailAddStopTimeRep)
	resp.HasPermission = hasPermission
	resp.HasFree = hasFree
	br.Ret = 200
	br.Success = true
	br.Msg = "操作成功"
	br.Data = resp
}

// @Title 文章带问
// @Description 新增文章带问接口
// @Param	request	body models.AddArticleAskRep true "type json string"
// @Success Ret=200 新增成功
// @router /askAdd [post]
func (this *ArticleController) AskAdd() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	user := this.User
	if user == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req models.AddArticleAskRep
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if req.Content == "" {
		br.Msg = "建议内容不可为空"
		return
	}

	content := req.Content
	itemToken, err := services.WxGetToken()
	if err != nil {
		br.Msg = "GetWxAccessToken Err:" + err.Error()
		return
	}
	if itemToken.AccessToken == "" {
		br.Msg = "accessToken is empty"
		return
	}
	commerr, err := weapp.MSGSecCheck(itemToken.AccessToken, content)
	if err != nil {
		br.Msg = "内容校验失败！"
		br.ErrMsg = "内容校验失败，Err:" + err.Error()

		return
	}
	if commerr.ErrCode != 0 {
		br.Msg = "内容违规,请重新提交！"
		br.ErrMsg = "颜文字内容违规，Err:" + commerr.ErrMSG
		return
	}

	articleId := req.ArticleId
	count, _ := models.GetArticleCountById(articleId)
	if count == 0 {
		br.Msg = "操作失败"
		br.ErrMsg = "文章ID错误,不存在 articleId：" + strconv.Itoa(articleId)
		return
	}
	companyDetail, err := models.GetCompanyDetailById(user.CompanyId)
	if err != nil {
		br.Msg = "提交失败！"
		br.ErrMsg = "获取客户详情失败，Err:" + err.Error()
		return
	}
	if companyDetail == nil {
		br.Msg = "提交失败！"
		br.ErrMsg = "客户不存在，uid:" + strconv.Itoa(user.UserId)
		return
	}
	item := new(models.CygxArticleAsk)
	item.UserId = user.UserId
	item.ArticleId = req.ArticleId
	item.CompanyId = user.CompanyId
	item.CompanyName = companyDetail.CompanyName
	item.CreateTime = time.Now()
	item.Mobile = user.Mobile
	item.Email = user.Email
	item.Content = content
	_, err = models.AddArticleAsk(item)
	if err != nil {
		br.Msg = "提交失败"
		br.ErrMsg = "提交失败,Err:" + err.Error()
		return
	}
	companyItem, err := models.GetSellerDetailAllByCompanyId(user.CompanyId)
	if err != nil {
		br.Msg = "获取信息失败"
		br.ErrMsg = "获取所属销售信息失败,Err:" + err.Error()
		return
	}
	var mobile string
	if utils.RunMode == "release" {
		//mobile = utils.WxMsgTemplateIdAskMsgMobileAll + "," + companyItem.Mobile
		mobile = utils.WxMsgTemplateIdAskMsgMobileAll
	} else {
		mobile = utils.WxMsgTemplateIdAskMsgMobile
	}
	openIdList, err := models.GetWxOpenIdByMobileList(mobile)
	if err != nil {
		br.Msg = "提交失败"
		br.ErrMsg = "提交失败,Err:" + err.Error()
		return
	}
	detail, err := models.GetArticleDetailById(articleId)
	if err != nil {
		br.Msg = "获取信息失败"
		br.ErrMsg = "获取信息失败,Err:" + err.Error()
		return
	}
	companyName := user.CompanyName + "-" + user.RealName + "（" + companyItem.SellerName + "）"
	go services.SendWxMsgWithAsk(companyName, time.Now().Format(utils.FormatDateTime), content, detail.Title, openIdList, req.ArticleId)
	br.Ret = 200
	br.Success = true
	br.Msg = "提交成功"
}

// @Title 下载PDF打水印
// @Description 下载PDF打水印接口
// @Param   ArticleId   query   int  true       "报告ID"
// @Success 200 {object} models.ArticleDetailFileLink
// @router /pdfwatermark [get]
func (this *ArticleController) Pdfwatermark() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	user := this.User
	if user == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，用户信息为空"
		br.Ret = 408
		return
	}
	uid := user.UserId
	articleId, err := this.GetInt("ArticleId")
	if articleId <= 0 {
		br.Msg = "文章不存在"
		br.ErrMsg = "文章不存在，文章ID错误"
		return
	}
	//缓存校验
	cacheKey := fmt.Sprint("xygx:apply_record:add:", uid, "ArticleId_", articleId)
	ttlTime := utils.Rc.GetRedisTTL(cacheKey)
	if ttlTime > 0 {
		br.Msg = "下载失败，下载过于频繁"
		br.ErrMsg = "下载失败，下载过于频繁:mobile" + user.Mobile
		return
	}

	detail := new(models.ArticleDetail)
	detail, err = models.GetArticleDetailById(articleId)
	if err != nil {
		br.Msg = "获取信息失败"
		br.ErrMsg = "获取信息失败,Err:" + err.Error()
		return
	}
	fileLink := detail.FileLink
	if fileLink == "" {
		br.Msg = "下载失败"
		br.ErrMsg = "下载失败,报告链接不存在"
		return
	}
	mobile := user.Mobile
	if mobile == "" {
		mobile = user.Email
	}
	sliceLink := strings.Split(fileLink, "/")
	uploadDir := "static/pdf/"
	//判断文件夹是否存在，不存在则创建
	if !utils.FileIsExist(uploadDir) {
		err = os.MkdirAll(uploadDir, 0755)
		if err != nil {
			br.Msg = "下载失败"
			br.ErrMsg = "存储目录创建失败,Err:" + err.Error()
			return
		}
	}
	var oldFile string
	var newFile string
	//获取PDF源文件名称
	pdfName := sliceLink[len(sliceLink)-1]
	pdfName = utils.MD5(pdfName) + ".pdf"
	oldFile = uploadDir + pdfName
	//判断PDF本地是否存在，不存在则保存到本地
	if !utils.FileIsExist(oldFile) {
		res, err := nhttp.Get(fileLink)
		if err != nil {
			br.Msg = "下载失败"
			br.ErrMsg = "获取源文件失败,Err:" + err.Error()
			return
		}
		defer res.Body.Close()
		// 获得get请求响应的reader对象
		reader := bufio.NewReaderSize(res.Body, 32*1024)
		file, err := os.Create(oldFile)
		if err != nil {
			br.Msg = "下载失败"
			br.ErrMsg = "保存源文件到本地失败,Err:" + err.Error()
			return
		}
		defer file.Close()
		//获得文件的writer对象
		writer := bufio.NewWriter(file)
		written, _ := io.Copy(writer, reader)
		fmt.Printf("Total length: %d", written)

	}
	newFile = uploadDir + "new_" + pdfName
	onTop := true
	wm, err := pdfcpu.ParseTextWatermarkDetails(mobile, " op:.4, pos:c ,points:16 ", onTop, 1)
	if err != nil {
		br.Msg = "下载失败"
		br.ErrMsg = "生成水印文件失败，Err:" + err.Error()
		return
	}
	err = api.AddWatermarksFile(oldFile, newFile, nil, wm, nil)
	if err != nil {
		br.Msg = "下载失败"
		br.ErrMsg = "生成水印PDF失败，Err:" + err.Error()
		return
	}
	resp := new(models.ArticleDetailFileLink)
	randStr := utils.GetRandStringNoSpecialChar(28)
	fileName := randStr + ".pdf"
	savePath := uploadDir + time.Now().Format("200601/20060102/")
	savePath += fileName
	//上传到阿里云
	err = services.UploadFileToAliyun(fileName, newFile, savePath)
	if err != nil {
		br.Msg = "下载失败"
		br.ErrMsg = "文件上传失败，Err:" + err.Error()
		return
	}
	fileHost := "https://hzstatic.hzinsights.com/"
	resourceUrl := fileHost + savePath
	defer func() {
		os.Remove(newFile)
	}()

	utils.Rc.SetNX(cacheKey, user.Mobile, time.Minute*5)
	resp.FileLink = resourceUrl
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// @Title 获取报告详情（无需token）
// @Description 获取报告详情接口
// @Param   ArticleId   query   int  true       "报告ID"
// @Param   CompanyCode     query string  false       "机构编号"
// @Param   CompanyName     query string  false       "机构名称"
// @Param   Email     query string  false       "邮箱"
// @Param   Sign   query   string  false       "加密签名"
// @Success 200 {object} models.ArticleDetailHtgjResp
// @router /detailPublic [get]
func (this *ArticleCommonController) DetailPublic() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

	articleId, _ := this.GetInt("ArticleId")
	companyCode := this.GetString("CompanyCode")
	companyNameHt := this.GetString("CompanyName")
	email := this.GetString("Email")
	sign := this.GetString("Sign")
	resp := new(models.ArticleDetailHtgjResp)
	if companyCode == "" || email == "" {
		resp.HasPermission = 2
		br.Ret = 200
		br.Success = true
		br.Msg = "获取成功"
		br.Data = resp
		return
	}
	if articleId <= 0 {
		br.Msg = "文章不存在"
		br.ErrMsg = "文章不存在，文章ID错误"
		return
	}

	errMsg, err, wxUser, companyName := services.CheckHtgj(companyCode, companyNameHt, email, sign)

	if errMsg != "" {
		br.Msg = errMsg
		return
	}
	companyPermission, err := models.GetCompanyPermission(wxUser.CompanyId)
	if err != nil {
		br.Msg = "获取信息失败"
		br.ErrMsg = "获取用户权限失败，Err:" + err.Error() + ";articleId" + strconv.Itoa(articleId)
		return
	}
	hasPermission := 0

	detail, err := models.GetArticleDetailById(articleId)
	if err != nil {
		br.Msg = "获取信息失败"
		br.ErrMsg = "获取信息失败,Err:" + err.Error()
		return
	}
	detail.Body = html.UnescapeString(detail.Body)
	detail.Body = strings.Replace(detail.Body, "<p data-f-id=\"pbf\" style=\"text-align: center; font-size: 14px; margin-top: 30px; opacity: 0.65; font-family: sans-serif;\">Powered by <a href=\"https://www.froala.com/wysiwyg-editor?pb=1\" title=\"Froala Editor\">Froala Editor</a></p>", "", -1)
	detail.Body = strings.Replace(detail.Body, "pre", "div", -1)
	detail.Abstract, _ = services.GetReportContentTextSub(detail.Abstract)

	var articlePermissionPermissionName string
	if detail.CategoryId > 0 {
		articlePermission, err := models.GetArticlePermission(detail.CategoryId)
		if err != nil {
			br.Msg = "获取信息失败"
			br.ErrMsg = "获取报告权限失败，Err:" + err.Error() + strconv.Itoa(wxUser.UserId) + ";articleId" + strconv.Itoa(articleId)
			return
		}
		if articlePermission == nil {
			br.Msg = "获取信息失败"
			br.ErrMsg = "报告权限不存在，Err:" + strconv.Itoa(wxUser.UserId) + ";articleId" + strconv.Itoa(articleId)
			return
		}
		articlePermissionPermissionName = articlePermission.PermissionName
	} else {
		articlePermissionPermissionName = detail.CategoryName
	}
	var hasPersion bool
	slice := strings.Split(articlePermissionPermissionName, ",")
	for _, v := range slice {
		if strings.Contains(companyPermission, v) {
			hasPersion = true
		}
	}
	if hasPersion {
		hasPermission = 1
	}
	if strings.Contains(detail.CategoryName, "研选") {
		detail.IsResearch = true
	}

	resp.HasPermission = hasPermission
	if hasPermission == 1 {
		//获取销售手机号
		sellerItem, err := models.GetSellerByCompanyId(wxUser.CompanyId)
		if err != nil {
			br.Msg = "获取信息失败"
			br.ErrMsg = "获取销售数据失败2，Err:" + strconv.Itoa(wxUser.UserId) + ";articleId" + strconv.Itoa(articleId)
			return
		}
		if sellerItem != nil {
			detail.SellerMobile = sellerItem.Mobile
			detail.SellerName = sellerItem.RealName
		}
		sellerList, err := models.GetSellerList(articleId)
		if err != nil {
			br.Msg = "获取信息失败"
			br.ErrMsg = "获取销售数据失败，Err:" + err.Error() + strconv.Itoa(wxUser.UserId) + ";articleId" + strconv.Itoa(articleId)
			return
		}
		if detail.ArticleId >= utils.SummaryArticleId && strings.Contains(detail.SellerAndMobile, "-") {
			strnum := strings.Index(detail.SellerAndMobile, "-")
			detail.SellerAndMobile = detail.SellerAndMobile[0:strnum]
			if strnum > 0 {
				nickName := detail.SellerAndMobile[0:strnum]
				sellerAndMobile := &models.SellerRep{
					SellerMobile: "",
					SellerName:   nickName,
				}
				sellerList = append(sellerList, sellerAndMobile)
			}
		}
		detail.SellerList = sellerList
		resp.Detail = detail
		historyRecord := new(models.CygxArticleHistoryRecord)
		historyRecord.UserId = wxUser.UserId
		historyRecord.ArticleId = articleId
		historyRecord.CreateTime = time.Now()
		historyRecord.Mobile = wxUser.Mobile
		historyRecord.Email = wxUser.Email
		historyRecord.CompanyId = wxUser.CompanyId
		historyRecord.CompanyName = companyName
		recordCount, _ := models.GetNoAddStoptimeArticleCount(wxUser.UserId, articleId)
		if recordCount == 0 {
			go models.AddCygxArticleHistoryRecord(historyRecord)
		} else {
			detailNew, err := models.GetNewArticleHistoryRecord(wxUser.UserId, articleId)
			if err != nil {
				br.Msg = "获取信息失败"
				br.ErrMsg = "获取信息失败,Err:" + err.Error()
				return
			}
			if detailNew.StopTime > 0 {
				go models.AddCygxArticleHistoryRecord(historyRecord)
			}
		}
		key := "CYGX_ARTICLE_" + strconv.Itoa(articleId) + "_" + strconv.Itoa(wxUser.UserId)
		if !utils.Rc.IsExist(key) {
			//新增浏览记录
			record := new(models.CygxArticleViewRecord)
			record.UserId = wxUser.UserId
			record.ArticleId = articleId
			record.CreateTime = time.Now()
			record.Mobile = wxUser.Mobile
			record.Email = wxUser.Email
			record.CompanyId = wxUser.CompanyId
			record.CompanyName = companyName
			go models.AddCygxArticleViewRecord(record)
			utils.Rc.Put(key, 1, 5*time.Second)
			models.ModifyReportLastViewTime(wxUser.UserId)
		}
	}
	resp.CompanyName = companyName
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// @Title 上传文章阅读时间（无需token）
// @Description 上传文章阅读时间接口（无需token）
// @Param  request	body models.AddStopTimeHtgjRep true "type json string"
// @Success 200 {object} models.ArticleDetailResp
// @router /addStopTimePublic [post]
func (this *ArticleCommonController) AddStopTimePublic() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

	var req models.AddStopTimeHtgjRep
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	articleId := req.ArticleId
	stopTime := req.StopTime
	outType := req.OutType
	source := req.Source
	companyCode := req.CompanyCode
	companyName := req.CompanyName
	wxuUserName := req.Email
	sign := req.Sign
	if companyCode == "" || companyName == "" || wxuUserName == "" || sign == "" {
		br.Msg = "上传失败"
		br.ErrMsg = "必填参数不能为空"
		return
	}
	companyNameHt := companyCode[0:4] + "_" + companyName
	errMsg := services.CheckSign(companyCode+companyName+wxuUserName, sign)
	if errMsg != "" {
		br.Msg = errMsg
		return
	}
	companyInfo, err := models.GetCompanyByName(companyNameHt)
	if err != nil {
		br.Msg = "获取信息失败"
		br.ErrMsg = "获取客户信息失败，Err:" + err.Error()
		return
	}
	user, err := models.GetUserByName(companyInfo.CompanyId, wxuUserName)
	if err != nil {
		br.Msg = "获取信息失败"
		br.ErrMsg = "获取用户信息失败，Err:" + err.Error()
		return
	}
	uid := user.UserId
	if articleId <= 0 {
		br.Msg = "文章ID不存在"
		br.ErrMsg = "参数错误"
		return
	}
	if stopTime == 0 {
		stopTime = 1
	}
	if outType != 2 {
		outType = 1
	}
	if source != "PC" {
		source = "MOBILE"
	}
	detail := new(models.ArticleDetail)
	hasPermission := 0
	hasFree := 0
	//判断是否已经申请过
	applyCount, err := models.GetApplyRecordCount(uid)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "获取信息失败"
		br.ErrMsg = "判断是否已申请过试用失败，Err:" + err.Error()
		return
	}
	//`description:"1:有该行业权限,正常展示，2：无该行业权限，不存在权益客户下，3:无该品类权限，4：潜在客户，未提交过申请，5：潜在客户,已提交过申请"`
	if user.CompanyId > 1 {
		companyPermission, err := models.GetCompanyPermission(user.CompanyId)
		if err != nil {
			br.Msg = "获取信息失败"
			br.ErrMsg = "判断是否已申请访谈失败，Err:" + strconv.Itoa(uid) + ";articleId" + strconv.Itoa(articleId)
			return
		}
		detail, err = models.GetArticleDetailById(articleId)
		if err != nil {
			br.Msg = "获取信息失败"
			br.ErrMsg = "获取文章信息失败,Err:" + err.Error() + strconv.Itoa(uid) + ";articleId" + strconv.Itoa(articleId)
			return
		}
		if companyPermission == "" {
			if applyCount > 0 {
				hasPermission = 5
			} else {
				hasPermission = 2
			}
			hasFree = 2
			goto Loop
		} else {
			hasFree = 1
			var articlePermissionPermissionName string
			if detail.CategoryId > 0 {
				articlePermission, err := models.GetArticlePermission(detail.CategoryId)
				if err != nil {
					br.Msg = "获取信息失败"
					br.ErrMsg = "获取报告权限失败，Err:" + err.Error() + strconv.Itoa(uid) + ";articleId" + strconv.Itoa(articleId)
					return
				}
				if articlePermission == nil {
					br.Msg = "获取信息失败"
					br.ErrMsg = "报告权限不存在，Err:" + strconv.Itoa(uid) + ";articleId" + strconv.Itoa(articleId)
					return
				}
				articlePermissionPermissionName = articlePermission.PermissionName
			} else {
				articlePermissionPermissionName = detail.CategoryName
			}
			var hasPersion bool
			slice := strings.Split(articlePermissionPermissionName, ",")
			for _, v := range slice {
				if strings.Contains(companyPermission, v) {
					hasPersion = true
				}
			}
			if hasPersion {
				detailNew, err := models.GetNewArticleHistoryRecord(uid, articleId)
				if err == nil {
					hasPermission = 1
					historyRecord := new(models.AddStopTimeNewRep)
					historyRecord.StopTime = detailNew.StopTime + stopTime
					historyRecord.Id = detailNew.Id
					historyRecord.OutType = outType
					go models.UpdateArticleStopTime(historyRecord)
				}

				//不统计本公司的阅读记录、正常退出的不做时间差统计
				if user.CompanyId != 16 && stopTime > 3 {
					key := "CYGX_ARTICLE_PV" + strconv.Itoa(articleId) + "_" + strconv.Itoa(uid) + "_" + strconv.Itoa(user.CompanyId) + "_" + strconv.Itoa(outType)
					record := new(models.CygxArticleHistoryRecordNewpv)
					record.UserId = uid
					record.ArticleId = articleId
					record.CreateTime = time.Now().Add(-time.Second * time.Duration(stopTime))
					record.ModifyTime = time.Now()
					record.Mobile = user.Mobile
					record.Email = user.Email
					record.CompanyId = user.CompanyId
					record.CompanyName = companyInfo.CompanyName
					record.StopTime = stopTime
					record.OutType = outType
					record.Source = source
					if !utils.Rc.IsExist(key) || outType != 2 {
						//新增浏览记录
						go models.AddCygxArticleViewRecordNewpv(record)
						recordRedis := new(services.ReportViewRecord)
						recordRedis.UserId = user.UserId
						recordRedis.ReportId = articleId
						recordRedis.Mobile = user.Mobile
						recordRedis.Email = user.Email
						recordRedis.RealName = user.RealName
						recordRedis.CompanyName = companyName
						recordRedis.CreateTime = time.Now().Add(-time.Second * time.Duration(stopTime))
						go services.PushViewRecordNewRedisData(recordRedis, user.CompanyId)
					} else {
						go models.UpdateCygxArticleViewRecordNewpv(record, stopTime)
					}
					utils.Rc.Put(key, 1, 10*time.Minute)
				}

				models.ModifyReportLastViewTime(uid)
			} else { //无该行业权限
				hasPermission = 3
			}
		}
	} else { //潜在客户
		if applyCount > 0 {
			hasPermission = 5
		} else {
			hasPermission = 4
		}
	}
Loop:
	resp := new(models.ArticleDetailAddStopTimeRep)
	resp.HasPermission = hasPermission
	resp.HasFree = hasFree
	br.Ret = 200
	br.Success = true
	br.Msg = "操作成功"
	br.Data = resp
}

// @Title 页面访问统计（无需token）
// @Description 上传页面访问统计（无需token）
// @Param	request	body models.CygxPageHistoryRecordHtgjRep true "type json string"
// @Success Ret=200 新增成功
// @router /pageHistoryPublic [post]
func (this *ArticleCommonController) PageHistoryPublic() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

	var req models.CygxPageHistoryRecordHtgjRep
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	companyCode := req.CompanyCode
	companyName := req.CompanyName
	wxuUserName := req.Email
	sign := req.Sign
	if companyCode == "" || companyName == "" || wxuUserName == "" || sign == "" {
		br.Msg = "上传失败"
		br.ErrMsg = "必填参数不能为空"
		return
	}
	companyNameHt := companyCode[0:4] + "_" + companyName
	errMsg := services.CheckSign(companyCode+companyName+wxuUserName, sign)
	if errMsg != "" {
		br.Msg = errMsg
		return
	}
	companyInfo, err := models.GetCompanyByName(companyNameHt)
	if err != nil {
		br.Msg = "获取信息失败"
		br.ErrMsg = "获取客户信息失败，Err:" + err.Error()
		return
	}
	user, err := models.GetUserByName(companyInfo.CompanyId, wxuUserName)
	if err != nil {
		br.Msg = "获取信息失败"
		br.ErrMsg = "获取用户信息失败，Err:" + err.Error()
		return
	}
	item := new(models.CygxPageHistoryRecord)
	item.UserId = user.UserId
	item.CreateTime = time.Now()
	item.Mobile = user.Mobile
	item.Email = user.Email
	item.CompanyId = user.CompanyId
	item.CompanyName = companyName
	item.DetailId = req.DetailId
	item.ChartPermissionId = req.ChartPermissionId
	item.IndustrialManagementId = req.IndustrialManagementId
	item.PageType = "ArticleCopy"
	_, err = models.AddCygxPageHistoryRecord(item)
	if err != nil {
		br.Msg = "记录信息失败"
		br.ErrMsg = "新增访问记录失败,Err:" + err.Error()
		return
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "新增成功"
}