hongze_clpt/controllers/user.go

package controllers

import (
	"encoding/json"
	"fmt"
	"github.com/rdlucklib/rdluck_tools/paging"
	"hongze/hongze_clpt/models"
	"hongze/hongze_clpt/services"
	"hongze/hongze_clpt/utils"
	"sort"
	"strconv"
	"strings"
	"time"
)

type UserController struct {
	BaseAuthController
}

type UserCommonController struct {
	BaseCommonController
}

// @Title 登录
// @Description 登录接口
// @Param	request	body models.LoginReq true "type json string"
// @Success 200 {object} models.LoginResp
// @router /login [post]
func (this *UserCommonController) Login() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	var token string
	var req models.LoginReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	mobile := req.Mobile
	req.Mobile = strings.Trim(req.Mobile, " ")
	if req.Mobile == "" {
		br.Msg = "参数错误"
		br.ErrMsg = "参数错误，手机号为空"
		return
	}
	code := req.VCode
	if code == "" {
		br.Msg = "参数错误"
		br.ErrMsg = "Code 为空"
		return
	}
	authorization := req.Token

	item, err := models.GetMsgCode(req.Mobile, req.VCode)
	if err != nil {
		if err.Error() == utils.ErrNoRow() {
			br.Msg = "验证码错误,请重新输入"
			br.ErrMsg = "校验验证码失败，Err:" + err.Error()
			return
		} else {
			br.Msg = "验证码错误,请重新输入"
			br.ErrMsg = "校验验证码失败，Err:" + err.Error()
			return
		}
	}
	if item == nil {
		br.Msg = "验证码错误,请重新输入"
		return
	}

	user, err := services.BindWxUser(mobile, "86")
	//user, err := models.GetWxUserItemByMobile(mobile)
	if err != nil {
		br.Msg = "登录失败"
		br.ErrMsg = "获取用户信息失败，GetUserDetailByMobile Err:" + err.Error()
		return
	}
	if authorization != "" {
		session, err := models.GetSessionByToken(authorization)
		if err != nil {
			br.Msg = "登录失败"
			br.ErrMsg = "绑定失败，GetSessionByToken err:" + err.Error()
			return
		}
		openid := session.OpenId
		if openid == "" {
			br.Msg = "登录失败"
			br.ErrMsg = "获取用户信息失败，绑定用户openid失败，OpenId不能为空 "
			return
		}
		err = models.BindSessionMobile(mobile, authorization)
		if err != nil {
			br.Msg = "登录失败"
			br.ErrMsg = "获取用户信息失败，BindSessionMobile Err:" + err.Error()
			return
		}
		err = models.BindUserRecordByOpenid(user.UserId, openid, mobile)
		if err != nil {
			br.Msg = "登录失败"
			br.ErrMsg = "获取用户信息失败，BindUserRecordByOpenid Err:" + err.Error()
			return
		}
		token = authorization
	} else {
		timeUnix := time.Now().Unix()
		timeUnixStr := strconv.FormatInt(timeUnix, 10)
		token = utils.MD5(mobile) + utils.MD5(timeUnixStr)
		itemsSession := new(models.CygxClptSession)
		itemsSession.UserId = user.UserId
		itemsSession.Mobile = mobile
		itemsSession.AccessToken = token
		itemsSession.CreatedTime = time.Now()
		itemsSession.LastUpdatedTime = time.Now()
		itemsSession.ExpireTime = time.Now().AddDate(0, 3, 0)
		err = models.AddCygxClptSession(itemsSession)
		if err != nil {
			br.Msg = "获取用户信息失败"
			br.ErrMsg = "添加Token失败，Err:" + err.Error()
			return
		}
	}

	//记录通过三方合作机构过来的公司
	{
		services.AddInviteCompany(user)
	}
	resp := new(models.LoginResp)
	resp.UserId = user.UserId
	resp.Headimgurl = user.Headimgurl
	resp.Mobile = user.Mobile
	resp.Email = user.Email
	resp.CompanyName = user.CompanyName
	resp.Authorization = token
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// @Title 获取用户详情
// @Description 获取用户详情接口
// @Success 200 {object} models.UserDetailResp
// @router /detail [get]
func (this *UserController) 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
	}
	resp := new(models.UserDetailResp)
	resp.UserId = user.UserId
	resp.UserName = user.RealName
	resp.Headimgurl = user.Headimgurl
	resp.Mobile = user.Mobile
	resp.Email = user.Email
	resp.CompanyName = user.CompanyName
	userDetail, err := models.GetUserDetailByUserId(user.UserId)
	if err != nil {
		br.Msg = "获取用户信息失败"
		br.ErrMsg = "获取用户信息失败，Err:" + err.Error()
		return
	}
	resp.OutboundCountryCode = userDetail.OutboundCountryCode
	resp.OutboundMobile = userDetail.OutboundMobile

	if user.CompanyId > 1 {
		companyItem, err := models.GetCompanyDetailById(user.CompanyId)
		if err != nil && err.Error() != utils.ErrNoRow() {
			br.Msg = "获取信息失败"
			br.ErrMsg = "获取客户信息失败,Err:" + err.Error()
			return
		}
		if companyItem != nil && companyItem.CompanyId > 0 {
			resp.CompanyName = companyItem.CompanyName
			//if companyItem.Status == "试用" || companyItem.Status == "永续" || companyItem.Status == "正式" {
			//permissionStr, err := models.GetCompanyPermissionByUser(companyItem.CompanyId)
			//if err != nil {
			//	br.Msg = "获取信息失败"
			//	br.ErrMsg = "获取客户信息失败,Err:" + err.Error()
			//	return
			//}
			var permissionStr string
			permissionList, err := models.GetCompanyPermissionList(companyItem.CompanyId)
			if err != nil {
				br.Msg = "获取信息失败"
				br.ErrMsg = "获取客户信息失败,Err:" + err.Error()
				return
			}

			mapIsUpgrade := make(map[string]string)
			mapZhukKeGuan := make(map[string]int)
			for _, v := range permissionList {
				mapZhukKeGuan[v.PermissionName] += 1
				if v.IsUpgrade == 1 {
					mapIsUpgrade[v.PermissionName] = v.PermissionName + "(升级)"
				}
			}
			mapPermissionName := make(map[string]string)
			//处理升级，并且合并主客观
			for _, v := range permissionList {
				if _, ok := mapPermissionName[v.PermissionName]; ok {
					continue
				}
				if _, ok := mapIsUpgrade[v.PermissionName]; ok {
					permissionStr += mapIsUpgrade[v.PermissionName] + ","
				} else {
					if mapZhukKeGuan[v.PermissionName] == 1 {
						permissionStr += v.Remark + ","
					} else {
						permissionStr += v.PermissionName + ","
					}
				}
				mapPermissionName[v.PermissionName] = v.PermissionName
			}
			permissionStr = strings.TrimRight(permissionStr, ",")
			//permissionStrOld, err := models.GetCompanyPermission(companyItem.CompanyId)
			//if err != nil {
			//	br.Msg = "获取信息失败"
			//	br.ErrMsg = "获取客户信息失败,Err:" + err.Error()
			//	return
			//}
			//permissionStrListOld := strings.Split(permissionStrOld, ",")
			//for _, v := range permissionStrListOld {
			//	if strings.Count(permissionStr, v) > 1 {
			//		permissionStr = strings.Replace(permissionStr, v+"(主观)", v, -1)
			//		permissionStr = strings.Replace(permissionStr, v+"(客观),", "", -1)
			//	}
			//}

			finalPermissionList := strings.Split(permissionStr, ",")
			for _, per := range finalPermissionList {
				resp.PermissionName = append(resp.PermissionName, per)
			}

		}
	}
	if resp.Headimgurl == "" {
		resp.Headimgurl = utils.DefaultHeadimgurl
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// @Title 未付费申请试用
// @Description 未付费申请试用
// @Param	request	body models.ApplyTryReq true "type json string"
// @Success 200
// @router /apply/try [post]
func (this *UserController) ApplyTryOut() {
	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
	}
	mobile := user.Mobile
	var req models.ApplyTryReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}

	if req.RealName == "" {
		req.RealName = user.RealName
	}
	if req.CompanyName == "" {
		req.CompanyName = user.CompanyName
	}
	uid := user.UserId

	var title string
	var sourceId int
	var source string
	tryType := req.TryType
	detailId := req.DetailId
	sourceId = detailId
	source = tryType
	var isResearch bool // 是否属于研选
	if tryType == "Article" {
		detail, err := models.GetArticleDetailById(detailId)
		if err != nil {
			br.Msg = "获取信息失败"
			br.ErrMsg = "获取信息失败,Err:" + err.Error()
			return
		}
		title = detail.Title
		if detail.ArticleTypeId > 0 {
			isResearch = true
		}
	} else if tryType == "Activity" {
		detail, err := models.GetAddActivityInfoById(detailId)
		if err != nil {
			br.Msg = "操作失败"
			br.ErrMsg = "活动ID错误,不存在activityId：" + strconv.Itoa(detailId)
			return
		}
		title = detail.ActivityName
		if strings.Contains(detail.ChartPermissionName, utils.CHART_PERMISSION_NAME_YANXUAN) {
			isResearch = true
		}
	} else if tryType == "MicroAudio" {
		// 微路演音频
		microAudio, e := models.GetCygxActivityVoiceById(detailId)
		if e != nil {
			br.Msg = "操作失败"
			br.ErrMsg = "微路演音频信息有误, 不存在的VoiceId: " + strconv.Itoa(detailId)
			return
		}
		title = microAudio.VoiceName
		sourceId = microAudio.ActivityId
		source = "activityvoice"
	} else if tryType == "ActivityVideo" {
		// 活动视频
		activityVideo, e := models.GetCygxActivityVideoById(detailId)
		if e != nil {
			br.Msg = "操作失败"
			br.ErrMsg = "微路演音频信息有误, 不存在的VoiceId: " + strconv.Itoa(detailId)
			return
		}
		title = activityVideo.Title
		sourceId = activityVideo.ActivityId
		source = "activityvideo"
	} else if tryType == "MicroVideo" {
		// 微路演视频
		microVideo, e := models.GetMicroRoadshowVideoById(detailId)
		if e != nil {
			br.Msg = "操作失败"
			br.ErrMsg = "微路演视频信息有误, 不存在的VideoId: " + strconv.Itoa(detailId)
			return
		}
		title = microVideo.VideoName
		source = "roadshow"
	} else if tryType == "Researchsummary" {
		// 本周研究汇总
		ResearchSummaryInfo, e := models.GetCygxResearchSummaryInfoById(detailId)
		if e != nil {
			br.Msg = "操作失败"
			br.ErrMsg = "本周研究汇总信息有误, 不存在的detailId: " + strconv.Itoa(detailId)
			return
		}
		title = ResearchSummaryInfo.Title
		source = "researchsummary"
	} else if tryType == "Minutessummary" {
		// 上周纪要汇总
		MinutesSummaryInfo, e := models.GetCygxMinutesSummaryInfoById(detailId)
		if e != nil {
			br.Msg = "操作失败"
			br.ErrMsg = "上周纪要汇总信息有误, 不存在的detailId: " + strconv.Itoa(detailId)
			return
		}
		title = MinutesSummaryInfo.Title
		source = "minutessummary"
	} else if tryType == "ReportSelection" {
		// 报告精选
		ReportSelectionInfo, e := models.GetCygxReportSelectionInfoById(detailId)
		if e != nil {
			br.Msg = "操作失败"
			br.ErrMsg = "报告精选信息有误, 不存在的detailId: " + strconv.Itoa(detailId)
			return
		}
		title = ReportSelectionInfo.Title
		source = "reportselection"
	} else if tryType == "ProductInterior" {
		// 产品内测
		ProductInteriorDetail, e := models.GetCygxProductInteriorDetail(detailId)
		if e != nil {
			br.Msg = "操作失败"
			br.ErrMsg = "产品内测信息有误, 不存在的detailId: " + strconv.Itoa(detailId)
			return
		}
		title = ProductInteriorDetail.Title
		source = "productinterior"
	}

	//缓存校验
	cacheKey := fmt.Sprint("xygx:apply_record:add:", uid)
	ttlTime := utils.Rc.GetRedisTTL(cacheKey)
	if ttlTime > 0 {
		br.Msg = "申请失败，申请过于频繁"
		br.ErrMsg = "申请失败，申请过于频繁"
		return
	}
	utils.Rc.SetNX(cacheKey, user.Mobile, time.Second*10)

	//判断是否已经申请过
	applyCount, err := models.GetApplyRecordCount(uid)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "获取信息失败"
		br.ErrMsg = "判断是否已申请过试用失败，Err:" + err.Error()
		return
	}

	if applyCount > 0 {
		br.Msg = "您已提交申请，请耐心等待。"
		br.IsSendEmail = false
		return
	}

	//判断是否存在申请
	var sellerMobile string
	if req.ApplyMethod == 2 {
		if req.BusinessCardUrl == "" {
			br.Msg = "请上传名片"
			return
		}

		if req.RealName == "" {
			br.Msg = "请输入姓名"
			return
		}

		if req.CompanyName == "" {
			br.Msg = "请输入公司名称"
			return
		}

		if req.BusinessCardUrl != "" && utils.RunMode == "release" {
			card, err := services.GetBusinessCard(req.BusinessCardUrl)
			if err != nil {
				br.Msg = "名片识别失败"
				br.ErrMsg = "名片识别失败,Err:" + err.Error()
				return
			}
			mobileStr := strings.Join(card.WordsResult.MOBILE, ",")
			isFlag := true
			if mobile != "" {
				if strings.Contains(mobileStr, mobile) || mobileStr == "" {
					isFlag = true
				} else {
					isFlag = false
				}
			}
			if !isFlag {
				//阿里云识别
				if utils.RunMode == "release" {
					aliyunResult, err := services.AliyunBusinessCard(req.BusinessCardUrl)
					if err != nil {
						br.Msg = "识别失败"
						br.ErrMsg = "识别失败,Err:" + err.Error()
						return
					}
					if !aliyunResult.Success {
						br.Msg = "识别失败"
						br.ErrMsg = "识别失败"
						return
					}

					mobileStr := strings.Join(aliyunResult.TelCell, ",")
					if mobile != "" {
						if strings.Contains(mobileStr, mobile) {
							isFlag = true
						} else {
							isFlag = false
						}
					}
				}
			}
			if !isFlag {
				br.Msg = "名片手机号与所填手机号不匹配，请重新填写"
				br.ErrMsg = "mobile:" + mobile
				return
			}
		}
	}

	//获取销售信息
	sellerItem, err := models.GetSellerByCompanyIdCheckFicc(user.CompanyId, 2)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "申请失败"
		br.ErrMsg = "获取销售信息失败,Err:" + err.Error()
		return
	}
	if sellerItem != nil {
		sellerMobile = sellerItem.Mobile
		//推送模板消息
		mobile := user.Mobile
		if mobile == "" {
			mobile = user.Email
		}
	}
	//用户状态，1：潜在客户 、2：现有客户 、3：FICC客户 、4：现有客户（正式，无对应权限） 、5：现有客户（试用，无对应权限）  、6：现有客户（试用暂停） 、7：现有客户（冻结） 、8：现有客户（流失）?
	CompanyIdType := 1
	applyMethod := ""

	if sellerItem != nil {

		companyItem, err := models.GetCompanyDetailById(user.CompanyId)
		if err != nil && err.Error() != utils.ErrNoRow() {
			br.Msg = "获取信息失败"
			br.ErrMsg = "获取客户信息失败,Err:" + err.Error()
			return
		}
		if companyItem != nil && companyItem.CompanyId > 0 {
			companyProduct, err := models.GetCompanyProductDetail(user.CompanyId, 2)
			if err != nil && err.Error() != utils.ErrNoRow() {
				br.Msg = "获取信息失败"
				br.ErrMsg = "获取客户信息失败,Err:" + err.Error()
				return
			}
			if companyProduct != nil && companyProduct.IsSuspend == 1 {
				CompanyIdType = 6
			} else {
				switch companyItem.Status {
				case "正式":
					CompanyIdType = 4
				case "试用":
					CompanyIdType = 5
				case "冻结":
					CompanyIdType = 7
				case "流失":
					CompanyIdType = 8
				}
			}
			applyMethod = companyItem.Status + "客户申请"
			if detailId > 0 {
				if companyProduct != nil && companyProduct.IsSuspend == 1 {
					applyMethod = "试用暂停客户"
				} else {
					if companyItem.Status == "正式" || companyItem.Status == "试用" {
						applyMethod = companyItem.Status + "客户申请,无对应权限"
					} else if companyItem.Status == "冻结" || companyItem.Status == "流失" {
						applyMethod = companyItem.Status + "客户"
					}
				}
				applyMethod = applyMethod + "," + title
			}
			openIpItem, _ := models.GetUserRecordByMobile(4, sellerItem.Mobile)
			if openIpItem != nil && openIpItem.OpenId != "" {
				if req.ApplyMethod != 2 {
					req.RealName = user.RealName
					req.CompanyName = user.CompanyName
				}
				//go services.SendPermissionApplyTemplateMsg(req.RealName, req.CompanyName, mobile, applyMethod, openIpItem)
			}
		}
	} else {
		//获取销售信息
		sellerItem, err := models.GetSellerByCompanyIdCheckFicc(user.CompanyId, 1)
		if err != nil && err.Error() != utils.ErrNoRow() {
			br.Msg = "申请失败"
			br.ErrMsg = "获取销售信息失败,Err:" + err.Error()
			return
		}
		if sellerItem != nil {
			CompanyIdType = 3
			applyMethod = "FICC客户"
		} else {
			CompanyIdType = 1
			applyMethod = "潜在客户"
		}
		if detailId > 0 {
			applyMethod = applyMethod + "," + title
		}
	}
	//openIpItem, _ := models.GetUserRecordByMobile(4, cnf.ConfigValue)
	//if openIpItem != nil && openIpItem.OpenId != "" {
	//	if req.ApplyMethod != 2 {
	//		req.RealName = user.RealName
	//		req.CompanyName = user.CompanyName
	//	}
	//	utils.FileLog.Info("推送消息 %s %s,%s,%s,%s", req.RealName, req.CompanyName, mobile, openIpItem.OpenId, applyMethod)
	//	go services.SendPermissionApplyTemplateMsg(req.RealName, req.CompanyName, mobile, applyMethod, openIpItem)
	//}

	//go services.SendPermissionApplyTemplateMsgAdmin(req, mobile, applyMethod, isResearch)

	item := new(models.CygxApplyRecord)
	item.UserId = user.UserId
	item.BusinessCardUrl = req.BusinessCardUrl
	item.RealName = req.RealName
	item.CompanyName = req.CompanyName
	item.Mobile = user.Mobile
	item.CreateTime = time.Now()
	item.ApplyMethod = req.ApplyMethod
	item.CompanyIdPay = user.CompanyId
	item.CompanyNamePay = user.CompanyName
	item.CompanyIdType = CompanyIdType
	if user.InviteCompany == utils.LUODING_CODE && user.CompanyId == 1 {
		//如果是潜在客户就标记来源
		item.InviteCompanySource = 2
	}
	item.Title = title
	item.SourceId = sourceId
	item.Source = strings.ToLower(source)
	item.RegisterPlatform = utils.REGISTER_PLATFORM
	err = models.AddApplyRecord(item)

	if err != nil {
		br.Msg = "申请失败"
		br.ErrMsg = "申请失败，Err:" + err.Error()
		return
	}
	if sellerItem == nil {
		go services.SendPermissionApplyTemplateMsgAdmin(req, mobile, applyMethod, isResearch)
	} else {
		openIpItem, _ := models.GetUserRecordByMobile(4, sellerItem.Mobile)
		if openIpItem != nil && openIpItem.OpenId != "" {
			go services.SendPermissionApplyTemplateMsg(req.RealName, req.CompanyName, mobile, applyMethod, openIpItem)
		}
	}

	//添加成功后，设置5分钟缓存，不允许重复添加
	//utils.Rc.SetNX(cacheKey, user.Mobile, time.Second*60)

	br.Msg = "申请成功！"
	br.Ret = 200
	br.Success = true
	br.Data = sellerMobile
}

