Ejemplo n.º 1
0
def account():
    if current_user.role != 'admin':
        form = UpdateAccountForm()
        if form.validate_on_submit():
            form.validate_name(form.name)
            form.validate_email(form.email)
            current_user.name = form.name.data
            current_user.email = form.email.data
            db.session.commit()
            flash('Reader account has been updated', 'success')
        else:
            form.name.data = current_user.name
            form.email.data = current_user.email
        # return render_template('account.html', title='Account', form=form)

    else:
        form = BookForm()
        if form.validate_on_submit():
            books = Book.query.filter_by(title=form.title.data).all()
            for book in books:
                if book.author == form.author.data:
                    flash('This book is already in the database', 'danger')
            else:
                book = Book()
                book.title = form.title.data
                book.author = form.author.data
                book.summary = form.summary.data
                db.session.add(book)
                db.session.commit()
                flash(f'Added book {book.title}', 'success')
                form.title.data = ''
                form.author.data = ''
                form.summary.data = ''
    return render_template('account.html', title='Account', form=form)
Ejemplo n.º 2
0
def get_added_books(delta_entries, user_id, client):
    """
    Return a list of Books. All books in this list have the correct mimetype,
    are under the size limit, and don't have a duplicate hash in the database
    (i.e. not a filepath rename).
    """
    added_entries = []
    for entry in delta_entries:
        pathname, metadata = entry
        pathname = canonicalize(pathname)

        # First check that it's not a removed pathname.
        if metadata is None:
            continue
        # Check that pathname is a file, has an okay mimetype and is under the
        # size limit.
        if metadata["is_dir"] or not mimetypes_filter(pathname) or metadata["bytes"] > AMAZON_SIZE_LIMIT:
            continue

        book = Book(user_id, pathname, download_book(client, pathname, user_id), metadata["bytes"])
        # NOTE: It's possible that the book failed to download here, in which
        # case `book_hash` is None. We still add it to the database in case it
        # can be downloaded later.
        db.session.add(book)

        # Make sure that the book is not a duplicate of a previously added book
        # (probably a renamed file).
        duplicate = Book.query.filter_by(user_id=user_id).filter_by(book_hash=book.book_hash).first()
        if duplicate is not None:
            book.unsent = duplicate.unsent
            continue

        added_entries.append(book)

    return added_entries
Ejemplo n.º 3
0
def add_book():
    form = BookForm()
    if form.validate_on_submit():
        if request.method == 'POST':
            existing_book = Book.query.filter(
                Book.name == form.name.data).filter(
                    Book.author == form.author.data).first()
            book = Book(name=form.name.data, author=form.author.data)

            if (existing_book == None):
                book.create_time = datetime.utcnow()
                db.session.add(book)
            elif (current_user not in book.user):
                book.user.append(current_user)
                book.create_time = datetime.utcnow()
            else:
                flash('Book already exists!')
                return redirect(url_for('add_book'))
            #   return redirect(url_for('add_book'))
        #and(existing_book.name == form.name.data and  existing_book.author == form.author.data and existing_book.user_id == current_user.id)):
        #   flash('Book already exists!')
        #   return redirect(url_for('add_book'))
            db.session.commit()

            flash('Your book succesfully added!')
            return redirect(url_for('index'))
    return render_template("add_book.html", title='Add_book', form=form)
Ejemplo n.º 4
0
def init_db():
    db.create_all()

    user1 = User(first_name="Albert",
                 last_name="Einstein",
                 email="*****@*****.**")
    user2 = User(first_name="Enrico", last_name="Fermi", email="*****@*****.**")
    user3 = User(first_name="Paul", last_name="Dirac", email="*****@*****.**")
    user4 = User(first_name="Werner",
                 last_name="Heisenberg",
                 email="*****@*****.**")

    book1 = Book(title="Harry Potter and the Sorcerer's Stone")
    book2 = Book(title="Harry Potter and the Chamber of Secrets")
    book3 = Book(title="Harry Potter and the Prisoner of Azkaban")

    user1.books.append(book1)
    user2.books.append(book1)
    book2.owners.append(user3)
    book2.owners.append(user1)
    book2.owners.append(user4)

    for ob in [user1, user2, user3, user4, book1, book2, book3]:
        ob.save()
    end

    yield db

    db.drop_all()
