eta_mini_ht_api/controllers/user/user_controller.go

package user

import (
	"eta/eta_mini_ht_api/common/component/cache"
	logger "eta/eta_mini_ht_api/common/component/log"
	"eta/eta_mini_ht_api/common/exception"
	authUtils "eta/eta_mini_ht_api/common/utils/auth"
	"eta/eta_mini_ht_api/controllers"
	"eta/eta_mini_ht_api/service/user"
	"fmt"
)

// UserController Operations about Users
type UserController struct {
	controllers.BaseController
	redis *cache.RedisCache
}

func (u *UserController) Prepare() {
	u.redis = cache.GetInstance()
}

type LoginCode struct {
	Code int    `json:"code"`
	Msg  string `json:"msg"`
}

// Get @Title GetAll
// @Description get all Users
// @Success 200 {object} models.User
// @router / [get]
func (u *UserController) Get() {
	logger.Warn("查询用户列表:%s")
	fmt.Print("查询用户列表")
	u.ServeJSON()
}

type FeedbackReq struct {
	Mobile  string `json:"mobile"`
	Message string `json:"message"`
}

type FollowAnalystReq struct {
	AnalystId   int    `json:"analystId"`
	AnalystName string `json:"analystName"`
	FollowType  string `json:"followType"`
	Mobile      string `json:"mobile"`
	ByName      bool   `json:"byName"`
}

// Feedback  用户意见反馈
// @Summary 用户意见反馈
// @Description 用户意见反馈
// @Success 200 {object} controllers.BaseResponse
// @router /feedback [post]
func (u *UserController) Feedback() {
	controllers.Wrap(&u.BaseController, func() (result *controllers.WrapData, err error) {
		result = u.InitWrapData("提交反馈失败")
		feedback := new(FeedbackReq)
		u.GetPostParams(feedback)
		if !authUtils.IsValidMobile(feedback.Mobile) {
			u.FailedResult("手机号非法", result)
			err = exception.New(exception.IllegalPhoneNumber)
			return
		}
		var userInfo user.User
		userInfo = u.Data["user"].(user.User)
		if userInfo.Mobile != feedback.Mobile {
			u.FailedResult("非当前用户的手机号提交", result)
			err = exception.New(exception.NotCurrentUserError)
			return
		}
		if feedback.Message == "" {
			u.FailedResult("反馈信息不能为空", result)
			err = exception.New(exception.FeedBackMsgEmpty)
			return
		}
		err = user.FeedBack(userInfo.Id, feedback.Mobile, feedback.Message)
		if err != nil {
			err = exception.New(exception.FeedBackError)
			u.FailedResult("提交反馈失败", result)
			return
		}
		u.SuccessResult("提交反馈成功", nil, result)
		return
	})
}

type FollowResp struct {
	AnalystId    int    `json:"analystId"`
	FollowedType string `json:"FollowedType"`
}

// FollowAnalyst  关注研究员
// @Summary 关注研究员
// @Description 关注研究员
// @Success 200 {object} controllers.BaseResponse
// @router /followAnalyst [post]
func (u *UserController) FollowAnalyst() {
	controllers.Wrap(&u.BaseController, func() (result *controllers.WrapData, err error) {
		result = u.InitWrapData("")
		followAnalyst := new(FollowAnalystReq)
		u.GetPostParams(followAnalyst)
		if !authUtils.IsValidMobile(followAnalyst.Mobile) {
			u.FailedResult("手机号非法", result)
			err = exception.New(exception.IllegalPhoneNumber)
			return
		}
		var userInfo user.User
		userInfo = u.Data["user"].(user.User)
		if userInfo.Mobile != followAnalyst.Mobile {
			u.FailedResult("非当前用户的手机号提交", result)
			err = exception.New(exception.NotCurrentUserError)
			return
		}
		if !checkFollowType(followAnalyst.FollowType) {
			u.FailedResult("关注状态非法", result)
			err = exception.New(exception.IllegalFollowType)
			return
		}
		var msg string
		switch followAnalyst.FollowType {
		case "following":
			msg = "关注研究员"
		case "unfollowed":
			msg = "取消关注研究员"
		}
		if followAnalyst.ByName {
			logger.Info("通过研究员姓名关注")
			if followAnalyst.AnalystName == "" {
				u.FailedResult("通过研究员姓名关注失败", result)
				err = exception.New(exception.AnalystNameEmptyError)
				return
			}
			err = user.FollowAnalystByName(userInfo.Id, followAnalyst.AnalystName, followAnalyst.FollowType)
		} else {
			err = user.FollowAnalyst(userInfo.Id, followAnalyst.AnalystId, followAnalyst.FollowType)
		}
		if err != nil {
			u.FailedResult(msg+"失败", result)
			return
		}
		resp := FollowResp{
			AnalystId:    followAnalyst.AnalystId,
			FollowedType: followAnalyst.FollowType,
		}
		u.SuccessResult(msg+"成功", resp, result)
		return
	})
}

func checkFollowType(followType string) bool {
	return followType == "following" || followType == "unfollowed"
}

