Exemple #1
0
        private List <IChannelParticipant> GetChannelParticipants(ChannelFull channelFull, IChannelParticipantsFilter filter)
        {
            var participantsList = new List <IChannelParticipant>();

            using (var client = new FullClientDisposable(this))
            {
                uint count  = 100;
                uint offset = 0;
                var  result = (ChannelsChannelParticipants)TelegramUtils.RunSynchronously(
                    client.Client.Methods.ChannelsGetParticipantsAsync(new ChannelsGetParticipantsArgs
                {
                    Channel = new InputChannel
                    {
                        ChannelId  = channelFull.Id,
                        AccessHash = TelegramUtils.GetChannelAccessHash(_dialogs.GetChat(channelFull.Id))
                    },
                    Filter = filter,
                    Limit  = 100,
                    Offset = offset
                }));
                participantsList.AddRange(result.Participants);
                _dialogs.AddUsers(result.Users);
            }
            return(participantsList);
        }
 public Task SignMessages(BubbleGroup group, bool sign, Action <bool> result)
 {
     return(Task.Factory.StartNew(() =>
     {
         using (var client = new FullClientDisposable(this))
         {
             try
             {
                 var response = TelegramUtils.RunSynchronously(client.Client.Methods.ChannelsToggleSignaturesAsync(new ChannelsToggleSignaturesArgs
                 {
                     Channel = new InputChannel
                     {
                         ChannelId = uint.Parse(group.Address),
                         AccessHash = TelegramUtils.GetChannelAccessHash(_dialogs.GetChat(uint.Parse(group.Address)))
                     },
                     Enabled = sign
                 }));
                 SendToResponseDispatcher(response, client.Client);
                 result(true);
             }
             catch (Exception e)
             {
                 DebugPrint("## exception while migrating the chat " + e);
                 result(false);
             }
         }
     }));
 }
Exemple #3
0
 public Task SetPartyDescription(BubbleGroup group, string description, Action <bool> result)
 {
     return(Task.Factory.StartNew(() =>
     {
         if (description != null)
         {
             using (var client = new FullClientDisposable(this))
             {
                 var edited = TelegramUtils.RunSynchronously(client.Client.Methods.ChannelsEditAboutAsync(new ChannelsEditAboutArgs
                 {
                     Channel = new InputChannel
                     {
                         ChannelId = uint.Parse(group.Address),
                         AccessHash = TelegramUtils.GetChannelAccessHash(_dialogs.GetChat(uint.Parse(group.Address)))
                     },
                     About = description
                 }));
                 if (edited)
                 {
                     result(true);
                 }
                 else
                 {
                     result(false);
                 }
             }
         }
     }));
 }
Exemple #4
0
 public Task LeaveParty(BubbleGroup group)
 {
     return(Task.Factory.StartNew(() =>
     {
         var inputUser = new InputUser {
             UserId = Settings.AccountId
         };
         using (var client = new FullClientDisposable(this))
         {
             if (!group.IsExtendedParty)
             {
                 var update = TelegramUtils.RunSynchronously(client.Client.Methods.MessagesDeleteChatUserAsync(new MessagesDeleteChatUserArgs
                 {
                     ChatId = uint.Parse(group.Address),
                     UserId = inputUser,
                 }));
                 SendToResponseDispatcher(update, client.Client);
             }
             else
             {
                 var update = TelegramUtils.RunSynchronously(client.Client.Methods.ChannelsLeaveChannelAsync(new ChannelsLeaveChannelArgs
                 {
                     Channel = new InputChannel
                     {
                         ChannelId = uint.Parse(group.Address),
                         AccessHash = TelegramUtils.GetChannelAccessHash(_dialogs.GetChat(uint.Parse(group.Address)))
                     }
                 }));
                 SendToResponseDispatcher(update, client.Client);
             }
         }
     }));
 }
Exemple #5
0
 public Task SetPartyName(BubbleGroup group, string name)
 {
     return(Task.Factory.StartNew(() =>
     {
         using (var client = new FullClientDisposable(this))
         {
             if (!group.IsExtendedParty)
             {
                 var update = TelegramUtils.RunSynchronously(
                     client.Client.Methods.MessagesEditChatTitleAsync(new MessagesEditChatTitleArgs
                 {
                     ChatId = uint.Parse(group.Address),
                     Title = name,
                 }));
                 SendToResponseDispatcher(update, client.Client);
             }
             else
             {
                 var update = TelegramUtils.RunSynchronously(
                     client.Client.Methods.ChannelsEditTitleAsync(new ChannelsEditTitleArgs
                 {
                     Channel = new InputChannel
                     {
                         ChannelId = uint.Parse(group.Address),
                         AccessHash = TelegramUtils.GetChannelAccessHash(_dialogs.GetChat(uint.Parse(group.Address)))
                     },
                     Title = name
                 }));
                 SendToResponseDispatcher(update, client.Client);
             }
         }
     }));
 }