Ejemplo n.º 5
0
    def test_send_book_list_email(self):
        u = User(username='******', email='*****@*****.**')
        b1title = 'hello'
        b2title = 'world'
        b1 = Book(title=b1title,
                  author='b',
                  date_of_purchase=datetime.utcnow(),
                  notes='Test Notes')
        b2 = Book(title=b2title,
                  author='d',
                  date_of_purchase=datetime.utcnow(),
                  notes='Test Notes')

        db.session.add(u)
        db.session.add(b1)
        db.session.add(b2)
        db.session.commit()
        u.add_book_owned(b1)
        u.add_book_owned(b2)
        db.session.commit()
        b = u.owned_books()
        subject = 'test'
        sender = '*****@*****.**'
        recipients = '*****@*****.**'
        text_body = 'text mctest'
        html_body = '<div>testing</div>'
        mail = Mail(self.app)
        with mail.record_messages() as outbox:
            send_book_list_email(u, recipients, b)
            assert len(outbox) == 1
            book1 = outbox[0].body.find('hello')
            book2 = outbox[0].body.find('world')
            assert book1 > 0
            assert book2 > 0
Ejemplo n.º 6
0
def get_added_books(delta_entries, user_id, client):
    """
    Return a list of Books. All books in this list have the correct mimetype,
    are under the size limit, and don't have a duplicate hash in the database
    (i.e. not a filepath rename).
    """
    added_entries = []
    for entry in delta_entries:
        pathname, metadata = entry
        pathname = canonicalize(pathname)

        # First check that it's not a removed pathname.
        if metadata is None:
            continue
        # Check that pathname is a file, has an okay mimetype and is under the
        # size limit.
        if (metadata['is_dir'] or not mimetypes_filter(pathname)
                or metadata['bytes'] > AMAZON_SIZE_LIMIT):
            continue

        book = Book(user_id, pathname, metadata['bytes'])

        download_book(client, book, u'kindlebox')

        # Make sure that the book is not a duplicate of a previously added book
        # (probably a renamed file).
        duplicate = (Book.query.filter_by(user_id=user_id).filter_by(
            book_hash=book.book_hash).first())
        if (duplicate is not None):
            book.unsent = duplicate.unsent

        added_entries.append(book)

    return added_entries
Ejemplo n.º 7
0
def test_borrow_book(mocker):
    # Testing with Invalid member
    mocker_model_get_by_id = mocker.patch('google.cloud.ndb.Model.get_by_id')
    mocker_model_get_by_id.side_effect = [None, None]
    with pytest.raises(MemberNotFound):
        borrow_book(1, 2)

    # Testing with Invalid Book
    mocker_model_get_by_id = mocker.patch('google.cloud.ndb.Model.get_by_id')
    mocker_model_get_by_id.side_effect = [Member(), None]
    with pytest.raises(BookNotFound):
        borrow_book(1, 2)

    # Testing with Already Taken Book
    mocker_model_get_by_id = mocker.patch('google.cloud.ndb.Model.get_by_id')
    mocker_model_get_by_id.side_effect = [Member(), Book(taken=True)]
    with pytest.raises(BookAlreadyTaken):
        borrow_book(1, 2)

    # Testing proper calling of function
    mocker_model_get_by_id = mocker.patch('google.cloud.ndb.Model.get_by_id')
    book = Book(taken=False)
    mocker_model_get_by_id.side_effect = [Member(), book]
    mocker_model_put = mocker.patch('google.cloud.ndb.Model.put')
    borrow_book(1, 2)
    assert book.taken == True
    mocker_model_put.assert_called_once()
Ejemplo n.º 8
0
def find_book(request):
    """
    Generates list with books of data which user entered. At first it check full equality in name,
    after tries to check if contains some part of entered data.
    """
    validate_api_secret_key(request.data.get('app_key'))
    request_serializer = FindBookRequest(data=request.data)

    if request_serializer.is_valid():
        user = get_object_or_404(TheUser,
                                 auth_token=request.data.get('user_token'))
        search_data = request.data.get('search_term')

        filtered_books = Book.exclude_private_books(
            user.id_user, Book.fetch_books(search_data))

        paginator = Paginator(filtered_books, OUTPUT_BOOKS_PER_PAGE)
        page = paginator.page(request.data.get('page'))
        next_page = page.has_next()
        page_books = page.object_list

        return Response(
            {
                'detail': 'successful',
                'data': {
                    'books':
                    [BookSerializer(book).data for book in page_books],
                    'next_page': page.next_page_number() if next_page else 0
                }
            },
            status=status.HTTP_200_OK)
    else:
        return invalid_data_response(request_serializer)
Ejemplo n.º 9
0
    def testSearchBookByName(self):
        response = self.client.post(url_for('main.index'), data={'name': 't'})
        self.assertTrue(response.status_code == 302)

        response = self.client.post(url_for('main.index'),
                                    data={'name': 't'},
                                    follow_redirects=True)
        self.assertTrue(response.status_code == 200)
        self.assertTrue('No records found' in response.get_data(as_text=True))

        category_one = Category(name='One')
        category_two = Category(name='Two')
        db.session.add_all([category_one, category_two])
        db.session.commit()
        book_one = Book(name='New World Order', category=category_one)
        book_two = Book(name='Things Fall Apart', category=category_two)
        book_three = Book(name='Pinkberry', category=category_two)
        book_four = Book(name='New Scopes', category=category_two)
        db.session.add_all([book_one, book_two, book_three, book_four])
        db.session.commit()

        response = self.client.post(url_for('main.index'),
                                    data={'name': 't'},
                                    follow_redirects=True)
        self.assertTrue(response.status_code == 200)
        self.assertTrue('Things Fall Apart' in response.get_data(as_text=True))
