eta_mini_api/controllers/user.go

package controllers

import (
	"encoding/json"
	"eta/eta_mini_api/models"
	"eta/eta_mini_api/models/request"
	"eta/eta_mini_api/models/response"
	"eta/eta_mini_api/services"
	"eta/eta_mini_api/services/alarm_msg"
	"eta/eta_mini_api/services/go_redis"
	"eta/eta_mini_api/utils"
	"fmt"
	"strings"
	"time"
)

type UserController struct {
	BaseCommonController
}

type UserAuthController struct {
	BaseAuthController
}

// @Title 用户登录接口
// @Description 用户登录
// @Param	request	body models.LoginReq true "type json string"
// @Success 200 {object} models.LoginResp
// @router /login [post]
func (this *UserAuthController) Login() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	session := this.Session

	var req request.LoginReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析失败"
		br.ErrMsg = "参数解析失败,Err:" + err.Error()
		return
	}

	switch req.LoginType {
	case 1:
		if req.Phone == "" {
			br.Msg = "请输入手机号"
			br.ErrMsg = "请输入手机号"
			return
		}
		if req.SmsCode == "" {
			br.Msg = "请输入验证码"
			br.ErrMsg = "请输入验证码"
			return
		}
		phone := req.AreaCode + req.Phone
		item, err := models.GetMsgCode(phone, req.SmsCode)
		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
		}

	case 2:
		if req.Email == "" {
			br.Msg = "请输入邮箱"
			br.ErrMsg = "请输入邮箱"
			return
		}
		if req.SmsCode == "" {
			br.Msg = "请输入验证码"
			br.ErrMsg = "请输入验证码"
			return
		}
		item, err := models.GetMsgCode(req.Email, req.SmsCode)
		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
		}
	}
	_, errMsg, err := services.BindUser(session.UnionId, session.OpenId, req.Phone, req.Email, req.AreaCode)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "登录失败，系统处理中，请稍后重试"
		if errMsg != "" {
			br.Msg = errMsg
		}
		br.ErrMsg = "登录失败:" + err.Error()
		return
	}

	br.Msg = "登录成功"
	br.Success = true
	br.Ret = 200
}

