pv7szbh4j
/
git-test
1
0
Fork 1
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Update blog_tags.py

Browse Source
master
p36kxhw2t 1 month ago
parent 0ad7529481
commit a51ad9a3e1
1 changed files with 195 additions and 195 deletions
Show Stats Download Patch File Download Diff File

390
src/DjangoBlog-master/blog/templatetags/blog_tags.py
Unescape View File

@ -20,325 +20,325 @@ from djangoblog.utils import get_current_site
from oauth.models import OAuthUser
from djangoblog.plugin_manage import hooks
logger = logging.getLogger(__name__)
logger = logging.getLogger(__name__) #ZNY 获取当前模块的日志记录器
register = template.Library()
register = template.Library() #ZNY 创建Django模板标签库实例
@register.simple_tag(takes_context=True)
def head_meta(context):
return mark_safe(hooks.apply_filters('head_meta', '', context))
@register.simple_tag(takes_context=True) #ZNY 注册简单模板标签，接收模板上下文
def head_meta(context): #ZNY 生成头部meta信息的模板标签
return mark_safe(hooks.apply_filters('head_meta', '', context)) #ZNY 应用过滤器并返回安全的HTML字符串
@register.simple_tag
def timeformat(data):
@register.simple_tag #ZNY 注册简单模板标签
def timeformat(data): #ZNY 时间格式化模板标签
try:
return data.strftime(settings.TIME_FORMAT)
return data.strftime(settings.TIME_FORMAT) #ZNY 按照设置的时间格式格式化时间
except Exception as e:
logger.error(e)
return ""
logger.error(e) #ZNY 记录错误日志
return "" #ZNY 出错时返回空字符串
@register.simple_tag
def datetimeformat(data):
@register.simple_tag #ZNY 注册简单模板标签
def datetimeformat(data): #ZNY 日期时间格式化模板标签
try:
return data.strftime(settings.DATE_TIME_FORMAT)
return data.strftime(settings.DATE_TIME_FORMAT) #ZNY 按照设置的日期时间格式格式化
except Exception as e:
logger.error(e)
return ""
logger.error(e) #ZNY 记录错误日志
return "" #ZNY 出错时返回空字符串
@register.filter()
@stringfilter
def custom_markdown(content):
return mark_safe(CommonMarkdown.get_markdown(content))
@register.filter() #ZNY 注册模板过滤器
@stringfilter #ZNY 确保输入被转换为字符串
def custom_markdown(content): #ZNY 自定义Markdown转换过滤器
return mark_safe(CommonMarkdown.get_markdown(content)) #ZNY 将Markdown内容转换为HTML并标记为安全
@register.simple_tag
def get_markdown_toc(content):
from djangoblog.utils import CommonMarkdown
body, toc = CommonMarkdown.get_markdown_with_toc(content)
return mark_safe(toc)
@register.simple_tag #ZNY 注册简单模板标签
def get_markdown_toc(content): #ZNY 获取Markdown目录模板标签
from djangoblog.utils import CommonMarkdown #ZNY 导入Markdown工具类
body, toc = CommonMarkdown.get_markdown_with_toc(content) #ZNY 获取带目录的Markdown内容
return mark_safe(toc) #ZNY 返回目录HTML并标记为安全
@register.filter()
@stringfilter
def comment_markdown(content):
content = CommonMarkdown.get_markdown(content)
return mark_safe(sanitize_html(content))
@register.filter() #ZNY 注册模板过滤器
@stringfilter #ZNY 确保输入被转换为字符串
def comment_markdown(content): #ZNY 评论Markdown转换过滤器
content = CommonMarkdown.get_markdown(content) #ZNY 将Markdown转换为HTML
return mark_safe(sanitize_html(content)) #ZNY 对HTML进行安全过滤后返回
@register.filter(is_safe=True)
@stringfilter
def truncatechars_content(content):
@register.filter(is_safe=True) #ZNY 注册安全模板过滤器
@stringfilter #ZNY 确保输入被转换为字符串
def truncatechars_content(content): #ZNY 截断文章内容过滤器
"""
获得文章内容的摘要
:param content:
:return:
"""
from django.template.defaultfilters import truncatechars_html
from djangoblog.utils import get_blog_setting
blogsetting = get_blog_setting()
return truncatechars_html(content, blogsetting.article_sub_length)
from django.template.defaultfilters import truncatechars_html #ZNY 导入HTML截断函数
from djangoblog.utils import get_blog_setting #ZNY 导入博客设置获取函数
blogsetting = get_blog_setting() #ZNY 获取博客设置
return truncatechars_html(content, blogsetting.article_sub_length) #ZNY 按设置的文章摘要长度截断HTML内容
@register.filter(is_safe=True)
@stringfilter
def truncate(content):
from django.utils.html import strip_tags
@register.filter(is_safe=True) #ZNY 注册安全模板过滤器
@stringfilter #ZNY 确保输入被转换为字符串
def truncate(content): #ZNY 简单截断过滤器
from django.utils.html import strip_tags #ZNY 导入HTML标签去除函数
return strip_tags(content)[:150]
return strip_tags(content)[:150] #ZNY 去除HTML标签后截取前150个字符
@register.inclusion_tag('blog/tags/breadcrumb.html')
def load_breadcrumb(article):
@register.inclusion_tag('blog/tags/breadcrumb.html') #ZNY 注册包含标签，指定模板
def load_breadcrumb(article): #ZNY 加载面包屑导航标签
"""
获得文章面包屑
:param article:
:return:
"""
names = article.get_category_tree()
from djangoblog.utils import get_blog_setting
blogsetting = get_blog_setting()
site = get_current_site().domain
names.append((blogsetting.site_name, '/'))
names = names[::-1]
names = article.get_category_tree() #ZNY 获取文章分类树
from djangoblog.utils import get_blog_setting #ZNY 导入博客设置获取函数
blogsetting = get_blog_setting() #ZNY 获取博客设置
site = get_current_site().domain #ZNY 获取当前站点域名
names.append((blogsetting.site_name, '/')) #ZNY 添加首页链接
names = names[::-1] #ZNY 反转列表顺序
return {
'names': names,
'title': article.title,
'count': len(names) + 1
'names': names, #ZNY 面包屑名称和URL列表
'title': article.title, #ZNY 文章标题
'count': len(names) + 1 #ZNY 面包屑数量
}
@register.inclusion_tag('blog/tags/article_tag_list.html')
def load_articletags(article):
@register.inclusion_tag('blog/tags/article_tag_list.html') #ZNY 注册包含标签，指定模板
def load_articletags(article): #ZNY 加载文章标签列表标签
"""
文章标签
:param article:
:return:
"""
tags = article.tags.all()
tags_list = []
for tag in tags:
url = tag.get_absolute_url()
count = tag.get_article_count()
tags_list.append((
url, count, tag, random.choice(settings.BOOTSTRAP_COLOR_TYPES)
tags = article.tags.all() #ZNY 获取文章的所有标签
tags_list = [] #ZNY 初始化标签列表
for tag in tags: #ZNY 遍历每个标签
url = tag.get_absolute_url() #ZNY 获取标签URL
count = tag.get_article_count() #ZNY 获取标签下文章数量
tags_list.append(( #ZNY 添加标签信息到列表
url, count, tag, random.choice(settings.BOOTSTRAP_COLOR_TYPES) #ZNY URL、数量、标签对象、随机颜色
))
return {
'article_tags_list': tags_list
'article_tags_list': tags_list #ZNY 返回标签列表
}
@register.inclusion_tag('blog/tags/sidebar.html')
def load_sidebar(user, linktype):
@register.inclusion_tag('blog/tags/sidebar.html') #ZNY 注册包含标签，指定模板
def load_sidebar(user, linktype): #ZNY 加载侧边栏标签
"""
加载侧边栏
:return:
"""
value = cache.get("sidebar" + linktype)
if value:
value['user'] = user
return value
else:
logger.info('load sidebar')
from djangoblog.utils import get_blog_setting
blogsetting = get_blog_setting()
recent_articles = Article.objects.filter(
status='p')[:blogsetting.sidebar_article_count]
sidebar_categorys = Category.objects.all()
extra_sidebars = SideBar.objects.filter(
is_enable=True).order_by('sequence')
most_read_articles = Article.objects.filter(status='p').order_by(
'-views')[:blogsetting.sidebar_article_count]
dates = Article.objects.datetimes('creation_time', 'month', order='DESC')
links = Links.objects.filter(is_enable=True).filter(
Q(show_type=str(linktype)) | Q(show_type=LinkShowType.A))
commment_list = Comment.objects.filter(is_enable=True).order_by(
'-id')[:blogsetting.sidebar_comment_count]
value = cache.get("sidebar" + linktype) #ZNY 尝试从缓存获取侧边栏数据
if value: #ZNY 如果缓存存在
value['user'] = user #ZNY 添加用户信息
return value #ZNY 返回缓存数据
else: #ZNY 如果缓存不存在
logger.info('load sidebar') #ZNY 记录加载侧边栏日志
from djangoblog.utils import get_blog_setting #ZNY 导入博客设置获取函数
blogsetting = get_blog_setting() #ZNY 获取博客设置
recent_articles = Article.objects.filter( #ZNY 获取最近文章
status='p')[:blogsetting.sidebar_article_count] #ZNY 只取已发布文章，按设置数量限制
sidebar_categorys = Category.objects.all() #ZNY 获取所有分类
extra_sidebars = SideBar.objects.filter( #ZNY 获取额外侧边栏
is_enable=True).order_by('sequence') #ZNY 只取启用的，按顺序排序
most_read_articles = Article.objects.filter(status='p').order_by( #ZNY 获取最多阅读文章
'-views')[:blogsetting.sidebar_article_count] #ZNY 按浏览量降序排列，按设置数量限制
dates = Article.objects.datetimes('creation_time', 'month', order='DESC') #ZNY 获取文章按月归档日期
links = Links.objects.filter(is_enable=True).filter( #ZNY 获取友情链接
Q(show_type=str(linktype)) | Q(show_type=LinkShowType.A)) #ZNY 按显示类型过滤
commment_list = Comment.objects.filter(is_enable=True).order_by( #ZNY 获取最新评论
'-id')[:blogsetting.sidebar_comment_count] #ZNY 按ID降序排列，按设置数量限制
# 标签云 计算字体大小
# 根据总数计算出平均值 大小为 (数目/平均值)*步长
increment = 5
tags = Tag.objects.all()
sidebar_tags = None
if tags and len(tags) > 0:
s = [t for t in [(t, t.get_article_count()) for t in tags] if t[1]]
count = sum([t[1] for t in s])
dd = 1 if (count == 0 or not len(tags)) else count / len(tags)
import random
sidebar_tags = list(
map(lambda x: (x[0], x[1], (x[1] / dd) * increment + 10), s))
random.shuffle(sidebar_tags)
value = {
'recent_articles': recent_articles,
'sidebar_categorys': sidebar_categorys,
'most_read_articles': most_read_articles,
'article_dates': dates,
'sidebar_comments': commment_list,
'sidabar_links': links,
'show_google_adsense': blogsetting.show_google_adsense,
'google_adsense_codes': blogsetting.google_adsense_codes,
'open_site_comment': blogsetting.open_site_comment,
'show_gongan_code': blogsetting.show_gongan_code,
'sidebar_tags': sidebar_tags,
'extra_sidebars': extra_sidebars
increment = 5 #ZNY 字体大小增量
tags = Tag.objects.all() #ZNY 获取所有标签
sidebar_tags = None #ZNY 初始化侧边栏标签
if tags and len(tags) > 0: #ZNY 如果有标签
s = [t for t in [(t, t.get_article_count()) for t in tags] if t[1]] #ZNY 生成标签和文章数量列表
count = sum([t[1] for t in s]) #ZNY 计算总文章数
dd = 1 if (count == 0 or not len(tags)) else count / len(tags) #ZNY 计算平均值
import random #ZNY 导入随机模块
sidebar_tags = list( #ZNY 生成侧边栏标签列表
map(lambda x: (x[0], x[1], (x[1] / dd) * increment + 10), s)) #ZNY 计算每个标签的字体大小
random.shuffle(sidebar_tags) #ZNY 随机打乱标签顺序
value = { #ZNY 构建侧边栏数据字典
'recent_articles': recent_articles, #ZNY 最近文章
'sidebar_categorys': sidebar_categorys, #ZNY 分类列表
'most_read_articles': most_read_articles, #ZNY 最多阅读文章
'article_dates': dates, #ZNY 文章归档日期
'sidebar_comments': commment_list, #ZNY 侧边栏评论
'sidabar_links': links, #ZNY 侧边栏链接
'show_google_adsense': blogsetting.show_google_adsense, #ZNY 是否显示谷歌广告
'google_adsense_codes': blogsetting.google_adsense_codes, #ZNY 谷歌广告代码
'open_site_comment': blogsetting.open_site_comment, #ZNY 是否开启全站评论
'show_gongan_code': blogsetting.show_gongan_code, #ZNY 是否显示公安备案
'sidebar_tags': sidebar_tags, #ZNY 侧边栏标签云
'extra_sidebars': extra_sidebars #ZNY 额外侧边栏
}
cache.set("sidebar" + linktype, value, 60 * 60 * 60 * 3)
logger.info('set sidebar cache.key:{key}'.format(key="sidebar" + linktype))
value['user'] = user
return value
cache.set("sidebar" + linktype, value, 60 * 60 * 60 * 3) #ZNY 将侧边栏数据存入缓存，有效期3小时
logger.info('set sidebar cache.key:{key}'.format(key="sidebar" + linktype)) #ZNY 记录缓存设置日志
value['user'] = user #ZNY 添加用户信息
return value #ZNY 返回侧边栏数据
@register.inclusion_tag('blog/tags/article_meta_info.html')
def load_article_metas(article, user):
@register.inclusion_tag('blog/tags/article_meta_info.html') #ZNY 注册包含标签，指定模板
def load_article_metas(article, user): #ZNY 加载文章meta信息标签
"""
获得文章meta信息
:param article:
:return:
"""
return {
'article': article,
'user': user
'article': article, #ZNY 文章对象
'user': user #ZNY 用户对象
}
@register.inclusion_tag('blog/tags/article_pagination.html')
def load_pagination_info(page_obj, page_type, tag_name):
previous_url = ''
next_url = ''
if page_type == '':
if page_obj.has_next():
next_number = page_obj.next_page_number()
next_url = reverse('blog:index_page', kwargs={'page': next_number})
if page_obj.has_previous():
previous_number = page_obj.previous_page_number()
previous_url = reverse(
@register.inclusion_tag('blog/tags/article_pagination.html') #ZNY 注册包含标签，指定模板
def load_pagination_info(page_obj, page_type, tag_name): #ZNY 加载分页信息标签
previous_url = '' #ZNY 初始化上一页URL
next_url = '' #ZNY 初始化下一页URL
if page_type == '': #ZNY 如果是首页分页
if page_obj.has_next(): #ZNY 如果有下一页
next_number = page_obj.next_page_number() #ZNY 获取下一页页码
next_url = reverse('blog:index_page', kwargs={'page': next_number}) #ZNY 生成下一页URL
if page_obj.has_previous(): #ZNY 如果有上一页
previous_number = page_obj.previous_page_number() #ZNY 获取上一页页码
previous_url = reverse( #ZNY 生成上一页URL
'blog:index_page', kwargs={
'page': previous_number})
if page_type == '分类标签归档':
tag = get_object_or_404(Tag, name=tag_name)
if page_obj.has_next():
next_number = page_obj.next_page_number()
next_url = reverse(
if page_type == '分类标签归档': #ZNY 如果是标签归档分页
tag = get_object_or_404(Tag, name=tag_name) #ZNY 获取标签对象
if page_obj.has_next(): #ZNY 如果有下一页
next_number = page_obj.next_page_number() #ZNY 获取下一页页码
next_url = reverse( #ZNY 生成标签下一页URL
'blog:tag_detail_page',
kwargs={
'page': next_number,
'tag_name': tag.slug})
if page_obj.has_previous():
previous_number = page_obj.previous_page_number()
previous_url = reverse(
if page_obj.has_previous(): #ZNY 如果有上一页
previous_number = page_obj.previous_page_number() #ZNY 获取上一页页码
previous_url = reverse( #ZNY 生成标签上一页URL
'blog:tag_detail_page',
kwargs={
'page': previous_number,
'tag_name': tag.slug})
if page_type == '作者文章归档':
if page_obj.has_next():
next_number = page_obj.next_page_number()
next_url = reverse(
if page_type == '作者文章归档': #ZNY 如果是作者归档分页
if page_obj.has_next(): #ZNY 如果有下一页
next_number = page_obj.next_page_number() #ZNY 获取下一页页码
next_url = reverse( #ZNY 生成作者下一页URL
'blog:author_detail_page',
kwargs={
'page': next_number,
'author_name': tag_name})
if page_obj.has_previous():
previous_number = page_obj.previous_page_number()
previous_url = reverse(
if page_obj.has_previous(): #ZNY 如果有上一页
previous_number = page_obj.previous_page_number() #ZNY 获取上一页页码
previous_url = reverse( #ZNY 生成作者上一页URL
'blog:author_detail_page',
kwargs={
'page': previous_number,
'author_name': tag_name})
if page_type == '分类目录归档':
category = get_object_or_404(Category, name=tag_name)
if page_obj.has_next():
next_number = page_obj.next_page_number()
next_url = reverse(
if page_type == '分类目录归档': #ZNY 如果是分类归档分页
category = get_object_or_404(Category, name=tag_name) #ZNY 获取分类对象
if page_obj.has_next(): #ZNY 如果有下一页
next_number = page_obj.next_page_number() #ZNY 获取下一页页码
next_url = reverse( #ZNY 生成分类下一页URL
'blog:category_detail_page',
kwargs={
'page': next_number,
'category_name': category.slug})
if page_obj.has_previous():
previous_number = page_obj.previous_page_number()
previous_url = reverse(
if page_obj.has_previous(): #ZNY 如果有上一页
previous_number = page_obj.previous_page_number() #ZNY 获取上一页页码
previous_url = reverse( #ZNY 生成分类上一页URL
'blog:category_detail_page',
kwargs={
'page': previous_number,
'category_name': category.slug})
return {
'previous_url': previous_url,
'next_url': next_url,
'page_obj': page_obj
'previous_url': previous_url, #ZNY 上一页URL
'next_url': next_url, #ZNY 下一页URL
'page_obj': page_obj #ZNY 分页对象
}
@register.inclusion_tag('blog/tags/article_info.html')
def load_article_detail(article, isindex, user):
@register.inclusion_tag('blog/tags/article_info.html') #ZNY 注册包含标签，指定模板
def load_article_detail(article, isindex, user): #ZNY 加载文章详情标签
"""
加载文章详情
:param article:
:param isindex:是否列表页，若是列表页只显示摘要
:return:
"""
from djangoblog.utils import get_blog_setting
blogsetting = get_blog_setting()
from djangoblog.utils import get_blog_setting #ZNY 导入博客设置获取函数
blogsetting = get_blog_setting() #ZNY 获取博客设置
return {
'article': article,
'isindex': isindex,
'user': user,
'open_site_comment': blogsetting.open_site_comment,
'article': article, #ZNY 文章对象
'isindex': isindex, #ZNY 是否是列表页
'user': user, #ZNY 用户对象
'open_site_comment': blogsetting.open_site_comment, #ZNY 是否开启全站评论
}
# return only the URL of the gravatar
# TEMPLATE USE: {{ email|gravatar_url:150 }}
@register.filter
def gravatar_url(email, size=40):
@register.filter #ZNY 注册模板过滤器
def gravatar_url(email, size=40): #ZNY 获取Gravatar头像URL过滤器
"""获得gravatar头像"""
cachekey = 'gravatat/' + email
url = cache.get(cachekey)
if url:
return url
else:
usermodels = OAuthUser.objects.filter(email=email)
if usermodels:
o = list(filter(lambda x: x.picture is not None, usermodels))
if o:
return o[0].picture
email = email.encode('utf-8')
default = static('blog/img/avatar.png')
url = "https://www.gravatar.com/avatar/%s?%s" % (hashlib.md5(
email.lower()).hexdigest(), urllib.parse.urlencode({'d': default, 's': str(size)}))
cache.set(cachekey, url, 60 * 60 * 10)
logger.info('set gravatar cache.key:{key}'.format(key=cachekey))
return url
@register.filter
def gravatar(email, size=40):
cachekey = 'gravatat/' + email #ZNY 生成缓存键
url = cache.get(cachekey) #ZNY 尝试从缓存获取头像URL
if url: #ZNY 如果缓存存在
return url #ZNY 返回缓存URL
else: #ZNY 如果缓存不存在
usermodels = OAuthUser.objects.filter(email=email) #ZNY 查询OAuth用户
if usermodels: #ZNY 如果找到用户
o = list(filter(lambda x: x.picture is not None, usermodels)) #ZNY 过滤有头像的用户
if o: #ZNY 如果有头像的用户存在
return o[0].picture #ZNY 返回用户自定义头像
email = email.encode('utf-8') #ZNY 编码邮箱
default = static('blog/img/avatar.png') #ZNY 设置默认头像路径
url = "https://www.gravatar.com/avatar/%s?%s" % (hashlib.md5( #ZNY 生成Gravatar URL
email.lower()).hexdigest(), urllib.parse.urlencode({'d': default, 's': str(size)})) #ZNY 使用MD5哈希和URL参数
cache.set(cachekey, url, 60 * 60 * 10) #ZNY 将URL存入缓存，有效期10小时
logger.info('set gravatar cache.key:{key}'.format(key=cachekey)) #ZNY 记录缓存设置日志
return url #ZNY 返回头像URL
@register.filter #ZNY 注册模板过滤器
def gravatar(email, size=40): #ZNY 获取Gravatar头像HTML过滤器
"""获得gravatar头像"""
url = gravatar_url(email, size)
return mark_safe(
url = gravatar_url(email, size) #ZNY 获取头像URL
return mark_safe( #ZNY 返回安全的HTML图像标签
'<img src="%s" height="%d" width="%d">' %
(url, size, size))
@register.simple_tag
def query(qs, **kwargs):
@register.simple_tag #ZNY 注册简单模板标签
def query(qs, **kwargs): #ZNY 查询集过滤模板标签
""" template tag which allows queryset filtering. Usage:
{% query books author=author as mybooks %}
{% for book in mybooks %}
...
{% endfor %}
"""
return qs.filter(**kwargs)
return qs.filter(**kwargs) #ZNY 应用过滤条件并返回查询集
@register.filter
def addstr(arg1, arg2):
@register.filter #ZNY 注册模板过滤器
def addstr(arg1, arg2): #ZNY 字符串连接过滤器
"""concatenate arg1 & arg2"""
return str(arg1) + str(arg2)
return str(arg1) + str(arg2) #ZNY 将两个参数转换为字符串后连接
Write Preview
Loading…
Cancel
Save