public static TelegramSettings GenerateAuthentication(Service service)
{
try
{
service.DebugPrint("Fetching nearest DC...");
var settings = new TelegramSettings();
var authInfo = TelegramUtils.RunSynchronously(FetchNewAuthentication(DefaultTransportConfig));
using (var client = new TelegramClient(DefaultTransportConfig,
new ConnectionConfig(authInfo.AuthKey, authInfo.Salt), AppInfo))
{
TelegramUtils.RunSynchronously(client.Connect());
var nearestDcId = (NearestDc)TelegramUtils.RunSynchronously(client.Methods.HelpGetNearestDcAsync(new HelpGetNearestDcArgs {
}));
var config = (Config)TelegramUtils.RunSynchronously(client.Methods.HelpGetConfigAsync(new HelpGetConfigArgs {
}));
var dcOption = config.DcOptions.OfType <DcOption>().FirstOrDefault(x => x.Id == nearestDcId.NearestDcProperty);
settings.NearestDcId = nearestDcId.NearestDcProperty;
settings.NearestDcIp = dcOption.IpAddress;
settings.NearestDcPort = (int)dcOption.Port;
}
service.DebugPrint("Generating authentication on nearest DC...");
var authInfo2 = TelegramUtils.RunSynchronously(FetchNewAuthentication(
new TcpClientTransportConfig(settings.NearestDcIp, settings.NearestDcPort)));
settings.AuthKey = authInfo2.AuthKey;
settings.Salt = authInfo2.Salt;
service.DebugPrint("Great! Ready for the service to start.");
return(settings);
}
catch (Exception ex)
{
service.DebugPrint("Error in GenerateAuthentication: " + ex);
}
return(null);
}
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);
}
}
}
}));
}
public static AuthPasswordRecovery RequestPasswordRecovery(Service service, TelegramSettings settings)
{
try
{
var transportConfig =
new TcpClientTransportConfig(settings.NearestDcIp, settings.NearestDcPort);
using (var client = new TelegramClient(transportConfig,
new ConnectionConfig(settings.AuthKey, settings.Salt), AppInfo))
{
TelegramUtils.RunSynchronously(client.Connect());
try
{
var result = (AuthPasswordRecovery)TelegramUtils.RunSynchronously(client.Methods.AuthRequestPasswordRecoveryAsync(new AuthRequestPasswordRecoveryArgs
{
}));
Thread.Sleep(100);
return(result);
}
catch (RpcErrorException ex)
{
var error = (RpcError)ex.Error;
return(null);
}
}
}
catch (Exception ex)
{
service.DebugPrint("Error in VerifyPassword: " + ex);
return(null);
}
}
private bool CheckLink(string linkUsefulPart, out IChat alreadyJoinedChat)
{
using (var client = new FullClientDisposable(this))
{
try
{
var result = TelegramUtils.RunSynchronously(client.Client.Methods.MessagesCheckChatInviteAsync(new MessagesCheckChatInviteArgs
{
Hash = linkUsefulPart
}));
var chatInvite = result as ChatInvite;
var chatInviteAlready = result as ChatInviteAlready;
if (chatInvite != null)
{
alreadyJoinedChat = null;
return(true);
}
if (chatInviteAlready != null)
{
alreadyJoinedChat = chatInviteAlready.Chat;
return(true);
}
alreadyJoinedChat = null;
return(false);
}
catch (Exception ex)
{
DebugPrint("Exception while checking invite" + ex);
alreadyJoinedChat = null;
return(false);
}
}
}
private uint GetLastPtsForChannel(TelegramClient client, string address)
{
uint offset = 0;
uint pts = 0;
Again:
var iDialogs = TelegramUtils.RunSynchronously(client.Methods.MessagesGetDialogsAsync(new MessagesGetDialogsArgs
{
Limit = 100,
OffsetPeer = new InputPeerEmpty()
}));
var dialogs = iDialogs as MessagesDialogs;
var dialogsSlice = iDialogs as MessagesDialogsSlice;
if (dialogs != null)
{
pts = FindPtsFromDialogs(dialogs.Dialogs, address);
}
if (dialogsSlice != null)
{
pts = FindPtsFromDialogs(dialogsSlice.Dialogs, address);
//pts can never be zero, so we use this
if (pts == 0)
{
offset += dialogsSlice.Count;
goto Again;
}
}
return(pts);
}
public static bool RequestAccountReset(Service service, TelegramSettings settings)
{
try
{
var transportConfig =
new TcpClientTransportConfig(settings.NearestDcIp, settings.NearestDcPort);
using (var client = new TelegramClient(transportConfig,
new ConnectionConfig(settings.AuthKey, settings.Salt), AppInfo))
{
TelegramUtils.RunSynchronously(client.Connect());
try
{
var result = TelegramUtils.RunSynchronously(client.Methods.AccountDeleteAccountAsync(new AccountDeleteAccountArgs
{
Reason = "Forgot Password"
}));
return(result);
}
catch (RpcErrorException ex)
{
var error = (RpcError)ex.Error;
return(false);
}
}
}
catch (Exception ex)
{
service.DebugPrint("Error in VerifyPassword: " + ex);
return(false);
}
}
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 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);
}
}
}));
}
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);
}
}
}));
}
public Task GetBotCallbackAnswer(BubbleGroup group, VisualBubble bubble, Bots.KeyboardButton button, Action <Bots.MessagesBotCallbackAnswer> answer)
{
return(Task.Factory.StartNew(() =>
{
using (var client = new FullClientDisposable(this))
{
// Note: Telegram also has KeyboardButtonGame which functions as a callback also
if (button is Bots.KeyboardButtonCallback)
{
var keyboardButtonCallback = button as Bots.KeyboardButtonCallback;
var args = new MessagesGetBotCallbackAnswerArgs
{
MsgId = uint.Parse(bubble.IdService),
Data = keyboardButtonCallback.Data,
Peer = GetInputPeer(group.Address, group.IsParty, group.IsExtendedParty)
};
SharpTelegram.Schema.MessagesBotCallbackAnswer telegramBotCallbackAnswer =
(SharpTelegram.Schema.MessagesBotCallbackAnswer)
TelegramUtils.RunSynchronously(
client.Client.Methods.MessagesGetBotCallbackAnswerAsync(args));
var disaBotCallbackAnswer = new Bots.MessagesBotCallbackAnswer
{
Alert = telegramBotCallbackAnswer.Alert != null ? true : false,
Message = telegramBotCallbackAnswer.Message
};
answer(disaBotCallbackAnswer);
}
}
}));
}
private IMessagesMessages GetChatMessagesForChannel(BubbleGroup group, long fromTime, int max, FullClientDisposable client)
{
var fullChat = FetchFullChat(group.Address, true);
var fullChannel = fullChat.FullChat as ChannelFull;
if (fullChannel != null)
{
if (fullChannel.MigratedFromChatId != 0)
{
var peerChat = GetInputPeer(fullChannel.MigratedFromChatId.ToString(), true, false);
DisposeFullChat();
return(TelegramUtils.RunSynchronously(
client.Client.Methods.MessagesGetHistoryAsync(new MessagesGetHistoryArgs
{
Peer = peerChat,
OffsetDate = (uint)fromTime,
Limit = (uint)max
})));
}
DisposeFullChat();
return(MakeMessagesMessages(new List <IChat>(), new List <IUser>(), new List <IMessage>()));
}
DisposeFullChat();
return(MakeMessagesMessages(new List <IChat>(), new List <IUser>(), new List <IMessage>()));
}
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);
}
}
}));
}
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);
}
}
}));
}
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);
}
}
}));
}
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);
}
}
}
}));
}
public Task GetPrivacyList(Action <string[]> addresses)
{
List <string> addressList;
return(Task.Factory.StartNew(() =>
{
uint offset = 0;
//TODO: check when it returns a chunk or a full list
using (var client = new FullClientDisposable(this))
{
Again:
var blocked =
TelegramUtils.RunSynchronously(
client.Client.Methods.ContactsGetBlockedAsync(new ContactsGetBlockedArgs
{
Limit = 100,
Offset = offset
}));
var contactsBlocked = blocked as ContactsBlocked;
var contactsBlockedSlice = blocked as ContactsBlockedSlice;
addressList = new List <string>();
if (contactsBlocked != null)
{
foreach (var blockedContact in contactsBlocked.Blocked)
{
var contactBlocked = blockedContact as ContactBlocked;
if (contactBlocked == null)
{
continue;
}
addressList.Add(contactBlocked.UserId.ToString(CultureInfo.InvariantCulture));
}
_dialogs.AddUsers(contactsBlocked.Users);
}
if (contactsBlockedSlice != null)
{
foreach (var blockedContact in contactsBlockedSlice.Blocked)
{
var contactBlocked = blockedContact as ContactBlocked;
if (contactBlocked == null)
{
continue;
}
addressList.Add(contactBlocked.UserId.ToString(CultureInfo.InvariantCulture));
}
_dialogs.AddUsers(contactsBlockedSlice.Users);
if (contactsBlockedSlice.Blocked.Any())
{
offset += contactsBlockedSlice.Count;
goto Again;
}
}
previousAddresses = addressList.ToArray();
addresses(addressList.ToArray());
}
}));
}
public DownloadManager(Document document, Telegram telegram)
{
_document = document;
_fileSize = document.Size;
_telegram = telegram;
int dcId = (int)_document.DcId;
//initialize the dc we want to download from
if (_document.DcId != _telegram.Settings.NearestDcId)
{
Retry:
// if its not the nearest dc, it could be unintialized. so lets check and init it.
var dc = DcDatabase.Get(dcId);
if (dc == null)
{
_telegram.GetClient(dcId);
//after this our dc configuration is ready, the connection should die out in a 60 secs.
}
var dcCached = DcDatabase.Get(dcId);
if (dcCached == null)
{
return;
}
var dcOption = _telegram.Config.DcOptions.Cast <DcOption>().FirstOrDefault(x => x.Id == dcId);
var tcpConfig = new TcpClientTransportConfig(dcOption.IpAddress, (int)dcOption.Port);
var authInfo = new SharpMTProto.Authentication.AuthInfo(dcCached.Key,
BitConverter.ToUInt64(dcCached.Salt, 0));
_client = new TelegramClient(tcpConfig,
new ConnectionConfig(authInfo.AuthKey, authInfo.Salt), AppInfo);
TelegramUtils.RunSynchronously(_client.Connect());
try
{
TelegramUtils.RunSynchronously(_client.Methods.AccountGetAccountTTLAsync(new AccountGetAccountTTLArgs()));
}
catch (Exception x)
{
if (x.Message != null && x.Message.Contains("401"))
{
telegram.DebugPrint("Yikes! DC went down. Let's reinstate it...");
_client.Dispose();
DcDatabase.Delete(dcId);
goto Retry;
}
}
}
else
{
var tcpConfig = new TcpClientTransportConfig(_telegram.Settings.NearestDcIp, (int)_telegram.Settings.NearestDcPort);
var authInfo = new SharpMTProto.Authentication.AuthInfo(_telegram.Settings.AuthKey,
_telegram.Settings.Salt);
_client = new TelegramClient(tcpConfig,
new ConnectionConfig(authInfo.AuthKey, authInfo.Salt), AppInfo);
TelegramUtils.RunSynchronously(_client.Connect());
}
}
public Task SetPrivacyList(string[] addresses)
{
return(Task.Factory.StartNew(() =>
{
using (var client = new FullClientDisposable(this))
{
if (addresses.Length < previousAddresses.Length)
{
//address was removed
foreach (var address in previousAddresses)
{
if (addresses.Contains(address))
{
continue;
}
TelegramUtils.RunSynchronously(
client.Client.Methods.ContactsUnblockAsync(new ContactsUnblockArgs
{
Id = new InputUser
{
UserId = uint.Parse(address),
AccessHash = GetUserAccessHashIfForeign(address)
}
}));
break;
}
}
else //address was added
{
foreach (var address in addresses)
{
if (previousAddresses.Contains(address))
{
continue;
}
TelegramUtils.RunSynchronously(
client.Client.Methods.ContactsBlockAsync(new ContactsBlockArgs
{
Id = new InputUser
{
UserId = uint.Parse(address),
AccessHash = GetUserAccessHashIfForeign(address)
}
}));
break;
}
}
}
ServiceEvents.RaisePrivacyListUpdated();
previousAddresses = addresses;
}));
}
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);
}
}
}
private IMessagesMessages GetChannelMessages(BubbleGroup group, uint offsetId, int max, FullClientDisposable client)
{
var peer = GetInputPeer(group.Address, group.IsParty, group.IsExtendedParty);
return
(TelegramUtils.RunSynchronously(
client.Client.Methods.MessagesGetHistoryAsync(new MessagesGetHistoryArgs
{
Peer = peer,
OffsetId = offsetId + 1,
OffsetDate = 0,
Limit = (uint)max
})));
}
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);
}));
}
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);
}
}
public static DcOption GetDcConfig(int migrateId, TelegramSettings settings)
{
var transportConfig =
new TcpClientTransportConfig(settings.NearestDcIp, settings.NearestDcPort);
using (var client = new TelegramClient(transportConfig,
new ConnectionConfig(settings.AuthKey, settings.Salt), AppInfo))
{
TelegramUtils.RunSynchronously(client.Connect());
var config = (Config)TelegramUtils.RunSynchronously(client.Methods.HelpGetConfigAsync(new HelpGetConfigArgs {
}));
var dcOption = config.DcOptions.OfType <DcOption>().FirstOrDefault(x => x.Id == migrateId);
return(dcOption);
}
}
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);
}
}));
}
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);
}
}
private static void GetPasswordDetails(TelegramClient client, CodeRegister cr)
{
var result = TelegramUtils.RunSynchronously(client.Methods.AccountGetPasswordAsync(new AccountGetPasswordArgs
{
}));
var authPassword = result as AccountPassword;
var authNoPassword = result as AccountNoPassword;
if (authPassword != null)
{
cr.CurrentSalt = authPassword.CurrentSalt;
cr.NewSalt = authPassword.NewSalt;
cr.HasRecovery = authPassword.HasRecovery;
cr.Hint = authPassword.Hint;
}
}
public static AuthExportedAuthorization GenerateExportedAuth(int migrateId, TelegramSettings settings)
{
var transportConfig =
new TcpClientTransportConfig(settings.NearestDcIp, settings.NearestDcPort);
using (var client = new TelegramClient(transportConfig,
new ConnectionConfig(settings.AuthKey, settings.Salt), AppInfo))
{
TelegramUtils.RunSynchronously(client.Connect());
var exportedAuth = (AuthExportedAuthorization)TelegramUtils.RunSynchronously(client.Methods.AuthExportAuthorizationAsync(
new SharpTelegram.Schema.AuthExportAuthorizationArgs
{
DcId = (uint)migrateId,
}));
return(exportedAuth);
}
}
public string PhoneNumberToServiceAddress(string number)
{
var users = TelegramUtils.RunSynchronously(FetchContacts());
var formattedNumber = FormatNumber(number);
if (formattedNumber == null)
{
return(null);
}
foreach (var user in users)
{
if (user.Phone == formattedNumber)
{
return(user.Id.ToString());
}
}
return(null);
}
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);
}
}
}
}));
}
private void DisconnectFullClientIfPossible()
{
if (IsFullClientConnected)
{
try
{
TelegramUtils.RunSynchronously(_fullClient.Methods.AccountUpdateStatusAsync(new AccountUpdateStatusArgs
{
Offline = true
}));
TelegramUtils.RunSynchronously(_fullClient.Disconnect());
}
catch (Exception ex)
{
DebugPrint("Failed to disconnect full client: " + ex);
}
RemoveFullClientPingIfPossible();
}
}