public IHttpActionResult Get([FromUri] BookSearch data)
        {
            // search for book by title, author, or genre.
            // bind author and genre params to book search
            // fromuri = force web api to read complex data type (object)
            var db        = new LibraryContext();
            var bookQuery = db.Books.Include(i => i.Author).Include(i => i.Genre);

            // if string has any params from BookSearch class, return them.
            if (!String.IsNullOrEmpty(data.Title))
            {
                bookQuery = bookQuery.Where(w => w.Title.Contains(data.Title));
            }

            if (!String.IsNullOrEmpty(data.Author))
            {
                bookQuery = bookQuery.Where(w => w.Author.Name.Contains(data.Author));
            }
            if (!String.IsNullOrEmpty(data.Genre))
            {
                bookQuery = bookQuery.Where(w => w.Genre.Name.Contains(data.Genre));
            }
            var results = bookQuery.ToList();

            if (results.Count == 0)
            {
                return(NotFound());
            }
            else
            {
                return(Ok(results));
            }
        }
Esempio n. 2
0
        public PagedResponse <BookDto> Execute(BookSearch search)
        {
            var query = _context.Books
                        .Include(x => x.Title)
                        .ThenInclude(x => x.TitleAuthors)
                        .ThenInclude(x => x.Author)
                        .Include(x => x.Title)
                        .ThenInclude(x => x.Publisher)
                        .Include(x => x.Title)
                        .ThenInclude(x => x.Category)
                        .Include(x => x.Title)
                        .ThenInclude(x => x.Prices)
                        .DefaultFilter(search);

            if (search.TitleIds.Count() > 0)
            {
                query = query.Where(x => search.TitleIds.Contains(x.TitleId));
            }

            if (search.SerialNumber.HasValue)
            {
                query = query.Where(x => x.SerialNumber.ToString().ToLower().Contains(search.SerialNumber.ToString().ToLower()));
            }

            return(query.Paged <BookDto, Domain.Book>(search, _mapper));
        }
        private void BookSearch_Click(object sender, RoutedEventArgs e)
        {
            List <Book> books  = ProcessBookFile("books.csv");
            BookSearch  search = new BookSearch(books);

            search.ShowDialog();
        }
Esempio n. 4
0
        public ActionResult BookSearch(string query)
        {
            BookSearch       bookSearch = new BookSearch();
            List <BookModel> bookModels = bookSearch.Search(query);

            return(View(bookModels));
        }
 private void updateButton_Click(object sender, RoutedEventArgs e)
 {
     try
     {
         if (iSBNTextBox.Text == "")
         {
             throw new Exception("Please enter the ISBN of the book you would like to update.");
         }
         BookSearch search = new BookSearch(books, people, iSBNTextBox.Text.Trim());
         search.ISBNSearch();
         if (search.FoundBooks.Count == 0)
         {
             throw new Exception("No book was found with that ISBN.");
         }
         //The found book will now be placed into a bookUpdater object for the updating process
         BookUpdater updater = new BookUpdater(books, people, logs, search.FoundBooks[0]);
         //Load the bookUpdatePage
         Reset();
         this.NavigationService.Navigate(new UpdateBookPage(updater));
     }
     catch (Exception ex)
     {
         errorLabel.Content = ErrorHandler.InnermostExceptionMessage(ex);
     }
 }
Esempio n. 6
0
        public List <Book> FindBooks(BookSearch entity)
        {
            List <Book> books = _bookRepository.GetAll();

            if (!String.IsNullOrEmpty(entity.TitleSearch))
            {
                books = books.Where(x => x.Title.Contains(entity.TitleSearch)).ToList();
            }

            if (!String.IsNullOrEmpty(entity.ISBNSearch))
            {
                books = books.Where(x => x.ISBN.Contains(entity.ISBNSearch)).ToList();
            }

            if (entity.AuthorSearch != null)
            {
                books = books.Where(x => x.Authors.Any(y => y.Id == entity.AuthorSearch)).ToList();
            }

            if (entity.LanguageSearch != null)
            {
                books = books.Where(x => x.Language.Id == entity.LanguageSearch).ToList();
            }

            if (entity.GenreSearch != null)
            {
                books = books.Where(x => x.Genre != null).Where(x => x.Genre.Id == entity.GenreSearch).ToList();
            }

            return(books);
        }