// @Title 获取短信/邮箱验证码
// @Description 用户登录
// @Param	request	body models.LoginReq true "type json string"
// @Success 200 {object} models.LoginResp
// @router /getVerifyCode [post]
func (this *UserController) GetVerifyCode() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.Ret != 200 {
			b, _ := json.Marshal(br)
			alarm_msg.SendAlarmMsg(string(b), 1)
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()

	var req request.VerifyCodeReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if req.VerifyType != 1 && req.VerifyType != 2 {
		br.Msg = "验证方式有误"
		br.ErrMsg = fmt.Sprintf("验证方式异常<%d>", req.VerifyType)
	}

	code := utils.GetRandDigit(6)
	fmt.Println(code)
	switch req.VerifyType {
	case 1:
		if req.AreaCode == "" {
			br.Msg = "请选择区号"
			return
		}
		if req.Phone == "" {
			br.Msg = "请输入手机号"
			return
		}
		if req.AreaCode == utils.TelAreaCodeHome && !utils.ValidateMobileFormatat(req.Phone) {
			br.Msg = "您的手机号输入有误, 请检查"
			return
		}
		phoneKey := utils.CACHE_ACCESS_PHONE_LOGIN_CODE + req.AreaCode + req.Phone
		res, _ := go_redis.RedisInt(phoneKey)
		if res > 5 {
			br.Msg = "验证码发送太频繁，请稍后重试"
			return
		}
		var ok bool
		if req.AreaCode == "86" {
			ok = services.SendSmsCode(req.Phone, code)
		}
		if !ok {
			br.Msg = "请检查手机号和区号"
			br.ErrMsg = "短信验证码发送失败"
			return
		} else {
			item := new(models.MsgCode)
			item.OpenId = ""
			item.Code = code
			item.Mobile = req.AreaCode + req.Phone
			item.ExpiredIn = time.Now().Add(15 * time.Minute).Unix()
			item.CreateTime = time.Now()
			err = item.Insert()
			if err != nil {
				br.Msg = "发送失败"
				br.ErrMsg = "发送失败，Err:" + err.Error()
				return
			}
			br.Msg = "发送成功"
			isExist := go_redis.IsExist(phoneKey)
			if isExist {
				go_redis.Incr(phoneKey)
			} else {
				go_redis.SetNX(phoneKey, 1, time.Minute*15)
			}
		}
	case 2:
		if req.Email == "" {
			br.Msg = "请输入邮箱"
		}
		if !utils.ValidateEmailFormatat(req.Email) {
			br.Msg = "您的邮箱格式输入有误, 请检查"
			return
		}

		emailKey := utils.CACHE_ACCESS_EMAIL_LOGIN_CODE + req.Email
		res, _ := go_redis.RedisInt(emailKey)
		if res > 5 {
			br.Msg = "验证码发送太频繁，请稍后重试"
			return
		}

		date := time.Now()
		content := "尊敬的用户：</br>本次请求的验证码为：" + code + "（为了保障您账号的安全性，请在15分钟内完成验证。）</br>东吴期货研究团队 </br>" + fmt.Sprintf("%d年%02d月%02d日", date.Year(), date.Month(), date.Day())
		title := "东吴期货登录验证"
		result, err := utils.SendEmailByDw(title, content, req.Email)
		if err != nil {
			br.Msg = "发送失败"
			br.ErrMsg = "发送失败,Err:" + err.Error()
			return
		}
		if result {
			item := new(models.MsgCode)
			item.OpenId = ""
			item.Code = code
			item.Mobile = req.Email
			item.ExpiredIn = time.Now().Add(15 * time.Minute).Unix()
			item.CreateTime = time.Now()
			err = item.Insert()
			if err != nil {
				br.Msg = "发送失败"
				br.ErrMsg = "发送失败，Err:" + err.Error()
				return
			}
			br.Msg = "发送成功"
			isExist := go_redis.IsExist(emailKey)
			if isExist {
				go_redis.Incr(emailKey)
			} else {
				go_redis.SetNX(emailKey, 1, time.Minute*15)
			}
		} else {
			br.Msg = "发送失败"
		}
	}

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

// @Title 新增报告浏览记录
// @Description 新增报告浏览记录接口
// @Param	request	body models.ReportRecordReq true "type json string"
// @Success 200 新增成功
// @router /addReportRecord [post]
func (this *UserAuthController) AddReportRecord() {
	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 = 403
		return
	}
	var req request.ReportRecordReq
	if err := json.Unmarshal(this.Ctx.Input.RequestBody, &req); err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if req.ReportId <= 0 {
		br.Msg = "参数错误"
		br.ErrMsg = "参数错误，报告id小于等于0"
		return
	}
	reportResp, err := services.GetReportDetail(req.ReportId, user.UserId)
	if err != nil {
		br.Msg = "添加阅读记录失败"
		br.ErrMsg = "获取研报错误，Err:" + err.Error()
		return
	}
	if reportResp.Ret != 200 {
		br.Msg = reportResp.Msg
		br.ErrMsg = reportResp.ErrMsg
		return
	}
	reportDetail := reportResp.Data.Report
	reportPermissionResp, err := services.GetReportChartPermissionList(req.ReportId)
	if err != nil {
		br.Msg = "添加阅读记录失败"
		br.ErrMsg = "获取研报品种错误，Err:" + err.Error()
		return
	}
	if reportPermissionResp.Ret != 200 {
		br.Msg = reportPermissionResp.Msg
		br.ErrMsg = reportPermissionResp.ErrMsg
		return
	}
	reportPermissionList := reportPermissionResp.Data
	chartPermissionList, err := services.GetChartPermissionAllList()
	if err != nil {
		br.Msg = "添加阅读记录失败"
		br.ErrMsg = "获取研报品种列表失败，Err:" + err.Error()
		return
	}
	chartMap := make(map[int]*models.ChartPermission)
	for _, permission := range chartPermissionList.Data {
		chartMap[permission.ChartPermissionId] = permission
	}
	curTime := time.Now()
	var insertId int64
	if req.RecordId == 0 {
		// 如果不存在就新增一条记录
		permission1Ids := make([]int, 0)
		permission2Ids := make([]int, 0)
		permissionNames := make([]string, 0)
		for _, item := range reportPermissionList {
			curPermission := chartMap[item.ChartPermissionId]
			permission1Ids = append(permission1Ids, curPermission.ParentId)
			permission2Ids = append(permission2Ids, curPermission.ChartPermissionId)
			permissionNames = append(permissionNames, curPermission.PermissionName)
		}
		permission1Ids = utils.Unique(permission1Ids)
		permission2Ids = utils.Unique(permission2Ids)
		permissionNames = utils.Unique(permissionNames)
		userReadRecord := &models.UserReadRecord{
			UserId:              user.UserId,
			ReportId:            req.ReportId,
			ReportTitle:         reportDetail.Title,
			ChartPermissionName: strings.Join(permissionNames, ","),
			ClassifyId1:         reportDetail.ClassifyIdFirst,
			ClassifyName1:       reportDetail.ClassifyNameFirst,
			ClassifyId2:         reportDetail.ClassifyIdSecond,
			ClassifyName2:       reportDetail.ClassifyNameSecond,
			ClassifyId3:         reportDetail.ClassifyIdThird,
			ClassifyName3:       reportDetail.ClassifyNameThird,
			Timestamp:           int(curTime.Unix()),
			CreateTime:          curTime,
			CreateDate:          curTime.Format(utils.FormatDate),
			ReportType:          utils.ReportTypeEta,
		}
		insertId, err = userReadRecord.Insert()
		if err != nil {
			br.Msg = "添加阅读记录失败"
			br.ErrMsg = "添加阅读记录失败，Err:" + err.Error()
			return
		}

		userReadPermission1 := make([]*models.UserReadPermission1, 0)
		for _, id := range permission1Ids {
			userReadPermission1 = append(userReadPermission1, &models.UserReadPermission1{
				UserReadRecordId:  int(insertId),
				ChartPermissionId: id,
				PermissionName:    chartMap[id].PermissionName,
			})
		}
		err = models.UserReadPermission1MultiInsert(userReadPermission1)
		if err != nil {
			br.Msg = "添加阅读记录失败"
			br.ErrMsg = "添加阅读记录失败，Err:" + err.Error()
			return
		}
		userReadPermission2 := make([]*models.UserReadPermission2, 0)
		for _, id := range permission2Ids {
			userReadPermission2 = append(userReadPermission2, &models.UserReadPermission2{
				UserReadRecordId:  int(insertId),
				ChartPermissionId: id,
			})
		}
		err = models.UserReadPermission2MultiInsert(userReadPermission2)
		if err != nil {
			br.Msg = "添加阅读记录失败"
			br.ErrMsg = "添加阅读记录失败，Err:" + err.Error()
			return
		}
	} else {
		// 如果存在就计算停留时间
		userRecord, err := models.GetUserReadRecordListById(req.RecordId)
		if err != nil {
			if err.Error() == utils.ErrNoRow() {
				br.Msg = "更新阅读记录不存在"
				return
			}
			br.Msg = "更新阅读记录失败"
			br.ErrMsg = "更新阅读记录失败，Err:" + err.Error()
			return
		}
		stayTime := curTime.Unix() - int64(userRecord.Timestamp)
		stayTimeStr := utils.SecondsToHMS(stayTime)
		err = models.UpdateUserReadRecordById(req.RecordId, int(curTime.Unix()), int(stayTime), stayTimeStr)
		if err != nil {
			br.Msg = "更新阅读记录失败"
			br.ErrMsg = "更新阅读记录失败，Err:" + err.Error()
			return
		}
	}
	resp := new(response.UserReadRecordResp)
	resp.RecordId = insertId

	br.Msg = "添加阅读记录成功"
	br.Ret = 200
	br.Success = true
	br.Data = resp
}

