async Task ExecuteLoadItemsCommand()
{
if (IsBusy)
{
return;
}
IsBusy = true;
try
{
Books.Clear();
var books = await App.Database.GetBooksAsync();
foreach (var book in books)
{
Books.Add(book);
}
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
finally
{
IsBusy = false;
}
}
public async void GetData(int pageIndex)
{
PageIndex = pageIndex;
var url = SoduPageValue.GetRankListPage(pageIndex.ToString());
var html = await GetHtmlData(url, true, true);
var list = ListPageDataHelper.GetRankListFromHtml(html);
if (list == null)
{
ToastHelper.ShowMessage("排行榜数据获取失败");
}
else
{
if (pageIndex == 1)
{
Books.Clear();
}
foreach (var book in list)
{
Books.Add(book);
}
Title = $"排行榜({PageIndex}/{PageCount})";
}
}
private void OnNewContentCommandExecute()
{
BookClass bookClass = Books.FirstOrDefault(h => h.DateBook == Data);
if (bookClass != null)
{
bookManager.Delete(bookClass);
Books.Remove(bookClass);
bookManager.Add(bookManager.Create(Headline, Content, Data, CategoryClassesList));
bookManager.Save();
Books.Clear();
Books.Add(bookManager.Create(Headline, Content, Data, CategoryClassesList));
}
else
{
if (Content is null || Headline is null)
{
return;
}
bookManager.Add(bookManager.Create(Headline, Content, Data, CategoryClassesList));
bookManager.Save();
Books.Clear();
Books.Add(bookManager.Create(Headline, Content, Data, CategoryClassesList));
}
}
private void OnDataSortAllCommandExecute()
{
Data = new DateTime();
Books.Clear();
Books = new ObservableCollection <BookClass>(bookManager.GetAll());
Books = new ObservableCollection <BookClass>(Books.OrderBy(x => x.DateBook));
}
public async Task InitAsync(StoreAccess storeAccess)
{
int tryCount = 0;
Books.Clear();
_storeAccess = storeAccess;
try
{
try
{
tryCount++;
BookShelf = await _bookShelfService.LoadBookShelfAsync(storeAccess);
}catch (Exception ex)
{
tryCount++;
await Task.Delay(1000).ConfigureAwait(false);
BookShelf = await _bookShelfService.LoadBookShelfAsync(storeAccess);
}
foreach (var bookReference in BookShelf.Content)
{
var bookVM = await BookViewModel.CreateAsync(_bookService, _eventAggregator, bookReference);
Books.Add(bookVM);
}
}
catch (NoBookShelfExistsException ex)
{
_eventAggregator.GetEvent <NoBookShelfExistsMessage>().Publish(new Tuple <StoreAccess, string>(storeAccess, ex.Message + " - " + ex.AccessGrant + " - " + ex.AdditionalError + " - " + ex.StoreKey + " - " + tryCount.ToString() + " - " + ex.StackTrace));
}
}
public override async void OnSearchCommand(object obj)
{
if (string.IsNullOrEmpty(obj?.ToString().Trim()))
{
return;
}
try
{
IsLoading = true;
var searchPara = obj.ToString();
var uri = string.Format(SoduPageValue.BookSearchPage, WebUtility.UrlEncode(searchPara));
var html = await GetHtmlData(uri, true, false);
var books = ListPageDataHelper.GetSearchResultkListFromHtml(html);
if (books == null || books.Count <= 0)
{
ToastHelper.ShowMessage("无搜索结果");
return;
}
Books.Clear();
foreach (var book in books)
{
Books.Add(book);
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
finally
{
IsLoading = false;
}
}
async Task ExecuteLoadBooksCommand()
{
if (IsBusy)
{
return;
}
IsBusy = true;
try
{
Books.Clear();
var items = await DataStore.GetBooksAsync(true);
foreach (var item in items)
{
Books.Add(item);
}
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
finally
{
IsBusy = false;
}
}
//Call API Repository to get all books or the next page
private async Task GetBooks(string keyword, int currentPage)
{
if (string.IsNullOrEmpty(keyword))
{
CustomActionSheets actionSheet = null;
var btcolor = (Color)App.Current.Resources[ColorKeys.Primary];
actionSheet = new CustomActionSheets(Labels.Labels.NotValidWord, new System.Tuple <Command, string, Color, Color, Color>[] {
new System.Tuple <Command, string, Color, Color, Color>(new Command(async() =>
{
await actionSheet.PopPopupAsync();
}),
Labels.Labels.OK, btcolor, Color.White, btcolor)
});
await actionSheet.DisplayActionSheet();
return;
}
IsBusy = true;
var books = await new ApiRepository().GetBooksByKeyword(keyword, currentPage);
if (currentPage == 0)
{
_keywordBackup = keyword;
page = 0;
Books.Clear();
}
if (!books.Success || books.Items == null)
{
CustomActionSheets actionSheet = null;
var btcolor = (Color)App.Current.Resources[ColorKeys.Primary];
actionSheet = new CustomActionSheets(Labels.Labels.NoMoreResults, new System.Tuple <Command, string, Color, Color, Color>[] {
new System.Tuple <Command, string, Color, Color, Color>(new Command(async() =>
{
await actionSheet.PopPopupAsync();
}),
Labels.Labels.OK, btcolor, Color.White, btcolor)
});
await actionSheet.DisplayActionSheet();
IsBusy = false;
return;
}
books.Items.ToList().ForEach(b =>
{
if (string.IsNullOrWhiteSpace(b.VolumeInfo.ImageLinks?.SmallThumbnail) || string.IsNullOrWhiteSpace(b.VolumeInfo.ImageLinks?.Thumbnail))
{
b.VolumeInfo.ImageLinks = new Models.Common.ImageLinks()
{
Thumbnail = (string)App.Current.Resources[IconKeys.Book],
SmallThumbnail = (string)App.Current.Resources[IconKeys.Book]
};
}
Books.Add(b);
});
IsBusy = false;
page++;
}
public void ResetData()
{
Books.Clear();
PageIndex = -1;
PageCount = -1;
Title = null;
CurrentBook = null;
}
public void ExecuteBookQuery()
{
Books.Clear();
foreach (BookModel book in bookProvider.DocumentsQuery("temp"))
{
Books.Add(book);
}
}
public async void reloadFrom(String cat)
{
Books.Clear();
await Task.Factory.StartNew(() =>
{
Service.getBooksFrom(cat).ForEach(b => Books.Add(b));
});
}
public void Delete()
{
Books.Clear();
Films.Clear();
Serials.Clear();
Comments.Clear();
IsDeleted = true;
}
private void RefreshCatalog()
{
Books.Clear();
foreach (Logic.DTOs.BookDTO b in bs.GetBookDTOs())
{
Books.Add(new BookViewModel(b.ID, b.title, b.author, b.publisher, (int)b.year));
}
OnPropertyChanged(nameof(Books));
}
private async Task FilBooksAsync()
{
DbCommand cmd = _conn.CreateCommand();
cmd.CommandText = "waitfor delay '00:00:02';";
cmd.CommandText += mtfQuery.Text;
Books.Clear();
int rows = 0;
DataTable table = new DataTable();
mlStatus.Text = "Query is proccesing.";
using (DbDataReader reader = await cmd.ExecuteReaderAsync())
{
bool fLine = true;
int collCount = reader.FieldCount;
do
{
while (await reader.ReadAsync())
{
if (fLine)
{
for (int i = 0; i < collCount; i++)
{
table.Columns.Add(reader.GetName(i));
}
fLine = false;
}
DataRow row = table.NewRow();
await Task.Run(async() =>
{
for (int i = 0; i < collCount; i++)
{
row[i] = await reader.GetFieldValueAsync <object>(i);
}
});
Books.Add(new Book()
{
Id = (int)reader["Id"],
Author_Id = (int)reader["Author_Id"],
Title = reader["Title"] as string,
Price = (int)reader["Price"],
Pages = (int)reader["Pages"]
});
table.Rows.Add(row);
rows++;
}
} while (reader.NextResult());
mlStatus.Text = $"Succesfully readed {rows} rows from Books";
dgvTableView.DataSource = table;
}
}
private void LoadBooks(int gid)
{
Books.Clear();
var booksFilteredByGenre = dm.Books.Where(b => b.GenreId == gid).ToList();
foreach (var book in booksFilteredByGenre)
{
Books.Add(new BooksViewModel(book));
}
}
public async void Refresh()
{
IsBusy = true;
OnPropertyChanged(nameof(IsBusy));
Books.Clear();
await LoadBooks();
IsBusy = false;
OnPropertyChanged(nameof(IsBusy));
}
public void Dispose()
{
if (DocumentStream != null)
{
DocumentStream.Dispose();
}
if (Books != null && Books.Count > 0)
{
Books.Clear();
}
}
/// <summary>
/// When navigate to this page, request an api based on the given url
/// If this character has url-based detail, requests those too
/// </summary>
/// <param name="parameter"></param>
/// <param name="mode"></param>
/// <param name="state"></param>
/// <returns></returns>
public override async Task OnNavigatedToAsync(object parameter, NavigationMode mode, IDictionary <string, object> state)
{
try
{
var characterUrl = (string)parameter;
var service = new ThroneService();
Character = await service.GetCharacterAsync(characterUrl);
Father = await service.GetCharacterAsync(Character.Father);
Mother = await service.GetCharacterAsync(Character.Mother);
Spouse = await service.GetCharacterAsync(Character.Spouse);
if (Character.Allegiances.Length != 0)
{
Allies.Clear();
foreach (String url in Character.Allegiances)
{
House newHouse = await service.GetHouseAsync(url);
Allies.Add(newHouse);
}
}
if (Character.Books.Length != 0)
{
Books.Clear();
foreach (String url in Character.Books)
{
Book newBook = await service.GetBookAsync(url);
Books.Add(newBook);
}
}
if (Character.PovBooks.Length != 0)
{
PovBooks.Clear();
foreach (String url in Character.PovBooks)
{
Book newBook = await service.GetBookAsync(url);
PovBooks.Add(newBook);
}
}
await base.OnNavigatedToAsync(parameter, mode, state);
}
catch (RedirectMainException)
{
NavigationService.Navigate(typeof(MainPage));
}
}
public void OnGetBooks()
{
Books.Clear();
var books = _booksService.GetBooks();
foreach (var b in books)
{
Books.Add(b);
}
}
private async Task RefreshBooksAsync()
{
Books.Clear();
var books = await _booksService.GetBooksAsync();
foreach (var book in books)
{
Books.Add(book);
}
SelectedBook = Books?.First();
}
private void SaveDataToFile()
{
var fileName = _dialogService.SaveFileDialog();
if (fileName != null)
{
List <Book> bookListToSave = Books.ToList();
_sourceOperations.GetWriter(fileName).WriteBooks(fileName, bookListToSave);
Books.Clear();
}
}
private async void RefreshBooksAsync()
{
Books.Clear();
var books = await _booksService.GetAllBooksAsync();
foreach (var book in books)
{
Books.Add(book);
}
SelectedBook = books.FirstOrDefault();
}
private void LoadBooks()
{
Books.Clear();
var books = _dbService.GetBooks();
foreach (var book in books)
{
Books.Add(book);
}
_logger.Info($"Loaded {Books.Count} books");
}
public void Query()
{
var books = _repo.Query();
Books.Clear();
foreach (var item in books)
{
Books.Add(item);
}
Status = string.Format("已入库图书{0}种，总入库数量{1}本",
books.Count, books.Sum(e => e.TotalCount));
}
public void RefreshBookList()
{
List <Book> books = App.Database.GetBooksAsync().Result.ToList();
Books.Clear();
books = FilterBooks(books);
books = SortBooks(books);
foreach (var book in books)
{
Books.Add(book);
}
}
private void ReadSavedBooks()
{
using (SQLiteConnection conn = new SQLiteConnection(App.DatabasePath))
{
conn.CreateTable <Best_book>();
var books = conn.Table <Best_book>().ToList();
Books.Clear();
foreach (var book in books)
{
Books.Add(book);
}
}
}
private async void PerformSearch()
{
OpenLibraryAPI.SearchResponse response = await searchModel.PerformSearch();
Books.Clear();
foreach (var book in response.books)
{
var b = new BookViewModel(book);
b.PropertyChanged += Book_OnNotifyPropertyChanged;
searchModel.Books.Add(b);
Books.Add(b);
}
}
/// <summary>
/// Upades book's amount.
/// </summary>
private void UpdateBookAmount(BookModel bookModel)
{
bookModel.Amount--;
HttpResponseMessage httpResponseMessage = ConstantsHelper.Post(bookModel, booksApiUrl + "/PutBook", httpClient);
Journals.Clear();
Books.Clear();
PopulateCollections();
if (bookModel.Amount <= 0)
{
var bookToRemove = Books.FirstOrDefault(b => b.Amount == 0);
Books.Remove(bookToRemove);
}
}
public void ReadBooks()
{
using (SQLiteConnection conn = new SQLiteConnection(DatabaseHelper.dbFile))
{
var books = conn.Table <Book>().ToList();
Books.Clear();
foreach (var book in books)
{
Books.Add(book);
}
}
}
private async void Search()
{
Books.Clear();
if (SearchText != "")
{
var searchedBooks = await WebClient.Client.SearchBooksAsync(SearchText);
ObservableCollection <Book> temp = new ObservableCollection <Book>(searchedBooks);
foreach (Book b in temp)
{
Books.Add(b);
}
}
}
