def setUp(self):
        uncle_bob = Author(name='Robert', surname='Martin')
        uncle_bob.save()
        mcconnell = Author(name='Steve', surname='McConnell')
        mcconnell.save()
        myers = Author(name='Glenford', surname='Myers')
        myers.save()
        levi_metthew = Author(name='Levi Metthew')
        levi_metthew.save()

        clean_code = Book(
            name='Clean code',
            description='How to write <i>code</i> well',
            price=Decimal('0.01'),
            link='http://amazons3.com/books/clean_code.pdf',
        )
        clean_code.save()
        clean_code.authors.add(uncle_bob)

        code_complete = Book(
            name='Code complete',
            description='How to write <i>code</i> well',
            price=Decimal('0.02'),
            link='http://amazons3.com/books/code_complete.pdf',
        )
        code_complete.save()
        code_complete.authors.add(mcconnell)
        code_complete.authors.add(levi_metthew)

        the_art_of_software_testing = Book(
            name='The art of software testing',
            description='The first book about software testing',
            price=Decimal('0.003'),
            link='http://amazons3.com/books/the_art_of_software_testing.pdf')
        the_art_of_software_testing.save()
        the_art_of_software_testing.authors.add(myers)
        the_art_of_software_testing.authors.add(levi_metthew)

        alobachev = User(username='******', email='*****@*****.**')
        alobachev.set_password('password')
        alobachev.save()
        alobachev.profile.bought_books.add(code_complete)
        achistyakov = User(username='******',
                           email='*****@*****.**')
        achistyakov.set_password('password')
        achistyakov.save()
        achistyakov.profile.bought_books.add(code_complete,
                                             the_art_of_software_testing)
        aukupnik = User(username='******', email='*****@*****.**')
        aukupnik.set_password('password')
        aukupnik.save()
        aukupnik.profile.bought_books.add(code_complete,
                                          the_art_of_software_testing,
                                          clean_code)
        aapostle = User(username='******', email='*****@*****.**')
        aapostle.set_password('password')
        aapostle.save()

        achistyakov.profile.cards.create(name='VISA***1111',
                                         payment_number='1111-1111-1111-1111')
Пример #2
0
    def setUp(self):
        self.user = User(username='******',
                         password='******',
                         email='*****@*****.**')
        self.user.save()

        self.author = Author(first_name='Ernest', last_name='Hemingway')
        self.author.save()

        self.book = Book(title='A Farewell to Arms',
                         author=self.author,
                         publication_year=1929)
        self.book.save()

        self.book2 = Book(title='The Sun Also Rises',
                          author=self.author,
                          publication_year=1926)
        self.book2.save()

        self.book3 = Book(title='For Whom The Bell Tolls',
                          author=self.author,
                          publication_year=1940)
        self.book3.save()

        self.review = Review(user=self.user,
                             book=self.book,
                             timestamp=datetime.datetime.now(),
                             review_message='Good Book',
                             rating=5)
Пример #3
0
    def testBookNullFields(self):
        """Test whether Book with Null fields is invalidated"""
        #title is Null
        b1 = Book(author=Author(first_name='Ernest', last_name='Hemingway'))
        self.assertRaises(ValidationError, b1.full_clean)

        #author is Null
        b2 = Book(title='A Farewell to Arms')
        self.assertRaises(ValidationError, b2.full_clean)
Пример #4
0
def get_all_books():
    books = []
    if request.method == 'GET':
        print('THis is get request')
        for book in Book.query.all():
            temp_dict = {
                'book_name': book.book_name,
                'book_price': book.book_price,
                'book_num': book.book_num
            }
            books.insert(0, temp_dict)
        return jsonify(books)
    elif request.method == 'POST':
        print('This is post request', request.get_json())
        request_data = request.get_json()
        if valid_book(request_data):
            new_book = Book(book_name=request_data['book_name'],
                            book_price=request_data['book_price'],
                            book_num=request_data['book_num'])
            db.session.add(new_book)
            db.session.commit()
            books.append(request.get_json())
            response = Response(
                "", 201,
                mimetype="application/json")  # 201 response i.e created
            response.headers['Location'] = '/books/' + str(
                request_data['book_num'])  # link in the header
            return response
        return Response("", 400, mimetype="application/json")