// @Title 用户修改外呼手机号以及区号
// @Description 用户修改外呼手机号以及区号接口
// @Param	request	body models.OutboundMobileItem true "type json string"
// @Success Ret=200 操作成功
// @router /countryCcode/addOutboundMobile [POST]
func (this *UserController) AddOutboundMobile() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	user := this.User
	uid := user.UserId
	if user == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，用户信息为空"
		br.Ret = 408
		return
	}
	var req models.OutboundMobileItem
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}

	if req.OutboundMobile == "" {
		br.Msg = "请填写区号！"
		return
	}
	item := new(models.OutboundMobileItem)
	item.OutboundMobile = req.OutboundMobile
	item.OutboundCountryCode = req.OutboundCountryCode
	//item.ActivityId = req.ActivityId
	//if req.ActivityId == 0 {
	//	err = models.AddOutboundMobile(item, uid)
	//} else {
	//	if user.Mobile == "" && user.OutboundMobile == "" {
	//		items := new(models.CygxActivitySignup)
	//		items.UserId = uid
	//		items.ActivityId = req.ActivityId
	//		items.CreateTime = time.Now()
	//		items.Mobile = user.Mobile
	//		items.Email = user.Email
	//		items.CompanyId = user.CompanyId
	//		items.CompanyName = user.CompanyName
	//		items.SignupType = 1
	//		items.FailType = 0
	//		items.DoFailType = 0
	//		items.OutboundMobile = req.OutboundMobile
	//		items.CountryCode = req.OutboundCountryCode
	//		_, err = models.AddActivitySignupFromEmail(items)
	//	} else {
	//		total, err := models.GetActivityCountByIdWithUid(item.ActivityId, uid)
	//		if total == 0 {
	//			br.Msg = "报名信息不存在"
	//			br.ErrMsg = "报名信息不存在,Err:" + "活动ActivityId：" + strconv.Itoa(item.ActivityId) + "用户Uid：" + strconv.Itoa(uid)
	//			return
	//		}
	//		if err != nil {
	//			br.Msg = "操作失败"
	//			br.ErrMsg = "操作失败,Err:" + err.Error()
	//			return
	//		}
	//		err = models.AddOutboundMobile(item, uid)
	//	}
	//}

	err = models.AddOutboundMobile(item, uid)
	if err != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "操作失败,Err:" + err.Error()
		return
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "操作成功"
}