Ejemplo n.º 10
0
def moveBooksDataFromTables():
    # carturesti_books = BooksCarturesti.query.all()
    carturesti_books = Book.query.all()
    for book in carturesti_books:
        new_book = Book(
            title=book.title,
            author=book.author,
            isbn=book.isbn,
            link=book.link,
            editura=book.editura,
            price=book.price,
            # img=book.img,
            library_id=1)
        db.session.add(new_book)
        db.session.commit()

    librarie_net_books = LibrarieNet.query.all()
    for book in librarie_net_books:
        new_book = Book(
            title=book.title,
            # author=book.author,
            isbn=book.isbn,
            link=book.link,
            # editura=book.editura,
            price=book.price,
            img=book.img,
            library_id=2)
        db.session.add(new_book)
        db.session.commit()
Ejemplo n.º 11
0
def editbook(request, book_id):
    if request.user.is_authenticated():
        if request.session['user'] == 'admin':
            if request.method == 'GET':
                print(request.GET)
            if request.method == 'POST':
                form = BookForm(request.POST)
                if form.is_valid():
                    cd = form.cleaned_data
                    post = Book(id=book_id, title=cd['title'], about=cd['about'], timestamp=cd['timestamp'])
                    post.save()
                    return HttpResponseRedirect('../../books')
                else:
                    ctx = Context({'form': form})
                    ctx.update(csrf(request))
                    return render_to_response('app/book_form.html', ctx)
            else:
                post = Book.objects.get(id=int(book_id))
                data = {'title': post.title, 'about': post.about}
                post_form = BookForm(initial=data)
                ctx = Context({'form': post_form})
                ctx.update(csrf(request))
                return render_to_response('app/book_form.html', ctx)
        else:  return render_to_response('app/index.html');
    else:  return render_to_response('app/index.html');
Ejemplo n.º 12
0
def create(request):
    if request.method == "GET":
        form = BookForms()
        return render(request, 'Library/book.html', {"form": form})

    if request.method == "POST":
        form = BookForms(request.POST)
        if form.is_valid():
            obj = Book()
            obj.name = form.cleaned_data["name"]
            obj.isbn = form.cleaned_data["isbn"]
            obj.published_date = form.cleaned_data["published_date"]
            obj.pages = form.cleaned_data["pages"]

            obj.save()
            #for e in form.cleaned_data["authors"]:
            obj.authors.set(form.cleaned_data["authors"])
            obj.save()

            return render(
                request, 'Library/book.html', {
                    "form": BookForms(),
                    "msg": {
                        "status": "success",
                        "msg": "Se añadio el libro"
                    }
                })
        return render(request, 'Library/book.html', {"form": form})
Ejemplo n.º 13
0
def deploy():
    """Run deployment tasks."""
    from flask.ext.migrate import upgrade
    from app.models import Author, Book, User
    upgrade()
    Author.add_authors()
    Book.add_books()
    User.add_admin()
Ejemplo n.º 14
0
 def testCanFindBooksInCategory(self):
     tech = Category(name='tech')
     book = Book(name='Clean Code', category=tech)
     book2 = Book(name='Eloquent JavaScript', category=tech)
     db.session.add_all([book, book2, tech])
     db.session.commit()
     books = Book.query.filter_by(category=tech).all()
     self.assertIsNotNone(books)
Ejemplo n.º 15
0
def create_books():
    book1 = Book(title='Flask Web Dev 2e')
    book2 = Book(title='The New And Improved Flask Mega')
    book3 = Book(title='Complete Web Application')
    db.session.add(book1)
    db.session.add(book2)
    db.session.add(book3)
    db.session.commit()