Exemple #6
0
 public Task UnblockPartyParticipant(BubbleGroup group, DisaParticipant participant, Action <bool> result)
 {
     return(Task.Factory.StartNew(() =>
     {
         using (var client = new FullClientDisposable(this))
         {
             try
             {
                 var response = TelegramUtils.RunSynchronously(client.Client.Methods.ChannelsKickFromChannelAsync(new ChannelsKickFromChannelArgs
                 {
                     Channel = new InputChannel
                     {
                         ChannelId = uint.Parse(group.Address),
                         AccessHash = TelegramUtils.GetChannelAccessHash(_dialogs.GetChat(uint.Parse(group.Address)))
                     },
                     Kicked = false,
                     UserId = new InputUser
                     {
                         UserId = uint.Parse(participant.Address),
                         AccessHash = GetUserAccessHashIfForeign(participant.Address)
                     }
                 }));
                 result(true);
             }
             catch (Exception e)
             {
                 DebugPrint("#### Exception " + e);
                 result(false);
             }
         }
     }));
 }
Exemple #7
0
 public Task SetPartyAddNewMembersRestriction(BubbleGroup group, PartyOptionsSettingsAddNewMembersRestriction restriction, Action <bool> result)
 {
     return(Task.Factory.StartNew(() =>
     {
         using (var client = new FullClientDisposable(this))
         {
             try
             {
                 var response = TelegramUtils.RunSynchronously(client.Client.Methods.ChannelsToggleInvitesAsync(new ChannelsToggleInvitesArgs
                 {
                     Channel = new InputChannel
                     {
                         ChannelId = uint.Parse(group.Address),
                         AccessHash = TelegramUtils.GetChannelAccessHash(_dialogs.GetChat(uint.Parse(group.Address)))
                     },
                     Enabled = restriction == PartyOptionsSettingsAddNewMembersRestriction.Everyone
                 }));
                 SendToResponseDispatcher(response, client.Client);
                 result(true);
             }
             catch (Exception e)
             {
                 DebugPrint("##### Exeption while setting all members are admins type " + e);
                 result(false);
             }
         }
     }));
 }
Exemple #8
0
        public Task DemotePartyParticipantsFromLeader(BubbleGroup group, DisaParticipant participant, Action <DemotePartyParticipantsResult> result)
        {
            return(Task.Factory.StartNew(() =>
            {
                var inputUser = new InputUser
                {
                    UserId = uint.Parse(participant.Address),
                    AccessHash = GetUserAccessHashIfForeign(participant.Address)
                };

                using (var client = new FullClientDisposable(this))
                {
                    if (!group.IsExtendedParty)
                    {
                        if (!ChatAdminsEnabled(group.Address))
                        {
                            result(DemotePartyParticipantsResult.AllMembersAreAdministratorsEnabled);
                            return;
                        }
                        try
                        {
                            TelegramUtils.RunSynchronously(client.Client.Methods.MessagesEditChatAdminAsync(new MessagesEditChatAdminArgs
                            {
                                ChatId = uint.Parse(group.Address),
                                IsAdmin = false,
                                UserId = inputUser,
                            }));
                            result(DemotePartyParticipantsResult.Success);
                        }
                        catch (Exception e)
                        {
                            result(DemotePartyParticipantsResult.Failure);
                        }
                    }
                    else
                    {
                        try
                        {
                            var response = TelegramUtils.RunSynchronously(client.Client.Methods.ChannelsEditAdminAsync(new ChannelsEditAdminArgs
                            {
                                Channel = new InputChannel
                                {
                                    ChannelId = uint.Parse(group.Address),
                                    AccessHash = TelegramUtils.GetChannelAccessHash(_dialogs.GetChat(uint.Parse(group.Address)))
                                },
                                Role = new ChannelRoleEmpty(),
                                UserId = inputUser
                            }));
                            SendToResponseDispatcher(response, client.Client);
                            result(DemotePartyParticipantsResult.Success);
                        }
                        catch (Exception e)
                        {
                            result(DemotePartyParticipantsResult.Failure);
                        }
                    }
                }
            }));
        }