// @Title 校验用户状态信息
// @Description 校验用户状态信息
// @Success 200 {object} models.CheckStatusResp
// @router /check/status [get]
func (this *UserController) CheckLogin() {
	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
	resp := new(models.CheckStatusResp)
	if uid > 0 {
		//判断token是否过期
		userRecord, err := models.GetUserSessionByUserId(uid)
		if err != nil {
			br.Msg = "获取用户信息失败"
			br.ErrMsg = "获取用户信息失败，Err:" + err.Error()
			return
		}
		permissionStr, err := models.GetCompanyPermission(user.CompanyId)
		if err != nil {
			br.Msg = "获取信息失败"
			br.ErrMsg = "获取客户信息失败,Err:" + err.Error()
			return
		}
		resp.PermissionName = permissionStr

		if user.Mobile == "" && user.Email == "" {
			resp.IsBind = true
		}
		if userRecord.UnionId == "" {
			resp.IsAuth = true
		}
	} else {
		resp.IsBind = true
		if user.UnionId == "" {
			resp.IsAuth = true
		}
		resp.PermissionName = ""
	}
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
	br.Ret = 200
}

// @Title 更改用户微信头像
// @Description 更改用户微信头像
// @Param	request	body models.Headimgurl true "type json string"
// @Success 200 {object} models.ArticleDetailFileLink
// @router /headimgurl/update [post]
func (this *UserController) HeadimgurlUpdate() {
	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.Headimgurl
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	uid := user.UserId
	headimgurl := req.Headimgurl
	if headimgurl == "" {
		br.Msg = "操作失败"
		br.ErrMsg = "头像信息不能为空"
		return
	}
	err = models.UpdateUserHeadimgurl(headimgurl, uid)
	if err != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "头像信息不能为空"
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "操作成功"
}