Esempio n. 7
0
        public List <Book> BuscarLivros(BookSearch busca, string path = "")
        {
            List <Book> books = Repository.Data(path);

            books = books.Where(x =>
                                (string.IsNullOrWhiteSpace(busca.Name) || RemoveDiacritics(x.Name).Contains(RemoveDiacritics(busca.Name))) &&
                                (string.IsNullOrWhiteSpace(busca.Author) || RemoveDiacritics(x.Specifications.Author).Contains(RemoveDiacritics(busca.Author))) &&
                                (string.IsNullOrWhiteSpace(busca.Illustrator) || x.Specifications.Illustrator.Any(i => RemoveDiacritics(i).Contains(RemoveDiacritics(busca.Illustrator)))) &&
                                (string.IsNullOrWhiteSpace(busca.Genres) || x.Specifications.Genres.Any(g => RemoveDiacritics(g).Contains(RemoveDiacritics(busca.Genres)))) &&
                                (busca.MinPrice == null || x.Price >= busca.MinPrice) &&
                                (busca.MaxPrice == null || x.Price <= busca.MaxPrice) &&
                                (busca.MinPage == null || x.Specifications.PageCount >= busca.MinPage) &&
                                (busca.MaxPage == null || x.Specifications.PageCount <= busca.MaxPage)
                                ).ToList();

            books.ForEach(x => x.ShippingFee = Math.Round(x.Price * 0.2, 2));

            if (!string.IsNullOrWhiteSpace(busca.Order))
            {
                if (busca.Order == "asc")
                {
                    books = books.OrderBy(x => x.Price).ToList();
                }
                else if (busca.Order == "desc")
                {
                    books = books.OrderByDescending(x => x.Price).ToList();
                }
            }

            return(books);
        }
Esempio n. 8
0
        public void SearchTest()
        {
            BookSearch bookSearch = new BookSearch();
            var        result     = bookSearch.Search("Spinning Silver");

            Assert.AreEqual(result != null, true);
        }
        //search
        public async Task <List <BookSearch> > SearchBook(BookSearch searchdata)
        {
            var sql = @"SELECT bd.BOOK_ID AS BookID,bc.BOOK_CLASS_NAME AS BookClassId,bd.BOOK_NAME AS BookName, CONVERT(varchar, bd.BOOK_BOUGHT_DATE, 111) AS BoughtDate, bcd.CODE_NAME AS BookStatusId, mm.USER_ENAME AS BookKeeperId
						FROM BOOK_DATA bd
								INNER JOIN BOOK_CLASS bc
									ON bd.BOOK_CLASS_ID = bc.BOOK_CLASS_ID
								INNER JOIN BOOK_CODE bcd
									ON bd.BOOK_STATUS = bcd.CODE_ID AND bcd.CODE_TYPE = 'BOOK_STATUS'
								LEFT OUTER JOIN MEMBER_M mm
									ON bd.BOOK_KEEPER = mm.[USER_ID]
						WHERE(bd.BOOK_CLASS_ID = @BookClassId OR @BookClassId = '') AND
								(LOWER(bd.BOOK_NAME) LIKE ('%'+LOWER(@BookName)+'%') OR @BookName = '') AND
								(bcd.CODE_ID = @BookStatusId OR @BookStatusId = '') AND
									(mm.[USER_ID] = @BookKeeperId OR @BookKeeperId = '')
						ORDER BY bd.CREATE_DATE DESC"                        ;

            using (SqlConnection conn = new SqlConnection(this.GetDBConnectionString()))
            {
                var SearchList = await conn.QueryAsync <BookSearch>(sql, new
                {
                    BookClassId  = searchdata.BookClassId == null ? string.Empty : searchdata.BookClassId,
                    BookName     = searchdata.BookName == null ? string.Empty : searchdata.BookName,
                    BookStatusId = searchdata.BookStatusId == null ? string.Empty : searchdata.BookStatusId,
                    BookKeeperId = searchdata.BookKeeperId == null ? string.Empty : searchdata.BookKeeperId
                });

                return(SearchList.ToList());
            }
        }
