def book_list(request):
keyword = request.GET.get("keyword")
path = request.path_info
"""童书列表"""
if keyword:
obj_all = models.Book.objects.filter(name__contains=keyword)
else:
obj_all = models.Book.objects.order_by("created_time").reverse()
# 计算售价和会员价
# for obj in obj_all:
# obj.cal_price()
# obj.save()
# 分页处理
total_count = obj_all.count()
page_num = request.GET.get("page")
page_obj = Page(path,
page_num,
total_count,
request.GET,
per_page=10,
page_max=11)
obj_show = obj_all[page_obj.start:page_obj.end]
page_html = page_obj.page_html()
return render(request, "book_list.html", {
"book_list": obj_show,
"page_html": page_html
})
def search(request):
keyword = request.GET.get('keyword', None)
if not keyword:
return redirect('/blog/')
entries = models.Entry.objects.filter(
Q(title__icontains=keyword)
| Q(body__icontains=keyword)
| Q(abstract__icontains=keyword))
if entries:
total_count = entries.count()
page_num = request.GET.get('page', 1)
url_prefix = "/blog/search/?keyword={}".format(keyword)
page_obj = Page(page_num=page_num,
total_count=total_count,
per_page=10,
url_prefix=url_prefix,
max_page=5)
entries = entries[page_obj.start:page_obj.end]
page_html = page_obj.page_html()
return render(request, 'blog/index.html', locals())
else:
error_msg = '没有与此关键词匹配的文章'
return render(request, 'blog/index.html', {
'error_msg': error_msg,
})
def index(request):
page_num = request.GET.get("page")
article_count = models.Article.objects.all().count()
page_obj=Page(page_num, article_count, per_page=10, url_prefix="/index/", max_page=11,)
article_list=models.Article.objects.all().order_by("nid").reverse()[page_obj.start:page_obj.end]
page_html=page_obj.page_html()
return render(request,"index.html",{"article_list":article_list,"page_html":page_html})
def stock_list(request):
keyword = request.GET.get("keyword")
path = request.path_info
"""库存列表"""
if keyword and keyword.strip():
if keyword[0:5].isdigit():
obj_all = models.Stock.objects.filter(ISBN=keyword.strip())
else:
obj_all = models.Stock.objects.filter(
book__name__contains=keyword.strip())
else:
obj_all = models.Stock.objects.order_by("created_time").reverse()
# 分页处理
total_count = obj_all.count()
page_num = request.GET.get("page")
page_obj = Page(path,
page_num,
total_count,
request.GET,
per_page=10,
page_max=11)
obj_show = obj_all[page_obj.start:page_obj.end]
page_html = page_obj.page_html()
return render(request, "stock_list.html", {
"stock_list": obj_show,
"page_html": page_html
})
def purchase_detail(request):
batch_id = request.GET.get("batch_id")
batch_obj = models.PurchaseBatch.objects.get(id=batch_id)
obj_all = models.PurchaseDetail.objects.filter(batch_id=batch_id).values(
"ISBN", "batch_id", "book__name", "book__is_package", "package_id",
"price_sale", "price_paid", "is_sold",
"memo").annotate(quantity=Count("batch_id"),
created_time=Min("created_time"),
id=Min("id")).order_by("created_time").reverse()
total_count = obj_all.count()
page_num = request.GET.get("page")
page_obj = Page("/purchase_detail/",
page_num,
total_count,
request.GET,
per_page=10,
page_max=11)
obj_show = obj_all[page_obj.start:page_obj.end]
page_html = page_obj.page_html()
return render(request, "purchase_detail.html", {
"purchase_list": obj_show,
"batch_obj": batch_obj,
"page_html": page_html
})
def listen_list(request):
"""价格比对列表"""
# sign标记是否允许更新：如果上次更新时间在12个小时之前，则允许更新sign=1
now = datetime.datetime.now()
if models.CurrentPrice.objects.exists():
cur_time = models.CurrentPrice.objects.values(
"created_time").all()[0]["created_time"]
else:
cur_time = now
sign = 0 if cur_time.date() == now.date(
) and (now - cur_time).seconds / 3600 < 12 else 1
obj_all = models.CurrentPrice.objects.order_by(
"final_discount") # 不能对decimal字段过滤？
# 分页处理
total_count = obj_all.count()
page_num = request.GET.get("page")
page_obj = Page("/listen_list/",
page_num,
total_count,
request.GET,
per_page=10,
page_max=11)
obj_show = obj_all[page_obj.start:page_obj.end]
page_html = page_obj.page_html()
return render(request, "listen_list.html", {
"listen_list": obj_show,
"page_html": page_html,
"sign": sign
})
def admin_other(request):
page_num = request.GET.get("page")
print(page_num, type(page_num))
# 总数据是多少
total_count = models.otherAccount.objects.all().count()
# print(total_count)
from utils.mypage import Page
page_obj = Page(
page_num,
total_count,
per_page=10,
url_prefix="/adminOther/",
max_page=9,
)
ret = models.otherAccount.objects.all().order_by(
"-day_other", "-id")[page_obj.start:page_obj.end]
page_html = page_obj.page_html()
return render(request, "admin_otherlist.html", {
"other_list": ret,
"page_html": page_html
})
def admin_bath(request):
page_num = request.GET.get("page")
print(page_num, type(page_num))
# 总数据是多少
total_count = models.bathAccount.objects.all().count()
# print(total_count)
from utils.mypage import Page
page_obj = Page(
page_num,
total_count,
per_page=10,
url_prefix="/admin_bath/",
max_page=9,
)
# print("bath:",page_obj.end)
ret = models.bathAccount.objects.all().order_by(
"-day_bath", "-id")[page_obj.start:page_obj.end]
# print("ret:",ret)
page_html = page_obj.page_html()
# ret = models.bathAccount.objects.all().order_by("id")
return render(request, "admin_bathlist.html", {
"bath_list": ret,
"page_html": page_html
})
def home(request,username,*args):
logger.debug("home视图获取到用户名:{}".format(username))
user=models.UserInfo.objects.filter(username=username).first()
if not user:
logger.warning("又有人访问不存在页面了")
return HttpResponse("404")
page_num = request.GET.get("page")
#如果用户存则需要将TA写的所有文章找出来
blog=user.blog
#我的文章列表
if not args:
logger.debug("args没有接收到参数，默认走的是用户的个人博客页面")
article_count = models.Article.objects.filter(user=user).count()
article_list=models.Article.objects.filter(user=user).order_by("nid").reverse()
else:
logger.debug(args)
logger.debug("----------------")
#表示按照文章的分类或tag或日期归档查询
if args[0]=="category":
article_count = models.Article.objects.filter(user=user).filter(category__title=args[1]).count()
article_list=models.Article.objects.filter(user=user).filter(category__title=args[1]).order_by("nid").reverse()
elif args[0]=="tag":
article_count = models.Article.objects.filter(user=user).filter(tag__title=args[1]).count()
article_list = models.Article.objects.filter(user=user).filter(tag__title=args[1]).order_by("nid").reverse()
else:
try:
year,month=args[1].split("-")
logger.debug("分割得到参数year:{},month:{}".format(year,month))
logger.debug("*******")
article_count = models.Article.objects.filter(user=user).filter(
create_time__year=year, create_time__month=month
).count()
article_list=models.Article.objects.filter(user=user).filter(
create_time__year=year,create_time__month=month
).order_by("nid").reverse()
except Exception as e:
logger.warning("请求访问的日志归档柜式不正确!!!")
logger.warning(str(e))
return HttpResponse("404")
page_obj = Page(page_num, article_count, per_page=10, url_prefix="/blog/"+request.user.username, max_page=11, )
article_list = article_list[page_obj.start:page_obj.end]
print(article_list)
page_html=page_obj.page_html()
return render(request,"home.html",{
"username":username,
"blog":blog,
"article_list":article_list,
"page_html":page_html,
})
def author(request):
# 获取当前页码
page_num = request.GET.get("page")
# 总数据
total_cont = models.Author.objects.all().count()
from utils.mypage import Page
page_obj = Page(page_num, total_cont, request.GET, url="/author/", per_page=21, max_page=7)
ret = models.Author.objects.all()[page_obj.start:page_obj.end]
page_html = page_obj.page_html()
return render(request, "author_list.html", {"author": ret, "page_html": page_html})
def books(request):
# 获取当前页码
page_num = request.GET.get("page")
# 总数据
total_cont = models.Book.objects.all().count()
from utils.mypage import Page
page_obj = Page(page_num, total_cont, request.GET, url="/books/", per_page=10, max_page=11)
ret = models.Book.objects.all()[page_obj.start:page_obj.end]
page_html = page_obj.page_html()
return render(request, "book_list.html", {"book_obj": ret, "page_html": page_html})
def home(request):
article_list = models.Article.objects.all()
base_url = request.path_info
total_count = article_list.count()
page_obj = Page(request.GET.get("page"),
total_count,
url_prefix=base_url,
per_page=3)
article_list = article_list[page_obj.start:page_obj.end]
page_html = page_obj.page_html()
return render(request, "index.html", {
"article_list": article_list,
"page_html": page_html
}) #用于显示页码
def books(request):
try:
page = int(request.GET.get("page"))
except Exception as e:
page = 1
# 获取书籍的总数
total_count = models.Boook.objects.all().count()
#
# # 计算可分的页数，每页最多10本书籍
# page_book_num = 10
# page_num, other = divmod(total_book, page_book_num)
# if other:
# page_num += 1
# if page > page_num:
# page = page_num
# # print(page_num, other)
# start_page = (page - 1) * 10
# end_page = page * 10
# # 当前页最大展示页
# max_page = 9
# if page_num < max_page:
# max_page = page_num
# half_page_num = max_page // 2
# # print(half_page_num)
# if page - half_page_num <= 1:
# page_start = 1
# page_end = max_page
# elif page + half_page_num > page_num:
# page_end = page_num
# page_start = page_num - max_page + 1
# else:
# # 计算分页，用于切片
# page_start = page - half_page_num
# page_end = page + half_page_num
# page_list = [i for i in range(page_start, page_end + 1)]
# print(page_list)
# 查询所有书籍
page_obj = Page(page, total_count, url_prefix="/books/")
all_book = models.Boook.objects.all()[page_obj.start:page_obj.end]
print(all_book)
page_html = page_obj.page_html()
# return render(request, "books.html", {"all_book": all_book, "page_list": page_list, "page_total": page_num,
# "page_now": page})
return render(request, "books.html", {
"books": all_book,
"page_html": page_html
})
def publisher_list(request):
# 去数据库查出所有的出版社,填充到HTML中,给用户返回
#ret = models.Publisher.objects.all().order_by("id")
#return render(request, "publisher_list.html", {"publisher_list": ret})
page_num = request.GET.get("page")
print(page_num, type(page_num))
# 总数据是多少
total_count = models.Publisher.objects.all().count()
page_obj = Page(page_num, total_count, per_page=10, url_prefix="/publisher_list/", max_page=9,)
all_publisher = models.Publisher.objects.all()[page_obj.start:page_obj.end]
page_html = page_obj.page_html()
return render(request, "publisher_list.html", {"publisher_list": all_publisher, "page_html": page_html})
def books(request):
from utils.mypage import Page
p = request.GET.get('page')
books = models.Book.objects.all()
total_count = books.count()
my_page = Page(p, total_count, 'books', per_page=20, max_page=10)
my_data_start = my_page.data_start
my_data_end = my_page.data_end
my_page_html = my_page.page_html()
current_page_books = books[my_data_start:my_data_end]
return render(request, 'books.html', {
'books': current_page_books,
'total_page': my_page_html
})
def depts(request):
# 从URL中取参数
page_num = request.GET.get("page")
# 总数据是多少
total_count = models.Dept.objects.all().count()
from utils.mypage import Page
page_obj = Page(page_num,
total_count,
per_page=10,
url_prefix="/depts/",
max_page=11)
ret = models.Dept.objects.all()[page_obj.start:page_obj.end]
page_html = page_obj.page_html()
return render(request, "dept.html", {"depts": ret, "page_html": page_html})
def book_list(request):
# 去数据库中查询所有的书籍
#all_book = models.Book.objects.all()
# 在HTML页面完成字符串替换(渲染数据)
#return render(request, "book_list.html", {"all_book": all_book})
# 从URL取参数
page_num = request.GET.get("page")
#print(page_num, type(page_num))
# 总数据是多少
total_count = models.Book.objects.all().count()
page_obj = Page(page_num, total_count, per_page=10, url_prefix="/book_list/", max_page=9,)
all_book = models.Book.objects.all()[page_obj.start:page_obj.end]
page_html = page_obj.page_html()
return render(request, "book_list.html", {"all_book": all_book, "page_html": page_html})
def order_list(request):
obj_all = models.Order.objects.all().order_by("id").reverse()
# 分页处理
total_count = obj_all.count()
page_num = request.GET.get("page")
page_obj = Page("/order_list/",
page_num,
total_count,
request.GET,
per_page=10,
page_max=11)
obj_show = obj_all[page_obj.start:page_obj.end]
page_html = page_obj.page_html()
return render(request, "order_list.html", {
"order_list": obj_show,
"page_html": page_html
})
def purchase_batch(request):
"""采购批次列表"""
obj_all = models.PurchaseBatch.objects.all().order_by(
"created_time").reverse()
total_count = obj_all.count()
page_num = request.GET.get("page")
page_obj = Page("/purchase_batch/",
page_num,
total_count,
per_page=10,
page_max=11)
obj_show = obj_all[page_obj.start:page_obj.end]
page_html = page_obj.page_html()
return render(request, "purchase_batch.html", {
"batch_list": obj_show,
"page_html": page_html
})
def depts(request):
page_num = request.GET.get("page")
print(page_num, type(page_num))
total_count = models.Dept.objects.all().count()
page_obj = Page(
page_num,
total_count,
per_page=10,
url_prefix="/depts/",
max_page=11,
)
print(page_obj.start, page_obj.end)
ret = models.Dept.objects.all().order_by("id")[page_obj.start:page_obj.end]
print(ret)
page_html = page_obj.page_html()
return render(request, "depts.html", {
"depts": ret,
"page_html": page_html
})
def book_list(request):
# 从URL取参数
page_num = request.GET.get("page")
# 总数据是多少
total_count = models.Book.objects.all().count()
page_obj = Page(
page_num,
total_count,
per_page=10,
url_prefix="book_list",
max_page=11,
)
ret = models.Book.objects.all()[page_obj.start:page_obj.end]
page_html = page_obj.page_html()
# ret = models.Book.objects.all().order_by('id')
return render(request, 'book_list.html', {
'book_list': ret,
'page_html': page_html
})
def archives(request, year, month):
entries = models.Entry.objects.filter(created_time__year=year,
created_time__month=month)
if entries:
entries_count = entries.count()
page = request.GET.get('page', 1)
url_prefix = "/blog/archives/{0}/{1}/?".format(year, month)
page_obj = Page(page_num=page,
total_count=entries_count,
per_page=10,
url_prefix=url_prefix,
max_page=5)
entries = entries[page_obj.start:page_obj.end]
page_html = page_obj.page_html()
return render(request, 'blog/index.html', locals())
else:
return render(request, 'blog/404.html', locals())
def author_list(request):
# author_obj = models.Author.objects.get(id=1)
# print(author_obj.book.all())
# print("=" * 120)
# 查询所有的作者
#all_author = models.Author.objects.all()
#return render(request, "author_list.html", {"author_list": all_author})
page_num = request.GET.get("page")
print(page_num, type(page_num))
# 总数据是多少
total_count = models.Author.objects.all().count()
page_obj = Page(page_num, total_count, per_page=10, url_prefix="/author_list/", max_page=9,)
all_author = models.Author.objects.all()[page_obj.start:page_obj.end]
page_html = page_obj.page_html()
return render(request, "author_list.html", {"author_list": all_author, "page_html": page_html})
def index(request):
entries = models.Entry.objects.all()
if entries:
entries_count = entries.count()
page_num = request.GET.get('page', 1)
url_prefix = "/blog/?"
page_obj = Page(page_num=page_num,
total_count=entries_count,
per_page=10,
url_prefix=url_prefix,
max_page=5)
entries = entries[page_obj.start:page_obj.end]
page_html = page_obj.page_html()
return render(request, 'blog/index.html', locals())
else:
error_msg = '暂无文章'
return render(request, 'blog/index.html', {
'error_msg': error_msg,
})
def category(request, category_id):
c = get_object_or_404(models.Category, id=category_id)
entries = models.Entry.objects.filter(category=c)
if entries:
entries_count = entries.count()
page = request.GET.get('page', 1)
url_prefix = "/blog/category/{}/?".format(category_id)
page_obj = Page(page_num=page,
total_count=entries_count,
per_page=10,
url_prefix=url_prefix,
max_page=5)
entries = entries[page_obj.start:page_obj.end]
page_html = page_obj.page_html()
return render(request, 'blog/index.html', locals())
else:
error_msg = '该分类下暂无文章'
return render(request, 'blog/index.html', {
'error_msg': error_msg,
})
def tag(request, tag_id):
tag = get_object_or_404(models.Tag, id=tag_id)
entries = models.Entry.objects.filter(tags=tag)
if entries:
entries_count = entries.count()
page = request.GET.get('page', 1)
url_prefix = "/blog/tag/{}/?".format(tag_id)
page_obj = Page(page_num=page,
total_count=entries_count,
per_page=10,
url_prefix=url_prefix,
max_page=5)
entries = entries[page_obj.start:page_obj.end]
page_html = page_obj.page_html()
return render(request, 'blog/index.html', locals())
else:
error_msg = '此标签下暂无文章'
return render(request, 'blog/index.html', {
'error_msg': error_msg,
})
def member_list(request):
"""会员列表"""
obj_all = models.MemberState.objects.all()
# 每次请求时更新state
for obj in obj_all:
state_old = obj.state
state_new = obj.state_set()
if state_old == state_new:
break
else:
obj.save()
# 搜索列表
keyword = request.GET.get("keyword")
path = request.path_info
if keyword and keyword.strip():
if keyword[0:4].isdigit():
obj_all = models.MemberState.objects.filter(
member__phone__contains=keyword.strip())
# 分页处理
total_count = obj_all.count()
page_num = request.GET.get("page")
page_obj = Page(path,
page_num,
total_count,
request.GET,
per_page=10,
page_max=11)
obj_show = obj_all[page_obj.start:page_obj.end]
page_html = page_obj.page_html()
return render(request, "member_list.html", {
"member_list": obj_show,
"page_html": page_html
})
def borrow_record(request):
"""借阅记录"""
# 获取全部待还的书籍 和 最近归还的书籍，按更新时间倒序
yesterday = datetime.datetime.now() - datetime.timedelta(hours=6)
obj_all = models.BorrowRecord.objects.filter(
Q(return_time__isnull=True)
| Q(return_time__gt=yesterday)).order_by("update_time").reverse()
# 处理还书请求，筛选对应书籍的待还借阅记录并返回，以完成还书操作
if request.method == "POST":
bid_list = []
for i in range(1, 6):
book_id = request.POST.get("ISBN%s" % i)
if book_id:
bid_list.append(book_id)
else:
break
obj_all = models.BorrowRecord.objects.filter(
book_id__in=bid_list,
return_time__isnull=True).order_by("created_time").reverse()
# 分页处理
total_count = obj_all.count()
page_num = request.GET.get("page")
page_obj = Page("/borrow_record/",
page_num,
total_count,
request.GET,
per_page=10,
page_max=11)
obj_show = obj_all[page_obj.start:page_obj.end]
page_html = page_obj.page_html()
return render(request, "borrow_record.html", {
"record_list": obj_show,
"page_html": page_html
})
def index(request):
#查询所有的文章列表
# article_list = models.Article.objects.all()
# 从URL去参数
page_num = request.GET.get("page")
# 总数据是多少
total_count = models.Article.objects.all().count()
"""
#从URL去参数
page_num = request.GET.get("page")
#每一页显示多少条数据
per_page = 10
#总页码数是多少
total_count = models.Book.objects.all().count()
#总共需要多少页码展示
# total_count // per_page
total_page, m = divmod(total_count,per_page)
if m:
total_page += 1
# 如果出现一个不正常的页码就默认为1
try:
page_num = int(page_num)
# 如果超过当前页码数 则为最当前
if page_num > total_page:
page_num = total_page
except Exception as e:
# 当输入一个页码不是正经数字的时候,默认返回第一页数据
page_num = 1
# 页面上总共展示多少页码
max_page = 11
if total_page < max_page:
max_page = total_page
data_start = (page_num - 1) * 10
data_end = page_num * 10
half_max_page = max_page // 2
#页面上展示的页码从哪儿开始
page_start = page_num - half_max_page
#页面上展示的页码到哪儿结束
page_end = page_num + half_max_page
#如果当前页减一半比1还小
if page_start <=1 :
page_start = 1
page_end = max_page
#如果当前页加一半比总页码数还大
if page_end >= total_page:
page_end = total_page
page_start = total_page - max_page + 1
all_book = models.Book.objects.all()[data_start:data_end]
# 自己拼接分页的HTML代码
html_str_list = []
#加上第一页
html_str_list.append('<li><a href="/books/?page=1">首页</a></li>')
#加上一个上一页的标签
if page_num <=1:
page_num = 1
html_str_list.append('<li class="disabled"><a href="#"><span aria-hidden="true">«</span></a></li>')
else:
html_str_list.append('<li><a href="/books/?page={}"><span aria-hidden="true">«</span></a></li>'.format(page_num-1))
for i in range(page_start,page_end+1):
# 如果是当前页就加一个active样式
if i == page_num:
tmp = '<li class="active"><a href="/books/?page={0}">{0}</a></li>'.format(i)
else:
tmp = '<li><a href="/books/?page={0}">{0}</a></li>'.format(i)
html_str_list.append(tmp)
# 加上一个下一页的标签
if page_num >= total_page :
html_str_list.append('<li class="disabled"><a href=""><span aria-hidden="true">»</span></a></li>')
else:
html_str_list.append('<li><a href="/books/?page={}"><span aria-hidden="true">»</span></a></li>'.format(page_num+1))
#加上最后一页
html_str_list.append('<li><a href="/books/?page={}">尾页</a></li>'.format(total_page))
page_html = "".join(html_str_list)
return render(request,"books.html",{"books": all_book, "page_html": page_html})
"""
from utils.mypage import Page
page_obj = Page(page_num,
total_count,
url_prefix="/index/",
per_page=5,
max_page=7)
ret = models.Article.objects.all()[page_obj.start:page_obj.end]
page_html = page_obj.page_html()
return render(request, "index.html", {
"article_list": ret,
"page_html": page_html
})
def books(request):
# 从URL取参数
page_num = request.GET.get("page")
# 总数据是多少
total_count = models.Book.objects.all().count()
# # 每一页显示多少条数据
# per_page = 10
#
# # 总共需要多少页码来展示
# total_page, m = divmod(total_count, per_page)
# if m:
# total_page += 1
#
# try:
# page_num = int(page_num)
# # 如果输入的页码超过了最大的页码数，默认返回最后一页
# if page_num > total_page:
# page_num = total_page
# except Exception as e:
# # 当输入的页码不是数字的时候，默认返回第一页的数据
# page_num = 1
#
# # 定义两个变量保存数据从哪取到哪
# data_start = (page_num - 1) * 10
# data_end = page_num * 10
#
# # 页面上总共展示多少页码
# max_page = 11
# if total_page < max_page:
# max_page = total_page
#
# half_max_page = max_page // 2
# # 页面上展示的页码从哪开始
# page_start = page_num - half_max_page
# # 页面上展示的页码到哪结束
# page_end = page_num + half_max_page
#
# # 如果当前页减一半 比1小
# if page_start <= 1:
# page_start = 1
# page_end = max_page
#
# # 如果当前页加一半 比总页码数还大
# if page_end >= total_page:
# page_end = total_page
# page_start = total_page - max_page + 1
#
# all_book = models.Book.objects.all()[data_start: data_end]
#
# # 拼接分页的html代码
# html_str_list = []
# # 加上第一页
# html_str_list.append('<li><a href="/books/?page=1">首页</a></li>')
#
# # 加上一页，上一页就是当前页减一
# # 判断，如果第一页，就没有上一页
# if page_num <= 1:
# html_str_list.append('<li class="disabled"><a href="#"><span aria-hidden="true">«</span></a></li>')
# else:
# html_str_list.append(
# '<li><a href="/books/?page={}"><span aria-hidden="true">«</span></a></li>'.format(page_num - 1))
#
# for i in range(page_start, page_end + 1):
# # 如果是当前页，加一个active样式类
# if i == page_num:
# tmp = '<li class="active"><a href="/books/?page={0}">{0}</a></li>'.format(i)
# else:
# tmp = '<li><a href="/books/?page={0}">{0}</a></li>'.format(i)
# html_str_list.append(tmp)
#
# # 加下一页，下一页就是当前页加一
# # 判断，如果是最后一页，就没有下一页
# if page_num >= total_page:
# html_str_list.append('<li class="disabled"><a href="#"><span aria-hidden="true">»</span></a></li>')
# else:
# html_str_list.append(
# '<li><a href="/books/?page={}"><span aria-hidden="true">»</span></a></li>'.format(page_num + 1))
#
# # 加最后一页
# html_str_list.append('<li><a href="/books/?page={}">尾页</a></li>'.format(total_page))
#
# page_html = "".join(html_str_list)
# 调用一个类
from utils.mypage import Page
page_obj = Page(page_num,
total_count,
per_page=10,
url_prefix="/books/",
max_page=11)
ret = models.Book.objects.all()[page_obj.start:page_obj.end]
page_html = page_obj.page_html()
return render(request, "books.html", {
"books": ret,
"page_html": page_html
})
