public async Task <ActionResult> LibraryBook(string id = null)
{
LibraryBookViewModel viewModel = null;
if (!string.IsNullOrEmpty(id))
{
LibraryBookResponse result = await _libraryBookClient.GetLibraryBookByLibraryBookCode(id);
if (result.StatusIsSuccessful)
{
viewModel = LibraryBookViewModel.CreateLibraryBookViewModel(result.Data);
}
else
{
AddResponseErrorsToModelState(result);
}
}
if (viewModel == null)
{
viewModel = new LibraryBookViewModel();
}
return(View(viewModel));
}
public async Task <ActionResult> SaveLibraryBook(LibraryBookViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(View("LibraryBook", viewModel));
}
string currentCode = string.Empty;
if (string.IsNullOrEmpty(viewModel.LibraryBookCode))
{
var insertResponse = await _libraryBookClient.Insert(viewModel.GetApiModel());
if (!insertResponse.StatusIsSuccessful)
{
AddResponseErrorsToModelState(insertResponse);
}
else
{
//viewModel.Id = insertResponse.ResponseResult;
currentCode = insertResponse.ResponseResult;
TempData["SuccessMessage"] = "Record Inserted";
}
}
else
{
currentCode = viewModel.LibraryBookCode;
var response = await _libraryBookClient.Update(viewModel.GetApiModel());
if (!response.StatusIsSuccessful)
{
AddResponseErrorsToModelState(response);
}
else
{
TempData["SuccessMessage"] = "Record Updated";
}
}
return(View("LibraryBook", viewModel));
}
public async Task <ActionResult> GetLibraryBooks(LibraryBookViewModel param)
{
int sortDirection = 0;
string strSortDirection = Request.Query["sSortDir_0"]; // asc or desc
if (strSortDirection == "asc")
{
sortDirection = 0;
}
else
{
sortDirection = 1;
}
int sortColumnIndex = Convert.ToInt32(Request.Query["iSortCol_0"]);
int pageNumber = (param.iDisplayStart / param.iDisplayLength) + 1;
PagedBase filterParameters = new PagedBase()
{
SearchText = param.sSearch,
PageNum = pageNumber,
PageSize = param.iDisplayLength,
OrderBy = sortColumnIndex,
SortOrder = sortDirection
};
LibraryBookPagedListResponse response = await _libraryBookClient.GetLibraryBooksPaged(filterParameters, true);
if (response.ResponseCode == HttpStatusCode.Unauthorized)
{
//return new HttpStatusCodeResult(HttpStatusCode.Unauthorized, Url.Action("Logout", "UserAccount", new { area = "" }));
return(new StatusCodeResult((int)HttpStatusCode.Unauthorized));
}
IEnumerable <string[]> result = new List <string[]>();
int TotalDisplayRecords = 0;
if (response.StatusIsSuccessful)
{
if (response.Data.Results != null)
{
result = from c in response.Data.Results
select new[] {
c.LibraryBookCode,
c.ISBN,
c.Author,
c.Title,
c.CopyNumber.ToString(),
c.IsLost.ToString(),
c.IsStolen.ToString(),
//c.CreatedBy,
//c.DateCreated.ToString(),
c.ModifiedBy,
c.DateModified.ToString()
};
TotalDisplayRecords = response.Data.Results.Count();
}
}
#pragma warning disable IDE0037
return(Json(new
{
sEcho = param.sEcho,
iTotalRecords = response.Data.SearchResultCount,
iTotalDisplayRecords = response.Data.SearchResultCount,
aaData = result
}));
#pragma warning restore IDE0037
}
// GET: /<controller>/
public IActionResult Index(LibraryBookViewModel viewModel)
{
return(View(viewModel));
}
public async Task <IActionResult> CreateAsync(
[FromBody] LibraryBookViewModel libraryBook
)
{
try
{
// parametro necessário não foi carregado
if (string.IsNullOrEmpty(libraryBook.Book.CodeIntegration))
{
return(NotFound(new ResponseErrorViewModel
{
Status = Constants.Error,
Errors = new List <object>
{
new { Message = Constants.LibraryNotFound }
}
}));
}
var libraryBookMap = _mapper.Map <LibraryBook>(libraryBook);
var bookDb = await _bookMananger
.GetByCodeIntegration(libraryBookMap.Book.CodeIntegration);
// verificar se já existe livro ativo na biblioteca
// realizar validações nos campos do livro quando não existir
if (bookDb != null)
{
libraryBookMap.Book = bookDb;
}
// quando livro não existir criar
if (bookDb == null)
{
bookDb = new Book();
// verificar se existe autores
var authors = new List <Author>();
foreach (var authorMap in libraryBookMap.Book.AuthorBooks)
{
var authorDb = await _authorMananger
.GetByName(authorMap.Author.Name);
if (authorDb == null)
{
authorDb = new Author
{
Name = authorMap.Author.Name,
Active = true,
CreatedAt = Util.CurrentDateTime(),
UpdatedAt = Util.CurrentDateTime()
};
}
if (bookDb.AuthorBooks == null)
{
bookDb.AuthorBooks = new List <AuthorBook>();
}
bookDb.AuthorBooks.Add(
new AuthorBook
{
Author = authorDb,
Book = bookDb
}
);
}
// verificar se existe categorias
foreach (var categoryMap in libraryBookMap.Book.CategoryBooks)
{
var categoryDb = await _categoryMananger
.GetByName(categoryMap.Category.Name);
if (categoryDb == null)
{
categoryDb = new Category
{
Name = categoryMap.Category.Name,
CreatedAt = Util.CurrentDateTime()
};
}
if (bookDb.CategoryBooks == null)
{
bookDb.CategoryBooks = new List <CategoryBook>();
}
bookDb.CategoryBooks.Add(
new CategoryBook
{
Category = categoryDb,
Book = bookDb
}
);
}
bookDb.AverageRating = libraryBookMap.Book.AverageRating;
bookDb.CodeIntegration = libraryBookMap.Book.CodeIntegration;
bookDb.Isbn13 = libraryBookMap.Book.Isbn13;
bookDb.Title = libraryBookMap.Book.Title;
bookDb.MaturityRating = libraryBookMap.Book.MaturityRating;
bookDb.CreatedAt = Util.CurrentDateTime();
}
// capturar login
var login = Util.GetClaim(_httpContext,
Constants.UserClaimIdentifier);
// carrega usuario
var userDb = await _userMananger.GetByLogin(login);
// verificar quando for PJ se está com o plano ativo
if (userDb.Person.PersonType.Equals("PJ") && userDb.Person
.PersonSubscriptions.Any(x => x.Validate != true))
{
return(BadRequest(new ResponseErrorViewModel
{
Errors = new List <object>
{
new { Message = Constants.UserPlanInvalid }
},
Status = Constants.Error
}));
}
if (userDb.Person.Addresses == null ||
userDb.Person.Addresses.Count <= 0)
{
return(NotFound(new ResponseErrorViewModel
{
Status = Constants.Error,
Errors = new List <object>
{
new { Message = Constants.UserAddressNotFound }
}
}));
}
var libraryDb = await _libraryMananger
.GetLibraryByPerson(userDb.IdPerson);
if (libraryDb != null)
{
libraryBookMap.Library = libraryDb;
}
// capturar tipos
var typesDb = new List <Models.Type>();
libraryBookMap.LibraryBookTypes = new List <LibraryBookType>();
foreach (var type in libraryBook.Types)
{
var typeDb = await _typeMananger
.GetByDescriptionAsync(type.Description);
if (typeDb != null)
{
libraryBookMap.LibraryBookTypes.Add(new LibraryBookType
{
LibraryBook = libraryBookMap,
Type = typeDb
});
}
}
// não localizou os tipos
if (libraryBookMap.LibraryBookTypes.Count <= 0)
{
return(BadRequest(new ResponseErrorViewModel
{
Errors = new List <object>
{
new { Message = Constants.InvalidType }
},
Result = Constants.Error
}));
}
libraryBookMap.Description = libraryBook.Book.Description;
libraryBookMap.Book = bookDb;
libraryBookMap.Active = true;
libraryBookMap.Price = userDb.Person.PersonType
.Equals("PF") ? 0 : libraryBookMap.Price;
libraryBookMap.CreatedAt = Util.CurrentDateTime();
libraryBookMap.UpdatedAt = libraryBookMap.CreatedAt;
await _libraryBookMananger.CreateAsync(libraryBookMap);
_uow.Commit();
var libraryBookCreated = _mapper.Map <LibraryBookViewModel>(libraryBookMap);
return(Created(
new Uri(Url.ActionLink("Create", "Book")),
new ResponseViewModel
{
Result = libraryBookCreated,
Status = Constants.Sucess
}));
}
catch (Exception ex)
{
// gerar log
return(BadRequest(new
{
Status = Constants.Error,
Errors = new List <object>
{
Util.ReturnException(ex)
}
}));
}
}
public async Task <IActionResult> UpdateAsync(
[FromBody] LibraryBookViewModel library
)
{
try
{
var libraryDb = await _libraryBookMananger
.GetByIdAsync(library.Id);
// não localizou
if (libraryDb == null)
{
return(BadRequest(new ResponseErrorViewModel
{
Status = Constants.Error,
Errors = new List <object>
{
new { Message = Constants.LibraryNotFound }
}
}));
}
var libraryBookMap = _mapper.Map <LibraryBook>(library);
// captura objetos que estão no banco
var typesDb = libraryDb.LibraryBookTypes.ToArray();
if (libraryBookMap.LibraryBookTypes.Count > 0)
{
// percorrer tipos dos livros cadastrados
foreach (var type in typesDb)
{
// verificar se existe no objeto enviado
if (!libraryBookMap.LibraryBookTypes
.Any(x => x.Type.Description.Equals(type.Type.Description)))
{
libraryDb.LibraryBookTypes.Remove(type);
}
}
// percorrer os novos tipos
foreach (var type in libraryBookMap.LibraryBookTypes)
{
if (typesDb.FirstOrDefault(x => x.Type.Description
.ToLower().Equals(type.Type.Description.ToLower())) == null)
{
var typeDb = await _typeMananger
.GetByDescriptionAsync(type.Type.Description);
if (typeDb != null)
{
libraryDb.LibraryBookTypes.Add(
new LibraryBookType
{
Type = typeDb,
LibraryBook = libraryDb
});
}
}
}
}
libraryDb.UpdatedAt = Util.CurrentDateTime();
libraryDb.Description = libraryBookMap.Description;
_libraryBookMananger.Update(libraryDb);
_uow.Commit();
return(Ok(new ResponseViewModel
{
Result = null,
Status = Constants.Sucess
}));
}
catch (Exception ex)
{
// gerar log
return(BadRequest(new
{
Status = Constants.Error,
Errors = new List <object>
{
Util.ReturnException(ex)
}
}));
}
}