Exemple #9
0
 private MessagesChatFull FetchFullChat(string address, bool superGroup)
 {
     //Classic check lock check pattern for concurrent access from all the methods
     if (_fullChat != null)
     {
         return(_fullChat);
     }
     lock (_fullChatLock)
     {
         if (_fullChat != null)
         {
             return(_fullChat);
         }
         using (var client = new FullClientDisposable(this))
         {
             if (!superGroup)
             {
                 _fullChat =
                     (MessagesChatFull)
                     TelegramUtils.RunSynchronously(
                         client.Client.Methods.MessagesGetFullChatAsync(new MessagesGetFullChatArgs
                 {
                     ChatId = uint.Parse(address)
                 }));
             }
             else
             {
                 try
                 {
                     _fullChat =
                         (MessagesChatFull)
                         TelegramUtils.RunSynchronously(
                             client.Client.Methods.ChannelsGetFullChannelAsync(new ChannelsGetFullChannelArgs
                     {
                         Channel = new InputChannel
                         {
                             ChannelId  = uint.Parse(address),
                             AccessHash = TelegramUtils.GetChannelAccessHash(_dialogs.GetChat(uint.Parse(address)))
                         }
                     }));
                 }
                 catch (Exception e)
                 {
                     DebugPrint(">>>> get full channel exception " + e);
                 }
             }
             //DebugPrint("#### fullchat " + ObjectDumper.Dump(_fullChat));
             _dialogs.AddUsers(_fullChat.Users);
             _dialogs.AddChats(_fullChat.Chats);
             return(_fullChat);
         }
     }
 }
Exemple #10
0
        public Task SetPartyPhoto(BubbleGroup group, byte[] bytes, Action <DisaThumbnail> result)
        {
            return(Task.Factory.StartNew(() =>
            {
                //MessagesEditChatPhotoAsync
                byte[] resizedImage = Platform.GenerateJpegBytes(bytes, 640, 640);
                var inputFile = UploadPartyImage(resizedImage);

                using (var client = new FullClientDisposable(this))
                {
                    if (!group.IsExtendedParty)
                    {
                        var update = TelegramUtils.RunSynchronously(
                            client.Client.Methods.MessagesEditChatPhotoAsync(new MessagesEditChatPhotoArgs
                        {
                            ChatId = uint.Parse(group.Address),
                            Photo = new InputChatUploadedPhoto
                            {
                                Crop = new InputPhotoCropAuto(),
                                File = inputFile
                            }
                        }));
                        SendToResponseDispatcher(update, client.Client);
                    }
                    else
                    {
                        //ChannelsEditPhoto
                        var update = TelegramUtils.RunSynchronously(
                            client.Client.Methods.ChannelsEditPhotoAsync(new ChannelsEditPhotoArgs
                        {
                            Channel = new InputChannel
                            {
                                ChannelId = uint.Parse(group.Address),
                                AccessHash = TelegramUtils.GetChannelAccessHash(_dialogs.GetChat(uint.Parse(group.Address)))
                            },
                            Photo = new InputChatUploadedPhoto
                            {
                                Crop = new InputPhotoCropAuto(),
                                File = inputFile
                            }
                        }));
                        SendToResponseDispatcher(update, client.Client);
                    }
                }
                byte[] disaImage = Platform.GenerateJpegBytes(bytes, 96, 96);
                var thumbnail = new DisaThumbnail(this, disaImage, GenerateRandomId().ToString());
                result(thumbnail);
            }));
        }
Exemple #11
0
 private IExportedChatInvite ExportChatInvite(BubbleGroup group)
 {
     using (var client = new FullClientDisposable(this))
     {
         var response = TelegramUtils.RunSynchronously(client.Client.Methods.ChannelsExportInviteAsync(new ChannelsExportInviteArgs
         {
             Channel = new InputChannel
             {
                 ChannelId  = uint.Parse(group.Address),
                 AccessHash = TelegramUtils.GetChannelAccessHash(_dialogs.GetChat(uint.Parse(group.Address)))
             }
         }));
         return(response);
     }
 }