Esempio n. 10
0
        public PageResponse <BookDTO> Execute(BookSearch request)
        {
            var query = _unitOfWork.Book.GetAll();

            if (request.MinPrice.HasValue)
            {
                query = query.Where(d => d.Price >= request.MinPrice);
            }
            if (request.MaxPrice.HasValue)
            {
                query = query.Where(d => d.Price <= request.MaxPrice);
            }
            if (request.MinPages.HasValue)
            {
                query = query.Where(d => d.Pages >= request.MinPages);
            }
            if (request.MaxPages.HasValue)
            {
                query = query.Where(d => d.Pages <= request.MaxPages);
            }
            if (request.Title != null)
            {
                var keyword = request.Title.ToLower();
                query = query.Where(d => d.Title.ToLower().Contains(keyword));
            }
            if (request.CategoryId != null)
            {
                query = query.Where(d => d.CategoryId == request.CategoryId);
            }
            if (request.AuthorId != null)
            {
                query = query.Where(d => d.AuthorId == request.AuthorId);
            }

            var totalCount = query.Count();

            query = query.Skip((request.PageNumber - 1) * request.PerPage).Take(request.PerPage);

            var pagesCount = (int)Math.Ceiling((double)totalCount / request.PerPage);
            var response   = new PageResponse <BookDTO>
            {
                CurrentPage = request.PageNumber,
                TotalCount  = totalCount,
                PageCount   = pagesCount,
                Data        = query.Select(d => new BookDTO()
                {
                    Id           = d.Id,
                    Title        = d.Title,
                    Price        = d.Price,
                    Description  = d.Description,
                    Pages        = d.Pages,
                    CategoryName = d.Category.Name,
                    AuthorName   = d.Author.FullName,
                    ImageUrl     = d.Image
                })
            };

            return(response);
        }
Esempio n. 11
0
        public SearchResultDTO Search(string term, int?userId)
        {
            term = term.Trim();
            if (String.IsNullOrWhiteSpace(term) || term.Length < 3)
            {
                //return empty result
                return(new SearchResultDTO()
                {
                    Id = -1,
                    Results = new SearchResultEntryDTO[0],
                    SearchTerm = null
                });
            }

            using (var db = new SDCContext())
            {
                //simple stuff:
                //return books that contain the term in their title.

                UserProfile profile = null;
                if (userId != null)
                {
                    profile = db.UserProfiles.FirstOrDefault(p => p.UserId == (int)userId);
                }



                var booksResult = (from b in db.Books
                                   where b.Shelf.IsVisible && b.Title.Contains(term)
                                   select new SearchResultBookDTO()
                {
                    Id = b.Id,
                    OwnerId = b.Shelf.Owner.UserId,
                    OwnerUserName = b.Shelf.Owner.UserName,
                    Title = b.Title,
                    Authors = b.Authors.Select(a => new AuthorDTO()
                    {
                        Id = a.Id,
                        Name = a.Name
                    }).ToList()
                }).ToArray();

                BookSearch search = new BookSearch()
                {
                    Date = DateTime.Now,
                    Term = term,
                    User = profile
                };

                db.BookSearches.Add(search);

                return(new SearchResultDTO()
                {
                    Id = search.Id,
                    Results = booksResult,
                    SearchTerm = term
                });
            }
        }
