public static async Task RefreshEbooksAsync()
        {
            await _ebooksAsyncLock.WaitAsync();

            try
            {
                var credentials = CredentialsService.GetProviderCredentials();

                foreach (var credential in credentials)
                {
                    var provider = EbookProviderService.GetProvider(credential);

                    Ebook[] ebooks;

                    try
                    {
                        ebooks = await provider.GetEbooksAsync();
                    }
                    catch
                    {
                        await provider.AuthenticateAsync(credential);

                        ebooks = await provider.GetEbooksAsync();
                    }

                    await EbookStorage.SaveEbooksAsync(ebooks);

                    await UIThread.RunAsync(() =>
                    {
                        // TODO: Support for multiple providers of the same books
                        // remove
                        {
                            var oldEbooks = Ebooks.Where(eb => !ebooks.Select(ebb => ebb.Isbn).Contains(eb.Isbn)).ToArray();
                            foreach (var oldEbook in oldEbooks)
                            {
                                Ebooks.Remove(oldEbook);
                            }
                        }

                        // Add
                        foreach (var ebook in ebooks)
                        {
                            var existing = Ebooks.FirstOrDefault(eb => eb.Isbn == ebook.Isbn);

                            if (existing == null)
                            {
                                Ebooks.Add(ebook);
                            }
                        }
                    });
                }
            }
            finally
            {
                _ebooksAsyncLock.Release();
            }
        }
Beispiel #2
0
        public static async Task <Ebook[]> LoadEbooksAsync()
        {
            var ebooks = await EbookStorage.GetEbooksAsync();

            if (ebooks != null)
            {
                // One place to do it.
                foreach (var ebook in ebooks.Where(eb => eb.Expires < DateTime.Today))
                {
                    await PageStorage.DeleteEbookAsync(ebook);

                    // Maybe unpin, or change the tiles image.
                }
            }

            return(ebooks);
        }
Beispiel #3
0
        public async void Run(IBackgroundTaskInstance taskInstance)
        {
            var deferral = taskInstance.GetDeferral();

            // Credentials from settings to PasswordVault
            {
                IPropertySet LocalSettings = ApplicationData.Current.LocalSettings.Values;
                IPropertySet RoamingSettings = ApplicationData.Current.RoamingSettings.Values;

                if (LocalSettings.ContainsKey("username"))
                {
                    var vault = new PasswordVault();
                    vault.Add(new PasswordCredential("Hermods Novo", (string)LocalSettings["username"], (string)LocalSettings["password"]));

                    LocalSettings.Remove("username");
                    LocalSettings.Remove("password");
                    try
                    {
                        RoamingSettings.Remove("username");
                        RoamingSettings.Remove("password");
                    }
                    catch { }
                }
            }

            // From 1.0.5.0
            {
                const string FILE_NAME = "ebooksList.json";

                StorageFolder StorageFolder = ApplicationData.Current.LocalFolder;

                var hermodsNovoEbooks = await StorageFolder.ContainsFileAsync(FILE_NAME) ? await StorageFolder.GetObjectAsync<HermodsNovoEbook[]>(FILE_NAME) : new HermodsNovoEbook[0];

                if (hermodsNovoEbooks.Any(hne => hne.Url != null))
                {
                    var ebooks = hermodsNovoEbooks.Select(HermodsNovoEbookProvider.ConvertToEbook).ToArray();
                    await EbookStorage.SaveEbooksAsync(ebooks);
                }
            }

            deferral.Complete();
        }