public void GetContactsAsync(System.Action callback)
{
var savedCount = TLUtils.OpenObjectFromMTProtoFile <TLInt>(_savedCountSyncRoot, Constants.SavedCountFileName);
var hash = TLUtils.GetContactsHash(savedCount, CacheService.GetContacts().Where(x => x.IsContact).OrderBy(x => x.Index).ToList());
IsWorking = true;
MTProtoService.GetContactsAsync(new TLInt(hash),
result => Execute.BeginOnUIThread(() =>
{
Execute.ShowDebugMessage(result.ToString());
IsWorking = false;
var contacts = result as TLContacts71;
if (contacts != null)
{
TLUtils.SaveObjectToMTProtoFile(_savedCountSyncRoot, Constants.SavedCountFileName, contacts.SavedCount);
InsertContacts(contacts.Users);
}
var contactsNotModified = result as TLContactsNotModified;
if (contactsNotModified != null)
{
}
callback.SafeInvoke();
}),
error => Execute.BeginOnUIThread(() =>
{
IsWorking = false;
Execute.ShowDebugMessage("contacts.getContacts error: " + error);
callback.SafeInvoke();
}));
}
public void Handle(TLUpdatePrivacy update)
{
if (update.Key is TLPrivacyKeyStatusTimestamp)
{
Execute.ShowDebugMessage("update privacy");
MTProtoService.GetStatusesAsync(
statuses => Execute.BeginOnUIThread(() =>
{
try
{
for (var i = 0; i < Items.Count; i++)
{
Items[i].NotifyOfPropertyChange(() => Items[i].StatusCommon);
}
_lastUpdateStatusesTime = DateTime.Now;
}
catch (Exception e)
{
Execute.ShowDebugMessage("UpdateStatuses ex " + e);
}
}),
error =>
{
Execute.ShowDebugMessage("contacts.getStatuses error " + error);
});
}
}
private void ReadMessages(params TLDecryptedMessageBase[] messages)
{
if (!_isActive)
{
return;
}
var chat = Chat as TLEncryptedChatCommon;
if (chat == null)
{
return;
}
var maxDate = messages.Max(x => x.Date.Value);
SetRead(messages);
MTProtoService.ReadEncryptedHistoryAsync(
new TLInputEncryptedChat {
ChatId = Chat.Id, AccessHash = chat.AccessHash
},
new TLInt(maxDate),
result =>
{
//SetRead(messages);
},
error =>
{
Execute.ShowDebugMessage("messages.readEncryptedHistory error: " + error);
});
}
private void UpdateStatusesAsync()
{
BeginOnThreadPool(TimeSpan.FromSeconds(1.0), () =>
{
if (_lastUpdateStatusesTime.HasValue &&
_lastUpdateStatusesTime.Value.AddSeconds(30.0) > DateTime.Now)
{
return;
}
try
{
for (var i = 0; i < Items.Count; i++)
{
Items[i].NotifyOfPropertyChange(() => Items[i].StatusCommon);
}
_lastUpdateStatusesTime = DateTime.Now;
}
catch (Exception e)
{
Execute.ShowDebugMessage("UpdateStatuses ex " + e);
}
});
}
public static void UpdateMainTile()
{
#if WNS_PUSH_SERVICE
try
{
ToastNotificationManager.History.Clear();
}
catch (Exception ex)
{
Telegram.Logs.Log.Write("ClearNotifications ex " + ex);
Execute.ShowDebugMessage("Clear notifications history exception\n" + ex);
}
try
{
BadgeUpdateManager.CreateBadgeUpdaterForApplication().Clear();
TileUpdateManager.CreateTileUpdaterForApplication().Clear();
}
catch (Exception ex)
{
Telegram.Logs.Log.Write("ClearTile ex " + ex);
Execute.ShowDebugMessage("Clear tile exception\n" + ex);
}
#else
// no way to clear toast history with MPNS
//try
//{
// ToastNotificationManager.History.Clear();
//}
//catch (Exception ex)
//{
// Telegram.Logs.Log.Write("ClearNotifications ex " + ex);
// Execute.ShowDebugMessage("Clear notifications history exception\n" + ex);
//}
var tile = ShellTile.ActiveTiles.FirstOrDefault();
if (tile == null)
{
return;
}
#if WP8
var tileData = new IconicTileData {
Count = 0, WideContent1 = "", WideContent2 = "", WideContent3 = ""
};
#else
var tileData = new StandardTileData {
Count = 0
};
#endif
try
{
tile.Update(tileData);
}
catch (Exception ex)
{
Execute.ShowDebugMessage("Tile.Update exception\n" + ex);
}
#endif
}
private void UpdateStickersAsync(TLFeaturedStickers cachedStickers)
{
var hash = cachedStickers != null ? cachedStickers.HashValue : new TLInt(0);
IsWorking = true;
MTProtoService.GetFeaturedStickersAsync(true, hash,
result => BeginOnUIThread(() =>
{
IsWorking = false;
var featuredStickers = result as TLFeaturedStickers;
if (featuredStickers != null)
{
UpdateSets(featuredStickers, featuredStickers.Unread);
UpdateStickersSubtitle(featuredStickers, _allStickers, _masks);
StateService.SaveFeaturedStickersAsync(featuredStickers);
}
}),
error => BeginOnUIThread(() =>
{
IsWorking = false;
Execute.ShowDebugMessage("messages.getFeaturedStickers error " + error);
}));
}
protected override void OnActivate(object sender, ActivatedEventArgs e)
{
Telegram.Logs.Log.Write("Activate");
#if LOG_REGISTRATION
TLUtils.WriteLog("App activate IsAppInstancePreserved=" + e.IsApplicationInstancePreserved);
#endif
EnterAppMutex();
CheckPasscode();
if (!e.IsApplicationInstancePreserved)
{
var cacheService = IoC.Get <ICacheService>();
cacheService.Init();
Execute.ShowDebugMessage("Init database");
}
TLUtils.WritePerformance(">>OnActivate IsAppInstancePreserved " + e.IsApplicationInstancePreserved);
//RestoreConnectionAsync();
LoadStateAndUpdateAsync();
ShowBatterySaverAlertAsync();
CheckTextScaleFactorAsync();
base.OnActivate(sender, e);
}
public static void SendEncryptedService(TLEncryptedChat chat, TLObject obj, IMTProtoService mtProtoService, ICacheService cacheService, Action <TLSentEncryptedMessage> callbak)
{
var message = GetDecryptedServiceMessage(obj);
if (message == null)
{
return;
}
cacheService.SyncDecryptedMessage(message, chat,
cachedMessage =>
{
mtProtoService.SendEncryptedServiceAsync(new TLInputEncryptedChat {
AccessHash = chat.AccessHash, ChatId = chat.Id
}, message.RandomId, TLUtils.EncryptMessage(obj, mtProtoService.CurrentUserId, chat),
result =>
{
callbak.SafeInvoke(result);
message.Status = MessageStatus.Confirmed;
message.NotifyOfPropertyChange(() => message.Status);
cacheService.SyncSendingDecryptedMessage(chat.Id, result.Date, message.RandomId, m => { });
},
error =>
{
message.Status = MessageStatus.Failed;
message.NotifyOfPropertyChange(() => message.Status);
Execute.ShowDebugMessage("messages.sendServiceEncrypted error " + error);
});
});
}
public void Handle(TLUpdatePrivacy update)
{
Execute.ShowDebugMessage("update privacy");
MTProtoService.GetStatusesAsync(
statuses =>
{
try
{
for (var i = 0; i < Items.Count; i++)
{
Items[i].NotifyOfPropertyChange("Status");
}
_lastUpdateStatusesTime = DateTime.Now;
}
catch (Exception e)
{
TLUtils.WriteException(e);
}
},
error =>
{
Execute.ShowDebugMessage("contacts.getStatuses error " + error);
});
}
private static UploadablePart GetUploadablePart(string fileName, long position, int partId, bool isLastPart = false)
{
var fullFilePath = ApplicationData.Current.LocalFolder.Path + "\\" + fileName;
var fi = new FileInfo(fullFilePath);
if (!fi.Exists)
{
return(null);
}
const int minPartLength = 1024;
const int maxPartLength = 16 * 1024;
var recordingLength = fi.Length - position;
if (!isLastPart && recordingLength < minPartLength)
{
return(null);
}
var subpartsCount = (int)recordingLength / minPartLength;
var uploadingBufferSize = 0;
if (isLastPart)
{
if (recordingLength > 0)
{
uploadingBufferSize = Math.Min(maxPartLength, (int)recordingLength);
}
}
else
{
uploadingBufferSize = Math.Min(maxPartLength, subpartsCount * minPartLength);
}
if (uploadingBufferSize == 0)
{
return(null);
}
var uploadingBuffer = new byte[uploadingBufferSize];
try
{
using (var fileStream = File.Open(fullFilePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
fileStream.Position = position;
fileStream.Read(uploadingBuffer, 0, uploadingBufferSize);
}
}
catch (Exception ex)
{
Execute.ShowDebugMessage("read file " + fullFilePath + " exception " + ex);
return(null);
}
return(new UploadablePart(null, new TLInt(partId), uploadingBuffer, position, uploadingBufferSize));
}
private void OnDialogAdded(object sender, DialogAddedEventArgs e)
{
var dialog = e.Dialog;
if (dialog == null)
{
return;
}
BeginOnUIThread(() =>
{
var index = -1;
for (var i = 0; i < Items.Count; i++)
{
if (Items[i] == e.Dialog)
{
return;
}
if (Items[i].GetDateIndex() < dialog.GetDateIndex())
{
index = i;
break;
}
}
#if LAYER_40
if (e.Dialog.Peer is TLPeerChannel)
{
for (var i = 0; i < Items.Count; i++)
{
if (e.Dialog.Peer.GetType() == Items[i].Peer.GetType() &&
e.Dialog.Peer.Id.Value == Items[i].Peer.Id.Value)
{
Items.RemoveAt(i);
Execute.ShowDebugMessage("OnDialogAdded RemoveAt=" + i);
break;
}
}
}
#endif
if (index == -1)
{
Items.Add(dialog);
}
else
{
Items.Insert(index, dialog);
}
Status = Items.Count == 0 || LazyItems.Count == 0 ? string.Empty : Status;
});
}
protected override void OnActivate()
{
if (StateService.DCOption != null)
{
var option = StateService.DCOption;
StateService.DCOption = null;
Execute.ShowDebugMessage("New DCOption=" + option);
}
base.OnActivate();
}
private void UpdateChannels()
{
MTProtoService.GetChannelDialogsAsync(new TLInt(0), new TLInt(100),
results => Execute.BeginOnUIThread(() =>
{
AddChannels(results);
}),
error => Execute.BeginOnUIThread(() =>
{
Execute.ShowDebugMessage("channels.getDialogs error " + error);
}));
}
public void DeleteContact(TLUserBase user)
{
if (user == null)
{
return;
}
MTProtoService.DeleteContactAsync(
user.ToInputUser(),
link => BeginOnUIThread(() => Items.Remove(user)),
error => Execute.ShowDebugMessage("contacts.deleteContact error: " + error));
}
public void GetDHConfig()
{
if (_dhConfig != null)
{
return;
}
_isGettingConfig = true;
MTProtoService.GetDHConfigAsync(new TLInt(0), new TLInt(0),
result =>
{
var dhConfig = result as TLDHConfig;
if (dhConfig == null)
{
return;
}
if (!TLUtils.CheckPrime(dhConfig.P.Data, dhConfig.G.Value))
{
return;
}
var aBytes = new byte[256];
var random = new SecureRandom();
random.NextBytes(aBytes);
var gaBytes = Telegram.Api.Services.MTProtoService.GetGB(aBytes, dhConfig.G, dhConfig.P);
dhConfig.A = TLString.FromBigEndianData(aBytes);
dhConfig.GA = TLString.FromBigEndianData(gaBytes);
_isGettingConfig = false;
Execute.BeginOnUIThread(() =>
{
_dhConfig = dhConfig;
if (_contact != null)
{
UserAction(_contact);
}
});
},
error =>
{
_isGettingConfig = false;
IsWorking = false;
NotifyOfPropertyChange(() => IsNotWorking);
NotifyOfPropertyChange(() => ProgressVisibility);
Execute.ShowDebugMessage("messages.getDhConfig error: " + error);
});
}
public void ResetAccount()
{
BeginOnUIThread(TimeSpan.FromSeconds(0.1), () =>
{
var r = MessageBox.Show(AppResources.ResetMyAccountConfirmation, AppResources.Warning, MessageBoxButton.OKCancel);
if (r != MessageBoxResult.OK)
{
return;
}
IsWorking = true;
MTProtoService.DeleteAccountAsync(
new TLString("Forgot password"),
result => BeginOnUIThread(() =>
{
IsWorking = false;
StateService.RemoveBackEntry = true;
StateService.SentCode = _sentCode;
NavigationService.UriFor <SignUpViewModel>().Navigate();
}),
error => BeginOnUIThread(() =>
{
IsWorking = false;
if (error.TypeEquals("2FA_RECENT_CONFIRM"))
{
MessageBox.Show(AppResources.ResetAccountError, AppResources.Error, MessageBoxButton.OK);
}
else if (error.TypeStarsWith("2FA_CONFIRM_WAIT"))
{
var message = error.Message.ToString().Replace("2FA_CONFIRM_WAIT_", string.Empty);
try
{
var confirmWait = Convert.ToInt32(message);
StateService.ConfirmWait = confirmWait;
StateService.SentCode = _sentCode;
NavigationService.UriFor <ResetAccountViewModel>().Navigate();
}
catch (Exception e)
{
}
}
else
{
Execute.ShowDebugMessage("account.deleteAccount error " + error);
}
}));
});
}
public static void SwitchIdleDetectionMode(bool enabled)
{
#if WINDOWS_PHONE
var mode = enabled ? IdleDetectionMode.Enabled : IdleDetectionMode.Disabled;
try
{
PhoneApplicationService.Current.UserIdleDetectionMode = mode;
}
catch (Exception ex)
{
Execute.ShowDebugMessage("UploadVideoFileManager UserIdleDetectionMode=" + mode + Environment.NewLine + ex);
}
#endif
}
public static void CrossThreadAccess(Action <IsolatedStorageSettings> action)
{
lock (SyncLock)
{
try
{
action(IsolatedStorageSettings.ApplicationSettings);
}
catch (Exception e)
{
Execute.ShowDebugMessage("SettingsHelper.CrossThreadAccess" + e);
}
}
}
private void ChangePhoneNumber()
{
IsWorking = true;
NotifyOfPropertyChange(() => CanSignIn);
var phoneNumber = PhoneCode + PhoneNumber;
_startTime = DateTime.Now;
_showHelpTimer.Start();
MTProtoService.SendChangePhoneCodeAsync(new TLString(phoneNumber),
sentCode => BeginOnUIThread(() =>
{
_showHelpTimer.Stop();
StateService.PhoneNumber = new TLString(phoneNumber);
StateService.PhoneNumberString = string.Format(AppResources.ConfirmMessage, PhoneNumberConverter.Convert(StateService.PhoneNumber));
StateService.PhoneCodeHash = sentCode.PhoneCodeHash;
StateService.PhoneRegistered = new TLBool(false);
StateService.SendCallTimeout = sentCode.SendCodeTimeout;
StateService.ChangePhoneNumber = true;
NavigationService.UriFor <ConfirmViewModel>().Navigate();
IsWorking = false;
NotifyOfPropertyChange(() => CanSignIn);
}),
error => BeginOnUIThread(() =>
{
_lastError = error;
IsWorking = false;
NotifyOfPropertyChange(() => CanSignIn);
if (error.TypeEquals(ErrorType.PHONE_NUMBER_INVALID))
{
MessageBox.Show(AppResources.PhoneNumberInvalidString, AppResources.Error, MessageBoxButton.OK);
}
else if (error.TypeEquals(ErrorType.PHONE_NUMBER_OCCUPIED))
{
MessageBox.Show(string.Format(AppResources.NewNumberTaken, "+" + phoneNumber), AppResources.Error, MessageBoxButton.OK);
}
else if (error.CodeEquals(ErrorCode.FLOOD))
{
MessageBox.Show(AppResources.FloodWaitString + Environment.NewLine + "(" + error.Message + ")", AppResources.Error, MessageBoxButton.OK);
}
else
{
Execute.ShowDebugMessage("account.sendChangePhoneCode error " + error);
}
}));
}
public static byte[] AesCtr(byte[] data, byte[] key, byte[] iv, bool encrypt)
{
var cipher = CipherUtilities.GetCipher("AES/CTR/NOPADDING");
cipher.Init(encrypt, new ParametersWithIV(ParameterUtilities.CreateKeyParameter("AES", key), iv));
var outData = cipher.DoFinal(data);
if (outData.Length != data.Length)
{
Execute.ShowDebugMessage(string.Format("Utils.AesCtr outData.Length!=data.Length outData={0} data={1}", outData.Length, data.Length));
}
return(outData);
}
private static void UpdateMainTile()
{
#if WNS_PUSH_SERVICE
try
{
ToastNotificationManager.History.Clear();
}
catch (Exception ex)
{
Execute.ShowDebugMessage("Clear notifications history exception\n" + ex);
}
try
{
BadgeUpdateManager.CreateBadgeUpdaterForApplication().Clear();
TileUpdateManager.CreateTileUpdaterForApplication().Clear();
}
catch (Exception ex)
{
Execute.ShowDebugMessage("Clear tile exception\n" + ex);
}
#else
var tile = ShellTile.ActiveTiles.FirstOrDefault();
if (tile == null)
{
return;
}
ShellTileData tileData;
#if WP8
tileData = new IconicTileData {
Count = 0, WideContent1 = "", WideContent2 = "", WideContent3 = ""
};
#else
tileData = new StandardTileData {
Count = 0
};
#endif
try
{
tile.Update(tileData);
}
catch (Exception ex)
{
Execute.ShowDebugMessage("Tile.Update exception\n" + ex);
}
#endif
}
public void LogOut()
{
var result = MessageBox.Show(AppResources.LogOutConfirmation, AppResources.Confirm, MessageBoxButton.OKCancel);
if (result != MessageBoxResult.OK)
{
return;
}
Telegram.Logs.Log.Write("SettingsViewModel.LogOut");
PushService.UnregisterDeviceAsync(() =>
MTProtoService.LogOutAsync(logOutResult =>
{
ContactsHelper.DeleteContactsAsync(null);
Execute.BeginOnUIThread(() =>
{
foreach (var activeTile in ShellTile.ActiveTiles)
{
if (activeTile.NavigationUri.ToString().Contains("Action=SecondaryTile"))
{
activeTile.Delete();
}
}
});
//MTProtoService.LogOutTransportsAsync(
// () =>
// {
// },
// errors =>
// {
// });
},
error =>
{
Execute.ShowDebugMessage("account.logOut error " + error);
}));
LogOutCommon(EventAggregator, MTProtoService, UpdateService, CacheService, StateService, PushService, NavigationService);
}
private void UploadAudioFileAsync(bool isLastPart)
{
Execute.BeginOnThreadPool(() =>
{
if (!_isPartReady)
{
return;
}
_isPartReady = false;
var uploadablePart = GetUploadablePart(_fileName, _uploadingLength, _uploadableParts.Count, isLastPart);
if (uploadablePart == null)
{
_isPartReady = true;
return;
}
_uploadableParts.Add(uploadablePart);
_uploadingLength += uploadablePart.Count;
//Execute.BeginOnUIThread(() => VibrateController.Default.Start(TimeSpan.FromSeconds(0.02)));
if (!isLastPart)
{
var mtProtoService = IoC.Get <IMTProtoService>();
mtProtoService.SaveFilePartAsync(_fileId, uploadablePart.FilePart,
TLString.FromBigEndianData(uploadablePart.Bytes),
result =>
{
if (result.Value)
{
uploadablePart.Status = PartStatus.Processed;
}
},
error => Execute.ShowDebugMessage("upload.saveFilePart error " + error));
}
_isPartReady = true;
});
}
private bool PutFile(TLLong fileId, TLInt filePart, byte[] bytes)
{
var manualResetEvent = new ManualResetEvent(false);
var result = false;
_mtProtoService.SaveFilePartAsync(fileId, filePart, TLString.FromBigEndianData(bytes),
savingResult =>
{
result = true;
manualResetEvent.Set();
},
error => Execute.BeginOnThreadPool(TimeSpan.FromSeconds(1.0), () =>
{
Execute.ShowDebugMessage(string.Format("upload.saveBigFilePart part={0}, count={1} error\n", filePart.Value, bytes.Length) + error);
manualResetEvent.Set();
}));
manualResetEvent.WaitOne();
return(result);
}
private bool PutFile(long fileId, int filePart, int fileTotalPars, byte[] bytes)
{
var manualResetEvent = new ManualResetEvent(false);
var result = false;
_mtProtoService.SaveFilePartCallback(fileId, filePart, bytes,
savingResult =>
{
result = true;
manualResetEvent.Set();
},
error => Execute.BeginOnThreadPool(TimeSpan.FromSeconds(1.0), () =>
{
Execute.ShowDebugMessage(string.Format("upload.saveFilePart part={0}, bytesCount={1} error\n", filePart, bytes.Length) + error);
manualResetEvent.Set();
}));
manualResetEvent.WaitOne();
return(result);
}
public void GetContactsAsync()
{
var contactIds = string.Join(",", Items.Select(x => x.Index).Union(new [] { StateService.CurrentUserId }).OrderBy(x => x));
var hash = MD5Core.GetHash(contactIds);
var hashString = BitConverter.ToString(hash).Replace("-", string.Empty).ToLower();
IsWorking = true;
MTProtoService.GetContactsAsync(new TLString(hashString),
result =>
{
IsWorking = false;
var contacts = result as TLContacts;
if (contacts != null)
{
InsertContacts(contacts.Users, false);
}
},
error =>
{
IsWorking = false;
Execute.ShowDebugMessage("contacts.getContacts error: " + error);
});
}
public static void DeleteContactsAsync(System.Action callback)
{
#if WP8
Execute.BeginOnThreadPool(
async() =>
{
var store = await ContactStore.CreateOrOpenAsync();
try
{
await store.DeleteAsync();
FileUtils.Delete(_delayedContactsSyncRoot, Constants.DelayedContactsFileName);
}
catch (Exception ex)
{
Execute.ShowDebugMessage("store.DeleteAsync ex " + ex);
}
finally
{
callback.SafeInvoke();
}
});
#endif
}
public static void SendEncrypted(TLEncryptedChat chat, TLObject obj, IMTProtoService mtProtoService, ICacheService cacheService)
{
var message = GetDecryptedMessage(obj);
if (message == null)
{
return;
}
cacheService.SyncDecryptedMessage(message, chat,
cachedMessage =>
{
mtProtoService.SendEncryptedAsync(new TLInputEncryptedChat {
AccessHash = chat.AccessHash, ChatId = chat.Id
}, message.RandomId, TLUtils.EncryptMessage(obj, chat),
result => Execute.BeginOnUIThread(() =>
{
message.Status = MessageStatus.Confirmed;
message.NotifyOfPropertyChange(() => message.Status);
cacheService.SyncSendingDecryptedMessage(chat.Id, result.Date, message.RandomId, m => { });
}),
() =>
{
//message.Date = result.Date;
message.Status = MessageStatus.Confirmed;
message.NotifyOfPropertyChange(() => message.Status);
},
error =>
{
message.Status = MessageStatus.Failed;
message.NotifyOfPropertyChange(() => message.Status);
Execute.ShowDebugMessage("messages.sendEncrypted error " + error);
});
});
}
public void ResetAccount()
{
var r = MessageBox.Show(AppResources.ResetMyAccountConfirmation, AppResources.Warning, MessageBoxButton.OKCancel);
if (r != MessageBoxResult.OK)
{
return;
}
IsWorking = true;
MTProtoService.DeleteAccountAsync(new TLString("Forgot password"),
result => BeginOnUIThread(() =>
{
IsWorking = false;
StateService.RemoveBackEntry = true;
NavigationService.UriFor <SignUpViewModel>().Navigate();
}),
error =>
{
IsWorking = false;
Execute.ShowDebugMessage("account.deleteAccount error " + error);
});
}
public void RecoverPassword()
{
if (_passwordBase == null)
{
return;
}
if (IsWorking)
{
return;
}
HasError = false;
Error = string.Empty;
IsWorking = true;
MTProtoService.RecoverPasswordAsync(new TLString(Code),
auth => BeginOnUIThread(() =>
{
IsWorking = false;
if (!_passwordBase.IsAuthRecovery)
{
MTProtoService.GetPasswordAsync(
passwordResult => BeginOnUIThread(() =>
{
MessageBox.Show(AppResources.PasswordDeactivated, AppResources.AppName, MessageBoxButton.OK);
StateService.RemoveBackEntry = true;
StateService.Password = passwordResult;
NavigationService.UriFor <PasswordViewModel>().Navigate();
}),
error2 =>
{
Execute.ShowDebugMessage("account.getPassword error " + error2);
});
}
else
{
_passwordBase.IsAuthRecovery = false;
#if LOG_REGISTRATION
TLUtils.WriteLog("auth.recoverPassword result " + auth);
TLUtils.WriteLog("TLUtils.IsLogEnabled=false");
#endif
TLUtils.IsLogEnabled = false;
TLUtils.LogItems.Clear();
var result = MessageBox.Show(
AppResources.ConfirmPushMessage,
AppResources.ConfirmPushTitle,
MessageBoxButton.OKCancel);
if (result != MessageBoxResult.OK)
{
Notifications.Disable();
}
else
{
Notifications.Enable();
}
ConfirmViewModel.UpdateNotificationsAsync(MTProtoService, StateService);
MTProtoService.SetInitState();
StateService.CurrentUserId = auth.User.Index;
StateService.FirstRun = true;
SettingsHelper.SetValue(Constants.IsAuthorizedKey, true);
ShellViewModel.Navigate(NavigationService);
}
}),
error => BeginOnUIThread(() =>
{
IsWorking = false;
var messageBuilder = new StringBuilder();
//messageBuilder.AppendLine(AppResources.Error);
//messageBuilder.AppendLine();
messageBuilder.AppendLine("Method: account.recoveryPassword");
messageBuilder.AppendLine("Result: " + error);
if (TLRPCError.CodeEquals(error, ErrorCode.FLOOD))
{
HasError = true;
Error = AppResources.FloodWaitString;
Execute.BeginOnUIThread(() => MessageBox.Show(AppResources.FloodWaitString, AppResources.Error, MessageBoxButton.OK));
}
else if (TLRPCError.CodeEquals(error, ErrorCode.INTERNAL))
{
HasError = true;
Error = AppResources.ServerError;
Execute.BeginOnUIThread(() => MessageBox.Show(messageBuilder.ToString(), AppResources.ServerError, MessageBoxButton.OK));
}
else if (TLRPCError.CodeEquals(error, ErrorCode.BAD_REQUEST))
{
if (TLRPCError.TypeEquals(error, ErrorType.CODE_EMPTY))
{
HasError = true;
Error = string.Format("{0} {1}", error.Code, error.Message);
Execute.BeginOnUIThread(() => MessageBox.Show(messageBuilder.ToString(), AppResources.Error, MessageBoxButton.OK));
}
else if (TLRPCError.TypeEquals(error, ErrorType.CODE_INVALID))
{
HasError = true;
Error = string.Format("{0} {1}", error.Code, error.Message);
Execute.BeginOnUIThread(() => MessageBox.Show(messageBuilder.ToString(), AppResources.Error, MessageBoxButton.OK));
}
else if (TLRPCError.TypeEquals(error, ErrorType.PASSWORD_EMPTY))
{
HasError = true;
Error = string.Format("{0} {1}", error.Code, error.Message);
Execute.BeginOnUIThread(() => MessageBox.Show(messageBuilder.ToString(), AppResources.Error, MessageBoxButton.OK));
}
else if (TLRPCError.TypeEquals(error, ErrorType.PASSWORD_RECOVERY_NA))
{
HasError = true;
Error = AppResources.EmailInvalid;
Execute.BeginOnUIThread(() => MessageBox.Show(AppResources.EmailInvalid, AppResources.Error, MessageBoxButton.OK));
}
else if (TLRPCError.TypeEquals(error, ErrorType.PASSWORD_RECOVERY_EXPIRED))
{
HasError = true;
Error = string.Format("{0} {1}", error.Code, error.Message);
Execute.BeginOnUIThread(() => MessageBox.Show(AppResources.EmailInvalid, AppResources.Error, MessageBoxButton.OK));
}
else
{
HasError = true;
Error = string.Format("{0} {1}", error.Code, error.Message);
Execute.BeginOnUIThread(() => MessageBox.Show(messageBuilder.ToString(), AppResources.Error, MessageBoxButton.OK));
}
}
else
{
HasError = true;
Error = string.Empty;
Execute.ShowDebugMessage("account.recoveryPassword error " + error);
}
}));
}