Merge remote-tracking branch 'origin/tuoyun' into tuoyun

internal/api/group/group.go

@@ -348,7 +348,7 @@ func ApplicationGroupResponse(c *gin.Context) {
 		return
 	}
 
-	resp := api.CommResp{ErrCode: reply.ErrCode, ErrMsg: reply.ErrMsg}
+	resp := api.CommResp{ErrCode: reply.CommonResp.ErrCode, ErrMsg: reply.CommonResp.ErrMsg}
 	c.JSON(http.StatusOK, resp)
 	log.NewInfo(req.OperationID, "ApplicationGroupResponse api return ", resp)
 }
@@ -379,7 +379,7 @@ func JoinGroup(c *gin.Context) {
 		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call  rpc server failed"})
 		return
 	}
-	resp := api.CommResp{ErrCode: RpcResp.ErrCode, ErrMsg: RpcResp.ErrMsg}
+	resp := api.CommResp{ErrCode: RpcResp.CommonResp.ErrCode, ErrMsg: RpcResp.CommonResp.ErrMsg}
 	c.JSON(http.StatusOK, resp)
 	log.NewInfo("JoinGroup api return", RpcResp.String())
 }
@@ -410,7 +410,7 @@ func QuitGroup(c *gin.Context) {
 		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call  rpc server failed"})
 		return
 	}
-	resp := api.CommResp{ErrCode: RpcResp.ErrCode, ErrMsg: RpcResp.ErrMsg}
+	resp := api.CommResp{ErrCode: RpcResp.CommonResp.ErrCode, ErrMsg: RpcResp.CommonResp.ErrMsg}
 	c.JSON(http.StatusOK, resp)
 	log.NewInfo("QuitGroup api return", RpcResp.String())
 }
@@ -441,7 +441,7 @@ func SetGroupInfo(c *gin.Context) {
 		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call  rpc server failed"})
 		return
 	}
-	resp := api.CommResp{ErrCode: RpcResp.ErrCode, ErrMsg: RpcResp.ErrMsg}
+	resp := api.CommResp{ErrCode: RpcResp.CommonResp.ErrCode, ErrMsg: RpcResp.CommonResp.ErrMsg}
 	c.JSON(http.StatusOK, resp)
 	log.NewInfo(req.OperationID, "SetGroupInfo api return ", resp)
 }
@@ -473,7 +473,7 @@ func TransferGroupOwner(c *gin.Context) {
 		return
 	}
 
-	resp := api.CommResp{ErrCode: reply.ErrCode, ErrMsg: reply.ErrMsg}
+	resp := api.CommResp{ErrCode: reply.CommonResp.ErrCode, ErrMsg: reply.CommonResp.ErrMsg}
 	c.JSON(http.StatusOK, resp)
 	log.NewInfo(req.OperationID, "TransferGroupOwner api return ", resp)
 }

internal/api/user/update_user_info.go

@@ -1 +0,0 @@
-package user

internal/rpc/friend/firend.go