// @Title 获取我的收藏
// @Description 获取我的收藏列表
// @Param   PageSize    query   int true       "PageSize"
// @Param   CurrentIndex    query   int true       "CurrentIndex"
// @Success 200 {object} models.ArticleCollectListResp
// @router /collect/list [get]
func (this *UserController) CollectList() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	userId := this.User.UserId
	var pageSize, currentIndex, startSize int
	pageSize, _ = this.GetInt("PageSize")
	currentIndex, _ = this.GetInt("CurrentIndex")
	if pageSize <= 0 {
		pageSize = utils.PageSize20
	}
	if currentIndex <= 0 {
		currentIndex = 1
	}
	startSize = utils.StartIndex(currentIndex, pageSize)

	total, err := models.GetArticleUserCollectCount(userId)
	if err != nil {
		br.Msg = "获取数据失败"
		br.ErrMsg = "获取数据失败，Err:" + err.Error()
		return
	}
	list, err := models.GetArticleUserCollectList(startSize, pageSize, userId)
	if err != nil {
		br.Msg = "获取数据失败"
		br.ErrMsg = "获取数据失败，Err:" + err.Error()
		return
	}
	resp := new(models.ArticleReportBillboardLIstPageResp)
	if len(list) == 0 {
		page := paging.GetPaging(currentIndex, pageSize, total)
		resp.List = list
		resp.Paging = page
		br.Msg = "获取成功！"
		br.Ret = 200
		br.Success = true
		br.Data = resp
		return
	}
	var condition string
	var pars []interface{}
	var articleIds []string
	for _, v := range list {
		articleIds = append(articleIds, strconv.Itoa(v.ArticleId))
	}
	articleIdStr := strings.Join(articleIds, ",")

	//获取文章关联的产业
	pars = make([]interface{}, 0)
	condition = ` AND mg.article_id IN (  ` + utils.GetOrmInReplace(len(articleIds)) + ` )  `
	pars = append(pars, articleIds)
	industrialList, err := models.GetIndustrialListByarticleId(pars, condition)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败，GetSubjectList Err:" + err.Error()
		return
	}
	industrialMap := make(map[int][]*models.IndustrialManagementIdInt)
	if len(industrialList) > 0 {
		for _, v := range industrialList {
			item := new(models.IndustrialManagementIdInt)
			item.ArticleId = v.ArticleId
			if v.ArticleId > utils.SummaryArticleId {
				item.IsResearch = true
			}
			item.IndustrialManagementId = v.IndustrialManagementId
			item.IndustryName = v.IndustryName
			item.ChartPermissionId = v.ChartPermissionId
			industrialMap[v.ArticleId] = append(industrialMap[v.ArticleId], item)
		}
	}
	for k, v := range list {
		if len(industrialMap[v.ArticleId]) > 0 {
			list[k].List = industrialMap[v.ArticleId]
		} else {
			list[k].List = make([]*models.IndustrialManagementIdInt, 0)
		}
	}

	articleMap := make(map[int]*models.ArticleDetail)
	if articleIdStr != "" {
		articleList, err := models.GetArticleDetailByIdStr(articleIdStr)
		if err != nil {
			br.Msg = "获取数据失败"
			br.ErrMsg = "获取报告详情信息失败，Err:" + err.Error()
			return
		}
		for _, v := range articleList {
			if _, ok := articleMap[v.ArticleId]; !ok {
				articleMap[v.ArticleId] = v
			}
		}
	}

	//处理文章PV收藏等数量
	mapArticleCollectNum := make(map[int]*models.CygxArticleNum)
	if len(articleIds) > 0 {
		articleCollectNumList, err := models.GetArticleCollectNum(articleIds, userId)
		if err != nil && err.Error() != utils.ErrNoRow() {
			br.Msg = "获取失败"
			br.ErrMsg = "获取失败，GetArticleCollectNum Err:" + err.Error()
			return
		}
		for _, v := range articleCollectNumList {
			mapArticleCollectNum[v.ArticleId] = v
		}
	}

	lenList := len(list)
	for i := 0; i < lenList; i++ {
		item := list[i]
		article := articleMap[item.ArticleId]
		list[i].Title = article.Title
		list[i].DepartmentId = article.DepartmentId
		list[i].NickName = article.NickName
		list[i].PublishDate = article.PublishDate
		if article.ArticleTypeId == 0 {
			list[i].Source = 1
		} else {
			list[i].Source = 2
			list[i].IsResearch = true
		}
		if mapArticleCollectNum[article.ArticleId] != nil {
			list[i].CollectNum = mapArticleCollectNum[article.ArticleId].CollectNum
			list[i].Pv = mapArticleCollectNum[article.ArticleId].Pv
			list[i].IsCollect = mapArticleCollectNum[article.ArticleId].IsCollect
		}
	}
	page := paging.GetPaging(currentIndex, pageSize, total)
	resp.List = list
	resp.Paging = page
	br.Msg = "获取成功！"
	br.Ret = 200
	br.Success = true
	br.Data = resp
}

