public ActionResult Save(Guid?id)
{
BookPageModel bookPageModel = new BookPageModel();
Response <List <BookModel> > responseBooks = JsonConvert.DeserializeObject <Response <List <BookModel> > >(UiRequestManager.Instance.Get("Book", "List"));
bookPageModel.BookList = responseBooks.Value;
Response <List <AuthorModel> > responseAuthor = JsonConvert.DeserializeObject <Response <List <AuthorModel> > >(UiRequestManager.Instance.Get("Author", "List"));
bookPageModel.AuthorList = responseAuthor.Value;
Response <List <PublisherModel> > responsePublisher = JsonConvert.DeserializeObject <Response <List <PublisherModel> > >(UiRequestManager.Instance.Get("Publisher", "List"));
bookPageModel.PubLisherList = responsePublisher.Value;
Response <List <TagModel> > responseTags = JsonConvert.DeserializeObject <Response <List <TagModel> > >(UiRequestManager.Instance.Get("Tag", "List"));
bookPageModel.TagList = responseTags.Value;
Response <List <CategoryModel> > responsecategory = JsonConvert.DeserializeObject <Response <List <CategoryModel> > >(UiRequestManager.Instance.Get("Category", "List"));
bookPageModel.CategoryList = responsecategory.Value;
if (Guid.Empty != id && id.HasValue)
{
Response <BookModel> responseSaving = JsonConvert.DeserializeObject <Response <BookModel> >(UiRequestManager.Instance.Get("Book", "GetOne", id));
bookPageModel.bookModel = responseSaving.Value;
}
return(View(bookPageModel));
}
public static BookPageModel GetBookPageModel(int id, int userID)
{
var book = manager.bookService.GetFullBookInfo(id);
BookPageModel result = book.ServiceBookToModelBook();
result.Authors = book.Authors.Select(e => e.ToAuthorShortModel());
result.Comments = book.Comments.Select(Comment.GetCommentModel);
result.Contents = book.Contents.Select(Content.GetContentModel);
result.Covers = book.Covers.Select(e => e.ToCoverModel());
if (!result.Covers.Any())
{
result.Covers = new List <CoverModel>()
{
new CoverModel()
{
ID = 0, BookID = id
}
};
}
result.Genres = book.Genres.Select(e => e.ToGenreModel());
result.Likes = Like.GetLikeButtonsModel(id, userID);
result.Lists = book.Lists.Select(e => e.ToListModel());
result.Reviews = book.Review.Select(Review.GetReviewModel);
result.Tags = book.Tags.Select(Tag.GetTagModel);
result.Screening = book.Screeninigs.Select(e => e.ToScreeningModel());
result.Collections = CollectionBook.GetBookInCollectionModel(id, userID);
return(result);
}
// GET: Books
public ActionResult Index(string search_param, string str)
{
HttpClient client = new HttpClient();
client.BaseAddress = new Uri("http://localhost:54162/");
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var apiRoute = "api/authors/books";
if (str != null && str.Trim() != "")
{
if (search_param == "author")
{
apiRoute = "api/authors/books/search/author/" + str;
}
else if (search_param == "title")
{
apiRoute = "api/authors/books/search/title/" + str;
}
else if (search_param == "all")
{
apiRoute = "api/authors/books/search/all/" + str;
}
}
HttpResponseMessage response = client.GetAsync(apiRoute).Result;
var book = response.Content.ReadAsAsync <IEnumerable <BookModel> >().Result;
BookPageModel bpm = new BookPageModel();
bpm.searchTerm = str;
bpm.searchType = search_param;
bpm.BookModels = book;
return(View(bpm));
}
public async Task <JsonResult> Save(BookPageModel model)
{
Response <BookModel> responseSaving = JsonConvert.DeserializeObject <Response <BookModel> >(UiRequestManager.Instance.Post("Book", "Save", JsonConvert.SerializeObject(model.bookModel)));
AppFileFilterModel appFileFilterModel = new AppFileFilterModel
{
AppFileModuleId = responseSaving.Value.Id,
ModuleType = API.Models.Enum.Enum.Module.BookThumbnail,
File = model.Thumbnail
};
await AppFileUploadHelper.Instance.UploadFile(appFileFilterModel);
appFileFilterModel.File = model.Publication;
appFileFilterModel.ModuleType = API.Models.Enum.Enum.Module.Publication;
await AppFileUploadHelper.Instance.UploadFile(appFileFilterModel);
model.bookModel.CategoryTagAssigment.BookId = responseSaving.Value.Id;
model.bookModel.CategoryTagAssigment.BookName = model.bookModel.BookName;
model.bookModel.CategoryTagAssigment.SignUrl = "https://imageserver.kitapyurdu.com/select.php?imageid=46240&width=100&isWatermarked=true";
model.bookModel.CategoryTagAssigment.AuthorId = model.bookModel.AuthorId;
model.bookModel.CategoryTagAssigment.PublisherId = model.bookModel.AuthorId;
model.bookModel.CategoryTagAssigment.BookSummary = model.bookModel.BookSummary;
JsonConvert.DeserializeObject <Response <CategoryTagAssigmentModel> >(UiRequestManager.Instance.Post("CategoryTagAssignment", "Save", JsonConvert.SerializeObject(model.bookModel.CategoryTagAssigment)));
return(Json(responseSaving));
}
public async Task <JsonResult> Save(BookPageModel model)
{
Response <BookModel> responseSaving = JsonConvert.DeserializeObject <Response <BookModel> >(UiRequestManager.Instance.Post("Book", "Save", JsonConvert.SerializeObject(model.bookModel)));
AppFileFilterModel appFileFilterModel = new AppFileFilterModel
{
AppFileModuleId = responseSaving.Value.Id,
ModuleType = API.Models.Enum.Enum.Module.BookThumbnail,
File = model.Thumbnail
};
var thumbNail = await AppFileUploadHelper.Instance.UploadFile(appFileFilterModel);
appFileFilterModel.File = model.Publication;
appFileFilterModel.ModuleType = API.Models.Enum.Enum.Module.Publication;
await AppFileUploadHelper.Instance.UploadFile(appFileFilterModel);
model.bookModel.CategoryTagAssigment.BookId = responseSaving.Value.Id;
model.bookModel.CategoryTagAssigment.BookName = model.bookModel.BookName;
model.bookModel.CategoryTagAssigment.BookSummary = model.bookModel.BookSummary;
model.bookModel.CategoryTagAssigment.SignUrl = thumbNail.Value.SignUrl;
model.bookModel.CategoryTagAssigment.AuthorId = model.bookModel.AuthorId;
model.bookModel.CategoryTagAssigment.AuthorSurname = model.bookModel.Author.Surname;
model.bookModel.CategoryTagAssigment.PublisherId = model.bookModel.PublisherId;
model.bookModel.CategoryTagAssigment.BookSummary = model.bookModel.BookSummary;
JsonConvert.DeserializeObject <Response <CategoryTagAssigmentModel> >(UiRequestManager.Instance.Post("CategoryTagAssignment", "Save", JsonConvert.SerializeObject(model.bookModel.CategoryTagAssigment)));
return(Json(responseSaving));
}
/// <summary>
/// Muestra el contenido de la página
/// </summary>
protected override void ShowPageReal(int pageIndex)
{
BookPageModel page = EBookContent.SearchPage(pageIndex + 1);
if (PageShow != null && page != null)
{
PageShow(this, new Controllers.PageShowEventArgs(System.IO.Path.Combine(PathTarget, page.FileName).Replace("/", "\\")));
}
}
/// <summary>
/// Inicializa las propiedades que muestran el cómic
/// </summary>
protected override void InitBookView()
{
ComicBook comicBook = new ComicBook();
int pageIndex = 0;
// Carga el archivo
comicBook.Load(Book.FileName);
// Crea la colección de páginas
ComicPages = new ControlListViewModel();
// Rellena la colección de páginas
foreach (ComicPage page in comicBook.Pages)
{
BookPageModel bookPage = new BookPageModel();
// Asigna las propiedades
bookPage.FileName = bookPage.FileName;
bookPage.PageNumber = pageIndex++;
// Añade la página del libro a la lista de página
ComicPages.Items.Add(new PageListItemViewModel(bookPage));
}
// Asigna el manejador de eventos
comicBook.ComicAction += (sender, comicArgs) =>
{
if (comicArgs.Action == EventComicArgs.ActionType.Uncompress)
{
int index = comicArgs.Actual - 1;
// Asigna los nombres de archivo
if (index < ComicPages.Items.Count && index < comicBook.Pages.Count &&
ComicPages.Items[index] is PageListItemViewModel page)
{
page.Page.FileName = comicBook.Pages[index].FileName;
page.ThumbFileName = comicBook.Pages[index].FileName;
}
// Si ya ha terminado, ordena los nombres
if (index >= ComicPages.Items.Count - 1)
{
// Ordena las páginas
comicBook.Pages.Sort();
// Asigna los nombres de archivo
for (int indexPage = 0; indexPage < comicBook.Pages.Count; indexPage++)
{
if (ComicPages.Items[indexPage] is PageListItemViewModel pageItem)
{
pageItem.Page.FileName = comicBook.Pages[indexPage].FileName;
pageItem.ThumbFileName = comicBook.Pages[indexPage].FileName;
}
}
}
// Se coloca en la primera página
ShowPageReal(0);
}
};
// Descomprime el archivo
comicBook.Uncompress(PathTarget, true);
}
public static BookPageModel ServiceBookToModelBook(this ServiceFullBook sfb)
{
BookPageModel model = new BookPageModel
{
ID = sfb.BookData.ID,
Name = sfb.BookData.Name,
PublishDate = sfb.BookData.FirstPublication,
AgeCategory = sfb.BookData.AgeCategory,
};
return(model);
}
public ActionResult Index()
{
BookPageModel bookPageModel = new BookPageModel();
Response <List <BookModel> > responsebooks = JsonConvert.DeserializeObject <Response <List <BookModel> > >(UiRequestManager.Instance.Get("Book", "List"));
bookPageModel.BookList = responsebooks.Value;
Response <List <AuthorModel> > responseauthor = JsonConvert.DeserializeObject <Response <List <AuthorModel> > >(UiRequestManager.Instance.Get("Author", "List"));
bookPageModel.AuthorList = responseauthor.Value;
Response <List <PublisherModel> > responsepublisher = JsonConvert.DeserializeObject <Response <List <PublisherModel> > >(UiRequestManager.Instance.Get("Publisher", "List"));
bookPageModel.PubLisherList = responsepublisher.Value;
return(View(bookPageModel));
}
public ActionResult Details(int id)
{
try
{
int userID = 0;
if (User.Identity.IsAuthenticated)
{
userID = (int) Profile["ID"];
}
BookPageModel model = Book.GetBookPageModel(id, userID);
return View(model);
}
catch (Exception ex)
{
logger.Error(ex);
return View("Error");
}
}
public static BookPageView Map(this BookPageModel model)
{
return(new BookPageView
{
BookId = model.BookId,
Text = model.Text,
SequenceNumber = model.SequenceNumber,
Status = model.Status.ToDescription(),
WriterAccountId = model.WriterAccountId,
WriterAccountName = model.WriterAccountName,
WriterAssignTimeStamp = model.WriterAssignTimeStamp,
ReviewerAccountId = model.ReviewerAccountId,
ReviewerAccountName = model.ReviewerAccountName,
ReviewerAssignTimeStamp = model.ReviewerAssignTimeStamp,
ChapterId = model.ChapterId,
ChapterTitle = model.ChapterTitle
});
}
/// <summary>
/// Convierte las páginas
/// </summary>
private BookPageModelCollection ConvertPagesEPub(LibEBook.Formats.eBook.IndexItemsCollection ePubPages)
{
BookPageModelCollection pages = new BookPageModelCollection();
// Añade las páginas
foreach (LibEBook.Formats.eBook.IndexItem ePubPage in ePubPages)
{
BookPageModel page = new BookPageModel();
// Asigna los datos
page.Name = ePubPage.Name;
page.FileName = ePubPage.URL;
page.Pages.AddRange(ConvertPagesEPub(ePubPage.Items));
// Añade la página a la colección
pages.Add(page);
}
// Devuelve la colección de páginas
return(pages);
}
/// <summary>
/// Convierte las páginas de un cómic
/// </summary>
private BookPageModelCollection ConvertPagesComic(BookModel book, string pathTarget)
{
LibComicsBooks.ComicBook comic = new LibComicsBooks.ComicBook();
BookPageModelCollection pages = new BookPageModelCollection();
// Descomprime el archivo
comic.Load(book.FileName);
// Asigna las páginas
for (int index = 0; index < comic.Pages.Count; index++)
{
BookPageModel page = new BookPageModel();
// Asigna los datos
page.Name = $"Página {index + 1}";
page.FileName = comic.Pages[index].FileName;
// Añade la página
pages.Add(page);
}
// Devuelve la colección de páginas
return(pages);
}
public BookPageView Render(BookPageModel source, int libraryId)
{
var result = source.Map();
var links = new List <LinkView>
{
_linkRenderer.Render(new Link
{
ActionName = nameof(BookPageController.GetPageByIndex),
Method = HttpMethod.Get,
Rel = RelTypes.Self,
Parameters = new { libraryId = libraryId, bookId = source.BookId, sequenceNumber = source.SequenceNumber }
}),
_linkRenderer.Render(new Link
{
ActionName = nameof(BookController.GetBookById),
Method = HttpMethod.Get,
Rel = RelTypes.Book,
Parameters = new { libraryId = libraryId, bookId = source.BookId }
})
};
if (!string.IsNullOrWhiteSpace(source.ImageUrl) && _fileStorage.SupportsPublicLink)
{
links.Add(new LinkView
{
Href = _fileStorage.GetPublicUrl(source.ImageUrl),
Method = "GET",
Rel = RelTypes.Image,
Accept = MimeTypes.Jpg
});
}
else if (source.ImageId.HasValue)
{
links.Add(_linkRenderer.Render(new Link
{
ActionName = nameof(FileController.GetFile),
Method = HttpMethod.Get,
Rel = RelTypes.Image,
Parameters = new { fileId = source.ImageId.Value }
}));
}
if (source.PreviousPage != null)
{
links.Add(_linkRenderer.Render(new Link
{
ActionName = nameof(BookPageController.GetPageByIndex),
Method = HttpMethod.Get,
Rel = RelTypes.Previous,
Parameters = new { libraryId = libraryId, bookId = source.PreviousPage.BookId, sequenceNumber = source.PreviousPage.SequenceNumber }
}));
}
if (source.NextPage != null)
{
links.Add(_linkRenderer.Render(new Link
{
ActionName = nameof(BookPageController.GetPageByIndex),
Method = HttpMethod.Get,
Rel = RelTypes.Next,
Parameters = new { libraryId = libraryId, bookId = source.NextPage.BookId, sequenceNumber = source.NextPage.SequenceNumber }
}));
}
if (_userHelper.IsWriter(libraryId) || _userHelper.IsLibraryAdmin(libraryId) || _userHelper.IsAdmin)
{
links.Add(_linkRenderer.Render(new Link
{
ActionName = nameof(BookPageController.UpdatePage),
Method = HttpMethod.Put,
Rel = RelTypes.Update,
Parameters = new { libraryId = libraryId, bookId = source.BookId, sequenceNumber = source.SequenceNumber }
}));
links.Add(_linkRenderer.Render(new Link
{
ActionName = nameof(BookPageController.DeletePage),
Method = HttpMethod.Delete,
Rel = RelTypes.Delete,
Parameters = new { libraryId = libraryId, bookId = source.BookId, sequenceNumber = source.SequenceNumber }
}));
if (_userHelper.IsLibraryAdmin(libraryId) || _userHelper.IsAdmin)
{
links.Add(_linkRenderer.Render(new Link
{
ActionName = nameof(BookPageController.AssignPage),
Method = HttpMethod.Post,
Rel = RelTypes.Assign,
Parameters = new { libraryId = libraryId, bookId = source.BookId, sequenceNumber = source.SequenceNumber }
}));
}
links.Add(_linkRenderer.Render(new Link
{
ActionName = nameof(BookPageController.UpdatePageSequence),
Method = HttpMethod.Post,
Rel = RelTypes.PageSequence,
Parameters = new { libraryId = libraryId, bookId = source.BookId, sequenceNumber = source.SequenceNumber }
}));
if (
((source.Status == Domain.Models.EditingStatus.Available ||
source.Status == Domain.Models.EditingStatus.Typing) &&
source.WriterAccountId != _userHelper.Account.Id) ||
((source.Status == Domain.Models.EditingStatus.Typed ||
source.Status == Domain.Models.EditingStatus.InReview) &&
source.ReviewerAccountId != _userHelper.Account.Id)
)
{
links.Add(_linkRenderer.Render(new Link
{
ActionName = nameof(BookPageController.AssignPageToUser),
Method = HttpMethod.Post,
Rel = RelTypes.AssignToMe,
Parameters = new { libraryId = libraryId, bookId = source.BookId, sequenceNumber = source.SequenceNumber }
}));
}
if (source.ImageId.HasValue)
{
links.Add(_linkRenderer.Render(new Link
{
ActionName = nameof(BookPageController.UpdatePageImage),
Method = HttpMethod.Put,
Rel = RelTypes.ImageUpload,
Parameters = new { libraryId = libraryId, bookId = source.BookId, sequenceNumber = source.SequenceNumber }
}));
links.Add(_linkRenderer.Render(new Link
{
ActionName = nameof(BookPageController.DeletePageImage),
Method = HttpMethod.Delete,
Rel = RelTypes.ImageDelete,
Parameters = new { libraryId = libraryId, bookId = source.BookId, sequenceNumber = source.SequenceNumber }
}));
links.Add(_linkRenderer.Render(new Link
{
ActionName = nameof(BookPageController.OcrPage),
Method = HttpMethod.Post,
Rel = RelTypes.Ocr,
Parameters = new { libraryId = libraryId, bookId = source.BookId, sequenceNumber = source.SequenceNumber }
}));
}
else
{
links.Add(_linkRenderer.Render(new Link
{
ActionName = nameof(BookPageController.UpdatePageImage),
Method = HttpMethod.Put,
Rel = RelTypes.ImageUpload,
Parameters = new { libraryId = libraryId, bookId = source.BookId, sequenceNumber = source.SequenceNumber }
}));
}
}
result.Links = links;
return(result);
}
public PageNodeViewModel(IHierarchicalViewModel nodePageParent, BookPageModel page)
: base(nodePageParent, page.Name, page, true)
{
Page = page;
}
public BookModel(Context context)
{
_context = context;
contentModel = new BookPageModel();
}
public PageListItemViewModel(BookPageModel page) : base((page.PageNumber + 1).ToString(), page)
{
Page = page;
}
public ActionResult Book(int? id, BookPageModel model)
{
if (id != null)
{
var con = new BookEntitiModel(new Uri("http://booksstore.apphb.com/BookWCFDataService.svc"));
var res = from cont in con.Books
where cont.BookID == id
select cont;
var firstOrDefault = res.FirstOrDefault();
if (firstOrDefault != null)
foreach (var cont in con.Comments)
{
if (cont.BookID == id)
firstOrDefault.Comments.Add(cont);
}
if (firstOrDefault != null) ViewBag.Message = firstOrDefault.Title;
var view = new BookPageModel() { BookModel = firstOrDefault, CommentModel = new CommentModels() };
wtf.CurrentBook = firstOrDefault;
return View(view);
}
ModelState.Clear();
if (model.CommentModel != null && !string.IsNullOrEmpty(model.CommentModel.Text))
{
var name = User.Identity.IsAuthenticated ? User.Identity.Name : "Анонімний";
var newcomment = new Comment()
{
Added = DateTime.Now,
Text = model.CommentModel.Text,
Name = name,
Book = wtf.CurrentBook,
BookID = wtf.CurrentBook.BookID
};
var context = new BookEntitiModel(new Uri("http://booksstore.apphb.com/BookWCFDataService.svc"));
var t = context.Comments.Where(p => p.BookID == newcomment.BookID).Where(p => p.Name == newcomment.Name).Where(p=>p.Text == newcomment.Text).ToList();
if (t.Count==0)
{
context.AddToComments(newcomment);
context.SaveChanges();
}
if (wtf.CurrentBook.Comments != null)
{
wtf.CurrentBook.Comments.Clear();
foreach (var cont in context.Comments.Where(p => p.BookID == wtf.CurrentBook.BookID))
{
wtf.CurrentBook.Comments.Add(cont);
}
}
}
var currentview = new BookPageModel() { BookModel = wtf.CurrentBook, CommentModel = new CommentModels() };
// ptr = false;
return View(currentview);
}