Exemple #12
0
 public Task SetPartyType(BubbleGroup group, PartyOptionsSettingsPartyType type, Action <bool> result)
 {
     return(Task.Factory.StartNew(() =>
     {
         try
         {
             if (type == PartyOptionsSettingsPartyType.Public)
             {
                 var randomUserName = RandomString(32);
                 DebugPrint("The random username is " + randomUserName);
                 using (var client = new FullClientDisposable(this))
                 {
                     var response = TelegramUtils.RunSynchronously(client.Client.Methods.ChannelsUpdateUsernameAsync(new SharpTelegram.Schema.ChannelsUpdateUsernameArgs
                     {
                         Channel = new InputChannel
                         {
                             ChannelId = uint.Parse(group.Address),
                             AccessHash = TelegramUtils.GetChannelAccessHash(_dialogs.GetChat(uint.Parse(group.Address)))
                         },
                         Username = randomUserName
                     }));
                     result(response);
                 }
             }
             else
             {
                 using (var client = new FullClientDisposable(this))
                 {
                     var response = TelegramUtils.RunSynchronously(client.Client.Methods.ChannelsUpdateUsernameAsync(new SharpTelegram.Schema.ChannelsUpdateUsernameArgs
                     {
                         Channel = new InputChannel
                         {
                             ChannelId = uint.Parse(group.Address),
                             AccessHash = TelegramUtils.GetChannelAccessHash(_dialogs.GetChat(uint.Parse(group.Address)))
                         },
                         Username = ""
                     }));
                     result(response);
                 }
             }
         }
         catch (Exception e)
         {
             DebugPrint("##### Exeption while setting group type " + e);
             result(false);
         }
     }));
 }
Exemple #13
0
 private bool SetChannelUserName(BubbleGroup group, string name)
 {
     using (var client = new FullClientDisposable(this))
     {
         var response = TelegramUtils.RunSynchronously(client.Client.Methods.ChannelsUpdateUsernameAsync(new ChannelsUpdateUsernameArgs
         {
             Channel = new InputChannel
             {
                 ChannelId  = uint.Parse(group.Address),
                 AccessHash = TelegramUtils.GetChannelAccessHash(_dialogs.GetChat(uint.Parse(group.Address)))
             },
             Username = name
         }));
         return(response);
     }
 }
Exemple #14
0
 public Task DeletePartyParticipant(BubbleGroup group, DisaParticipant participant)
 {
     return(Task.Factory.StartNew(() =>
     {
         var inputUser = new InputUser
         {
             UserId = uint.Parse(participant.Address),
             AccessHash = GetUserAccessHashIfForeign(participant.Address)
         };
         using (var client = new FullClientDisposable(this))
         {
             if (!group.IsExtendedParty)
             {
                 var update = TelegramUtils.RunSynchronously(client.Client.Methods.MessagesDeleteChatUserAsync(new MessagesDeleteChatUserArgs
                 {
                     ChatId = uint.Parse(group.Address),
                     UserId = inputUser,
                 }));
                 SendToResponseDispatcher(update, client.Client);
             }
             else
             {
                 try
                 {
                     var update = TelegramUtils.RunSynchronously(client.Client.Methods.ChannelsKickFromChannelAsync(new ChannelsKickFromChannelArgs
                     {
                         Channel = new InputChannel
                         {
                             ChannelId = uint.Parse(group.Address),
                             AccessHash = TelegramUtils.GetChannelAccessHash(_dialogs.GetChat(uint.Parse(group.Address)))
                         },
                         Kicked = true,
                         UserId = inputUser
                     }));
                     SendToResponseDispatcher(update, client.Client);
                 }
                 catch (Exception e)
                 {
                     DebugPrint("Exception " + e);
                 }
             }
         }
     }));
 }