// @Title 新增pdf报告浏览记录
// @Description 新增pdf报告浏览记录接口
// @Param	request	body models.ReportPdfRecordReq true "type json string"
// @Success 200 新增成功
// @router /pdf/addReportRecord [post]
func (this *UserAuthController) AddReportPdfRecord() {
	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 = 403
		return
	}
	var req request.ReportPdfRecordReq
	if err := json.Unmarshal(this.Ctx.Input.RequestBody, &req); err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if req.ReportPdfId <= 0 {
		br.Msg = "参数错误"
		br.ErrMsg = "参数错误，报告id小于等于0"
		return
	}
	reportPdf, err := models.GetReportPdfById(req.ReportPdfId)
	if err != nil {
		if err.Error() == utils.ErrNoRow() {
			br.Msg = "报告不存在或已删除"
			return
		}
		br.Msg = "添加阅读记录失败"
		br.ErrMsg = "获取研报错误，Err:" + err.Error()
		return
	}
	reportClassifyId := services.GetReportPdfClassify(reportPdf)
	reportPermissionResp, err := services.GetChartPermissionListByClassifyId(reportClassifyId, 0)
	if err != nil {
		br.Msg = "添加阅读记录失败"
		br.ErrMsg = "获取研报品种错误，Err:" + err.Error()
		return
	}
	if reportPermissionResp.Ret != 200 {
		br.Msg = reportPermissionResp.Msg
		br.ErrMsg = reportPermissionResp.ErrMsg
		return
	}
	reportPermissionList := reportPermissionResp.Data
	chartPermissionList, err := services.GetChartPermissionAllList()
	if err != nil {
		br.Msg = "添加阅读记录失败"
		br.ErrMsg = "获取研报品种列表失败，Err:" + err.Error()
		return
	}
	chartMap := make(map[int]*models.ChartPermission)
	for _, permission := range chartPermissionList.Data {
		chartMap[permission.ChartPermissionId] = permission
	}
	curTime := time.Now()
	var insertId int64
	if req.RecordId == 0 {
		// 如果不存在就新增一条记录
		permission1Ids := make([]int, 0)
		permission2Ids := make([]int, 0)
		permissionNames := make([]string, 0)
		for _, item := range reportPermissionList {
			curPermission := chartMap[item.ChartPermissionId]
			permission1Ids = append(permission1Ids, curPermission.ParentId)
			permission2Ids = append(permission2Ids, curPermission.ChartPermissionId)
			permissionNames = append(permissionNames, curPermission.PermissionName)
		}
		permission1Ids = utils.Unique(permission1Ids)
		permission2Ids = utils.Unique(permission2Ids)
		permissionNames = utils.Unique(permissionNames)
		userReadRecord := &models.UserReadRecord{
			UserId:              user.UserId,
			ReportId:            reportPdf.ReportPdfId,
			ReportTitle:         reportPdf.Title,
			ChartPermissionName: strings.Join(permissionNames, ","),
			ClassifyId1:         reportPdf.ClassifyIdFirst,
			ClassifyName1:       reportPdf.ClassifyNameFirst,
			ClassifyId2:         reportPdf.ClassifyIdSecond,
			ClassifyName2:       reportPdf.ClassifyNameSecond,
			Timestamp:           int(curTime.Unix()),
			CreateTime:          curTime,
			CreateDate:          curTime.Format(utils.FormatDate),
			ReportType:          utils.ReportTypePdf,
		}
		insertId, err = userReadRecord.Insert()
		if err != nil {
			br.Msg = "添加阅读记录失败"
			br.ErrMsg = "添加阅读记录失败，Err:" + err.Error()
			return
		}

		userReadPermission1 := make([]*models.UserReadPermission1, 0)
		for _, id := range permission1Ids {
			userReadPermission1 = append(userReadPermission1, &models.UserReadPermission1{
				UserReadRecordId:  int(insertId),
				ChartPermissionId: id,
				PermissionName:    chartMap[id].PermissionName,
			})
		}
		err = models.UserReadPermission1MultiInsert(userReadPermission1)
		if err != nil {
			br.Msg = "添加阅读记录失败"
			br.ErrMsg = "添加阅读记录失败，Err:" + err.Error()
			return
		}
		userReadPermission2 := make([]*models.UserReadPermission2, 0)
		for _, id := range permission2Ids {
			userReadPermission2 = append(userReadPermission2, &models.UserReadPermission2{
				UserReadRecordId:  int(insertId),
				ChartPermissionId: id,
			})
		}
		err = models.UserReadPermission2MultiInsert(userReadPermission2)
		if err != nil {
			br.Msg = "添加阅读记录失败"
			br.ErrMsg = "添加阅读记录失败，Err:" + err.Error()
			return
		}
		count, err := models.GetUserReadRecordCountByReportPdfIdAndUserId(req.ReportPdfId, user.UserId)
		if err != nil {
			br.Msg = "添加阅读记录失败"
			br.ErrMsg = "获取阅读记录失败，Err:" + err.Error()
			return
		}
		if count > 1 {
			err = models.UpdateReportPdfPv(req.ReportPdfId)
			if err != nil {
				br.Msg = "添加研报阅读记录失败"
				br.ErrMsg = "更新阅读记录失败，Err:" + err.Error()
				return
			}
		} else {
			err = models.UpdateReportPdfUvAndPv(req.ReportPdfId)
			if err != nil {
				br.Msg = "添加研报阅读记录失败"
				br.ErrMsg = "更新阅读记录失败，Err:" + err.Error()
				return
			}
		}
	} else {
		// 如果存在就计算停留时间
		userRecord, err := models.GetUserReadRecordListById(req.RecordId)
		if err != nil {
			if err.Error() == utils.ErrNoRow() {
				br.Msg = "更新阅读记录不存在"
				return
			}
			br.Msg = "更新阅读记录失败"
			br.ErrMsg = "更新阅读记录失败，Err:" + err.Error()
			return
		}
		stayTime := curTime.Unix() - int64(userRecord.Timestamp)
		stayTimeStr := utils.SecondsToHMS(stayTime)
		err = models.UpdateUserReadRecordById(req.RecordId, int(curTime.Unix()), int(stayTime), stayTimeStr)
		if err != nil {
			br.Msg = "更新阅读记录失败"
			br.ErrMsg = "更新阅读记录失败，Err:" + err.Error()
			return
		}
	}
	resp := new(response.UserReadRecordResp)
	resp.RecordId = insertId

	br.Msg = "添加阅读记录成功"
	br.Ret = 200
	br.Success = true
	br.Data = resp
}

