hongze_cygx/controllers/user.go

package controllers

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

//用户
type UserController struct {
	BaseAuthController
}

// @Title 登录
// @Description 登录接口
// @Param	request	body models.LoginReq true "type json string"
// @Success 200 {object} models.LoginResp
// @router /login [post]
func (this *UserController) Login() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	var req models.LoginReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	user := this.User
	if user == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录"
		br.Ret = 408
		return
	}

	unionId := this.User.UnionId
	openId := this.User.OpenId
	if unionId == "" {
		br.Msg = "参数错误"
		br.ErrMsg = "参数错误，unionId 为空"
		return
	}
	if req.LoginType == 1 || req.LoginType == 3 {
		if req.Mobile == "" {
			br.Msg = "参数错误"
			br.ErrMsg = "参数错误，手机号为空 为空"
			return
		}
		if req.LoginType == 3 {
			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
			}
		}
		req.Mobile = strings.Trim(req.Mobile, " ")
	} else if req.LoginType == 2 {
		if req.Email == "" {
			br.ErrMsg = "邮箱不能为空,请输入邮箱"
			br.Msg = "邮箱不能为空,请输入邮箱"
			return
		}
		if !utils.ValidateEmailFormatat(req.Email) {
			br.ErrMsg = "邮箱格式错误，请重新输入"
			br.Msg = "邮箱格式错误，请重新输入"
			return
		}
		item, err := models.GetMsgCode(req.Email, 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
		}
	} else {
		br.Msg = "无效的登录方式"
		br.ErrMsg = "无效的登录方式,Err:" + err.Error()
		return
	}
	if len(req.Mobile) >= 11 && req.CountryCode == "" {
		req.CountryCode = "86"
	}
	user, err = services.BindWxUser(openId, req.Mobile, req.Email, req.CountryCode)
	userId := user.UserId
	var token string
	tokenItem, err := models.GetTokenByOpenId(openId)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "登录失败"
		br.ErrMsg = "登录失败，获取token失败:" + err.Error()
		return
	}

	if tokenItem == nil || (err != nil && err.Error() == utils.ErrNoRow()) {
		timeUnix := time.Now().Unix()
		timeUnixStr := strconv.FormatInt(timeUnix, 10)
		token = utils.MD5(openId) + utils.MD5(timeUnixStr)
		//新增session
		{
			session := new(models.CygxSession)
			session.OpenId = unionId
			session.UnionId = unionId
			session.UserId = userId
			session.CreatedTime = time.Now()
			session.LastUpdatedTime = time.Now()
			session.ExpireTime = time.Now().AddDate(0, 1, 0)
			session.AccessToken = token
			err = models.AddSession(session)
			if err != nil {
				br.Msg = "登录失败"
				br.ErrMsg = "登录失败，新增用户session信息失败:" + err.Error()
				return
			}
		}
	} else {
		token = tokenItem.AccessToken
	}

	//新增登录日志
	{
		loginLog := new(models.WxUserLog)
		loginLog.UserId = userId
		loginLog.OpenId = unionId
		loginLog.Mobile = req.Mobile
		loginLog.Email = req.Email
		loginLog.CreateTime = time.Now()
		loginLog.Handle = "wechat_user_login"
		loginLog.Remark = token
		go models.AddWxUserLog(loginLog)
	}
	//添加邀请绑定关系
	{
		if req.ShareUserCode != "" {
			count, _ := models.GetUserInviteeCount(userId)
			if count == 0 {
				userItem := new(models.UserInvitee)
				userItem.CreateTime = time.Now()
				userItem.InviteedUserId = strconv.Itoa(userId)
				userItem.InviteeUserId = req.ShareUserCode
				models.AddUserInvite(userItem)
			}
		}
	}
	resp := new(models.LoginResp)
	resp.UserId = userId
	resp.Authorization = token
	if user.CompanyId == 1 {
		resp.IsPotential = true
	}
	br.Ret = 200
	br.Success = true
	br.Data = resp
	br.Msg = "登录成功"
}