Ejemplo n.º 16
0
        def test_follow_posts(self):
            # create users and books
            u1 = User(username='******', email='*****@*****.**')
            u2 = User(username='******', email='*****@*****.**')
            u3 = User(username='******', email='*****@*****.**')
            u4 = User(username='******', email='*****@*****.**')
            b1 = Book(title='Gone with the wind', author='Margaret Mitchell')
            b2 = Book(title='A tale of 2 cities', author='Charles Dickens')
            b3 = Book(title='Conspiration', author='Dan Brown')

            db.session.add(u1)
            db.session.add(u2)
            db.session.add(u3)
            db.session.add(u4)
            db.session.add(b1)
            db.session.add(b2)
            db.session.add(b3)

            db.session.commit()

            # create four posts
            now = datetime.utcnow()
            p1 = Post(body="post from john",
                      user=u1,
                      book=b1,
                      timestamp=now + timedelta(seconds=1),
                      level=1)
            p2 = Post(body="post from susan",
                      user=u2,
                      book=b2,
                      timestamp=now + timedelta(seconds=4),
                      level=1)
            p3 = Post(body="post from mary",
                      user=u3,
                      book=b2,
                      timestamp=now + timedelta(seconds=3),
                      level=1)
            p4 = Post(body="post from david",
                      user=u4,
                      book=b3,
                      timestamp=now + timedelta(seconds=2),
                      level=1)
            db.session.add_all([p1, p2, p3, p4])
            db.session.commit()

            # setup the followers
            u1.follow(b1)
            u1.follow(b2)
            u1.follow(b3)
            u2.follow(b1)
            db.session.commit()

            # check the followed posts of each user
            f1 = u1.followed_posts().all()
            f2 = u2.followed_posts().all()

            self.assertEqual(f1, [p2, p3, p4, p1])
            self.assertEqual(f2, [p1])
Ejemplo n.º 17
0
 def setUp(self):
     self.admin = User.objects.get(pk=1)
     self.book1 = Book(pk=1, title="foo", body="foofoofoo", author=self.admin)
     self.book1.save()
     self.book2 = Book(pk=2, title="bar", body="barbarbar", author=self.admin)
     self.book2.save()
 
     # Delete TaggedItem everytime
     TaggedItem.objects.all().delete()
Ejemplo n.º 18
0
        def create_book():
            book_info = request.json or request.form
            book = Book(name=book_info.get('name'),
                        author_id=book_info.get('author'))

            db.session.add(book)
            db.session.commit()

            return jsonify(book.to_dict())
    def test_update_book_name(self, patched_query, patched_session):
        name = 'new_name'
        isbn = 'fake_isbn'
        author = 'fake_author'
        Book.add_book(name, 50, isbn, author)

        Book.update_book_name(isbn, name)
        patched_session.commit.assert_called()
        patched_query.filter_by.assert_called_once()
    def test_add_book(self, patched_session):
        mock_book = self.mock_books[0]
        Book.add_book(_name=mock_book['name'],
                      _isbn=mock_book['isbn'],
                      _price=mock_book['price'],
                      _author=mock_book['author'])

        patched_session.add.assert_called_once()
        patched_session.commit.assert_called_once()
Ejemplo n.º 21
0
    def handle(self, *args, **options):


        data = pickle.load(open(str(args[0])))
        Section.objects.all().delete()
        Book.objects.all().delete()
        i = 0
        for quarter in data:
            for dept in quarter['departments']:
                for courses in dept['courses']:
                    newCourseName = courses['name']

                    for section in courses['sections']:
                        newSectionName = section['name']
                        newSectionID = section['id']

                        for book in section['books']:
                            newISBN = book['ISBN']
                            newAuthor = book['author']
                            newBinding = book['binding']
                            newPrice = book['broncoListPrice']
                            newEdition = book['edition']
                            newRequired = book['isRequired']
                            newtitle = book['title']

                            newBook = Book(
                                isbn = newISBN,
                                sectionID = newSectionID,
                                required = newRequired,
                                broncoPrice = newPrice,
                                author = newAuthor,
                                edition = newEdition,
                                binding = newBinding,
                                title = newtitle
                            )
                            newBook.save()
                            print i
                            i +=1
                        
        for quarter in data:
            for dept in quarter['departments']:
                for courses in dept['courses']:
                    newCourseName = courses['name']
                    for section in courses['sections']:
                        newSectionID = section['id']
                        newSectionName = section['name']
                        newInstructor = section['instructor']
                        newQuartername = quarter['name']
                        newCourse = Section(
                            quarterName = newQuartername, 
                            courseName = newCourseName, 
                            sectionID = newSectionID, 
                            sectionName = newSectionName, 
                            instructor = newInstructor)
                        newCourse.save()
                        print newCourse
Ejemplo n.º 22
0
 def test_adding_books(self):
     b1 = Book(metabook_id=1, owner_id=1, condition="new", region="sf")
     b2 = Book(metabook_id=1, owner_id=1, condition="used", region="hyd")
     b3 = Book(metabook_id=1, owner_id=1, condition="torn", region="sel")
     db.session.add_all([b1, b2, b3])
     db.session.commit()
     hydbook = Book.query.filter_by(region="hyd").first()
     numbertorn = Book.query.filter_by(condition="torn").all()
     self.assertEqual(hydbook.owner_id, 1)
     self.assertEqual(len(numbertorn), 1)