Exemple #15
0
        public Task PromotePartyParticipantToLeader(BubbleGroup group, DisaParticipant participant)
        {
            return(Task.Factory.StartNew(() =>
            {
                var inputUser = new InputUser
                {
                    UserId = uint.Parse(participant.Address),
                    AccessHash = GetUserAccessHashIfForeign(participant.Address)
                };

                using (var client = new FullClientDisposable(this))
                {
                    if (!ChatAdminsEnabled(group.Address))
                    {
                        //this condition should ideally never be hit
                        // if chat admins are disabled, everyone is an admin and hence the ui never allows anyone to be promoted to an admin
                    }

                    if (!group.IsExtendedParty)
                    {
                        TelegramUtils.RunSynchronously(client.Client.Methods.MessagesEditChatAdminAsync(new MessagesEditChatAdminArgs
                        {
                            ChatId = uint.Parse(group.Address),
                            IsAdmin = true,
                            UserId = inputUser,
                        }));
                    }
                    else
                    {
                        TelegramUtils.RunSynchronously(client.Client.Methods.ChannelsEditAdminAsync(new ChannelsEditAdminArgs
                        {
                            Channel = new InputChannel
                            {
                                ChannelId = uint.Parse(group.Address),
                                AccessHash = TelegramUtils.GetChannelAccessHash(_dialogs.GetChat(uint.Parse(group.Address)))
                            },
                            Role = new ChannelRoleModerator(),
                            UserId = inputUser
                        }));
                    }
                }
            }));
        }
        public Task AddPartyParticipant(BubbleGroup group, DisaParticipant participant)
        {
            var inputUser = new InputUser
            {
                UserId     = uint.Parse(participant.Address),
                AccessHash = GetUserAccessHashIfForeign(participant.Address)
            };

            return(Task.Factory.StartNew(() =>
            {
                using (var client = new FullClientDisposable(this))
                {
                    if (!group.IsExtendedParty)
                    {
                        var update = TelegramUtils.RunSynchronously(client.Client.Methods.MessagesAddChatUserAsync(new MessagesAddChatUserArgs
                        {
                            UserId = inputUser,
                            ChatId = uint.Parse(group.Address),
                            FwdLimit = 0
                        }));
                        SendToResponseDispatcher(update, client.Client);
                    }
                    else
                    {
                        var update = TelegramUtils.RunSynchronously(client.Client.Methods.ChannelsInviteToChannelAsync(new ChannelsInviteToChannelArgs
                        {
                            Channel = new InputChannel
                            {
                                ChannelId = uint.Parse(group.Address),
                                AccessHash = TelegramUtils.GetChannelAccessHash(_dialogs.GetChat(uint.Parse(group.Address)))
                            },
                            Users = new List <IInputUser>
                            {
                                inputUser
                            }
                        }));
                        SendToResponseDispatcher(update, client.Client);
                    }
                }
            }));
        }
        private void JoinChannelIfLeft(string id)
        {
            var channel = _dialogs.GetChat(uint.Parse(id)) as Channel;

            if (channel != null)
            {
                if (channel.Left != null)
                {
                    using (var client = new FullClientDisposable(this))
                    {
                        var updates = TelegramUtils.RunSynchronously(client.Client.Methods.ChannelsJoinChannelAsync(new ChannelsJoinChannelArgs
                        {
                            Channel = new InputChannel
                            {
                                ChannelId  = uint.Parse(id),
                                AccessHash = TelegramUtils.GetChannelAccessHash(_dialogs.GetChat(uint.Parse(id)))
                            }
                        }));
                        SendToResponseDispatcher(updates, client.Client);
                    }
                }
            }
        }
