def cms_top_article(request):
'''置顶和取消置顶
1. 如果文章已置顶则无需再置顶，未置顶则置顶。
2. 如果选择的是置顶（不置顶），而数据库中存的也是置顶（不置顶），
则不需操作，抛出异常
如果选择的是置顶，而数据库中存的是不置顶，则删除该字段
如果选择的是不置顶，而数据库中存的是置顶，则创建改字段
3. 修改TopModel之后也要更改ArticleModel的top字段
'''
form = TopArticleForm(request.POST)
if form.is_valid():
article_id = form.cleaned_data.get('article_id')
# 本文章选择的是置顶还是不置顶
is_top = form.cleaned_data.get('is_top')
article_model = ArticleModel.objects.filter(pk=article_id).first()
if article_model:
top_model = article_model.top
if is_top:
if top_model:
return myjson.json_params_error(message=u'该文章已经置顶！')
else:
top_model = TopModel()
top_model.save()
article_model.top = top_model
article_model.save(update_fields=['top'])
return myjson.json_result()
else:
if top_model:
top_model.delete()
return myjson.json_result()
else:
return myjson.json_params_error(message=u'该文章没有置顶！')
else:
message = form.errors
return myjson.json_params_error(message)
def top_article(request):
# method(GET,POST)
# 参数
# wiki
form = TopArticleForm(request.POST)
if form.is_valid():
uid = form.cleaned_data.get('uid')
articleModel = ArticleModel.objects.filter(pk=uid).first()
if articleModel:
if not articleModel.thumbnail:
return myjson.json_params_error(message=u'有缩略图的文章才能置顶')
topModel = articleModel.top
if not topModel:
topModel = TopModel()
# 如果存在,也save一下,这样就会更新operate_time了
topModel.save()
articleModel.top = topModel
articleModel.save(update_fields=['top'])
return myjson.json_result()
else:
return myjson.json_params_error(message=u'该文章不存在')
else:
return form.get_error_response()
def sms_captcha(request):
telephone = request.GET.get('telephone')
# 获取用户名，用于发送短信验证码显示用户名
if not telephone:
return myjson.json_params_error(message=u'必须指定手机号码！')
if cache.get(telephone):
return myjson.json_params_error(message=u'验证码已发送，请1分钟后重复发送！')
# if not username:
# return myjson.json_params_error(message=u'必须输入用户名！')
# 阿里大于APP_KEY及APP_SECRET
app_key = settings.APP_KEY
app_secret = settings.APP_SECRET
req = top.setDefaultAppInfo(app_key, app_secret)
req = toprequest.api.AlibabaAliqinFcSmsNumSendRequest()
req.extend = ""
req.sms_type = 'normal'
# 签名名称
req.sms_free_sign_name = settings.SIGN_NAME
# 随即生成字符串
captcha = Captcha.gene_text()
# 设置短信的模板
req.sms_param = "{code:%s}" % captcha
# req.sms_param = "{username:%s,code:%s}" % (username, captcha)
req.rec_num = telephone.decode('utf-8').encode('ascii')
req.sms_template_code = settings.TEMPLATE_CODE
try:
resp = req.getResponse()
cache.set(telephone, captcha, 120)
return myjson.json_result()
except Exception, e:
print e
return myjson.json_server_error()
def front_article_star(request):
'''点赞和取消点赞，同置顶
1. 如果文章已点赞则无需再点赞，未点赞则点赞。
2. 如果选择的是点赞（不点赞），而数据库中存的也是点赞（不点赞），
则不需操作，抛出异常
如果选择的是点赞，而数据库中存的是不点赞，则删除该字段
如果选择的是不点赞，而数据库中存的是点赞，则创建改字段
3. 修改TopModel之后也要更改ArticleModel的top字段
'''
form = ArticleStarForm(request.POST)
if form.is_valid():
article_id = form.cleaned_data.get('article_id')
# 本文章选择的是置顶还是不置顶
is_star = form.cleaned_data.get('is_star')
article_model = ArticleModel.objects.filter(pk=article_id).first()
star_model = ArticleStarModel.objects.filter(pk=article_id).first()
if article_model:
if is_star:
if star_model:
return myjson.json_params_error(message=u'该文章已经置顶！')
else:
star_model = ArticleStarModel()
star_model.author = request.user.username
star_model.article = article_model
star_model.save()
return myjson.json_result()
else:
if star_model:
star_model.delete()
return myjson.json_result()
else:
return myjson.json_params_error(message=u'该文章没有置顶！')
else:
return myjson.json_params_error(message=form.get_error())
def front_reset_email(request):
if request.method == 'GET':
return render(request, 'front_reset_email.html')
else:
# 如果邮箱在数据库存在，则无需修改
# 否则才允许修改新密码
form = ResetEmailForm(request.POST)
if form.is_valid():
email = form.cleaned_data.get('email', None)
user = request.user
if email:
if request.email == email:
return myjson.json_params_error(u'新邮箱与老邮箱一致，无需修改！')
else:
if send_mail(receivers=email):
user.email = email
user.save(update_fields=['email'])
return myjson.json_result(u'该邮箱验证成功！')
else:
return myjson.json_server_error()
else:
return myjson.json_params_error(message=u'必须输入邮箱！')
else:
return render(request, 'front_reset_email.html',
{'error': form.get_error()})
def front_delete_comment(request):
comment_id = request.GET.get('comment_id', None)
if comment_id:
comment_model = CommentModel.objects.filter(pk=comment_id).first()
if comment_model:
comment_model.is_removed = True
comment_model.save()
return myjson.json_result()
else:
return myjson.json_params_error(message=u'该评论不存在！')
else:
return myjson.json_params_error(u'没有该id！')
def front_delete_article(request):
article_id = request.GET.get('article_id', None)
if article_id:
article_model = ArticleModel.objects.filter(
article_id=article_id).first()
if article_model:
article_model.is_removed = True
article_model.save()
return redirect(reverse('article_list'))
else:
return myjson.json_params_error(u'该文章不存在！')
else:
return myjson.json_params_error(u'没有该id！')
def comment(request):
form = CommentForm(request.POST)
if form.is_valid():
content = form.cleaned_data.get('content')
articleId = form.cleaned_data.get('article_id')
articleModel = ArticleModel.objects.filter(pk=articleId).first()
if articleModel:
commentModel = CommentModel(content=content, article=articleModel, author=request.front_user)
commentModel.save()
return redirect(reverse('front_article_detail', kwargs={'article_id': articleId}))
else:
return myjson.json_params_error(message=u'没有这篇文章')
else:
return myjson.json_params_error(message=form.get_error())
def cms_edit_category(request):
form = EditCategoryForm(request.POST)
if form.is_valid():
category_id = form.cleaned_data.get('category_id')
category_name = form.cleaned_data.get('category_name')
category_model = CategoryModel.objects.filter(pk=category_id).first()
if category_model:
category_model.name = name
category_model.save(update_fields=['name'])
return myjson.json_result()
else:
return myjson.json_params_error(message=u'该分类不存在')
else:
message = form.errors
return myjson.json_params_error(message)
def add_category(request):
form = AddCategoryForm(request.POST)
if form.is_valid():
categoryname = form.cleaned_data.get('categoryname', None)
resultCategory = CategoryModel.objects.filter(name=categoryname).first()
if not resultCategory:
categoryModel = CategoryModel(name=categoryname)
categoryModel.save()
return myjson.json_result(data={'id': categoryModel.id, 'name': categoryModel.name})
else:
# return JsonResponse({'error':u'不能設置同名的分類!','code':403})
return myjson.json_params_error(message=u'不能設置同名的分類!')
else:
# return JsonResponse({'error':form.errors.as_json,'code':'403'});
return myjson.json_params_error(message=u'表单验证失败')
def untop_article(request):
form = TopArticleForm(request.POST)
if form.is_valid():
uid = form.cleaned_data.get('uid')
articleModel = ArticleModel.objects.filter(pk=uid).first()
if articleModel:
if articleModel.top:
topModel = articleModel.top
topModel.delete()
return myjson.json_result()
else:
return myjson.json_params_error(message=u'本文章还未置顶呢')
else:
return myjson.json_params_error(message=u'该文章不存在')
else:
return form.get_error_response()
def cms_reset_pwd(request):
if request.method == 'GET':
return render(request, 'cms_reset_pwd.html')
else:
username = request.user
## 使用cleaned_password方法
# form = ResetpwdForm(request.POST,username=username)
# return render(request,'cms_reset_pwd.html',{'error':form.errors})
# 使用save_password方法
form = ResetpwdForm(request.POST, user=username)
if form.is_vaild():
oldpwd = form.cleaned_data.get('oldpwd')
user = authenticate(username=username, password=oldpwd)
if user:
is_vaild = form.save_password()
if is_vaild:
return myjson.json_result()
else:
return myjson.json_params_error(message=u'密码验证错误！')
else:
user = user.create(username=username, password=newpwd)
return myjson.json_result()
else:
return render(request, 'cms_reset_pwd.html',
{'error': form.get_error()})
def update_profile(request):
# 1.更新头像
# 2.更新用户名
form = UpdateFrontProfileForm(request.POST)
if form.is_valid():
front_username = form.cleaned_data.get('front_username', None)
portrait = form.cleaned_data.get('portrait', None)
email = form.cleaned_data.get('email')
print email
user = FrontUserModel.objects.filter(email=email).first()
if user:
user.username = front_username
user.portrait = portrait
user.save()
# # 获取FrontUserModel中所有用户信息
# users = FrontUserModel.objects.all()
# user = users.filter(email="*****@*****.**").first()
# frontUser = FrontUser.objects.filter(user__pk=user.pk).first()
# 如果FrontUser表中已存在数据与user对应 直接更新
# if frontUser:
# frontUser.portrait = portrait
# 否则，先新建一个frontuser模型 再保存
# else:
# frontUser = FrontUser(portrait=portrait,user=user)
# frontUser.save()
# return JsonResponse({'code':200})
return myjson.json_result()
else:
print '------------------------fial'
# return JsonResponse({'error':form.errors})
return myjson.json_params_error(message=u'表单验证错误！')
def cms_add_tag(request):
'''如果tag已经存在，则不允许在添加，否则添加
'''
form = AddTagForm(request.POST)
if form.is_valid():
tag_name = form.cleaned_data.get('tag_name')
tag_model = TagModel.objects.filter(name=tag_name).first()
if tag_model:
return myjson.json_params_error(u'该标签已存在，请重新设置！')
else:
tagModel = TagModel(name=tag_name)
tagModel.save()
return myjson.json_result()
else:
message = form.errors
return myjson.json_params_error(message)
def front_article_detail(request, article_id):
'''我们需要获取的有：
1. 文章(ArticleModel)
2. 标签(TagModel)
3. 分类(CategoryModel)
4. 评论(CommentModel)
5. 点赞(ArticleStarModel)
另外，阅读量访问一次+1，还需获取当前的分类
'''
article_model = ArticleModel.objects.filter(pk=article_id,
is_removed=False)
if article_model:
# 每次访问阅读量都+1
article_model.read_count += 1
article_model.save()
# 获取所有给这篇文章点赞的作者
star_author_ids = [
star_model.author.id for star_model in article_model.stars
]
context = {
'articles': article_model,
'comments': article_model.commentmodel_set.all(),
'tags': TagModel.objects.all(),
'categorys': CategoryModel.objects.all(),
# 当前文章分类
'c_category': article_model.category,
# 当前文章分类
'c_tag': article_model.tags,
'star_author_ids': star_author_ids
}
return render(request, 'front_article_detail.html', context=context)
else:
return myjson.json_params_error(u'该文章不存在！')
def front_reset_pwd(request):
if request.method == 'GET':
return render(request, 'front_reset_pwd.html')
else:
username = request.user
form = ResetpwdForm(request.POST, user=username)
if form.is_vaild():
oldpwd = form.cleaned_data.get('oldpwd')
newpwd = form.cleaned_data.get('newpwd')
user = FrontUserModel.objects.filter(username=username,
password=oldpwd).first()
if user:
is_vaild = user.check_password()
if is_vaild:
user.set_password(newpwd)
user.save()
return myjson.json_result()
else:
return myjson.json_params_error(message=u'密码验证错误！')
else:
user = user.create(username=username, password=newpwd)
return myjson.json_result()
else:
return render(request, 'front_reset_pwd.html',
{'error': form.get_error()})
def cms_add_category(request):
'''如果tag已经存在，则不允许在添加，否则添加
'''
form = AddCategoryForm(request.POST)
if form.is_valid():
category_name = form.cleaned_data.get('category_name')
category_model = CategoryModel.objects.filter(
name=category_name).first()
if category_model:
return myjson.json_params_error(u'该分类已存在，请重新设置！')
else:
categoryModel = categoryModel(name=category_name)
categoryModel.save()
return myjson.json_result()
else:
message = form.errors
return myjson.json_params_error(message)
def cms_remove_comment(request):
comment_id = request.POST.get('comment_id', 1)
if not comment_id:
return myjson.json_params_error()
comment_model = CommentModel.objects.filter(comment_id).first()
if comment_model:
comment_model.is_removed = True
comment_model.save()
return myjson.json_result()
def front_edit_article(request):
'''
它的逻辑和add_article相似，但作者不会变，只需获取文章的id
我们会用到一篇已存在的article里的的所有数据，包括tags
但文章里的tags会通过article.tags多对多的方式获取，而不再从tagmodel获取
因为可能会修改tags，我们仍需要传入所有的tags
因此我们需要将tags添加到article里，而为了方便使用，也为了添加tags
我们会使用到model_to_dict这个函数，将数据库里的数据提取出来并转化成dict类型
'''
if request.method == 'GET':
article_id = request.GET.get('article_id', None)
if article_id:
article_model = ArticleModel.objects.filter(pk=article_id).first()
article_dict = model_to_dict(article_model)
tag_model = article_model.tags.all()
article_dict['tags'] = [tag_model.id for tags in tag_model]
context = {
'categorys': CategoryModel.objects.all(),
'tags': TagModel.objects.all(),
'article': article_dict
}
return render(request, 'front_add_article.html', context=context)
else:
return myjson.json_params_error(u'没有该id！')
else:
form = EditArticleForm(request.POST)
if form.is_valid():
tag_ids = request.POST.getlist('tags[]')
article_id = form.cleaned_data.get('article_id')
title = form.cleaned_data.get('title')
thumbnail = form.cleaned_data.get('thumbnail')
content = form.cleaned_data.get('content')
category_id = form.cleaned_data.get('category')
article_model = ArticleModel.objects.filter(pk=article_id).first()
category = CategoryModel.objects.filter(pk=category_id).first()
# 修改和创建的方式不一样
if article_model:
article_model.title = title
article_model.thumbnail = thumbnail
article_model.content = content
article_model.category = category
article_model.save()
# 文章与标签的多对多的保存
# 如果选择了标签，则将选择的标签以此存入，否则不用存
if tag_ids:
for tag_id in tag_ids:
tag_model = TagModel.objects.filter(pk=tag_id).first()
if tag_model:
article_model.tags.add(tag_model)
return myjson.json_result()
else:
return render(request, 'front_edit_article.html',
{'error': form.get_error()})
def delete_category(request):
form = CategoryForm(request.POST)
if form.is_valid():
categoryId = form.cleaned_data.get('category_id')
categoryModel = CategoryModel.objects.filter(pk=categoryId).first()
if categoryModel:
# 首先拿到该分类下的文章数量
articleCount = categoryModel.articlemodel_set.all().count()
# 如果文章数量大于0,就不让删除
if articleCount > 0:
return myjson.json_params_error(message=u'该分类下还存在文章,不能删除!')
else:
categoryModel.delete()
return myjson.json_result()
else:
return myjson.json_params_error(message=u'该分类不存在')
else:
return form.get_error_response()
def article_detail(request, article_id=''):
articleId = article_id
if articleId:
articleModel = ArticleModel.objects.filter(pk=articleId).first()
if articleModel:
comments = articleModel.commentmodel_set.all()
context = {
'article': articleModel,
'categorys': CategoryModel.objects.all(),
'c_category': articleModel.category,
'tags': articleModel.tags.all(),
'comments': comments
}
return render(request, 'front_article_detail.html', context)
else:
myjson.json_params_error(message=u"该文章不存在")
else:
myjson.json_params_error(message=u'文章id不能为空')
def add_tag(requset):
form = AddTagForm(requset.POST)
if form.is_valid():
tagname = form.cleaned_data.get('tagname', None)
resultTag = TagModel.objects.filter(name=tagname).first()
if not resultTag:
tagModel = TagModel(name=tagname)
tagModel.save()
# return JsonResponse(data={'id':tagModel.id,'name':tagModel.name,'code':200})
return myjson.json_result(data={
'id': tagModel.id,
'name': tagModel.name
})
else:
# return JsonResponse({'error':u'该标签已存在！','code':400})
return myjson.json_params_error(message=u'该标签已存在！')
else:
# return JsonResponse({'error':form.errors.as_json,'code':'403'})
return myjson.json_params_error(message=u'表单验证错误！')
def delete_category(request):
form = CategoryForm(request.POST)
if form.is_valid():
categoryId = form.cleaned_data.get('category_id')
categoryModel = CategoryModel.objects.filter(pk=categoryId).first()
if categoryModel:
# 首先获取该分类下文章数量
articleCount = categoryModel.articlemodel_set.all().count()
# 若该分类存在文章 禁止删除操作
if articleCount > 0:
return myjson.json_params_error(
message=u'无法删除该分类,请删除分类下文章后再尝试')
else:
categoryModel.delete()
return myjson.json_result()
else:
return myjson.json_params_error(message=u'不存在该分类！')
else:
return form.get_error_response()
def front_reply_comment(request):
'''回复评论需要：文章id，被回复的评论id（即原始评论），回复内容
'''
if request.method == 'GET':
article_id = request.GET.get('article_id', None)
comment_id = request.GET.get('comment_id', None)
if article_id:
article_model = ArticleModel.objects.filter(pk=article_id).first()
if article_model:
context = {'articles': article_model}
if comment_id:
# 原始评论
origin_comment = CommentModel.objects.filter(
pk=comment_id).first()
if origin_comment:
context['origin_comment'] = origin_comment
return render(request, 'front_add_article.html', context)
else:
form = ReplyCommentForm(request.POST)
if form.is_valid():
article_id = form.cleaned_data.get('article_id', None)
comment_id = form.cleaned_data.get('comment_id', None)
content = form.cleaned_data.get('content', None)
if article_id:
article_model = ArticleModel.objects.filter(article_id).first()
if content:
comment_model = CommentModel(content=content)
comment_model.article = article_model
comment_model.author = request.user.username
if comment_id:
origin_comment = CommentModel.objects.filter(
pk=comment_id).first()
comment_model.origin_comment = origin_comment
comment_model.save()
return myjson.json_result()
else:
return myjson.json_params_error(u'没有评论内容！')
else:
return myjson.json_params_error(u'没有该评论！')
else:
return myjson.json_params_error(message=form.errors)
def delete_blog(request):
form = DeleteArticleForm(request.POST)
if form.is_valid():
uid = form.cleaned_data.get('uid')
articleModel = ArticleModel.objects.filter(pk=uid).first()
if articleModel:
articleModel.delete()
return myjson.json_result()
else:
return myjson.json_params_error(message=u'该文章不存在！')
else:
return form.get_error_response()
def cms_delete_article(request):
form = DeleteArticleForm(request.POST)
if form.is_valid():
article_id = form.cleaned_data.get('article_id')
article_model = ArticleModel.objects.filter(pk=article_id).first()
if article_model:
article_model.delete()
return myjson.json_result()
else:
return myjson.json_params_error(message=u'该文章不存在或已被删除')
else:
# return myjson.json_params_error(message=form.errors)
return redirect(reverse('article_list'))
def add_category(request):
form = AddCategoryForm(request.POST)
if form.is_valid():
print '-------------------sucece'
categoryname = form.cleaned_data.get('categoryname', None)
resultCategory = CategoryModel.objects.filter(
name=categoryname).first()
if not resultCategory:
categoryModel = CategoryModel(name=categoryname)
categoryModel.save()
# return JsonResponse(data={'id':categoryModel.id,'name':categoryModel.name,'code':200})
return myjson.json_result(data={
'id': categoryModel.id,
'name': categoryModel.name
})
else:
# return JsonResponse({'error':u'该分类已存在！','code':400})
return myjson.json_params_error(message=u'该分类已存在！')
else:
print '---------------------error'
# return JsonResponse({'error':form.errors.as_json,'code':'400'})
return myjson.json_params_error(message=u'表单验证错误！')
def cms_remove_category(request):
'''
1.如果该分类不存在不能移除，
2.如果分类下有文章则不允许移除，
因此我们要获取该分类下的所有文章，如果文章数小于0则不允许删除
'''
form = CategoryForm(request.POST)
if form.is_valid():
category_id = form.cleaned_data.get('category_id')
category_model = CategoryModel.objects.filter(pk=category_id).first()
if category_model:
article_count = category_model.articlemodel_set.all().count()
if article_count > 0:
return myjson.json_params_error(message=u'该分类下还有文章,不能删除!')
else:
category_model.delete()
return myjson.json_result()
else:
return myjson.json_params_error(message=u'该分类不存在！')
else:
message = form.errors
return myjson.json_params_error(message)
def cms_remove_tag(request):
'''
1.如果该标签不存在不能移除，
2.如果标签下有文章则不允许移除，
因此我们要获取该标签下的所有文章，如果文章数小于0则不允许删除
'''
form = TagForm(request.POST)
if form.is_valid():
tag_id = form.cleaned_data.get('tag_id')
tag_model = TagModel.objects.filter(pk=tag_id).first()
if tag_model:
article_count = tag_model.articlemodel_set.all().count()
if article_count > 0:
return myjson.json_params_error(message=u'该标签下还有文章,不能删除!')
else:
tag_model.delete()
return myjson.json_result()
else:
return myjson.json_params_error(message=u'该标签不存在！')
else:
message = form.errors
return myjson.json_params_error(message)
def front_search(request):
q = request.GET.GET('query')
if q:
# 查询条件忽略大小写
article_model = ArticleModel.objects.filter(
Q(title__icontains=q) | Q(content__icontains=q))
context = {
'articles': article_model,
'categorys': CategoryModel.objects.all()
}
# return myjson.json_result()
return render(request, 'front_search.html', context=context)
else:
return myjson.json_params_error(message=u'请输入查询字符串')