Ejemplo n.º 23
0
def add_book():
    form = BookForm()
    if form.validate_on_submit():
        book = Book()
        book.book = form.name.data
        db.session.add(book)
        db.session.commit()
        flash("Book create with successfully!", "success")
        return redirect(url_for(".add_book"))
    return render_template("add.html", form=form)
 def test_book_is_related_to_list_of_books(self):
     list_of_books = ListfOfBooks.objects.create()
     book = Book(
         list_of_books=list_of_books,
         title='Some title',
         current_page=1,
         total_pages=255,
     )
     book.save()
     self.assertIn(book, list_of_books.book_set.all())
    def test_update_book_price(self, patched_query, patched_session):

        # An alternative approach: test very lightly since the function is simple, just make sure the function
        # does not crash and commit is called once successfully

        isbn = 'fake_isbn'

        Book.update_book_price(isbn, 50)
        patched_query.filter_by.assert_called_once()
        patched_session.commit.assert_called_once()
def replace_book(isbn):
    if not valid_put_request_data(request.json):
        abort(
            400,
            "Invalid book object passed in request. Data should be passed in similar to this {'name': "
            "'bookname', 'price': 7.99 }")

    Book.replace_book(isbn, request.json.get('name'),
                      request.json.get('price'))
    return jsonify(dict()), 204
 def test_cannot_save_empty_book_details(self):
     list_of_books = ListfOfBooks.objects.create()
     book = Book()
     book.title = ""  # empty book detail (title)
     book.current_page = 6
     book.total_pages = 344
     book.list_of_books = list_of_books
     with self.assertRaises(ValidationError):
         book.save()
         book.full_clean()  # fully checks empty value in TextField.
Ejemplo n.º 28
0
def add_book(title, author, description, pages_no):
    """Helper function for adding example book to db."""
    book = Book(title=title,
                author=author,
                description=description,
                pages_no=pages_no)
    book.add_date()
    db.session.add(book)
    db.session.commit()
    return book
def add_book():
    if not valid_book_object(request.json):
        abort(
            400,
            "Invalid book object passed in request. Data passed in similar to this {'name': 'bookname', "
            "'price': 7.99, 'isbn': 9780394800165, 'author': 'Someone' }")
    Book.add_book(request.json.get('name'), request.json.get('price'),
                  request.json.get('isbn'), request.json.get('author'))
    data = dict(
        Location=url_for('v1.get_book_by_isbn', isbn=request.json.get('isbn')))
    return jsonify(data), 201
Ejemplo n.º 30
0
    def test_adding_uploader(self):
        """Tests if an uploader can be added to a book."""
        user = self.add_user()
        file = '/tmp/some-test-book.pdf'
        book = Book(title='book', publish_date=date.today(), file=file,
                    file_type='pdf')
        book.uploader = user
        self.add_to_db(book)

        book = Book.query.all()[0]
        self.assertEqual(book.uploader, user)
    def test_delete_book(self, patched_query, patched_session):
        mock_filter_by = Mock()
        patched_query.filter_by.return_value = mock_filter_by
        mock_filter_by.delete.return_value = True

        isbn = 'fake_isbn'
        Book.delete_book(isbn)

        patched_query.filter_by.assert_called_with(isbn=isbn)
        mock_filter_by.delete.assert_called_once()
        patched_session.commit.assert_called_once()
def update_book(isbn):
    if not valid_patch_request_data(request.json):
        abort(
            400,
            "Invalid book object passed in request. Data should be passed in similar to this {'name': "
            "'bookname', 'price': 7.99 }")

    Book.update(isbn, **request.json)

    return jsonify(
        dict(Location=url_for('v1.get_book_by_isbn', isbn=isbn))), 204
Ejemplo n.º 33
0
def book_add():
    form = BookForm()
    if form.validate_on_submit():
        book = Book()
        book.name = form.name.data
        db.session.add(book)
        db.session.commit()
        flash("Livro cadastrado com sucesso", "success")
        return redirect(url_for('book.book_add'))

    return render_template('book/add.html', form=form)
Ejemplo n.º 34
0
def fill_books(books):
    for author in set([a for a in books.values()]):
        a = Author(name=author)
        db.session.add(a)
        db.session.commit()

    for book_name in books.keys():
        b = Book(name=book_name)
        b.authors = [Author.query.filter_by(name=books[book_name]).first()]
        db.session.add(a)
        db.session.commit()
Ejemplo n.º 35
0
def add_book():
    form = BookForm()
    form.author.choices = [(i.id, i.name) for i in Author.query.all()]
    if form.validate_on_submit():
        Book.save(name=form.name.data,
                  date=form.date.data,
                  author_id=form.author.data)
        return redirect(url_for('books'))
    return render_template('form.html',
                           title="Добавление новой книги",
                           form=form,
                           url=url_for('add_book'))
