def filter(request, site, condition, val):
"""个人主页筛选"""
blog = models.Blog.objects.filter(site=site).first()
if not blog:
return redirect('/')
tag_list = models.Tag.objects.filter(blog=blog).values(
'nid', 'title').annotate(c=Count('nid'))
category_list = models.Article.objects.filter(blog=blog).values(
'category_id',
'category__title',
).annotate(c=Count('nid'))
date_list = models.Article.objects.filter(blog=blog).extra(
select={
'c': "strftime('%%Y年%%m月',create_time)"
}).values('c').annotate(ct=Count('nid'))
if condition == 'tag':
all_count = models.Article.objects.filter(tags=val,
blog=blog).all().count()
urls = request.path_info
page_info = Pagination(request.GET.get('page'), all_count, 5, 5)
article_list = models.Article.objects.filter(
tags__nid=1, blog=blog).all()[page_info.start:page_info.end]
print('zxzxzxccz', val, article_list)
page_str = page_info.page_str(urls)
elif condition == 'category':
all_count = models.Article.objects.filter(category_id=val,
blog=blog).all().count()
urls = request.path_info
page_info = Pagination(request.GET.get('page'), all_count, 5, 5)
article_list = models.Article.objects.filter(
category_id=val, blog=blog).all()[page_info.start:page_info.end]
page_str = page_info.page_str(urls)
elif condition == 'date':
all_count = models.Article.objects.filter(blog=blog).extra(
where=['strftime("%%Y年%%m月", create_time)=%s'], params=[
val,
]).all().count()
urls = request.path_info
page_info = Pagination(request.GET.get('page'), all_count, 5, 5)
article_list = models.Article.objects.filter(blog=blog).extra(
where=['strftime("%%Y年%%m月",create_time)=%s'], params=[
val,
]).all()[page_info.start:page_info.end]
# select * from tb where blog_id=1 and strftime("%Y-%m",create_time)=2017-01
page_str = page_info.page_str(urls)
else:
article_list = []
page_str = ''
return render(
request, 'home_summary_list.html', {
'blog': blog,
'tag_list': tag_list,
'category_list': category_list,
'date_list': date_list,
'article_list': article_list,
"page_str": page_str,
})
def index(request, *args, **kwargs):
"""
博客首页：展现全部博文
:param request:
:return:
"""
"""
type_choice = [
(1, 'Python'),
(2, 'Django'),
(3, 'book'),
(4, '区块链'),
(5, '人工智能'),
]
"""
print(kwargs)
article_type_list = models.Article.type_choice
if kwargs:
article_type_id = int(kwargs['article_type_id'])
base_url = reverse('web_home:index', kwargs=kwargs)
print(article_type_id)
data_count = models.Article.objects.filter(
article_type_id=article_type_id).count()
print(data_count)
page_obj = Pagination(request.GET.get('p'), data_count)
# 每页文章列表
article_list = models.Article.objects.filter(
article_type_id=article_type_id).order_by(
'-nid')[page_obj.start:page_obj.end]
page_str = page_obj.page_str(base_url)
else:
article_type_id = None
base_url = '/'
data_count = models.Article.objects.all().count()
page_obj = Pagination(request.GET.get('p'), data_count)
# 每页文章列表
article_list = models.Article.objects.all().order_by(
'-nid')[page_obj.start:page_obj.end]
page_str = page_obj.page_str(base_url)
return render(
request, 'web_home/index.html', {
'article_type_id': article_type_id,
'article_type_list': article_type_list,
'article_list': article_list,
'page_str': page_str,
})
def home(request, site):
"""个人主页"""
blog = models.Blog.objects.filter(site=site).first()
# Article 连接category通过category_id where blog_id=blog.nid 文章分类表
category_list = models.Article.objects.filter(blog=blog).values(
'category_id',
'category__title',
).annotate(c=Count('nid'))
tag_list = models.Tag.objects.filter(blog=blog).values(
'nid', 'title').annotate(c=Count('nid'))
date_list = models.Article.objects.filter(blog=blog).extra(
# select={'c': "date_format(create_time,'%%Y年%%m月')"}).values('c').annotate(ct=Count('nid'))
select={
'c': "strftime('%%Y年%%m月',create_time)"
}).values('c').annotate(ct=Count('nid'))
all_count = blog.article_set.all().count() if blog else 0
urls = request.path_info
page_info = Pagination(request.GET.get('page'), all_count, 5, 5)
page_str = page_info.page_str(urls)
article_list = blog.article_set.filter(
blog=blog).all()[page_info.start:page_info.end] if blog else ''
if not blog:
return redirect('/')
return render(
request, "home.html", {
"blog": blog,
'article_list': article_list,
'page_str': page_str,
'category_list': category_list,
'tag_list': tag_list,
"date_list": date_list
})
def index(request, *args, **kwargs):
article_type_list = models.Article.article_type_choices # [(1, 'python'), (2, 'linux'), (3, 'OpenStack'), (4, 'GoLang')]
if kwargs:
article_type_id = int(kwargs['article_type_id'])
base_url = reverse('index', kwargs=kwargs) # /article_type/1.html
else:
article_type_id = None
base_url = '/' # /
data_count = models.Article.objects.filter(
**kwargs).count() # 根据文章标签搜索到的数据库里一共存有多少篇该标签下的文章
page_obj = Pagination(request.GET.get('p', 1),
data_count,
per_page_article_num=5,
pager_num=7) # 为了获取start和end
article_list = models.Article.objects.filter(
**kwargs).order_by('-aid')[page_obj.start:page_obj.end] # 从数据库获取要显示的文章
# print(111, article_list)
page_str = page_obj.page_str(base_url)
return render(
request, 'web/index.html', {
'article_type_list': article_type_list,
'article_type_id': article_type_id,
'article_list': article_list,
'page_str': page_str,
})
def index(request, *args, **kwargs):
"""
首頁主站
"""
# 文章內建分類列表
article_type_list = models.Article.type_choices
# 判斷分類和url
if kwargs:
article_type_id = int(kwargs['article_type_id'])
base_url = reverse('index', kwargs=kwargs)
else:
article_type_id = None
base_url = "/"
# 分頁
data_count = models.Article.objects.filter(**kwargs).count() # 文章數
current_page = request.GET.get('p')
print(current_page)
page_obj = Pagination(data_count, current_page, perPageItemNum=4)
page_str = page_obj.page_str(base_url)
# 篩選文章(照nid倒序排列)，並根據頁數不同而改變文章
article_list = models.Article.objects.filter(
**kwargs).order_by('-nid')[page_obj.start():page_obj.end()]
blog_list = models.Blog.objects.all()[:5]
return render(request, "index.html", locals())
def get_dic(request, Model, Url, blog_id, **kwargs):
data_count = Model.objects.filter(blog_id=blog_id).count()
page = Pagination(request.GET.get('p', 1), data_count)
obj = Model.objects.filter(blog_id=blog_id).all()[page.start:page.end]
page_str = page.page_str(Url)
kwargs['p'] = page.current_page
return {'obj': obj, 'cate_dict': kwargs, 'page_str': page_str}
def get_blogger(request, site):
blog = models.Blog.objects.filter(site=site).select_related('user').first()
if not blog:
return redirect('/')
tag_list = models.Tag.objects.filter(blog=blog)
# tag_list = models.Tag.objects.filter(blog_id=blog.nid)
category_list = models.Category.objects.filter(blog=blog)
date_list = models.Article.objects.raw(
'select nid, count(nid) as num,strftime("%%Y-%%m",create_time) as ctime from repository_article where blog_id=%d group by strftime("%%Y-%%m",create_time)'
% (blog.nid))
# blog_user_id = request.GET.get('nid')
# user = models.UserInfo.objects.filter(nid=blog.user.nid).first()
data_count = blog.user.f.count()
page_obj = Pagination(request.GET.get('p'), data_count)
follower_list = models.UserInfo.objects.filter(nid=blog.user.nid).first(
).f.order_by('-nid')[page_obj.start:page_obj.end]
base_url = "/blogger_list/" + site + ".html"
page_str = page_obj.page_str(base_url)
return render(
request, 'follower_list.html', {
'blog': blog,
'tag_list': tag_list,
'category_list': category_list,
'date_list': date_list,
'follower_list': follower_list,
'page_str': page_str
})
def home(request, site):
blog = models.Blog.objects.filter(site=site).select_related('user').first()
if not blog:
return redirect('/')
base_url = site + ".html"
tag_list = models.Tag.objects.filter(blog=blog)
type_list = models.Category.objects.filter(blog=blog)
date_list = models.Article.objects.raw(
'select nid, count(nid) as num,strftime("%Y-%m",create_time) as ctime from repository_article group by strftime("%Y-%m",create_time)'
)
# article_list = models.Article.objects.filter(blog=blog).order_by("nid").all()
data_count = models.Article.objects.filter(blog=blog).count() # 需要展示的总个数
page_obj = Pagination(request.GET.get('p'), data_count,
per_page_count=4) # 当前页码
# 为了显示最新内容在最上面，需要加上order_by,参数加-就是倒序（desc），不加就是顺序（asc）
article_list = models.Article.objects.filter(
blog=blog).order_by('nid')[page_obj.start:page_obj.end]
# page_str就是分页工具最后生成的那一排a标签，要传到前端去显示
page_str = page_obj.page_str(base_url)
return render(
request, 'home.html', {
'blog': blog,
"tag_list": tag_list,
"type_list": type_list,
"date_list": date_list,
"article_list": article_list,
"page_str": page_str,
})
def detail(request, site, nid):
blog = models.Blog.objects.filter(site=site).first()
if not blog:
return redirect('/')
base_url = "/" + site + "/" + nid + ".html"
tag_list = models.Tag.objects.filter(blog_id=blog.bid)
type_list = models.Category.objects.filter(blog_id=blog.bid)
date_list = models.Article.objects.raw(
'select nid, count(nid) as num,strftime("%Y-%m",create_time) as ctime from repository_article group by strftime("%Y-%m",create_time)'
)
# article = models.Article.objects.filter(blog_id=blog.bid,nid=nid).first()
article_detail = models.ArticleDetail.objects.filter(
article_id=nid).first()
# comment_list = models.Comment.objects.filter(article_id=nid).all()
data_count = models.Comment.objects.filter(article_id=nid).count()
page_obj = Pagination(request.GET.get('p'), data_count)
comment_list = models.Comment.objects.filter(
article_id=nid).order_by('-nid')[page_obj.start:page_obj.end]
#page_str就是分页工具最后生成的那一排a标签，要传到前端去显示
page_str = page_obj.page_str(base_url)
return render(
request, 'home_detail.html', {
"blog": blog,
"tag_list": tag_list,
"type_list": type_list,
"date_list": date_list,
"article": article_detail,
"comment_list": comment_list,
"page_str": page_str,
})
def index(request, *args, **kwargs):
print(request)
print(kwargs)
if kwargs:
article_type_id = int(kwargs['article_type_id'])
#在HTML中：{% url "index" article_type_id=1 %} => all/1.html
#在views中：reverse('index',kwargs={"article_type_id":1}) =>all/1.html
base_url = reverse('index', kwargs=kwargs)
else:
article_type_id = None
base_url = '/'
#分页查看，必要参数：当前页码、需要展示数据的总个数
data_count = models.Article.objects.filter(**kwargs).count() #需要展示的总个数
page_obj = Pagination(request.GET.get('p'), data_count) #当前页码
#为了显示最新内容在最上面，需要加上order_by,参数加-就是倒序（desc），不加就是顺序（asc）
article_list = models.Article.objects.filter(
**kwargs).order_by('nid')[page_obj.start:page_obj.end]
type_list = models.Article.article_type_choices
#page_str就是分页工具最后生成的那一排a标签，要传到前端去显示
page_str = page_obj.page_str(base_url)
return render(
request, "index.html", {
"type_list": type_list,
"article_type_id": article_type_id,
"article_list": article_list,
"page_str": page_str,
})
def detail(request, site, nid):
"""
博文详细页
"""
blog = models.Blog.objects.filter(site=site).select_related('user').first()
tag_list = models.Tag.objects.filter(blog=blog).all()
category_list = models.Category.objects.filter(blog=blog)
date_list = models.Article.objects.raw('select nid,count(nid) as num,DATE_FORMAT(create_time,"%%Y年%%m月") as ctime from repository_article group by DATE_FORMAT(create_time,"%%Y年%%m月")')
article = models.Article.objects.filter(blog=blog,nid=nid).select_related('category', 'articledetail').first()
# comment_list = models.Comment.objects.filter(article_id=nid).all()
base_url = '/%s/%s.html'%(site,nid)
data_count = models.Comment.objects.filter(article_id=nid).count()
page_obj = Pagination(request.GET.get('p'),data_count)
comment_list = models.Comment.objects.filter(article_id=nid).order_by('-nid')[page_obj.start:page_obj.end]
page_str = page_obj.page_str(base_url)
return render(request, 'home_detail.html',{
"blog":blog,
"tag_list":tag_list,
"category_list":category_list,
"date_list":date_list,
"article":article,
"comment_list":comment_list,
"page_str":page_str})
def tag(request):
if request.method == 'GET':
blog = request.user.blog
tag_list = models.Tag.objects.filter(blog=blog).annotate(
c=Count("article")).values("title", "c", 'nid')
page = Pagination(request.GET.get('p', 1), tag_list.count())
tag_list = tag_list[page.start:page.end]
page_str = page.page_str(reverse('backend:tag'))
return render(request, 'backend_tag.html', {
'tag_list': tag_list,
'page_str': page_str
})
else:
'''修改tag'''
title = request.POST.get('title', None)
nid = request.POST.get('nid', 0)
blog = request.user.blog
ret = {"status": 0, "msg": ""}
if title and nid:
new_title_exist = models.Tag.objects.filter(blog=blog, title=title)
if new_title_exist:
ret['status'] = 1
ret['msg'] = '修改失败，"' + title + '"已存在！'
else:
models.Tag.objects.filter(blog=blog,
nid=nid).update(title=title)
else:
ret['status'] = 1
ret['msg'] = '标签名不能为空'
return JsonResponse(ret)
def index(request, *args, **kwargs):
"""
博客首页，展示全部博文
:param request:
:return:
"""
article_type_list = models.Article.type_choices
if kwargs:
article_type_id = int(kwargs['article_type_id'])
base_url = reverse('index', kwargs=kwargs)
else:
article_type_id = None
base_url = '/'
data_count = article_list = models.Article.objects.filter(**kwargs).count()
page_obj = Pagination(request.GET.get('p'), data_count)
article_list = models.Article.objects.filter(
**kwargs).order_by('-nid')[page_obj.start:page_obj.end]
page_str = page_obj.page_str(base_url)
return render(
request, 'index.html', {
'article_list': article_list,
'article_type_id': article_type_id,
'article_type_list': article_type_list,
'page_str': page_str,
})
def article(request, *args, **kwargs):
"""
博主个人文章管理
:param request:
:return:
"""
blog_id = request.session['user_info']['blog__nid']
condition = {}
for k, v in kwargs.items():
if v == '0':
pass
else:
condition[k] = v
condition['blog_id'] = blog_id
data_count = models.Article.objects.filter(**condition).count()
page = Pagination(request.GET.get('p', 1), data_count)
result = models.Article.objects.filter(**condition).order_by('-nid').only(
'nid', 'title', 'blog').select_related('blog')[page.start:page.end]
page_str = page.page_str(reverse('article', kwargs=kwargs))
category_list = models.Category.objects.filter(blog_id=blog_id).values(
'nid', 'title')
type_list = map(lambda item: {
'nid': item[0],
'title': item[1]
}, models.Article.type_choices)
kwargs['p'] = page.current_page
return render(
request, 'backend_article.html', {
'result': result,
'page_str': page_str,
'category_list': category_list,
'type_list': type_list,
'arg_dict': kwargs,
'data_count': data_count
})
def tag(request):
"""
博主个人标签管理
:param request:
:return:
"""
data_count = models.Tag.objects.all().count()
page_obj = Pagination(request.GET.get('p'), data_count)
base_url = '/backend/tag.html'
page_str = page_obj.page_str(base_url)
print(page_str)
if request.method == "GET":
row_list = models.Tag.objects.all().order_by(
'-nid')[page_obj.start:page_obj.end]
return render(request, 'backend_tag.html', locals())
elif request.method == "POST":
nickname = request.POST.get('nickname')
blog_id = request.session['user_info']['blog__nid']
if nickname:
obj = models.Tag(title=nickname, blog_id=blog_id)
obj.save()
row_list = models.Tag.objects.all().order_by(
'-nid')[page_obj.start:page_obj.end]
return render(request, 'backend_tag.html', locals())
else:
row_list = models.Tag.objects.all().order_by(
'-nid')[page_obj.start:page_obj.end]
return render(request, 'backend_tag.html', locals())
def home(request, site):
"""
博主个人首页
:param request:
:param site: 博主的网站后缀如：http://xxx.com/wupeiqi.html
:return:
"""
blog = models.Blog.objects.filter(site=site).select_related('user').first()
if not blog:
return redirect('/')
tag_list = models.Tag.objects.filter(blog=blog)
# tag_list = models.Tag.objects.filter(blog_id=blog.nid)
category_list = models.Category.objects.filter(blog=blog)
date_list = models.Article.objects.raw(
'select nid, count(nid) as num,strftime("%%Y-%%m",create_time) as ctime from repository_article where blog_id=%d group by strftime("%%Y-%%m",create_time)'
% (blog.nid))
data_count = models.Article.objects.filter(blog=blog).count()
page_obj = Pagination(request.GET.get('p'), data_count)
article_list = models.Article.objects.filter(
blog=blog).order_by('-nid')[page_obj.start:page_obj.end]
base_url = "/" + site + ".html"
page_str = page_obj.page_str(base_url)
return render(
request, 'home.html', {
'blog': blog,
'tag_list': tag_list,
'category_list': category_list,
'date_list': date_list,
'article_list': article_list,
'page_str': page_str,
})
def category(request):
"""
博主个人分类管理
"""
#用户对象
user_obj = models.UserInfo.objects.filter(nid=str(request.session.get('user_info')["nid"])).first()
#博客对象
blog = models.Blog.objects.filter(site=user_obj.username).select_related('user').first()
#分页
base_url = '/backend/category.html'
category_count = article_list = models.Category.objects.filter(blog_id=blog.nid).count()
page_obj = Pagination(request.GET.get('p'),category_count)
page_str = page_obj.page_str(base_url)
#分类对象
category_list = models.Category.objects.filter(blog=blog).all().order_by('nid')[page_obj.start:page_obj.end]
ret={"status":False,"error":None,"data":None}
if request.method =='GET':
return render(request, 'backend_category.html',{"user_obj":user_obj,"blog":blog,"category_list":category_list,"page_str":page_str})
elif request.method == "POST":
ret["status"]=True
if request.POST.get("category_type") == "delete":
category_id = request.POST.get("category_id")
models.Article.objects.filter(category_id=category_id).update(category_id='')
models.Category.objects.filter(nid=category_id).delete()
elif request.POST.get("category_type") == "save":
category_id = request.POST.get("category_id")
category_name = request.POST.get("category_name")
models.Category.objects.filter(nid=category_id).update(title=category_name)
else:
category_name = request.POST.get("category_name")
models.Category.objects.create(title=category_name,blog_id=blog.nid)
return HttpResponse(json.dumps(ret))
def article(request, *args, **kwargs):
# print(kwargs)
blog_id = request.session['user_info']['blog__bid']
condition = {}
for k, v in kwargs.items():
if v == '0':
pass
else:
condition[k] = v
condition['blog_id'] = blog_id
data_count = models.Article.objects.filter(**condition).count()
page = Pagination(request.GET.get('p', 1), data_count)
article_list = models.Article.objects.filter(
**condition).order_by("-nid")[page.start:page.end]
page_str = page.page_str(reverse('article', kwargs=kwargs))
type_list = map(lambda item: {
'nid': item[0],
'title': item[1]
}, models.Article.article_type_choices)
category_list = models.Category.objects.filter(blog_id=blog_id).values(
"nid", "title")
# print(category_list)
kwargs["p"] = page.current_page
return render(
request, "backend_article.html", {
"page_str": page_str,
"type_list": type_list,
"category_list": category_list,
'arg_dict': kwargs,
"article_list": article_list,
"data_count": data_count,
})
def article(request, *args, **kwargs):
"""
博主个人文章管理
:param request:
:return:
"""
blog_id = request.session['user_info']['blog__nid']
condition = {}
for k, v in kwargs.items():
if v == '0':
pass
else:
condition[k] = v
article_type_id = kwargs.get('article_type_id')
category_id = kwargs.get('category_id')
category_list = models.Category.objects.filter(blog_id=blog_id).values(
'nid', 'title')
type_list = list(
map(lambda item: {
'nid': item[0],
'title': item[1]
}, models.Article.type_choices))
# if article_type_id == 0:
# type_list = map(lambda item: {'nid': item[0], 'title': item[1]}, models.Article.type_choices)
# if category_id == 0:
# pass
# else:
# condition['category_id'] = category_id
# else:
# type_obj = models.Article.objects.filter(id=article_type_id).first()
# type_list = map(lambda item: {'nid': item[0], 'title': item[1]}, models.Article.type_choices)
#
# vlist = type_obj.article_type_id.all().values_list('nid', 'title') # [(1,),(2,),(3,)]
# if not vlist:
# classification_id_list = []
# else:
# classification_id_list = list(zip(*vlist))[0]
#
# if category_id == 0:
# condition['category_id__in'] = classification_id_list
# else:
# if category_id in classification_id_list:
# condition['category_id'] = category_id
# else:
# #方向指定，分类不在其中 [1,2,3] 分类：5
# kwargs['category_id'] = 0
# condition['category_id'] = classification_id_list
condition['blog_id'] = blog_id
data_count = models.Article.objects.filter(**condition).count()
page = Pagination(request.GET.get('p', 1), data_count)
page_str = page.page_str(reverse('article', kwargs=kwargs))
kwargs['p'] = page.current_page
result = models.Article.objects.filter(**condition).order_by('-nid').only(
'nid', 'title', 'blog').select_related('blog')[page.start:page.end]
return render(request, 'backend_article.html', locals())
def test(request):
page_obj = Pagination(request.GET.get('p'), 100)
test_list = range(1, 100)[page_obj.start:page_obj.end]
page_str = page_obj.page_str('/test/')
return render(request, 'test.html', {
'test_list': test_list,
'page_str': page_str,
})
def user_list(request, *args, **kwargs):
user_list = UserInfo.objects.all()
page_obj = Pagination(user_list.count(), request.GET.get('p'))
base_url = reverse('backend:user_list')
page_str = page_obj.page_str(base_url)
user_list = user_list[page_obj.start:page_obj.end]
return render(request, 'backend_user_list.html', {
'user_list': user_list,
'page_str': page_str
})
def article(request, *args, **kwargs): # article_type_id, tag__tid
blog_id = request.session['userinfo']['blog__bid']
search_condition = {}
for k, v in kwargs.items():
if v != '0':
search_condition[k] = v
# print(55, search_condition)
tag_list = models.Tag.objects.filter(blog_id=blog_id).all()
article_type_choices = models.Article.article_type_choices # [(1, 'python'), (2, 'linux'), (3, 'OpenStack'), (4, 'GoLang')]
article_type_list = list(
map(lambda x: {
'nid': x[0],
'title': x[1]
}, article_type_choices))
# print(article_type_list) # [{'nid': 1, 'title': 'python'}, {'nid': 2, 'title': 'linux'}, {'nid': 3, 'title': 'OpenStack'}, {'nid': 4, 'title': 'GoLang'}]
# article_obj2 = models.Article.objects.filter(blog_id=blog_id, tag__article2tag__).all()
# print(333,article_obj2)
article_obj = models.Article.objects.filter(blog_id=blog_id,
**search_condition)
data_count = article_obj.count()
page_obj = Pagination(
request.GET.get('p', 1),
data_count,
per_page_article_num=10,
)
article_list = article_obj.order_by('-create_time')
article_list2 = []
for index, article in enumerate(article_list, 1):
article_dict = {'index': index, 'article': article}
article_list2.append(article_dict)
# article_list2 = article_obj.order_by('-aid')[page_obj.start:page_obj.end]
article_list3 = article_list2[page_obj.start:page_obj.end]
page_str = page_obj.page_str(reverse('article', kwargs=kwargs))
kwargs['p'] = page_obj.current_page
return render(
request, 'backend/article.html', {
'article_type_list': article_type_list,
'data_count': data_count,
'article_list': article_list,
'kwargs_dict': kwargs,
'tag_list': tag_list,
'page_str': page_str,
'article_list3': article_list3,
})
def article(request, *args, **kwargs):
'''
博主个人博客后台管理
:param request:
:param args:
:param kwargs:
:return:
'''
print(kwargs)
blog_id = request.session.get('user_info')['blog__nid']
upload_avatar = request.session.get('user_info')['avatar']
print(blog_id)
print(upload_avatar)
# 对传入的参数列表按照自己的意愿进行字典类型的转化
condition = {}
for k, v in kwargs.items():
if v == '0':
pass
else:
condition[k] = v
condition['blog_id'] = blog_id
data_count = models.Article.objects.filter(**condition).count()
print(data_count)
page = Pagination(request.GET.get('p', 1), data_count)
result = models.Article.objects.filter(**condition).order_by('-nid').only(
'nid', 'title', 'blog').select_related('blog')[page.start:page.end]
page_str = page.page_str(reverse('article', kwargs=kwargs))
category_list = models.Category.objects.filter(blog_id=blog_id).values(
'nid', 'title')
print(category_list)
type_list = map(lambda item: {
'nid': item[0],
'title': item[1]
}, models.Article.type_choices)
# type_list 目前还只是一个迭代器对象要执行可以使用list(type_list)
kwargs['p'] = page.current_page
return render(
request,
'backend_article.html',
{
'upload_avatar': upload_avatar,
'arg_dict': kwargs,
'result': result,
'page_str': page_str,
'category_list': category_list,
'type_list': type_list,
'data_count': data_count,
},
)
def report(request):
if request.method == 'GET':
data_count = models.Report.objects.count()
page = Pagination(request.GET.get('p', 1), data_count)
result = models.Report.objects.order_by('-id').select_related(
'article_id', )[page.start:page.end]
page_str = page.page_str("/report.html")
return render(
request, 'backend_report.html', {
'result': result,
'page_str': page_str,
'data_count': data_count,
'menu_string': request.session['menu_string'],
})
def tag(request):
# -----------------要有blog才可使用-----------------
blog_id = request.session['user_info']['blog__nid']
if blog_id is None:
return redirect("/backend/index.html")
# --------------------------------------------------
blog_id = request.session["user_info"]["blog__nid"]
# 分頁
data_count = models.Tag.objects.filter(blog_id=blog_id).count()
current_page = request.GET.get("p")
page_obj = Pagination(data_count, current_page, perPageItemNum=7)
page_str = page_obj.page_str("/backend/tag.html")
result = models.Tag.objects.filter(
blog_id=blog_id)[page_obj.start():page_obj.end()]
return render(request, "backend_tag.html", locals())
def article(request, **kwargs):
user_info = request.session.get('user_info')
blog = Blog.objects.filter(user_id=user_info.get('id')).first()
type_list = Classification.objects.filter(blog=blog)
tag_list = Tags.objects.filter(blog=blog)
condition = {}
for k, v in kwargs.items():
kwargs[k] = int(v)
type_id = kwargs.get('type_id')
tag_id = kwargs.get('tag_id')
# print(type_id,tag_id)
if type_id == 0:
if tag_id == 0:
pass
else:
condition['tags'] = tag_id
else:
if tag_id == 0:
# Article.objects.filter(blog__classification=type_id)
pass
else:
condition['tags'] = tag_id
condition['article_classification_id'] = type_id
condition['blog'] = blog
# print(condition)
article_list = Article.objects.filter(**condition).order_by(
'-publish', '-id')
# article_list = Article.objects.filter(blog=blog,).values('tags','article_classification_id','title')
data_count = article_list.count()
page_obj = Pagination(data_count, request.GET.get('p'))
base_url = reverse('backend:backend_article',
kwargs={
'type_id': type_id,
'tag_id': tag_id
})
page_str = page_obj.page_str(base_url)
article_list = article_list[page_obj.start:page_obj.end]
context = {
'kwargs': kwargs,
'type_list': type_list,
'tag_list': tag_list,
'article_list': article_list,
'data_count': data_count,
'page_str': page_str
}
return render(request, 'backend_article.html', context)
def tag(request):
blog_id = request.session['user_info']['blog__nid']
data_count = models.Category.objects.count()
page = Pagination(request.GET.get('p', 1), data_count)
result = models.Tag.objects.filter(blog_id=blog_id).order_by(
'-nid').select_related('blog')[page.start:page.end]
page_str = page.page_str("/tag.html")
article_list = models.Article.objects.filter(blog_id=blog_id)
return render(
request, 'backend_tag.html', {
'result': result,
'page_str': page_str,
'article_list': article_list,
'data_count': data_count,
'menu_string': request.session['menu_string']
})
def index(request, *args, **kwargs):
'''
博客首页，展示全部博文
:param request:
:param args:
:param kwargs:
:return:
'''
article_type_list = models.Article.type_choices
if kwargs:
article_type_id = int(kwargs['article_type_id'])
base_url = reverse('index', kwargs=kwargs)
else:
article_type_id = None
base_url = '/'
if article_type_id == 5: ## 返回妹子图片
article_type_id = 5
meizi_list = models.MeiZi.objects.all()
return render(
request, 'meizi.html', {
'article_type_id': article_type_id,
'article_type_list': article_type_list
})
else:
# ## 得到全部的数据
data_count = article_list = models.Article.objects.filter(
**kwargs).count()
## 分页对象
page_obj = Pagination(1, data_count=data_count)
article_list = models.Article.objects.filter(**kwargs).order_by(
('-nid'))[page_obj.start:page_obj.end]
page_str = page_obj.page_str(base_url=base_url)
return render(
request, 'index.html', {
'article_list': article_list,
'article_type_id': article_type_id,
'article_type_list': article_type_list,
'page_str': page_str,
})
def category(request,*args,**kwargs):
"""
博主个人分类管理
:param request:
:return:
"""
bass_url = reverse('category', kwargs=kwargs)
user=request.session.get('user_info')['blog__nid']
if not user:
return redirect('/login')
date_count=models.Category.objects.filter(blog=user).count()
page_obj=Pagination(request.GET.get('p'),date_count)
from django.db.models.aggregates import Count
date_list=models.Category.objects.filter(blog=user).annotate(c=Count('article__title')).values('title','c','nid')[page_obj.start:page_obj.end]
# category_list = models.Category.objects.filter(blog=user)[page_obj.start:page_obj.end]
# for i in category_list:
# article_sum=i.article_set.filter(blog=user).count()
page_str = page_obj.page_str(bass_url)
return render(request,'backend_category.html',{'date_list':date_list,'page_str':page_str})
def index(request, *args, **kwargs):
"""
博客首页，展示全部博文
:param request:
:return:
"""
# return render(request,'index.html')
# 获取文章类型
article_type_list = models.Article.type_choices
# {},[]
if kwargs:
article_type_id = int(kwargs['article_type_id'])
# 按照別名反向生成URL
# 有參數時 all/(?P<article_type_id>\d+).html {%url 'index' article_type_id=1%} all/1.html
# 無參數時 all/(\d+).html{%url 'index' 1%} all/1.html
# 在 views中使用 有分組時 kwargs={article_type_id:1,}
# 在 views中使用 無分組時 args=(1,)
base_url = reverse('index', kwargs=kwargs) # all/1.html
else:
article_type_id = None
base_url = '/' # /
data_count = models.Article.objects.filter(**kwargs).count()
page_obj = Pagination(request.GET.get('p'), data_count)
article_list = models.Article.objects.filter(
**kwargs).order_by('-nid')[page_obj.start:page_obj.end]
page_str = page_obj.page_str(base_url)
article_like_list = models.Article.objects.order_by('-up_count')[0:10]
article_comment_list = models.Article.objects.order_by(
'-comment_count')[0:10]
return render(
request,
'index.html',
{
'article_list': article_list,
'article_type_id': article_type_id, # 文章分類id
'article_type_list': article_type_list, # 文章分類的文本
'page_str': page_str,
'article_like_list': article_like_list,
'article_comment_list': article_comment_list,
})
