def get_cates_infos(book_cate):
if is_string_validate(book_cate):
print("输入数据有错误")
resData = {
"resCode": 404, # 非0即错误 1
"data": [],# 数据位置，一般为数组
"message": '输入数据有错误'
}
return jsonify(resData)
if request.method == 'POST':
print("捕获到了post请求 book_cate", book_cate)
get_data = json.loads(request.get_data(as_text=True))
key = get_data['key']
print("key = ", key)
secretKey = get_data['secretKey']
if book_cate in BOOK_LIST:
print(key, " is in BOOK_LIST")
print(key, secretKey)
if key == 'newest':
# select * from book_infos where book_cate='xiuzhen' order by book_last_update_time desc limit 3
print("newest")
book = Book()
sql_data = book.get_cates_newst_books_30(book_cate)
resData = {
"resCode": 0, # 非0即错误 1
"data": sql_data,# 数据位置，一般为数组
"message": '最新的30本图书信息查询结果'
}
return jsonify(resData)
elif key == 'most':
print("most")
book = Book()
sql_data = book.get_cates_most_books_30(book_cate)
resData = {
"resCode": 0, # 非0即错误 1
"data": sql_data,# 数据位置，一般为数组
"message": '最新的30本图书信息查询结果'
}
return jsonify(resData)
else:
resData = {
"resCode": 2, # 非0即错误 1
"data": [],# 数据位置，一般为数组
"message": '参数有误'
}
return jsonify(resData)
else:
print("key is not BOOK_LIST")
return 404
else:
resData = {
"resCode": 1, # 非0即错误 1
"data": [],# 数据位置，一般为数组
"message": '请求方法错误'
}
return jsonify(resData)
def show_book_cates(book_cate):
# 判断请求是否合法
if book_cate in BOOK_LIST:
# print("请求合法")
pass
else:
# print("请求不合法")
abort(404)
# print("用这个去区分每个不同的域名给他不同的关键词和描述 ", request.path)
seo = {
"title": TITLES[request.path][0],
"keywords": TITLES[request.path][1],
"description": TITLES[request.path][2]
}
book = Book()
# 最新更新的30章内容
sql_newest_data = book.get_cates_newst_books_30(book_cate)
# 最多阅读的30张内容
sql_most_data = book.get_cates_most_books_30(book_cate)
return render_template("book_cate.html",
seo=seo,
books_cates=BOOK_CATES,
sql_newest_data=sql_newest_data,
sql_most_data=sql_most_data,
form=SearchForm())
def show_book_index(book_id):
book = Book()
# 获取图书信息
sql_book_infos = book.get_book_infos_by_book_id(book_id)
if len(sql_book_infos) == 0:
# 说明图书并不存在
abort(404)
cap_20_data = book.get_book_newest_20_caps_by_book_id(book_id)
all_cap_data = book.get_book_all_caps_by_book_id(book_id)
seo = {
"title": sql_book_infos[0]['book_name']+'('+sql_book_infos[0]['book_author']+")最新章节_"+ sql_book_infos[0]['book_name']+TITLES['bookindex'][0], # 大道朝天(猫腻)最新章节_大道朝天在线阅读 _笔趣阁
"keywords" : sql_book_infos[0]['book_name']+"最新章节列表,"+sql_book_infos[0]['book_name']+"无弹窗广告,"+sql_book_infos[0]['book_name']+"全文阅读,"+sql_book_infos[0]['book_author'],
# 大道朝天最新章节列表,大道朝天无弹窗广告,大道朝天全文阅读,猫腻
"description" : TITLES['bookindex'][2]+sql_book_infos[0]['book_author']+"大神最新作品《"+sql_book_infos[0]['book_name']+"》最新章节全文免费阅读，"+sql_book_infos[0]['book_name']+"全集，"+ \
sql_book_infos[0]['book_name']+"5200，"+sql_book_infos[0]['book_name']+"无弹窗！请关注"+sql_book_infos[0]['book_name']+"吧，明月书吧最新最快更新"+sql_book_infos[0]['book_name']+"最新章节。"
# 笔趣阁提供猫腻大神最新作品《大道朝天》最新章节全文免费阅读，大道朝天全集，大道朝天5200，大道朝天无弹窗！请关注大道朝天吧，本站最新最快更新大道朝天最新章节。
}
return render_template(
"book_index.html",
seo = seo,
books_cates = BOOK_CATES,
sql_book_infos = sql_book_infos,
cap_20_data = cap_20_data,
all_cap_data = all_cap_data,
form = SearchForm()
)
def search_infos():
if request.method == 'POST':
get_data = json.loads(request.get_data(as_text=True))
key = get_data['key']
secretKey = get_data['secretKey']
if is_string_validate(key):
resData = {
"resCode": 1, # 非0即错误 1
"data": [],# 数据位置，一般为数组
"message": '参数错误'
}
return jsonify(resData)
book = Book()
search_data = book.search_infos_by_key(key)
if len(search_data) == 0:
resData = {
"resCode": 0, # 非0即错误 1
"data": [],# 数据位置，一般为数组
"message": '数据为空'
}
return jsonify(resData)
resData = {
"resCode": 0, # 非0即错误 1
"data": search_data,# 数据位置，一般为数组
"message": '搜索结果'
}
return jsonify(resData)
else:
resData = {
"resCode": 1, # 非0即错误 1
"data": [],# 数据位置，一般为数组
"message": '请求方法错误'
}
return jsonify(resData)
def list_books(cursor, query, trace=False):
if trace:
print('Call MqSQL with:', query)
cursor.execute(search_query, (
query,
query,
))
results = cursor.fetchall()
if trace:
print(results)
# Nothing found
if len(results) == 0:
return None, []
# List of books
books = [
Book(isbn,
title,
authors,
image,
genre=genre,
language=language,
description=description) for isbn, title, authors, image, genre,
language, description, score in results
]
if trace:
print('%d book(s) found' % len(books))
return books
def get_book_infos_by_id(book_id):
if request.method == 'POST':
get_data = json.loads(request.get_data(as_text=True))
key = get_data['key']
secretKey = get_data['secretKey']
book = Book()
sql_data = book.get_book_infos_by_book_id(book_id)
if key == 'index':
resData = {
"resCode": 0, # 非0即错误 1
"data": sql_data,# 数据位置，一般为数组
"message": '图书的信息'
}
return jsonify(resData)
elif key == "cap20":
if len(sql_data) == 0:
resData = {
"resCode": 5, # 非0即错误 1
"data": [],# 数据位置，一般为数组
"message": '图书不存在'
}
return jsonify(resData)
cap_20_data = book.get_book_newest_20_caps_by_book_id(book_id)
resData = {
"resCode": 0, # 非0即错误 1
"data": cap_20_data,# 数据位置，一般为数组
"message": '最新的20章内容'
}
return jsonify(resData)
elif key == "all":
if len(sql_data) == 0:
resData = {
"resCode": 5, # 非0即错误 1
"data": [],# 数据位置，一般为数组
"message": '图书不存在'
}
return jsonify(resData)
all_cap_data = book.get_book_all_caps_by_book_id(book_id)
resData = {
"resCode": 0, # 非0即错误 1
"data": all_cap_data,# 数据位置，一般为数组
"message": '所有图书信息'
}
return jsonify(resData)
else:
resData = {
"resCode": 1, # 非0即错误 1
"data": [],# 数据位置，一般为数组
"message": '参数错误'
}
return jsonify(resData)
# book_infos
else:
resData = {
"resCode": 1, # 非0即错误 1
"data": [],# 数据位置，一般为数组
"message": '请求方法错误'
}
return jsonify(resData)
def test_process_books(self):
converters = [pipe_to_book, slash_to_book, csv_to_book]
file_parse_info = zip(get_input_files(), ["|", "/", ","], converters)
books = get_books_from_files(file_parse_info)
self.assertEquals(len(process_books(books, "", False, False)), 9)
books = get_books_from_files(file_parse_info)
self.assertEquals(process_books(books, None, False, False)[0],
Book("Kent", "Beck", "Implementation Patterns",
"2007"))
books = get_books_from_files(file_parse_info)
self.assertEquals(process_books(books, None, False, True)[-1],
Book("Kent", "Beck", "Implementation Patterns",
"2007"))
books = get_books_from_files(file_parse_info)
self.assertEquals(process_books(books, None, True, False)[0],
Book("Fred", "Brooks", "The Mythical Man-Month",
"1975"))
def bookForm_page():
form=bookForm()
if request.method =='POST':
if form.validate_on_submit():
book = Book(name=form.name.data,writer=form.writer.data, year_pub=form.year_pub.data,tpage=form.tpage.data,publisher=form.publisher.data,language=form.language.data,genre=form.genre.data)
book.addbook()
flash(f'{form.name.data} is created!', 'success')
return redirect(url_for('home'))
return render_template("addbook.html", form = form)
def search_infos():
if request.method == 'POST':
get_data = json.loads(request.get_data(as_text=True))
key = get_data['key']
secretKey = get_data['secretKey']
secret_result = get_secret_key(secretKey)
if secret_result['request_time'] == '':
# 如果这边返回的是空的，说明请求的数据已经被破坏了
resData = {
"resCode": 1, # 非0即错误 1
"data": [],# 数据位置，一般为数组
"message": '你猜，你使劲猜'
}
return jsonify(resData)
if is_allow_domain_time(secret_result['request_time'], secret_result['request_url']):
resData = {
"resCode": 1, # 非0即错误 1
"data": [],# 数据位置，一般为数组
"message": '你猜，你使劲猜'
}
return jsonify(resData)
if is_string_validate(key):
resData = {
"resCode": 1, # 非0即错误 1
"data": [],# 数据位置，一般为数组
"message": '参数错误'
}
return jsonify(resData)
book = Book()
search_data = book.search_infos_by_key(key)
if len(search_data) == 0:
resData = {
"resCode": 0, # 非0即错误 1
"data": [],# 数据位置，一般为数组
"message": '数据为空'
}
return jsonify(resData)
resData = {
"resCode": 0, # 非0即错误 1
"data": search_data,# 数据位置，一般为数组
"message": '搜索结果'
}
return jsonify(resData)
else:
resData = {
"resCode": 1, # 非0即错误 1
"data": [],# 数据位置，一般为数组
"message": '请求方法错误'
}
return jsonify(resData)
def find_book(cursor, words, trace=False):
# Only match by words longer than two letters
words = set([w for w in words if len(w) > 2])
if len(words) < 1:
return None, []
str_words = ' '.join(words)
if trace:
print('Call MqSQL with:', str_words)
cursor.execute(search_query, (
str_words,
str_words,
))
results = cursor.fetchall()
if trace:
print(results)
# Nothing found
if len(results) == 0:
return None, []
# Get top score and top results
max_score = results[0][7]
top_results = [r for r in results if r[7] == max_score]
# List of books with same top score
top_books = [
Book(isbn,
title,
authors,
image,
genre=genre,
language=language,
description=description) for isbn, title, authors, image, genre,
language, description, score in top_results
]
# Find the shortest book among the top ones
res_len = [len(r[1]) + len(r[2]) for r in top_results]
i = res_len.index(min(res_len))
book = top_books[i]
if trace:
print('%d book(s) found (%.2f)' % (len(top_books), max_score),
[b.title for b in top_books])
return book, top_books
def get_book_detail_infos(book_id, sort_id):
if request.method == 'POST':
book = Book()
sql_book_id_data = book.get_book_infos_by_book_id(book_id)
if len(sql_book_id_data) == 0:
# 不存在该图书
resData = {
"resCode": 1, # 非0即错误 1
"data": [],# 数据位置，一般为数组
"message": '不存在该图书信息'
}
return jsonify(resData)
# 该图书存在
# print("sql_book_id_data[0]['book_name'] = ", sql_book_id_data[0]['book_name'])
sql_detail_data = book.get_book_detail_by_book_id_sort_id(book_id, sort_id)
next_data = book.get_next_cap_id(book_id, sort_id)
print("in flask :next_data = ", next_data)
if next_data == None:
print("next_data == None")
sql_detail_data[0]['next_sort_id'] = ''
else:
print("next_data != None")
sql_detail_data[0]['next_sort_id'] = next_data['sort_id']
before_data = book.get_before_cap_id(book_id, sort_id)
if before_data == None:
sql_detail_data[0]['before_sort_id'] = ''
else:
sql_detail_data[0]['before_sort_id'] = before_data['sort_id']
sql_detail_data[0]['book_name'] = sql_book_id_data[0]['book_name']
resData = {
"resCode": 0, # 非0即错误 1
"data": sql_detail_data,# 数据位置，一般为数组
"message": '所有图书信息'
}
return jsonify(resData)
else:
resData = {
"resCode": 1, # 非0即错误 1
"data": [],# 数据位置，一般为数组
"message": '请求方法错误'
}
return jsonify(resData)
def open_book(self):
book_path = QFileDialog.getOpenFileName(self, u'打开Epub格式电子书', ".",
"(*.epub)")
print u"in open_book, book_name is:" + str(book_path)
print u"in open_book, bookdata path:" + str(LIBRARY_DIR)
print os.path.dirname(str(book_path))
if os.path.dirname(str(book_path)) + os.sep != str(LIBRARY_DIR):
shutil.copy(str(book_path), LIBRARY_DIR)
file_name = os.path.basename(str(book_path))
book_id = file_name.split('.epub')[0]
book = Book(book_id)
insert_library(book)
self.library.refresh()
def get_book_sql(cursor, isbn, tags=False, trace=False):
# Check if book with such ISBN exist
cursor.execute(select_query, (isbn, ))
results = cursor.fetchall()
if len(results) > 0:
book = Book(isbn, results[0][0], results[0][1], results[0][2], genre=results[0][3], \
language=results[0][4], description=results[0][5])
# Query tags for this book if requested
if tags:
cursor.execute(select_tags, (isbn, ))
results = cursor.fetchall()
book.tags = [r[0] for r in results]
return book
return None
def show_book_detail(book_id, sort_id):
book = Book()
sql_book_id_data = book.get_book_infos_by_book_id(book_id)
if len(sql_book_id_data) == 0:
abort(404)
# print("图书信息：------",sql_book_id_data)
book_name = sql_book_id_data[0]['book_name']
sql_detail_data = book.get_book_detail_by_book_id_sort_id(book_id, sort_id)
if len(sql_detail_data) == 0:
abort(404)
next_data = book.get_next_cap_id(book_id, sort_id)
if next_data == None:
next_sort_id = ''
else:
next_sort_id = next_data['sort_id']
before_data = book.get_before_cap_id(book_id, sort_id)
if before_data == None:
before_sort_id = ''
else:
before_sort_id = before_data['sort_id']
seo = {
"title":
sql_detail_data[0]['detail_title'] + '_' + book_name +
TITLES['bookdetail'][0],
# 第二十七章来了_大道朝天 - 笔趣阁
"keywords":
book_name + ',' + sql_book_id_data[0]['book_author'] + ',' +
sql_detail_data[0]['detail_title'],
# 大道朝天,猫腻,第二十七章来了
"description":
book_name + "无弹窗,是作者" + sql_book_id_data[0]['book_author'] +
"所著的好看的小说" + TITLES['bookdetail'][2]
# 大道朝天无弹窗,是作者猫腻所著的玄幻小说类小说，本站提供无弹窗阅读环境
}
return render_template("book_detail.html",
seo=seo,
books_cates=BOOK_CATES,
sql_detail_data=sql_detail_data,
next_sort_id=next_sort_id,
before_sort_id=before_sort_id,
book_name=book_name,
form=SearchForm())
def show_book_index(book_id):
book = Book()
# 获取图书信息
sql_book_infos = book.get_book_infos_by_book_id(book_id)
if len(sql_book_infos) == 0:
# 说明图书并不存在
abort(404)
cap_20_data = book.get_book_newest_20_caps_by_book_id(book_id)
all_cap_data = book.get_book_all_caps_by_book_id(book_id)
seo = {
"title": sql_book_infos[0]['book_name']+"无弹窗_"+sql_book_infos[0]['book_author']+"_"+sql_book_infos[0]['book_name']+"最新章节列表_明月书吧", # 大道朝天(猫腻)最新章节_大道朝天在线阅读 _笔趣阁
"keywords" : sql_book_infos[0]['book_name']+","+sql_book_infos[0]['book_name']+"无弹窗",
# 大道朝天最新章节列表,大道朝天无弹窗广告,大道朝天全文阅读,猫腻
"description" : TITLES['bookindex'][2]+sql_book_infos[0]['book_author']+"大神最新作品《"+sql_book_infos[0]['book_name']+"》最新章节全文免费阅读，"+sql_book_infos[0]['book_name']+"全集，"+ \
sql_book_infos[0]['book_name']+"5200，"+sql_book_infos[0]['book_name']+"无弹窗！请关注"+sql_book_infos[0]['book_name']+"吧，明月书吧最新最快更新"+sql_book_infos[0]['book_name']+"最新章节。"
# 笔趣阁提供猫腻大神最新作品《大道朝天》最新章节全文免费阅读，大道朝天全集，大道朝天5200，大道朝天无弹窗！请关注大道朝天吧，本站最新最快更新大道朝天最新章节。
}
BOOK_LIST_dict = {
'xuanhuan': "玄幻小说",
'xiuzhen': "修真小说",
'dushi': "都市小说",
'lishi': "历史小说",
'wangyou': "网游小说",
'kehuan': "科幻小说",
'yanqing': "言情小说",
'qita': "其他小说",
'quanben': "全本小说，完结小说"
}
sql_book_infos[0]["book_cate_china"] = BOOK_LIST_dict[
sql_book_infos[0].get("book_cate")]
print("我想要的数据========", sql_book_infos)
return render_template("book_index.html",
seo=seo,
books_cates=BOOK_CATES,
sql_book_infos=sql_book_infos,
cap_20_data=cap_20_data,
all_cap_data=all_cap_data,
form=SearchForm())
def hello_world():
book = Book()
arrData = book.get_books_infos_limit()
return jsonify(arrData)
return total_price * discount
def find_max_books_to_buy(books, money):
books_to_buy = []
price = 0
books = sorted(books, key=lambda book: book.price)
for book in books:
price += book.price
if price <= money:
books_to_buy.append(book)
else:
return books_to_buy
return books_to_buy
books = []
books.append(Book("Pragmatic Thinking and Learning", 30))
books.append(Book("Learn You a Haskell", 0))
books.append(Book("The Healthy Programmer", 50))
books.append(Book("Code Complete", 60))
books.append(Book("The Pragmatic Programmer", 20))
books.append(Book("Pro Git", 0))
books.append(Book("Introduction to Algorithms", 80))
books.append(Book("Concrete Mathematics", 100))
print_books(books)
print("The total price is: " + str(calculate_total_price(books)))
print("Books count: " + str(len(books)))
print_books(find_max_books_to_buy(books, 150))
def get_or_create(cls, queries, *args, **kwargs):
item = Book.get_by_queries(**queries)
if not item:
item = Book(*args, **kwargs)
item.save()
return item
from books import Book
class Student:
def __init__(self, name, address):
self.name = name
self.address = address
def getName(self):
return self.name
def getAddress(self):
return self.address
n = int(input("Enter number of students"))
student = []
for i in range(n):
x = input("Enter name: ")
y = input("Enter address: ")
stud = Student(x, y)
student.append(stud)
disp = map(lambda stud: stud.getName() + " " + stud.getAddress(), student)
print(list(disp))
book = Book(1, "sad", "me")
print(book.getAuthor())
# -*- coding: utf-8 -*-
from books import Book, Library
lib = Library(1, '51 Some str., NY')
try:
lib += Book('Leo Tolstoi', 'War and Peace')
lib += Book('Charles Dickens', 'David Copperfield')
lib += Book('Arthur Conan Doyle', 'The Lost World')
lib += Book('', 'Test empty book')
except ValueError as err:
print(err)
for book in lib:
print(book)
print(book.tag())
print('')
def get_book_detail_infos(book_id, sort_id):
if request.method == 'POST':
get_data = json.loads(request.get_data(as_text=True))
secretKey = get_data['secretKey']
secret_result = get_secret_key(secretKey)
if secret_result['request_time'] == '':
# 如果这边返回的是空的，说明请求的数据已经被破坏了
resData = {
"resCode": 1, # 非0即错误 1
"data": [],# 数据位置，一般为数组
"message": '你猜，你使劲猜'
}
return jsonify(resData)
if is_allow_domain_time(secret_result['request_time'], secret_result['request_url']):
resData = {
"resCode": 1, # 非0即错误 1
"data": [],# 数据位置，一般为数组
"message": '你猜，你使劲猜'
}
return jsonify(resData)
book = Book()
sql_book_id_data = book.get_book_infos_by_book_id(book_id)
if len(sql_book_id_data) == 0:
# 不存在该图书
resData = {
"resCode": 1, # 非0即错误 1
"data": [],# 数据位置，一般为数组
"message": '不存在该图书信息'
}
return jsonify(resData)
# 该图书存在
# print("sql_book_id_data[0]['book_name'] = ", sql_book_id_data[0]['book_name'])
sql_detail_data = book.get_book_detail_by_book_id_sort_id(book_id, sort_id)
next_data = book.get_next_cap_id(book_id, sort_id)
print("in flask :next_data = ", next_data)
if next_data == None:
print("next_data == None")
sql_detail_data[0]['next_sort_id'] = ''
else:
print("next_data != None")
sql_detail_data[0]['next_sort_id'] = next_data['sort_id']
before_data = book.get_before_cap_id(book_id, sort_id)
if before_data == None:
sql_detail_data[0]['before_sort_id'] = ''
else:
sql_detail_data[0]['before_sort_id'] = before_data['sort_id']
sql_detail_data[0]['book_name'] = sql_book_id_data[0]['book_name']
resData = {
"resCode": 0, # 非0即错误 1
"data": sql_detail_data,# 数据位置，一般为数组
"message": '所有图书信息'
}
return jsonify(resData)
else:
resData = {
"resCode": 1, # 非0即错误 1
"data": [],# 数据位置，一般为数组
"message": '请求方法错误'
}
return jsonify(resData)
def get_book_infos_by_id(book_id):
if request.method == 'POST':
get_data = json.loads(request.get_data(as_text=True))
key = get_data['key']
secretKey = get_data['secretKey']
secret_result = get_secret_key(secretKey)
if secret_result['request_time'] == '':
# 如果这边返回的是空的，说明请求的数据已经被破坏了
resData = {
"resCode": 1, # 非0即错误 1
"data": [],# 数据位置，一般为数组
"message": '你猜，你使劲猜'
}
return jsonify(resData)
if is_allow_domain_time(secret_result['request_time'], secret_result['request_url']):
resData = {
"resCode": 1, # 非0即错误 1
"data": [],# 数据位置，一般为数组
"message": '你猜，你使劲猜'
}
return jsonify(resData)
book = Book()
sql_data = book.get_book_infos_by_book_id(book_id)
if key == 'index':
resData = {
"resCode": 0, # 非0即错误 1
"data": sql_data,# 数据位置，一般为数组
"message": '图书的信息'
}
return jsonify(resData)
elif key == "cap20":
if len(sql_data) == 0:
resData = {
"resCode": 5, # 非0即错误 1
"data": [],# 数据位置，一般为数组
"message": '图书不存在'
}
return jsonify(resData)
cap_20_data = book.get_book_newest_20_caps_by_book_id(book_id)
resData = {
"resCode": 0, # 非0即错误 1
"data": cap_20_data,# 数据位置，一般为数组
"message": '最新的20章内容'
}
return jsonify(resData)
elif key == "all":
if len(sql_data) == 0:
resData = {
"resCode": 5, # 非0即错误 1
"data": [],# 数据位置，一般为数组
"message": '图书不存在'
}
return jsonify(resData)
all_cap_data = book.get_book_all_caps_by_book_id(book_id)
resData = {
"resCode": 0, # 非0即错误 1
"data": all_cap_data,# 数据位置，一般为数组
"message": '所有图书信息'
}
return jsonify(resData)
else:
resData = {
"resCode": 1, # 非0即错误 1
"data": [],# 数据位置，一般为数组
"message": '参数错误'
}
return jsonify(resData)
# book_infos
else:
resData = {
"resCode": 1, # 非0即错误 1
"data": [],# 数据位置，一般为数组
"message": '请求方法错误'
}
return jsonify(resData)
def load_book(self, book_id):
self.book = Book(book_id)
self.chapter_list.clear()
for chapter in self.book.chapters:
self.chapter_list.addItem(chapter[0])
self.chapter_list.setCurrentRow(0)
def add_book(self):
book = Book()
book.create_book(self.create_id)
self.create_id += 1
self.library.append(book)
def hello_world():
book = Book()
res = book.get_books_infos_limit()
return 'hello world ! \n {}'.format(res)
# pip install pillow
from PIL import Image
from PIL import ImageTk
from books import Book
books = []
with open('books.txt', 'r') as file:
lines = file.read().splitlines()
for n in range(0, len(lines), 5):
rf = lines[n]
title = lines[n + 1]
author = lines[n + 2]
description = lines[n + 3]
image_link = lines[n + 4]
books.append(Book(rf, title, author, description, image_link))
def search_book(rfid):
global books
for book in books:
if book.rfid == rfid:
return book
return None
bauld = 115200
for port in list_ports.comports():
print(port)
from books import Book
from users import Users
from manage_books import Manage
book = Book()
users = Users()
manage = Manage()
def menu():
get_username = input("Enter your username: "******"Enter your password: "******"\n----------------------------------------\n")
user_input = input("1.) Borrow Books\n"
"2.) Return Books\n"
"3.) See Current Available books\n"
"4.) See Current books you need to return\n"
"5.) Book Details\n"
"6.) Add Book (Require staff access)\n"
"7.) Delete Book (Require staff access)\n"
"8.) Modify Book (Require staff access)\n"
"9.) Quit\n"
"Your answer (enter the number): ")
# Option 1, Borrow
if user_input == '1':
print(
manage.borrow_book(
book=input("What book would you like to borrow: ")))
def index():
if request.method == 'POST':
print("我接到了post请求")
form = SearchForm()
if form.validate_on_submit():
keyword = form.keyword.data
else:
abort(404)
print("keyword = ", keyword)
if is_string_validate(keyword):
print("输入有误，请确认后重新输入")
messages = "输入有误，请确认后重新输入"
search_data = ""
seo = {
"title": "搜索结果页面",
"keywords": "首页关键词",
"description": "首页描述"
}
return render_template("search.html",
seo=seo,
books_cates=BOOK_CATES,
form=SearchForm(),
messages=messages,
search_data=search_data)
book = Book()
search_data = book.search_infos_by_key(keyword)
if len(search_data) == 0:
print("没有获得结果")
messages = ""
search_data = ""
seo = {
"title": "搜索结果页面",
"keywords": "首页关键词",
"description": "首页描述"
}
return render_template("search.html",
seo=seo,
books_cates=BOOK_CATES,
form=SearchForm(),
messages=messages,
search_data=search_data)
else:
print("有获得结果")
messages = ""
seo = {
"title": "搜索结果页面",
"keywords": "首页关键词",
"description": "首页描述"
}
return render_template("search.html",
seo=seo,
books_cates=BOOK_CATES,
form=SearchForm(),
messages=messages,
search_data=search_data)
book = Book()
xuanhuan_data = book.get_xuanhuan_top5()
xiuzhen_data = book.get_xiuzhen_top5()
dushi_data = book.get_dushi_top5()
lishi_data = book.get_lishi_top5()
wangyou_data = book.get_wangyou_top5()
kehuan_data = book.get_kehuan_top5()
yanqing_data = book.get_yanqing_top5()
quanben_data = book.get_quanben_top5()
# print("用这个去区分每个不同的域名给他不同的关键词和描述 ------------------------>", request.path)
seo = {
"title": TITLES[request.path][0],
"keywords": TITLES[request.path][1],
"description": TITLES[request.path][2]
}
return render_template("index.html",
seo=seo,
books_cates=BOOK_CATES,
form=SearchForm(),
xuanhuan_data=xuanhuan_data,
xiuzhen_data=xiuzhen_data,
dushi_data=dushi_data,
lishi_data=lishi_data,
wangyou_data=wangyou_data,
kehuan_data=kehuan_data,
yanqing_data=yanqing_data,
quanben_data=quanben_data)