Ejemplo n.º 36
0
    def test_adding_language_to_book(self):
        """Tests setting a language for a book."""
        file = '/tmp/some-test-book.pdf'
        book = Book(title='book', publish_date=date.today(), file=file,
                    file_type='pdf')
        lang = self.add_language()
        book.language = lang
        self.add_to_db(book)

        book = Book.query.all()[0]

        self.assertEqual(book.language, lang)
Ejemplo n.º 37
0
 def setUp(self):
     from app.models import Book
     self.admin = User.objects.create_superuser(
             username='******', email='*****@*****.**',
             password='******'
         )
     self.book1 = Book(pk=1, title="foo", body="foofoofoo", author=self.admin)
     self.book1.save()
     self.book2 = Book(pk=2, title="bar", body="barbarbar", author=self.admin)
     self.book2.save()
 
     # Delete TaggedItem everytime
     TaggedItem.objects.all().delete()
Ejemplo n.º 38
0
def deploy():
    """Run deployment tasks."""
    from flask.ext.migrate import upgrade
    from app.models import Role, User, Year, Book, Author
    from app import db

    db.drop_all()
    db.create_all()
    Role.insert_roles()
    User.generate_fake()
    Year.generate_fake()
    Author.generate_fake()
    Book.generate_fake()
Ejemplo n.º 39
0
def book_add():
    form = LoginForm()
    book_form = BookForm(request.form)
    book_form.authors.choices = [(p.id, p.name) for p in db_session.query(Author).order_by('id')]

    if book_form.validate_on_submit():
        book = Book()
        book.title = book_form.title.data
        book.authors = [db_session.query(Author).get(o) for o in book_form.authors.data]
        db_session.add(book)
        db_session.commit()
        flash('Successfully added.', 'success')
        return redirect(url_for('index'))

    return render_template("add_book.html", bform=book_form, form=form, user=current_user, is_authenticated=True)
Ejemplo n.º 40
0
def update_books():
    title = request.form['title']
    authors = request.form['authors']
    data = json.loads(authors)
    book_id = request.form['id']
    if book_id == 'new_book':
        book = Book(title)
    else:
        book = Book.get_byId(book_id, g.dbs)
        del book.authors[:]
        book.title = title
    for it in data:
        book.authors.append(Author.get_byId(it, g.dbs))
    g.dbs.add(book)
    g.dbs.commit()
    return 'success'
Ejemplo n.º 41
0
def authors_of_book():
    book_id = request.args['id']
    book = Book.get_byId(book_id, g.dbs)
    author_ids = []
    for author in book.authors:
        author_ids.append(author.id)
    json = dict(id=book_id)
    return jsonify(book_id=book.id, book_title=book.title, author_ids=author_ids)
Ejemplo n.º 42
0
def new_book():
    form = NewBookForm()
    if form.validate_on_submit():
        if form.book_title.data is None:
            flash("Fill in a book title to create a book!")
            return redirect(url_for('show_books'))
        book = Book(book_title=form.book_title.data)
        author = form.author.data
        book.authors.append(author)
        book.user = g.user
        if book.book_title in db.session.query(Book.book_title).all():
            flash('This book title already exists.')
            return redirect(url_for('new_book'))
        db.session.add(book)
        db.session.commit()
        flash('Book successfully added.')
        return redirect(url_for('show_books'))
    return render_template('newbook.html', form=form)
Ejemplo n.º 43
0
def search_books():
    form = SearchForm()
    results = None
    if request.method == 'POST' and form.validate_on_submit():
        book = request.form['book']
        author = request.form['author']
        results = Book.get_byTitleAuthor(book, author, g.dbs)

        # flash('book: %s author: %s' % (books, author))
    return render_template('search_books.html', form=form, results=results)
Ejemplo n.º 44
0
def delete_instance():
    instance_type = request.form['type']
    id = request.form['id']
    if instance_type == 'book':
        instance = Book.get_byId(id, g.dbs)
    elif instance_type == 'author':
        instance = Author.get_byId(id, g.dbs)
    else:
        return 'wtf?'
    g.dbs.delete(instance)
    g.dbs.commit()
    return 'ok'
Ejemplo n.º 45
0
def new_entry(request):
    if  request.session['user'] == 'admin':
        if request.method == 'POST':
            form = BookForm(request.POST)
            if form.is_valid():
                cd = form.cleaned_data
                print(cd)
                post = Book(title=cd['title'], about=cd['about'], timestamp=cd['timestamp'])
                post.save()
                return HttpResponseRedirect('/books.html')
            else:
                ctx = Context({'form': form})
                ctx.update(csrf(request))
                return render_to_response('app/book_form.html', ctx)
        else:
            form = BookForm()
            ctx = Context({'form': form})
            ctx.update(csrf(request))
            return render_to_response('app/book_form.html', ctx)
    else: 
        return render_to_response('app/index.html');