Esempio n. 12
0
        public void TestePaginas(int minPag, int maxPag, int count)
        {
            BookSearch busca = new BookSearch(null, null, null, null, minPag, maxPag, null, null, null);

            var resultado = BookService.BuscarLivros(busca, path);

            Assert.AreEqual(count, resultado.Count);
        }
Esempio n. 13
0
        public void TesteGenero(string genre, int count)
        {
            BookSearch busca = new BookSearch(null, null, null, null, null, null, null, genre, null);

            var resultado = BookService.BuscarLivros(busca, path);

            Assert.AreEqual(count, resultado.Count);
        }
Esempio n. 14
0
        public void TesteIlustrador(string illustrator, int count)
        {
            BookSearch busca = new BookSearch(null, null, null, null, null, null, illustrator, null, null);

            var resultado = BookService.BuscarLivros(busca, path);

            Assert.AreEqual(count, resultado.Count);
        }
Esempio n. 15
0
        public void TestePreco(double minPrice, double maxPrice, int count)
        {
            BookSearch busca = new BookSearch(null, minPrice, maxPrice, null, null, null, null, null, null);

            var resultado = BookService.BuscarLivros(busca, path);

            Assert.AreEqual(count, resultado.Count);
        }
Esempio n. 16
0
        public IActionResult Get(
            [FromQuery] BookSearch search,
            [FromServices] IGetBooksQuery query)
        {
            var result = _executor.ExecuteQuery(query, search);

            return(Ok(result));
        }
Esempio n. 17
0
    public static void main(string[] args)
    {
        BookSearch      bs = new BookSearch();
        BookSearchProxy pbs;

        pbs = new BookSearchProxy(bs);
        Book b1 = pbs.getBook("1");

        System.Console.WriteLine("===============");
        Book b2 = pbs.getBook("2");
    }
        public static BookSearch ConvertToModel(this BookSearchViewModel viewModel)
        {
            BookSearch model = new BookSearch();

            model.TitleSearch    = viewModel.TitleSearch;
            model.ISBNSearch     = viewModel.ISBNSearch;
            model.AuthorSearch   = viewModel.AuthorSearch;
            model.LanguageSearch = viewModel.LanguageSearch;
            model.GenreSearch    = viewModel.GenreSearch;

            return(model);
        }
Esempio n. 19
0
        public ActionResult Search(BookSearch searchBook)
        {
            var result = db.Books.AsQueryable();

            if (searchBook != null)
            {
                if (!string.IsNullOrEmpty(searchBook.BookTitle))
                {
                    result = result.Where(t => t.BookTitle.Contains(searchBook.BookTitle));
                }

                if (!string.IsNullOrEmpty(searchBook.AuthorName))
                {
                    result = result.Where(t => t.AuthorName == searchBook.AuthorName);
                }

                /*if (!enum.(searchBook.Genre))
                 * {
                 *   result = result.Where(t => t.Genre == searchBook.Genre);
                 *  }
                 *
                 *
                 * if (searchBook.GenreType.)
                 *  {
                 *     result = result.Where(t => t.GenreType == searchBook.GenreType);
                 *  }*/


//you have an extra if statement here in case the result is null to redirect to Create page
            }
            return(View("Index", result.OrderByDescending(t => t.AuthorName)));



/* var books = from b in db.Books
 *       select b;
 * if(!String.IsNullOrEmpty(BookSearchModel))
 * {
 * books = books.Where(k => k.BookTitle.Contains(BookSearchModel));
 * }
 * if (!String.IsNullOrEmpty(authorSearch))
 * {
 * books = books.Where(k => k.AuthorName.Contains(authorSearch));
 * }
 * if(books.ToList().Count == 0)
 * {
 * //google api search
 * // or redirect to add..do you want to add book
 *
 *
 * return RedirectToAction("Create");
 */
        }
 public SearchInBookPageViewModel(
     INavigationService navigationService,
     IBookRepository bookRepository,
     SearchInBookController searchController,
     IBusyIndicatorManager busyIndicatorManager,
     BookSearch bookSearch)
 {
     _navigationService    = navigationService;
     _bookRepository       = bookRepository;
     _searchController     = searchController;
     _busyIndicatorManager = busyIndicatorManager;
     _bookSearch           = bookSearch;
 }
