public async Task <IActionResult> ReparseRawBookData([FromBody] BookLoader request)
{
try {
if (request == null)
{
throw new ArgumentException("Missing request");
}
if (string.IsNullOrEmpty(request.Isbn))
{
throw new ArgumentException("Missing ISBN");
}
if (request.Isbn.Any(c => !char.IsLetterOrDigit(c)))
{
throw new ArgumentException("Invalid ISBN");
}
var rawData = await _bookRepo.GetRawData(request.Isbn) ?? throw new ArgumentException("Invalid ISBN");
DataScraperFactory.ReparseBookData(rawData);
await _bookRepo.StoreRawData(rawData);
var bookId = await _bookRepo.GetOne(request.Isbn, x => x.Id);
var newBook = await DataScraperFactory.CreateBook(rawData);
await _bookRepo.Update(bookId, newBook);
return(Ok());
} catch (ArgumentException ex) {
_log.LogWarning(ex, ex.Message);
return(BadRequest(ex.Message));
} catch (Exception ex) {
_log.LogError(ex, ex.Message);
return(StatusCode(500, ex.Message));
}
}
public async Task <IActionResult> CreateBookFromRawData(string id)
{
try {
var dbId = ObjectId.Parse(id);
var extnData = await _bookRepo.GetRawData(dbId) ?? throw new ArgumentException("Invalid database ID");
var chk = await _bookRepo.GetOne(extnData.Isbn, x => x.Id);
if (chk != ObjectId.Empty)
{
throw new ArgumentException($"Book already loaded for '{extnData.Isbn}'");
}
var book = await DataScraperFactory.CreateBook(extnData);
var newId = await _bookRepo.Insert(book);
return(Ok(newId.ToString()));
} catch (ArgumentException ex) {
_log.LogWarning(ex, ex.Message);
return(BadRequest(ex.Message));
} catch (Exception ex) {
_log.LogError(ex, ex.Message);
return(StatusCode(500, ex.Message));
}
}
public async Task <IActionResult> SearchForBookData([FromBody] BookLoader request)
{
try {
if (request == null)
{
throw new ArgumentException("Missing request");
}
if (string.IsNullOrEmpty(request.Isbn))
{
throw new ArgumentException("Missing ISBN");
}
if (request.Isbn.Any(c => !char.IsLetterOrDigit(c)))
{
throw new ArgumentException("Invalid ISBN");
}
var chk = await _bookRepo.GetOne(request.Isbn, x => x.Id);
if (chk != ObjectId.Empty)
{
throw new ArgumentException($"Book already loaded for '{request.Isbn}'")
{
HelpLink = chk.ToString()
}
}
;
var extnData = await DataScraperFactory.GetBookDataFromWeb(request.Isbn);
await _bookRepo.StoreRawData(extnData);
var bk = await DataScraperFactory.CreateBook(extnData);
var newId = await _bookRepo.Insert(bk);
return(Ok(newId.ToString()));
} catch (ArgumentException ex) {
_log.LogWarning(ex, ex.Message);
if (ex.HelpLink != null)
{
return(BadRequest(new ErrorMessageModel {
Message = ex.Message, BookId = ex.HelpLink
}));
}
return(BadRequest(ex.Message));
} catch (SearchFailedException ex) {
_log.LogWarning(ex, ex.Message);
return(BadRequest(ex.Message));
} catch (Exception ex) {
_log.LogError(ex, ex.Message);
return(StatusCode(500, ex.Message));
}
}
private async Task <ExtnBookData> LoadBook(DirectoryInfo bookDir)
{
var raw = new ExtnBookData {
Isbn = bookDir.Name, ImportedOn = DateTime.UtcNow
};
var opt = new EnumerationOptions {
IgnoreInaccessible = true,
MatchCasing = MatchCasing.CaseInsensitive,
MatchType = MatchType.Simple,
RecurseSubdirectories = false,
ReturnSpecialDirectories = false
};
foreach (var dataFile in bookDir.EnumerateFiles("*.raw", opt))
{
using var dataStr = dataFile.OpenText();
var htmlRaw = await dataStr.ReadToEndAsync();
switch (dataFile.Name.ToLowerInvariant())
{
case "bookfinder.raw":
raw.BookFinder = new SiteData {
RawHtml = htmlRaw
};
break;
case "isbndb.raw":
raw.IsbnDb = new SiteData {
RawHtml = htmlRaw
};
break;
case "openlibrary.raw":
raw.OpenLibrary = new SiteData {
RawHtml = htmlRaw
};
break;
}
}
DataScraperFactory.ReparseBookData(raw);
await _repo.StoreRawData(raw);
return(raw);
}
/// <inheritdoc />
public void Run(CancellationToken cancel)
{
//var wait = Task.Delay(10000, cancel);
//wait.Wait(cancel);
Task.Run(async() => {
var dataDir = new DirectoryInfo(_settings.DataSrcDir);
if (!dataDir.Exists)
{
throw new ApplicationException($"Data directory {_settings.DataSrcDir} does not exist");
}
var loadedRaw = new List <ExtnBookData>();
foreach (var isbnDir in dataDir.EnumerateDirectories())
{
_log.LogInformation("Directory found: {0}", isbnDir.Name);
// check to see if book already exists
var raw = await _repo.GetRawData(isbnDir.Name);
if (raw != null)
{
continue;
}
_log.LogInformation("New book data, parsing and loading: {0}", isbnDir.Name);
raw = await LoadBook(isbnDir);
loadedRaw.Add(raw);
}
foreach (var rawBook in loadedRaw)
{
var chk = await _repo.GetOne(rawBook.Isbn, BookIsbn.GetMap());
if (chk != null)
{
continue;
}
_log.LogInformation("Parsing raw data to load book {0}", rawBook.Isbn);
var bk = await DataScraperFactory.CreateBook(rawBook);
var newId = await _repo.Insert(bk);
_log.LogInformation("Book '{0}' loaded new id = {1}", rawBook.Isbn, newId);
}
}, cancel).Wait(cancel);
_log.LogWarning("Task finished.");
}
public async Task <IActionResult> SearchForBookDataOnOpenLibrary(string id)
{
try {
var dbId = ObjectId.Parse(id);
var extnData = await _bookRepo.GetRawData(dbId) ?? throw new ArgumentException("Invalid database ID");
var updates = await DataScraperFactory.GetBookDataFromOpenLibrary(extnData);
await _bookRepo.StoreRawData(updates);
return(Ok());
} catch (ArgumentException ex) {
_log.LogWarning(ex, ex.Message);
return(BadRequest(ex.Message));
} catch (SearchFailedException ex) {
_log.LogWarning(ex, ex.Message);
return(BadRequest(ex.Message));
} catch (Exception ex) {
_log.LogError(ex, ex.Message);
return(StatusCode(500, ex.Message));
}
}