Пример #5
0
    def handle(self, *args, **options):
        Publisher.objects.all().delete()
        Book.objects.all().delete()
        Store.objects.all().delete()

        # create 5 publishers
        publishers = [
            Publisher(name=f"Publisher{index}") for index in range(1, 6)
        ]
        Publisher.objects.bulk_create(publishers)

        # create 20 books for every publishers
        counter = 0
        books = []
        for publisher in Publisher.objects.all():
            for i in range(20):
                counter = counter + 1
                books.append(
                    Book(name=f"Book{counter}",
                         price=random.randint(50, 300),
                         publisher=publisher))

        Book.objects.bulk_create(books)

        # create 10 stores and insert 10 books in every store
        books = list(Book.objects.all())
        for i in range(10):
            temp_books = [books.pop(0) for i in range(10)]
            store = Store.objects.create(name=f"Store{i+1}")
            store.books.set(temp_books)
            store.save()
Пример #6
0
    def handle(self, *args, **options):
        Publisher.objects.all().delete()
        Book.objects.all().delete()
        Store.objects.all().delete()

        #Adding Publisher
        publisher = [Publisher(name=f"Publisher {i}") for i in range(1, 6)]
        Publisher.objects.bulk_create(publisher)

        #Adding 20 books for each publisher
        count = 0
        books = []
        for publisher in Publisher.objects.all():
            for i in range(20):
                count += 1
                books.append(
                    Book(name=f"Book {count}",
                         price=random.randint(50, 500),
                         publisher=publisher))
        Book.objects.bulk_create(books)

        #Create 10 Stores and insert 10 books in each Store
        books = list(Book.objects.all())  # All 100 books will come
        for i in range(1, 11):
            ten_books = [
                books.pop(0) for _ in range(10)
            ]  # Will pop 0th element from books 10 times. To get 10 books
            print('ten_books:', ten_books)
            store = Store.objects.create(name=f"Store {i}")
            print('store:', store)
            store.books.set(ten_books)
            store.save()
Пример #7
0
 def setUp(self):
     self.book = Book(
         name='Clean code',
         description='How to write <i>code</i> well',
         price=Decimal('0.01'),
         link='http://amazons3.com/rmartin/clean_code.pdf',
     )
     self.book.save()
Пример #8
0
    def testBookString(self):
        """Test whether string representation of Book is correct"""

        b = Book(title='A Farewell to Arms',
                 author=Author(first_name='Ernest', last_name='Hemingway'),
                 publication_year=1929)

        self.assertEqual(str(b), 'A Farewell to Arms')
Пример #9
0
    def testBookNegativePublicationYear(self):
        """Test whether a Book with a negative pub year is invalidated"""

        b = Book(title='A Farewell to Arms',
                 author=Author(first_name='Ernest', last_name='Hemingway'),
                 publication_year=-10)

        self.assertRaises(ValidationError, b.full_clean)
Пример #10
0
def add_book(request, author_id):
    a = Author.objects.get(pk=author_id)
    data = request.POST
    b = Book()
    b.title = data.get("title", "")
    b.author = a
    b.save()

    return HttpResponseRedirect(reverse('books:book_list'))
Пример #11
0
    def testReviewInvalidRating(self):
        """Test whether a review with an invalid rating
        (ie. not 1-5) is invalid"""

        #rating is less than 1
        r1 = Review(user=User(username='******'),
                    book=Book(title='A Farewell to Arms'),
                    timestamp=datetime.datetime.now(),
                    review_message='',
                    rating=0)
        self.assertRaises(ValidationError, r1.full_clean)

        #rating is greater than 5
        r2 = Review(user=User(username='******'),
                    book=Book(title='A Farewell to Arms'),
                    timestamp=datetime.datetime.now(),
                    review_message='',
                    rating=6)
        self.assertRaises(ValidationError, r2.full_clean)
