Merge remote-tracking branch 'origin/v2.3.0release' into v2.3.0release

internal/api/auth/auth.go

@@ -3,6 +3,7 @@ package apiAuth
 import (
 	api "Open_IM/pkg/base_info"
 	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/log"
 	"Open_IM/pkg/common/token_verify"
 	"Open_IM/pkg/grpc-etcdv3/getcdv3"
@@ -10,10 +11,11 @@ import (
 	open_im_sdk "Open_IM/pkg/proto/sdk_ws"
 	"Open_IM/pkg/utils"
 	"context"
-	"github.com/fatih/structs"
-	"github.com/gin-gonic/gin"
 	"net/http"
 	"strings"
+
+	"github.com/fatih/structs"
+	"github.com/gin-gonic/gin"
 )
 
 // @Summary 用户注册
@@ -65,11 +67,15 @@ func UserRegister(c *gin.Context) {
 	if reply.CommonResp.ErrCode != 0 {
 		errMsg := req.OperationID + " " + " UserRegister failed " + reply.CommonResp.ErrMsg + req.String()
 		log.NewError(req.OperationID, errMsg)
-		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		if reply.CommonResp.ErrCode == constant.RegisterLimit {
+			c.JSON(http.StatusOK, gin.H{"errCode": constant.RegisterLimit, "errMsg": "用户注册被限制"})
+		} else {
+			c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		}
 		return
 	}
 
-	pbDataToken := &rpc.UserTokenReq{Platform: params.Platform, FromUserID: params.UserID, OperationID: params.OperationID}
+	pbDataToken := &rpc.UserTokenReq{Platform: params.Platform, FromUserID: params.UserID, OperationID: params.OperationID, LoginIp: params.CreateIp}
 	replyToken, err := client.UserToken(context.Background(), pbDataToken)
 	if err != nil {
 		errMsg := req.OperationID + " " + " client.UserToken failed " + err.Error() + pbDataToken.String()
@@ -110,7 +116,7 @@ func UserToken(c *gin.Context) {
 		c.JSON(http.StatusBadRequest, gin.H{"errCode": 401, "errMsg": errMsg})
 		return
 	}
-	req := &rpc.UserTokenReq{Platform: params.Platform, FromUserID: params.UserID, OperationID: params.OperationID}
+	req := &rpc.UserTokenReq{Platform: params.Platform, FromUserID: params.UserID, OperationID: params.OperationID, LoginIp: params.LoginIp}
 	log.NewInfo(req.OperationID, "UserToken args ", req.String())
 	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImAuthName, req.OperationID)
 	if etcdConn == nil {

internal/api/third/minio_storage_credential.go

@@ -15,6 +15,8 @@ import (
 	_ "github.com/minio/minio-go/v7"
 	cr "github.com/minio/minio-go/v7/pkg/credentials"
 	"net/http"
+	"strconv"
+	"strings"
 )
 
 // @Summary minio上传文件(web api)
@@ -176,6 +178,7 @@ func UploadUpdateApp(c *gin.Context) {
 		return
 	}
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req)
+
 	var yamlName string
 	if req.Yaml == nil {
 		yamlName = ""
@@ -218,6 +221,13 @@ func UploadUpdateApp(c *gin.Context) {
 	c.JSON(http.StatusOK, resp)
 }
 
+func version2Int(version string) (int, error) {
+	versions := strings.Split(version, ".")
+	s := strings.Join(versions, "")
+	versionInt, err := strconv.Atoi(s)
+	return versionInt, err
+}
+
 func GetDownloadURL(c *gin.Context) {
 	var (
 		req  api.GetDownloadURLReq
@@ -238,7 +248,13 @@ func GetDownloadURL(c *gin.Context) {
 	}
 	log.Debug(req.OperationID, utils.GetSelfFuncName(), "app: ", app)
 	if app != nil {
-		if app.Version != req.Version && app.Version != "" {
+		appVersion, err := version2Int(app.Version)
+		reqVersion, err := version2Int(req.Version)
+		if err != nil {
+			log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), "req version", req.Version, "app version", app.Version)
+		}
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "req version:", reqVersion, "app version:", appVersion)
+		if appVersion > reqVersion && app.Version != "" {
 			resp.Data.HasNewVersion = true
 			if app.ForceUpdate == true {
 				resp.Data.ForceUpdate = true

internal/cron_task/clear_msg.go

@@ -2,11 +2,13 @@ package cronTask
 
 import (
 	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/db"
 	"Open_IM/pkg/common/log"
 	server_api_params "Open_IM/pkg/proto/sdk_ws"
 	"Open_IM/pkg/utils"
 	"github.com/golang/protobuf/proto"
+	"math"
 )
 
 const oldestList = 0
@@ -19,6 +21,7 @@ func ResetUserGroupMinSeq(operationID, groupID string, userIDList []string) erro
 		log.NewError(operationID, utils.GetSelfFuncName(), groupID, "deleteMongoMsg failed")
 		return utils.Wrap(err, "")
 	}
+	log.NewDebug(operationID, utils.GetSelfFuncName(), "delMsgIDList:", delMsgIDList, "minSeq", minSeq)
 	for _, userID := range userIDList {
 		userMinSeq, err := db.DB.GetGroupUserMinSeq(groupID, userID)
 		if err != nil {
@@ -43,17 +46,34 @@ func DeleteMongoMsgAndResetRedisSeq(operationID, userID string) error {
 	if err != nil {
 		return utils.Wrap(err, "")
 	}
-	log.NewDebug(operationID, utils.GetSelfFuncName(), "delMsgIDMap: ", userID, delMsgIDList)
+	log.NewDebug(operationID, utils.GetSelfFuncName(), "delMsgIDMap: ", delMsgIDList, "minSeq", minSeq)
 	err = db.DB.SetUserMinSeq(userID, minSeq)
 	return err
 }
 
+func delMongoMsgs(operationID string, delMsgIDList *[][2]interface{}) error {
+	if len(*delMsgIDList) > 0 {
+		var IDList []string
+		for _, v := range *delMsgIDList {
+			IDList = append(IDList, v[0].(string))
+		}
+		err := db.DB.DelMongoMsgs(IDList)
+		if err != nil {
+			return utils.Wrap(err, "DelMongoMsgs failed")
+		}
+	}
+	return nil
+}
+
 // recursion
 func deleteMongoMsg(operationID string, ID string, index int64, delMsgIDList *[][2]interface{}) (uint32, error) {
 	// 从最旧的列表开始找
 	msgs, err := db.DB.GetUserMsgListByIndex(ID, index)
-	if err != nil {
-		return 0, utils.Wrap(err, "GetUserMsgListByIndex failed")
+	if err != nil || msgs.UID == "" {
+		if err != nil {
+			log.NewError(operationID, utils.GetSelfFuncName(), "GetUserMsgListByIndex failed", err.Error(), index, ID)
+		}
+		return getDelMaxSeqByIDList(*delMsgIDList), delMongoMsgs(operationID, delMsgIDList)
 	}
 	if len(msgs.Msg) > db.GetSingleGocMsgNum() {
 		log.NewWarn(operationID, utils.GetSelfFuncName(), "msgs too large", len(msgs.Msg), msgs.UID)
@@ -62,15 +82,8 @@ func deleteMongoMsg(operationID string, ID string, index int64, delMsgIDList *[]
 	for i, msg := range msgs.Msg {
 		// 找到列表中不需要删除的消息了
 		if utils.GetCurrentTimestampByMill() < msg.SendTime+int64(config.Config.Mongo.DBRetainChatRecords)*24*60*60*1000 {
-			if len(*delMsgIDList) > 0 {
-				var IDList []string
-				for _, v := range *delMsgIDList {
-					IDList = append(IDList, v[0].(string))
-				}
-				err := db.DB.DelMongoMsgs(IDList)
-				if err != nil {
-					return 0, utils.Wrap(err, "DelMongoMsgs failed")
-				}
+			if err := delMongoMsgs(operationID, delMsgIDList); err != nil {
+				return 0, err
 			}
 			minSeq := getDelMaxSeqByIDList(*delMsgIDList)
 			if i > 0 {
@@ -84,19 +97,21 @@ func deleteMongoMsg(operationID string, ID string, index int64, delMsgIDList *[]
 						log.NewError(operationID, utils.GetSelfFuncName(), err.Error(), msgs.UID, i)
 						return minSeq, nil
 					}
-					minSeq = msgPb.Seq - 1
+					minSeq = msgPb.Seq
 				}
 			}
 			return minSeq, nil
 		}
 	}
-	msgPb := &server_api_params.MsgData{}
-	err = proto.Unmarshal(msgs.Msg[len(msgs.Msg)-1].Msg, msgPb)
-	if err != nil {
-		log.NewError(operationID, utils.GetSelfFuncName(), err.Error(), len(msgs.Msg)-1, msgs.UID)
-		return 0, utils.Wrap(err, "proto.Unmarshal failed")
+	if len(msgs.Msg) > 0 {
+		msgPb := &server_api_params.MsgData{}
+		err = proto.Unmarshal(msgs.Msg[len(msgs.Msg)-1].Msg, msgPb)
+		if err != nil {
+			log.NewError(operationID, utils.GetSelfFuncName(), err.Error(), len(msgs.Msg)-1, msgs.UID)
+			return 0, utils.Wrap(err, "proto.Unmarshal failed")
+		}
+		*delMsgIDList = append(*delMsgIDList, [2]interface{}{msgs.UID, msgPb.Seq})
 	}
-	*delMsgIDList = append(*delMsgIDList, [2]interface{}{msgs.UID, msgPb.Seq})
 	// 没有找到 代表需要全部删除掉 继续递归查找下一个比较旧的列表
 	seq, err := deleteMongoMsg(operationID, utils.GetSelfFuncName(), index+1, delMsgIDList)
 	if err != nil {
@@ -111,3 +126,29 @@ func getDelMaxSeqByIDList(delMsgIDList [][2]interface{}) uint32 {
 	}
 	return delMsgIDList[len(delMsgIDList)-1][1].(uint32)
 }
+
+func checkMaxSeqWithMongo(operationID, ID string, diffusionType int) error {
+	var maxSeq uint64
+	var err error
+	if diffusionType == constant.WriteDiffusion {
+		maxSeq, err = db.DB.GetUserMaxSeq(ID)
+	} else {
+		maxSeq, err = db.DB.GetGroupMaxSeq(ID)
+	}
+	if err != nil {
+		return utils.Wrap(err, "GetUserMaxSeq failed")
+	}
+	msg, err := db.DB.GetNewestMsg(ID)
+	if err != nil {
+		return utils.Wrap(err, "GetNewestMsg failed")
+	}
+	msgPb := &server_api_params.MsgData{}
+	err = proto.Unmarshal(msg.Msg, msgPb)
+	if err != nil {
+		return utils.Wrap(err, "")
+	}
+	if math.Abs(float64(msgPb.Seq-uint32(maxSeq))) > 10 {
+		log.NewWarn(operationID, utils.GetSelfFuncName(), maxSeq, msgPb.Seq, "redis maxSeq is different with msg.Seq")
+	}
+	return nil
+}

internal/cron_task/cron_task.go

@@ -1,6 +1,7 @@
 package cronTask
 
 import (
+	"Open_IM/pkg/common/config"
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/db/mysql_model/im_mysql_model"
 	rocksCache "Open_IM/pkg/common/db/rocks_cache"
@@ -16,8 +17,10 @@ const cronTaskOperationID = "cronTaskOperationID-"
 func StartCronTask() {
 	log.NewInfo(utils.OperationIDGenerator(), "start cron task")
 	c := cron.New()
-	_, err := c.AddFunc("30 3-6,20-23 * * *", func() {
+	fmt.Println("config", config.Config.Mongo.ChatRecordsClearTime)
+	_, err := c.AddFunc(config.Config.Mongo.ChatRecordsClearTime, func() {
 		operationID := getCronTaskOperationID()
+		log.NewInfo(operationID, "start", utils.GetSelfFuncName())
 		userIDList, err := im_mysql_model.SelectAllUserID()
 		if err == nil {
 			log.NewDebug(operationID, utils.GetSelfFuncName(), "userIDList: ", userIDList)
@@ -25,6 +28,9 @@ func StartCronTask() {
 				if err := DeleteMongoMsgAndResetRedisSeq(operationID, userID); err != nil {
 					log.NewError(operationID, utils.GetSelfFuncName(), err.Error(), userID)
 				}
+				if err := checkMaxSeqWithMongo(operationID, userID, constant.WriteDiffusion); err != nil {
+					log.NewError(operationID, utils.GetSelfFuncName(), userID, err)
+				}
 			}
 		} else {
 			log.NewError(operationID, utils.GetSelfFuncName(), err.Error())
@@ -42,7 +48,9 @@ func StartCronTask() {
 				if err := ResetUserGroupMinSeq(operationID, groupID, userIDList); err != nil {
 					log.NewError(operationID, utils.GetSelfFuncName(), err.Error(), groupID, userIDList)
 				}
-
+				if err := checkMaxSeqWithMongo(operationID, groupID, constant.ReadDiffusion); err != nil {
+					log.NewError(operationID, utils.GetSelfFuncName(), groupID, err)
+				}
 			}
 		} else {
 			log.NewError(operationID, utils.GetSelfFuncName(), err.Error())
@@ -53,6 +61,7 @@ func StartCronTask() {
 		fmt.Println("start cron failed", err.Error())
 		panic(err)
 	}
+
 	c.Start()
 	fmt.Println("start cron task success")
 	for {

internal/cron_task/test/main.go

@@ -0,0 +1,3 @@
+package main
+
+func main() {}

internal/demo/register/login.go

@@ -10,8 +10,9 @@ import (
 	"Open_IM/pkg/utils"
 	"encoding/json"
 	"fmt"
-	"github.com/gin-gonic/gin"
 	"net/http"
+
+	"github.com/gin-gonic/gin"
 )
 
 type ParamsLogin struct {
@@ -62,6 +63,11 @@ func Login(c *gin.Context) {
 	openIMGetUserToken.Platform = params.Platform
 	openIMGetUserToken.Secret = config.Config.Secret
 	openIMGetUserToken.UserID = userID
+	loginIp := c.Request.Header.Get("X-Forward-For")
+	if loginIp == "" {
+		loginIp = c.ClientIP()
+	}
+	openIMGetUserToken.LoginIp = loginIp
 	openIMGetUserTokenResp := api.UserTokenResp{}
 	bMsg, err := http2.Post(url, openIMGetUserToken, 2)
 	if err != nil {
@@ -72,7 +78,11 @@ func Login(c *gin.Context) {
 	err = json.Unmarshal(bMsg, &openIMGetUserTokenResp)
 	if err != nil || openIMGetUserTokenResp.ErrCode != 0 {
 		log.NewError(params.OperationID, "request get user token", account, "err", "")
-		c.JSON(http.StatusOK, gin.H{"errCode": constant.GetIMTokenErr, "errMsg": ""})
+		if openIMGetUserTokenResp.ErrCode == constant.LoginLimit {
+			c.JSON(http.StatusOK, gin.H{"errCode": constant.LoginLimit, "errMsg": "用户登录被限制"})
+		} else {
+			c.JSON(http.StatusOK, gin.H{"errCode": constant.GetIMTokenErr, "errMsg": ""})
+		}
 		return
 	}
 	c.JSON(http.StatusOK, gin.H{"errCode": constant.NoError, "errMsg": "", "data": openIMGetUserTokenResp.UserToken})

internal/demo/register/set_password.go

@@ -10,11 +10,12 @@ import (
 	"Open_IM/pkg/common/log"
 	"Open_IM/pkg/utils"
 	"encoding/json"
-	"github.com/gin-gonic/gin"
 	"math/big"
 	"net/http"
 	"strconv"
 	"time"
+
+	"github.com/gin-gonic/gin"
 )
 
 type ParamsSetPassword struct {
@@ -81,6 +82,11 @@ func SetPassword(c *gin.Context) {
 	openIMRegisterReq.Nickname = params.Nickname
 	openIMRegisterReq.Secret = config.Config.Secret
 	openIMRegisterReq.FaceURL = params.FaceURL
+	createIp := c.Request.Header.Get("X-Forward-For")
+	if createIp == "" {
+		createIp = c.ClientIP()
+	}
+	openIMRegisterReq.CreateIp = createIp
 	openIMRegisterResp := api.UserRegisterResp{}
 	log.NewDebug(params.OperationID, utils.GetSelfFuncName(), "register req:", openIMRegisterReq)
 	bMsg, err := http2.Post(url, openIMRegisterReq, 2)
@@ -95,7 +101,11 @@ func SetPassword(c *gin.Context) {
 		if err != nil {
 			log.NewError(params.OperationID, utils.GetSelfFuncName(), err.Error())
 		}
-		c.JSON(http.StatusOK, gin.H{"errCode": constant.RegisterFailed, "errMsg": "register failed: " + openIMRegisterResp.ErrMsg})
+		if openIMRegisterResp.ErrCode == constant.RegisterLimit {
+			c.JSON(http.StatusOK, gin.H{"errCode": constant.RegisterLimit, "errMsg": "用户注册被限制"})
+		} else {
+			c.JSON(http.StatusOK, gin.H{"errCode": constant.RegisterFailed, "errMsg": "register failed: " + openIMRegisterResp.ErrMsg})
+		}
 		return
 	}
 	log.Info(params.OperationID, "begin store mysql", account, params.Password, "info", params.FaceURL, params.Nickname)

internal/push/getui/push.go

@@ -83,6 +83,7 @@ type Alert struct {
 type Android struct {
 	Ups struct {
 		Notification Notification `json:"notification"`
+		Options      Options      `json:"options"`
 	} `json:"ups"`
 }
 
@@ -92,6 +93,18 @@ type Notification struct {
 	ClickType string `json:"click_type"`
 }
 
+type Options struct {
+	HW struct {
+		DefaultSound bool   `json:"/message/android/notification/default_sound"`
+		ChannelID    string `json:"/message/android/notification/channel_id"`
+		Sound        string `json:"/message/android/notification/sound"`
+		Importance   string `json:"/message/android/notification/importance"`
+	} `json:"HW"`
+	XM struct {
+		ChannelID string `json:"/extra.channel_id"`
+	} `json:""`
+}
+
 type PushResp struct {
 }
 
@@ -133,6 +146,17 @@ func (g *Getui) Push(userIDList []string, alert, detailContent, operationID stri
 		Body:      alert,
 		ClickType: "startapp",
 	}
+	pushReq.PushChannel.Android.Ups.Options = Options{
+		HW: struct {
+			DefaultSound bool   `json:"/message/android/notification/default_sound"`
+			ChannelID    string `json:"/message/android/notification/channel_id"`
+			Sound        string `json:"/message/android/notification/sound"`
+			Importance   string `json:"/message/android/notification/importance"`
+		}{ChannelID: "RingRing4", Sound: "/raw/ring001", Importance: "importance"},
+		XM: struct {
+			ChannelID string `json:"/extra.channel_id"`
+		}{ChannelID: "Default"},
+	}
 	pushResp := PushResp{}
 	err = g.request(PushURL, pushReq, token, &pushResp, operationID)
 	switch err {

internal/rpc/auth/auth.go

@@ -15,6 +15,7 @@ import (
 	"net"
 	"strconv"
 	"strings"
+	"time"
 
 	"Open_IM/pkg/common/config"
 
@@ -29,6 +30,13 @@ func (rpc *rpcAuth) UserRegister(_ context.Context, req *pbAuth.UserRegisterReq)
 		user.Birth = utils.UnixSecondToTime(int64(req.UserInfo.Birth))
 	}
 	log.Debug(req.OperationID, "copy ", user, req.UserInfo)
+	Limited, LimitError := imdb.IsLimitRegisterIp(req.UserInfo.CreateIp)
+	if LimitError != nil {
+		return &pbAuth.UserRegisterResp{CommonResp: &pbAuth.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: LimitError.Error()}}, nil
+	}
+	if Limited {
+		return &pbAuth.UserRegisterResp{CommonResp: &pbAuth.CommonResp{ErrCode: constant.RegisterLimit, ErrMsg: "Register Limit"}}, nil
+	}
 	err := imdb.UserRegister(user)
 	if err != nil {
 		errMsg := req.OperationID + " imdb.UserRegister failed " + err.Error() + user.UserID
@@ -42,20 +50,43 @@ func (rpc *rpcAuth) UserRegister(_ context.Context, req *pbAuth.UserRegisterReq)
 
 func (rpc *rpcAuth) UserToken(_ context.Context, req *pbAuth.UserTokenReq) (*pbAuth.UserTokenResp, error) {
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc args ", req.String())
-	_, err := imdb.GetUserByUserID(req.FromUserID)
+	user, err := imdb.GetUserByUserID(req.FromUserID)
 	if err != nil {
 		errMsg := req.OperationID + " imdb.GetUserByUserID failed " + err.Error() + req.FromUserID
 		log.NewError(req.OperationID, errMsg)
 		return &pbAuth.UserTokenResp{CommonResp: &pbAuth.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}}, nil
 	}
-
+	var Limited bool
+	var LimitError error
+	if user.LoginLimit == 0 {
+		Limited, LimitError = imdb.IsLimitLoginIp(req.LoginIp)
+	} else if user.LoginLimit == 1 {
+		Limited, LimitError = imdb.IsLimitUserLoginIp(user.UserID, req.LoginIp)
+	} else if user.LoginLimit == 2 {
+		Limited, LimitError = imdb.UserIsBlock(user.UserID)
+	}
+	if LimitError != nil {
+		return &pbAuth.UserTokenResp{CommonResp: &pbAuth.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: LimitError.Error()}}, nil
+	}
+	if Limited {
+		return &pbAuth.UserTokenResp{CommonResp: &pbAuth.CommonResp{ErrCode: constant.LoginLimit, ErrMsg: "用户被限制"}}, nil
+	}
 	tokens, expTime, err := token_verify.CreateToken(req.FromUserID, int(req.Platform))
 	if err != nil {
 		errMsg := req.OperationID + " token_verify.CreateToken failed " + err.Error() + req.FromUserID + utils.Int32ToString(req.Platform)
 		log.NewError(req.OperationID, errMsg)
 		return &pbAuth.UserTokenResp{CommonResp: &pbAuth.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}}, nil
 	}
-
+	//增加用户登录信息
+	user.LoginTimes = user.LoginTimes + 1
+	user.LastLoginIp = req.LoginIp
+	user.LastLoginTime = time.Now()
+	err = imdb.UpdateUserInfo(*user)
+	if err != nil {
+		errMsg := req.OperationID + " imdb.UpdateUserInfo failed " + err.Error() + req.FromUserID
+		log.NewError(req.OperationID, errMsg)
+		return &pbAuth.UserTokenResp{CommonResp: &pbAuth.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}}, nil
+	}
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc return ", pbAuth.UserTokenResp{CommonResp: &pbAuth.CommonResp{}, Token: tokens, ExpiredTime: expTime})
 	return &pbAuth.UserTokenResp{CommonResp: &pbAuth.CommonResp{}, Token: tokens, ExpiredTime: expTime}, nil
 }

internal/rpc/conversation/conversaion.go

@@ -38,7 +38,7 @@ func (rpc *rpcConversation) ModifyConversationField(c context.Context, req *pbCo
 			resp.CommonResp = &pbConversation.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
 			return resp, nil
 		}
-		if groupInfo.Status == constant.GroupStatusDismissed && !req.Conversation.IsNotInGroup {
+		if groupInfo.Status == constant.GroupStatusDismissed && !req.Conversation.IsNotInGroup && req.FieldType != constant.FieldUnread {
 			errMsg := "group status is dismissed"
 			resp.CommonResp = &pbConversation.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}
 			return resp, nil

internal/rpc/user/user.go

@@ -6,7 +6,7 @@ import (
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/db"
 	imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model"
-	"Open_IM/pkg/common/db/rocks_cache"
+	rocksCache "Open_IM/pkg/common/db/rocks_cache"
 	errors "Open_IM/pkg/common/http"
 	"Open_IM/pkg/common/log"
 	"Open_IM/pkg/common/token_verify"
@@ -540,11 +540,20 @@ func (s *userServer) GetUsersByName(ctx context.Context, req *pbUser.GetUsersByN
 			continue
 		}
 		resp.Users = append(resp.Users, &pbUser.User{
-			ProfilePhoto: user.FaceURL,
-			Nickname:     user.Nickname,
-			UserId:       user.UserID,
-			CreateTime:   user.CreateTime.String(),
-			IsBlock:      isBlock,
+			ProfilePhoto:  user.FaceURL,
+			Nickname:      user.Nickname,
+			UserId:        user.UserID,
+			CreateTime:    user.CreateTime.Format("2006-01-02 15:04:05"),
+			CreateIp:      user.CreateIp,
+			IsBlock:       isBlock,
+			Birth:         user.Birth.Format("2006-01-02"),
+			PhoneNumber:   user.PhoneNumber,
+			Email:         user.Email,
+			LastLoginIp:   user.LastLoginIp,
+			LastLoginTime: user.LastLoginTime.Format("2006-01-02 15:04:05"),
+			LoginTimes:    user.LoginTimes,
+			Gender:        user.Gender,
+			LoginLimit:    user.LoginLimit,
 		})
 	}
 	user := db.User{Nickname: req.UserName}
@@ -576,11 +585,20 @@ func (s *userServer) GetUserById(ctx context.Context, req *pbUser.GetUserByIdReq
 		return resp, errors.WrapError(constant.ErrDB)
 	}
 	resp.User = &pbUser.User{
-		ProfilePhoto: user.FaceURL,
-		Nickname:     user.Nickname,
-		UserId:       user.UserID,
-		CreateTime:   user.CreateTime.String(),
-		IsBlock:      isBlock,
+		ProfilePhoto:  user.FaceURL,
+		Nickname:      user.Nickname,
+		UserId:        user.UserID,
+		CreateTime:    user.CreateTime.Format("2006-01-02 15:04:05"),
+		CreateIp:      user.CreateIp,
+		IsBlock:       isBlock,
+		Birth:         user.Birth.Format("2006-01-02"),
+		PhoneNumber:   user.PhoneNumber,
+		Email:         user.Email,
+		LastLoginIp:   user.LastLoginIp,
+		LastLoginTime: user.LastLoginTime.Format("2006-01-02 15:04:05"),
+		LoginTimes:    user.LoginTimes,
+		Gender:        user.Gender,
+		LoginLimit:    user.LoginLimit,
 	}
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
 	return resp, nil
@@ -598,11 +616,20 @@ func (s *userServer) GetUsers(ctx context.Context, req *pbUser.GetUsersReq) (*pb
 		isBlock, err := imdb.UserIsBlock(v.UserID)
 		if err == nil {
 			user := &pbUser.User{
-				ProfilePhoto: v.FaceURL,
-				UserId:       v.UserID,
-				CreateTime:   v.CreateTime.String(),
-				Nickname:     v.Nickname,
-				IsBlock:      isBlock,
+				ProfilePhoto:  v.FaceURL,
+				UserId:        v.UserID,
+				CreateTime:    v.CreateTime.Format("2006-01-02 15:04:05"),
+				CreateIp:      v.CreateIp,
+				Nickname:      v.Nickname,
+				Birth:         v.Birth.Format("2006-01-02"),
+				PhoneNumber:   v.PhoneNumber,
+				Email:         v.Email,
+				IsBlock:       isBlock,
+				LastLoginIp:   v.LastLoginIp,
+				LastLoginTime: v.LastLoginTime.Format("2006-01-02 15:04:05"),
+				LoginTimes:    v.LoginTimes,
+				Gender:        v.Gender,
+				LoginLimit:    v.LoginLimit,
 			}
 			resp.User = append(resp.User, user)
 		} else {