// AreaCodeList
// @Title 手机号区号列表
// @Description 手机号区号列表
// @Success 200 Ret=200 获取成功
// @router /area_code/list [get]
func (this *UserController) AreaCodeList() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()

	resp := make([]response.AreaCodeListResp, 0)
	confValue, e := models.GetConfigDetailByCode(models.ConfAreaCodeListKey)
	if e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取手机号区号配置失败, Err: " + e.Error()
		return
	}
	if confValue == "" {
		br.Msg = "获取失败"
		br.ErrMsg = "手机号区号配置为空"
		return
	}
	if e := json.Unmarshal([]byte(confValue), &resp); e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "手机号区号配置有误"
		return
	}

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

// 用户品种信息
// @Title 用户信息
// @Description 用户信息
// @Success 200 Ret=200 获取成功
// @router /info [get]
func (this *UserAuthController) Info() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	user := this.User

	if user == nil {
		user = &models.User{}
	}
	seller, err := models.GetSellerById(user.SellerId)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "查询失败"
		br.ErrMsg = "查询失败，系统异常，Err:" + err.Error()
		return
	}
	private, err := services.GetPrivateChartPermissionList()
	if err != nil {
		br.Msg = "查询失败"
		br.ErrMsg = "查询失败，系统异常，Err:" + err.Error()
		return
	}
	if private.Ret != 200 {
		br.Msg = private.Msg
		br.ErrMsg = private.ErrMsg
		return
	}
	userPermissionIds, err := models.GetUserChartPermissionIdByUserId(user.UserId)
	if err != nil {
		br.Msg = "查看权限失败"
		br.ErrMsg = "查看权限失败，系统异常，Err:" + err.Error()
		return
	}
	userPermissionMap := make(map[int]struct{})
	for _, v := range userPermissionIds {
		userPermissionMap[v] = struct{}{}
	}
	if seller == nil {
		// 添加默认的销售电话
		seller = &models.SysUser{
			Phone:    utils.DefaultPhone,
			AreaCode: utils.DefaultAreaCode,
		}
	}
	var hasPermission string
	for _, v := range private.Data {
		for _, vv := range v.Child {
			if _, ok := userPermissionMap[vv.ChartPermissionId]; ok {
				hasPermission = "私有权限"
				break
			}
		}
	}
	if hasPermission == "" || user.Status == utils.UserStatusNo {
		hasPermission = "公有权限"
	}
	miniconf, err := models.GetMiniConf()
	if err != nil {
		br.Msg = "获取配置失败"
		br.ErrMsg = "获取配置失败，系统异常，Err:" + err.Error()
		return
	}

	userView := &models.UserView{
		Headimgurl:     miniconf["Logo"],
		RealName:       user.RealName,
		Phone:          user.Phone,
		AreaCode:       user.AreaCode,
		SellerName:     seller.SysRealName,
		SellerPhone:    seller.Phone,
		SellerAreaCode: seller.AreaCode,
		HasPermission:  hasPermission,
		Email:          user.Email,
		Componey:       user.Company,
		IsRegistered:   user.IsRegistered,
		Status:         user.Status,
		ValidEndTime:   user.ValidEndTime.Format(utils.FormatDate),
	}

	if user.ValidEndTime.IsZero() {
		userView.ValidEndTime = ""
	}
	br.Data = userView
	br.Msg = "查询成功"
	br.Success = true
	br.Ret = 200
}

