public IEnumerable <BookModel> GetTrials()
{
using (BookDataContext context = BookDataContext.Connect())
{
return(context.Books.Where(b => b.Trial).ToList());
}
}
public bool CheckUniqueId(string uniqueId)
{
using (BookDataContext context = BookDataContext.Connect())
{
return(!context.Books.Any(t => t.UniqueID == uniqueId && !t.Deleted));
}
}
private void OnFixupDatabase(object sender, RoutedEventArgs e)
{
BookDataContext.ResetSingleton("InitialBookData.Db");
var bookdb = BookDataContext.Get();
var books = bookdb.Books.ToList();
int nfix = 0;
foreach (var book in books)
{
if (book.LCC == null)
{
nfix++; book.LCC = "";
}
if (book.LCCN == null)
{
nfix++; book.LCCN = "";
}
if (book.LCSH == null)
{
nfix++; book.LCSH = "";
}
}
;
bookdb.SaveChanges();
BookDataContext.ResetSingleton(null);
}
public int Count()
{
using (BookDataContext context = BookDataContext.Connect())
{
return(context.Catalogs.Count());
}
}
private void SetNotes(BookData bookData)
{
var bookdb = BookDataContext.Get();
if (bookData == null)
{
// Do a refresh as needed
bookData = CurrBookData;
if (bookData == null)
{
return; // very uncommon -- perhaps race conditions and startup?
}
}
CurrBookData = bookData;
Notes.Clear();
var bookId = CurrBookData.BookId;
var bn = CommonQueries.BookNotesFind(bookdb, bookId);
if (bn == null)
{
;
}
else if (bn.Notes != null)
{
var sorted = bn.Notes.OrderBy(note => note.LocationNumericValue).ToList();
foreach (var note in sorted)
{
Notes.Add(new UserNoteWithTitle(note, false));
}
}
}
private static void AddBooks(BookDataContext context)
{
context.Books.Add(new Book {
BookName = "Master C Sharp", AuthorName = "Steve Philips", Genre = "Computer Programming", Price = 580
});
context.SaveChanges();
}
private void DeleteNotes_Click(object sender, RoutedEventArgs e)
{
var bookdb = BookDataContext.Get();
UserNoteWithTitle[] list = new UserNoteWithTitle[uiList.SelectedItems.Count];
int i = 0;
foreach (var item in uiList.SelectedItems)
{
list[i++] = item as UserNoteWithTitle;
}
foreach (var note in list)
{
Notes.Remove(note);
var bookId = note.BookId;
var bn = CommonQueries.BookNotesFind(bookdb, bookId);
if (bn == null)
{
;
}
else if (bn.Notes != null)
{
bn.Notes.Remove(note.BaseNote);
}
}
CommonQueries.BookSaveChanges(bookdb);
}
public async Task DoFilesActivated(FileActivatedEventArgs args)
{
var items = args.Files;
var bookdb = BookDataContext.Get();
await DoOpenFilesAsync(bookdb, items);
}
public static void DownloadedBookEnsureFileMarkedAsDownloaded(BookDataContext bookdb, string bookId, string folderPath, string filename)
{
NQueries++;
var book = BookGet(bookdb, bookId);
if (book == null)
{
App.Error($"ERROR: trying to ensure that {bookId} is downloaded, but it's not a valid book");
return;
}
var dd = book.DownloadData;
if (dd == null)
{
dd = new DownloadData()
{
BookId = bookId,
FilePath = folderPath,
FileName = filename,
CurrFileStatus = DownloadData.FileStatus.Downloaded,
DownloadDate = DateTimeOffset.Now,
};
book.DenormDownloadDate = dd.DownloadDate.ToUnixTimeSeconds();
CommonQueries.DownloadedBookAdd(bookdb, dd, CommonQueries.ExistHandling.IfNotExists);
CommonQueries.BookSaveChanges(bookdb);
}
else if (dd.CurrFileStatus != DownloadData.FileStatus.Downloaded)
{
dd.FilePath = folderPath;
dd.CurrFileStatus = DownloadData.FileStatus.Downloaded;
BookSaveChanges(bookdb);
}
}
/// <summary>
/// Returns TRUE if a note was edited, FALSE otherwise.
/// </summary>
/// <param name="controlId"></param>
/// <param name="note"></param>
/// <returns></returns>
public static async Task <bool> EditNoteAsync(NavigateControlId controlId, UserNote note)
{
var bookdb = BookDataContext.Get();
var edited = false;
var cd = new ContentDialog()
{
Title = "Edit Bookmark (Note)",
PrimaryButtonText = "OK",
SecondaryButtonText = "Cancel"
};
var ne = new NoteEditor();
ne.DataContext = note;
cd.Content = ne;
var result = await cd.ShowAsync();
switch (result)
{
case ContentDialogResult.Primary:
ne.SaveNoteIfNeeded(controlId, bookdb);
edited = true;
break;
case ContentDialogResult.Secondary:
// Cancel means don't save the note.
edited = false;
break;
}
return(edited);
}
public IEnumerable <CatalogModel> GetAll()
{
using (BookDataContext context = BookDataContext.Connect())
{
return(context.Catalogs.ToList());
}
}
/// <summary>
/// Will do an absolute save position. This is almost never needed; instead use the
/// SavePositionEZ which will save in a CPU and disk friendlier way.
/// </summary>
private async Task SavePositionNow()
{
if (BookData == null)
{
return;
}
var bookdb = BookDataContext.Get();
var currPosition = GetCurrBookLocation().ToJson();
if (currPosition == lastSavedPosition)
{
return;
}
var nd = EnsureBookNavigationData(bookdb);
if (nd == null)
{
return;
}
nd.CurrSpot = currPosition;
lastSavedPosition = currPosition;
CommonQueries.BookSaveChanges(bookdb);
var localSettings = Windows.Storage.ApplicationData.Current.LocalSettings;
localSettings.Values[CURR_READING_BOOK_ID] = BookData.BookId;
localSettings.Values[CURR_READING_BOOK_POS] = currPosition;
// Update the bookmark file, too.
await BookMarkFile.SmartSaveAsync(BookMarkFile.BookMarkFileType.RecentOnly);
}
private async Task UpdateList()
{
// Get list of currently-reading books
var startTime = DateTime.Now;
var search = "";
var searchType = uiShowDownloaded.IsChecked.Value ? "Downloaded" : "Reading";
var sortBy = "title";
var language = "en";
List <BookData> resultList = null;
bool andMore = false;
Books.Clear();
var searchTask = Task.Run(() => {
var bookdb = BookDataContext.Get();
lock (bookdb)
{
resultList = AllBookSearch.SearchInternal(bookdb, searchType, search, language, sortBy, out andMore);
}
});
await searchTask;
// Finally add to the output
foreach (var book in resultList)
{
Books.Add(new HelperBookDataWithSelected(book));
}
}
private void AddDefaultCatalogs(BookDataContext dataContext)
{
/*
* var catalog = new CatalogModel
* {
* Url = "http://data.fbreader.org/catalogs/litres2/index.php5",
* Title = "FBReader_Litres",
* Description = "description",
* IconLocalPath = "/Resources/Icons/litres_icon.jpg",
* SearchUrl = "http://data.fbreader.org/catalogs/litres2/search.php5?query={0}",
* Type = CatalogType.Litres
* };
* dataContext.Catalogs.InsertOnSubmit(catalog);
* /*/
var catalog = new CatalogModel
{
Url = "http://194.58.90.83:8081",
Title = "Ѕиблиотеке",
Description = "description",
IconLocalPath = "/Resources/Icons/cops_icon.jpg",
SearchUrl = "http://194.58.90.83:8081/?searchType=books&searchTerm={0}",
OpenSearchDescriptionUrl = "http://194.58.90.83:8081/web?id=07",
Type = CatalogType.OPDS
};
dataContext.Catalogs.InsertOnSubmit(catalog);
//*/
dataContext.SubmitChanges();
}
/// <summary>
/// Returns the number of books read; clears out the original books and saves.
/// </summary>
/// <returns></returns>
public static async Task <int> ReadDirAsync(BookDataContext bookdb)
{
var picker = new FolderPicker()
{
SuggestedStartLocation = PickerLocationId.DocumentsLibrary,
};
picker.FileTypeFilter.Add(".rdf");
var folder = await picker.PickSingleFolderAsync();
if (folder == null)
{
return(-1);
}
NextIndexLogged = LogNIndex;
NRead = 0;
CommonQueries.BookRemoveAll(bookdb);
await ReadDirAsyncFolder(bookdb, folder);
CommonQueries.BookSaveChanges(bookdb);
var totlog = logsb.ToString();
return(NRead);
}
/// <summary>
/// Queries user for ZIPPED TAR'd RDF (catalog) file and stuff data into database
/// </summary>
/// <param name="bookdb"></param>
/// <returns></returns>
public static async Task <int> ReadZipTarRdfFile(BookDataContext bookdb)
{
var picker = new FileOpenPicker()
{
ViewMode = PickerViewMode.List,
SuggestedStartLocation = PickerLocationId.DocumentsLibrary,
SettingsIdentifier = "NewGutengbergFile",
};
picker.FileTypeFilter.Add(".zip");
var filepick = await picker.PickSingleFileAsync();
if (filepick == null)
{
return(0);
}
//var fullpath = filepick.Path;
//var file = await PCLStorage.FileSystem.Current.GetFileFromPathAsync(fullpath);
var ui = new NullIndexReader(); // don't really do anything :-)
int retval = 0;
await Task.Run(async() =>
{
var cts = new CancellationTokenSource();
retval = await ReadZipTarRdfFileAsync(ui, bookdb, filepick, cts.Token);
;
});
return(retval);
}
private async Task DoSwipeDownload(BookData bookData)
{
var bookcard = GetBookCardFromBookData(bookData);
var bookdb = BookDataContext.Get();
var nd = CommonQueries.BookNavigationDataEnsure(bookdb, bookData);
nd.NSwipeRight++;
nd.NSpecificSelection++;
CommonQueries.BookSaveChanges(bookdb);
// Before I can download, make sure that the download file list is set up.
SetupDownloadsIfNeeded(bookData);
// But wait! If the book is already downloaded, then just display it
var fileStatus = bookData.DownloadData == null ? DownloadData.FileStatus.Unknown : bookData.DownloadData.CurrFileStatus;
switch (fileStatus)
{
case DownloadData.FileStatus.Downloaded:
var nav = Navigator.Get();
nav.DisplayBook(ControlId, bookData);
break;
default:
await bookcard.DoDownloadAsync();
break;
}
}
private List <ChapterDataModel> LoadChapters()
{
using (BookDataContext context = BookDataContext.Connect())
{
var chaptersInBook =
from chapter in context.Chapters
where chapter.BookID == BookId
orderby chapter.TokenID
select chapter;
var source = new List <ChapterDataModel>();
foreach (ChapterModel chapterModel in chaptersInBook)
{
int tokenID = chapterModel.TokenID;
var chapter = new ChapterDataModel
{
Depth = chapterModel.Level,
Title = chapterModel.Title.Trim(),
TokenId = tokenID
};
source.Add(chapter);
}
return(source);
}
}
public static void DoCreateIndexFileEF()
{
if (BookIndexes != null)
{
return;
}
BookIndexes = new Dictionary <string, BookIndex>();
var bookdb = BookDataContext.Get();
var bookList = bookdb.Books
.Include(b => b.People)
.Include(b => b.Review)
.Include(b => b.Notes)
.Include(b => b.Notes.Notes)
.ToList();
//var sb = new StringBuilder();
foreach (var bookData in bookList)
{
var index = BookIndex.FromBookData(bookData);
BookIndexes.Add(index.BookId, index);
//sb.Append(index.ToString());
//sb.Append('\n');
}
//var fullIndex = sb.ToString();
;
}
public async Task ExecuteAsync()
{
using (var db = BookDataContext.Connect())
{
AddDefaultCatalogs(db);
}
}
public void Add(BookDownloadModel item)
{
using (BookDataContext context = BookDataContext.Connect())
{
context.Downloads.InsertOnSubmit(item);
context.SubmitChanges();
}
}
public static BookNotes BookNotesFind(BookDataContext bookdb, string bookId)
{
NQueries++;
var book = BookGet(bookdb, bookId);
var retval = book.Notes;
return(retval);
}
public static void BookSaveChanges(BookDataContext bookdb)
{
NQueries++;
lock (bookdb)
{
bookdb.SaveChanges();
}
}
public CatalogModel Get(int catalogId)
{
using (BookDataContext context = BookDataContext.Connect())
{
CatalogModel model = context.Catalogs.FirstOrDefault(t => t.Id == catalogId);
return(model);
}
}
public void Add(CatalogModel catalog)
{
using (BookDataContext context = BookDataContext.Connect())
{
context.Catalogs.InsertOnSubmit(catalog);
context.SubmitChanges();
}
}
public override void Update(BookDataContext db, DatabaseSchemaUpdater updater)
{
updater.AddColumn <BookDownloadModel>("Author");
updater.AddColumn <BookDownloadModel>("Description");
updater.AddColumn <BookDownloadModel>("AcquisitionUrl");
updater.AddColumn <BookDownloadModel>("AcquisitionType");
updater.AddColumn <BookDownloadModel>("AcquisitionPrices");
}
public void Add(BookModel book)
{
using (BookDataContext context = BookDataContext.Connect())
{
context.Books.InsertOnSubmit(book);
context.SubmitChanges();
}
}
public void Save(CatalogModel catalog)
{
using (BookDataContext context = BookDataContext.Connect())
{
context.Catalogs.Attach(catalog);
context.Refresh(0, catalog);
context.SubmitChanges();
}
}
public void DeleteBookmarks(string bookId)
{
using (BookDataContext context = BookDataContext.Connect())
{
var bookmarks = context.Bookmarks.Where(t => t.BookID == bookId);
context.Bookmarks.DeleteAllOnSubmit(bookmarks);
context.SubmitChanges();
}
}
public static int BookCount(BookDataContext bookdb)
{
NQueries++;
lock (bookdb)
{
var retval = bookdb.Books.Count();
return(retval);
}
}
public abstract void Update(BookDataContext db);