// @Title 获取我的留言
// @Description 获取我的留言列表
// @Param   PageSize    query   int true       "PageSize"
// @Param   CurrentIndex    query   int true       "CurrentIndex"
// @Success 200 {object} models.CygxCommentListResp
// @router /comment/list [get]
func (this *UserController) CommnetList() {
	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 pageSize, currentIndex, startSize int
	pageSize, _ = this.GetInt("PageSize")
	currentIndex, _ = this.GetInt("CurrentIndex")
	if pageSize <= 0 {
		pageSize = utils.PageSize20
	}
	if currentIndex <= 0 {
		currentIndex = 1
	}
	startSize = utils.StartIndex(currentIndex, pageSize)

	userId := this.User.UserId
	total, err := models.GetCommentListCount(userId)
	if err != nil {
		br.Msg = "获取数据失败"
		br.ErrMsg = "获取数据失败，Err:" + err.Error()
		return
	}
	commentlist, err := models.GetCommentList(userId, startSize, pageSize)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "获取失败"
		br.ErrMsg = "获取我的留言列表失败，Err:" + err.Error()
		return
	}

	resp := new(models.CygxCommentListResp)

	for _, comment := range commentlist {
		item := models.CygxArticleCommentResp{
			Id:          comment.Id,
			UserId:      comment.UserId,
			ArticleId:   comment.ArticleId,
			IndustryId:  comment.IndustryId,
			ActivityId:  comment.ActivityId,
			VideoId:     comment.VideoId,
			CreateTime:  comment.CreateTime.Format(utils.FormatDateTime),
			Mobile:      comment.Mobile,
			Email:       comment.Email,
			CompanyId:   comment.CompanyId,
			CompanyName: comment.CompanyName,
			Content:     comment.Content,
			Title:       comment.Title,
		}
		if comment.ArticleId > 0 {
			item.RedirectType = 1
		} else if comment.IndustryId > 0 {
			detail, err := models.GetIndustrialManagementDetail(comment.IndustryId)
			if err != nil {
				br.Msg = "获取信息失败"
				br.ErrMsg = "获取信息失败,Err:" + err.Error()
				return
			}
			item.RedirectType = 3
			item.ChartPermissionId = detail.ChartPermissionId
		} else if comment.ActivityId > 0 && comment.VideoId == 0 {
			item.RedirectType = 2
		} else if comment.IndustryId == 0 && comment.VideoId > 0 {
			item.RedirectType = 4
		}
		resp.List = append(resp.List, &item)
	}

	page := paging.GetPaging(currentIndex, pageSize, total)
	resp.Paging = page

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