Esempio n. 21
0
        public PagedResponse <BookDto> Execute(BookSearch search)
        {
            var query = _context.Books.Include(x => x.Publisher)
                        .Include(x => x.BookAuthors)
                        .ThenInclude(x => x.Author)

                        .AsQueryable();

            if (!string.IsNullOrEmpty(search.Title) || !string.IsNullOrWhiteSpace(search.Title))
            {
                query = query.Where(x => x.Title.ToLower().Contains(search.Title.ToLower()));
            }

            if (search.MinPrice != 0)
            {
                query = query.Where(x => x.Price >= search.MinPrice);
            }
            if (search.MaxPrice != 0)
            {
                query = query.Where(x => x.Price <= search.MaxPrice);
            }

            var skipCount = search.PerPage * (search.Page - 1);
            var response  = new PagedResponse <BookDto>
            {
                TotalCount   = query.Count(),
                CurrentPage  = search.Page,
                ItemsPerPage = search.PerPage,
                Items        = query.Skip(skipCount)
                               .Take(search.PerPage)
                               .Select(m => new BookDto
                {
                    Id    = m.Id,
                    Title = m.Title,
                    Year  = m.Year,
                    // GenreName = m.Genre.Name,
                    Description   = m.Description,
                    Price         = m.Price,
                    PublisherName = m.Publisher.Name,
                    BookAuthors   = m.BookAuthors.Select(ma => new BookAuthorDto
                    {
                        Id    = ma.AuthorId,
                        Year  = ma.Book.Year,
                        Name  = ma.Author.FirstName,
                        Title = ma.Book.Title,
                    })
                })
            };

            return(response);
        }
 private void searchButton_Click(object sender, RoutedEventArgs e)
 {
     try
     {
         //Searchs for books and lists matches below to aid updating
         BookSearch search = new BookSearch(books, people, searchTextBox.Text.Trim());
         search.SearchAllFields();
         booksListBox.DataContext = search.FoundBooks;
     }
     catch (Exception ex)
     {
         errorLabel.Content = ErrorHandler.InnermostExceptionMessage(ex);
     }
 }
Esempio n. 23
0
        private static void Main(string[] args)
        {
            Console.WriteLine("\n------------------------------------------------------------------------");

            string isbn   = "0071807993";
            var    output = BookSearch.SearchISBN(isbn);
            var    result = output.Result;

            Console.WriteLine("------------------------------------------------------------------------");
            Console.WriteLine("Book Name: \t" + result.VolumeInfo.Title);
            Console.WriteLine("Author: \t" + result.VolumeInfo.Authors.FirstOrDefault());
            Console.WriteLine("Publisher: \t" + result.VolumeInfo.Publisher);
            Console.WriteLine("------------------------------------------------------------------------");
        }
        public SearchInBookResultItemDataModel ToDataModel(
            BookSearchResult searchResult,
            string queryString,
            string bookId)
        {
            var query = BookSearch.PrepareQuery(queryString);

            var item = new SearchInBookResultItemDataModel();

            if (searchResult.PreviousContext.Any())
            {
                item.TokenId = searchResult.PreviousContext[0].ID;
            }
            else
            {
                item.TokenId = searchResult.SearchResult[0].ID;
            }

            item.BookId = bookId;

            var firstWord = query.First();
            var lastWord  = query.Last();

            var firstToken = searchResult.SearchResult.First();
            var lastToken  = searchResult.SearchResult.Last();

            var beforeWords = searchResult.PreviousContext.Select(r => r.Text).ToList();
            var afterWords  = searchResult.NextContext.Select(r => r.Text).ToList();

            var intermediateWords = searchResult.SearchResult.Skip(1).Take(searchResult.SearchResult.Count - 2).Select(r => r.Text).ToList();

            var firstWordIndex = firstToken.Text.IndexOf(firstWord, StringComparison.InvariantCultureIgnoreCase);

            beforeWords.Add(firstToken.Text.Substring(0, firstWordIndex));
            intermediateWords.Insert(0, firstToken.Text.Substring(firstWordIndex, firstWord.Length));

            var lastWordIndex = lastToken.Text.IndexOf(lastWord, StringComparison.InvariantCultureIgnoreCase);

            afterWords.Insert(0, lastToken.Text.Substring(lastWordIndex + lastWord.Length));
            if (query.Count > 1)
            {
                intermediateWords.Add(lastToken.Text.Substring(lastWordIndex, lastWord.Length));
            }

            item.TextBefore   = string.Join(" ", beforeWords);
            item.SearchedText = string.Join(" ", intermediateWords);
            item.TextAfter    = string.Join(" ", afterWords);

            return(item);
        }
