LivreLand/StubbedDTO/Stub.cs

207 lines
8.5 KiB

using DtoAbstractLayer;
using JsonReader;
using LibraryDTO;
using System.Reflection;
namespace StubbedDTO
{
public class Stub : IDtoManager
{
public static List<AuthorDTO> Authors { get; set; } = new List<AuthorDTO>();
public static List<BookDTO> Books { get; set; } = new List<BookDTO>();
public static List<WorkDTO> Works { get; set; } = new List<WorkDTO>();
public static Assembly Assembly => typeof(Stub).Assembly;
static Stub()
{
foreach (var resource in Assembly.GetManifestResourceNames().Where(n => n.Contains("authors")))
{
using (Stream stream = Assembly.GetManifestResourceStream(resource))
using (StreamReader reader = new StreamReader(stream))
{
Authors.Add(AuthorJsonReader.ReadAuthor(reader.ReadToEnd()));
}
}
foreach (var resource in Assembly.GetManifestResourceNames().Where(n => n.Contains("works")))
{
var ratingsResource = resource.Insert(resource.LastIndexOf('.'), ".ratings").Replace("works", "ratings");
using (Stream stream = Assembly.GetManifestResourceStream(resource))
using (StreamReader reader = new StreamReader(stream))
using (Stream streamRatings = Assembly.GetManifestResourceStream(ratingsResource))
using (StreamReader readerRatings = new StreamReader(streamRatings))
{
var work = WorkJsonReader.ReadWork(reader.ReadToEnd(), readerRatings.ReadToEnd());
if (work.Authors != null)
foreach (var author in work.Authors.ToList())
{
var newAuthor = Authors.SingleOrDefault(a => a.Id == author.Id);
work.Authors.Remove(author);
work.Authors.Add(newAuthor);
}
Works.Add(work);
}
}
foreach (var resource in Assembly.GetManifestResourceNames().Where(n => n.Contains("books")))
{
using (Stream stream = Assembly.GetManifestResourceStream(resource))
using (StreamReader reader = new StreamReader(stream))
{
var book = BookJsonReader.ReadBook(reader.ReadToEnd());
foreach (var author in book.Authors.ToList())
{
var newAuthor = Authors.SingleOrDefault(a => a.Id == author.Id);
book.Authors.Remove(author);
book.Authors.Add(newAuthor);
}
foreach (var work in book.Works.ToList())
{
var newWork = Works.SingleOrDefault(w => w.Id == work.Id);
book.Works.Remove(work);
book.Works.Add(newWork);
}
Books.Add(book);
}
}
}
public Task<AuthorDTO> GetAuthorById(string id)
{
var author = Stub.Authors.SingleOrDefault(a => a.Id.Contains(id));
return Task.FromResult(author);
}
private Task<Tuple<long, IEnumerable<AuthorDTO>>> OrderAuthors(IEnumerable<AuthorDTO> authors, int index, int count, string sort = "")
{
switch (sort)
{
case "name":
authors = authors.OrderBy(a => a.Name);
break;
case "name_reverse":
authors = authors.OrderByDescending(a => a.Name);
break;
}
return Task.FromResult(Tuple.Create((long)authors.Count(), authors.Skip(index * count).Take(count)));
}
public async Task<Tuple<long, IEnumerable<AuthorDTO>>> GetAuthors(int index, int count, string sort = "")
{
IEnumerable<AuthorDTO> authors = Stub.Authors;
return await OrderAuthors(authors, index, count, sort);
}
public async Task<Tuple<long, IEnumerable<AuthorDTO>>> GetAuthorsByName(string name, int index, int count, string sort = "")
{
var authors = Stub.Authors.Where(a => a.Name.Contains(name, StringComparison.OrdinalIgnoreCase)
|| a.AlternateNames.Exists(alt => alt.Contains(name, StringComparison.OrdinalIgnoreCase)));
return await OrderAuthors(authors, index, count, sort);
}
public Task<BookDTO> GetBookById(string id)
{
var book = Stub.Books.SingleOrDefault(b => b.Id.Contains(id));
return Task.FromResult(book);
}
private Task<Tuple<long, IEnumerable<BookDTO>>> OrderBooks(IEnumerable<BookDTO> books, int index, int count, string sort = "")
{
switch (sort)
{
case "title":
books = books.OrderBy(b => b.Title);
break;
case "title_reverse":
books = books.OrderByDescending(b => b.Title);
break;
case "new":
books = books.OrderByDescending(b => b.PublishDate);
break;
case "old":
books = books.OrderBy(b => b.PublishDate);
break;
}
return Task.FromResult(Tuple.Create(books.LongCount(), books.Skip(index * count).Take(count)));
}
public async Task<Tuple<long, IEnumerable<BookDTO>>> GetBooks(int index, int count, string sort = "")
{
var books = Stub.Books;
return await OrderBooks(books, index, count, sort);
}
public Task<BookDTO> GetBookByISBN(string isbn)
{
var book = Stub.Books.SingleOrDefault(b => b.ISBN13.Equals(isbn, StringComparison.OrdinalIgnoreCase));
return Task.FromResult(book);
}
public async Task<Tuple<long, IEnumerable<BookDTO>>> GetBooksByTitle(string title, int index, int count, string sort = "")
{
var books = Stub.Books.Where(b => b.Title.Contains(title, StringComparison.OrdinalIgnoreCase)
|| b.Series.Exists(s => s.Contains(title, StringComparison.OrdinalIgnoreCase)));
return await OrderBooks(books, index, count, sort);
}
public async Task<Tuple<long, IEnumerable<BookDTO>>> GetBooksByAuthorId(string authorId, int index, int count, string sort = "")
{
var books = Stub.Books.Where(b => b.Authors.Exists(a => a.Id.Contains(authorId))
|| b.Works.Exists(w => w.Authors.Exists(a => a.Id.Contains(authorId))));
return await OrderBooks(books, index, count, sort);
}
public async Task<Tuple<long, IEnumerable<BookDTO>>> GetBooksByAuthor(string name, int index, int count, string sort = "")
{
var books = Stub.Books.Where(b => ContainsAuthorName(b, name));
return await OrderBooks(books, index, count, sort);
}
private bool ContainsAuthorName(BookDTO book, string name)
{
IEnumerable<AuthorDTO> authors = new List<AuthorDTO>();
if (book.Authors != null && book.Authors.Count > 0)
{
authors = authors.Union(book.Authors);
}
if (book.Works != null)
{
var worksAuthors = book.Works.SelectMany(w => w.Authors).ToList();
if (worksAuthors.Count > 0)
authors = authors.Union(worksAuthors);
}
foreach (var author in authors)
{
if (author.Name.Contains(name, StringComparison.OrdinalIgnoreCase)
|| author.AlternateNames.Exists(alt => alt.Contains(name, StringComparison.OrdinalIgnoreCase)))
{
return true;
}
}
return false;
}
public Task<Tuple<long, IEnumerable<WorkDTO>>> GetWorks(int index, int count)
{
long nbWorks = Stub.Works.Count;
var works = Stub.Works.Skip(index * count).Take(count);
return Task.FromResult(Tuple.Create(nbWorks, works));
}
public Task<long> GetNbAuthors()
=> Task.FromResult((long)Stub.Authors.Count);
public Task<long> GetNbBooks()
=> Task.FromResult((long)Stub.Books.Count);
public Task<long> GetNbWorks()
=> Task.FromResult((long)Stub.Works.Count);
}
}