@@ -113,8 +113,9 @@ func (s *friendServer) AddBlacklist(ctx context.Context, req *pbFriend.AddBlackl
 	if !ok {
 		log.NewError(req.CommID.OperationID, "CheckAccess failed ", req.CommID.OpUserID, req.CommID.FromUserID)
 	}
+	black := imdb.Black{OwnerUserID: req.CommID.FromUserID, BlockUserID: req.CommID.ToUserID}
 
-	err := imdb.InsertInToUserBlackList(req.CommID.FromUserID, req.CommID.ToUserID)
+	err := imdb.InsertInToUserBlackList(black)
 	if err != nil {
 		log.NewError(req.CommID.OperationID, "InsertInToUserBlackList failed ", err.Error())
 		return &pbFriend.AddBlacklistResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
@@ -131,15 +132,17 @@ func (s *friendServer) AddFriend(ctx context.Context, req *pbFriend.AddFriendReq
 		log.NewError(req.CommID.OperationID, "CheckAccess failed ", req.CommID.OpUserID, req.CommID.FromUserID)
 	}
 	//Cannot add non-existent users
-	if _, err := imdb.FindUserByUID(req.CommID.ToUserID); err != nil {
+	if _, err := imdb.GetUserByUserID(req.CommID.ToUserID); err != nil {
-		log.NewError(req.CommID.OperationID, "FindUserByUID failed ", err.Error(), req.CommID.ToUserID)
+		log.NewError(req.CommID.OperationID, "GetUserByUserID failed ", err.Error(), req.CommID.ToUserID)
 		return &pbFriend.AddFriendResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
 	}
 
 	//Establish a latest relationship in the friend request table
-	err := imdb.ReplaceIntoFriendReq(req.CommID.FromUserID, req.CommID.ToUserID, constant.ApplicationFriendFlag, req.ReqMsg)
+	friendRequest := imdb.FriendRequest{ReqMessage: req.ReqMsg}
+	utils.CopyStructFields(&friendRequest, req.CommID)
+	err := imdb.UpdateFriendApplication(&friendRequest)
 	if err != nil {
-		log.NewError(req.CommID.OperationID, "ReplaceIntoFriendReq failed ", err.Error())
+		log.NewError(req.CommID.OperationID, "UpdateFriendApplication failed ", err.Error())
 		return &pbFriend.AddFriendResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
 	}
 
@@ -158,8 +161,7 @@ func (s *friendServer) ImportFriend(ctx context.Context, req *pbFriend.ImportFri
 		c.ErrMsg = constant.ErrAccess.ErrMsg
 		return &pbFriend.ImportFriendResp{CommonResp: &c, FailedFriendUserIDList: req.FriendUserIDList}, nil
 	}
-
+	if _, err := imdb.GetUserByUserID(req.FromUserID); err != nil {
-	if _, err := imdb.FindUserByUID(req.FromUserID); err != nil {
 		log.NewError(req.OperationID, "FindUserByUID failed ", err.Error(), req.FromUserID)
 		c.ErrCode = constant.ErrDB.ErrCode
 		c.ErrMsg = "this user not exists,cant not add friend"
@@ -167,14 +169,15 @@ func (s *friendServer) ImportFriend(ctx context.Context, req *pbFriend.ImportFri
 	}
 
 	for _, v := range req.FriendUserIDList {
-		if _, fErr := imdb.FindUserByUID(v); fErr != nil {
+		if _, fErr := imdb.GetUserByUserID(v); fErr != nil {
 			c.ErrMsg = "some uid establish failed"
 			c.ErrCode = 408
 			resp.FailedFriendUserIDList = append(resp.FailedFriendUserIDList, v)
 		} else {
-			if _, err := imdb.FindFriendRelationshipFromFriend(req.FromUserID, v); err != nil {
+			if _, err := imdb.GetFriendRelationshipFromFriend(req.FromUserID, v); err != nil {
 				//Establish two single friendship
-				err1 := imdb.InsertToFriend(req.FromUserID, v, 1)
+				toInsertFollow := imdb.Friend{OwnerUserID: req.FromUserID, FriendUserID: v}
+				err1 := imdb.InsertToFriend(&toInsertFollow)
 				if err1 != nil {
 					resp.FailedFriendUserIDList = append(resp.FailedFriendUserIDList, v)
 					log.NewError(req.OperationID, "InsertToFriend failed", req.FromUserID, v, err1.Error())
@@ -182,7 +185,8 @@ func (s *friendServer) ImportFriend(ctx context.Context, req *pbFriend.ImportFri
 					c.ErrCode = 408
 					continue
 				}
-				err2 := imdb.InsertToFriend(v, req.FromUserID, 1)
+				toInsertFollow = imdb.Friend{OwnerUserID: v, FriendUserID: req.FromUserID}
+				err2 := imdb.InsertToFriend(&toInsertFollow)
 				if err2 != nil {
 					resp.FailedFriendUserIDList = append(resp.FailedFriendUserIDList, v)
 					log.NewError(req.OperationID, "InsertToFriend failed", v, req.FromUserID, err2.Error())
@@ -193,7 +197,6 @@ func (s *friendServer) ImportFriend(ctx context.Context, req *pbFriend.ImportFri
 				for _, v := range req.FriendUserIDList {
 					chat.FriendAddedNotification(req.OperationID, req.OpUserID, req.FromUserID, v)
 				}
-
 			}
 		}
 	}
@@ -213,18 +216,21 @@ func (s *friendServer) AddFriendResponse(ctx context.Context, req *pbFriend.AddF
 
 	//Check there application before agreeing or refuse to a friend's application
 	//req.CommID.FromUserID process req.CommID.ToUserID
-	if _, err := imdb.FindFriendApplyFromFriendReqByUid(req.CommID.ToUserID, req.CommID.FromUserID); err != nil {
+	friendRequest, err := imdb.GetFriendApplicationByBothUserID(req.CommID.ToUserID, req.CommID.FromUserID)
-		log.NewError(req.CommID.OperationID, "FindFriendApplyFromFriendReqByUid failed ", err.Error(), req.CommID.ToUserID, req.CommID.FromUserID)
+	if err != nil {
+		log.NewError(req.CommID.OperationID, "GetFriendApplicationByBothUserID failed ", err.Error(), req.CommID.ToUserID, req.CommID.FromUserID)
 		return &pbFriend.AddFriendResponseResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
 	}
 
+	friendRequest.HandleResult = req.Flag
 	//Change friend request status flag
-	err := imdb.UpdateFriendRelationshipToFriendReq(req.CommID.ToUserID, req.CommID.FromUserID, req.Flag)
+	err = imdb.UpdateFriendApplication(friendRequest)
 	if err != nil {
-		log.NewError(req.CommID.OperationID, "UpdateFriendRelationshipToFriendReq failed ", err.Error(), req.CommID.ToUserID, req.CommID.FromUserID, req.Flag)
+		log.NewError(req.CommID.OperationID, "UpdateFriendApplication failed ", err.Error(), friendRequest)
 		return &pbFriend.AddFriendResponseResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
 	}
 	log.NewInfo(req.CommID.OperationID, "rpc AddFriendResponse ok")
+
 	//Change the status of the friend request form
 	if req.Flag == constant.FriendFlag {
 		//Establish friendship after find friend relationship not exists
@@ -284,7 +290,7 @@ func (s *friendServer) GetBlacklist(ctx context.Context, req *pbFriend.GetBlackl
 		return &pbFriend.GetBlacklistResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, nil
 	}
 
-	blackListInfo, err := imdb.GetBlackListByUID(req.CommID.FromUserID)
+	blackListInfo, err := imdb.GetBlackListByUserID(req.CommID.FromUserID)
 	if err != nil {
 		log.NewError(req.CommID.OperationID, "GetBlackListByUID failed ", err.Error(), req.CommID.FromUserID)
 		return &pbFriend.GetBlacklistResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}, nil
@@ -296,7 +302,7 @@ func (s *friendServer) GetBlacklist(ctx context.Context, req *pbFriend.GetBlackl
 	for _, blackUser := range blackListInfo {
 		var blackUserInfo sdkws.PublicUserInfo
 		//Find black user information
-		us, err := imdb.FindUserByUID(blackUser.BlockUserID)
+		us, err := imdb.GetUserByUserID(blackUser.BlockUserID)
 		if err != nil {
 			log.NewError(req.CommID.OperationID, "FindUserByUID failed ", err.Error(), blackUser.BlockUserID)
 			continue
@@ -322,7 +328,7 @@ func (s *friendServer) SetFriendComment(ctx context.Context, req *pbFriend.SetFr
 		return &pbFriend.SetFriendCommentResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
 	}
 	log.NewInfo(req.CommID.OperationID, "rpc SetFriendComment ok")
-	chat.FriendInfoChangedNotification(req)
+	chat.FriendInfoChangedNotification(req.CommID.OperationID, req.CommID.OpUserID, req.CommID.FromUserID, req.CommID.ToUserID)
 	return &pbFriend.SetFriendCommentResp{CommonResp: &pbFriend.CommonResp{}}, nil
 }
 
@@ -352,7 +358,7 @@ func (s *friendServer) IsInBlackList(ctx context.Context, req *pbFriend.IsInBlac
 	}
 
 	var isInBlacklist = false
-	err := imdb.FindRelationshipFromBlackList(req.CommID.FromUserID, req.CommID.ToUserID)
+	err := imdb.CheckBlack(req.CommID.FromUserID, req.CommID.ToUserID)
 	if err == nil {
 		isInBlacklist = true
 	}
@@ -367,7 +373,7 @@ func (s *friendServer) IsFriend(ctx context.Context, req *pbFriend.IsFriendReq)
 		log.NewError(req.CommID.OperationID, "CheckAccess false ", req.CommID.OpUserID, req.CommID.FromUserID)
 		return &pbFriend.IsFriendResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, nil
 	}
-	_, err := imdb.FindFriendRelationshipFromFriend(req.CommID.FromUserID, req.CommID.ToUserID)
+	_, err := imdb.GetFriendRelationshipFromFriend(req.CommID.FromUserID, req.CommID.ToUserID)
 	if err == nil {
 		isFriend = true
 	} else {
@@ -386,7 +392,7 @@ func (s *friendServer) GetFriendList(ctx context.Context, req *pbFriend.GetFrien
 		return &pbFriend.GetFriendListResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, nil
 	}
 
-	friends, err := imdb.FindUserInfoFromFriend(req.CommID.FromUserID)
+	friends, err := imdb.GetUserInfoFromFriend(req.CommID.FromUserID)
 	if err != nil {
 		log.NewError(req.CommID.OperationID, "FindUserInfoFromFriend failed", err.Error(), req.CommID.FromUserID)
 		return &pbFriend.GetFriendListResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}, nil
@@ -394,14 +400,14 @@ func (s *friendServer) GetFriendList(ctx context.Context, req *pbFriend.GetFrien
 	for _, friendUser := range friends {
 		var friendUserInfo sdkws.FriendInfo
 		//find user is in blackList
-		err = imdb.FindRelationshipFromBlackList(req.CommID.FromUserID, friendUser.FriendUserID)
+		//	err = imdb.GetRelationshipFromBlackList(req.CommID.FromUserID, friendUser.FriendUserID)
 		//if err == nil {
 		//	friendUserInfo.IsBlack = constant.BlackListFlag
 		//} else {
 		//	friendUserInfo.IsBlack = 0
 		//}
 		//Find user information
-		us, err := imdb.FindUserByUID(friendUser.FriendUserID)
+		us, err := imdb.GetUserByUserID(friendUser.FriendUserID)
 		if err != nil {
 			log.NewError(req.CommID.OperationID, "FindUserByUID failed", err.Error(), friendUser.FriendUserID)
 			continue
@@ -426,7 +432,7 @@ func (s *friendServer) GetFriendApplyList(ctx context.Context, req *pbFriend.Get
 	}
 
 	//	Find the  current user friend applications received
-	ApplyUsersInfo, err := imdb.FindFriendsApplyFromFriendReq(req.CommID.FromUserID)
+	ApplyUsersInfo, err := imdb.GetReceivedFriendsApplicationListByUserID(req.CommID.FromUserID)
 	if err != nil {
 		log.NewError(req.CommID.OperationID, "FindFriendsApplyFromFriendReq ", err.Error(), req.CommID.FromUserID)
 		return &pbFriend.GetFriendApplyListResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}, nil
@@ -453,7 +459,7 @@ func (s *friendServer) GetSelfApplyList(ctx context.Context, req *pbFriend.GetSe
 	}
 
 	//	Find the self add other userinfo
-	usersInfo, err := imdb.FindSelfApplyFromFriendReq(req.CommID.FromUserID)
+	usersInfo, err := imdb.GetSendFriendApplicationListByUserID(req.CommID.FromUserID)
 	if err != nil {
 		log.NewError(req.CommID.OperationID, "FindSelfApplyFromFriendReq failed ", err.Error(), req.CommID.FromUserID)
 		return &pbFriend.GetSelfApplyListResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}, nil

internal/rpc/group/group.go

@@ -39,17 +39,16 @@ func NewGroupServer(port int) *groupServer {
 }
 
 func (s *groupServer) Run() {
-	log.Info("", "", "rpc group init....")
+	log.NewInfo("0", "group rpc start ")
-
 	ip := utils.ServerIP
 	registerAddress := ip + ":" + strconv.Itoa(s.rpcPort)
 	//listener network
 	listener, err := net.Listen("tcp", registerAddress)
 	if err != nil {
-		log.InfoByArgs("listen network failed,err=%s", err.Error())
+		log.NewError("0", "Listen failed ", err.Error(), registerAddress)
 		return
 	}
-	log.Info("", "", "listen network success, address = %s", registerAddress)
+	log.NewInfo("0", "listen network success, ", registerAddress, listener)
 	defer listener.Close()
 	//grpc server
 	srv := grpc.NewServer()
@@ -58,15 +57,15 @@ func (s *groupServer) Run() {
 	pbGroup.RegisterGroupServer(srv, s)
 	err = getcdv3.RegisterEtcd(s.etcdSchema, strings.Join(s.etcdAddr, ","), ip, s.rpcPort, s.rpcRegisterName, 10)
 	if err != nil {
-		log.ErrorByArgs("get etcd failed,err=%s", err.Error())
+		log.NewError("0", "RegisterEtcd failed ", err.Error())
 		return
 	}
 	err = srv.Serve(listener)
 	if err != nil {
-		log.ErrorByArgs("listen rpc_group error,err=%s", err.Error())
+		log.NewError("0", "Serve failed ", err.Error())
 		return
 	}
-	log.Info("", "", "rpc create group init success")
+	log.NewInfo("0", "group rpc success")
 }
 
 func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupReq) (*pbGroup.CreateGroupResp, error) {
@@ -79,20 +78,24 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
 	//Time stamp + MD5 to generate group chat id
 	groupId := utils.Md5(strconv.FormatInt(time.Now().UnixNano(), 10))
 	//to group
-	err := im_mysql_model.InsertIntoGroup(groupId, req.GroupInfo.GroupName, req.GroupInfo.Introduction, req.GroupInfo.Notification, req.GroupInfo.FaceUrl, req.GroupInfo.Ex, req.GroupInfo.GroupType)
+	groupInfo := imdb.Group{}
+	utils.CopyStructFields(&groupInfo, req.GroupInfo)
+	err := im_mysql_model.InsertIntoGroup(groupInfo)
 	if err != nil {
 		log.NewError(req.OperationID, "InsertIntoGroup failed, ", err.Error(), groupId, req.GroupInfo.GroupName, req.GroupInfo.Introduction, req.GroupInfo.Notification, req.GroupInfo.FaceUrl, req.GroupInfo.Ex, req.GroupInfo.GroupType)
 		return &pbGroup.CreateGroupResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}, nil
 	}
 
-	us, err := im_mysql_model.FindUserByUID(req.OwnerUserID)
+	us, err := imdb.GetUserByUserID(req.OwnerUserID)
 	if err != nil {
 		log.NewError(req.OperationID, "FindUserByUID failed ", err.Error(), req.OwnerUserID)
 		return &pbGroup.CreateGroupResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}, nil
 	}
 
 	//to group member
-	err = im_mysql_model.InsertIntoGroupMember(groupId, us.UserID, us.Nickname, us.FaceUrl, constant.GroupOwner)
+	groupMember := imdb.GroupMember{GroupID: groupId, RoleLevel: 1}
+	utils.CopyStructFields(&groupMember, us)
+	err = im_mysql_model.InsertIntoGroupMember(groupMember)
 	if err != nil {
 		log.NewError(req.OperationID, "InsertIntoGroupMember failed ", err.Error())
 		return &pbGroup.CreateGroupResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}, nil
@@ -106,7 +109,7 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
 
 	//to group member
 	for _, user := range req.InitMemberList {
-		us, err := im_mysql_model.FindUserByUID(user.UserID)
+		us, err := im_mysql_model.GetUserByUserID(user.UserID)
 		if err != nil {
 			log.NewError(req.OperationID, "FindUserByUID failed ", err.Error(), user.UserID)
 			continue
@@ -115,9 +118,10 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
 			log.NewError(req.OperationID, "only one owner, failed ", user)
 			continue
 		}
-		err = im_mysql_model.InsertIntoGroupMember(groupId, user.UserID, us.Nickname, us.FaceUrl, user.RoleLevel)
+		utils.CopyStructFields(&groupMember, us)
+		err = im_mysql_model.InsertIntoGroupMember(groupMember)
 		if err != nil {
-			log.NewError(req.OperationID, "InsertIntoGroupMember failed ", groupId, user.UserID, us.Nickname, us.FaceUrl, user.RoleLevel)
+			log.NewError(req.OperationID, "InsertIntoGroupMember failed ", err.Error(), groupMember)
 		}
 		okUserIDList = append(okUserIDList, user.UserID)
 		err = db.DB.AddGroupMember(groupId, user.UserID)
@@ -127,9 +131,9 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
 	}
 
 	resp := &pbGroup.CreateGroupResp{}
-	group, err := im_mysql_model.FindGroupInfoByGroupId(groupId)
+	group, err := im_mysql_model.GetGroupInfoByGroupID(groupId)
 	if err != nil {
-		log.NewError(req.OperationID, "FindGroupInfoByGroupId failed ", err.Error(), groupId)
+		log.NewError(req.OperationID, "GetGroupInfoByGroupID failed ", err.Error(), groupId)
 		resp.ErrCode = constant.ErrDB.ErrCode
 		resp.ErrMsg = constant.ErrDB.ErrMsg
 		return resp, nil
@@ -146,20 +150,19 @@ func (s *groupServer) GetJoinedGroupList(ctx context.Context, req *pbGroup.GetJo
 		log.NewError(req.OperationID, "CheckAccess false ", req.OpUserID, req.FromUserID)
 		return &pbGroup.GetJoinedGroupListResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, nil
 	}
-
 	//group list
-	joinedGroupList, err := imdb.GetJoinedGroupIdListByMemberId(req.FromUserID)
+	joinedGroupList, err := imdb.GetJoinedGroupIDListByUserID(req.FromUserID)
 	if err != nil {
-		log.NewError(req.OperationID, "GetJoinedGroupIdListByMemberId failed ", err.Error(), req.FromUserID)
+		log.NewError(req.OperationID, "GetJoinedGroupIDListByUserID failed ", err.Error(), req.FromUserID)
 		return &pbGroup.GetJoinedGroupListResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}, nil
 	}
 
 	var resp pbGroup.GetJoinedGroupListResp
 	for _, v := range joinedGroupList {
 		var groupNode open_im_sdk.GroupInfo
-		num := imdb.GetGroupMemberNumByGroupId(v.GroupID)
+		num := imdb.GetGroupMemberNumByGroupID(v)
-		owner, err2 := imdb.GetGroupOwnerInfoByGroupId(v.GroupID)
+		owner, err2 := imdb.GetGroupOwnerInfoByGroupID(v)
-		group, err := imdb.FindGroupInfoByGroupId(v.GroupID)
+		group, err := imdb.GetGroupInfoByGroupID(v)
 		if num > 0 && owner != nil && err2 == nil && group != nil && err == nil {
 			utils.CopyStructFields(&groupNode, group)
 			groupNode.CreateTime = group.CreateTime
@@ -184,7 +187,7 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
 		return &pbGroup.InviteUserToGroupResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, nil
 	}
 
-	groupInfoFromMysql, err := imdb.FindGroupInfoByGroupId(req.GroupID)
+	groupInfoFromMysql, err := imdb.GetGroupInfoByGroupID(req.GroupID)
 	if err != nil || groupInfoFromMysql == nil {
 		log.NewError(req.OperationID, "FindGroupInfoByGroupId failed ", req.GroupID, err)
 		return &pbGroup.InviteUserToGroupResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, nil
@@ -198,7 +201,8 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
 		var resultNode pbGroup.Id2Result
 		resultNode.UserID = v
 		resultNode.Result = 0
-		toUserInfo, err := imdb.FindUserByUID(v)
+		toUserInfo, err := imdb.GetUserByUserID(v)
+
 		if err != nil {
 			log.NewError(req.OperationID, "FindUserByUID failed ", err.Error(), v)
 			resultNode.Result = -1
@@ -212,10 +216,13 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
 			resp.Id2ResultList = append(resp.Id2ResultList, &resultNode)
 			continue
 		}
-
+		var toInsertInfo imdb.GroupMember
-		err = imdb.InsertGroupMember(req.GroupID, toUserInfo.UserID, toUserInfo.Nickname, toUserInfo.FaceUrl, 0)
+		utils.CopyStructFields(&toInsertInfo, toUserInfo)
+		toInsertInfo.GroupID = req.GroupID
+		toInsertInfo.RoleLevel = 0
+		err = imdb.InsertIntoGroupMember(toInsertInfo)
 		if err != nil {
-			log.NewError(req.OperationID, "InsertGroupMember failed ", req.GroupID, toUserInfo.UserID, toUserInfo.Nickname, toUserInfo.FaceUrl)
+			log.NewError(req.OperationID, "InsertIntoGroupMember failed ", req.GroupID, toUserInfo.UserID, toUserInfo.Nickname, toUserInfo.FaceUrl)
 			resultNode.Result = -1
 			resp.Id2ResultList = append(resp.Id2ResultList, &resultNode)
 			continue
@@ -238,7 +245,7 @@ func (s *groupServer) GetGroupAllMember(ctx context.Context, req *pbGroup.GetGro
 	log.NewInfo(req.OperationID, "GetGroupAllMember, args ", req.String())
 	var resp pbGroup.GetGroupAllMemberResp
 	resp.ErrCode = 0
-	memberList, err := imdb.FindGroupMemberListByGroupId(req.GroupID)
+	memberList, err := imdb.GetGroupMemberListByGroupID(req.GroupID)
 	if err != nil {
 		resp.ErrCode = constant.ErrDB.ErrCode
 		resp.ErrMsg = constant.ErrDB.ErrMsg
@@ -270,7 +277,7 @@ func (s *groupServer) GetGroupMemberList(ctx context.Context, req *pbGroup.GetGr
 
 	var resp pbGroup.GetGroupMemberListResp
 	resp.ErrCode = 0
-	memberList, err := imdb.GetGroupMemberByGroupId(req.GroupID, req.Filter, req.NextSeq, 30)
+	memberList, err := imdb.GetGroupMemberByGroupID(req.GroupID, req.Filter, req.NextSeq, 30)
 	if err != nil {
 		resp.ErrCode = constant.ErrDB.ErrCode
 		resp.ErrMsg = err.Error()
@@ -297,7 +304,7 @@ func (s *groupServer) GetGroupMemberList(ctx context.Context, req *pbGroup.GetGr
 
 func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGroupMemberReq) (*pbGroup.KickGroupMemberResp, error) {
 	log.NewInfo(req.OperationID, "KickGroupMember args ", req.String())
-	ownerList, err := imdb.GetOwnerManagerByGroupId(req.GroupID)
+	ownerList, err := imdb.GetOwnerManagerByGroupID(req.GroupID)
 	if err != nil {
 		log.NewError(req.OperationID, "GetOwnerManagerByGroupId failed ", err.Error(), req.GroupID)
 		return &pbGroup.KickGroupMemberResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, nil
@@ -332,7 +339,7 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou
 
 	groupOwnerUserID := ""
 	for _, v := range ownerList {
-		if v.AdministratorLevel == 1 {
+		if v.RoleLevel == 1 {
 			groupOwnerUserID = v.UserID
 		}
 	}
@@ -374,7 +381,7 @@ func (s *groupServer) GetGroupMembersInfo(ctx context.Context, req *pbGroup.GetG
 
 	for _, v := range req.MemberList {
 		var memberNode open_im_sdk.GroupMemberFullInfo
-		memberInfo, err := imdb.GetMemberInfoById(req.GroupID, v)
+		memberInfo, err := imdb.GetMemberInfoByID(req.GroupID, v)
 		memberNode.UserID = v
 		if err != nil {
 			log.NewError(req.OperationID, "GetMemberInfoById failed ", err.Error(), req.GroupID, v)
@@ -397,15 +404,21 @@ func (s *groupServer) GetGroupApplicationList(_ context.Context, req *pbGroup.Ge
 		log.NewError(req.OperationID, "GetGroupApplicationList failed ", err.Error(), req.OpUserID)
 		return &pbGroup.GetGroupApplicationListResp{ErrCode: 701, ErrMsg: "GetGroupApplicationList failed"}, nil
 	}
-	log.NewInfo(req.OperationID, "GetGroupMembersInfo rpc return ", reply)
+
-	return reply, nil
+	resp := pbGroup.GetGroupApplicationListResp{}
+	for _, v := range reply {
+		var node open_im_sdk.GroupRequest
+		utils.CopyStructFields(&node, v)
+	}
+	log.NewInfo(req.OperationID, "GetGroupMembersInfo rpc return ", resp)
+	return &resp, nil
 }
 
 func (s *groupServer) GetGroupsInfo(ctx context.Context, req *pbGroup.GetGroupsInfoReq) (*pbGroup.GetGroupsInfoResp, error) {
 	log.NewInfo(req.OperationID, "GetGroupsInfo args ", req.String())
 	groupsInfoList := make([]*open_im_sdk.GroupInfo, 0)
 	for _, groupID := range req.GroupIDList {
-		groupInfoFromMysql, err := im_mysql_model.FindGroupInfoByGroupId(groupID)
+		groupInfoFromMysql, err := im_mysql_model.GetGroupInfoByGroupID(groupID)
 		if err != nil {
 			log.NewError(req.OperationID, "FindGroupInfoByGroupId failed ", err.Error(), groupID)
 			continue
@@ -439,17 +452,6 @@ func (s *groupServer) GroupApplicationResponse(_ context.Context, req *pbGroup.G
 	chat.ApplicationProcessedNotification(req)
 	if req.HandleResult == 1 {
 		chat.MemberEnterNotification(req)
-		//if req.ToUserID == "0" {
-		//	err = db.DB.AddGroupMember(req.GroupID, req.FromUserID)
-		//	if err != nil {
-		//		log.NewError(req.OperationID, "AddGroupMember failed ", err.Error(), req.GroupID, req.FromUserID)
-		//	}
-		//} else {
-		//	err = db.DB.AddGroupMember(req.GroupID, req.ToUserID)
-		//	if err != nil {
-		//		log.NewError(req.OperationID, "AddGroupMember failed ", err.Error(), req.GroupID, req.ToUserID)
-		//	}
-		//}
 	}
 
 	log.NewInfo(req.OperationID, "rpc GroupApplicationResponse return ")
@@ -458,26 +460,23 @@ func (s *groupServer) GroupApplicationResponse(_ context.Context, req *pbGroup.G
 
 func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq) (*pbGroup.JoinGroupResp, error) {
 	log.NewInfo(req.OperationID, "JoinGroup args ", req.String())
-
+	applicationUserInfo, err := imdb.GetUserByUserID(req.OpUserID)
-	applicationUserInfo, err := im_mysql_model.FindUserByUID(req.OpUserID)
 	if err != nil {
 		log.NewError(req.OperationID, "FindUserByUID failed ", err.Error(), req.OpUserID)
 		return &pbGroup.JoinGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
 	}
 
-	_, err = im_mysql_model.FindGroupRequestUserInfoByGroupIDAndUid(req.GroupID, req.OpUserID)
+	var groupRequest imdb.GroupRequest
-	if err == nil {
+	utils.CopyStructFields(&groupRequest, req)
-		err = im_mysql_model.DelGroupRequest(req.GroupID, req.OpUserID, "0")
+	err = imdb.UpdateGroupRequest(groupRequest)
-	}
+	if err != nil {
-
+		log.NewError(req.OperationID, "UpdateGroupRequest ", err.Error(), groupRequest)
-	if err = im_mysql_model.InsertIntoGroupRequest(req.GroupID, req.OpUserID, "0", req.ReqMessage, applicationUserInfo.Nickname, applicationUserInfo.FaceUrl); err != nil {
-		log.NewError(req.OperationID, "InsertIntoGroupRequest ", err.Error(), req.GroupID, req.OpUserID, "0", req.ReqMessage, applicationUserInfo.Nickname, applicationUserInfo.FaceUrl)
 		return &pbGroup.JoinGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
 	}
 
-	memberList, err := im_mysql_model.FindGroupMemberListByGroupIdAndFilterInfo(req.GroupID, constant.GroupOwner)
+	_, err = imdb.GetGroupMemberListByGroupIDAndRoleLevel(req.GroupID, constant.GroupOwner)
-	if len(memberList) == 0 {
+	if err != nil {
-		log.NewError(req.OperationID, "FindGroupMemberListByGroupIdAndFilterInfo failed ", req.GroupID, constant.GroupOwner, err)
+		log.NewError(req.OperationID, "GetGroupMemberListByGroupIDAndRoleLevel failed ", err.Error(), req.GroupID, constant.GroupOwner)
 		return &pbGroup.JoinGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""}}, nil
 	}
 
@@ -490,13 +489,13 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq)
 func (s *groupServer) QuitGroup(ctx context.Context, req *pbGroup.QuitGroupReq) (*pbGroup.QuitGroupResp, error) {
 	log.NewError("QuitGroup args ", req.String())
 
-	_, err := im_mysql_model.FindGroupMemberInfoByGroupIdAndUserId(req.GroupID, req.OpUserID)
+	_, err := imdb.GetGroupMemberInfoByGroupIDAndUserID(req.GroupID, req.OpUserID)
 	if err != nil {
 		log.NewError(req.OperationID, "FindGroupMemberInfoByGroupIdAndUserId failed", err.Error(), req.GroupID, req.OpUserID)
 		return &pbGroup.QuitGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
 	}
 
-	err = im_mysql_model.DeleteGroupMemberByGroupIdAndUserId(req.GroupID, req.OpUserID)
+	err = imdb.DeleteGroupMemberByGroupIDAndUserID(req.GroupID, req.OpUserID)
 	if err != nil {
 		log.NewError(req.OperationID, "DeleteGroupMemberByGroupIdAndUserId failed ", err.Error(), req.GroupID, req.OpUserID)
 		return &pbGroup.QuitGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
@@ -517,13 +516,13 @@ func hasAccess(req *pbGroup.SetGroupInfoReq) bool {
 	if utils.IsContain(req.OpUserID, config.Config.Manager.AppManagerUid) {
 		return true
 	}
-	groupUserInfo, err := im_mysql_model.FindGroupMemberInfoByGroupIdAndUserId(req.GroupInfo.GroupID, req.OpUserID)
+	groupUserInfo, err := im_mysql_model.GetGroupMemberInfoByGroupIDAndUserID(req.GroupInfo.GroupID, req.OpUserID)
 	if err != nil {
 		log.NewError(req.OperationID, "FindGroupMemberInfoByGroupIdAndUserId failed, ", err.Error(), req.GroupInfo.GroupID, req.OpUserID)
 		return false
 
 	}
-	if groupUserInfo.AdministratorLevel == constant.OrdinaryMember {
+	if groupUserInfo.RoleLevel == constant.OrdinaryMember {
 		return true
 	}
 }
@@ -535,9 +534,9 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf
 		return &pbGroup.SetGroupInfoResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, nil
 	}
 
-	group, err := im_mysql_model.FindGroupInfoByGroupId(req.GroupInfo.GroupID)
+	group, err := im_mysql_model.GetGroupInfoByGroupID(req.GroupInfo.GroupID)
 	if err != nil {
-		log.NewError(req.OperationID, "FindGroupInfoByGroupId failed, ", err.Error(), req.GroupInfo.GroupID)
+		log.NewError(req.OperationID, "FindGroupInfoByGroupId failed ", err.Error(), req.GroupInfo.GroupID)
 		return &pbGroup.SetGroupInfoResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, nil
 	}
 
@@ -556,15 +555,18 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf
 		changedType = changedType | (1 << 3)
 	}
 	//only administrators can set group information
-	if err = im_mysql_model.SetGroupInfo(req.GroupInfo.GroupID, req.GroupInfo.GroupName, req.GroupInfo.Introduction, req.GroupInfo.Notification, req.GroupInfo.FaceUrl, ""); err != nil {
+	var groupInfo imdb.Group
-		return &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}, nil
+	utils.CopyStructFields(&groupInfo, req.GroupInfo)
+	err = imdb.SetGroupInfo(groupInfo)
+	if err != nil {
+		return &pbGroup.SetGroupInfoResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, nil
 	}
 
 	if changedType != 0 {
 		chat.GroupInfoChangedNotification(req.OperationID, req.OpUserID, req.GroupInfo.GroupID, changedType)
 	}
-	log.NewInfo("SetGroupInfo rpc return ")
+	log.NewInfo("SetGroupInfo rpc return ", pbGroup.SetGroupInfoResp{CommonResp: &pbGroup.CommonResp{}})
-	return &pbGroup.CommonResp{}, nil
+	return &pbGroup.SetGroupInfoResp{CommonResp: &pbGroup.CommonResp{}}, nil
 }
 
 func (s *groupServer) TransferGroupOwner(_ context.Context, req *pbGroup.TransferGroupOwnerReq) (*pbGroup.TransferGroupOwnerResp, error) {

pkg/base_info/public_struct.go

@@ -16,7 +16,6 @@ type UserInfo struct {
 	Ex          string `json:"ex" binding:"omitempty,max=1024"`
 }
 
-//c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
 func SetErrCodeMsg(c *gin.Context, status int) *CommResp {
 	resp := CommResp{ErrCode: int32(status), ErrMsg: http.StatusText(status)}
 	c.JSON(status, resp)

pkg/base_info/user_api_struct.go

@@ -22,7 +22,6 @@ type GetUserInfoReq struct {
 	OperationID string   `json:"operationID" binding:"required"`
 	UserIDList  []string `json:"userIDList" binding:"required"`
 }
-
 type GetUserInfoResp struct {
 	CommResp
 	UserInfoList []*open_im_sdk.UserInfo `json:"data"`

pkg/common/db/mysql_model/im_mysql_model/friend_model.go

@@ -20,7 +20,7 @@ func InsertToFriend(toInsertFollow *Friend) error {
 	return nil
 }
 
-func FindFriendRelationshipFromFriend(OwnerUserID, FriendUserID string) (*Friend, error) {
+func GetFriendRelationshipFromFriend(OwnerUserID, FriendUserID string) (*Friend, error) {
 	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
 	if err != nil {
 		return nil, err
@@ -33,7 +33,7 @@ func FindFriendRelationshipFromFriend(OwnerUserID, FriendUserID string) (*Friend
 	return &friend, err
 }
 
-func FindUserInfoFromFriend(OwnerUserID string) ([]Friend, error) {
+func GetUserInfoFromFriend(OwnerUserID string) ([]Friend, error) {
 	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
 	if err != nil {
 		return nil, err

pkg/common/db/mysql_model/im_mysql_model/friend_request_model.go

@@ -45,7 +45,7 @@ func GetSendFriendApplicationListByUserID(FromUserID string) ([]FriendRequest, e
 }
 
 //reqId apply to add userId already
-func FindFriendApplicationByBothUserID(FromUserId, ToUserID string) (*FriendRequest, error) {
+func GetFriendApplicationByBothUserID(FromUserId, ToUserID string) (*FriendRequest, error) {
 	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
 	if err != nil {
 		return nil, err
@@ -58,7 +58,7 @@ func FindFriendApplicationByBothUserID(FromUserId, ToUserID string) (*FriendRequ
 	return &friendRequest, nil
 }
 
-func UpdateFriendApplication(friendRequest FriendRequest) error {
+func UpdateFriendApplication(friendRequest *FriendRequest) error {
 	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
 	if err != nil {
 		return err

pkg/common/db/mysql_model/im_mysql_model/group_member_model.go

@@ -21,6 +21,7 @@ func InsertIntoGroupMember(toInsertInfo GroupMember) error {
 	if err != nil {
 		return err
 	}
+	toInsertInfo.JoinSource = time.Now()
 	err = dbConn.Table("group_member").Create(toInsertInfo).Error
 	if err != nil {
 		return err
@@ -54,13 +55,13 @@ func GetGroupMemberListByGroupID(groupID string) ([]GroupMember, error) {
 	return groupMemberList, nil
 }
 
-func GetGroupMemberListByGroupIDAndFilter(groupID string, filter int32) ([]GroupMember, error) {
+func GetGroupMemberListByGroupIDAndRoleLevel(groupID string, roleLevel int32) ([]GroupMember, error) {
 	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
 	if err != nil {
 		return nil, err
 	}
 	var groupMemberList []GroupMember
-	err = dbConn.Table("group_member").Where("group_id=? and role_level=?", groupID, filter).Find(&groupMemberList).Error
+	err = dbConn.Table("group_member").Where("group_id=? and role_level=?", groupID, role_level).Find(&groupMemberList).Error
 	if err != nil {
 		return nil, err
 	}

pkg/common/db/mysql_model/im_mysql_model/group_model.go

@@ -2,7 +2,6 @@ package im_mysql_model
 
 import (
 	"Open_IM/pkg/common/db"
-	"Open_IM/pkg/common/log"
 	"Open_IM/pkg/proto/group"
 	"errors"
 	"time"