IM/open-im-server
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Gordon
2022-08-16 19:16:20 +08:00
parent 12a4c12753 e8fdc454db
commit 97b1a774fb
53 changed files with 2916 additions and 1562 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/api/auth/auth.go
+2
View File
@@ -69,6 +69,8 @@ func UserRegister(c *gin.Context) {
log.NewError(req.OperationID, errMsg)
if reply.CommonResp.ErrCode == constant.RegisterLimit {
c.JSON(http.StatusOK, gin.H{"errCode": constant.RegisterLimit, "errMsg": "用户注册被限制"})
} else if reply.CommonResp.ErrCode == constant.InvitationError {
c.JSON(http.StatusOK, gin.H{"errCode": constant.InvitationError, "errMsg": "邀请码错误"})
} else {
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
}
internal/api/third/aws_storage_credential.go
+76
View File
@@ -0,0 +1,76 @@
package apiThird
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/utils"
"context"
"net/http"
"github.com/aws/aws-sdk-go-v2/aws"
awsConfig "github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/credentials"
"github.com/aws/aws-sdk-go-v2/service/sts"
"github.com/gin-gonic/gin"
)
func AwsStorageCredential(c *gin.Context) {
var (
req api.AwsStorageCredentialReq
resp api.AwsStorageCredentialResp
)
if err := c.BindJSON(&req); err != nil {
log.NewError("0", utils.GetSelfFuncName(), "BindJSON failed ", err.Error())
c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
return
}
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req)
var ok bool
var errInfo string
ok, _, errInfo = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
if !ok {
errMsg := req.OperationID + " " + "GetUserIDFromToken failed " + errInfo + " token:" + c.Request.Header.Get("token")
log.NewError(req.OperationID, errMsg)
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
return
}
//原始帐号信息
awsSourceConfig, err := awsConfig.LoadDefaultConfig(context.TODO(), awsConfig.WithRegion(config.Config.Credential.Aws.Region),
awsConfig.WithCredentialsProvider(credentials.StaticCredentialsProvider{
Value: aws.Credentials{
AccessKeyID: config.Config.Credential.Aws.AccessKeyID,
SecretAccessKey: config.Config.Credential.Aws.AccessKeySecret,
Source: "Open IM OSS",
},
}))
if err != nil {
errMsg := req.OperationID + " " + "Init AWS S3 Credential failed " + err.Error() + " token:" + c.Request.Header.Get("token")
log.NewError(req.OperationID, errMsg)
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
return
}
//帐号转化
awsStsClient := sts.NewFromConfig(awsSourceConfig)
StsRole, err := awsStsClient.AssumeRole(context.Background(), &sts.AssumeRoleInput{
RoleArn: aws.String(config.Config.Credential.Aws.RoleArn),
DurationSeconds: aws.Int32(constant.AwsDurationTimes),
RoleSessionName: aws.String(config.Config.Credential.Aws.RoleSessionName),
ExternalId: aws.String(config.Config.Credential.Aws.ExternalId),
})
if err != nil {
errMsg := req.OperationID + " " + "AWS S3 AssumeRole failed " + err.Error() + " token:" + c.Request.Header.Get("token")
log.NewError(req.OperationID, errMsg)
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
return
}
resp.CosData.AccessKeyId = string(*StsRole.Credentials.AccessKeyId)
resp.CosData.SecretAccessKey = string(*StsRole.Credentials.SecretAccessKey)
resp.CosData.SessionToken = string(*StsRole.Credentials.SessionToken)
resp.CosData.Bucket = config.Config.Credential.Aws.Bucket
resp.CosData.RegionID = config.Config.Credential.Aws.Region
resp.CosData.FinalHost = config.Config.Credential.Aws.FinalHost
c.JSON(http.StatusOK, gin.H{"errCode": 0, "errMsg": "", "data": resp})
}
internal/cms_api/admin/admin.go
+93 -1
View File
@@ -8,6 +8,7 @@ import (
"Open_IM/pkg/common/log"
"Open_IM/pkg/grpc-etcdv3/getcdv3"
pbAdmin "Open_IM/pkg/proto/admin_cms"
pbCommon "Open_IM/pkg/proto/sdk_ws"
"Open_IM/pkg/utils"
"context"
"github.com/minio/minio-go/v7"
@@ -63,7 +64,7 @@ func AdminLogin(c *gin.Context) {
reqPb pbAdmin.AdminLoginReq
)
if err := c.BindJSON(&req); err != nil {
log.NewInfo("0", utils.GetSelfFuncName(), err.Error())
log.NewError("0", utils.GetSelfFuncName(), err.Error())
openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
return
}
@@ -87,3 +88,94 @@ func AdminLogin(c *gin.Context) {
resp.Token = respPb.Token
openIMHttp.RespHttp200(c, constant.OK, resp)
}
func AddUserRegisterAddFriendIDList(c *gin.Context) {
var (
req apiStruct.AddUserRegisterAddFriendIDListRequest
resp apiStruct.AddUserRegisterAddFriendIDListResponse
)
if err := c.BindJSON(&req); err != nil {
log.NewError("0", utils.GetSelfFuncName(), err.Error())
openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
return
}
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), req)
etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImAdminCMSName, req.OperationID)
if etcdConn == nil {
errMsg := req.OperationID + "getcdv3.GetConn == nil"
log.NewError(req.OperationID, errMsg)
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
return
}
client := pbAdmin.NewAdminCMSClient(etcdConn)
_, err := client.AddUserRegisterAddFriendIDList(context.Background(), &pbAdmin.AddUserRegisterAddFriendIDListReq{OperationID: req.OperationID, UserIDList: req.UserIDList})
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "rpc failed", err.Error())
openIMHttp.RespHttp200(c, err, nil)
return
}
openIMHttp.RespHttp200(c, constant.OK, resp)
}
func ReduceUserRegisterAddFriendIDList(c *gin.Context) {
var (
req apiStruct.ReduceUserRegisterAddFriendIDListRequest
resp apiStruct.ReduceUserRegisterAddFriendIDListResponse
)
if err := c.BindJSON(&req); err != nil {
log.NewError("0", utils.GetSelfFuncName(), err.Error())
openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
return
}
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), req)
etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImAdminCMSName, req.OperationID)
if etcdConn == nil {
errMsg := req.OperationID + "getcdv3.GetConn == nil"
log.NewError(req.OperationID, errMsg)
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
return
}
client := pbAdmin.NewAdminCMSClient(etcdConn)
_, err := client.ReduceUserRegisterAddFriendIDList(context.Background(), &pbAdmin.ReduceUserRegisterAddFriendIDListReq{OperationID: req.OperationID, UserIDList: req.UserIDList, Operation: req.Operation})
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "rpc failed", err.Error())
openIMHttp.RespHttp200(c, err, nil)
return
}
openIMHttp.RespHttp200(c, constant.OK, resp)
}
func GetUserRegisterAddFriendIDList(c *gin.Context) {
var (
req apiStruct.GetUserRegisterAddFriendIDListRequest
resp apiStruct.GetUserRegisterAddFriendIDListResponse
)
if err := c.BindJSON(&req); err != nil {
log.NewError("0", utils.GetSelfFuncName(), err.Error())
openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
return
}
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), req)
etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImAdminCMSName, req.OperationID)
if etcdConn == nil {
errMsg := req.OperationID + "getcdv3.GetConn == nil"
log.NewError(req.OperationID, errMsg)
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
return
}
client := pbAdmin.NewAdminCMSClient(etcdConn)
respPb, err := client.GetUserRegisterAddFriendIDList(context.Background(), &pbAdmin.GetUserRegisterAddFriendIDListReq{OperationID: req.OperationID, Pagination: &pbCommon.RequestPagination{
PageNumber: int32(req.PageNumber),
ShowNumber: int32(req.ShowNumber),
}})
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "rpc failed", err.Error())
openIMHttp.RespHttp200(c, err, nil)
return
}
resp.Users = respPb.UserInfoList
resp.ShowNumber = int(respPb.Pagination.ShowNumber)
resp.CurrentPage = int(respPb.Pagination.CurrentPage)
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), resp)
openIMHttp.RespHttp200(c, constant.OK, resp)
}
internal/cms_api/group/group.go
+4 -2
View File
@@ -220,8 +220,10 @@ func GetGroupMembers(c *gin.Context) {
ShowNumber: int(respPb.Pagination.ShowNumber),
}
resp.MemberNums = int(respPb.MemberNums)
for _, groupMembers := range respPb.Members {
resp.GroupMembers = append(resp.GroupMembers, *groupMembers)
for _, groupMember := range respPb.Members {
memberResp := cms_api_struct.GroupMemberResponse{}
utils.CopyStructFields(&memberResp, groupMember)
resp.GroupMembers = append(resp.GroupMembers, memberResp)
}
log.NewInfo("", utils.GetSelfFuncName(), "req: ", resp)
openIMHttp.RespHttp200(c, constant.OK, resp)
internal/cms_api/router.go
+4 -6
View File
@@ -20,6 +20,10 @@ func NewGinRouter() *gin.Engine {
adminRouterGroup := router.Group("/admin")
{
adminRouterGroup.POST("/login", admin.AdminLogin)
adminRouterGroup.Use(middleware.JWTAuth())
adminRouterGroup.POST("/add_user_register_add_friend_id", admin.AddUserRegisterAddFriendIDList)
adminRouterGroup.POST("/reduce_user_register_reduce_friend_id", admin.ReduceUserRegisterAddFriendIDList)
adminRouterGroup.POST("/get_user_register_reduce_friend_id_list", admin.GetUserRegisterAddFriendIDList)
}
r2 := router.Group("")
r2.Use(middleware.JWTAuth())
@@ -73,12 +77,6 @@ func NewGinRouter() *gin.Engine {
userRouterGroup.POST("/delete_user", user.DeleteUser)
userRouterGroup.GET("/get_users_by_name", user.GetUsersByName)
}
friendRouterGroup := r2.Group("/friend")
{
friendRouterGroup.POST("/get_friends_by_id")
friendRouterGroup.POST("/set_friend")
friendRouterGroup.POST("/remove_friend")
}
messageCMSRouterGroup := r2.Group("/message")
{
messageCMSRouterGroup.GET("/get_chat_logs", messageCMS.GetChatLogs)
internal/cms_api/user/user.go
+4
View File
@@ -323,6 +323,10 @@ func GetBlockUsers(c *gin.Context) {
ProfilePhoto: v.User.ProfilePhoto,
Nickname: v.User.Nickname,
IsBlock: v.User.IsBlock,
Birth: v.User.Birth,
PhoneNumber: v.User.PhoneNumber,
Email: v.User.Email,
Gender: int(v.User.Gender),
CreateTime: v.User.CreateTime,
},
BeginDisableTime: v.BeginDisableTime,
internal/cron_task/cron_task.go
+1
View File
@@ -15,6 +15,7 @@ import (
const cronTaskOperationID = "cronTaskOperationID-"
func StartCronTask() {
log.NewPrivateLog("cron")
log.NewInfo(utils.OperationIDGenerator(), "start cron task")
c := cron.New()
fmt.Println("config", config.Config.Mongo.ChatRecordsClearTime)
internal/cron_task/test/main.go
+5 -1
View File
@@ -1,3 +1,7 @@
package main
func main() {}
import "Open_IM/pkg/common/db"
func main() {
db.DB.BatchInsertChat()
}
internal/demo/register/invitation_code.go
+120
View File
@@ -0,0 +1,120 @@
package register
import (
apiStruct "Open_IM/pkg/base_info"
"Open_IM/pkg/common/constant"
imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model"
"Open_IM/pkg/common/log"
"Open_IM/pkg/utils"
"github.com/gin-gonic/gin"
"net/http"
"time"
)
type InvitationCode struct {
InvitationCode string `json:"invitationCode"`
CreateTime time.Time `json:"createTime"`
UserID string `json:"userID"`
LastTime time.Time `json:"lastTime"`
Status int32 `json:"status"`
}
type GenerateInvitationCodeReq struct {
CodesNum int `json:"codesNum" binding:"required"`
CodeLen int `json:"codeLen" binding:"required"`
OperationID string `json:"operationID" binding:"required"`
}
type GenerateInvitationCodeResp struct {
Codes []string `json:"codes"`
}
func GenerateInvitationCode(c *gin.Context) {
req := GenerateInvitationCodeReq{}
resp := GenerateInvitationCodeResp{}
if err := c.BindJSON(&req); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"errCode": constant.FormattingError, "errMsg": err.Error()})
return
}
var err error
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req:", req)
resp.Codes, err = imdb.BatchCreateInvitationCodes(req.CodesNum, req.CodeLen)
if err != nil {
log.NewError(req.OperationID, "BatchCreateInvitationCodes failed", req.CodesNum, req.CodeLen)
c.JSON(http.StatusInternalServerError, gin.H{"errCode": constant.ErrDB, "errMsg": "Verification code error!"})
return
}
c.JSON(http.StatusOK, gin.H{"errCode": 0, "errMsg": "", "data": resp})
}
type QueryInvitationCodeReq struct {
Code string `json:"code" binding:"required"`
OperationID string `json:"operationID" binding:"required"`
}
type QueryInvitationCodeResp struct {
InvitationCode
}
func QueryInvitationCode(c *gin.Context) {
req := QueryInvitationCodeReq{}
resp := QueryInvitationCodeResp{}
if err := c.BindJSON(&req); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"errCode": constant.FormattingError, "errMsg": err.Error()})
return
}
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req:", req)
invitation, err := imdb.GetInvitationCode(req.Code)
if err != nil {
log.NewError(req.OperationID, "GetInvitationCode failed", req.Code)
c.JSON(http.StatusInternalServerError, gin.H{"errCode": constant.ErrDB, "errMsg": "Verification code error!"})
return
}
resp.UserID = invitation.UserID
resp.CreateTime = invitation.CreateTime
resp.Status = invitation.Status
resp.LastTime = invitation.LastTime
resp.InvitationCode.InvitationCode = invitation.InvitationCode
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp:", resp)
c.JSON(http.StatusOK, gin.H{"errCode": 0, "errMsg": "", "data": resp})
}
type GetInvitationCodesReq struct {
Status int32 `json:"status"`
OperationID string `json:"operationID" binding:"required"`
apiStruct.Pagination
}
type GetInvitationCodesResp struct {
apiStruct.Pagination
Codes []InvitationCode `json:"codes"`
}
func GetInvitationCodes(c *gin.Context) {
req := GetInvitationCodesReq{}
resp := GetInvitationCodesResp{}
if err := c.BindJSON(&req); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"errCode": constant.FormattingError, "errMsg": err.Error()})
return
}
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req:", req)
codes, err := imdb.GetInvitationCodes(req.ShowNumber, req.PageNumber, req.Status)
if err != nil {
log.NewError(req.OperationID, "GetInvitationCode failed", req.ShowNumber, req.PageNumber, req.Status)
c.JSON(http.StatusInternalServerError, gin.H{"errCode": constant.ErrDB, "errMsg": "Verification code error!"})
return
}
resp.Pagination.PageNumber = req.PageNumber
resp.Pagination.ShowNumber = req.ShowNumber
for _, v := range codes {
resp.Codes = append(resp.Codes, InvitationCode{
InvitationCode: v.InvitationCode,
CreateTime: v.CreateTime,
UserID: v.UserID,
LastTime: v.LastTime,
Status: v.Status,
})
}
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp:", resp)
c.JSON(http.StatusOK, gin.H{"errCode": 0, "errMsg": "", "data": resp})
}
internal/demo/register/ip_limit.go
+223
View File
@@ -0,0 +1,223 @@
package register
import (
//api "Open_IM/pkg/base_info"
"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/log"
"Open_IM/pkg/utils"
"github.com/gin-gonic/gin"
//"github.com/jinzhu/gorm"
"net/http"
"time"
)
type QueryIPRegisterReq struct {
OperationID string `json:"operationID"`
IP string `json:"ip"`
}
type QueryIPRegisterResp struct {
IP string `json:"ip"`
RegisterNum int `json:"num"`
Status int `json:"status"`
UserIDList []string `json:"userIDList"`
}
func QueryIPRegister(c *gin.Context) {
req := QueryIPRegisterReq{}
resp := QueryIPRegisterResp{}
if err := c.BindJSON(&req); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"errCode": constant.FormattingError, "errMsg": err.Error()})
return
}
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req:", req)
userIDList, err := imdb.GetRegisterUserNum(req.IP)
if err != nil {
log.NewError(req.OperationID, "GetInvitationCode failed", req.IP)
c.JSON(http.StatusInternalServerError, gin.H{"errCode": constant.ErrDB.ErrCode, "errMsg": "GetRegisterUserNum error!"})
return
}
resp.IP = req.IP
resp.RegisterNum = len(userIDList)
resp.UserIDList = userIDList
ipLimit, err := imdb.QueryIPLimits(req.IP)
if err != nil {
log.NewError(req.OperationID, "QueryIPLimits failed", req.IP, err.Error())
} else {
if ipLimit != nil {
if ipLimit.Ip != "" {
resp.Status = 1
}
}
}
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp:", resp)
c.JSON(http.StatusOK, gin.H{"errCode": 0, "errMsg": "", "data": resp})
}
type AddIPLimitReq struct {
OperationID string `json:"operationID"`
IP string `json:"ip"`
LimitTime int32 `json:"limitTime"`
}
type AddIPLimitResp struct {
}
func AddIPLimit(c *gin.Context) {
req := AddIPLimitReq{}
//resp := AddIPLimitResp{}
if err := c.BindJSON(&req); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"errCode": constant.FormattingError, "errMsg": err.Error()})
return
}
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req:", req)
if err := imdb.InsertOneIntoIpLimits(db.IpLimit{
Ip: req.IP,
LimitRegister: 1,
LimitLogin: 1,
CreateTime: time.Now(),
LimitTime: utils.UnixSecondToTime(int64(req.LimitTime)),
}); err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.IP, req.LimitTime)
c.JSON(http.StatusInternalServerError, gin.H{"errCode": constant.ErrDB.ErrCode, "errMsg": "InsertOneIntoIpLimits error!"})
return
}
c.JSON(http.StatusOK, gin.H{"errCode": 0, "errMsg": ""})
}
type RemoveIPLimitReq struct {
OperationID string `json:"operationID"`
IP string `json:"ip"`
}
type RemoveIPLimitResp struct {
}
func RemoveIPLimit(c *gin.Context) {
req := RemoveIPLimitReq{}
//resp := AddIPLimitResp{}
if err := c.BindJSON(&req); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"errCode": constant.ErrArgs, "errMsg": err.Error()})
return
}
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req:", req)
if err := imdb.DeleteOneFromIpLimits(req.IP); err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.IP)
c.JSON(http.StatusInternalServerError, gin.H{"errCode": constant.ErrDB.ErrCode, "errMsg": "InsertOneIntoIpLimits error!"})
return
}
c.JSON(http.StatusOK, gin.H{"errCode": 0, "errMsg": ""})
}
// ===========================================sk ==========================
type QueryUserIDIPLimitLoginReq struct {
UserID string `json:"userID" binding:"required"`
OperationID string `json:"operationID" binding:"required"`
}
//type QueryUserIDIPLimitLoginResp struct {
// UserIpLimit []db.UserIpLimit `json:"userIpLimit"`
//}
func QueryUserIDLimitLogin(c *gin.Context) {
req := QueryUserIDIPLimitLoginReq{}
if err := c.BindJSON(&req); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"errCode": constant.FormattingError, "errMsg": err.Error()})
return
}
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req:", req)
resp, err := imdb.GetIpLimitsLoginByUserID(req.UserID)
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.UserID)
c.JSON(http.StatusInternalServerError, gin.H{"errCode": constant.ErrDB.ErrCode, "errMsg": "GetIpLimitsByUserID error!"})
return
}
if len(resp) > 0 {
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp:", resp)
c.JSON(http.StatusOK, gin.H{"errCode": 0, "errMsg": "", "data": resp})
return
}
c.JSON(http.StatusOK, gin.H{"errCode": 0, "errMsg": "", "data": resp})
}
type AddUserIPLimitLoginReq struct {
UserID string `json:"userID" binding:"required"`
OperationID string `json:"operationID" binding:"required"`
IP string `json:"ip"`
}
type AddUserIPLimitLoginResp struct {
}
// 添加ip 特定用户才能登录 user_ip_limits 表
func AddUserIPLimitLogin(c *gin.Context) {
req := AddUserIPLimitLoginReq{}
if err := c.BindJSON(&req); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"errCode": constant.FormattingError, "errMsg": err.Error()})
return
}
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req:", req)
userIp := db.UserIpLimit{UserID: req.UserID, Ip: req.IP}
err := imdb.UpdateUserInfo(db.User{
UserID: req.UserID,
LoginLimit: 1,
})
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.UserID)
c.JSON(http.StatusInternalServerError, gin.H{"errCode": constant.ErrDB, "errMsg": "InsertUserIpLimitsLogin error!"})
return
}
err = imdb.InsertUserIpLimitsLogin(&userIp)
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.UserID)
c.JSON(http.StatusInternalServerError, gin.H{"errCode": constant.ErrDB, "errMsg": "InsertUserIpLimitsLogin error!"})
return
}
c.JSON(http.StatusOK, gin.H{"errCode": 0, "errMsg": ""})
}
type RemoveUserIPLimitReq struct {
UserID string `json:"userID" binding:"required"`
OperationID string `json:"operationID" binding:"required"`
IP string `json:"ip"`
}
type RemoveUserIPLimitResp struct {
}
// 删除ip 特定用户才能登录 user_ip_limits 表
func RemoveUserIPLimitLogin(c *gin.Context) {
req := RemoveUserIPLimitReq{}
if err := c.BindJSON(&req); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"errCode": constant.FormattingError, "errMsg": err.Error()})
return
}
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req:", req)
err := imdb.DeleteUserIpLimitsLogin(req.UserID, req.IP)
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.UserID)
c.JSON(http.StatusInternalServerError, gin.H{"errCode": constant.ErrDB, "errMsg": "DeleteUserIpLimitsLogin error!"})
return
}
ips, err := imdb.GetIpLimitsLoginByUserID(req.UserID)
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.UserID)
c.JSON(http.StatusInternalServerError, gin.H{"errCode": constant.ErrDB, "errMsg": "GetIpLimitsLoginByUserID error!"})
return
}
if len(ips) == 0 {
err := imdb.UpdateUserInfoByMap(db.User{
UserID: req.UserID,
}, map[string]interface{}{"login_limit": 0})
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.UserID)
c.JSON(http.StatusInternalServerError, gin.H{"errCode": constant.ErrDB, "errMsg": "UpdateUserInfo error!"})
return
}
}
c.JSON(http.StatusOK, gin.H{"errCode": 0, "errMsg": ""})
}
internal/demo/register/login.go
+5
View File
@@ -57,12 +57,17 @@ func Login(c *gin.Context) {
} else {
userID = r.Account
}
ip := c.Request.Header.Get("X-Forward-For")
if ip == "" {
ip = c.ClientIP()
}
url := fmt.Sprintf("http://%s:%d/auth/user_token", utils.ServerIP, config.Config.Api.GinPort[0])
openIMGetUserToken := api.UserTokenReq{}
openIMGetUserToken.OperationID = params.OperationID
openIMGetUserToken.Platform = params.Platform
openIMGetUserToken.Secret = config.Config.Secret
openIMGetUserToken.UserID = userID
openIMGetUserToken.LoginIp = ip
loginIp := c.Request.Header.Get("X-Forward-For")
if loginIp == "" {
loginIp = c.ClientIP()
internal/demo/register/onboarding_process.go
+1
View File
@@ -9,6 +9,7 @@ import (
"Open_IM/pkg/common/log"
"Open_IM/pkg/grpc-etcdv3/getcdv3"
groupRpc "Open_IM/pkg/proto/group"
organizationRpc "Open_IM/pkg/proto/organization"
commonPb "Open_IM/pkg/proto/sdk_ws"
"Open_IM/pkg/utils"
internal/demo/register/register_import_friend.go
+52
View File
@@ -0,0 +1,52 @@
package register
import (
"Open_IM/pkg/common/config"
imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model"
"Open_IM/pkg/common/log"
"Open_IM/pkg/grpc-etcdv3/getcdv3"
pbFriend "Open_IM/pkg/proto/friend"
"Open_IM/pkg/utils"
"context"
"strings"
)
var ChImportFriend chan *pbFriend.ImportFriendReq
func init() {
ChImportFriend = make(chan *pbFriend.ImportFriendReq, 1000)
}
func ImportFriendRoutine() {
for {
req := <-ChImportFriend
go func() {
friendUserIDList, err := imdb.GetRegisterAddFriendList(0, 0)
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), req, err.Error())
return
}
log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "ImportFriendRoutine IDList", friendUserIDList)
if len(friendUserIDList) == 0 {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "len==0")
return
}
req.FriendUserIDList = friendUserIDList
etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName, req.OperationID)
if etcdConn == nil {
errMsg := req.OperationID + "getcdv3.GetConn == nil"
log.NewError(req.OperationID, errMsg)
return
}
client := pbFriend.NewFriendClient(etcdConn)
rpcResp, err := client.ImportFriend(context.Background(), req)
if err != nil {
log.NewError(req.OperationID, "ImportFriend failed ", err.Error(), req.String())
return
}
if rpcResp.CommonResp.ErrCode != 0 {
log.NewError(req.OperationID, "ImportFriend failed ", rpcResp)
}
}()
}
}
internal/demo/register/send_code.go
+12 -3
View File
@@ -8,12 +8,12 @@ import (
"Open_IM/pkg/common/log"
"Open_IM/pkg/common/utils"
"fmt"
"github.com/gin-gonic/gin"
"gopkg.in/gomail.v2"
"math/rand"
"net/http"
"time"
"github.com/gin-gonic/gin"
"gopkg.in/gomail.v2"
)
var sms SMS
@@ -73,6 +73,15 @@ func SendVerificationCode(c *gin.Context) {
c.JSON(http.StatusOK, gin.H{"errCode": constant.HasRegistered, "errMsg": "The phone number has been registered"})
return
}
//需要邀请码
if config.Config.Demo.NeedInvitationCode {
err = im_mysql_model.CheckInvitationCode(params.InvitationCode)
if err != nil {
log.NewError(params.OperationID, "邀请码错误", params)
c.JSON(http.StatusOK, gin.H{"errCode": constant.InvitationError, "errMsg": "邀请码错误"})
return
}
}
accountKey = accountKey + "_" + constant.VerificationCodeForRegisterSuffix
ok, err := db.DB.JudgeAccountEXISTS(accountKey)
if ok || err != nil {
internal/demo/register/set_password.go
+54 -8
View File
@@ -5,9 +5,10 @@ import (
"Open_IM/pkg/common/config"
"Open_IM/pkg/common/constant"
"Open_IM/pkg/common/db"
"Open_IM/pkg/common/db/mysql_model/im_mysql_model"
imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model"
http2 "Open_IM/pkg/common/http"
"Open_IM/pkg/common/log"
pbFriend "Open_IM/pkg/proto/friend"
"Open_IM/pkg/utils"
"encoding/json"
"math/big"
@@ -40,6 +41,23 @@ func SetPassword(c *gin.Context) {
c.JSON(http.StatusBadRequest, gin.H{"errCode": constant.FormattingError, "errMsg": err.Error()})
return
}
ip := c.Request.Header.Get("X-Forward-For")
if ip == "" {
ip = c.ClientIP()
}
log.NewDebug(params.OperationID, utils.GetSelfFuncName(), "ip:", ip)
Limited, LimitError := imdb.IsLimitRegisterIp(ip)
if LimitError != nil {
log.Error(params.OperationID, utils.GetSelfFuncName(), LimitError, ip)
c.JSON(http.StatusBadRequest, gin.H{"errCode": constant.ErrDB.ErrCode, "errMsg": LimitError.Error()})
return
}
if Limited {
c.JSON(http.StatusBadRequest, gin.H{"errCode": constant.RegisterLimit, "errMsg": "limited"})
return
}
var account string
if params.Email != "" {
account = params.Email
@@ -63,6 +81,13 @@ func SetPassword(c *gin.Context) {
return
}
}
if config.Config.Demo.NeedInvitationCode && params.InvitationCode != "" {
err := imdb.CheckInvitationCode(params.InvitationCode)
if err != nil {
c.JSON(http.StatusOK, gin.H{"errCode": constant.InvitationError, "errMsg": "邀请码错误"})
return
}
}
}
//userID := utils.Base64Encode(account)
var userID string
@@ -83,11 +108,9 @@ 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
openIMRegisterReq.CreateIp = ip
openIMRegisterReq.LastLoginIp = ip
openIMRegisterReq.InvitationCode = params.InvitationCode
openIMRegisterResp := api.UserRegisterResp{}
log.NewDebug(params.OperationID, utils.GetSelfFuncName(), "register req:", openIMRegisterReq)
bMsg, err := http2.Post(url, openIMRegisterReq, 2)
@@ -104,18 +127,30 @@ func SetPassword(c *gin.Context) {
}
if openIMRegisterResp.ErrCode == constant.RegisterLimit {
c.JSON(http.StatusOK, gin.H{"errCode": constant.RegisterLimit, "errMsg": "用户注册被限制"})
return
} else if openIMRegisterResp.ErrCode == constant.InvitationError {
c.JSON(http.StatusOK, gin.H{"errCode": constant.InvitationError, "errMsg": "邀请码错误"})
return
} else {
c.JSON(http.StatusOK, gin.H{"errCode": constant.RegisterFailed, "errMsg": "register failed: " + openIMRegisterResp.ErrMsg})
return
}
return
}
log.Info(params.OperationID, "begin store mysql", account, params.Password, "info", params.FaceURL, params.Nickname)
err = im_mysql_model.SetPassword(account, params.Password, params.Ex, userID, params.AreaCode)
err = imdb.SetPassword(account, params.Password, params.Ex, userID, params.AreaCode, ip)
if err != nil {
log.NewError(params.OperationID, "set phone number password error", account, "err", err.Error())
c.JSON(http.StatusOK, gin.H{"errCode": constant.RegisterFailed, "errMsg": err.Error()})
return
}
if config.Config.Demo.NeedInvitationCode && params.InvitationCode != "" {
//判断一下验证码的使用情况
LockSucc := imdb.TryLockInvitationCode(params.InvitationCode, userID)
if LockSucc {
imdb.FinishInvitationCode(params.InvitationCode, userID)
}
}
log.Info(params.OperationID, "end setPassword", account, params.Password)
// demo onboarding
if params.UserID == "" && config.Config.Demo.OnboardProcess {
@@ -132,6 +167,17 @@ func SetPassword(c *gin.Context) {
log.NewWarn(params.OperationID, utils.GetSelfFuncName(), "to ch timeOut")
}
}
select {
case ChImportFriend <- &pbFriend.ImportFriendReq{
OperationID: params.OperationID,
FromUserID: userID,
OpUserID: config.Config.Manager.AppManagerUid[0],
}:
case <-time.After(time.Second * 2):
log.NewWarn(params.OperationID, utils.GetSelfFuncName(), "to ChImportFriend timeOut")
}
c.JSON(http.StatusOK, gin.H{"errCode": constant.NoError, "errMsg": "", "data": openIMRegisterResp.UserToken})
return
}
internal/rpc/admin_cms/admin_cms.go
+54
View File
@@ -3,11 +3,13 @@ package admin_cms
import (
"Open_IM/pkg/common/config"
"Open_IM/pkg/common/constant"
imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model"
openIMHttp "Open_IM/pkg/common/http"
"Open_IM/pkg/common/log"
"Open_IM/pkg/common/token_verify"
"Open_IM/pkg/grpc-etcdv3/getcdv3"
pbAdminCMS "Open_IM/pkg/proto/admin_cms"
server_api_params "Open_IM/pkg/proto/sdk_ws"
"Open_IM/pkg/utils"
"context"
"net"
@@ -100,3 +102,55 @@ func (s *adminCMSServer) AdminLogin(_ context.Context, req *pbAdminCMS.AdminLogi
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
return resp, nil
}
func (s *adminCMSServer) AddUserRegisterAddFriendIDList(_ context.Context, req *pbAdminCMS.AddUserRegisterAddFriendIDListReq) (*pbAdminCMS.AddUserRegisterAddFriendIDListResp, error) {
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
resp := &pbAdminCMS.AddUserRegisterAddFriendIDListResp{}
if err := imdb.AddUserRegisterAddFriendIDList(req.UserIDList...); err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.UserIDList)
return resp, openIMHttp.WrapError(constant.ErrDB)
}
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", req.String())
return resp, nil
}
func (s *adminCMSServer) ReduceUserRegisterAddFriendIDList(_ context.Context, req *pbAdminCMS.ReduceUserRegisterAddFriendIDListReq) (*pbAdminCMS.ReduceUserRegisterAddFriendIDListResp, error) {
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
resp := &pbAdminCMS.ReduceUserRegisterAddFriendIDListResp{}
if req.Operation == 0 {
if err := imdb.ReduceUserRegisterAddFriendIDList(req.UserIDList...); err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.UserIDList)
return resp, openIMHttp.WrapError(constant.ErrDB)
}
} else {
if err := imdb.DeleteAllRegisterAddFriendIDList(); err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.UserIDList)
return resp, openIMHttp.WrapError(constant.ErrDB)
}
}
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", req.String())
return resp, nil
}
func (s *adminCMSServer) GetUserRegisterAddFriendIDList(_ context.Context, req *pbAdminCMS.GetUserRegisterAddFriendIDListReq) (*pbAdminCMS.GetUserRegisterAddFriendIDListResp, error) {
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
resp := &pbAdminCMS.GetUserRegisterAddFriendIDListResp{UserInfoList: []*server_api_params.UserInfo{}}
userIDList, err := imdb.GetRegisterAddFriendList(req.Pagination.ShowNumber, req.Pagination.PageNumber)
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error())
return resp, openIMHttp.WrapError(constant.ErrDB)
}
userList, err := imdb.GetUsersByUserIDList(userIDList)
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), userIDList)
return resp, openIMHttp.WrapError(constant.ErrDB)
}
log.NewDebug(req.OperationID, utils.GetSelfFuncName(), userList, userIDList)
resp.Pagination = &server_api_params.ResponsePagination{
CurrentPage: req.Pagination.PageNumber,
ShowNumber: req.Pagination.ShowNumber,
}
utils.CopyStructFields(&resp.UserInfoList, userList)
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", req.String())
return resp, nil
}
internal/rpc/auth/auth.go
+3 -7
View File
@@ -30,15 +30,11 @@ 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 {
if err == constant.InvitationMsg {
return &pbAuth.UserRegisterResp{CommonResp: &pbAuth.CommonResp{ErrCode: constant.InvitationError, ErrMsg: "邀请码错误"}}, nil
}
errMsg := req.OperationID + " imdb.UserRegister failed " + err.Error() + user.UserID
log.NewError(req.OperationID, errMsg, user)
return &pbAuth.UserRegisterResp{CommonResp: &pbAuth.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}}, nil
internal/rpc/group/group.go
+16 -12
View File
@@ -623,7 +623,7 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou
continue
}
err = imdb.RemoveGroupMember(req.GroupID, v)
err = imdb.DeleteGroupMemberByGroupIDAndUserID(req.GroupID, v)
if err != nil {
log.NewError(req.OperationID, "RemoveGroupMember failed ", err.Error(), req.GroupID, v)
resp.Id2ResultList = append(resp.Id2ResultList, &pbGroup.Id2Result{UserID: v, Result: -1})
@@ -1344,7 +1344,7 @@ func (s *groupServer) GetGroupByID(_ context.Context, req *pbGroup.GetGroupByIDR
return resp, http.WrapError(constant.ErrDB)
}
utils.CopyStructFields(resp.CMSGroup.GroupInfo, group)
groupMember, err := imdb.GetGroupMaster(group.GroupID)
groupMember, err := imdb.GetGroupOwnerInfoByGroupID(group.GroupID)
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroupMaster", err.Error())
return resp, http.WrapError(constant.ErrDB)
@@ -1358,6 +1358,7 @@ func (s *groupServer) GetGroupByID(_ context.Context, req *pbGroup.GetGroupByIDR
resp.CMSGroup.GroupOwnerUserName = groupMember.Nickname
resp.CMSGroup.GroupOwnerUserID = groupMember.UserID
resp.CMSGroup.GroupInfo.CreatorUserID = group.CreatorUserID
resp.CMSGroup.GroupInfo.CreateTime = uint32(group.CreateTime.Unix())
utils.CopyStructFields(resp.CMSGroup.GroupInfo, group)
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
return resp, nil
@@ -1387,12 +1388,14 @@ func (s *groupServer) GetGroup(_ context.Context, req *pbGroup.GetGroupReq) (*pb
for _, v := range groups {
group := &pbGroup.CMSGroup{GroupInfo: &open_im_sdk.GroupInfo{}}
utils.CopyStructFields(group.GroupInfo, v)
groupMember, err := imdb.GetGroupMaster(v.GroupID)
groupMember, err := imdb.GetGroupOwnerInfoByGroupID(v.GroupID)
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroupMaster error", err.Error())
continue
}
group.GroupOwnerUserID = groupMember.GroupID
group.GroupInfo.CreateTime = uint32(v.CreateTime.Unix())
group.GroupOwnerUserID = groupMember.UserID
group.GroupOwnerUserName = groupMember.Nickname
resp.CMSGroups = append(resp.CMSGroups, group)
}
@@ -1411,24 +1414,23 @@ func (s *groupServer) GetGroups(_ context.Context, req *pbGroup.GetGroupsReq) (*
log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroups error", err.Error())
return resp, http.WrapError(constant.ErrDB)
}
groupsCountNum, err := imdb.GetGroupsCountNum(db.Group{})
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "groupsCountNum ", groupsCountNum)
resp.GroupNum, err = imdb.GetGroupsCountNum(db.Group{})
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroupsCountNum", err.Error())
log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroupsCountNum error", err.Error())
return resp, http.WrapError(constant.ErrDB)
}
resp.GroupNum = groupsCountNum
resp.Pagination.PageNumber = req.Pagination.PageNumber
resp.Pagination.ShowNumber = req.Pagination.ShowNumber
for _, v := range groups {
group := &pbGroup.CMSGroup{GroupInfo: &open_im_sdk.GroupInfo{}}
utils.CopyStructFields(group.GroupInfo, v)
groupMember, err := imdb.GetGroupMaster(v.GroupID)
groupMember, err := imdb.GetGroupOwnerInfoByGroupID(v.GroupID)
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroupMaster failed", err.Error(), v)
continue
}
group.GroupOwnerUserID = groupMember.GroupID
group.GroupInfo.CreateTime = uint32(v.CreateTime.Unix())
group.GroupOwnerUserID = groupMember.UserID
group.GroupOwnerUserName = groupMember.Nickname
resp.CMSGroups = append(resp.CMSGroups, group)
}
@@ -1439,7 +1441,7 @@ func (s *groupServer) GetGroups(_ context.Context, req *pbGroup.GetGroupsReq) (*
func (s *groupServer) OperateUserRole(_ context.Context, req *pbGroup.OperateUserRoleReq) (*pbGroup.OperateUserRoleResp, error) {
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "args:", req.String())
resp := &pbGroup.OperateUserRoleResp{}
oldOwnerUserID, err := imdb.GetGroupMaster(req.GroupID)
oldOwnerUserID, err := imdb.GetGroupOwnerInfoByGroupID(req.GroupID)
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroupMaster failed", err.Error())
return resp, http.WrapError(constant.ErrDB)
@@ -1485,6 +1487,8 @@ func (s *groupServer) GetGroupMembersCMS(_ context.Context, req *pbGroup.GetGrou
for _, groupMember := range groupMembers {
member := open_im_sdk.GroupMemberFullInfo{}
utils.CopyStructFields(&member, groupMember)
member.JoinTime = int32(groupMember.JoinTime.Unix())
member.MuteEndTime = uint32(groupMember.MuteEndTime.Unix())
resp.Members = append(resp.Members, &member)
}
resp.Pagination = &open_im_sdk.ResponsePagination{
@@ -1499,7 +1503,7 @@ func (s *groupServer) RemoveGroupMembersCMS(_ context.Context, req *pbGroup.Remo
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "args:", req.String())
resp := &pbGroup.RemoveGroupMembersCMSResp{}
for _, userId := range req.UserIDList {
err := imdb.RemoveGroupMember(req.GroupID, userId)
err := imdb.DeleteGroupMemberByGroupIDAndUserID(req.GroupID, userId)
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error())
resp.Failed = append(resp.Failed, userId)
internal/rpc/message_cms/message_cms.go
+1 -1
View File
@@ -150,7 +150,7 @@ func (s *messageCMSServer) GetChatLogs(_ context.Context, req *pbMessageCMS.GetC
pbChatLog.ReciverNickName = recvUser.Nickname
case constant.GroupChatType:
group, err := imdb.GetGroupById(chatLog.RecvID)
group, err := imdb.GetGroupInfoByGroupID(chatLog.RecvID)
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroupById failed")
continue
internal/rpc/msg/rpcChat.go
+3 -3
View File
@@ -21,8 +21,8 @@ type rpcChat struct {
etcdSchema string
etcdAddr []string
onlineProducer *kafka.Producer
offlineProducer *kafka.Producer
delMsgCh chan deleteMsg
//offlineProducer *kafka.Producer
delMsgCh chan deleteMsg
}
type deleteMsg struct {
@@ -41,7 +41,7 @@ func NewRpcChatServer(port int) *rpcChat {
etcdAddr: config.Config.Etcd.EtcdAddr,
}
rc.onlineProducer = kafka.NewKafkaProducer(config.Config.Kafka.Ws2mschat.Addr, config.Config.Kafka.Ws2mschat.Topic)
rc.offlineProducer = kafka.NewKafkaProducer(config.Config.Kafka.Ws2mschatOffline.Addr, config.Config.Kafka.Ws2mschatOffline.Topic)
//rc.offlineProducer = kafka.NewKafkaProducer(config.Config.Kafka.Ws2mschatOffline.Addr, config.Config.Kafka.Ws2mschatOffline.Topic)
rc.delMsgCh = make(chan deleteMsg, 1000)
return &rc
}
internal/rpc/organization/organization.go
+2 -25
View File
@@ -305,31 +305,8 @@ func (s *organizationServer) CreateOrganizationUser(ctx context.Context, req *rp
}
func (s *organizationServer) UpdateOrganizationUser(ctx context.Context, req *rpc.UpdateOrganizationUserReq) (*rpc.UpdateOrganizationUserResp, error) {
authReq := &pbAuth.UserRegisterReq{UserInfo: &open_im_sdk.UserInfo{}}
utils.CopyStructFields(authReq.UserInfo, req.OrganizationUser)
authReq.OperationID = req.OperationID
etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImAuthName, req.OperationID)
if etcdConn == nil {
errMsg := req.OperationID + "getcdv3.GetConn == nil"
log.NewError(req.OperationID, errMsg)
return &rpc.UpdateOrganizationUserResp{ErrCode: constant.ErrInternal.ErrCode, ErrMsg: errMsg}, nil
}
client := pbAuth.NewAuthClient(etcdConn)
reply, err := client.UserRegister(context.Background(), authReq)
if err != nil {
errMsg := "UserRegister failed " + err.Error()
log.NewError(req.OperationID, errMsg)
return &rpc.UpdateOrganizationUserResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}, nil
}
if reply.CommonResp.ErrCode != 0 {
errMsg := "UserRegister failed " + reply.CommonResp.ErrMsg
log.NewError(req.OperationID, errMsg)
return &rpc.UpdateOrganizationUserResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}, nil
}
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc args ", req.String())
if !token_verify.IsManagerUserID(req.OpUserID) {
if !token_verify.IsManagerUserID(req.OpUserID) && req.OpUserID != req.OrganizationUser.UserID {
errMsg := req.OperationID + " " + req.OpUserID + " is not app manager"
log.Error(req.OperationID, errMsg)
return &rpc.UpdateOrganizationUserResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: errMsg}, nil
@@ -342,7 +319,7 @@ func (s *organizationServer) UpdateOrganizationUser(ctx context.Context, req *rp
}
log.Debug(req.OperationID, "src ", *req.OrganizationUser, "dst ", organizationUser)
err = imdb.UpdateOrganizationUser(&organizationUser, nil)
err := imdb.UpdateOrganizationUser(&organizationUser, nil)
if err != nil {
errMsg := req.OperationID + " " + "CreateOrganizationUser failed " + err.Error()
log.Error(req.OperationID, errMsg, organizationUser)
internal/rpc/user/user.go
+47 -17
View File
@@ -12,6 +12,7 @@ import (
"Open_IM/pkg/common/token_verify"
"Open_IM/pkg/grpc-etcdv3/getcdv3"
pbFriend "Open_IM/pkg/proto/friend"
pbOrganization "Open_IM/pkg/proto/organization"
sdkws "Open_IM/pkg/proto/sdk_ws"
pbUser "Open_IM/pkg/proto/user"
"Open_IM/pkg/utils"
@@ -19,6 +20,7 @@ import (
"net"
"strconv"
"strings"
"time"
"google.golang.org/grpc"
)
@@ -431,21 +433,33 @@ func (s *userServer) UpdateUserInfo(ctx context.Context, req *pbUser.UpdateUserI
if req.UserInfo.Nickname != "" {
go s.SyncJoinedGroupMemberNickname(req.UserInfo.UserID, req.UserInfo.Nickname, oldNickname, req.OperationID, req.OpUserID)
}
//updateUserInfoToCacheReq := &cache.UpdateUserInfoToCacheReq{
// OperationID: req.OperationID,
// UserInfoList: []*sdkws.UserInfo{req.UserInfo},
//}
//cacheEtcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName)
//cacheClient := cache.NewCacheClient(cacheEtcdConn)
//resp, err := cacheClient.UpdateUserInfoToCache(context.Background(), updateUserInfoToCacheReq)
//if err != nil {
// log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), updateUserInfoToCacheReq.String())
// return &pbUser.UpdateUserInfoResp{CommonResp: &pbUser.CommonResp{ErrCode: constant.ErrServer.ErrCode, ErrMsg: err.Error()}}, nil
//}
//if resp.CommonResp.ErrCode != 0 {
// log.NewError(req.OperationID, utils.GetSelfFuncName(), resp.String())
// return &pbUser.UpdateUserInfoResp{CommonResp: &pbUser.CommonResp{ErrCode: constant.ErrServer.ErrCode, ErrMsg: resp.CommonResp.ErrMsg}}, nil
//}
etcdConn = getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName, req.OperationID)
clientOrg := pbOrganization.NewOrganizationClient(etcdConn)
out, err := clientOrg.UpdateOrganizationUser(context.Background(), &pbOrganization.UpdateOrganizationUserReq{
OrganizationUser: &sdkws.OrganizationUser{
UserID: req.UserInfo.UserID,
Nickname: req.UserInfo.Nickname,
EnglishName: req.UserInfo.Nickname,
FaceURL: req.UserInfo.FaceURL,
Gender: req.UserInfo.Gender,
Mobile: req.UserInfo.PhoneNumber,
Telephone: req.UserInfo.PhoneNumber,
Birth: req.UserInfo.Birth,
Email: req.UserInfo.Email,
Ex: req.UserInfo.Ex,
},
OperationID: req.OperationID,
OpUserID: req.OpUserID,
})
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "UpdateOrganizationUser failed", err.Error())
} else {
if out.ErrCode != 0 {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "grpc resp: ", out)
}
}
return &pbUser.UpdateUserInfoResp{CommonResp: &pbUser.CommonResp{}}, nil
}
func (s *userServer) SetGlobalRecvMessageOpt(ctx context.Context, req *pbUser.SetGlobalRecvMessageOptReq) (*pbUser.SetGlobalRecvMessageOptResp, error) {
@@ -660,11 +674,19 @@ func (s *userServer) ResignUser(ctx context.Context, req *pbUser.ResignUserReq)
func (s *userServer) AlterUser(ctx context.Context, req *pbUser.AlterUserReq) (*pbUser.AlterUserResp, error) {
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
resp := &pbUser.AlterUserResp{}
birth, _ := time.ParseInLocation("2006-01-02", req.Birth, time.Local)
gender, gendererr := strconv.Atoi(req.Gender)
if gendererr != nil {
gender = 0
}
user := db.User{
PhoneNumber: strconv.FormatInt(req.PhoneNumber, 10),
PhoneNumber: req.PhoneNumber,
Nickname: req.Nickname,
Email: req.Email,
UserID: req.UserId,
Gender: int32(gender),
FaceURL: req.Photo,
Birth: birth,
}
if err := imdb.UpdateUserInfo(user); err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "UpdateUserInfo", err.Error())
@@ -678,7 +700,7 @@ func (s *userServer) AlterUser(ctx context.Context, req *pbUser.AlterUserReq) (*
func (s *userServer) AddUser(ctx context.Context, req *pbUser.AddUserReq) (*pbUser.AddUserResp, error) {
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
resp := &pbUser.AddUserResp{}
err := imdb.AddUser(req.UserId, req.PhoneNumber, req.Name)
err := imdb.AddUser(req.UserId, req.PhoneNumber, req.Name, req.Email, req.Gender, req.Photo, req.Birth)
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "AddUser", err.Error())
return resp, errors.WrapError(constant.ErrDB)
@@ -723,6 +745,10 @@ func (s *userServer) GetBlockUsers(ctx context.Context, req *pbUser.GetBlockUser
Nickname: v.User.Nickname,
UserId: v.User.UserID,
IsBlock: true,
Birth: v.User.Birth.Format("2006-01-02"),
PhoneNumber: v.User.PhoneNumber,
Email: v.User.Email,
Gender: v.User.Gender,
},
BeginDisableTime: (v.BeginDisableTime).String(),
EndDisableTime: (v.EndDisableTime).String(),
@@ -755,6 +781,10 @@ func (s *userServer) GetBlockUserById(_ context.Context, req *pbUser.GetBlockUse
Nickname: user.User.Nickname,
UserId: user.User.UserID,
IsBlock: true,
Birth: user.User.Birth.Format("2006-01-02"),
PhoneNumber: user.User.PhoneNumber,
Email: user.User.Email,
Gender: user.User.Gender,
},
BeginDisableTime: (user.BeginDisableTime).String(),
EndDisableTime: (user.EndDisableTime).String(),