Пример #12
0
    def testReviewString(self):
        """Test whether string representation of Review is correct"""

        r = Review(user=User(username='******'),
                   book=Book(title='A Farewell to Arms'),
                   timestamp=datetime.datetime.now(),
                   review_message='',
                   rating=1)

        self.assertEqual(str(r), 'guy : A Farewell to Arms')
Пример #13
0
 def test_buy_book(self):
     book = Book(
         name='foo',
         description='bar',
         price=Decimal('0.00001'),
         link='http://example.com/book.pdf',
     )
     book.save()
     self.user.profile.bought_books.add(book)
     self.assertEqual(list(book.buyers.all()), [self.user.profile])
Пример #14
0
def db_populate_books(db):
    """Populate the test database with mock books data."""
    books = []

    for x in range(20):
        books.append(
            Book(title=f'Book{x}', author=f'Author{x}')
        )
    
    db.session.add_all(books)
    db.session.commit()
Пример #15
0
    def testReviewNullFields(self):
        """Test whether Book with Null fields is invalidated"""

        #user is Null
        r1 = Review(book=Book(title='A Farewell to Arms'),
                    timestamp=datetime.datetime.now(),
                    review_message='',
                    rating=1)
        self.assertRaises(ValidationError, r1.full_clean)

        #book is Null
        r2 = Review(user=User(username='******'),
                    timestamp=datetime.datetime.now(),
                    review_message='',
                    rating=1)
        self.assertRaises(ValidationError, r2.full_clean)

        #timestamp is Null
        r3 = Review(user=User(username='******'),
                    book=Book(title='A Farewell to Arms'),
                    review_message='',
                    rating=1)
        self.assertRaises(ValidationError, r3.full_clean)

        #review_message is Null
        r4 = Review(user=User(username='******'),
                    book=Book(title='A Farewell to Arms'),
                    timestamp=datetime.datetime.now(),
                    rating=1)
        self.assertRaises(ValidationError, r4.full_clean)

        #rating is Null
        r5 = Review(
            user=User(username='******'),
            book=Book(title='A Farewell to Arms'),
            timestamp=datetime.datetime.now(),
            review_message='',
        )
        self.assertRaises(ValidationError, r5.full_clean)
Пример #16
0
def add_book():
    with open("bookdb/books.csv") as f:
        reader = csv.reader(f)
        header = next(
            reader)  # skip the first line which is a field description
        for item in reader:
            dt = Book(isbn=item[11],
                      title=item[1],
                      author=item[2],
                      publish_date=item[13],
                      average_rating=item[3],
                      ratings_count=item[4],
                      page_count=item[9],
                      description=item[7])
            dt.save()
            print(f"Added {dt.isbn}")
Пример #17
0
        # 책 이름, 이미지 주소
        img_set[find_img[i].find('a').find('img').get('alt')] = list()
        img_set[find_img[i].find('a').find('img').get('alt')].append(
            find_img[i].find('a').find('img').get('src'))
        # 작가 이름, 주소
        img_set[find_img[i].find('a').find('img').get('alt')].append(
            find_auth[i].find('a').text)
        img_set[find_img[i].find('a').find('img').get('alt')].append(
            find_auth[i].find('a').get('href'))
        # 출판사, 출판일
        img_set[find_img[i].find('a').find('img').get('alt')].append(
            find_pub[i].text)
        img_set[find_img[i].find('a').find('img').get('alt')].append(
            find_date[i].text)

    return img_set


if __name__ == "__main__":
    img = get_all()
    #print(img.items())

    for title, others in img.items():
        print(title, others)
        Book(title=title,
             link=others[0],
             author_name=others[1],
             author_link=others[2],
             pub_name=others[3],
             pub_date=others[4]).save()
from bookstore.models import Author, Book

some_author = Author(name='Chris Conlan')
some_author.save()

