def get(self): # Get all the displayable books books_query = Book.query(ancestor=ROOT_BOOK_KEY) # Get the books currently in the cart cart_query = [] # check for a person and filter the books if self.person: books_query = books_query.filter(ndb.OR(Book.cart_key == None, Book.cart_key == self.person.key)) cart_query = self.person.get_cart() else: # remove all the books that are in someone's cart books_query = books_query.filter(Book.cart_key == None) books_query = books_query.order(-Book.last_touch_date_time) # Get additional details needed to populate lists dept_query = Department.query(ancestor=ROOT_DEPT_KEY).order(Department.abbrev) book_conditions = Book.get_conditions() self.values.update({"books_query": books_query, "cart_query" : cart_query, "dept_query": dept_query, "book_conditions": book_conditions}) self.render(**self.values)
def books(): book_edit_form_errors = None book_edit_forms = [] # generate book edit forms for book in Book.query.all(): book_edit_form = BookEditForm() writers = Writer.query.all() book_edit_form.writers.data = [writer.id for writer in book.writers] book_edit_form.title.data = book.title book_edit_form.id.data = book.id book_edit_forms.append(book_edit_form) if request.method == 'GET': book_add_form = BookAddForm() else: if request.form['btn'] == 'Edit': book_add_form = BookAddForm() book_edit_form_errors = BookEditForm(request.form) if book_edit_form_errors.validate(): writers = Writer.query.filter(Writer.id.in_(book_edit_form_errors.writers.data)).all() book = Book.query.filter(Book.id == book_edit_form_errors.id.data).first() book.edit(title=book_edit_form_errors.title.data, writers=writers) return redirect(url_for('books')) else: book_add_form = BookAddForm(request.form) if book_add_form.validate(): writer_ids = [writer.id for writer in book_add_form.writers.data] writers = Writer.query.filter(Writer.id.in_(writer_ids)).all() Book.add(title=book_add_form.title.data, writers=writers) return redirect(url_for('books')) return render_template('books.html', book_add_form=book_add_form, book_edit_forms=book_edit_forms, book_edit_form_errors=book_edit_form_errors)
def post(self, arg): book = Book(title = self.request.get('title', None), pages = self.get_int_param('pages'), locations = self.get_int_param('locations'), page = self.request.get('page', "Page")) book.put() self.redirect('/admin/books/%s/' % book.slug)
def add_book(request): if request.method =="POST": form = newBook(request.POST) if form.is_valid(): cd = form.cleaned_data try: author = Author.objects.get(Name = cd["Author"]) except: request.session["ISBN"] = cd["ISBN"] request.session["Title"] = cd["Title"] request.session["Publisher"] = cd["Publisher"] request.session["PublishDate"] = (str)(cd["PublishDate"]) request.session["Price"] = (str)(cd["Price"]) return HttpResponseRedirect("/add_author/?author=%s"%cd["Author"]) b = Book(ISBN = cd["ISBN"], Title = cd["Title"], AuthorID = author, Publisher = cd["Publisher"], PublishDate = cd["PublishDate"], Price = cd["Price"] ) b.save() return HttpResponseRedirect("/success/") else: form = newBook() return render_to_response("add_book.html",{"form":form})
def add_book(request): """ 添加书籍""" if request.POST: post = request.POST flag = 0 name_Set = post["authorname"] author_name =Author.objects.filter(name = name_Set) if(len(author_name) == 0): flag = 0 book_count = Book.objects.all().count() book_sum=Context({"Book_count":book_count, "flag":flag}) return render_to_response("addbook.html",book_sum) else: author_id =Author.objects.get(name = name_Set) new_book = Book( ISBN=post['ISBN'], Title = post['Title'], Publisher=post['Publisher'], PublishDate = post['PublishDate'], Price = post['Price'], Authorname = post['authorname'], Authorid = author_id) new_book.save() flag = -flag book_count = Book.objects.all().count() book_sum=Context({"Book_count":book_count,"flag":flag}) return render_to_response("addbook.html",book_sum) else: flag = 0 book_count = Book.objects.all().count() book_sum=Context({"Book_count":book_count,"flag":flag}) return render_to_response("addbook.html",book_sum)
def add(request): if request.POST: post = request.POST if ( post["ISBN"] and post["Title"] and post["AuthorID"] and post["Publisher"] and post["PublishDate"] and post["Price"] ): post = request.POST new_book = Book( ISBN=post["ISBN"], Title=post["Title"], AuthorID=post["AuthorID"], Publisher=post["Publisher"], PublishDate=post["PublishDate"], Price=post["Price"], ) new_book.save() # # new_author = Author( # AuthorID = post["AuthorID"], # Name = post["Name"], # Age = post["Age"], # Country = post["Country"]) # new_author.save() else: return HttpResponse("Please full all information.") return render_to_response("add.html")
def loaddir(directory, clear=False): if clear: Book.objects.all().delete() queue = os.listdir(directory) while queue: next = queue.pop() if next[0] == '.': continue if next in ('categories', 'template'): continue next = path.join(directory, next) if path.isdir(next): queue.extend([ path.join(next,f) for f in os.listdir(next) ]) continue filecontent = file(next).read() header, content = filecontent.split('\n---\n') header = yaml.load(header) content = preprocess_rst_content(content) review_date = parsedate(header['review_date']) review_date = time.strftime('%Y-%m-%d', review_date) B = Book(slug=header['slug'], title=header['title'], booktitle=header['booktitle'], author=header['author'], content=content, review_date=review_date) B.save() for c in header.get('tags','').split(): B.tags.add(tag_for(c))
def addBook(self, request): """create a book.""" self._ensureAdmin() b_key = ndb.Key(Book, request.sbId.upper()) if b_key.get(): raise endpoints.ConflictException( 'Another book with same id already exists: %s' % request.sbId) email = endpoints.get_current_user().email() book = Book (key = b_key, title = request.title.lower(), author = request.author, sbId = request.sbId.upper(), language = request.language, volume = request.volume, isbn = request.isbn, price = request.price, notes = request.notes, suggestedGrade = request.suggestedGrade, category = request.category, publisher = request.publisher, mediaType = request.mediaType, editionYear = request.editionYear, donor = request.donor, comments = request.comments, reference = request.reference, createdBy = email, createdDate = date.today() ) book.put() return request
def test_book_can_reserve_new_book_once(): book = Book('TITLE', 'DESCRIPTION', 'ISBN') book.reserve('RESERVER') book.reserve('RESERVER') assert_equals(len(book.reservations), 1) assert_in('RESERVER', book.reservations)
def test_book_can_borrow_reserved_book_if_only_reserver(): book = Book('TITLE', 'DESCRIPTION', 'ISBN') book.reserve('RESERVER') book.check_out('RESERVER') assert_equals(len(book.reservations), 0)
def get(self): db = getUtility(IRelationalDatabase) cr = db.cursor() barcode = self.book.barcode if barcode: cr.execute("""SELECT id, barcode, author, title FROM books WHERE barcode = ?""", (barcode,)) else: cr.execute("""SELECT id, barcode, author, title FROM books""") rst = cr.fetchall() cr.close() books = [] for record in rst: id = record['id'] barcode = record['barcode'] author = record['author'] title = record['title'] book = Book() book.id = id book.barcode = barcode book.author = author book.title = title books.append(book) return books
def test_default_creation(self): "Objects created on the default database don't leak onto other databases" # Create a book on the default database using create() Book.objects.create(title="Pro Django", published=datetime.date(2008, 12, 16)) # Create a book on the default database using a save dive = Book() dive.title="Dive into Python" dive.published = datetime.date(2009, 5, 4) dive.save() # Check that book exists on the default database, but not on other database try: Book.objects.get(title="Pro Django") Book.objects.using('default').get(title="Pro Django") except Book.DoesNotExist: self.fail('"Dive Into Python" should exist on default database') self.assertRaises(Book.DoesNotExist, Book.objects.using('other').get, title="Pro Django" ) try: Book.objects.get(title="Dive into Python") Book.objects.using('default').get(title="Dive into Python") except Book.DoesNotExist: self.fail('"Dive into Python" should exist on default database') self.assertRaises(Book.DoesNotExist, Book.objects.using('other').get, title="Dive into Python" )
def content(bid, cid): book = Book.get(bid) chapter = Chapter.get(cid, bid) if not (book and chapter): abort(404) # NOTE read/set cookies for recent reading recent_reading = request.cookies.get('recent_reading') rec_book_chapters = [] if recent_reading: for bid_cid in recent_reading.split('|'): _bid, _cid = [int(id) for id in bid_cid.split(':', 1)] if not _bid == bid: if Book.get(_bid) and Chapter.get(_cid, _bid): rec_book_chapters.append( (Book.get(_bid), Chapter.get(_cid, _bid)) ) rec_book_chapters.insert(0, (book, chapter)) rec_book_chapters = rec_book_chapters[:10] resp = make_response(render_template('content.html', **locals())) recent_reading_str = '|'.join(['%s:%s' % (book.id, chapter.id) for book, chapter in rec_book_chapters]) resp.set_cookie('recent_reading', recent_reading_str) return resp
def post(self): "Creates a new book record from a json representation" # check we have the correct authentication ket auth = self.request.get("auth") if auth != settings.AUTH: return self.error(401) # get the request body json = self.request.body # convert the JSON to a Python object representation = simplejson.loads(json) # create a datastore object from the JSON book = Book( title = representation['title'], ident = representation['ident'], author = representation['author'], image = representation['image'], notes = representation['notes'], url = representation['url'] ) logging.info('Add new book request') try: # save the object to the datastore book.put() # send an email about the new book _email_new_book(book) except: logging.error("Error occured creating new book via POST") self.error(500)
def post(): form = PostForm() if request.method == 'GET': if request.args.get('isbn'): form.isbn.data = request.args.get('isbn') if form.validate_on_submit(): isbn = form.isbn.data.strip().replace('-','').replace(' ','') price = form.price.data if price == '': price = None cond = form.condition.data comments = form.comments.data courses = form.courses.data.strip().replace(' ','').upper() if len(courses) > 9: courses = '' if not Book.query.get(isbn): info = get_amazon_info(isbn) image = get_amazon_image(isbn) b = Book(isbn=isbn, title=info['title'], author=info['author'], amazon_url=info['url'], image=image, courses=[courses]) add_commit(db, b) else: b = Book.query.get(isbn) old_courses = list(b.courses) old_courses.append(courses) b.courses = list(set(old_courses)) db.session.commit() p = Post(uid=current_user.id, timestamp=datetime.utcnow(), isbn=isbn, price=price,condition=cond,comments=comments) add_commit(db, p) email_subbers(p) return redirect(url_for('book',isbn=isbn)) return render_template('post.html', post_form = form)
def test_book_can_reserve_new_book_with_more_than_one_user(): book = Book('TITLE', 'DESCRIPTION', 'ISBN') book.reserve('RESERVER') book.reserve('ANOTHER RESERVER') assert_equals(len(book.reservations), 2) assert_equals('RESERVER', book.reservations[0]) assert_equals('ANOTHER RESERVER', book.reservations[1])
def insert_action(request): #try: inputed_isbn = request.POST['br-input-isbn'] inputed_bcover = request.POST['br-input-bcover'] inputed_bname = request.POST['br-input-bname'] inputed_author = request.POST['br-input-author'] inputed_translator = request.POST['br-input-translator'] inputed_publisher = request.POST['br-input-publisher'] inputed_byear = request.POST['br-input-byear'] inputed_pagination = request.POST['br-input-pagination'] inputed_price = request.POST['br-input-price'] inputed_insertednum = request.POST['br-input-insertednum'] try: book=Book.objects.get(isbn=inputed_isbn) book.bname=B(inputed_bname) book.author=B(inputed_author) book.translator=B(inputed_translator) book.byear=B(inputed_byear) book.pagination=int(inputed_pagination) book.price=float(inputed_price) # TODO : 封面应该下载到本地储存或SAE storage book.bcover=B(inputed_bcover) book.publisher=B(inputed_publisher) book.totalnum=book.totalnum+int(inputed_insertednum) book.available=book.available+int(inputed_insertednum) book.save() return HttpResponseRedirect("/success/insert") except Book.DoesNotExist: book=Book( isbn=B(inputed_isbn), bname=B(inputed_bname), author=B(inputed_author), translator=B(inputed_translator), byear=B(inputed_byear), pagination = 0, price=float(inputed_price), # TODO : 封面应该下载到本地储存或SAE storage bcover=B(inputed_bcover), publisher=B(inputed_publisher), totalnum=int(inputed_insertednum), available=int(inputed_insertednum), ) if(inputed_pagination!=''): book.pagination=int(inputed_pagination) book.save() return HttpResponseRedirect("/success/insert") except Book.MultipleObjectsReturned as e: #isbn不唯一 #TODO:其实这里新建一条记录可能比较好 raise Exception(Book.STATIC_BOOKS_WITH_SAME_ISBN+unicode(e)) """
def on_add_clicked(self, *args): barcode = self.ui.barcode.get_text() author = self.ui.author.get_text() title = self.ui.title.get_text() book = Book() book.barcode = barcode book.author = author book.title = title self.add(book) self.ui.list_store.append((book, barcode, author, title))
def book_return(self, book_barcode): book = Book() book.number = book_barcode bookdboperation = getAdapter(book, IDbOperation) book = bookdboperation.get()[0] circulation = Circulation() circulation.book = book circulationdboperation = getAdapter(circulation, IDbOperation) circulationdboperation.delete()
def save(request): form = BookForm(request.POST) if form.is_valid(): cd = form.cleaned_data new_book = Book(isbn=cd['isbn'], title=cd['title'], author=cd['author'], cover=cd['cover']) new_book.save() return HttpResponseRedirect('/')
def dispatch_request(self): form = BookForm() form.authors.query = Author.query.all() if request.method == "POST": if form.validate_on_submit(): obj = Book() form.populate_obj(obj) obj.save() return redirect("/books/") return render_template("book_add.html", form=form)
def test_concurrent_delete(self): "Deletes on concurrent transactions don't collide and lock the database. Regression for #9479" # Create some dummy data b1 = Book(id=1, pagecount=100) b2 = Book(id=2, pagecount=200) b3 = Book(id=3, pagecount=300) b1.save() b2.save() b3.save() transaction.commit() self.assertEqual(3, Book.objects.count()) # Delete something using connection 2. cursor2 = self.conn2.cursor() cursor2.execute('DELETE from delete_regress_book WHERE id=1') self.conn2._commit() # Now perform a queryset delete that covers the object # deleted in connection 2. This causes an infinite loop # under MySQL InnoDB unless we keep track of already # deleted objects. Book.objects.filter(pagecount__lt=250).delete() transaction.commit() self.assertEqual(1, Book.objects.count()) transaction.commit()
def edit_book(request): if request.method == 'POST': form = BookForm(request.POST) if form.is_valid(): cd = form.cleaned_data book = Book(title=cd['title']) book.put() return HttpResponseRedirect('/search/?q=all') else: form = BookForm() logger.error ("here i am") return render_to_response('book_edit.html', {'form': form})
def test_book_autodelete(self): note1 = Note(text='text') note1.save() note2 = Note(text='text') note2.save() book = Book(title='title') book.save() book.notes.add(*[note1, note2]) note1.delete() self.assertTrue(Book.objects.all()) note2.delete() self.assertFalse(Book.objects.all())
def books_add(): form = BookForm(request.form) if request.method == "POST" and form.validate(): new_book = Book(title=form.data.get('title')) new_book.authors = form.data.get('authors') db.session.add(new_book) db.session.commit() flash("Book added") return redirect(url_for('books_view_all')) return render_template('books/add.html', **locals())
def put(self, ident): "Update an existing book or create a new one" # check we have the correct authentication ket auth = self.request.get("auth") if auth != settings.AUTH: return self.error(401) # get the JSON from the request json = self.request.body # convert the JSON to a Python object representation = simplejson.loads(json) # set the properties title = representation['title'] ident = representation['ident'] author = representation['author'] image = representation['image'] notes = representation['notes'] url = representation['url'] try: # retrieve the book based on its ident value book = Book.all().filter('ident =', ident)[0] book.title = title book.ident = ident book.author = author book.image = image book.notes = notes book.url = url except IndexError: # if we don't find a book then create one book = Book( title = title, ident = ident, author = author, image = image, notes = notes, url = url ) logging.info("Update request for %s (%s)" % (title, ident)) # save the object to the datastore try: # save the object to the datastore book.put() # send an email about the new book _email_new_book(book) # we'e updated so we need to clear the cache memcache.delete("ws_books") except: logging.error("Error occured creating/updating \ book %s (%s) via PUT") % (title, ident) self.error(500)
def test_books_with_content_returns_200(self): self.assertEquals(0, Book.all().count()) book = Book( title = "test", ident = "1", author = "author", notes = "", image = "http://example.com/image.gif", url = "http://example.com" ) book.put() response = self.app.get('/books', expect_errors=True) self.assertEquals("200 OK", response.status)
def submit(request): if request.POST: post = request.POST p=Author.objects.get(AuthorID =post["authorid"]) new_book = Book( Title = post["title"], ISBN = post["isbn"], Publisher = post["pub"], PublishDate = post["date"], Price = post["price"], Authors=p) new_book.save() return HttpResponseRedirect('/home/')
def new_book(request): t = get_template('feedback.html') try: author = Author.objects.get(name = request.GET['author']) date = request.GET['year']+'-'+request.GET['month']+'-'+request.GET['day'] book = Book(title=request.GET['title'], author_id = author, publisher=request.GET['publisher'], publish_date=date, price=request.GET['price']) book.save() html = t.render(Context({'text':'操作成功'})) except: html = t.render(Context({'text':'操作失败'})) return HttpResponse(html)
def donate(request): authenticated = False donated = False user_admin = False if request.user.is_superuser and request.user.is_staff: user_admin = True if request.user.is_authenticated(): authenticated = True donations = Donate.objects.values() form = DonateForm(request.POST or None, request.FILES or None) if request.method == 'POST': smth = True for donation in donations: if 'accept' + str(donation['id_donate']) in request.POST: book = Book(ISBN=donation['ISBN'], title=donation['title'], author=donation['author'], genre=donation['genre'], image=donation['image'] ) book.save() Donate.objects.filter(id_donate=donation['id_donate']).delete() email_user(user=request.user, subject='donate book', message='Your book donation for' + donation.title + ' has been accepted') smth = False break if 'reject' + str(donation['id_donate']) in request.POST: Donate.objects.filter(id_donate=donation['id_donate']).delete() smth = False email_user(user=request.user, subject='donate book', message='Your book donation for' + donation.title + ' has been declined') break if smth and form.is_valid(): donation = form.save(commit=False) donation.user = request.user donation.image = form.cleaned_data['simage'] donation.save() donated = True email_user(user=request.user, subject='donate book', message='Request for donating ' + donation.title + " received") donations = Donate.objects.values() return render_to_response("book_donate.html", context_instance=RequestContext(request, {'authenticated': authenticated, 'user_admin': user_admin, 'donations': donations, 'form': form, 'donated': donated}))
def create_books(): book = load_json('books.json') for oneBook in book: #print(oneBook['title']) if Book.query.get(oneBook['google_id']) is None: isbn = oneBook.get('isbn') title = oneBook.get('title') try: sub = oneBook['subtitle'] except KeyError: sub = None id = oneBook.get('google_id') date_pub = oneBook.get('publication_date') if date_pub: try: date_pub = datetime.date(datetime.strptime(oneBook.get('publication_date'),"%Y-%m-%d")) except: date_pub = None image_url = oneBook['image_url'] description = oneBook.get('description') #we cant import a list into our db for pub in oneBook['publishers']: publisher = pub['name'] create_publishers(pub) #we cant import a list into our db for aut in oneBook['authors']: author = aut['name'] create_authors(aut) newBook = Book(isbn = isbn,id = id,title = title,subtitle = sub,date_pub = date_pub,author = author,publisher = publisher,description = description,img_url = image_url) db.session.add(newBook) db.session.commit()
def get_all_shelves(reader_id, shelf_name): books_in_shelf = Shelf.read_by_reader_and_name(shelf_name, reader_id) books = [] for book in books_in_shelf: books.append(Book.read_by_id(book['id_book'])) return jsonify(books), 200
def queryCheckouts(self, request): """get checkout records""" self._ensureAdmin() q = Book.query(Book.checkedOut == True) if request.overDue == True: q = q.filter(Book.dueDate < date.today()) elif request.sbId: q = q.filter( ndb.AND(Book.sbId >= request.sbId.upper(), Book.sbId < request.sbId.upper() + 'Z')) q = q.order(Book.sbId) elif request.name: q = q.filter( ndb.AND(Book.title >= request.name.lower(), Book.title < request.name.lower() + 'z')) q = q.order(Book.title) curs = Cursor(urlsafe=request.cursor) books, nextcurs, more = q.fetch_page(PAGE_SIZE, start_cursor=curs) nextcursor = None if more and nextcurs: nextcursor = nextcurs.urlsafe() return CheckoutForms(items = [self._copyCheckoutToForm(checkout) \ for checkout in books], cursor = nextcursor)
def add_book(): book_data = request.get_json()['book'] val = 0 result = check_book(book_data, val) if (result == 1): return "<h1>please enter valid data</h1>" title = book_data['title'] author = book_data['author'] publisher = book_data['publisher'] isbn = book_data['isbn'] url = book_data['url'] try: book = Book(title=title, author=author, publisher=publisher, isbn=isbn, url=url) db.session.add(book) db.session.commit() res = { 'id': book.id, 'title': book.title, 'author': book.author, 'publisher': book.publisher, 'isbn': book.isbn, 'url': book.url } return jsonify(res) except Exception as e: return (str(e))
def loadBooks(): publisher_id = 1 book_id = 1 authorList_id = 1 for i in range(len(df)): book_id = book_id book_title = df['title'][i] book_description = df['description'][i] book_isbn = df['isbn'][i] book_publisher_date = df['publication_date'][i] book_google_id = df['google_id'][i] book_image_url = df['image_url'][i] book_publisherID = publisher_id publishers = db.session.query(Publisher).all() for publisher in publishers: if df['publishers'][i][0]['name'] == publisher.name: book_publisherID = publisher.id #print(book_publisherID) newBook = Book(id=book_id, title=book_title, description=book_description, isbn=book_isbn, publisher_date=book_publisher_date, google_id=book_google_id, image_url=book_image_url, publisherID=book_publisherID) db.session.add(newBook) db.session.commit() book_id += 1
def queryBooks(self, request): """Return books based on query.""" self._ensureAdmin() q = Book.query() #TODO: get projection, not all columns if request.sbId: q = q.filter( ndb.AND(Book.sbId >= request.sbId.upper(), Book.sbId < request.sbId.upper() + 'Z')) q = q.order(Book.sbId) elif request.name: q = q.filter( ndb.AND(Book.title >= request.name.lower(), Book.title < request.name.lower() + 'z')) q = q.order(Book.title) curs = Cursor(urlsafe=request.cursor) books, nextcurs, more = q.fetch_page(PAGE_SIZE, start_cursor=curs) nextcursor = None if more and nextcurs: nextcursor = nextcurs.urlsafe() return BookForms(items = [self._copyBookToForm(book) \ for book in books], cursor = nextcursor)
def create_book(): body = request.get_json() new_title = body.get( 'title', None ) # get title from the body, if nothing in title, set its value to None new_author = body.get( 'author', None ) # get author from the body, if nothing in author, set its value to None new_rating = body.get( 'rating', None ) # get rating from the body, if no rating, then set its value to None (initially) search = body.get('search', None) try: if search: # if there's search term selection = Book.query.order_by(Book.id).filter( Book.title.ilike('%{}%'.format( search))) # search book title with case insensitive current_books = paginate_books( request, selection) # paginate the search results return jsonify({ 'success': True, 'books': current_books, 'total_books': len(selection.all()) }) else: book = Book(title=new_title, author=new_author, rating=new_rating) book.insert() selection = Book.query.order_by(Book.id).all() current_books = paginate_books(request, selection) return jsonify({ 'success': True, 'created': book.id, 'books': current_books, 'total_books': len(Book.query.all()) }) except: #unprocessable abort(422)
def get_item_info(): rows = Book.query.all() book_list = [] for row in rows: book_list.append(Book.as_dict(row)) item_info_dict = reader.get_item_full_info(book_list) return item_info_dict
def api_collection_book_chapters(collection_name, bookNumber): """ swagger_from_file: specs/collection_book_chapters.yaml """ book_id = Book.get_id_from_number(bookNumber) return Chapter.query.filter_by(collection=collection_name, arabicBookID=book_id).order_by( Chapter.babID)
def show_item_info(): rows = Book.query.all() book_list = [] for row in rows[:1000]: book_list.append(Book.as_dict(row)) item_info_dict = reader.get_item_full_info(book_list) return json.dumps(item_info_dict)
def create_books(): b = Book(u'Война и мир') a = Author(u'Толстой') b.authors.append(a) db.session.add(b) b1 = Book(u'Финансист') b2 = Book(u'Титан') a = Author(u'Теодор Драйзер') b1.authors.append(a) b2.authors.append(a) db.session.add_all([b1, b2]) b = Book(u'Dive into Python') a = Author(u'Марк Пилгрим') b.authors.append(a) db.session.add(b)
def get_book_by_isbn(isbn): rows = _get_books_from_db('books.isbn', isbn, False) if rows.rowcount > 0: book = Book() _populate_book_data(book, next(rows)) _populate_book_reviews(book) return book return None
def _add_book(**kwargs): try: book = Book(**kwargs) db.session.add(book) db.session.commit() return jsonify(message="Book added. book id={}".format(book.id)) except Exception as e: return jsonify(errors=str(e)), HTTPStatus.BAD_REQUEST
def new_book(): body = request.get_json() book = Book(body.get('title'), body.get('author'), int(body.get('rating'))) book.insert() book = Book.query.order_by('id').all formatted_books = [book.format() for book in Book] page = request.args.get('page', 1, type=int) start = (page - 1) * 8 end = start + 8 return jsonify({ 'success': True, 'Created': Book.id, 'books': formatted_books[start:end], 'total_books': len(formatted_books) })
def test_book_update_via_service_put(self): self.assertEquals(0, Book.all().count()) book = Book(title="test", ident="1", author="author", notes="", image="http://example.com/image.gif", url="http://example.com") book.put() self.assertEquals(1, Book.all().count()) json = """{ "ident": "1", "title": "test update", "author": "author", "notes": "", "image": "http://example.com/image.gif", "url": "http://example.com" }""" response = self.app.put('/books/1', params=json, expect_errors=True) self.assertEquals(1, Book.all().count()) response = self.app.get('/books/1', expect_errors=True) self.assertEquals("200 OK", response.status) try: json = response.json except AttributeError: assert (False) self.assertEqual(json['ident'], "1") self.assertEqual(json['title'], "test update")
def list_chapters(self): course = Course(self.api_client.client, self.args.course) book = Book(course, self.args.book) print_list( [ "{}. {}".format(str(float(c["rank"])).rstrip("0").rstrip("."), c["title"]) for c in Chapter.list(course, book) ] )
def bulk_add_books(books_to_add): """Add a large amount of books to database in one request. :param books_to_add: list of dicts with keys: title, author, category and description """ for book in books_to_add: new_book = Book(**book) db.session.add(new_book) db.session.commit()
def import_books(): with open("books.csv") as f: csvreader = csv.reader(f) next(csvreader) for isbn, title, author, year in csvreader: book = Book(isbn=isbn, title=title, author=author, year=year) db.session.add(book) print(f'Added book. title: {title}') db.session.commit()
def delat(genre_id): # Вывод всей информации о жанре информация для авторизованного пользователя # если пользователь не авторизован, кидаем его на страницу входа if 'username' not in session: return redirect('/login') # если не админ, то его на главную страницу if session['username'] != 'admin': return redirect(url_for('index')) # иначе выдаем информацию books = Book(db.get_connection()).get_by_genre(genre_id) for i in books: Book(db.get_connection()).delete(i[2]) genre_Book(db.get_connection()).delete(genre_id) genres = genre_Book(db.get_connection()).get_all() return render_template('genre_admin.html', username=session['username'], title='Просмотр жанров', genres=genres)
def create_book(self, title="test_title", google_books_id="1", authors="test_authors"): book = Book(title=title, google_books_id=google_books_id, authors=authors) self.add_to_database(book) return book
def get(self, book_id, page_id): book = Book(book_id) page = Page(page_id, book) paras = [ ParaSerializer(Paragraph(id=paraId, in_page=page, in_book=book)).data for paraId in page.paras ] return jsonify(data=paras)
def books_create(): try: book = Book(title=request.form.get('title')) db.session.add(book) db.session.commit() except Exception as e: app.logger.error('Failed to add book') app.logger.error(e) return redirect('/books')
async def vote_by_criterias( c: types.CallbackQuery , state: FSMContext ) : print( f'user @{c.from_user.username} wants to vote by criteria' ) async with state.proxy() as data : book = Book.objects( id=data[ 'book_id' ] ).first() await add_to_temp( await new_book_or_review( get_user( c.from_user.id ) , c , book , need_to_add=False , actions=False ) , data )
def run(): for bt, st in spider.get_tags(): if not Tag.objects(btag=bt[0]).all(): for t in st: tag = Tag(stag=t, btag=bt[0]) tag.save() for t in Tag.objects.all(): # 查询小标签出来,逐个下载 for page, url_list in spider.get_all_list_page(t.stag): # 获取所有翻页 for book_url in url_list: # 遍历列表页 detail = spider.get_book_detail(book_url) detail = spider.clean_detail(detail) # 清洗数据 detail["small_tag"] = t.stag detail["big_tag"] = t.btag book = Book(**detail) book.save() break break
def readFile(): v = [] f = open("./storage/books.csv") isbns = [] reader = csv.reader(f) for isbn, title, author, year in reader: book = Book(isbn=isbn, title=title, author=author, year=year) v.append(book) isbns.append(book.isbn)
def delete_book(book_id): try: book = Book.query.filter(Book.id == book_id).one_or_none() if book is None: abort(404) book.delete() return jsonify({ 'success': True, 'deleted': book_id, 'books': paginate(request), 'total_books': Book.count() }) except: abort(404) finally: Book.db_close()
def rating(book_id): # Запрос книг, продающихся в определенном жанре form = SearchgenreForm() form.genre_id.choices = [(0, '0'), (1, '1'), (2, '2'), (3, '3'), (4, '4'), (5, '5')] if form.validate_on_submit(): # if form.genre_id.data != '0': Book(db.get_connection()).sred(book_id, form.genre_id.data) # редирект на главную страницу books = Book(db.get_connection()).get_all() return render_template('book_user.html', username=session['username'], title='Просмотр базы', books=books) return render_template("search_genre.html", title='Подбор по цене', form=form)
def add(): data = request.get_json() author = data['author'] title = data['title'] read = data['read'] book = Book(author=author, title=title, read=read) db.session.add(book) db.session.commit() return jsonify(data)
def create_book(): print("FORM DATA:", dict(request.form)) new_book = Book(title=request.form["book_title"], author_id=request.form["author_name"]) db.session.add(new_book) db.session.commit() return jsonify({"message": "BOOK CREATED OK", "book": dict(request.form)})
def main(): path = Path() menu = Menu() menu.instructions() while True: # menu.de_entrada() try: excel_filename = input("Ingresa el nombre del archivo de excel: ") excel_exists = path.check_existence(excel_filename) if excel_exists: # File found notification for the user. menu.file_found() # Tras haber verificado que el archivo existe, se crea el path para cargar el libro con openpyxl. excel_file_path = path.book_path(excel_filename) # Book settings book = Book(excel_file_path) book_headers = book.get_headers() book_rows = book.get_list_of_rows() app_name = input( "Ingresa el nombre del app de tu proyecto Django: ") model_name = input("Ingresa el nombre del modelo de tu app: ") fx = Fixture( app=app_name, model=model_name, headers=book_headers, list_of_fields=book_rows, ) fx.create_objects() fx.create_json_file(path.json_dir) menu.task_completed() break else: menu.file_not_found() except ValueError: print("Ingresa el nombre del archivo.") print("") pass