// @Title 获取用户详情
// @Description 获取用户详情接口
// @Success 200 {object} models.UserDetail
// @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
	}
	uid := user.UserId
	var hasPermission int
	detail := new(models.UserDetail)
	if uid > 0 {
		var err error
		detail, err = models.GetUserDetailByUserId(uid)
		if err != nil && err.Error() != utils.ErrNoRow() {
			br.Msg = "获取信息失败"
			br.ErrMsg = "获取信息失败,Err:" + err.Error()
			return
		}

		userRecord, _ := models.GetUserRecordByUserId(uid, utils.WxPlatform)
		if userRecord != nil {
			detail.NickName = userRecord.NickName
			detail.Headimgurl = userRecord.Headimgurl
			if detail.Headimgurl == "" {
				userRecord, _ = models.GetUserRecordByUserId(uid, 1)
				if userRecord != nil {
					detail.NickName = userRecord.NickName
					detail.Headimgurl = userRecord.Headimgurl
				}
			}
		}
		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 {
				detail.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
					}
					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)
						}
					}
					detail.PermissionName = permissionStr
				} else {
					hasPermission = 1
				}
				detail.SellerName = companyItem.SellerName
				detail.SellerMobile = companyItem.Mobile
			} else {
				hasPermission = 1
			}
		} else {
			//判断是否已经申请过
			applyCount, err := models.GetApplyRecordCount(uid)
			if err != nil && err.Error() != utils.ErrNoRow() {
				br.Msg = "获取信息失败"
				br.ErrMsg = "判断是否已申请过试用失败，Err:" + err.Error()
				return
			}
			if applyCount > 0 {
				hasPermission = 3
			} else {
				hasPermission = 2
			}
			detail.CompanyName = detail.Note
		}
		detail.HasPermission = hasPermission

	} else {
		ur, _ := models.GetUserRecordByOpenId(user.OpenId)
		if ur != nil {
			detail.NickName = ur.NickName
			detail.Email = ur.BindAccount
			detail.Mobile = ur.BindAccount
			detail.NickName = ur.NickName
			detail.Headimgurl = ur.Headimgurl
		}
		hasPermission = 2
		detail.HasPermission = hasPermission
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = detail
}

