def init():
a = models.Author.query.all()
b = models.Book.query.all()
for c in a:
db.session.delete(c)
db.session.commit()
for c in b:
db.session.delete(c)
db.session.commit()
a1 = models.Author('author1')
a2 = models.Author('author2')
a3 = models.Author('author3')
a4 = models.Author('author4')
b1 = models.Book('book1')
b2 = models.Book('book2')
b3 = models.Book('book3')
b4 = models.Book('book4')
a1.books.append(b1)
a1.books.append(b2)
a2.books.append(b2)
a3.books.append(b2)
a3.books.append(b3)
a4.books.append(b1)
a4.books.append(b2)
a4.books.append(b3)
a4.books.append(b4)
db.session.add(a1)
db.session.add(a2)
db.session.add(a3)
db.session.add(a4)
db.session.commit()
flash('Database was reinitiated')
return redirect('/index')
def addBook(config):
click.echo('add Book from config file:%s' % config)
"""
"name": "book3",
"author": "author3",
"pic": "wwww.baidu.com",
"desc": "This is description",
"contents": "描\n述\n文\n本",
"type": "type",
"download": "www.baidu.com,www.baidu.com"
"""
import json as js
bookConfig = open(config).read()
bookConfig = js.loads(bookConfig)
click.echo(bookConfig['books'])
for book in bookConfig['books']:
click.echo(book['name'])
bookData = models.Book(name=book['name'],
author=book['author'],
booktype=book['type'],
pic=book['pic'],
contents=book['contents'],
download=book['download'])
db.session.add(bookData)
db.session.commit()
def add_book():
""" Add a book specifying the data as query parameters and returns the newly generated object
"""
try:
title = request.args.get('title', None)
author = request.args.get('author', None)
language = request.args.get('language', None)
if title is None or author is None or language is None:
json_obj = add_service_info_to_json(code='Error',
state='Missing parameter(s)')
else:
existing = models.Book.query.filter_by(title=title,
author=author,
language=language).first()
if existing is None:
book = models.Book(title=title,
author=author,
language=language)
db.session.add(book)
db.session.commit()
db.session.refresh(book)
json_obj = add_service_info_to_json(
code='OK',
state='Book created successfully',
json_obj=book.json())
else:
json_obj = add_service_info_to_json(
code='OK',
state='Book exists, using existing',
json_obj=existing.json())
except exc.OperationalError as err:
json_obj = add_service_info_to_json(code='Error', state=str(err))
return json.dumps(json_obj, sort_keys=True)
def addBook():
log.debug("GET add book page")
form = AddBookForm()
user = models.User.query.filter_by(
usernameDB=current_user.usernameDB).first()
ListsToPick = [(list.id, list.listTitle)
for list in models.List.query.filter_by(user_id=user.id)]
form.addBookToList.choices = ListsToPick
if form.validate_on_submit():
log.debug("Add book form submitted")
newBook = models.Book(bookTitle=form.bookTitle.data,
bookRating=form.bookRating.data,
user_id=user.id)
checkBook = models.Book.query.filter_by(
user_id=current_user.id).filter_by(
bookTitle=form.bookTitle.data).first()
if checkBook is None:
for listID in form.addBookToList.data:
addToList = models.List.query.get(listID)
newBook.lists.append(addToList)
db.session.add(newBook)
db.session.commit()
log.info("Successfully added book '%s'", newBook.bookTitle)
else:
log.error("Cannot add book: Book already exists")
flash("Book alreay exists!")
form.bookTitle.data = ""
form.bookRating.data = ""
flash("Book added!")
return render_template('AddBook.html',
title='Add Book',
form=form,
Lists=models.List.query.filter_by(user_id=user.id))
def client():
os.environ['APP_CONFIG'] = 'testing.cfg'
app = create_app()
with app.test_client() as client:
with app.app_context():
db.create_all()
db.session.add(models.Book(title='1984', author='George Orwell'))
db.session.add(
models.Book(title='Война и мир', author='Лев Толстой'))
db.session.commit()
yield client
with app.app_context():
db.drop_all()
def add_book():
form = forms.BookForm()
if form.validate_on_submit():
cover = form.cover.data
filename = secure_filename(cover.filename)
path = os.path.abspath(MEDIA_FOLDER)
path = os.path.join(path, filename)
cover.save(path)
book = models.Book()
book.title = form.title.data
book.author = form.author.data
book.year = form.year.data
book.description = form.description.data
book.cover_path = filename
if not form.validate():
flash('Title field is required', 'error')
return render_template('book.html', form=form, add_book=True)
try:
db.session.add(book)
db.session.commit()
flash('You have successfully added a new book.')
except:
# in case book name already exists
flash('Error: Book name already exists.')
return redirect(url_for('index'))
else:
return render_template('book.html', form=form, add_book=True)
def add_book(self, data):
if 'csrf_token' in data:
data.pop('csrf_token')
new_book = models.Book(title=data['title'], borrowed=data['available'])
for author in data['author']:
new_book.authors.append(models.Author(name=author))
db.session.add(new_book)
db.session.commit()
def post(self):
data = BooksCreate.parser.parse_args()['data']
data = _str2dict(data)
book = models.Book(**data)
db.session.add(book)
db.session.commit()
return {"data": data}
def add_book():
title = request.form['title']
author = request.form['author']
possessor = request.form['possessor']
book = models.Book(title, author, possessor)
db.session.add(book)
db.session.commit()
return redirect(url_for('get_books'))
def get_or_create_book(used_id: int, book: schemas.BookCreate,
db: Session) -> schemas.Book:
db_book = (db.query(models.Book).filter(
models.Book.google_books_id == book.google_books_id).first())
if not db_book:
db_book = models.Book(**book.dict())
db_user = db.query(models.User).filter(models.User.id == used_id).first()
db.add(db_book)
db_book.users.append(db_user)
db.commit()
db.refresh(db_book)
return db_book
def upload():
g.user = current_user
filenames = []
if request.method == 'POST':
if request.form['title'] == '':
flash('Please enter a title of the book that is to be uploaded')
return redirect(request.url)
newfolder_id = db.session.query(db.func.max(
models.Book.id)).scalar() # latest id
# print('newfolder_id = '+str(newfolder_id))
newfolder_id = int(newfolder_id or 0) + 1
dir = UPLOAD_FOLDER + '/' + str(newfolder_id)
# print('dir = '+str(dir))
uploaded_files = request.files.getlist("file")
#print('\n')
shareable = 'shareable' in request.form
# print('shareable = '+str(shareable))
for file in uploaded_files:
print('file name:')
print(file.filename)
if file.filename == '':
flash('No files selected')
return redirect(request.url)
# Check if the file is one of the allowed types/extensions
if file and allowed_file(file.filename):
# Make the filename safe, remove unsupported chars
filename = secure_filename(file.filename)
# Move the file from the temp folder ot the upload folder
if not os.path.exists(dir):
print('folder does not exist. Creating folder...')
os.makedirs(dir)
print('uploading ' + file.filename)
file.save(os.path.join(dir, filename))
print('upload of ' + filename + ' complete')
# save the filename into a list, we'll use it later
filenames.append(filename)
else:
flash('Only files of type mp3 and jpg will be uploaded.')
#return redirect(request.url)
print('\n')
a = concatAudio(dir, request.form['title'])
a.concat()
newBook = models.Book(title=request.form['title'],
author=request.form['author'],
shareable=shareable)
current_user.books.append(newBook)
db.session.add(newBook)
db.session.commit()
return render_template('upload.html',
filenames=filenames,
title='all the new files')
def reupload(book_id, email="", key=""):
subtitle = "Reupload book to Internet Archive"
form = ReUpload()
if email in (None, "") and key not in (None, ""):
return render_template('reupload.html', subtitle=subtitle, form=form)
if key != hashlib.md5(str(email) + str(keys.flask_app_secret)).hexdigest(
) and key not in (None, ""):
return render_template('reupload.html', subtitle=subtitle, form=form)
form = ReUpload()
if form.validate() or key not in (None, ""):
book_values = re.search("(.*):(.*)", book_id)
library = book_values.group(1)
Id = book_values.group(2)
ia_identifier_suffix = get_valid_identifier_suffix(library, Id)
reset_book_progress(library, ia_identifier_suffix)
redis = redis_py.Redis()
redis_key3 = keys.redis_key3
book_metadata = redis_py.get(redis_key3 + ":" + book_id + ":meta_data",
True)
book_key = "%s:%s:%s" % (redis_key3, library, ia_identifier_suffix)
metadata_key = book_key + ":meta_data"
book_request_key = book_key + ":requests"
redis_py.set(metadata_key, book_metadata, True)
request = dict(email=form.email.data)
redis_py.sadd(book_request_key,
json.dumps(request),
request_cache=True)
book = models.Book(book_id=ia_identifier_suffix,
library=library,
requests=json.dumps(request),
meta_data=book_metadata)
db.session.add(book)
db.session.commit()
redis_key1 = keys.redis_key1
q_global_job = redis_py.Queue(redis_key1 + "global")
q_global_job.add(
json.dumps(dict(library=library, book_id=ia_identifier_suffix)))
q = redis_py.Queue(redis_key1)
q.add(
json.dumps(
dict(library=library,
Id=Id,
ia_identifier_suffix=ia_identifier_suffix)))
flash(error_msg(100, email=form.email.data))
return redirect(
url_for('progress', book_id=library + ":" + ia_identifier_suffix))
else:
return render_template('reupload.html', subtitle=subtitle, form=form)
def submit_job(stored_request):
"""Add book-request to the job queues"""
redis_key1 = keys.redis_key1
lock_key1 = keys.lock_key1
q = redis_py.Queue(redis_key1)
q_global_job = redis_py.Queue(redis_key1 + "global")
redis = redis_py.Redis()
redis_key3 = keys.redis_key3
book_key = "%s:%s:%s" % (redis_key3, stored_request.library,
stored_request.book_id)
book_request_key = book_key + ":requests"
Lock = redis_py.Lock(lock_key1)
locked = False
if redis.exists(book_request_key):
locked = Lock.acquire(timeout=60)
request = dict(sno=stored_request.sno, email=stored_request.email)
redis_py.sadd(book_request_key, json.dumps(request), request_cache=True)
redundant_request = models.Request.query.filter_by(
md5_book=stored_request.md5_book, confirmed=1,
job_submitted=1).first()
if redundant_request == None:
reset_book_progress(stored_request.library, stored_request.book_id)
md5_book = hashlib.md5(stored_request.book_id +
stored_request.library).hexdigest()
library_url_key = book_key + ":library_url"
library_url = redis_py.get(library_url_key, True)
metadata_key = book_key + ":meta_data"
meta_data = redis_py.get(metadata_key, True)
book = models.Book(book_id=stored_request.book_id,
library=stored_request.library,
md5_book=stored_request.md5_book,
connected_request_sno=stored_request.sno,
requests=json.dumps(request),
library_url=library_url,
meta_data=meta_data)
db.session.add(book)
#db.session.commit()
q.add(stored_request.sno)
stored_request.job_submitted = 1
db.session.commit()
q_global_job.add(
json.dumps(
dict(library=stored_request.library,
book_id=stored_request.book_id)))
if locked == True:
Lock.release()
def addbook():
form = forms.Book_add()
if form.validate_on_submit():
newbook = models.Book(id=form.id.data,
name=form.name.data,
style_num=form.style_num.data,
author=form.author.data,
count=form.count.data,
available_count=form.available_count.data,
price=form.price.data,
press=form.press.data,
publish_date=form.publish_date.data,
summary=form.summary.data)
db.session.add(newbook)
db.session.commit()
flash('操作成功')
return render_template('addbook.html', form=form)
def add():
form = AddForm()
if form.validate_on_submit():
if form.a_name.data in str(models.Author.query.all()):
author = models.Author.query.filter_by(
name=form.a_name.data).first()
else:
author = models.Author(form.a_name.data)
if form.b_name.data in str(models.Book.query.all()):
book = models.Book.query.filter_by(name=form.b_name.data).first()
else:
book = models.Book(form.b_name.data)
author.books.append(book)
db.session.add(author)
db.session.commit()
flash('Added successfully')
return redirect('/index')
return render_template('Add.html', title='Add', form=form)
def create_book(book_raw, user_id):
book_schema = m.BookSchema()
book_data, _err = book_schema.load(book_raw)
book = m.Book()
book.title = book_data['title']
book.description = book_data['description']
book.cover = book_data['cover']
book.editors.append(m.User.query.get(user_id))
if _err:
return None
else:
m.db.session.add(book)
m.db.session.commit()
# book_dump = book_schema.dump(book)
return book
def test_Book_release(self):
b = models.Book(**self.bookParameters)
self.assertEqual(b.released, "1996-08-01T00:00:00")
def manual():
subtitle = "Upload using wildcards"
try:
form = WildcardForm(request.form)
except UnboundLocalError:
form = WildcardForm()
return render_template("wildcard.html", subtitle=subtitle, form=form)
if request.method == 'POST':
if form.validate():
if form.book_url.data in (None,
"") and form.book_pdf_url.data in (None,
""):
return render_template("wildcard.html",
subtitle=subtitle,
form=form)
if form.link_type.data == 'wildcard':
book_url = form.book_url.data if form.book_url.data not in (
None, "") else ""
from_no = html_escape(
form.from_no.data) if form.from_no.data not in (None,
"") else ""
to_no = html_escape(
form.to_no.data) if form.to_no.data not in (None,
"") else ""
info_url = re.sub('\(\*\)', str(from_no), book_url)
book_url = book_url + ":" + str(from_no) + "," + str(to_no)
book_url = book_url + ":" + 'wildcard'
elif form.link_type.data == 'pdf':
book_url = form.book_pdf_url.data if form.book_pdf_url.data not in (
None, "") else ""
info_url = book_url
book_url = book_url + ":" + 'pdf'
library = 'man'
Id = hashlib.md5(book_url).hexdigest()
email = html_escape(
form.email.data) if form.email.data not in (None, "") else ""
book = bridge.fields(library, book_url, email)
verification_status_no = book.verify_fields()
if verification_status_no != 0:
flash(error_msg(verification_status_no, book))
return render_template("wildcard.html",
subtitle=subtitle,
form=form)
tld = extract_base_domain(book_url)
book_metadata = dict(
image_url="",
thumbnail_url="",
printType="BOOK",
subtitle="",
infoLink=info_url,
publicDomain=True,
scanner=tld,
sponser=tld,
title=form.title.data if form.title.data not in (None,
"") else "",
author=form.author.data
if form.author.data not in (None, "") else "",
publisher=form.publisher.data
if form.publisher.data not in (None, "") else "",
publishedDate=form.date.data
if form.date.data not in (None, "") else "",
description=form.desc.data
if form.desc.data not in (None, "") else "",
language=form.language.data
if form.language.data not in (None, "") else "")
ia_identifier_suffix = get_valid_identifier_suffix(library, Id)
redis = redis_py.Redis()
redis_key3 = keys.redis_key3
redis_key1 = keys.redis_key1
book_key = "%s:%s:%s" % (redis_key3, library, ia_identifier_suffix)
metadata_key = book_key + ":meta_data"
redis_py.set(metadata_key, json.dumps(book_metadata), True)
book_request_key = book_key + ":requests"
request_details = dict(email=email)
redis_py.sadd(book_request_key,
json.dumps(request_details),
request_cache=True)
md5_book = hashlib.md5(ia_identifier_suffix + library).hexdigest()
meta_data = json.dumps(book_metadata)
book = models.Book(book_id=ia_identifier_suffix,
library=library,
requests=json.dumps(request_details),
meta_data=meta_data,
md5_book=md5_book)
db.session.add(book)
db.session.commit()
q_global_job = redis_py.Queue(redis_key1 + "global")
q_global_job.add(
json.dumps(dict(library=library,
book_id=ia_identifier_suffix)))
q = redis_py.Queue(redis_key1)
q.add(
json.dumps(
dict(library=library,
Id=book_url,
ia_identifier_suffix=ia_identifier_suffix)))
flash(error_msg(100, email=email))
return redirect(
url_for('progress',
book_id=library + ":" + ia_identifier_suffix))
else:
return render_template("wildcard.html",
subtitle=subtitle,
form=form)
else:
return render_template("wildcard.html", subtitle=subtitle, form=form)
def test_Book_media3(self):
b = models.Book(**self.bookParameters3)
self.assertEqual(b.mediaType, "Hardcover")
def test_Book_release3(self):
b = models.Book(**self.bookParameters3)
self.assertEqual(b.released, "2005-11-08T00:00:00")
def test_Book_toDict3(self):
instance = models.Book(**self.bookParameters3)
self.assertEqual(len(instance.toDict()), 12)
def test_Book_publisher3(self):
b = models.Book(**self.bookParameters3)
self.assertEqual(b.publisher, "Bantam Books")
def test_Book_name3(self):
b = models.Book(**self.bookParameters3)
self.assertEqual(b.name, "A Feast for Crows")
def test_Book_isbn3(self):
b = models.Book(**self.bookParameters3)
self.assertEqual(b.isbn, self.bookParameters3['isbn'])
def test_Book_numberOfPages3(self):
b = models.Book(**self.bookParameters3)
self.assertEqual(b.numberOfPages, 784)
def test_Book_release2(self):
b = models.Book(**self.bookParameters2)
self.assertEqual(b.released, "2000-10-31T00:00:00")
def test_Book_name2(self):
b = models.Book(**self.bookParameters2)
self.assertEqual(b.name, "A Storm of Swords")
def test_Book_numberOfPages2(self):
b = models.Book(**self.bookParameters2)
self.assertEqual(b.numberOfPages, 992)
def test_Book_name(self):
b = models.Book(**self.bookParameters)
self.assertEqual(b.name, "A Game of Thrones")