Ejemplo n.º 46
0
def get_added_books(delta_entries, user_id, client):
    """
    Return a list of Books. All books in this list have the correct mimetype,
    are under the size limit, and don't have a duplicate hash in the database
    (i.e. not a filepath rename).
    """
    added_entries = []
    for entry in delta_entries:
        pathname, metadata = entry
        pathname = canonicalize(pathname)

        # First check that it's not a removed pathname.
        if metadata is None:
            continue
        # Check that pathname is a file, has an okay mimetype and is under the
        # size limit.
        if (metadata['is_dir'] or not mimetypes_filter(pathname) or
                metadata['bytes'] > AMAZON_SIZE_LIMIT):
            continue

        book = Book(user_id,
                    pathname,
                    metadata['bytes'])

        download_book(client, book, u'kindlebox')

        # Make sure that the book is not a duplicate of a previously added book
        # (probably a renamed file).
        duplicate = (Book.query.filter_by(user_id=user_id)
                               .filter_by(book_hash=book.book_hash).first())
        if (duplicate is not None):
            book.unsent = duplicate.unsent

        added_entries.append(book)

    return added_entries
Ejemplo n.º 47
0
def edit_books_and_authors():
    books = Book.get_all(g.dbs)
    authors = Author.get_all(g.dbs)
    book_form = EditForm()
    author_form = AddAuthorForm()
    return render_template('edit_books_and_authors.html', books=books, authors=authors,  form=book_form, author_form=author_form)
Ejemplo n.º 48
0
def ca():
    db.create_all()
    Role.insert_roles()
    User.generate_fake()
    Book.generate_fake()
Ejemplo n.º 49
0
class TaggedItemTestCase(AppTestCase):
    installed_apps = ['universaltag.tests.app']
    def setUp(self):
        from app.models import Book
        self.admin = User.objects.create_superuser(
                username='******', email='*****@*****.**',
                password='******'
            )
        self.book1 = Book(pk=1, title="foo", body="foofoofoo", author=self.admin)
        self.book1.save()
        self.book2 = Book(pk=2, title="bar", body="barbarbar", author=self.admin)
        self.book2.save()
    
        # Delete TaggedItem everytime
        TaggedItem.objects.all().delete()
        
    def test_add_or_get(self):
        TaggedItem.objects.add_or_get(self.book1, 'test1')
        TaggedItem.objects.add_or_get(self.book1, 'test2')
        TaggedItem.objects.add_or_get(self.book1, 'test3')
        self.assertEquals(len(self.book1.tags.values()), 3)
    def test_add_or_get_duplicate(self):
        TaggedItem.objects.add_or_get(self.book1, 'test1')
        TaggedItem.objects.add_or_get(self.book1, 'test2')
        TaggedItem.objects.add_or_get(self.book1, 'test3')
        # Add duplicate tag
        TaggedItem.objects.add_or_get(self.book1, 'test3')
        self.assertEquals(len(self.book1.tags.values()), 3)
    def test_get_for_model(self):
        from app.models import Book
        TaggedItem.objects.add_or_get(self.book1, 'test1')
        TaggedItem.objects.add_or_get(self.book1, 'test2')
        TaggedItem.objects.add_or_get(self.book1, 'test3')
        TaggedItem.objects.add_or_get(self.book2, 'test2')
        TaggedItem.objects.add_or_get(self.book2, 'test3')
        TaggedItem.objects.add_or_get(self.book2, 'test4')

        qs = TaggedItem.objects.get_for_model(Book)
        self.assertEquals(qs.count(), 6)
    def test_get_for_object(self):
        TaggedItem.objects.add_or_get(self.book1, 'test1')
        TaggedItem.objects.add_or_get(self.book1, 'test2')
        TaggedItem.objects.add_or_get(self.book1, 'test3')
        TaggedItem.objects.add_or_get(self.book2, 'test2')
        TaggedItem.objects.add_or_get(self.book2, 'test3')
        TaggedItem.objects.add_or_get(self.book2, 'test4')

        qs = TaggedItem.objects.get_for_object(self.book1)
        self.assertEquals(qs.count(), 3)
    def test_remove(self):
        TaggedItem.objects.add_or_get(self.book1, 'test1')
        TaggedItem.objects.add_or_get(self.book1, 'test2')
        TaggedItem.objects.add_or_get(self.book1, 'test3')

        qs = TaggedItem.objects.get_for_object(self.book1)
        self.assertEquals(qs.count(), 3)
        
        TaggedItem.objects.remove(self.book1, 'test1')
        
        qs = TaggedItem.objects.get_for_object(self.book1)
        self.assertEquals(qs.count(), 2)
        
    def test_freeze(self):
        TaggedItem.objects.add_or_get(self.book1, 'test1')
        TaggedItem.objects.add_or_get(self.book1, 'test2')
        TaggedItem.objects.add_or_get(self.book1, 'test3')
        
        TaggedItem.objects.freeze(self.book1, 'test1', 'thaw')
        
        tagged_item = TaggedItem.objects.get_for_object(self.book1).get(tag__label='test1')
        self.assertFalse(tagged_item.frozen)

        TaggedItem.objects.freeze(self.book1, 'test1')
        
        tagged_item = TaggedItem.objects.get_for_object(self.book1).get(tag__label='test1')
        self.assertTrue(tagged_item.frozen)
        
        TaggedItem.objects.freeze(self.book1, 'test1')
        
        tagged_item = TaggedItem.objects.get_for_object(self.book1).get(tag__label='test1')
        self.assertFalse(tagged_item.frozen)
    
    def test_remove_fail(self):
        TaggedItem.objects.add_or_get(self.book1, 'test1')
        TaggedItem.objects.add_or_get(self.book1, 'test2')
        TaggedItem.objects.add_or_get(self.book1, 'test3')
        
        TaggedItem.objects.freeze(self.book1, 'test1', 'freeze')
        TaggedItem.objects.remove(self.book1, 'test1')
        
        qs = TaggedItem.objects.get_for_object(self.book1)
        self.assertEquals(qs.count(), 3)
        
        TaggedItem.objects.freeze(self.book1, 'test1', 'thaw')
        TaggedItem.objects.remove(self.book1, 'test1')
        
        qs = TaggedItem.objects.get_for_object(self.book1)
        self.assertEquals(qs.count(), 2)
    
    def test_reconstruct(self):
        TaggedItem.objects.add_or_get(self.book1, 'test1')
        TaggedItem.objects.add_or_get(self.book1, 'test2')
        TaggedItem.objects.add_or_get(self.book1, 'test3')
        
        NEW_TAGS = ("foobar1", "foobar2", "foobar3", "foobar4")
        TaggedItem.objects.reconstruct(self.book1, ",".join(NEW_TAGS))
        
        qs = TaggedItem.objects.get_for_object(self.book1)
        for i, tagged_item in enumerate(qs):
            self.assertEquals(tagged_item.tag.label, NEW_TAGS[i])