// PermissionList
// @Title 用户个人权限列表
// @Description 用户个人权限列表
// @Param	request	body models.LoginReq true "type json string"
// @Success 200 {object} []models.ChartPermissionTreeView
// @router /permission/list [get]
func (this *UserAuthController) PermissionList() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	user := this.User
	permissionIds, err := models.GetUserChartPermissionIdByUserId(user.UserId)
	if err != nil {
		br.Msg = "查询用户权限失败"
		br.ErrMsg = "查询用户权限失败，系统异常，Err:" + err.Error()
		return
	}
	userPermissionMap := make(map[int]struct{})
	for _, v := range permissionIds {
		userPermissionMap[v] = struct{}{}
	}
	// 查询公有权限
	var publicView []*models.ChartPermissionTreeView
	publicResp, err := services.GetPublicChartPermissionList()
	if err != nil {
		br.Msg = "查询公有权限失败"
		br.ErrMsg = "查询私有权限失败，系统异常，Err:" + err.Error()
	}
	if publicResp.Ret != 200 {
		br.Msg = publicResp.Msg
		br.ErrMsg = publicResp.ErrMsg
		return
	}
	publicView = publicResp.Data

	// 如果是正式用户，则查询私有权限
	var privateView []*models.ChartPermissionTreeView
	if user.Status == utils.UserStatusFormal {
		privateResp, err := services.GetPrivateChartPermissionList()
		if err != nil {
			br.Msg = "查询私有权限失败"
			br.ErrMsg = "查询私有权限失败，系统异常，Err:" + err.Error()
		}
		if privateResp.Ret != 200 {
			br.Msg = privateResp.Msg
			br.ErrMsg = privateResp.ErrMsg
			return
		}

		for _, v := range privateResp.Data {
			IsAdd := false
			curPermissionView := &models.ChartPermissionTreeView{
				ChartPermissionId: v.ChartPermissionId,
				PermissionName:    v.PermissionName,
				IsPublic:          v.IsPublic,
				Sort:              v.Sort,
				Child:             make([]*models.ChartPermissionTreeView, 0),
			}
			for _, vv := range v.Child {
				if _, ok := userPermissionMap[vv.ChartPermissionId]; ok {
					curPermissionView.Child = append(curPermissionView.Child, vv)
					IsAdd = true
				}
			}
			if IsAdd {
				privateView = append(privateView, curPermissionView)
			}
		}
	}
	privateAloneView := make([]*models.ChartPermissionTreeView, 0)
	for _, vi := range privateView {
		isHas := false
		for _, vb := range publicView {
			if vi.ChartPermissionId == vb.ChartPermissionId {
				isHas = true
				vb.Child = append(vb.Child, vi.Child...)
				break
			}
		}
		if !isHas {
			privateAloneView = append(privateAloneView, vi)
		}
	}
	publicView = append(publicView, privateAloneView...)
	for _, vi := range publicView {
		vi.ChartPermissionType = utils.PermissionTypeEta
		for _, vi := range vi.Child {
			vi.ChartPermissionType = utils.PermissionTypeEta
		}
	}

	br.Data = publicView
	br.Msg = "查询成功"
	br.Success = true
	br.Ret = 200
}

