notification

internal/rpc/auth/user_register.go

@@ -10,9 +10,6 @@ import (
 func (rpc *rpcAuth) UserRegister(_ context.Context, pb *pbAuth.UserRegisterReq) (*pbAuth.UserRegisterResp, error) {
 	log.Info("", "", "rpc user_register start, [data: %s]", pb.String())
 
-	//if len(pb.UID) == 0 {
-	//	pb.UID = utils.GenID()
-	//}
 	if err := im_mysql_model.UserRegister(pb); err != nil {
 		log.Error("", "", "rpc user_register error, [data: %s] [err: %s]", pb.String(), err.Error())
 		return &pbAuth.UserRegisterResp{Success: false}, err

internal/rpc/chat/send_msg.go

@@ -6,7 +6,7 @@ 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"
+	immysql "Open_IM/pkg/common/db/mysql_model/im_mysql_model"
 	http2 "Open_IM/pkg/common/http"
 	"Open_IM/pkg/common/log"
 	"Open_IM/pkg/grpc-etcdv3/getcdv3"
@@ -189,49 +189,7 @@ func (rpc *rpcChat) UserSendMsg(_ context.Context, pb *pbChat.UserSendMsgReq) (*
 		return returnMsg(&replay, pb, 0, "", serverMsgID, pbData.SendTime)
 	default:
 		return returnMsg(&replay, pb, 203, "unkonwn sessionType", "", 0)
-
 	}
-
-}
-
-type WSToMsgSvrChatMsg struct {
-	SendID      string `protobuf:"bytes,1,opt,name=SendID" json:"SendID,omitempty"`
-	RecvID      string `protobuf:"bytes,2,opt,name=RecvID" json:"RecvID,omitempty"`
-	Content     string `protobuf:"bytes,3,opt,name=Content" json:"Content,omitempty"`
-	MsgFrom     int32  `protobuf:"varint,5,opt,name=MsgFrom" json:"MsgFrom,omitempty"`
-	ContentType int32  `protobuf:"varint,8,opt,name=ContentType" json:"ContentType,omitempty"`
-	SessionType int32  `protobuf:"varint,9,opt,name=SessionType" json:"SessionType,omitempty"`
-	OperationID string `protobuf:"bytes,10,opt,name=OperationID" json:"OperationID,omitempty"`
-}
-
-func CreateGroupNotification(sendID string, creator im_mysql_model.User, group im_mysql_model.Group, memberList []im_mysql_model.GroupMember) {
-	var msg WSToMsgSvrChatMsg
-	msg.OperationID = utils.OperationIDGenerator()
-	msg.SendID = sendID
-	msg.RecvID = group.GroupId
-	msg.ContentType = constant.CreateGroupTip
-	msg.SessionType = constant.GroupChatType
-	msg.MsgFrom = constant.SysMsgType
-
-	var groupCreated open_im_sdk.GroupCreatedTips
-	groupCreated.Group = &open_im_sdk.GroupInfo{}
-	utils.CopyStructFields(groupCreated.Group, group)
-	groupCreated.Creator = &open_im_sdk.GroupMemberFullInfo{}
-	utils.CopyStructFields(groupCreated.Creator, creator)
-	for _, v := range memberList {
-		var groupMemberInfo open_im_sdk.GroupMemberFullInfo
-		utils.CopyStructFields(&groupMemberInfo, v)
-		groupCreated.MemberList = append(groupCreated.MemberList, &groupMemberInfo)
-	}
-	var tips open_im_sdk.TipsComm
-	tips.Detail = utils.StructToJsonString(groupCreated)
-	tips.DefaultTips = creator.Name + " " + config.Config.DefaultTips.GroupCreatedTips
-	msg.Content = utils.StructToJsonString(tips)
-	Notification(&msg, false)
-}
-
-func Notification(m *WSToMsgSvrChatMsg, onlineUserOnly bool) {
-
 }
 
 func (rpc *rpcChat) sendMsgToKafka(m *pbChat.WSToMsgSvrChatMsg, key string) error {
@@ -245,6 +203,7 @@ func GetMsgID(sendID string) string {
 	t := time.Now().Format("2006-01-02 15:04:05")
 	return t + "-" + sendID + "-" + strconv.Itoa(rand.Int())
 }
+
 func returnMsg(replay *pbChat.UserSendMsgResp, pb *pbChat.UserSendMsgReq, errCode int32, errMsg, serverMsgID string, sendTime int64) (*pbChat.UserSendMsgResp, error) {
 	replay.ErrCode = errCode
 	replay.ErrMsg = errMsg
@@ -254,6 +213,7 @@ func returnMsg(replay *pbChat.UserSendMsgResp, pb *pbChat.UserSendMsgReq, errCod
 	replay.SendTime = sendTime
 	return replay, nil
 }
+
 func modifyMessageByUserMessageReceiveOpt(userID, sourceID string, sessionType int, msg *pbChat.WSToMsgSvrChatMsg) bool {
 	conversationID := utils.GetConversationIDBySessionType(sourceID, sessionType)
 	opt, err := db.DB.GetSingleConversationMsgOpt(userID, conversationID)
@@ -278,3 +238,240 @@ func modifyMessageByUserMessageReceiveOpt(userID, sourceID string, sessionType i
 
 	return true
 }
+
+type NotificationMsg struct {
+	SendID      string
+	RecvID      string
+	Content     []byte
+	MsgFrom     int32
+	ContentType int32
+	SessionType int32
+	OperationID string
+}
+
+func Notification(n *NotificationMsg, onlineUserOnly bool) {
+
+}
+
+//message GroupCreatedTips{
+//  GroupInfo Group = 1;
+//  GroupMemberFullInfo Creator = 2;
+//  repeated GroupMemberFullInfo MemberList = 3;
+//  uint64 OperationTime = 4;
+//}
+func GroupCreatedNotification(operationID string, creator *immysql.User, group *immysql.Group, memberList []immysql.GroupMember) {
+	var n NotificationMsg
+	n.SendID = creator.UserID
+	n.RecvID = group.GroupID
+	n.ContentType = constant.CreateGroupTip
+	n.SessionType = constant.GroupChatType
+	n.MsgFrom = constant.SysMsgType
+	n.OperationID = operationID
+
+	var groupCreated open_im_sdk.GroupCreatedTips
+	groupCreated.Group = &open_im_sdk.GroupInfo{}
+	utils.CopyStructFields(groupCreated.Group, group)
+	groupCreated.Creator = &open_im_sdk.GroupMemberFullInfo{}
+	utils.CopyStructFields(groupCreated.Creator, creator)
+	for _, v := range memberList {
+		var groupMemberInfo open_im_sdk.GroupMemberFullInfo
+		utils.CopyStructFields(&groupMemberInfo, v)
+		groupCreated.MemberList = append(groupCreated.MemberList, &groupMemberInfo)
+	}
+	var tips open_im_sdk.TipsComm
+	tips.Detail, _ = json.Marshal(groupCreated)
+	tips.DefaultTips = config.Config.Notification.GroupCreated.DefaultTips.Tips
+	n.Content, _ = json.Marshal(tips)
+	Notification(&n, false)
+}
+
+//message ReceiveJoinApplicationTips{
+//  GroupInfo Group = 1;
+//  PublicUserInfo Applicant  = 2;
+//  string 	Reason = 3;
+//}
+func ReceiveJoinApplicationNotification(operationID, RecvID string, applicant *immysql.User, group *immysql.Group) {
+	var n NotificationMsg
+	n.SendID = applicant.UserID
+	n.RecvID = RecvID
+	n.ContentType = constant.ApplyJoinGroupTip
+	n.SessionType = constant.SingleChatType
+	n.MsgFrom = constant.SysMsgType
+	n.OperationID = operationID
+
+	var joniGroup open_im_sdk.ReceiveJoinApplicationTips
+	joniGroup.Group = &open_im_sdk.GroupInfo{}
+	utils.CopyStructFields(joniGroup.Group, group)
+	joniGroup.Applicant = &open_im_sdk.PublicUserInfo{}
+	utils.CopyStructFields(joniGroup.Applicant, applicant)
+
+	var tips open_im_sdk.TipsComm
+	tips.Detail, _ = json.Marshal(joniGroup)
+	tips.DefaultTips = config.Config.Notification.ApplyJoinGroup.DefaultTips.Tips
+	n.Content, _ = json.Marshal(tips)
+	Notification(&n, false)
+}
+
+//message ApplicationProcessedTips{
+//  GroupInfo Group = 1;
+//  GroupMemberFullInfo OpUser = 2;
+//  int32 Result = 3;
+//  string 	Reason = 4;
+//}
+func ApplicationProcessedNotification(operationID, RecvID string, group immysql.Group, opUser immysql.GroupMember, result int32, Reason string) {
+
+}
+
+//message MemberInvitedTips{
+//  GroupInfo Group = 1;
+//  GroupMemberFullInfo OpUser = 2;
+//  GroupMemberFullInfo InvitedUser = 3;
+//  uint64 OperationTime = 4;
+//}
+func MemberInvitedNotification(operationID string, group immysql.Group, opUser immysql.GroupMember, invitedUser immysql.GroupMember) {
+
+}
+
+//message MemberKickedTips{
+//  GroupInfo Group = 1;
+//  GroupMemberFullInfo OpUser = 2;
+//  GroupMemberFullInfo KickedUser = 3;
+//  uint64 OperationTime = 4;
+//}
+func MemberKickedNotification(operationID string, group immysql.Group, opUser immysql.GroupMember, KickedUser immysql.GroupMember) {
+
+}
+
+//message GroupInfoChangedTips{
+//  int32 ChangedType = 1; //bitwise operators: 1:groupName; 10:Notification  100:Introduction; 1000:FaceUrl
+//  GroupInfo Group = 2;
+//  GroupMemberFullInfo OpUser = 3;
+//}
+func GroupInfoChangedNotification(operationID string, changedType int32, group *immysql.Group, opUser *immysql.GroupMember) {
+	var n NotificationMsg
+	n.SendID = opUser.UserID
+	n.RecvID = group.GroupID
+	n.ContentType = constant.ChangeGroupInfoTip
+	n.SessionType = constant.GroupChatType
+	n.MsgFrom = constant.SysMsgType
+	n.OperationID = operationID
+
+	var groupInfoChanged open_im_sdk.GroupInfoChangedTips
+	groupInfoChanged.Group = &open_im_sdk.GroupInfo{}
+	utils.CopyStructFields(groupInfoChanged.Group, group)
+	groupInfoChanged.OpUser = &open_im_sdk.GroupMemberFullInfo{}
+	utils.CopyStructFields(groupInfoChanged.OpUser, opUser)
+	groupInfoChanged.ChangedType = changedType
+
+	var tips open_im_sdk.TipsComm
+	tips.Detail, _ = json.Marshal(groupInfoChanged)
+	tips.DefaultTips = config.Config.Notification.GroupInfoChanged.DefaultTips.Tips
+	n.Content, _ = json.Marshal(tips)
+	Notification(&n, false)
+}
+
+//message MemberLeaveTips{
+//  GroupInfo Group = 1;
+//  GroupMemberFullInfo LeaverUser = 2;
+//  uint64 OperationTime = 3;
+//}
+func MemberLeaveNotification(operationID string, group *immysql.Group, leaverUser *immysql.GroupMember) {
+
+}
+
+//message MemberEnterTips{
+//  GroupInfo Group = 1;
+//  GroupMemberFullInfo EntrantUser = 2;
+//  uint64 OperationTime = 3;
+//}
+func MemberEnterNotification(operationID string, group *immysql.Group, entrantUser *immysql.GroupMember) {
+
+}
+
+//message MemberInfoChangedTips{
+//  int32 ChangeType = 1; //1:info changed; 2:mute
+//  GroupMemberFullInfo OpUser = 2; //who do this
+//  GroupMemberFullInfo FinalInfo = 3; //
+//  uint64 MuteTime = 4;
+//  GroupInfo Group = 5;
+//}
+func MemberInfoChangedNotification(operationID string, group *immysql.Group, opUser *immysql.GroupMember, userFinalInfo *immysql.GroupMember) {
+
+}
+
+//message FriendApplicationAddedTips{
+//  PublicUserInfo OpUser = 1; //user1
+//  FriendApplication Application = 2;
+//  PublicUserInfo  OpedUser = 3; //user2
+//}
+func FriendApplicationAddedNotification(operationID string, opUser *immysql.User, opedUser *immysql.User, application *immysql.FriendRequest) {
+
+}
+
+//message FriendApplicationProcessedTips{
+//  PublicUserInfo     OpUser = 1;  //user2
+//  PublicUserInfo     OpedUser = 2; //user1
+//  int32 result = 3; //1: accept; -1: reject
+//}
+func FriendApplicationProcessedNotification(operationID string, opUser *immysql.User, OpedUser *immysql.User, result int32) {
+
+}
+
+//message FriendAddedTips{
+//  FriendInfo Friend = 1;
+//}
+//message FriendInfo{
+//  UserInfo OwnerUser = 1;
+//  string Remark = 2;
+//  uint64 CreateTime = 3;
+//  UserInfo FriendUser = 4;
+//}
+
+func FriendAddedNotification(operationID string, opUser *immysql.User, friendUser *immysql.Friend) {
+
+}
+
+//message FriendDeletedTips{
+//  FriendInfo Friend = 1;
+//}
+func FriendDeletedNotification(operationID string, opUser *immysql.User, friendUser *immysql.Friend) {
+
+}
+
+//message FriendInfoChangedTips{
+//  FriendInfo Friend = 1;
+//  PublicUserInfo OpUser = 2;
+//  uint64 OperationTime = 3;
+//}
+func FriendInfoChangedNotification(operationID string, opUser *immysql.User, friendUser *immysql.Friend) {
+
+}
+
+//message BlackAddedTips{
+//    BlackInfo Black = 1;
+//}
+//message BlackInfo{
+//  PublicUserInfo OwnerUser = 1;
+//  string Remark = 2;
+//  uint64 CreateTime = 3;
+//  PublicUserInfo BlackUser = 4;
+//}
+func BlackAddedNotification(operationID string, opUser *immysql.User, blackUser *immysql.User) {
+
+}
+
+//message BlackDeletedTips{
+//  BlackInfo Black = 1;
+//}
+func BlackDeletedNotification(operationID string, opUser *immysql.User, blackUser *immysql.User) {
+
+}
+
+//message SelfInfoUpdatedTips{
+//  UserInfo SelfUserInfo = 1;
+//  PublicUserInfo OpUser = 2;
+//  uint64 OperationTime = 3;
+//}
+func SelfInfoUpdatedNotification(operationID string, opUser *immysql.User, selfUser *immysql.User) {
+
+}

internal/rpc/group/create_group.go

@@ -1,8 +1,7 @@
 package group
 
 import (
-	"Open_IM/internal/push/content_struct"
-	"Open_IM/internal/push/logic"
+	"Open_IM/internal/rpc/chat"
 	"Open_IM/pkg/common/config"
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/db"
@@ -10,7 +9,6 @@ import (
 	"Open_IM/pkg/common/log"
 	"Open_IM/pkg/common/token_verify"
 	"Open_IM/pkg/grpc-etcdv3/getcdv3"
-	pbChat "Open_IM/pkg/proto/chat"
 	pbGroup "Open_IM/pkg/proto/group"
 	"Open_IM/pkg/utils"
 	"context"
@@ -69,39 +67,40 @@ func (s *groupServer) Run() {
 }
 
 func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupReq) (*pbGroup.CreateGroupResp, error) {
-	log.InfoByArgs("rpc create group is server,args=%s", req.String())
+	log.NewInfo(req.OperationID, "CreateGroup, args=%s", req.String())
 	var (
 		groupId string
 	)
 	//Parse token, to find current user information
 	claims, err := token_verify.ParseToken(req.Token)
 	if err != nil {
-		log.Error(req.Token, req.OperationID, "err=%s,parse token failed", err.Error())
+		log.NewError(req.OperationID, "ParseToken failed, ", err.Error(), req.String())
 		return &pbGroup.CreateGroupResp{ErrorCode: constant.ErrParseToken.ErrCode, ErrorMsg: constant.ErrParseToken.ErrMsg}, nil
 	}
 	//Time stamp + MD5 to generate group chat id
 	groupId = utils.Md5(strconv.FormatInt(time.Now().UnixNano(), 10))
 	err = im_mysql_model.InsertIntoGroup(groupId, req.GroupName, req.Introduction, req.Notification, req.FaceUrl, req.Ex)
 	if err != nil {
-		log.ErrorByKv("create group chat failed", req.OperationID, "err=%s", err.Error())
+		log.NewError(req.OperationID, "InsertIntoGroup failed, ", err.Error(), req.String())
 		return &pbGroup.CreateGroupResp{ErrorCode: constant.ErrCreateGroup.ErrCode, ErrorMsg: constant.ErrCreateGroup.ErrMsg}, nil
 	}
 
-	isMagagerFlag := 0
+	isManagerFlag := 0
 	tokenUid := claims.UID
 
 	if utils.IsContain(tokenUid, config.Config.Manager.AppManagerUid) {
-		isMagagerFlag = 1
+		isManagerFlag = 1
 	}
 
-	if isMagagerFlag == 0 {
+	us, err := im_mysql_model.FindUserByUID(claims.UID)
+	if err != nil {
+		log.Error("", req.OperationID, "find userInfo failed", err.Error())
+		return &pbGroup.CreateGroupResp{ErrorCode: constant.ErrCreateGroup.ErrCode, ErrorMsg: constant.ErrCreateGroup.ErrMsg}, nil
+	}
+
+	if isManagerFlag == 0 {
 		//Add the group owner to the group first, otherwise the group creation will fail
-		us, err := im_mysql_model.FindUserByUID(claims.UID)
-		if err != nil {
-			log.Error("", req.OperationID, "find userInfo failed", err.Error())
-			return &pbGroup.CreateGroupResp{ErrorCode: constant.ErrCreateGroup.ErrCode, ErrorMsg: constant.ErrCreateGroup.ErrMsg}, nil
-		}
-		err = im_mysql_model.InsertIntoGroupMember(groupId, claims.UID, us.Name, us.Icon, constant.GroupOwner)
+		err = im_mysql_model.InsertIntoGroupMember(groupId, claims.UID, us.Nickname, us.FaceUrl, constant.GroupOwner)
 		if err != nil {
 			log.Error("", req.OperationID, "create group chat failed,err=%s", err.Error())
 			return &pbGroup.CreateGroupResp{ErrorCode: constant.ErrCreateGroup.ErrCode, ErrorMsg: constant.ErrCreateGroup.ErrMsg}, nil
@@ -109,7 +108,7 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
 
 		err = db.DB.AddGroupMember(groupId, claims.UID)
 		if err != nil {
-			log.Error("", "", "create mongo group member failed, db.DB.AddGroupMember fail [err: %s]", err.Error())
+			log.NewError(req.OperationID, "AddGroupMember failed ", err.Error(), groupId, claims.UID)
 			return &pbGroup.CreateGroupResp{ErrorCode: constant.ErrCreateGroup.ErrCode, ErrorMsg: constant.ErrCreateGroup.ErrMsg}, nil
 		}
 	}
@@ -118,12 +117,12 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
 	for _, user := range req.MemberList {
 		us, err := im_mysql_model.FindUserByUID(user.Uid)
 		if err != nil {
-			log.Error("", req.OperationID, "find userInfo failed,uid=%s", user.Uid, err.Error())
+			log.NewError(req.OperationID, "FindUserByUID failed ", err.Error(), user.Uid)
 			continue
 		}
-		err = im_mysql_model.InsertIntoGroupMember(groupId, user.Uid, us.Name, us.Icon, user.SetRole)
+		err = im_mysql_model.InsertIntoGroupMember(groupId, user.Uid, us.Nickname, us.FaceUrl, user.SetRole)
 		if err != nil {
-			log.ErrorByArgs("pull %s to group %s failed,err=%s", user.Uid, groupId, err.Error())
+			log.ErrorByArgs("InsertIntoGroupMember failed", user.Uid, groupId, err.Error())
 		}
 		err = db.DB.AddGroupMember(groupId, user.Uid)
 		if err != nil {
@@ -131,32 +130,21 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
 		}
 	}
 
-	if isMagagerFlag == 1 {
+	if isManagerFlag == 1 {
 
-		//type NotificationContent struct {
-		//	IsDisplay   int32  `json:"isDisplay"`
-		//	DefaultTips string `json:"defaultTips"`
-		//	Detail      string `json:"detail"`
-		//}	n := NotificationContent{
-		//		IsDisplay:   1,
-		//		DefaultTips: "You have joined the group chat:" + createGroupResp.Data.GroupName,
-		//		Detail:      createGroupResp.Data.GroupId,
-		//	}
-
-		////Push message when create group chat
-		n := content_struct.NotificationContent{1, req.GroupName, groupId}
-		logic.SendMsgByWS(&pbChat.WSToMsgSvrChatMsg{
-			SendID:      claims.UID,
-			RecvID:      groupId,
-			Content:     n.ContentToString(),
-			SendTime:    utils.GetCurrentTimestampByNano(),
-			MsgFrom:     constant.SysMsgType,     //Notification message identification
-			ContentType: constant.CreateGroupTip, //Add friend flag
-			SessionType: constant.GroupChatType,
-			OperationID: req.OperationID,
-		})
 	}
+	group, err := im_mysql_model.FindGroupInfoByGroupId(groupId)
+	if err != nil {
+		log.NewError(req.OperationID, "FindGroupInfoByGroupId failed ", err.Error(), groupId)
+		return &pbGroup.CreateGroupResp{GroupID: groupId}, nil
+	}
+	memberList, err := im_mysql_model.FindGroupMemberListByGroupId(groupId)
+	if err != nil {
+		log.NewError(req.OperationID, "FindGroupMemberListByGroupId failed ", err.Error(), groupId)
+		return &pbGroup.CreateGroupResp{GroupID: groupId}, nil
+	}
+	chat.GroupCreatedNotification(req.OperationID, us, group, memberList)
+	log.NewInfo(req.OperationID, "GroupCreatedNotification, rpc CreateGroup success return ", groupId)
 
-	log.Info(req.Token, req.OperationID, "rpc create group success return")
 	return &pbGroup.CreateGroupResp{GroupID: groupId}, nil
 }

internal/rpc/group/group.go

@@ -384,9 +384,9 @@ func (s *groupServer) GetGroupMembersInfo(ctx context.Context, req *pbGroup.GetG
 		}
 		user, err := imdb.FindUserByUID(v)
 		if err == nil && user != nil {
-			memberNode.FaceUrl = user.Icon
+			memberNode.FaceUrl = user.FaceUrl
 			memberNode.JoinTime = uint64(memberInfo.JoinTime.Unix())
-			memberNode.UserId = user.UID
+			memberNode.UserId = user.UserID
 			memberNode.NickName = memberInfo.NickName
 			memberNode.Role = memberInfo.AdministratorLevel
 		}

internal/rpc/group/group_application_response.go

@@ -1,6 +1,7 @@
 package group
 
 import (
+	"Open_IM/internal/rpc/chat"
 	"Open_IM/pkg/common/db"
 	"Open_IM/pkg/common/db/mysql_model/im_mysql_model"
 	"Open_IM/pkg/common/log"
@@ -9,12 +10,11 @@ import (
 )
 
 func (s *groupServer) GroupApplicationResponse(_ context.Context, pb *group.GroupApplicationResponseReq) (*group.GroupApplicationResponseResp, error) {
-	log.Info("", "", "rpc GroupApplicationResponse call start..., [pb: %s]", pb.String())
-
+	log.NewInfo(pb.OperationID, "GroupApplicationResponse args: ", pb.String())
 	reply, err := im_mysql_model.GroupApplicationResponse(pb)
 	if err != nil {
-		log.Error("", "", "rpc GroupApplicationResponse call..., im_mysql_model.GroupApplicationResponse fail [pb: %s] [err: %s]", pb.String(), err.Error())
-		return &group.GroupApplicationResponseResp{ErrCode: 702, ErrMsg: "rpc GroupApplicationResponse failed"}, nil
+		log.NewError(pb.OperationID, "GroupApplicationResponse failed ", err.Error(), pb)
+		return &group.GroupApplicationResponseResp{ErrCode: 702, ErrMsg: err.Error()}, nil
 	}
 
 	if pb.HandleResult == 1 {
@@ -32,8 +32,15 @@ func (s *groupServer) GroupApplicationResponse(_ context.Context, pb *group.Grou
 			}
 		}
 	}
+	if pb.ToUserID == "0" {
+		chat.ApplicationProcessedNotification(pb.OperationID, pb.FromUserID)
+	}
 
-	log.Info("", "", "rpc GroupApplicationResponse call..., im_mysql_model.GroupApplicationResponse")
+	if pb.HandleResult == 1 {
+
+	}
+
+	log.NewInfo(pb.OperationID, "rpc GroupApplicationResponse ok ", reply)
 
 	return reply, nil
 }

internal/rpc/group/join_group.go

@@ -1,6 +1,7 @@
 package group
 
 import (
+	"Open_IM/internal/rpc/chat"
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/db/mysql_model/im_mysql_model"
 	"Open_IM/pkg/common/log"
@@ -10,16 +11,16 @@ import (
 )
 
 func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq) (*pbGroup.CommonResp, error) {
-	log.Info(req.Token, req.OperationID, "rpc join group is server,args=%s", req.String())
+	log.NewInfo(req.Token, req.OperationID, "JoinGroup args ", req.String())
 	//Parse token, to find current user information
 	claims, err := token_verify.ParseToken(req.Token)
 	if err != nil {
-		log.Error(req.Token, req.OperationID, "err=%s,parse token failed", err.Error())
+		log.NewError(req.OperationID, "ParseToken failed", err.Error(), req.String())
 		return &pbGroup.CommonResp{ErrorCode: constant.ErrParseToken.ErrCode, ErrorMsg: constant.ErrParseToken.ErrMsg}, nil
 	}
 	applicationUserInfo, err := im_mysql_model.FindUserByUID(claims.UID)
 	if err != nil {
-		log.Error(req.Token, req.OperationID, "No this user,err=%s", err.Error())
+		log.NewError(req.OperationID, "FindUserByUID failed", err.Error(), claims.UID)
 		return &pbGroup.CommonResp{ErrorCode: constant.ErrSearchUserInfo.ErrCode, ErrorMsg: constant.ErrSearchUserInfo.ErrMsg}, nil
 	}
 
@@ -28,30 +29,23 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq)
 		err = im_mysql_model.DelGroupRequest(req.GroupID, claims.UID, "0")
 	}
 
-	log.Info(req.Token, req.OperationID, "args: ", req.GroupID, claims.UID, "0", req.Message, applicationUserInfo.Name, applicationUserInfo.Icon)
-
-	if err = im_mysql_model.InsertIntoGroupRequest(req.GroupID, claims.UID, "0", req.Message, applicationUserInfo.Name, applicationUserInfo.Icon); err != nil {
+	if err = im_mysql_model.InsertIntoGroupRequest(req.GroupID, claims.UID, "0", req.Message, applicationUserInfo.Nickname, applicationUserInfo.FaceUrl); err != nil {
 		log.Error(req.Token, req.OperationID, "Insert into group request failed,er=%s", err.Error())
 		return &pbGroup.CommonResp{ErrorCode: constant.ErrJoinGroupApplication.ErrCode, ErrorMsg: constant.ErrJoinGroupApplication.ErrMsg}, nil
 	}
-	////Find the the group owner
-	//groupCreatorInfo, err := im_mysql_model.FindGroupMemberListByGroupIdAndFilterInfo(req.GroupID, constant.GroupCreator)
-	//if err != nil {
-	//	log.Error(req.Token, req.OperationID, "find group creator failed", err.Error())
-	//} else {
-	//	//Push message when join group chat
-	//	logic.SendMsgByWS(&pbChat.WSToMsgSvrChatMsg{
-	//		SendID:      claims.UID,
-	//		RecvID:      groupCreatorInfo[0].Uid,
-	//		Content:     content_struct.NewContentStructString(0, "", req.String()),
-	//		SendTime:    utils.GetCurrentTimestampBySecond(),
-	//		MsgFrom:     constant.SysMsgType,
-	//		ContentType: constant.JoinGroupTip,
-	//		SessionType: constant.SingleChatType,
-	//		OperationID: req.OperationID,
-	//	})
-	//}
 
-	log.Info(req.Token, req.OperationID, "rpc join group success return")
-	return &pbGroup.CommonResp{}, nil
+	memberList, err := im_mysql_model.FindGroupMemberListByGroupIdAndFilterInfo(req.GroupID, constant.GroupOwner)
+	if len(memberList) == 0 {
+		log.NewError(req.OperationID, "FindGroupMemberListByGroupIdAndFilterInfo failed ", req.GroupID, constant.GroupOwner, err)
+		return &pbGroup.CommonResp{ErrorCode: 0, ErrorMsg: ""}, nil
+	}
+	group, err := im_mysql_model.FindGroupInfoByGroupId(req.GroupID)
+	if err != nil {
+		log.NewError(req.OperationID, "FindGroupInfoByGroupId failed ", req.GroupID)
+		return &pbGroup.CommonResp{ErrorCode: 0, ErrorMsg: ""}, nil
+	}
+	chat.ReceiveJoinApplicationNotification(req.OperationID, memberList[0].UserID, applicationUserInfo, group)
+
+	log.NewInfo(req.OperationID, "ReceiveJoinApplicationNotification rpc JoinGroup success return")
+	return &pbGroup.CommonResp{ErrorCode: 0, ErrorMsg: ""}, nil
 }

internal/rpc/group/set_group_info.go

@@ -1,6 +1,7 @@
 package group
 
 import (
+	"Open_IM/internal/rpc/chat"
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/db/mysql_model/im_mysql_model"
 	"Open_IM/pkg/common/log"
@@ -18,6 +19,7 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf
 		log.Error(req.Token, req.OperationID, "err=%s,parse token failed", err.Error())
 		return &pbGroup.CommonResp{ErrorCode: constant.ErrParseToken.ErrCode, ErrorMsg: constant.ErrParseToken.ErrMsg}, nil
 	}
+
 	groupUserInfo, err := im_mysql_model.FindGroupMemberInfoByGroupIdAndUserId(req.GroupID, claims.UID)
 	if err != nil {
 		log.Error("", req.OperationID, "your are not in the group,can not change this group info,err=%s", err.Error())
@@ -26,21 +28,33 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf
 	if groupUserInfo.AdministratorLevel == constant.OrdinaryMember {
 		return &pbGroup.CommonResp{ErrorCode: constant.ErrSetGroupInfo.ErrCode, ErrorMsg: constant.ErrAccess.ErrMsg}, nil
 	}
+	group, err := im_mysql_model.FindGroupInfoByGroupId(req.GroupID)
+	if err != nil {
+		log.NewError(req.OperationID, "FindGroupInfoByGroupId failed, ", err.Error(), req.GroupID)
+		return &pbGroup.CommonResp{ErrorCode: constant.ErrSetGroupInfo.ErrCode, ErrorMsg: constant.ErrAccess.ErrMsg}, nil
+	}
+	////bitwise operators: 1:groupName; 10:Notification  100:Introduction; 1000:FaceUrl
+	var changedType int32
+	if group.GroupName != req.GroupName && req.GroupName != "" {
+		changedType = 1
+	}
+	if group.Notification != req.Notification && req.Notification != "" {
+		changedType = changedType | (1 << 1)
+	}
+	if group.Introduction != req.Introduction && req.Introduction != "" {
+		changedType = changedType | (1 << 2)
+	}
+	if group.FaceUrl != req.FaceUrl && req.FaceUrl != "" {
+		changedType = changedType | (1 << 3)
+	}
 	//only administrators can set group information
 	if err = im_mysql_model.SetGroupInfo(req.GroupID, req.GroupName, req.Introduction, req.Notification, req.FaceUrl, ""); err != nil {
 		return &pbGroup.CommonResp{ErrorCode: constant.ErrSetGroupInfo.ErrCode, ErrorMsg: constant.ErrSetGroupInfo.ErrMsg}, nil
 	}
-	////Push message when set group info
-	//jsonInfo, _ := json.Marshal(req)
-	//logic.SendMsgByWS(&pbChat.WSToMsgSvrChatMsg{
-	//	SendID:      claims.UID,
-	//	RecvID:      req.GroupID,
-	//	Content:     string(jsonInfo),
-	//	SendTime:    utils.GetCurrentTimestampBySecond(),
-	//	MsgFrom:     constant.SysMsgType,
-	//	ContentType: constant.SetGroupInfoTip,
-	//	SessionType: constant.GroupChatType,
-	//	OperationID: req.OperationID,
-	//})
+
+	if changedType != 0 {
+		chat.GroupInfoChangedNotification(req.OperationID, claims.UID, changedType, group, groupUserInfo)
+	}
+
 	return &pbGroup.CommonResp{}, nil
 }