// @Title 我的足迹
// @Description 获取我的足迹列表
// @Param   PageSize    query   int true       "PageSize"
// @Param   CurrentIndex    query   int true       "CurrentIndex"
// @Success 200 {object} models.ArticleBrowseHistoryListResp
// @router /browse/history/list [get]
func (this *UserController) BrowseHistoryList() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	userId := this.User.UserId
	var pageSize, currentIndex, startSize int
	pageSize, _ = this.GetInt("PageSize")
	currentIndex, _ = this.GetInt("CurrentIndex")
	if pageSize <= 0 {
		pageSize = utils.PageSize20
	}
	if currentIndex <= 0 {
		currentIndex = 1
	}
	startSize = utils.StartIndex(currentIndex, pageSize)

	endDate := time.Now().AddDate(0, -1, 0).Format(utils.FormatDate)
	total, err := models.GetArticleUserBrowseHistoryCount(userId, endDate)
	if err != nil {
		br.Msg = "获取数据失败"
		br.ErrMsg = "获取数据失败，Err:" + err.Error()
		return
	}
	list, err := models.GetArticleUserBrowseHistoryList(startSize, pageSize, userId, endDate)
	if err != nil {
		br.Msg = "获取数据失败"
		br.ErrMsg = "获取数据失败，Err:" + err.Error()
		return
	}
	resp := new(models.ArticleReportBillboardLIstPageResp)
	if len(list) == 0 {
		page := paging.GetPaging(currentIndex, pageSize, total)
		resp.List = list
		resp.Paging = page
		br.Msg = "获取成功！"
		br.Ret = 200
		br.Success = true
		br.Data = resp
		return
	}

	var articleIds []string
	var condition string
	var pars []interface{}
	for _, v := range list {
		articleIds = append(articleIds, strconv.Itoa(v.ArticleId))
	}
	articleIdStr := strings.Join(articleIds, ",")

	//获取文章关联的产业
	pars = make([]interface{}, 0)
	condition = ` AND mg.article_id IN (  ` + utils.GetOrmInReplace(len(articleIds)) + ` )  `
	pars = append(pars, articleIds)
	industrialList, err := models.GetIndustrialListByarticleId(pars, condition)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败，GetSubjectList Err:" + err.Error()
		return
	}
	industrialMap := make(map[int][]*models.IndustrialManagementIdInt)
	if len(industrialList) > 0 {
		for _, v := range industrialList {
			item := new(models.IndustrialManagementIdInt)
			item.ArticleId = v.ArticleId
			if v.ArticleId > utils.SummaryArticleId {
				item.IsResearch = true
			}
			item.IndustrialManagementId = v.IndustrialManagementId
			item.IndustryName = v.IndustryName
			item.ChartPermissionId = v.ChartPermissionId
			industrialMap[v.ArticleId] = append(industrialMap[v.ArticleId], item)
		}
	}
	for k, v := range list {
		if len(industrialMap[v.ArticleId]) > 0 {
			list[k].List = industrialMap[v.ArticleId]
		} else {
			list[k].List = make([]*models.IndustrialManagementIdInt, 0)
		}
	}

	articleMap := make(map[int]*models.ArticleDetail)
	if articleIdStr != "" {
		articleList, err := models.GetArticleDetailByIdStr(articleIdStr)
		if err != nil {
			br.Msg = "获取数据失败"
			br.ErrMsg = "获取报告详情信息失败，Err:" + err.Error()
			return
		}
		for _, v := range articleList {
			if _, ok := articleMap[v.ArticleId]; !ok {
				articleMap[v.ArticleId] = v
			}
		}
	}

	//处理文章PV收藏等数量
	mapArticleCollectNum := make(map[int]*models.CygxArticleNum)
	if len(articleIds) > 0 {
		articleCollectNumList, err := models.GetArticleCollectNum(articleIds, userId)
		if err != nil && err.Error() != utils.ErrNoRow() {
			br.Msg = "获取失败"
			br.ErrMsg = "获取失败，GetArticleCollectNum Err:" + err.Error()
			return
		}
		for _, v := range articleCollectNumList {
			mapArticleCollectNum[v.ArticleId] = v
		}
	}

	lenList := len(list)
	for i := 0; i < lenList; i++ {
		item := list[i]
		article := articleMap[item.ArticleId]
		if article != nil {
			list[i].Title = article.Title
			list[i].PublishDate = utils.TimeRemoveHms2(article.PublishDate)
			list[i].DepartmentId = article.DepartmentId
			list[i].NickName = article.NickName
			if article.ArticleId < utils.SummaryArticleId {
				list[i].Source = 1
			} else {
				list[i].Source = 2
			}

			if mapArticleCollectNum[article.ArticleId] != nil {
				list[i].CollectNum = mapArticleCollectNum[article.ArticleId].CollectNum
				list[i].Pv = mapArticleCollectNum[article.ArticleId].Pv
				list[i].IsCollect = mapArticleCollectNum[article.ArticleId].IsCollect
			}
			//list[i].TitleEn = article.TitleEn
			//list[i].UpdateFrequency = article.UpdateFrequency
			//list[i].CreateDate = article.CreateDate
			//list[i].Body, _ = services.GetReportContentTextSub(article.Body)
			//list[i].Abstract = article.Abstract
			//list[i].CategoryName = article.CategoryName
			//list[i].SubCategoryName = article.SubCategoryName
		}
	}
	page := paging.GetPaging(currentIndex, pageSize, total)

	resp.List = list
	resp.Paging = page
	br.Msg = "获取成功！"
	br.Ret = 200
	br.Success = true
	br.Data = resp
}

