invite user to groups api add

cmd/open_im_api/main.go

@@ -111,6 +111,8 @@ func main() {
 		groupRouterGroup.POST("/get_group_all_member_list", group.GetGroupAllMemberList) //1
 		groupRouterGroup.POST("/get_group_members_info", group.GetGroupMembersInfo)      //1
 		groupRouterGroup.POST("/invite_user_to_group", group.InviteUserToGroup)          //1
+		//only for supergroup
+		groupRouterGroup.POST("/invite_user_to_groups", group.InviteUserToGroups)
 		groupRouterGroup.POST("/get_joined_group_list", group.GetJoinedGroupList)
 		groupRouterGroup.POST("/dismiss_group", group.DismissGroup) //
 		groupRouterGroup.POST("/mute_group_member", group.MuteGroupMember)

internal/api/group/group.go

@@ -370,6 +370,47 @@ func InviteUserToGroup(c *gin.Context) {
 	log.NewInfo(req.OperationID, "InviteUserToGroup api return ", resp)
 	c.JSON(http.StatusOK, resp)
 }
+func InviteUserToGroups(c *gin.Context) {
+	params := api.InviteUserToGroupsReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.InviteUserToGroupsReq{}
+	utils.CopyStructFields(req, &params)
+
+	var ok bool
+	var errInfo string
+	ok, req.OpUserID, 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.StatusBadRequest, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+
+	log.NewInfo(req.OperationID, "InviteUserToGroup args ", req.String())
+
+	etcdConn := getcdv3.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetDefaultConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	client := rpc.NewGroupClient(etcdConn)
+	RpcResp, err := client.InviteUserToGroups(context.Background(), req)
+	if err != nil {
+		log.NewError(req.OperationID, "InviteUserToGroup failed ", err.Error(), req.String())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error()})
+		return
+	}
+	resp := api.InviteUserToGroupResp{CommResp: api.CommResp{ErrCode: RpcResp.ErrCode, ErrMsg: RpcResp.ErrMsg}}
+
+	log.NewInfo(req.OperationID, "InviteUserToGroups api return ", resp)
+	c.JSON(http.StatusOK, resp)
+}
 
 // @Summary 创建群组
 // @Description 创建群组

internal/rpc/group/group.go

@@ -564,6 +564,35 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
 	return &resp, nil
 }
 
