批量关注

common/exception/exc_enums.go

@@ -34,6 +34,7 @@ const (
 	IllegalAreaCode
 	MediaTypeError
 	GetAnalystListFailed
+	BatchFollowingAnalystFailed
 )
 
 // UserErrCode 用户
@@ -61,6 +62,7 @@ const (
 	IllegalAnalystId
 	ReadMessageFailed
 	BindMobileFailed
+	CheckFollowStatusByNamesFailed
 )
 
 // WechatErrCode 微信
@@ -129,6 +131,8 @@ var ErrorMap = map[int]string{
 	IllegalMessageId:                   "非法的消息ID",
 	ReadMessageFailed:                  "已读消息失败",
 	IllegalAnalystId:                   "研究员Id非法",
+	CheckFollowStatusByNamesFailed:     "获取关注猪状态失败",
+	BatchFollowingAnalystFailed:        "批量关注研究员列表失败",
 	//微信
 	WeChatServerError:    "微信服务器发生错误",
 	WechatUserInfoFailed: "获取微信用户信息失败",

controllers/user/user_controller.go

@@ -8,6 +8,7 @@ import (
 	"eta/eta_mini_ht_api/controllers"
 	"eta/eta_mini_ht_api/service/user"
 	"fmt"
+	"strings"
 )
 
 // UserController Operations about Users
@@ -91,6 +92,114 @@ type FollowResp struct {
 	FollowedType string `json:"FollowedType"`
 }
 
+type FollowAnalystsReq struct {
+	AnalystNames string `json:"analystName"`
+	FollowType   string `json:"followType"`
+	Mobile       string `json:"mobile"`
+	ByName       bool   `json:"byName"`
+}
+
+// FollowAnalysts  批量关注研究员
+// @Summary 批量关注研究员
+// @Description 批量关注研究员
+// @Success 200 {object} controllers.BaseResponse
+// @router /followAnalysts [post]
+func (u *UserController) FollowAnalysts() {
+	controllers.Wrap(&u.BaseController, func() (result *controllers.WrapData, err error) {
+		result = u.InitWrapData("")
+		followAnalyst := new(FollowAnalystsReq)
+		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 = "批量取消关注研究员"
+		}
+		var nameList []string
+		names := followAnalyst.AnalystNames
+		if strings.HasPrefix(names, ",") {
+			names = names[1:len(names)]
+		}
+		if strings.HasSuffix(names, ",") {
+			names = names[0 : len(names)-1]
+		}
+		if names == "" {
+			nameList = []string{}
+		} else {
+			nameList = strings.Split(names, ",")
+		}
+		for i := 0; i < len(nameList); i++ {
+			nameList[i] = strings.TrimSpace(nameList[i])
+			if nameList[i] == "" {
+				u.FailedResult("通过研究员姓名关注失败", result)
+				err = exception.New(exception.AnalystNameEmptyError)
+				return
+			}
+		}
+		err = user.FollowAnalystsByName(userInfo.Id, nameList, followAnalyst.FollowType)
+		if err != nil {
+			u.FailedResult(msg+"失败", result)
+			return
+		}
+		u.SuccessResult(msg+"成功", nil, result)
+		return
+	})
+}
+
+// FollowAnalyst  获取关注状态
+// @Summary 获取关注状态
+// @Description 获取关注状态
+// @Success 200 {object} controllers.BaseResponse
+// @router /followAnalyst [get]
+func (u *UserController) CheckFollowStatus(names string) {
+	controllers.Wrap(&u.BaseController, func() (result *controllers.WrapData, err error) {
+		result = u.InitWrapData("获取关注状态失败")
+		var userInfo user.User
+		userInfo = u.Data["user"].(user.User)
+		var nameList []string
+		if strings.HasPrefix(names, ",") {
+			names = names[1:len(names)]
+		}
+		if strings.HasSuffix(names, ",") {
+			names = names[0 : len(names)-1]
+		}
+		if names == "" {
+			nameList = []string{}
+		} else {
+			nameList = strings.Split(names, ",")
+		}
+		for i := 0; i < len(nameList); i++ {
+			nameList[i] = strings.TrimSpace(nameList[i])
+		}
+		list, err := user.CheckFollowStatusByNames(userInfo.Id, nameList)
+		if err != nil {
+			u.FailedResult("获取关注状态失败", result)
+			return
+		}
+		u.SuccessResult("获取关注状态成功", list, result)
+		return
+	})
+
+}
+
 // FollowAnalyst  关注研究员
 // @Summary 关注研究员
 // @Description 关注研究员
@@ -153,9 +262,9 @@ func checkFollowType(followType string) bool {
 	return followType == "following" || followType == "unfollowed"
 }
 