// PermissionList
// @Title 用户已购权限列表
// @Description 用户已购权限列表
// @Param	request	body models.LoginReq true "type json string"
// @Success 200 {object} []models.ChartPermissionTreeView
// @router /purchased/list [get]
func (this *UserAuthController) PurchasedPermission() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	user := this.User
	permissionIds, err := models.GetUserChartPermissionIdByUserId(user.UserId)
	if err != nil {
		br.Msg = "查询用户权限失败"
		br.ErrMsg = "查询用户权限失败，系统异常，Err:" + err.Error()
		return
	}
	permissionMap := make(map[int]struct{})
	for _, v := range permissionIds {
		permissionMap[v] = struct{}{}
	}
	// 查询私有权限
	privateResp, err := services.GetPrivateChartPermissionList()
	if err != nil {
		br.Msg = "查询私有权限失败"
		br.ErrMsg = "查询私有权限失败，系统异常，Err:" + err.Error()
	}
	if privateResp.Ret != 200 {
		br.Msg = privateResp.Msg
		br.ErrMsg = privateResp.ErrMsg
		return
	}

	var privateView []*models.ChartPermissionTreeView
	for _, v := range privateResp.Data {
		IsAdd := false
		curPermissionView := &models.ChartPermissionTreeView{
			ChartPermissionId:   v.ChartPermissionId,
			PermissionName:      v.PermissionName,
			IsPublic:            v.IsPublic,
			Sort:                v.Sort,
			Child:               make([]*models.ChartPermissionTreeView, 0),
			ChartPermissionType: utils.PermissionTypeEta,
		}
		for _, vv := range v.Child {
			if _, ok := permissionMap[vv.ChartPermissionId]; ok && vv.ParentId != 0 {
				vv.ChartPermissionType = utils.PermissionTypeEta
				curPermissionView.Child = append(curPermissionView.Child, vv)
				IsAdd = true
			}
		}
		if IsAdd {
			privateView = append(privateView, curPermissionView)
		}
	}
	for _, vi := range privateView {
		vi.Child = append(vi.Child, &models.ChartPermissionTreeView{
			ChartPermissionId:   -1,
			PermissionName:      utils.MINI_CUSTOM_PERMISSION_NAME,
			IsPublic:            0,
			Sort:                0,
			ChartPermissionType: utils.ReportTypePdf,
		})
	}

	br.Data = privateView
	br.Msg = "查询成功"
	br.Success = true
	br.Ret = 200
}