// @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.GetUserRecordByUserId(uid, utils.WxPlatform)
		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   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
	}
	var articleIds []string
	for _, v := range list {
		articleIds = append(articleIds, strconv.Itoa(v.ArticleId))
	}
	articleIdStr := strings.Join(articleIds, ",")
	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
			}
		}
	}
	lenList := len(list)
	for i := 0; i < lenList; i++ {
		item := list[i]
		article := articleMap[item.ArticleId]
		list[i].Title = article.Title
		list[i].TitleEn = article.TitleEn
		list[i].UpdateFrequency = article.UpdateFrequency
		list[i].CreateDate = article.CreateDate
		list[i].PublishDate = article.PublishDate
		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 := new(models.ArticleCollectListResp)
	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.ArticleInterviewApplyListResp
// @router /interview/apply/list [get]
func (this *UserController) InterviewApplyList() {
	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.GetArticleUserInterviewApplyCount(userId)
	if err != nil {
		br.Msg = "获取数据失败"
		br.ErrMsg = "获取数据失败，Err:" + err.Error()
		return
	}
	list, err := models.GetArticleUserInterviewApplyList(startSize, pageSize, userId)
	if err != nil {
		br.Msg = "获取数据失败"
		br.ErrMsg = "获取数据失败，Err:" + err.Error()
		return
	}
	var articleIds []string
	for _, v := range list {
		articleIds = append(articleIds, strconv.Itoa(v.ArticleId))
	}
	articleIdStr := strings.Join(articleIds, ",")
	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
			}
		}
	}
	lenList := len(list)
	for i := 0; i < lenList; i++ {
		item := list[i]
		article := articleMap[item.ArticleId]
		bodySub, _ := services.GetReportContentTextSub(article.Body)
		list[i].Title = article.Title
		list[i].TitleEn = article.TitleEn
		list[i].UpdateFrequency = article.UpdateFrequency
		list[i].CreateDate = article.CreateDate
		list[i].PublishDate = article.PublishDate
		list[i].Body = bodySub
		list[i].Abstract = article.Abstract
		list[i].CategoryName = article.CategoryName
		list[i].SubCategoryName = article.SubCategoryName
		list[i].ExpertBackground = article.ExpertBackground
		list[i].ExpertNumber = article.ExpertNumber
	}
	page := paging.GetPaging(currentIndex, pageSize, total)
	resp := new(models.ArticleInterviewApplyListResp)
	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.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
	}
	var articleIds []string
	for _, v := range list {
		articleIds = append(articleIds, strconv.Itoa(v.ArticleId))
	}
	articleIdStr := strings.Join(articleIds, ",")
	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
			}
		}
	}
	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].TitleEn = article.TitleEn
			list[i].UpdateFrequency = article.UpdateFrequency
			list[i].CreateDate = article.CreateDate
			list[i].PublishDate = article.PublishDate
			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 := new(models.ArticleBrowseHistoryListResp)
	resp.List = list
	resp.Paging = page
	br.Msg = "获取成功！"
	br.Ret = 200
	br.Success = true
	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
	tryType := req.TryType
	detailId := req.DetailId
	if tryType == "Article" {
		detail, err := models.GetArticleDetailById(detailId)
		if err != nil {
			br.Msg = "获取信息失败"
			br.ErrMsg = "获取信息失败,Err:" + err.Error()
			return
		}
		title = detail.Title
	} 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
	}

	fmt.Println(title)
	//缓存校验
	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
		}
	}
	applyMethod := ""
	cnf, _ := models.GetConfigByCode("tpl_msg")
	if cnf != nil {
		if sellerItem != nil {
			cnf.ConfigValue = sellerItem.Mobile
			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 {
				applyMethod = companyItem.Status + "客户申请"
				if detailId > 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 {
						applyMethod = "试用暂停客户"
					} else {
						if companyItem.Status == "正式" || companyItem.Status == "试用" {
							applyMethod = companyItem.Status + "客户申请,无对应权限"
						} else if companyItem.Status == "冻结" || companyItem.Status == "流失" {
							applyMethod = companyItem.Status + "客户"
						}
					}
					applyMethod = applyMethod + "," + title
				}
			}
		} 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 {
				applyMethod = "FICC客户"
			} else {
				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
			}
			fmt.Println("推送消息", req.RealName, req.CompanyName, mobile, openIpItem.OpenId, applyMethod)
			utils.FileLog.Info("推送消息 %s %s,%s,%s,%s", req.RealName, req.CompanyName, mobile, openIpItem.OpenId, applyMethod)
			go services.SendPermissionApplyTemplateMsg(req.RealName, req.CompanyName, mobile, openIpItem.OpenId, applyMethod)
		}
	}
	err = models.AddApplyRecord(&req, user.Mobile, user.CompanyName, uid, user.CompanyId)
	if err != nil {
		br.Msg = "申请失败"
		br.ErrMsg = "申请失败，Err:" + err.Error()
		return
	}
	//添加成功后，设置5分钟缓存，不允许重复添加
	//utils.Rc.SetNX(cacheKey, user.Mobile, time.Second*60)

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

// @Title 是否需要填写区号
// @Description 获取是否需要填写区号接口
// @Success 200 {object} models.CountryCode
// @router /countryCcode/isNeedAdd [get]
func (this *UserController) CountryCcode() {
	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
	}
	if uid == 0 {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，用户信息为空"
		br.Ret = 408
		return
	}
	resp := new(models.CountryCode)
	if user.CountryCode == "" && len(user.Mobile) >= 11 {
		err := models.ChangeUserOutboundMobileByMobile(uid)
		if err != nil {
			br.Msg = "操作失败"
			br.ErrMsg = "操作失败,Err:" + err.Error()
			return
		}
	}
	if user.CountryCode == "" && user.Mobile != "" && len(user.Mobile) < 11 {
		resp.IsNeedAddCountryCode = true
	}
	if user.OutboundMobile != "" {
		resp.IsNeedAddCountryCode = false
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// @Title 上传用户区号
// @Description 上传用户区号接口
// @Param	request	body models.CountryCodeItem true "type json string"
// @Success Ret=200 新增成功
// @router /countryCcode/Add [POST]
func (this *UserController) AddCountryCcode() {
	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.CountryCodeItem
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	err = models.AddCountryCode(req.CountryCode, user)
	if err != nil {
		br.Msg = "获取信息失败"
		br.ErrMsg = "获取信息失败,Err:" + err.Error()
		return
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "新增成功"
}

// @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 !utils.ValidateFixedTelephoneFormatatEasy(req.OutboundMobile) {
		br.Msg = "号码格式有误，请重新填写！"
		br.ErrMsg = "号码格式有误，请重新填写" + req.OutboundMobile
		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)
		}
	}
	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.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
	}
	userId := this.User.UserId
	listActcivity, err := models.GetActivityAskList(userId)
	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)
	resp.List = listActcivity
	br.Msg = "获取成功！"
	br.Ret = 200
	br.Success = true
	br.Data = resp
}