Exemple #18
0
        // TODO: Move to TelegramUtils for both
        // Separate implementation for Mentions - PartyOptions has its own as well
        private MessagesChatFull MentionsFetchFullChat(string address, bool superGroup, TelegramClient optionalClient = null)
        {
            using (var client = new OptionalClientDisposable(this, optionalClient))
            {
                MessagesChatFull fullChat = null;

                if (!superGroup)
                {
                    fullChat =
                        (MessagesChatFull)
                        TelegramUtils.RunSynchronously(
                            client.Client.Methods.MessagesGetFullChatAsync(new MessagesGetFullChatArgs
                    {
                        ChatId = uint.Parse(address)
                    }));
                }
                else
                {
                    fullChat =
                        (MessagesChatFull)
                        TelegramUtils.RunSynchronously(
                            client.Client.Methods.ChannelsGetFullChannelAsync(new ChannelsGetFullChannelArgs
                    {
                        Channel = new InputChannel
                        {
                            ChannelId  = uint.Parse(address),
                            AccessHash = TelegramUtils.GetChannelAccessHash(_dialogs.GetChat(uint.Parse(address)))
                        }
                    }));
                }

                _dialogs.AddUsers(fullChat.Users);
                _dialogs.AddChats(fullChat.Chats);

                return(fullChat);
            }
        }
        public Task InviteToChannel(BubbleGroup group, Tuple <Contact, Contact.ID>[] contacts, Action <bool> result)
        {
            var addPartyResult = AddPartyResult.Success;

            return(Task.Factory.StartNew(() =>
            {
                if (contacts.Length > 0)
                {
                    var inputUsers = new List <IInputUser>();
                    var names = new List <string>();
                    foreach (var contact in contacts)
                    {
                        names.Add(contact.Item1.FullName);
                        IUser user = null;
                        if (contact.Item1 is TelegramContact)
                        {
                            user = (contact.Item1 as TelegramContact).User;
                        }
                        else if (contact.Item1 is TelegramBotContact)
                        {
                            user = (contact.Item1 as TelegramBotContact).User;
                        }
                        var inputUser = TelegramUtils.CastUserToInputUser(user);
                        if (inputUser != null)
                        {
                            inputUsers.Add(inputUser);
                        }
                    }

                    if (inputUsers.Any())
                    {
                        using (var client = new FullClientDisposable(this))
                        {
                            try
                            {
                                var update = TelegramUtils.RunSynchronously(client.Client.Methods.ChannelsInviteToChannelAsync(new ChannelsInviteToChannelArgs
                                {
                                    Channel = new InputChannel
                                    {
                                        ChannelId = uint.Parse(group.Address),
                                        AccessHash = TelegramUtils.GetChannelAccessHash(_dialogs.GetChat(uint.Parse(group.Address)))
                                    },
                                    Users = inputUsers
                                }));
                                SendToResponseDispatcher(update, client.Client);
                            }
                            catch (Exception ex)
                            {
                                Utils.DebugPrint("Failed Telegram ChannelsInviteToChannelAsync: " + ex);

                                if (ex.Message.Contains("PEER_FLOOD"))
                                {
                                    _addPartyResult = AddPartyResult.Flood;
                                }
                                else
                                {
                                    _addPartyResult = AddPartyResult.Error;
                                }
                                return;
                            }
                        }
                    }
                }
            }));
        }
Exemple #20
0
        public Task AddPartyParticipant(BubbleGroup group, DisaParticipant participant)
        {
            _addPartyResult = AddPartyResult.Success;

            var inputUser = new InputUser
            {
                UserId     = uint.Parse(participant.Address),
                AccessHash = GetUserAccessHashIfForeign(participant.Address)
            };

            return(Task.Factory.StartNew(() =>
            {
                var user = _dialogs.GetUser(uint.Parse(participant.Address)) as User;
                if (user.BotNochats != null)
                {
                    _addPartyResult = AddPartyResult.BotNoChat;
                    return;
                }

                using (var client = new FullClientDisposable(this))
                {
                    if (!group.IsExtendedParty)
                    {
                        try
                        {
                            var update = TelegramUtils.RunSynchronously(client.Client.Methods.MessagesAddChatUserAsync(new MessagesAddChatUserArgs
                            {
                                UserId = inputUser,
                                ChatId = uint.Parse(group.Address),
                                FwdLimit = 0
                            }));
                            SendToResponseDispatcher(update, client.Client);
                        }
                        catch (Exception ex)
                        {
                            Utils.DebugPrint("Failed Telegram MessagesAddChatUserAsync: " + ex.Message);

                            if (ex.Message.Contains("PEER_FLOOD"))
                            {
                                _addPartyResult = AddPartyResult.Flood;
                            }
                            else
                            {
                                _addPartyResult = AddPartyResult.Error;
                            }
                            return;
                        }
                    }
                    else
                    {
                        try
                        {
                            var update = TelegramUtils.RunSynchronously(client.Client.Methods.ChannelsInviteToChannelAsync(new ChannelsInviteToChannelArgs
                            {
                                Channel = new InputChannel
                                {
                                    ChannelId = uint.Parse(group.Address),
                                    AccessHash = TelegramUtils.GetChannelAccessHash(_dialogs.GetChat(uint.Parse(group.Address)))
                                },
                                Users = new List <IInputUser>
                                {
                                    inputUser
                                }
                            }));
                            SendToResponseDispatcher(update, client.Client);
                        }
                        catch (Exception ex)
                        {
                            Utils.DebugPrint("Failed Telegram ChannelsInviteToChannelAsync: " + ex.Message);

                            if (ex.Message.Contains("PEER_FLOOD"))
                            {
                                _addPartyResult = AddPartyResult.Flood;
                            }
                            else
                            {
                                _addPartyResult = AddPartyResult.Error;
                            }
                            return;
                        }
                    }
                }
            }));
        }