Ejemplo n.º 50
0
def library(request):
    bookset = []
    bookinformation = []
    authorinformation = []
    ALLset = Book.objects.all()
    if request.GET:
        post = request.GET
        
        if post.has_key('insertorupdate'):#insert or update
            new_book = Book(
                ISBN = post["ISBN"],
                Title=post['Title'],
                AuthorID = post["AuthorID"],
                Publisher = post["Publisher"],
                PublishDate = post["PublishDate"],
                Price = post['Price'])
            dset = Book.objects.filter(ISBN = post['ISBN']) 
            if len(dset) != 0: #delete the repetitive book
                dset[0].delete()
            new_book.save()
            dset = Author.objects.filter(AuthorID = post['AuthorID'])
            if len(dset) == 0:  # add an author
                new_author = Author(
                    AuthorID = post['AuthorID'],
                    Name = post['AuthorName'],
                    Age = post['AuthorAge'],
                    Country = post['AuthorCountry'])
                new_author.save()
                
        if post.has_key('delete'): #delete the book
            dset = Book.objects.filter(ISBN = post['ISBN'])
            if len(dset) != 0:
                aset = Book.objects.filter(AuthorID = dset[0].AuthorID)
                if len(aset) == 1:
                    bset = Author.objects.filter(AuthorID = dset[0].AuthorID)
                    bset[0].delete()  #delete the author
                dset[0].delete()
                
        for i in ALLset:
            if post.has_key(i.Title):#show information of a book
                oneq = []
                oneq.append(i)
                bookinformation = [] + oneq
                authorinformation = Author.objects.filter(AuthorID = i.AuthorID)
                break
            if post.has_key(i.ISBN): #delete the book
                aset = Book.objects.filter(AuthorID = i.AuthorID)
                if len(aset) == 1:
                    bset = Author.objects.filter(AuthorID = i.AuthorID)
                    bset[0].delete()  #delete the author
                i.delete()
                break

        if post.has_key('toselect'):#search
            authorset = Author.objects.filter(Name = post['authorselect'])
            if len(authorset) != 0:
                bookset = Book.objects.filter(AuthorID = authorset[0].AuthorID)
                
    ALLset = Book.objects.all()
    
    
    return render_to_response('Book.html', {'ALLset': ALLset, 'ONE': bookinformation, \
    'AUTHOR': authorinformation, 'Bookset': bookset}, context_instance=RequestContext(request))