// @Title 获取我的提问
// @Description 获取我的提问列表
// @Param   PageSize    query   int true       "PageSize"
// @Param   CurrentIndex    query   int true       "CurrentIndex"
// @Success 200 {object} models.CygxAskListResp
// @router /ask/list [get]
func (this *UserController) AskList() {
	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 pageSize, currentIndex, startSize int
	pageSize, _ = this.GetInt("PageSize")
	currentIndex, _ = this.GetInt("CurrentIndex")
	if pageSize <= 0 {
		pageSize = utils.PageSize20
	}
	if currentIndex <= 0 {
		currentIndex = 1
	}
	startSize = utils.StartIndex(currentIndex, pageSize)

	userId := this.User.UserId
	total, err := models.GetActivityAskCount(userId)
	if err != nil {
		br.Msg = "获取数据失败"
		br.ErrMsg = "获取数据失败，Err:" + err.Error()
		return
	}

	listActcivity, err := models.GetActivityAskList(userId, startSize, pageSize)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "获取失败"
		br.ErrMsg = "获取活动问题失败，Err:" + err.Error()
		return
	}
	for _, v := range listActcivity {
		v.AskType = "Activity"
	}
	listArticle, err := models.GetArticleAskList(userId)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "获取失败"
		br.ErrMsg = "获取文章问题失败，Err:" + err.Error()
		return
	}
	for _, v := range listArticle {
		v.AskType = "Report"
		listActcivity = append(listActcivity, v)
	}
	resp := new(models.CygxAskListResp)
	page := paging.GetPaging(currentIndex, pageSize, total)
	resp.Paging = page

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

