def page_handler(request, surfix, article_id):
p = request.GET.get('p')
try:
article = ArticleInfo.objects.get(id=article_id)
except ArticleInfo.DoesNotExist:
return JsonResponse({'error': '文章不存在'})
comment_count = CommentInfo.objects.filter(article=article).count()
page = pagination.Pagination(p, comment_count, per_page_count=5)
comment_list = CommentInfo.objects.filter(article=article). \
select_related('comment_parent').order_by('time')[page.start:page.end]
comment_list = list(comment_list)
res = []
for obj in comment_list:
if obj.comment_parent:
comment_parent_username = obj.comment_parent.user.username
else:
comment_parent_username = None
tmp = {
'id': obj.id,
'time': obj.time.strftime('%Y年-%m月-%d日 %H:%M'),
'username': obj.user.username,
'detail': obj.detail,
'comment_parent_username': comment_parent_username,
}
res.append(tmp)
return JsonResponse(res, safe=False)
def user_list(request):
page = pagination.Pagination(request, len(users), per_num=13, max_show=8)
return render(request, 'user_list.html', {
"data": users[page.start:page.end],
'html_str': page.show_li
})
async def questions_solved(request):
"""
Solved questions
"""
page_query = pagination.get_page_number(url=request.url)
count = await Question.filter(accepted_answer=True).count()
paginator = pagination.Pagination(page_query, count)
results = (
await Question.filter(accepted_answer=True)
.prefetch_related("user", "tags")
.limit(paginator.page_size)
.offset(paginator.offset())
.order_by('-id')
)
answer_count = []
for row in results:
r = (
await Answer.all()
.prefetch_related("question")
.filter(question__id=row.id).count()
)
answer_count.append(r)
page_controls = pagination.get_page_controls(
url=request.url,
current_page=paginator.current_page(),
total_pages=paginator.total_pages()
)
return templates.TemplateResponse(
"questions/questions.html",
{
"request": request,
"results": zip(results, answer_count),
"page_controls": page_controls
}
)
def site(request, username, **kwargs):
# 先效验用户对应的站点是否存在
user_obj = models.UserInfo.objects.filter(username=username).first()
if not user_obj:
return render(request, 'errors.html')
blog = user_obj.blog
# 查询当前个人站点下的所有的文章
article_list = models.Artice.objects.filter(blog=blog)
if kwargs:
# print(kwargs) # {'condition': 'tag', 'param': '1'}
condition = kwargs.get('condition')
param = kwargs.get('param')
# 判断用户到底想按照哪个条件筛选数据
if condition == 'category':
article_list = article_list.filter(category_id=param)
elif condition == 'tag':
article_list = article_list.filter(tags__id=param)
else:
year, month = param.split('-') # 2020-11 [2020,11]
article_list = article_list.filter(create_time__year=year,
create_time__month=month)
current_page = request.GET.get('page', 1)
all_count = article_list.count()
# 1 传值生成对象
page_obj = pagination.Pagination(current_page=current_page,
all_count=all_count)
# 2 直接对总数据进行切片操作
page_queryset = article_list[page_obj.start:page_obj.end]
return render(request, 'site.html', locals())
async def filter_search(request):
"""
Filter search questions by city and available ads (not rented ads in
required time)
"""
a = Ad
i = Image
r = Review
city = request.query_params["city"]
start = request.query_params["start"]
end = request.query_params["end"]
guests = request.query_params["guests"]
page_query = pagination.get_page_number(url=request.url)
if start > end:
return RedirectResponse(url="/")
# available apartment (not rented apartment in required time)
results = await a.raw(
f"SELECT * FROM ad WHERE ad.id NOT IN "
f"(SELECT a.id FROM ad AS a JOIN rent AS r "
f"ON a.id = r.ad_rent WHERE "
f"('{start}' <= r.end_date::date "
f"AND '{end}' >= r.start_date::date)) "
f"AND ad.visitor = '{guests}' "
f"AND ad.city ILIKE '%{city}%';"
).run()
count = len(results)
paginator = pagination.Pagination(page_query, count)
image_results = [
await i.select().where(i.ad_image == item["id"]).first().run()
for item in results
]
review_count = [
await r.count().where(r.ad == item["id"]).run() for item in results
]
review_grades = []
for item in results:
review_grades.extend(
await r.raw(
f"SELECT ROUND(AVG(review_grade)::numeric,2) AS stars "
f"FROM review JOIN ad ON review.ad = {item['id']};"
).run()
)
review_stars = [
0 if k["stars"] is None else k["stars"] for k in review_grades
]
page_controls = pagination.get_page_controls(
url=request.url,
current_page=paginator.current_page(),
total_pages=paginator.total_pages(),
)
return templates.TemplateResponse(
"ads/ads_list.html",
{
"request": request,
"results": zip(results, image_results, review_count, review_stars),
"page_controls": page_controls,
"count": count,
},
)
def page(request, obj):
current_page = request.GET.get('page', 1)
all_count = obj.count()
# 1 传值生成对象
page_obj = pagination.Pagination(current_page=current_page,
all_count=all_count)
# 2 直接对总数据进行切片操作
page_queryset = obj[page_obj.start:page_obj.end]
return page_queryset
def trouble(request):
user = request.session.get('user')
if not user:
return redirect('/login')
data_count = TroubleInfo.objects.filter(submitter_id=user['id']).count()
p = request.GET.get('p')
page = pagination.Pagination(p, data_count)
datas = TroubleInfo.objects.filter(
submitter_id=user['id'])[page.start:page.end]
page_str = page.page_str(request.path)
return render(request, 'backend/backend-trouble.html', locals())
def backend(request):
# 获取当前用户所有的文章
article_list = models.Artice.objects.filter(blog=request.user.blog)
current_page = request.GET.get('page', 1)
all_count = article_list.count()
# 1 传值生成对象
page_obj = pagination.Pagination(current_page=current_page,
all_count=all_count)
# 2 直接对总数据进行切片操作
page_queryset = article_list[page_obj.start:page_obj.end]
return render(request, 'backend/backend.html', locals())
def home(request):
article_queryset = models.Artice.objects.all()
# page_queryset = page(request,article_queryset)
current_page = request.GET.get('page', 1)
all_count = article_queryset.count()
# 1 传值生成对象
page_obj = pagination.Pagination(current_page=current_page,
all_count=all_count)
# 2 直接对总数据进行切片操作
page_queryset = article_queryset[page_obj.start:page_obj.end]
return render(request, 'home.html', locals())
async def search(request):
"""
Search ads
"""
a = Ad
i = Image
r = Review
count = await a.count().run()
page_query = pagination.get_page_number(url=request.url)
q = request.query_params["q"]
count = await count_search_ads(q).run()
paginator = pagination.Pagination(page_query, count)
results = (
await get_search_ads(q)
.limit(paginator.page_size)
.offset(paginator.offset())
.order_by(a.id, ascending=False)
.run()
)
image_results = [
await i.select().where(i.ad_image == item["id"]).first().run()
for item in results
]
review_count = [
await r.count().where(r.ad == item["id"]).run() for item in results
]
review_grades = []
for item in results:
review_grades.extend(
await r.raw(
f"SELECT ROUND(AVG(review_grade)::numeric,2) AS stars "
f"FROM review JOIN ad ON review.ad = {item['id']};"
).run()
)
review_stars = [
0 if k["stars"] is None else k["stars"] for k in review_grades
]
page_controls = pagination.get_page_controls(
url=request.url,
current_page=paginator.current_page(),
total_pages=paginator.total_pages(),
)
return templates.TemplateResponse(
"ads/ads_list.html",
{
"request": request,
"results": zip(results, image_results, review_count, review_stars),
"page_controls": page_controls,
"count": count,
},
)
def trouble_handled(request):
user = request.session.get('user')
if not user:
return redirect('/login')
p = request.GET.get('p')
data_count = TroubleInfo.objects. \
filter(submitter_id=user['id'], status=1, ).count()
page = pagination.Pagination(p, data_count)
datas = TroubleInfo.objects.filter(handler_id=user['id'], status=1) \
.order_by('submit_time')[page.start:page.end]
page_str = page.page_str(request.path)
btn_status = 1
return render(request, 'backend/backend-trouble-handler.html', locals())
def get(self, request):
# 模糊搜索
q = self.get_search_content(['course', 'semester'])
all_class = models.ClassList.objects.filter(q)
# 获取路径
query_params = self.get_query_params()
# 分页的应用
page = pagination.Pagination(request, len(all_class),
request.GET.copy())
return render(
request, 'crm/teacher/class_list.html', {
"all_class": all_class[page.start:page.end],
"pagination": page.show_li,
"query_params": query_params
})
def get(self, request, class_id):
# 模糊查询
q = self.get_search_content([])
all_course = models.CourseRecord.objects.filter(q,
re_class_id=class_id)
# 获取路径
query_params = self.get_query_params()
# 分页
page = pagination.Pagination(request, len(all_course),
request.GET.copy())
return render(
request, 'crm/teacher/course_list.html', {
"query_params": query_params,
"all_course": all_course[page.start:page.end],
'pagination': page.show_li,
"class_id": class_id,
})
def blog_article(request, surfix, article_id):
blog = BlogInfo.objects.filter(
surfix=surfix).select_related('user').first()
if not blog:
return redirect('/')
# 获得标签
tags = TagInfo.objects.filter(blog=blog)
# 获得个人类型
kinds = KindInfo.objects.filter(blog=blog)
# 获得统计日期
date_list = ArticleInfo.objects.distinct_date(blog=blog)
date_list = sorted(list(date_list))
# date_list ['2017-6','2018-6']
dates = []
for obj in date_list:
# c = ArticleInfo.objects.filter(blog=blog, time__year=l[0], time__month=l[1]).count()
# 上面的查询语句不知道为什么使用time__month就查不出任何东西
c = ArticleInfo.objects.filter(blog=blog).extra(
where=['date_format(time,"%%Y-%%m")=%s'], params=[
obj,
]).count()
dates.append((obj, c))
# 粉丝数
fans_count = Star2Fans.objects.filter(star_user=blog.user).count()
# 关注数
star_count = Star2Fans.objects.filter(fans_user=blog.user).count()
# 获得具体文章
try:
article = ArticleInfo.objects.get(id=article_id)
except ArticleInfo.DoesNotExist:
return redirect('/' + surfix + '/' + article_id)
# 获得文章的全部评论,加上分页
comment_count = CommentInfo.objects.filter(article=article).count()
p = request.GET.get('p')
page = pagination.Pagination(p, comment_count, per_page_count=5)
comment_list = CommentInfo.objects.filter(article=article). \
select_related('comment_parent').order_by('time')[page.start:page.end]
page_str = page.page_str()
return render(request, 'web/blog-article.html', locals())
async def tags(request):
"""
All tags
"""
page_query = pagination.get_page_number(url=request.url)
tag = request.path_params["tag"]
count = (
await Question.all()
.prefetch_related("user", "tags")
.filter(tags__name=tag)
.count()
)
paginator = pagination.Pagination(page_query, count)
results = (
await Question.all()
.prefetch_related("user", "tags")
.filter(tags__name=tag)
.limit(paginator.page_size)
.offset(paginator.offset())
.order_by("-id")
)
answer_count = []
for row in results:
r = (
await Answer.all()
.prefetch_related("question")
.filter(question__id=row.id).count()
)
answer_count.append(r)
page_controls = pagination.get_page_controls(
url=request.url,
current_page=paginator.current_page(),
total_pages=paginator.total_pages()
)
return templates.TemplateResponse(
"questions/tags.html", {
"request": request,
"results": zip(results, answer_count),
"page_controls": page_controls,
"tag": tag
}
)
async def dashboard(request):
auth_user = request.user.display_name
page_query = pagination.get_page_number(url=request.url)
count = await User.all().count()
paginator = pagination.Pagination(page_query, count)
results = (await User.all().limit(paginator.page_size
).offset(paginator.offset()))
page_controls = pagination.get_page_controls(
url=request.url,
current_page=paginator.current_page(),
total_pages=paginator.total_pages())
return templates.TemplateResponse(
"accounts/dashboard.html",
{
"request": request,
"results": results,
"auth_user": auth_user,
"page_controls": page_controls,
"count": count
},
)
def index(request, **kwargs):
# 获得按点赞数排行的点赞对象集合
# kwargs: {'index_kind': '2'}
# 命名正则会使命名名字为参数传入视图 index_kind=2
best_list = EvaluateInfo.objects.filter(action=1).values('article'). \
annotate(c=Count('article')).order_by('-c')[0:6]
bests = []
for obj in best_list:
bests.append(ArticleInfo.objects.get(id=obj['article']))
# 获得按评论数排行
# 排除评论对象为评论，即父文章外键为空的评论对象
comment_list = CommentInfo.objects.filter(~Q(article=None)). \
values('article').annotate(c=Count('article')).order_by('-c')[0:6]
# print(comment_list.query)
talks = []
for obj in comment_list:
talks.append(ArticleInfo.objects.get(id=obj['article']))
# 获得显示的全部文章，按点击数排行
# articles = ArticleInfo.objects.all().order_by('-read')
if kwargs:
base_url = reverse('index', kwargs=kwargs)
else:
base_url = '/'
# 分页
data_count = ArticleInfo.objects.filter(**kwargs).count()
p = request.GET.get('p')
page_obj = pagination.Pagination(p, data_count)
article_list = ArticleInfo.objects.filter(
**kwargs).order_by('-read')[page_obj.start:page_obj.end]
page_str = page_obj.page_str(base_url)
context = {
'articles': article_list,
'bests': bests,
'talks': talks,
'title': '首页',
'page_str': page_str,
}
return render(request, 'web/index.html', context)
async def profile_ads(request):
a = Ad
auth_user = request.user.display_name
page_query = pagination.get_page_number(url=request.url)
count = await a.count().where(a.ad_user.username == auth_user).run()
paginator = pagination.Pagination(page_query, count)
ads = (await get_ads().where(a.ad_user.username == auth_user
).limit(paginator.page_size
).offset(paginator.offset()).run())
page_controls = pagination.get_page_controls(
url=request.url,
current_page=paginator.current_page(),
total_pages=paginator.total_pages(),
)
return templates.TemplateResponse(
"accounts/profile_ads.html",
{
"request": request,
"ads": ads,
"page_controls": page_controls,
},
)
async def profile_questions(request):
p = Question
auth_user = request.user.display_name
page_query = pagination.get_page_number(url=request.url)
count = await p.count().where(p.user.username == auth_user).run()
paginator = pagination.Pagination(page_query, count)
if request.user.is_authenticated:
questions = (await
get_questions().where(p.user.username == auth_user).limit(
paginator.page_size).offset(paginator.offset()).run())
page_controls = pagination.get_page_controls(
url=request.url,
current_page=paginator.current_page(),
total_pages=paginator.total_pages(),
)
return templates.TemplateResponse(
"accounts/profile_questions.html",
{
"request": request,
"questions": questions,
"page_controls": page_controls,
},
)
async def profile_notifications(request):
n = Notification
auth_user = request.user.display_name
page_query = pagination.get_page_number(url=request.url)
count = await n.count().where(n.recipient.username == auth_user).run()
paginator = pagination.Pagination(page_query, count)
notifications = (await n.select(
n.id, n.message, n.created, n.is_read,
n.sender.username).where(n.recipient.username == auth_user
).limit(paginator.page_size
).offset(paginator.offset()).run())
page_controls = pagination.get_page_controls(
url=request.url,
current_page=paginator.current_page(),
total_pages=paginator.total_pages(),
)
return templates.TemplateResponse(
"accounts/profile_notifications.html",
{
"request": request,
"notifications": notifications,
"page_controls": page_controls,
},
)
def depart_list(request):
# change the request.py zhong de mutable
# from django.http.request import QueryDict
# qd=request.GET.copy() #deepcopy
# qd['xxx']=1
print("zhou11", request.GET, type(request.GET))
print("zhou22", request.GET.urlencode())
departs = models.Depart.objects.all()
# depart_list=[]
# for i in range(2,302):
# obj=models.Depart(name="bumen-{}".format(i))
# depart_list.append(obj)
# models.Depart.objects.bulk_create(depart_list)
# #begin
# try:
# page_num=int(request.GET.get("page",1))
# except Exception as e:
# page_num=1
page_num = request.GET.get("page", 1)
#
# start=(page_num-1)*10
# end=page_num*10
all_count = departs.count()
per_num = 10
max_show = 11
objpag = pagination.Pagination(page_num, all_count, per_num, max_show)
start = objpag.start()
end = objpag.end()
page_html = objpag.page_html()
# half_show=max_show//2
#
# total_num,more =divmod(all_count,per_num)
# if more:
# total_num+=1
#
# if total_num < max_show:
# page_start =1
# page_end =total_num
# else:
# if page_num < half_show:
# page_start = 1
# page_end=page_num + half_show
# elif page_num + half_show > total_num:
# page_start=page_num-half_show
# page_end=total_num
# else:
# page_start = page_num - half_show
# page_end = page_num + half_show
# #end
# page_list=[]
# for i in range(page_start,page_end+1):
# if i == page_num:
# page_list.append("<li class='active'><a href='?page={}'>{}</a></li>".format(i,i))
#
# else:
# page_list.append("<li><a href='?page={}'>{}</a></li>".format(i, i))
#
# page_html=''.join(page_list)
# print(page_html)
return render(request, "index.html", {
"departs": departs[start:end],
"page_html": page_html
})
def blog(request, **kwargs):
surfix = kwargs['surfix']
# 首先判断，若没有这个博客，让他滚回首页
blog = BlogInfo.objects.filter(
surfix=surfix).select_related('user').first()
if not blog:
return redirect('/')
# 看看url是不是带条件的（类型2）
condition = kwargs.get('condition', '')
p = request.GET.get('p')
if condition != '':
# url带有条件
if condition == 'tag':
article_count = Article2Tag.objects.filter(
tag_id=int(kwargs['value'])).count()
page = pagination.Pagination(p, article_count, per_page_count=3)
# 多表链接查询，只要有关系便可以使用
articles = ArticleInfo.objects.filter(
article2tag__tag_id=int(kwargs['value']))
elif condition == 'type':
article_count = ArticleInfo.objects.filter(category_id=int(
kwargs['value']),
blog=blog).count()
page = pagination.Pagination(p, article_count, per_page_count=3)
articles = ArticleInfo.objects.filter(category_id=int(kwargs['value']), blog=blog). \
order_by('-time')[page.start:page.end]
elif condition == 'date':
article_count = ArticleInfo.objects.filter(blog=blog). \
extra(where=['date_format(time,"%%Y-%%m")=%s'], params=[kwargs['value'], ]).count()
page = pagination.Pagination(p, article_count, per_page_count=3)
articles = ArticleInfo.objects.filter(blog=blog). \
extra(where=['date_format(time,"%%Y-%%m")=%s'], params=[kwargs['value'], ]). \
order_by('-time')[page.start:page.end]
else:
# 没带条件，获取全部文章
article_count = ArticleInfo.objects.filter(blog=blog).count()
page = pagination.Pagination(p, article_count, per_page_count=3)
articles = ArticleInfo.objects.filter(
blog=blog).order_by('time')[page.start:page.end]
base_url = request.path
page_str = page.page_str(base_url)
# 以下是共有的数据
# 获得标签
tags = TagInfo.objects.filter(blog=blog)
# 获得个人类型
kinds = KindInfo.objects.filter(blog=blog)
# 获得统计日期
date_list = ArticleInfo.objects.distinct_date(blog=blog)
date_list = sorted(list(date_list))
# date_list ['2017-6','2018-6']
dates = []
for obj in date_list:
# c = ArticleInfo.objects.filter(blog=blog, time__year=l[0], time__month=l[1]).count()
# 上面的查询语句不知道为什么使用time__month就查不出任何东西
c = ArticleInfo.objects.filter(blog=blog).extra(
where=['date_format(time,"%%Y-%%m")=%s'], params=[
obj,
]).count()
dates.append((obj, c))
# 粉丝数
fans_count = Star2Fans.objects.filter(star_user=blog.user).count()
# 关注数
star_count = Star2Fans.objects.filter(fans_user=blog.user).count()
return render(request, 'web/blog.html', locals())
async def questions_categories(request):
"""
Questions categories
"""
p = Question
category = request.path_params["category"]
page_query = pagination.get_page_number(url=request.url)
count = await p.count().where(p.category.name == category).run()
paginator = pagination.Pagination(page_query, count)
try:
tab = request.query_params["tab"]
if tab == "oldest":
results = (
await get_questions()
.where(p.category.name == category)
.limit(paginator.page_size)
.offset(paginator.offset())
.order_by(p.id, ascending=True)
.run()
)
if tab == "unsolved":
count = len(
await get_questions().where(p.accepted_answer == False).run()
)
paginator = pagination.Pagination(page_query, count)
results = (
await get_questions()
.where(
(p.accepted_answer == False)
& (p.category.name == category)
)
.limit(paginator.page_size)
.offset(paginator.offset())
.order_by(p.id, ascending=False)
.run()
)
if tab == "solved":
count = len(
await get_questions().where(p.accepted_answer == True).run()
)
paginator = pagination.Pagination(page_query, count)
results = (
await get_questions()
.where(
(p.accepted_answer == True) & (p.category.name == category)
)
.limit(paginator.page_size)
.offset(paginator.offset())
.order_by(p.id, ascending=False)
.run()
)
except KeyError:
results = (
await get_questions()
.where(p.category.name == category)
.limit(paginator.page_size)
.offset(paginator.offset())
.order_by(p.id, ascending=False)
.run()
)
answer_count = [
await p.raw(
f"select count(answer.id) from answer "
f"join question on answer.question = question.id "
f"where question.id = {item['id']};"
).run()
for item in results
]
c = Category
categories = await c.select().order_by(c.name, ascending=True).run()
category_count = [
await p.count().where(p.category.name == item["name"]).run()
for item in categories
]
page_controls = pagination.get_page_controls(
url=request.url,
current_page=paginator.current_page(),
total_pages=paginator.total_pages(),
)
return templates.TemplateResponse(
"questions/questions_categories.html",
{
"request": request,
"results": zip(results, answer_count),
"categories": zip(categories, category_count),
"page_controls": page_controls,
"r": results,
},
)
async def search(request):
"""
Search questions
"""
try:
page_query = pagination.get_page_number(url=request.url)
q = request.query_params['q']
count = (
await Question.all()
.prefetch_related("user")
.filter(Q(title__icontains=q) |
Q(content__icontains=q) |
Q(user__username__icontains=q))
.distinct()
.count()
)
paginator = pagination.Pagination(page_query, count)
results = (
await Question.all()
.prefetch_related("user", "tags")
.filter(Q(title__icontains=q) |
Q(content__icontains=q) |
Q(user__username__icontains=q) |
Q(tags__name__icontains=q))
.distinct()
.limit(paginator.page_size)
.offset(paginator.offset())
)
page_controls = pagination.get_page_controls(
url=request.url,
current_page=paginator.current_page(),
total_pages=paginator.total_pages()
)
except KeyError:
page_query = pagination.get_page_number(url=request.url)
count = await Question.all().count()
paginator = pagination.Pagination(page_query, count)
results = (
await Question.all()
.prefetch_related("user", "tags")
.limit(paginator.page_size)
.offset(paginator.offset())
)
page_controls = pagination.get_page_controls(
url=request.url,
current_page=paginator.current_page(),
total_pages=paginator.total_pages()
)
answer_count = []
for row in results:
r = (
await Answer.all()
.prefetch_related("question")
.filter(question__id=row.id).count()
)
answer_count.append(r)
return templates.TemplateResponse(
"questions/search.html", {
"request": request,
"results": zip(results, answer_count),
"page_controls": page_controls,
"count": count,
"q": q
}
)