// @Title 是否展示免费试用按钮
// @Description 获取是否展示免费试用按钮接口
// @Param	request	body models.IsShow true "type json string"
// @Success 200
// @router /isShow/freeButton [get]
func (this *UserController) IsShow() {
	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
	}
	var resp models.IsShow
	detail, err := models.GetConfigByCode("free_trial_card")
	if err != nil {
		br.Msg = "获取数据失败"
		br.ErrMsg = "城市配置信息失败，Err:" + err.Error()
		return
	}
	companyDetail, err := models.GetCompanyDetailByIdGroup(user.CompanyId)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "获取数据失败！"
		br.ErrMsg = "获取客户详情失败，Err:" + err.Error()
		return
	}
	count, err := models.CountCygxUserFreeeButton(user.UserId)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "获取数据失败！"
		br.ErrMsg = "获取客户详情失败，Err:" + err.Error()
		return
	}
	if companyDetail != nil {
		if detail.ConfigValue == "1" && (companyDetail.Status == "正式" || companyDetail.Status == "试用" || companyDetail.Status == "永续") && count == 0 {
			resp.IsShow = true
		}
	}
	br.Ret = 200
	br.Success = true
	br.Data = resp
}

// @Title 隐藏当天的按钮
// @Description 隐藏当天的按钮接口
// @Success 200
// @router /freeButton/update [post]
func (this *UserController) FreeButtonUpdate() {
	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
	}
	count, err := models.CountCygxUserFreeeButtonByUser(user.UserId)
	if err != nil {
		br.Msg = "获取数据失败！"
		br.ErrMsg = "获取客户详情失败，Err:" + err.Error()
		return
	}
	if count == 0 {
		item := new(models.CygxUserFreeeButton)
		item.UserId = user.UserId
		item.CompanyId = user.CompanyId
		item.CreateTime = time.Now()
		item.ModifyTime = time.Now()
		item.EffectiveTime = time.Now().Format(utils.FormatDate)
		_, err := models.AddCygxUserFreeeButton(item)
		if err != nil {
			br.Msg = "操作失败！"
			br.ErrMsg = "获取客户详情失败，Err:" + err.Error()
			return
		}
	} else {
		err := models.UpdateCygxUserFreeeButton(user.UserId)
		if err != nil {
			br.Msg = "操作失败！"
			br.ErrMsg = "获取客户详情失败，Err:" + err.Error()
			return
		}
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "操作成功！"
}

// @Title 权限弹窗是否展示免费月卡
// @Description 获取权限弹窗是否展示免费月卡接口
// @Param	request	body models.IsShow true "type json string"
// @Success 200
// @router /isShow/alert [get]
func (this *UserController) AlertIsShow() {
	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
	}
	var resp models.IsShow
	detail, err := models.GetConfigByCode("free_trial_card")
	if err != nil {
		br.Msg = "获取数据失败"
		br.ErrMsg = "城市配置信息失败，Err:" + err.Error()
		return
	}
	if user.CompanyId == 1 && detail.ConfigValue == "1" {
		resp.IsShow = true
	}
	br.Ret = 200
	br.Success = true
	br.Data = resp
}

// @Title 分享的时候是否展示免费月卡
// @Description 获取权限弹窗是否展示免费月卡接口
// @Param	request	body models.IsShow true "type json string"
// @Success 200
// @router /isShow/share [get]
func (this *UserController) ShareIsShow() {
	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
	}
	var resp models.IsShow
	detail, err := models.GetConfigByCode("free_trial_card")
	if err != nil {
		br.Msg = "获取数据失败"
		br.ErrMsg = "城市配置信息失败，Err:" + err.Error()
		return
	}
	if user.CompanyId != 16 && detail.ConfigValue == "1" {
		resp.IsShow = true
	}
	br.Ret = 200
	br.Success = true
	br.Data = resp
}