-// FollowingAnalysts  关注研究员列表
-// @Summary 研究员详情
-// @Description 研究员详情
+// FollowingAnalysts  关注研究员
+// @Summary 关注研究员
+// @Description 关注研究员
 // @Success 200 {object} controllers.BaseResponse
 // @router /followingAnalysts [get]
 func (u *UserController) FollowingAnalysts(analystId int) {

domian/report/report_service.go

@@ -81,7 +81,7 @@ func GetGetReportById(reportId int) (ReportDTO ReportDTO, err error) {
 		return
 	}
 	orgId := report.OrgID
-	names, _ := reportDao.GetAuthorByOrgId(orgId)
+	names, _ := reportDao.GetAuthorByOrgId(orgId, string(report.Source))
 	if names != nil && len(names) > 1 {
 		names = stringUtils.UniqueItems(names)
 		report.Author = strings.Join(names, ",")

domian/user/user_following_service.go

@@ -1,16 +1,17 @@
 package user
 
 import (
+	"errors"
 	userDao "eta/eta_mini_ht_api/models/user"
 	"time"
 )
 
 type FollowDTO struct {
-	UserId       int
-	AnalystId    int
-	AnalystName  string
-	FollowType   string
-	FollowedTime time.Time
+	UserId       int       `json:"userId"`
+	AnalystId    int       `json:"analystId"`
+	AnalystName  string    `json:"analystName"`
+	FollowType   string    `json:"followType"`
+	FollowedTime time.Time `json:"followedTime"`
 }
 
 func convertToCrmFollowingAnalyst(dto FollowDTO) userDao.UserAnalystFollowList {
@@ -36,6 +37,12 @@ func convertToFollowDTO(follow userDao.UserAnalystFollowList) (dto FollowDTO) {
 		FollowedTime: follow.FollowedTime,
 	}
 }
+func convertFollowStatusToFollowDTO(follow userDao.FollowStatus) (dto FollowDTO) {
+	return FollowDTO{
+		AnalystName: follow.FinancialAnalystName,
+		FollowType:  string(follow.Followed),
+	}
+}
 func followType(followType string) userDao.FollowingType {
 	switch followType {
 	case "following":
@@ -46,7 +53,29 @@ func followType(followType string) userDao.FollowingType {
 		return ""
 	}
 }
-
+func FollowAnalystsByName(userId int, analysts []FollowDTO, follow string) error {
+	flType := followType(follow)
+	var userFollows []userDao.UserAnalystFollowList
+	if flType == "" {
+		return errors.New("关注状态非法")
+	}
+	for _, analyst := range analysts {
+		userFollow := convertToCrmFollowingAnalyst(analyst)
+		userFollow.Followed = flType
+		userFollows = append(userFollows, userFollow)
+	}
+	return userDao.FollowAnalystsByName(userId, userFollows, flType)
+}
+func CheckFollowStatusByNames(userId int, names []string) (follows []FollowDTO, err error) {
+	list, err := userDao.CheckFollowStatusByNames(userId, names)
+	if err != nil {
+		return
+	}
+	for _, follow := range list {
+		follows = append(follows, convertFollowStatusToFollowDTO(follow))
+	}
+	return
+}
 func GetFollowingAnalystList(userId int) (dtoList []FollowDTO, err error) {
 	list, err := userDao.GetFollowingAnalystList(userId)
 	if err != nil {

models/report/report.go

@@ -58,9 +58,9 @@ func (t *Report) BeforeCreate(_ *gorm.DB) (err error) {
 	return
 }
 
-func GetAuthorByOrgId(orgId int) (names []string, err error) {
+func GetAuthorByOrgId(orgId int, source string) (names []string, err error) {
 	db := models.Main()
-	err = db.Model(&Report{}).Select("author").Where("org_id = ?", orgId).Scan(&names).Error
+	err = db.Model(&Report{}).Select("author").Where("org_id = ? and source =? ", orgId, source).Scan(&names).Error
 	return
 }
 func GetReportById(reportId int) (report Report, err error) {

models/user/user_analyst_follow_list.go

@@ -14,6 +14,8 @@ const (
 	Following   FollowingType = "following"
 	Unfollowed  FollowingType = "unfollowed"
 	listColumns               = "user_id, financial_analyst_id,financial_analyst_name, followed,followed_time"
+
+	FollowingStatusColumns = "financial_analyst_id,financial_analyst_name, followed"
 )
 
 // UserAnalystFollowList 代表用户关注的研究员列表
@@ -44,6 +46,83 @@ func (fa *UserAnalystFollowList) BeforeCreate(_ *gorm.DB) (err error) {
 	fa.CreatedTime = time.Now()
 	return
 }
+
+type FollowStatus struct {
+	FinancialAnalystName string
+	Followed             FollowingType
+}
+
+func FollowAnalystsByName(userId int, analysts []UserAnalystFollowList, followType FollowingType) (err error) {
+	db := models.Main()
+	if followType == Following {
+		tx := db.Begin()
+		for _, analyst := range analysts {
+			var dbFollow UserAnalystFollowList
+			err = db.Model(&UserAnalystFollowList{}).Where("user_id = ? and financial_analyst_name = ?", userId, analyst.FinancialAnalystName).First(&dbFollow).Error
+			if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+				return
+			}
+			if errors.Is(err, gorm.ErrRecordNotFound) {
+				err = db.Create(&analyst).Error
+			} else {
+				if analyst.Followed == Unfollowed {
+					analyst.ID = dbFollow.ID
+					analyst.CreatedTime = dbFollow.CreatedTime
+					analyst.FollowedTime = dbFollow.FollowedTime
+					analyst.FollowedTime = time.Now()
+				}
+				err = db.Updates(&analyst).Error
+			}
+			if err != nil {
+				tx.Rollback()
+				return
+			}
+		}
+		tx.Commit()
+	}
+	if followType == Unfollowed {
+		tx := db.Begin()
+		for _, analyst := range analysts {
+			var dbFollow UserAnalystFollowList
+			err = db.Model(&UserAnalystFollowList{}).Where("user_id = ? and financial_analyst_name = ?", userId, analyst.FinancialAnalystName).First(&dbFollow).Error
+			if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+				return
+			}
+			if errors.Is(err, gorm.ErrRecordNotFound) || analyst.Followed == Unfollowed {
+				continue
+			} else {
+				err = db.Updates(&analyst).Error
+			}
+			if err != nil {
+				tx.Rollback()
+				return
+			}
+		}
+		tx.Commit()
+	}
+	return
+}
+func CheckFollowStatusByNames(userId int, names []string) (list []FollowStatus, err error) {
+	var result []FollowStatus
+	db := models.Main()
+	var followingList []UserAnalystFollowList
+	err = db.Select(FollowingStatusColumns).Where("user_id = ? and followed = ? and financial_analyst_name in ?", userId, Following, names).Find(&followingList).Error
+	for _, name := range names {
+		result = append(result, FollowStatus{
+			FinancialAnalystName: name,
+			Followed:             Unfollowed,
+		})
+	}
+	for i := 0; i < len(result); i++ {
+		for _, v := range followingList {
+			if v.FinancialAnalystName == result[i].FinancialAnalystName {
+				result[i].Followed = Following
+				break
+			}
+		}
+	}
+	return
+}
 func GetFollowingAnalystList(userId int) (list []UserAnalystFollowList, err error) {
 	db := models.Main()
 	err = db.Select(listColumns).Where("user_id = ? and followed = ?", userId, Following).Order("followed_time desc").Find(&list).Error
@@ -74,7 +153,7 @@ func FollowAnalyst(follow UserAnalystFollowList) (err error) {
 			return
 		}
 		if follow.Followed == Unfollowed {
-			return nil
+			return
 		}
 		err = db.Create(&follow).Error
 		return

service/user/user_service.go

@@ -45,6 +45,37 @@ func convertToAnalystDetail(dto analystService.FinancialAnalystDTO) AnalystDetai
 	}
 
 }
+func FollowAnalystsByName(userId int, analystNames []string, followType string) (err error) {
+	var followlist []userService.FollowDTO
+	for _, analystName := range analystNames {
+		FinancialAnalystDTO, followErr := analystService.GetAnalystByName(analystName)
+		if followErr != nil {
+
+			err = exception.New(exception.AnalystNotFound)
+		}
+		followDTO := userService.FollowDTO{
+			UserId:      userId,
+			AnalystId:   FinancialAnalystDTO.Id,
+			AnalystName: FinancialAnalystDTO.Name,
+			FollowType:  followType,
+		}
+		followlist = append(followlist, followDTO)
+	}
+	err = userService.FollowAnalystsByName(userId, followlist, followType)
+	if err != nil {
+		logger.Error("批量关注研究员失败：%v", err)
+		err = exception.New(exception.BatchFollowingAnalystFailed)
+	}
+	return
+}
+func CheckFollowStatusByNames(userId int, names []string) (list []userService.FollowDTO, err error) {
+	list, err = userService.CheckFollowStatusByNames(userId, names)
+	if err != nil {
+		logger.Error("获取关注状态失败:%v", err)
+		err = exception.New(exception.CheckFollowStatusByNamesFailed)
+	}
+	return
+}
 func FollowAnalyst(userId int, analystId int, followType string) (err error) {
 	FinancialAnalystDTO, err := analystService.GetAnalystById(analystId)
 	if err != nil {