// @Title 我的收藏微路演列表
// @Description 我的收藏微路演列表接口
// @Param   PageSize		query	int		true	"每页数据条数"
// @Param   CurrentIndex	query	int		true	"当前页页码，从1开始"
// @Success 200 {object} models.HomeListResp
// @router /collect/microRoadShow [get]
func (this *UserController) Mycollect() {
	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
	}
	pageSize, _ := this.GetInt("PageSize")
	currentIndex, _ := this.GetInt("CurrentIndex")

	if pageSize <= 0 {
		pageSize = utils.PageSize20
	}
	if currentIndex <= 0 {
		currentIndex = 1
	}
	userId := user.UserId
	listMycollect, err := models.GetUserMicroRoadshowCollectList(userId)
	if err != nil {
		br.Msg = "获取数据失败"
		br.ErrMsg = "获取数据失败，Err:" + err.Error()
		return
	}
	collectVoiceMap := make(map[int]time.Time, 0)
	collectVideoMap := make(map[int]time.Time, 0)
	collectActivityVideoMap := make(map[int]time.Time, 0)
	var audioIds []string
	var videoIds []string
	var activityVideoIds []string
	for _, item := range listMycollect {
		if item.ActivityVoiceId > 0 {
			audioIds = append(audioIds, strconv.Itoa(item.ActivityVoiceId))
			collectVoiceMap[item.ActivityVoiceId] = item.CreateTime
		} else if item.VideoId > 0 {
			videoIds = append(videoIds, strconv.Itoa(item.VideoId))
			collectVideoMap[item.VideoId] = item.CreateTime
		} else if item.ActivityVideoId > 0 {
			activityVideoIds = append(activityVideoIds, strconv.Itoa(item.ActivityVideoId))
			collectActivityVideoMap[item.ActivityVideoId] = item.CreateTime
		}
	}

	if len(audioIds) == 0 && len(videoIds) == 0 && len(activityVideoIds) == 0 {
		resp := new(models.MicroRoadShowListResp)
		page := paging.GetPaging(currentIndex, pageSize, 0)
		resp.List = make([]*models.MicroRoadShowPageList, 0)
		resp.Paging = page
		br.Ret = 200
		br.Success = true
		br.Msg = "获取成功"
		br.Data = resp
		return
	}

	audioIdstr := strings.Join(audioIds, ",")
	ideoIdsStr := strings.Join(videoIds, ",")
	activityVideoIdsStr := strings.Join(activityVideoIds, ",")
	// 微路演列表
	list, total, e := services.GetMicroRoadShowMycollect(pageSize, currentIndex, audioIdstr, ideoIdsStr, activityVideoIdsStr)
	if e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取微路演列表失败, Err: " + e.Error()
		return
	}
	for _, item := range list {
		if item.Type == 1 {
			//音频
			count, err := models.GetVoiceCollectCount(user.UserId, item.Id)
			if err != nil {
				br.Msg = "获取数据失败！"
				br.ErrMsg = "获取数据失败，Err:" + err.Error()
				return
			}
			if count > 0 {
				item.IsCollect = true
			}
			if v, ok := collectVoiceMap[item.Id]; ok {
				item.CollectTime = v
			}
		} else if item.Type == 2 {
			//活动视频
			count, err := models.GetActivityVideoCollectCount(user.UserId, item.Id)
			if err != nil {
				br.Msg = "获取数据失败！"
				br.ErrMsg = "获取数据失败，Err:" + err.Error()
				return
			}
			if count > 0 {
				item.IsCollect = true
			}
			if v, ok := collectActivityVideoMap[item.Id]; ok {
				item.CollectTime = v
			}
		} else if item.Type == 3 {
			//微路演视频
			count, err := models.GetVideoCollectCount(user.UserId, item.Id)
			if err != nil {
				br.Msg = "获取数据失败！"
				br.ErrMsg = "获取数据失败，Err:" + err.Error()
				return
			}
			if count > 0 {
				item.IsCollect = true
			}
			if v, ok := collectVideoMap[item.Id]; ok {
				item.CollectTime = v
			}
		}
	}
	// 用户权限
	authInfo, permissionArr, e := services.GetUserRaiPermissionInfo(user.UserId, user.CompanyId)
	if e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取用户权限失败, Err: " + e.Error()
		return
	}

	// 获取默认图配置
	audioMap, videoMap, audioShareMap, videoShareMap, e := services.GetMicroRoadShowDefaultImgConfig()
	if e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取微路演列表失败, Err: " + e.Error()
		return
	}

	for i := range list {
		// 权限
		au := new(models.UserPermissionAuthInfo)
		au.SellerName = authInfo.SellerName
		au.SellerMobile = authInfo.SellerMobile
		au.HasPermission = authInfo.HasPermission
		au.OperationMode = authInfo.OperationMode
		if au.HasPermission == 1 {
			// 非宏观权限进一步判断是否有权限
			if list[i].ChartPermissionId != utils.HONG_GUAN_ID && !utils.InArrayByStr(permissionArr, list[i].ChartPermissionName) {
				au.HasPermission = 2
			}
		}
		// 无权限的弹框提示
		if au.HasPermission != 1 {
			if au.OperationMode == services.UserPermissionOperationModeCall {
				if list[i].Type == 1 {
					au.PopupMsg = services.UserPermissionPopupMsgCallActivity
				} else {
					au.PopupMsg = services.UserPermissionPopupMsgCallMicroVideo
				}
			} else {
				if list[i].Type == 1 {
					au.PopupMsg = services.UserPermissionPopupMsgApplyActivity
				} else {
					au.PopupMsg = services.UserPermissionPopupMsgApplyMicroVideo
				}
			}
		}
		list[i].AuthInfo = au
		list[i].PublishTime = utils.StrTimeToTime(list[i].PublishTime).Format(utils.FormatDate)
		// 默认图
		if list[i].BackgroundImg == "" {
			if list[i].Type == 1 {
				list[i].BackgroundImg = audioMap[list[i].ChartPermissionId]
			} else {
				list[i].BackgroundImg = videoMap[list[i].ChartPermissionId]
			}
		}
		// 分享图
		if list[i].ShareImg == "" {
			if list[i].Type == 1 {
				list[i].ShareImg = audioShareMap[list[i].ChartPermissionId]
			} else {
				list[i].ShareImg = videoShareMap[list[i].ChartPermissionId]
			}
		}
	}

	var sortList models.MicroList

	sortList = list
	sort.Sort(sortList)

	resp := new(models.MicroRoadShowListResp)
	page := paging.GetPaging(currentIndex, pageSize, total)
	resp.List = sortList
	resp.Paging = page

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