+func (s *groupServer) InviteUserToGroups(ctx context.Context, req *pbGroup.InviteUserToGroupsReq) (*pbGroup.InviteUserToGroupsResp, error) {
+	if !token_verify.IsManagerUserID(req.OpUserID) {
+		log.NewError(req.OperationID, "no permission InviteUserToGroup ", req.String())
+		return &pbGroup.InviteUserToGroupsResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, nil
+	}
+	for _, v := range req.GroupIDList {
+		groupInfo, err := imdb.GetGroupInfoByGroupID(v)
+		if err != nil {
+			log.NewError(req.OperationID, "GetGroupInfoByGroupID failed ", v, err)
+			return &pbGroup.InviteUserToGroupsResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: err.Error() + v}, nil
+		}
+		if groupInfo.Status == constant.GroupStatusDismissed {
+			errMsg := " group status is dismissed " + v
+			return &pbGroup.InviteUserToGroupsResp{ErrCode: constant.ErrStatus.ErrCode, ErrMsg: errMsg}, nil
+		}
+	}
+	if err := db.DB.AddUserToSuperGroups(req.GroupIDList, req.InvitedUserID); err != nil {
+		log.NewError(req.OperationID, "AddUserToSuperGroups failed ", err.Error())
+		return &pbGroup.InviteUserToGroupsResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: err.Error()}, nil
+	}
+	if err := rocksCache.DelJoinedSuperGroupIDListFromCache(req.InvitedUserID); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error())
+	}
+	chat.SuperGroupNotification(req.OperationID, req.InvitedUserID, req.InvitedUserID)
+
+	log.NewInfo(req.OperationID, "InviteUserToGroups rpc return ")
+	return nil, nil
+}
+
 func (s *groupServer) GetGroupAllMember(ctx context.Context, req *pbGroup.GetGroupAllMemberReq) (*pbGroup.GetGroupAllMemberResp, error) {
 	log.NewInfo(req.OperationID, "GetGroupAllMember, args ", req.String())
 	var resp pbGroup.GetGroupAllMemberResp

pkg/base_info/group_api_struct.go

@@ -47,7 +47,15 @@ type InviteUserToGroupResp struct {
 	CommResp
 	UserIDResultList []*UserIDResult `json:"data"`
 }
-
+type InviteUserToGroupsReq struct {
+	GroupIDList   string `json:"groupIDList" binding:"required"`
+	InvitedUserID string `json:"invitedUserID" binding:"required"`
+	Reason        string `json:"reason"`
+	OperationID   string `json:"operationID" binding:"required"`
+}
+type InviteUserToGroupsResp struct {
+	CommResp
+}
 type GetJoinedGroupListReq struct {
 	OperationID string `json:"operationID" binding:"required"`
 	FromUserID  string `json:"fromUserID" binding:"required"`

pkg/common/db/model.go

@@ -112,6 +112,10 @@ func init() {
 	if err := createMongoIndex(mongoClient, cTag, true, "tag_id"); err != nil {
 		panic(err.Error() + "index create failed " + cTag + " tag_id")
 	}
+	if err := createMongoIndex(mongoClient, cUserToSuperGroup, true, "user_id"); err != nil {
+		panic(err.Error() + "index create failed " + cUserToSuperGroup + " user_id")
+	}
+
 	DB.mongoClient = mongoClient
 
 	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)

pkg/common/db/mongoModel.go

@@ -1233,6 +1233,36 @@ func (d *DataBases) AddUserToSuperGroup(groupID string, userIDList []string) err
 	_ = session.CommitTransaction(ctx)
 	return err
 }
+func (d *DataBases) AddUserToSuperGroups(groupIDList []string, userID string) error {
+	ctx, _ := context.WithTimeout(context.Background(), time.Duration(config.Config.Mongo.DBTimeout)*time.Second)
+	c := d.mongoClient.Database(config.Config.Mongo.DBDatabase).Collection(cSuperGroup)
+	session, err := d.mongoClient.StartSession()
+	if err != nil {
+		return utils.Wrap(err, "start session failed")
+	}
+	defer session.EndSession(ctx)
+	sCtx := mongo.NewSessionContext(ctx, session)
+	if err != nil {
+		return utils.Wrap(err, "start transaction failed")
+	}
+	_, err = c.UpdateMany(sCtx, bson.M{"group_id": bson.M{"$in": groupIDList}}, bson.M{"$addToSet": bson.M{"member_id_list": userID}})
+	if err != nil {
+		_ = session.AbortTransaction(ctx)
+		return utils.Wrap(err, "transaction failed")
+	}
+	c = d.mongoClient.Database(config.Config.Mongo.DBDatabase).Collection(cUserToSuperGroup)
+	upsert := true
+	opts := &options.UpdateOptions{
+		Upsert: &upsert,
+	}
+	_, err = c.UpdateOne(sCtx, bson.M{"user_id": userID}, bson.M{"$addToSet": bson.M{"group_id_list": bson.M{"$each": groupIDList}}}, opts)
+	if err != nil {
+		_ = session.AbortTransaction(ctx)
+		return utils.Wrap(err, "transaction failed")
+	}
+	_ = session.CommitTransaction(ctx)
+	return err
+}
 
 func (d *DataBases) RemoverUserFromSuperGroup(groupID string, userIDList []string) error {
 	ctx, _ := context.WithTimeout(context.Background(), time.Duration(config.Config.Mongo.DBTimeout)*time.Second)

pkg/proto/group/group.proto

@@ -200,6 +200,17 @@ message InviteUserToGroupResp {
   repeated  Id2Result Id2ResultList = 3; // 0 ok, -1 error
 }
 
+message InviteUserToGroupsReq {
+  string OperationID = 1;
+  repeated string groupIDList = 2;
+  string Reason = 3;
+  string invitedUserID = 4;
+  string OpUserID = 5; //group member or app manager
+}
+message InviteUserToGroupsResp {
+  int32   ErrCode = 1;
+  string  ErrMsg = 2;
+}
 
 message GetGroupAllMemberReq {
   string GroupID = 1;
@@ -413,6 +424,7 @@ service group{
   rpc kickGroupMember(KickGroupMemberReq) returns (KickGroupMemberResp);
   rpc getJoinedGroupList(GetJoinedGroupListReq) returns (GetJoinedGroupListResp);
   rpc inviteUserToGroup(InviteUserToGroupReq) returns (InviteUserToGroupResp);
+  rpc inviteUserToGroups(InviteUserToGroupsReq) returns (InviteUserToGroupsResp);
   rpc getGroupAllMember(GetGroupAllMemberReq) returns(GetGroupAllMemberResp);
 
   rpc GetGroups(GetGroupsReq) returns(GetGroupsResp);