// FollowingAnalysts  关注研究员列表
// @Summary 研究员详情
// @Description 研究员详情
// @Success 200 {object} controllers.BaseResponse
// @router /followingAnalysts [get]
func (u *UserController) FollowingAnalysts(analystId int) {
	controllers.Wrap(&u.BaseController, func() (result *controllers.WrapData, err error) {
		result = u.InitWrapData("获取研究员详情失败")
		fmt.Println(analystId)
		userInfo := u.Data["user"].(user.User)
		detail, err := user.GetAnalystDetail(userInfo.Id, analystId)
		if err != nil {
			u.FailedResult("获取研究员详情失败", result)
			return
		}
		u.SuccessResult("获取研究员详情成功", detail, result)
		return
	})
}

type UserProfileReq struct {
	UserName string `json:"userName"`
	Mobile   string `json:"mobile"`
}

// Profile  获取用户信息
// @Summary 获取用户信息
// @Description 获取用户信息
// @Success 200 {object} controllers.BaseResponse
// @router /profile [get]
func (u *UserController) Profile() {
	controllers.Wrap(&u.BaseController, func() (result *controllers.WrapData, err error) {
		result = u.InitWrapData("获取用户信息详情失败")
		userInfo := u.Data["user"].(user.User)
		u.SuccessResult("获取研究员详情成功", covertToUserProfile(userInfo), result)
		return
	})
}

// FollowingAnalystList  获取关注动态列表
// @Summary 获取关注动态列表
// @Description 获取关注动态列表
// @Success 200 {object} controllers.BaseResponse
// @router /followingAnalystList [get]
func (u *UserController) FollowingAnalystList() {
	controllers.Wrap(&u.BaseController, func() (result *controllers.WrapData, err error) {
		result = u.InitWrapData("获取研究员详情失败")
		userInfo := u.Data["user"].(user.User)
		detail, err := user.GetFollowingAnalystList(userInfo.Id)
		if err != nil {
			u.FailedResult("获取研究员详情失败", result)
			return
		}
		u.SuccessResult("获取研究员详情成功", detail, result)
		return
	})
}

// UnReadMessageList  获取未读消息
// @Summary 获取未读消息
// @Description 获取未读消息
// @Success 200 {object} controllers.BaseResponse
// @router /message [get]
func (u *UserController) UnReadMessageList() {
	controllers.Wrap(&u.BaseController, func() (result *controllers.WrapData, err error) {
		result = u.InitWrapData("获取我的未读消息失败")
		userInfo := u.Data["user"].(user.User)
		messages, err := user.GetUnReadMessageList(userInfo.Id)
		if err != nil {
			u.FailedResult("获取我的未读消息失败", result)
			return
		}
		u.SuccessResult("获取我的未读消息成功", messages, result)
		return
	})
}

type ReadMessageReq struct {
	AnalystId int `json:"analystId"`
	MessageId int `json:"MessageId"`
}

// ReadMessage  获取未读消息
// @Summary 获取未读消息
// @Description 获取未读消息
// @Success 200 {object} controllers.BaseResponse
// @router /readMessage [post]
func (u *UserController) ReadMessage() {
	controllers.Wrap(&u.BaseController, func() (result *controllers.WrapData, err error) {
		result = u.InitWrapData("获取我的未读消息失败")
		readMessageReq := new(ReadMessageReq)
		u.GetPostParams(readMessageReq)
		if readMessageReq.MessageId <= 0 {
			logger.Error("消息Id非法")
			err = exception.New(exception.IllegalMessageId)
			u.FailedResult("已读消息失败", result)
			return
		}
		userInfo := u.Data["user"].(user.User)
		if user.ReadMessage(userInfo.Id, readMessageReq.MessageId) {
			u.SuccessResult("已读消息成功", nil, result)
			return
		} else {
			err = exception.New(exception.ReadMessageFailed)
			u.FailedResult("已读消息失败", result)
			return
		}
	})
}

// ReadMessages  获取未读消息
// @Summary 获取未读消息
// @Description 获取未读消息
// @Success 200 {object} controllers.BaseResponse
// @router /readMessages [post]
func (u *UserController) ReadMessages() {
	controllers.Wrap(&u.BaseController, func() (result *controllers.WrapData, err error) {
		result = u.InitWrapData("获取我的未读消息失败")
		readMessageReq := new(ReadMessageReq)
		u.GetPostParams(readMessageReq)
		if readMessageReq.AnalystId <= 0 {
			logger.Error("研究员Id非法")
			err = exception.New(exception.IllegalAnalystId)
			u.FailedResult("已读消息失败", result)
			return
		}
		userInfo := u.Data["user"].(user.User)
		if user.ReadMessages(userInfo.Id, readMessageReq.AnalystId) {
			u.SuccessResult("已读消息成功", nil, result)
			return
		} else {
			err = exception.New(exception.ReadMessageFailed)
			u.FailedResult("已读消息失败", result)
			return
		}
	})
}
func covertToUserProfile(user user.User) UserProfileReq {
	return UserProfileReq{
		UserName: user.Username,
		Mobile:   user.Mobile,
	}
}