public IActionResult Put(int id, [FromBody] BooksViewModel books)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Books _booksDb = _booksRepository.GetSingle(id);
if (_booksDb == null)
{
return(NotFound());
}
else
{
_booksDb.Title = books.Title;
_booksDb.Isbn = books.Isbn;
_booksDb.Price = books.Price;
_booksDb.AvailableQuantity = books.AvailableQuantity;
_booksDb.AuthorId = books.AuthorId;
// _booksDb.Author = books.Author;
_booksDb.CreateDate = books.CreateDate;
_booksRepository.Commit();
}
books = Mapper.Map <Books, BooksViewModel>(_booksDb);
return(new NoContentResult());
}
public async Task <IActionResult> Post(BooksViewModel book)
{
if (!string.IsNullOrEmpty(book.BookName))
{
var isExist = await _BookService.GetByName(book.BookName);
if (isExist != null && isExist.Id > 0)
{
return(BadRequest("Book already exists"));
}
var newBook = new Books()
{
BookName = book.BookName,
CreatedBy = book.CreatedBy,
CreatedDate = DateTime.UtcNow,
Price = book.Price,
};
_BookService.AddAsync(newBook);
return(Ok());
}
else
{
return(BadRequest());
}
}
public Books()
{
InitializeComponent();
var books = new BooksViewModel();
DataContext = books;
}
public async Task <IActionResult> Search([FromQuery(Name = "pattern")] string search = "", [FromQuery(Name = "page")] int page = 1)
{
if (page < 1)
{
return(NotFound($"Invalid page '{page}'! Should be 1 or more."));
}
var searchPattern = search ?? string.Empty;
var result = await _booksClient.Get(searchPattern, (page - 1) *BooksOnPage, BooksOnPage);
if (result.ResponseMessage.StatusCode != HttpStatusCode.OK)
{
ModelState.AddModelError(string.Empty, result.ResponseMessage.Content.ToString());
}
else
{
var books = result.GetContent();
var totalPages = (int)Math.Ceiling(books.TotalBooksCount / (decimal)BooksOnPage);
var vm = new BooksViewModel
{
TotalBooksCount = books.TotalBooksCount,
Pagination = new PaginationViewModel(totalPages, page),
BooksOnPage = _mapper.Map <IEnumerable <Book>, IEnumerable <BookViewModel> >(books.Books),
SearchPattern = searchPattern
};
return(View(vm));
}
return(View());
}
public BooksViewModel GetBooksViewModel()
{
BooksViewModel booksViewModel = new BooksViewModel();
booksViewModel.Books = GetBookViewModelEnumerable().ToList();
return(booksViewModel);
}
public async Task <IActionResult> Index(string searchString)
{
var viewModel = new BooksViewModel()
{
Database = "wookie_books",
Collection = "books"
};
viewModel.Documents = await _documentService.GetDocuments(viewModel.Database, viewModel.Collection);
// convert BSON list to JSON to BookViewModel
var dotNetObjList = viewModel.Documents.ConvertAll(BsonTypeMapper.MapToDotNetValue);
string jsonBooksList = JsonConvert.SerializeObject(dotNetObjList);
viewModel.BooksList = JsonConvert.DeserializeObject <List <BookViewModel> >(jsonBooksList);
if (!String.IsNullOrEmpty(searchString))
{
var viewModelWithSearch = new BooksViewModel()
{
Database = "wookie_books",
Collection = "books"
};
viewModel.BooksList = viewModel.BooksList.Where(s => s.Title.ToUpper().Contains(searchString.ToUpper())).ToList();
}
return(View(viewModel));
}
public static void SortBooksFromBooksViewModel(BooksViewModel model, BookSortMethod m)
{
switch (m)
{
case BookSortMethod.ByID:
model.Books.Sort((x, y) => x.ID.CompareTo(y.ID));
break;
case BookSortMethod.ByTitle:
model.Books.Sort((x, y) => x.Title.CompareTo(y.Title));
break;
case BookSortMethod.ByAuthor:
model.Books.Sort((x, y) => x.Author.CompareTo(y.Author));
break;
case BookSortMethod.ByPages:
model.Books.Sort((x, y) => x.Pages.CompareTo(y.Pages));
break;
case BookSortMethod.ByYearReaded:
model.Books.Sort((x, y) => x.YearReaded.CompareTo(y.YearReaded));
break;
case BookSortMethod.ByYearRelease:
model.Books.Sort((x, y) => x.YearPublished.CompareTo(y.YearPublished));
break;
case BookSortMethod.ByState:
model.Books.Sort((x, y) => x.State.CompareTo(y.State));
break;
}
}
public BooksView()
{
InitializeComponent();
ViewModel = new BooksViewModel();
this.DataContext = this;
}
public ActionResult Edit(BooksViewModel model)
{
if (ModelState.IsValid == false)
{
var bookModelId = _unitOfWork.Repo.GetBooks().FirstOrDefault(b => b.BookId == model.BookId).BookId;
var authorname = _unitOfWork.Repo.GetAuthors().FirstOrDefault(b => b.AuthorId == model.AuthorId).FullName;
model.PreparForEdit(bookModelId);
model.AuthorName = authorname;
return(View(model));
}
try
{
var m = Mapper.Map <BooksViewModel, Book>(model);
_unitOfWork.Repo.EditBook(m);
_unitOfWork.Complete();
return(RedirectToAction("Details", new
{
id = m.BookId
}));
}
catch
{
return(View("Error"));
}
}
//View _currentView;
////StackLayout slideDots;
//double _height, _width;
//private Image[] dots;
//CarouselPage CarouselPage;
//int numPage, currentPage = 0;
////Timer timer;
//int dotCount = 1;
public BooksPage()
{
InitializeComponent();
BindingContext = new BooksViewModel();
////List<Book> images = ;
//numPage = 3;
//dots = new Image[numPage];
//Image whiteDot = new Image();
//for (int i = 0; i < numPage; i++)
//{
// dots[i] = new Image();
// dots[i].Source = ImageSource.FromResource("CarouselView.Images.Dots.noactive_dot.png");
// //LinearLayout.LayoutParams param = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.WrapContent, LinearLayout.LayoutParams.WrapContent);
// //param.SetMargins(8, 0, 8, 0);
// //slideDots.AddView(dots[i], param);
// slideDots.Children.Add(dots[i]);
//}
//dots[0].Source = ImageSource.FromResource("CarouselView.Images.Dots.active_dot.png");
}
// GET: Books
public ActionResult Index()
{
BooksViewModel vm = db.GetBooks();
var books = vm.Books;
return(View(books));
}
public ActionResult Create(BooksViewModel knjigaCVM)
{
//sve na frontu
if (ModelState.IsValid == false)
{
return(RedirectToAction("Create"));
}
try
{
var book = Mapper.Map <BooksViewModel, Book>(knjigaCVM);
var author = _unitOfWork.Repo.GetAuthors().FirstOrDefault(b => b.AuthorId == knjigaCVM.AuthorId);
book.Author = author;
_unitOfWork.Repo.AddBook(book);
_unitOfWork.Complete();
return(RedirectToAction("Details", "Books", new
{
id = book.BookId
}));
}
catch
{
ViewBag.SomeError = "Unošenje podataka nije uspjelo";
return(RedirectToAction("Create"));
}
}
public BooksView()
{
InitializeComponent();
context = new BooksViewModel();
BindingContext = context;
this.Title = "App Javeriana";
}
public void TestA3()
{
ViewResult result = controller.Index(2, null, null, null) as ViewResult;
BooksViewModel model = result.Model as BooksViewModel;
Assert.AreEqual(0, model.Books.Count);
}
protected override void OnCreate(Bundle bundle)
{
base.OnCreate(bundle);
SetContentView(Resource.Layout.Toolbar);
_viewModel = new BooksViewModel();
Button button = FindViewById <Button>(Resource.Id.myButton);
var list = FindViewById <ListView>(Resource.Id.listView1);
button.Click += async delegate
{
button.Enabled = false;
var bookName = FindViewById <EditText>(Resource.Id.bookTitle).Text;
await _viewModel.GetBooksAsAsync(bookName);
list.Adapter = new ArrayAdapter <string>(this,
Android.Resource.Layout.SimpleListItem1,
Android.Resource.Id.Text1,
_viewModel.AllegroBooksResponses.Select(m => $"Nazwa aukcji: {m.auctionName}\n" +
$"Numer aukcji: {m.auctionNumber}\n" +
$"Cena produktu: {m.productPrice} zł\n" +
$"Cena dostawy: {m.lowestPriceDelivery}\n"
).ToArray());
button.Enabled = true;
};
}
public Books()
{
InitializeComponent();
_booksViewModel = Startup.Resolve <BooksViewModel>();
BindingContext = _booksViewModel;
}
public override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
_viewModel = ViewModelProviders.Of(this).Get(DependencyLocator.Current.CreateBooksViewModel);
_viewModel.ViewDidLoad();
}
//Chamadas assíncronas para otimizar o programa
public async Task <IActionResult> Books()
{
var model = new BooksViewModel {
Books = await db.Books.ToListAsync()
};
return(View(model));
}
public void TestC2()
{
ViewResult result = controller.Index(1, null, "Gone", null) as ViewResult;
BooksViewModel model = result.Model as BooksViewModel;
Assert.AreEqual(1, model.Books.Count);
Assert.AreEqual("Gone Girl", model.Books[0].Name);
}
private void Filter_Click(object sender, RoutedEventArgs e)
{
Grid parentGrid = (Grid)((Button)sender).Parent;
object fromDate = ((ComboBox)parentGrid.FindName("FromDateCombo")).SelectionBoxItem;
object toDate = ((ComboBox)parentGrid.FindName("ToDateCombo")).SelectionBoxItem;
BooksViewModel.LoadFilteredPage((string)fromDate, (string)toDate);
}
public BooksController(ApplicationDbContext db)
{
_db = db;
BooksVM = new BooksViewModel()
{
Books = new List <Book>()
};
}
public void TestA2()
{
ViewResult result = controller.Index(1, null, null, "Historical Fiction") as ViewResult;
BooksViewModel model = result.Model as BooksViewModel;
Assert.AreEqual(1, model.Books.Count);
Assert.AreEqual("Girl with a Pearl Earring", model.Books[0].Name);
}
public ActionResult Create()
{
var BookVM = new BooksViewModel();
BookVM.PrepareForCreateNew();
return(View(BookVM));
}
// GET: Books
public ActionResult Books()
{
var booksViewMoel = new BooksViewModel();
var repo = new FantasyRepository();
booksViewMoel.Books = repo.GetAllBooks();
return(View(booksViewMoel));
}
public async Task <IActionResult> Index()
{
var model = new BooksViewModel();
var userID = _UserManager.GetUserId(this.User);
model.Books = await _BookService.GetBooksForUser(new Guid(userID));
return(View(model));
}
public IActionResult Books()
{
var model = new BooksViewModel()
{
Products = _JsonFileProductService.GetProducts().ToList(), Tags = _TextAnalyzerService.AnalyzeText("My cat is vegeterian")
};
return(View(model));
}
public ActionResult AddBook()
{
var model = new BooksViewModel
{
Categories = GetCategories()
};
return(View(model));
}
public ActionResult Create()
{
BooksViewModel booksViewModel = new BooksViewModel();
booksViewModel.authors = db.author.ToList();
booksViewModel.bookBranches = db.bookBranch.ToList();
booksViewModel.bookPublications = db.bookPublication.ToList();
return(View(booksViewModel));
}
public IActionResult Index()
{
var model = new BooksViewModel()
{
Tags = _textAnalyzerService.AnalyzeText("My cat is vegeterian")
};
return(View(model));
}
public ActionResult Edit(int id)
{
var model = new BooksViewModel();
var m = _unitOfWork.Repo.GetBooks().FirstOrDefault(b => b.BookId == id);
model = Mapper.Map <Book, BooksViewModel>(m);
model.PreparForEdit(id);
return(View(model));
}
public ActionResult Index(int? page)
{
IEnumerable<Book> items = BooksController._library;
if (page.HasValue)
items = items.Skip((page.Value - 1) * BooksController.PageSize);
items = items.Take(BooksController.PageSize);
var viewModel = new BooksViewModel(items, (int)Math.Ceiling(BooksController._library.Count / (double)BooksController.PageSize), page ?? 1);
return this.View(viewModel);
}