some_book = Book(author=some_author,
                 title='Fast Python',
                 subtitle='Re-learn the basics')
some_book.save()
Пример #19
0
    def test_add_book_and_review(self):
        num_cat = Category.objects.filter(owner='kati')
        self.assertEqual(num_cat.count(), 0)

        first_cat = Category(name='Novel', owner='kati')
        first_cat.save()

        num_cat = Category.objects.filter(owner='kati')
        self.assertEqual(num_cat.count(), 1)

        first_book = Book(title='The Thief of Baramos',
                          author='Rabbit',
                          owner='kati',
                          category=num_cat[0])
        first_book.save()
        book = Book.objects.filter(owner='kati')
        self.assertEqual(book.count(), 1)

        second_book = Book(title='The Thief of Baramos vol2',
                           author='Rabbit',
                           owner='kati',
                           category=num_cat[0])
        second_book.save()
        book = Book.objects.filter(owner='kati')
        self.assertEqual(book.count(), 2)

        first_review = Review(book=book[0],
                              timestamp=timezone.now(),
                              review_message='สนุกมาก',
                              rating=4)
        first_review.save()

        avg = Book.objects.filter(id=book[0].id).update(
            avg_rating=Review.objects.filter(book=book[0]).aggregate(
                Avg('rating')).get('rating__avg', 0.00))
        update = Book.objects.filter(id=book[0].id).update(
            update_review=timezone.now())

        second_review = Review(book=book[1],
                               timestamp=timezone.now(),
                               review_message='สนุกมาก',
                               rating=4)
        second_review.save()

        third_review = Review(book=book[1],
                              timestamp=timezone.now(),
                              review_message='สนุกมาก',
                              rating=5)
        third_review.save()

        avg = Book.objects.filter(id=book[1].id).update(
            avg_rating=Review.objects.filter(book=book[1]).aggregate(
                Avg('rating')).get('rating__avg', 0.00))
        update = Book.objects.filter(id=book[1].id).update(
            update_review=timezone.now())

        num_review = Review.objects.all()
        self.assertEqual(num_review.count(), 3)
        self.assertEqual(book[0].avg_rating, 4)
        self.assertEqual(book[1].avg_rating, 4.5)

        response = self.client.post('/kati/2/')
        self.assertEqual(response.templates[0].name,
                         'bookstore/display_title.html')
def get_book_by_isbn(isbn) -> Book:
    response = requests.get(BOOK_ENDPOINT, params={'ISBN': isbn})
    return Book(**response.json())
Пример #21
0
    tempDay = random.randint(1, 28)

    published_date = date(tempYear, tempMonth, tempDay)

    if len(title) >= 300:
        title = title[0:295] + '...'

    books = '{}\n'.format(cnt)
    books += 'Book Title: {}\n'.format(title)
    books += 'Pages: {}\n'.format(pages)
    books += 'Price: {}\n'.format(price)
    books += 'Rating: {}\n'.format(rating)
    books += 'Publisher: {}\n'.format(publisher)
    books += 'Published Date: {}\n'.format(published_date.strftime("%Y-%m-%d"))

    book = Book()
    book.book_title = title
    book.pages = pages
    book.price = price
    book.rating = rating
    book.publisher_id = publisher
    book.published_date = published_date

    author_id = [random.randint(1, 1572)]

    if cnt % 17 == 0:
        for i in range(1, 3):
            author_id.append(random.randint(1, 1572))

    if cnt % 29 == 0:
        for i in range(1, 4):
def mocked_books():
    return [Book(**book) for book in mocks.MOCKED_BOOKS]
Пример #23
0
    def test_schema_load_only(self, schema):
        """Assert schema is load-only."""
        book = Book(title='title', author='author')

        dumped_book = schema.dump(book)
        assert not dumped_book
def get_all_books() -> List[Book]:
    response = requests.get(BOOKS_ENDPOINT)
    if not response.ok:
        raise ConnectionError(f'Unable to get all books: {response.content}')
    books = response.json()['books']
    return [Book(**book) for book in books]