Esempio n. 25
0
 public IList <BooksList> BookSearch(BookSearch model)
 {
     try
     {
         DynamicParameters parameters = new DynamicParameters();
         parameters.Add("@SearchValue", model.SearchValue);
         parameters.Add("@SearchId", model.SearchId);
         IList <BooksList> list = SqlMapper.Query <BooksList>(con, "sp_BookSearch", param: parameters, commandType: CommandType.StoredProcedure).ToList();
         return(list);
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
Esempio n. 26
0
        public IHttpActionResult GetMerchandise(GetRequest data)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }


            BookInfo[] books = BookSearch.BookSearchWithMerchandiseId(data.MerchandiseId);
            if (books.Length == 0)
            {
                return(BadRequest("No Merchandise Found"));
            }
            return(Ok(books[0]));
        }
        public ActionResult Checkout(string id, bool?error)
        {
            if (error != null)
            {
                if (error == true)
                {
                    ViewBag.Message = "The borrower already has checked out 3 book. Cannot checkout any more books!";
                }
            }

            Repo.UtilityFunctions uf   = new Repo.UtilityFunctions();
            BookSearch            book = uf.BookSearch(id).First();

            return(View(book));
        }
Esempio n. 28
0
        public void TestSearchAllFieldsForISBN()
        {
            //Arrange
            PersonBLLCollection people = CreatePersonBLLCollection();
            BookBLLCollection   books  = CreateBookCollection();

            string query = "3003";
            //Act
            BookSearch search = new BookSearch(books, people, query);

            search.SearchAllFields();

            //Assert
            Assert.AreEqual(1, search.FoundBooks.Count);
        }
Esempio n. 29
0
        public void TestSearchForOnlyISBN()
        {
            //Arrange
            PersonBLLCollection people = CreatePersonBLLCollection();
            BookBLLCollection   books  = CreateBookCollection();

            string query = "4004";

            //Act
            BookSearch search = new BookSearch(books, people, query);

            search.ISBNSearch();

            //Assert
            Assert.AreEqual(1, search.FoundBooks.Count);
        }
Esempio n. 30
0
        public void TestSearchForWordNotThere()
        {
            //Arrange
            PersonBLLCollection people = CreatePersonBLLCollection();
            BookBLLCollection   books  = CreateBookCollection();

            string query = "Zebra";

            //Act
            BookSearch search = new BookSearch(books, people, query);

            search.SearchAllFields();

            //Assert
            Assert.AreEqual(0, search.FoundBooks.Count);
        }
		private void CreateDataAPI()
		{
			_search = new BookSearch();
			_searchParams = new BookSearchParameters();
			_search.AccessKeyId = "xx";
			_search.AssociateTag = "xx";
			_searchParams.Keywords = SearchTerm;
			_searchParams.MaxResults = Count;
		}