private async void EmpIdNextButton_Click(object sender, RoutedEventArgs e)
{
EmpIdNextButton.IsEnabled = false;
ProgressRingPassword.IsActive = true;
ProgressRingPassword.Visibility = Visibility.Visible;
await EmployeeSync.GetLoginEmployeesAsnc(EmployeeLoginCharacters, EmployeeCharacters[0].EmpId, EmppasswordBox.Password);
if (EmployeeLoginCharacters.Count > 0)
{
var localObjectStorageHelper = new LocalObjectStorageHelper();
// Read and Save with simple objects for login page
string keySimpleObject = "47";
localObjectStorageHelper.Save(keySimpleObject, EmployeeCharacters[0].EmpId);
if (EmployeeLoginCharacters[0].EmpGroup == 1)
{
Frame.Navigate(typeof(NonAdminPage));
}
else if (EmployeeLoginCharacters[0].EmpGroup == 2)
{
Frame.Navigate(typeof(LeaveListPageAdmin));
}
//
}
else if (EmployeeLoginCharacters.Count == 0)
{
NotFindErrorTextBlock.Visibility = Visibility.Visible;
}
ProgressRingPassword.IsActive = false;
ProgressRingPassword.Visibility = Visibility.Collapsed;
EmpIdNextButton.IsEnabled = true;
}
public static async void EnsureCacheLatest()
{
var settingsStorage = new LocalObjectStorageHelper();
var onlineDocsSHA = await GetDocsSHA();
var cacheSHA = settingsStorage.Read <string>(_cacheSHAKey);
bool outdatedCache = onlineDocsSHA != null && cacheSHA != null && onlineDocsSHA != cacheSHA;
bool noCache = onlineDocsSHA != null && cacheSHA == null;
if (outdatedCache || noCache)
{
// Delete everything in the Cache Folder. Could be Pre 3.0.0 Cache data.
foreach (var item in await ApplicationData.Current.LocalCacheFolder.GetItemsAsync())
{
try
{
await item.DeleteAsync(StorageDeleteOption.Default);
}
catch
{
}
}
// Update Cache Version info.
settingsStorage.Save(_cacheSHAKey, onlineDocsSHA);
}
}
private async Task WirelessLogin()
{
var response = await NetHelper.LoginAsync(currentAccount.Username, currentAccount.Password);
if (response == "Login is successful.")
{
SetLoginButtonAnimation();
}
else if (response == "IP has been online, please logout.")
{
SetLoginButton();
}
else if (response == "E2532: The two authentication interval cannot be less than 3 seconds.")
{
await Task.Delay(3500);
await LoginNetworkIfFavoriteAsync();
}
else if (response == "E2553: Password is error.")
{
CredentialHelper.RemoveAccount(App.Accounts[0].Username);
App.Accounts.RemoveAt(0);
var localHelper = new LocalObjectStorageHelper();
await localHelper.SaveFileAsync("Accounts", App.Accounts);
var rootFrame = Window.Current.Content as Frame;
rootFrame.Navigate(typeof(WelcomePage));
}
}
public SettingsPage()
{
this.InitializeComponent();
DataContext = this;
var localHelper = new LocalObjectStorageHelper();
if (localHelper.KeyExists("BalanceThreshold"))
{
BalanceSlider.Value = localHelper.Read("BalanceThreshold", 5);
}
else
{
BalanceSlider.Value = 5;
}
if (localHelper.KeyExists("IsLowBalanceAlertEnabled"))
{
LowBalanceAlertToggleSwitch.IsOn = localHelper.Read("IsLowBalanceAlertEnabled", true);
}
else
{
LowBalanceAlertToggleSwitch.IsOn = true;
}
var packageVersion = Package.Current.Id.Version;
Version = String.Format("{0}.{1}.{2}.{3}", packageVersion.Major, packageVersion.Minor, packageVersion.Build, packageVersion.Revision);
}
public VideoPlayRequestBridgeToPlayer(
IMessenger messenger,
AppearanceSettings appearanceSettings,
Lazy <AppWindowSecondaryViewPlayerManager> secondaryPlayerViewManager,
Lazy <PrimaryViewPlayerManager> primaryViewPlayerManager,
LocalObjectStorageHelper localObjectStorageHelper,
QueuePlaylist queuePlaylist,
NicoVideoProvider nicoVideoProvider,
NicoLiveProvider nicoLiveProvider,
PlaylistItemsSourceResolver playlistItemsSourceResolver
)
{
_messenger = messenger;
_appearanceSettings = appearanceSettings;
__secondaryPlayerManager = secondaryPlayerViewManager;
__primaryViewPlayerManager = primaryViewPlayerManager;
_localObjectStorage = localObjectStorageHelper;
_queuePlaylist = queuePlaylist;
_nicoVideoProvider = nicoVideoProvider;
_nicoLiveProvider = nicoLiveProvider;
_playlistItemsSourceResolver = playlistItemsSourceResolver;
_messenger.Register <VideoPlayRequestMessage>(this);
_messenger.Register <PlayerPlayLiveRequestMessage>(this);
_messenger.Register <ChangePlayerDisplayViewRequestMessage>(this);
}
private async Task LoadCachedStatusAsync()
{
var localHelper = new LocalObjectStorageHelper();
Status status = null;
if (await localHelper.FileExistsAsync("ConnectionStatus"))
{
status = await localHelper.ReadFileAsync <Status>("ConnectionStatus");
}
if (status != null)
{
ConnectionStatus.Usage = status.Usage;
ConnectionStatus.Balance = status.Balance;
ConnectionStatus.Username = status.Username;
ConnectionStatus.Session = status.Session;
}
if (await localHelper.FileExistsAsync("DetailUsage"))
{
DetailUsage = await localHelper.ReadFileAsync <List <UsageWithDate> >("DetailUsage");
}
if (DetailUsage != null)
{
(DetailUsageChart.Series[0] as LineSeries).ItemsSource = DetailUsage;
SetChartAxis();
if (this.Resources["FadeIn_Chart"] is Storyboard fadeIn)
{
fadeIn.Begin();
}
}
}
public static async Task <int> RestoreLegacyLocalMylistGroups(LocalMylistManager manager)
{
try
{
var localStorage = new LocalObjectStorageHelper();
var isMigrateLocalMylist = localStorage.Read("is_migrate_local_mylist_0_17_0", false);
if (!isMigrateLocalMylist)
{
var items = await LoadLegacyLocalMylistGroups();
foreach (var regacyItem in items)
{
manager.Mylists.Add(new LocalMylistGroup(regacyItem.Id, regacyItem.Label, new ObservableCollection <string>(regacyItem.PlaylistItems.Select(x => x.ContentId))));
}
localStorage.Save("is_migrate_local_mylist_0_17_0", true);
return(items.Count);
}
else
{
return(0);
}
}
catch
{
return(0);
}
}
protected async override void OnNavigatedTo(NavigationEventArgs e)
{
try
{
var localSettings = Windows.Storage.ApplicationData.Current.LocalSettings;
user = localSettings.Values["user"].ToString();
pass = localSettings.Values["pass"].ToString();
credentialEnterned = true;
}
catch
{
refershButton.IsEnabled = false;
return;
}
if (credentialEnterned)
{
refershButton.IsEnabled = true;
}
var helper = new LocalObjectStorageHelper();
if (await helper.FileExistsAsync(keyLargeObject))
{
var dataList = await helper.ReadFileAsync <DataList>(keyLargeObject);
dataLimit.Text = dataList.planList[0].ToString();
dataStartDate.Text = dataList.planList[1].ToString();
dataEndDate.Text = dataList.planList[2].ToString();
dataTime.Text = dataList.usageList[0].ToString();
dataUploaded.Text = dataList.usageList[1].ToString();
dataDownloaded.Text = dataList.usageList[2].ToString();
dataTotal.Text = dataList.usageList[3].ToString();
}
}
private async void RootPage_Loaded(object sender, RoutedEventArgs e)
{
var localHelper = new LocalObjectStorageHelper();
string oldImgaeUri = null;
if (localHelper.KeyExists("BackgroundImage"))
{
oldImgaeUri = localHelper.Read <string>("BackgroundImage");
}
if (oldImgaeUri != null)
{
OldBackgroundImage.Source = await ImageCache.Instance.GetFromCacheAsync(new Uri(oldImgaeUri));
}
var imageSource = await AssetsHelper.GetBingWallpaperAsync();
if (imageSource != null)
{
NewBackgroundImage.Source = new BitmapImage(imageSource);
localHelper.Save("BackgroundImage", imageSource.OriginalString);
}
if (imageSource != null)
{
if (this.Resources["FadeIn_Image"] is Storyboard fadeIn)
{
fadeIn.Begin();
}
}
}
private async void Init()
{
LocalObjectStorageHelper LocalObjectStorageHelper = new LocalObjectStorageHelper();
if (!LocalObjectStorageHelper.KeyExists("rules"))
{
StorageFile JsonRules = await StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appx:///Assets/rules.json"));
string StringRules = await FileIO.ReadTextAsync(JsonRules);
Rules = JsonConvert.DeserializeObject <Rules>(StringRules);
LocalObjectStorageHelper.Save("rules", Rules);
}
else
{
Rules = LocalObjectStorageHelper.Read("rules", Rules);
}
CoreApplication.GetCurrentView().TitleBar.ExtendViewIntoTitleBar = true;
var TitleBar = ApplicationView.GetForCurrentView().TitleBar;
TitleBar.BackgroundColor = Colors.Transparent;
TitleBar.ButtonBackgroundColor = Colors.Transparent;
TitleBar.ButtonInactiveForegroundColor = Colors.Transparent;
TitleBar.ButtonInactiveBackgroundColor = Colors.Transparent;
MainFrame.Navigate(typeof(ShellPage));
}
private void LowBalanceAlertToggleSwitchToggled(object sender, RoutedEventArgs e)
{
if (sender is ToggleSwitch toggleSwitch)
{
var localHelper = new LocalObjectStorageHelper();
localHelper.Save("IsLowBalanceAlertEnabled", toggleSwitch.IsOn);
}
}
private void Slider_ValueChanged(object sender, RoutedEventArgs e)
{
if (sender is Slider slider)
{
var localHelper = new LocalObjectStorageHelper();
localHelper.Save("BalanceThreshold", slider.Value);
}
}
private void StartObserveDataChanged()
{
DataChangedDisposable.Disposable = Observable.Merge(DocumentsSource.CollectionChangedAsObservable().ToUnit(),
DocumentsSource.ObserveElementObservableProperty(x => x.Title).ToUnit(),
DocumentsSource.ObserveElementObservableProperty(x => x.Content).ToUnit())
.Throttle(TimeSpan.FromSeconds(5))
.Subscribe(async _ => await LocalObjectStorageHelper.SaveFileAsync("docs.json", DocumentsSource.ToArray()));
}
protected override async void OnLaunched(LaunchActivatedEventArgs e)
{
var localHelper = new LocalObjectStorageHelper();
FavoriteNetworks = new ObservableCollection <Network>();
Accounts = new ObservableCollection <Account>();
if (await localHelper.FileExistsAsync("Networks"))
{
FavoriteNetworks = await localHelper.ReadFileAsync <ObservableCollection <Network> >("Networks");
}
if (FavoriteNetworks == null)
{
FavoriteNetworks = new ObservableCollection <Network>();
}
if (await localHelper.FileExistsAsync("Accounts"))
{
Accounts = await localHelper.ReadFileAsync <ObservableCollection <Account> >("Accounts");
}
if (Accounts == null)
{
Accounts = new ObservableCollection <Account>();
}
CheckOnLaunch();
if (!(Window.Current.Content is Frame rootFrame))
{
rootFrame = new Frame();
rootFrame.NavigationFailed += OnNavigationFailed;
if (e.PreviousExecutionState == ApplicationExecutionState.Terminated)
{
}
Window.Current.Content = rootFrame;
}
if (e.PrelaunchActivated == false)
{
if (rootFrame.Content == null)
{
if (Accounts.Count() == 0)
{
rootFrame.Navigate(typeof(WelcomePage), e.Arguments);
}
else
{
rootFrame.Navigate(typeof(RootPage), e.Arguments);
}
}
Window.Current.Activate();
ExtendAcrylicIntoTitleBar();
}
}
public WatchItLater(
IScheduler scheduler,
SubscriptionManager subscriptionManager,
Models.Provider.LoginUserHistoryProvider loginUserDataProvider,
UseCase.Playlist.PlaylistAggregateGetter playlistAggregate
)
{
Scheduler = scheduler;
SubscriptionManager = subscriptionManager;
LoginUserDataProvider = loginUserDataProvider;
_playlistAggregate = playlistAggregate;
Refresh = new AsyncReactiveCommand();
Refresh.Subscribe(async() => await Update())
.AddTo(_disposables);
{
var localObjectStorageHelper = new LocalObjectStorageHelper();
IsAutoUpdateEnabled = localObjectStorageHelper.Read(nameof(IsAutoUpdateEnabled), true);
AutoUpdateInterval = localObjectStorageHelper.Read(nameof(AutoUpdateInterval), DefaultAutoUpdateInterval);
}
this.ObserveProperty(x => x.IsAutoUpdateEnabled)
.Subscribe(x =>
{
var localObjectStorageHelper = new LocalObjectStorageHelper();
localObjectStorageHelper.Save(nameof(IsAutoUpdateEnabled), IsAutoUpdateEnabled);
})
.AddTo(_disposables);
this.ObserveProperty(x => x.AutoUpdateInterval)
.Subscribe(x =>
{
var localObjectStorageHelper = new LocalObjectStorageHelper();
localObjectStorageHelper.Save(nameof(AutoUpdateInterval), AutoUpdateInterval);
})
.AddTo(_disposables);
Observable.Merge(new[]
{
this.ObserveProperty(x => x.IsAutoUpdateEnabled).ToUnit(),
this.ObserveProperty(x => x.AutoUpdateInterval).ToUnit()
})
.Subscribe(x =>
{
if (IsAutoUpdateEnabled)
{
StartOrResetAutoUpdate();
}
else
{
StopAutoUpdate();
}
})
.AddTo(_disposables);
App.Current.Suspending += Current_Suspending;
App.Current.Resuming += Current_Resuming;
}
static ViewModelLocator()
{
ServiceLocator.SetLocatorProvider(() => SimpleIoc.Default);
// Register Services
if (!SimpleIoc.Default.IsRegistered <INavigationService>())
{
var navigationService = CreateNavigationService();
SimpleIoc.Default.Register(() => navigationService);
}
if (!SimpleIoc.Default.IsRegistered <IReactiveTVShowTimeApiService>())
{
var tvshowtimeApiService = new ReactiveTVShowTimeApiService();
SimpleIoc.Default.Register <IReactiveTVShowTimeApiService>(() => tvshowtimeApiService);
}
if (!SimpleIoc.Default.IsRegistered <IHamburgerMenuService>())
{
var hamburgerMenuService = new HamburgerMenuService();
SimpleIoc.Default.Register <IHamburgerMenuService>(() => hamburgerMenuService);
}
if (!SimpleIoc.Default.IsRegistered <IObjectStorageHelper>())
{
var localObjectStorageHelper = new LocalObjectStorageHelper();
SimpleIoc.Default.Register <IObjectStorageHelper>(() => localObjectStorageHelper, ServiceLocatorConstants.LocalObjectStorageHelper);
var roamingObjectStorageHelper = new RoamingObjectStorageHelper();
SimpleIoc.Default.Register <IObjectStorageHelper>(() => roamingObjectStorageHelper, ServiceLocatorConstants.RoamingObjectStorageHelper);
}
if (!SimpleIoc.Default.IsRegistered <IEventService>())
{
var eventService = new EventService();
SimpleIoc.Default.Register <IEventService>(() => eventService);
}
if (!SimpleIoc.Default.IsRegistered <IToastNotificationService>())
{
var toastNotificationService = new ToastNotificationService();
SimpleIoc.Default.Register <IToastNotificationService>(() => toastNotificationService);
}
// Register ViewModels
SimpleIoc.Default.Register <AgendaViewModel>();
SimpleIoc.Default.Register <CollectionViewModel>();
SimpleIoc.Default.Register <EpisodeViewModel>();
SimpleIoc.Default.Register <ExploreViewModel>();
SimpleIoc.Default.Register <FeedbackViewModel>();
SimpleIoc.Default.Register <LoginViewModel>();
SimpleIoc.Default.Register <MainViewModel>();
SimpleIoc.Default.Register <SettingsViewModel>();
SimpleIoc.Default.Register <ShowViewModel>();
SimpleIoc.Default.Register <ToWatchViewModel>();
SimpleIoc.Default.Register <UpcomingViewModel>();
}
public static void Save()
{
var localObjectStorageHelper = new LocalObjectStorageHelper();
localObjectStorageHelper.Save <int>("LaunchCount", launchCount);
localObjectStorageHelper.Save <List <Drink> >("PersonalDrinks", PersonalList);
localObjectStorageHelper.Save <List <Drink> >("FavoriteDrinks", FavoritesList);
localObjectStorageHelper.Save <List <string> >("DefaultSelectedIngredients", DefaultSelectedIngredients);
}
public async Task RunAsync(IBackgroundTaskInstance taskInstance)
{
// Create services
var localObjectStorageHelper = new LocalObjectStorageHelper();
// Check if notifications are enabled
var notificationsEnabled = localObjectStorageHelper.Read(LocalStorageConstants.EnableNewEpisodeNotificationsOption, true);
if (!notificationsEnabled)
{
return;
}
// Retrieve token to access API
string token = RetrieveToken();
// Create services (2)
var tvshowtimeApiService = new TVShowTimeApiService(token);
// Retrieve episodes from the agenda (episodes that will be aired soon)
var agendaResponse = await tvshowtimeApiService.GetAgendaAsync();
if (agendaResponse.Result == "OK")
{
// Retrieve list of episodes already notified
var newEpisodesIdsNotified = new List <long>();
if (await localObjectStorageHelper.FileExistsAsync(LocalStorageConstants.NewEpisodesIdsNotified))
{
newEpisodesIdsNotified = await localObjectStorageHelper
.ReadFileAsync(LocalStorageConstants.NewEpisodesIdsNotified, new List <long>());
}
var episodesInAgenda = agendaResponse.Episodes;
foreach (var episode in episodesInAgenda)
{
var timeSpanDiff = episode.AirDate.Value.Subtract(DateTime.Now.ToUniversalTime());
if (episode.AirTime.HasValue)
{
timeSpanDiff = timeSpanDiff
.Add(TimeSpan.FromHours(episode.AirTime.Value.DateTime.Hour));
timeSpanDiff = timeSpanDiff
.Add(TimeSpan.FromMinutes(episode.AirTime.Value.DateTime.Minute));
}
if (newEpisodesIdsNotified.All(id => episode.Id != id) &&
timeSpanDiff.TotalDays <= 0)
{
// Create Toast notification when a new episode is out
GenerateToastNotification(episode);
newEpisodesIdsNotified.Add(episode.Id);
}
}
// Save the updated list in local storage
await localObjectStorageHelper.SaveFileAsync(LocalStorageConstants.NewEpisodesIdsNotified, newEpisodesIdsNotified);
}
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
LocalObjectStorageHelper localObjectStorage = new LocalObjectStorageHelper();
if (localObjectStorage.KeyExists("passenger"))
{
Passenger = localObjectStorage.Read <Passenger>("passenger");
}
ViewModel.Connect(Passenger.Email);
}
public SetupDownloadDialog()
{
InitializeComponent();
var helper = new LocalObjectStorageHelper();
EnableBackgroundDownloading.IsOn = helper.Read(App.EnableDownload, false);
Loaded += SetupDownloadDialog_Loaded;
}
private async void passwordResetButton_Click(object sender, RoutedEventArgs e)
{
if(string.IsNullOrEmpty(passwordResetBox.Password)||string.IsNullOrWhiteSpace(passwordResetBox.Password))
{
var messageDialog = new MessageDialog("Type password before you click on change");
await messageDialog.ShowAsync();
}
else
{
try
{
passwordResetButton.IsEnabled = false;
ProgressRingPasswordReset.IsActive = true;
ProgressRingPasswordReset.Visibility = Visibility.Visible;
string empId = "";
string newPassword = "";
var localObjectStorageHelper = new LocalObjectStorageHelper();
// Read and Save with simple objects
string keySimpleObject = "47";
if (localObjectStorageHelper.KeyExists(keySimpleObject))
{
empId = localObjectStorageHelper.Read<string>(keySimpleObject);
}
newPassword = passwordResetBox.Password;
await EmployeeSync.GetAllEmployeesAsnc(EmployeeCharacters, empId);
string condition = EmployeeCharacters[0]._id.Oid.ToString();
string setValue = String.Format("{{\"$set\":{{\"Password\":\"{0}\"}}}}", newPassword);
await EmployeeSync.EmpPasswordPutAsync(condition, setValue);
var messageDialog = new MessageDialog("Password changed");
await messageDialog.ShowAsync();
passwordResetButton.IsEnabled = true;
ProgressRingPasswordReset.Visibility = Visibility.Collapsed;
ProgressRingPasswordReset.IsActive = false;
passwordResetBox.Password = "";
}
catch
{
var messageDialog = new MessageDialog("Password not changed !Error ");
await messageDialog.ShowAsync();
ProgressRingPasswordReset.Visibility = Visibility.Collapsed;
ProgressRingPasswordReset.IsActive = false;
passwordResetButton.IsEnabled = true;
}
}
}
public static async Task <T> Load <T>(string filename, T list)
{
var helper = new LocalObjectStorageHelper();
if (await helper.FileExistsAsync(filename))
{
return(await helper.ReadFileAsync <T>(filename));
}
return(list);
}
public static void Load()
{
try
{
var temp = new LocalObjectStorageHelper().Read <Settings>(Keys.Settings);
if (temp != null)
{
Settings = temp;
}
}
catch { }
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
Contact = e.Parameter as Passenger;
LocalObjectStorageHelper localObjectStorage = new LocalObjectStorageHelper();
if (localObjectStorage.KeyExists("passenger"))
{
Passenger = localObjectStorage.Read <Passenger>("passenger");
}
ViewModel.Connect(Passenger.Email, Contact.Email);
ViewModel.SetMessages(Contact.Email);
}
public async Task <Passenger> GetLoggedInPassengerAsync()
{
var json = await client.GetStringAsync(new Uri("http://localhost:5000/api/passenger/"));
var passenger = JsonConvert.DeserializeObject <Passenger>(json);
LocalObjectStorageHelper localObjectStorage = new LocalObjectStorageHelper();
localObjectStorage.Save("passenger", passenger);
return(passenger);
}
private async Task <object> storeAmazonItemsAsync()
{
/*
* StorageFile sampleFile = await Windows.Storage.ApplicationData.Current.LocalFolder.CreateFileAsync("AmazonItems.txt", CreationCollisionOption.ReplaceExisting);
* await Windows.Storage.FileIO.WriteTextAsync(sampleFile, JsonConvert.SerializeObject(AmazonItems));
*/
var helper = new LocalObjectStorageHelper();
await helper.SaveFileAsync("AmazonItems", AmazonItems);
return(null);
}
public MainPage()
{
this.InitializeComponent();
_stravaService = new StravaService();
_loginService = new LoginService(_stravaService);
DataContext = new MainViewModel(_stravaService);
var storageHelper = new LocalObjectStorageHelper();
if (storageHelper.KeyExists(StorageKeys.ACCESSTOKEN))
{
_stravaService.AccessToken = storageHelper.Read <string>(StorageKeys.ACCESSTOKEN);
}
}
private async Task GetUsageChartSourceAsync()
{
await UseregHelper.LoginAsync(currentAccount.Username, currentAccount.Password);
DetailUsage = await UseregHelper.GetDetailUsageForChart();
if (DetailUsage != null)
{
var localHelper = new LocalObjectStorageHelper();
await localHelper.SaveFileAsync("DetailUsage", DetailUsage);
(DetailUsageChart.Series[0] as LineSeries).ItemsSource = DetailUsage;
SetChartAxis();
}
}
private async Task WiredLogin(Windows.Security.Credentials.PasswordCredential credential)
{
var response = await AuthHelper.LoginAsync(4, currentAccount.Username, credential.Password);
if (response == null)
{
return;
}
if (response.Contains("login_ok"))
{
SetLoginButtonAnimation();
await GetConnectionStatusAsync();
var response6 = await AuthHelper.LoginAsync(6, currentAccount.Username, credential.Password);
if (response6 != null && response6.Contains("login_error"))
{
await Task.Delay(10100);
await AuthHelper.LoginAsync(6, currentAccount.Username, credential.Password);
}
}
else if (response == "ip_already_online_error")
{
SetLoginButton();
}
else if (response == "not_online_error")
{
await WirelessLogin();
}
else if (response.Contains("login_error"))
{
await Task.Delay(10100);
await LoginNetworkIfFavoriteAsync();
}
else
{
CredentialHelper.RemoveAccount(App.Accounts[0].Username);
App.Accounts.RemoveAt(0);
var localHelper = new LocalObjectStorageHelper();
await localHelper.SaveFileAsync("Accounts", App.Accounts);
var rootFrame = Window.Current.Content as Frame;
rootFrame.Navigate(typeof(WelcomePage));
}
}
protected async override void OnNavigatedTo(NavigationEventArgs e)
{
string LeaveType = (string)e.Parameter;
string empId = "";
var localObjectStorageHelper = new LocalObjectStorageHelper();
// Read and Save with simple objects
string keySimpleObject = "47";
if (localObjectStorageHelper.KeyExists(keySimpleObject))
{
empId = localObjectStorageHelper.Read <string>(keySimpleObject);
}
await LeaveTransactionGetPostPut.GetLeaveTransactionAsnc(LeaveTransactions, empId, LeaveType);
}
